# Aislamiento por petición El servidor FastCGI atiende muchas peticiones en un mismo proceso. En Devkron 1.x parte del estado de una petición se quedaba en el proceso y lo veían las siguientes: rutas de `#path`, el modo de `errordet()`, objetos abiertos y el contexto de la primera petición. En 2.0 **cada ejecución tiene su propio ámbito**. Esta página explica qué quedó aislado, qué se conservó igual que en 1.x y qué revisar en su código. ## Qué quedó aislado | Tema | 1.x | 2.0 | |---|---|---| | `#path` agregado por una petición | lo veían las siguientes peticiones del proceso, de cualquier sitio | solo dura esa ejecución | | `errordet()` | global del proceso: una petición lo cambiaba para todas | por ejecución | | objetos que quedan vivos al terminar (conexiones a bases de datos, archivos abiertos, *streams*) | se quedaban abiertos hasta que el recolector de memoria los liberara | se llama `Dispose` al terminar cada ejecución o petición (no al `@http_context`) | | contexto de la primera petición | el proceso lo retenía completo (con su `@http_context`, objetos y conexiones) | no se retiene | | funciones declaradas dentro de otra función, en un programa de **consola** | fallaban desde la segunda ejecución del proceso (`runscript` repetido, `-repeat`) | funcionan en todas | Aplica igual a cada `dkl` de consola, a cada petición FastCGI y a cada ejecución que lanzan las bibliotecas de hilos. ### Ejemplo: `#path` ya no se hereda Dos páginas del mismo sitio; la primera agrega una carpeta de bibliotecas con `#path`, la segunda no: ```dkl #include "dkli.dkh" #! program "con-path" { #include "functions.dkh" #path "/opt/miapp/lib" #include "util.dkh" @http_context<"response/output">: "text" @http_context<"response/text">: util.saluda("Ana") } ``` ```dkl #include "dkli.dkh" #! program "sin-path" { #include "functions.dkh" #include "util.dkh" @http_context<"response/output">: "text" @http_context<"response/text">: util.saluda("Luis") } ``` En 2.0, `sin-path.dkl` falla **siempre** con `No se puede encontrar el archivo util.dkh`, aunque antes se haya pedido `con-path.dkl`. En 1.x funcionaba o fallaba según qué página se hubiera pedido antes en ese proceso, lo que producía errores imposibles de reproducir. Si una página necesita una carpeta de bibliotecas, declare su propio `#path`. ### Ejemplo: objetos que se cierran solos ```dkl #include "dkli.dkh" #! program "archivo-abierto" { #include "functions.dkh" do _map_function(-1, "System.IO.StreamWriter", "Write", "sw.write", "System.String", "void") ref sw = _new("System.IO.StreamWriter", "/tmp/salida.txt") do _invoke(sw, "sw.write", "hola") @http_context<"response/output">: "text" @http_context<"response/text">: "escrito sin cerrar" } ``` Al terminar la petición, Devkron 2.0 cierra el `StreamWriter`: el archivo queda escrito con `hola`. En 1.x quedaba abierto (y vacío) hasta que el recolector de memoria decidiera liberarlo. Esta liberación es una red de seguridad, no un sustituto de cerrar. Lo que un programa deja abierto se libera **a más tardar** al terminar la ejecución (la petición o el programa de consola). Lo que deja un `runscript` o `runcode` al terminar: desde 2.0.5.0, lo que nadie más usa lo recoge el recolector de memoria, como en 1.x (el *pool* de MySQL recupera las conexiones que el `runscript` no cerró), y lo que dejó guardado en un objeto del programa que lo llamó se libera al terminar la ejecución principal. Hasta 2.0.4, en un proceso largo —un orquestador que lanza muchos `runscript`, un servicio con un ciclo `while` que no termina— todo lo de cada `runscript` seguía retenido hasta el final, ocupando memoria o un lugar en el *pool* de conexiones. Aun así, cierre siempre lo que abre (`dbr.close(db)`), también en el bloque `exception`: el recolector no tiene prisa, y un archivo abandonado pierde lo que no se escribió. ## Lo que se conservó igual que en 1.x **Funciones declaradas dentro de otra función, en páginas web.** El controlador estándar ejecuta cada página con `runscript`, y las funciones **anidadas** (declaradas dentro de otra función) de un `runscript` o `runcode` se registran en el programa **que lo llama** (el controlador), no en la página, en el momento en que se ejecuta la función que las contiene (las de nivel superior de la página no pasan al programa que la llama). Por eso una función anidada no se encuentra al llamarla desde la función que la contiene, **desde la primera petición**: ```dkl #include "dkli.dkh" #! program "anidada" { #include "functions.dkh" total::a, b { doble::x { return x * 2 } return doble(a) + doble(b) } r = total(2, 3) @http_context<"response/output">: "text" @http_context<"response/text">: "Total: " + str(r) } ``` Detrás del servidor FastCGI esta página responde 500 con: ```text {1} Error al invocar runscript. ({1} Error en expresión: Función: doble no reconocida o no registrada [anidada.dkl][Ln= 12]) [http.dkl][Ln= 390] ``` El mismo programa en consola, sin `runscript`, sí funciona. La solución es declarar las funciones **al mismo nivel**, no una dentro de otra: ```dkl #include "dkli.dkh" #! program "plana" { #include "functions.dkh" doble::x { return x * 2 } total::a, b { return doble(a) + doble(b) } r = total(2, 3) @http_context<"response/output">: "text" @http_context<"response/text">: "Total: " + str(r) } ``` ```text Total: 10 ``` Se conservó así porque corregirlo cambia la salida de programas existentes. **Otras peculiaridades conservadas:** el entorno del proceso se copia a `@http_context<"request/headers/…">` (no ponga en el entorno del servicio valores que no deban ver todos los programas); `@http_context` es idéntico llave por llave al de 1.x. ## Qué revisar al migrar - Páginas que funcionaban "porque otra página ya había puesto el `#path`": agrégueles su propio `#path` o copie la biblioteca a la carpeta del programa o junto a `dkl`. - Programas que llaman `errordet(@true)` o `errordet(@false)` esperando cambiar el comportamiento de todo el servidor: en 2.0 solo cambian su propia ejecución. El valor para todas las páginas se fija en `fastcgi/http.dkl` ([Errores HTTP 500](/es/devkron/2.0/migracion/errores-http.md)). - Código que dejaba un objeto abierto a propósito para reutilizarlo en la siguiente petición: ya no sobrevive. Para compartir datos entre peticiones use la caché del proceso de `threads.dkh` ([Bibliotecas estándar](/es/devkron/2.0/bibliotecas/estandar/)) o la base de datos. - Funciones anidadas en páginas web: declárelas al mismo nivel. - Procesos largos (orquestadores con muchos `runscript`, servicios con un ciclo que no termina): cierre en cada programa lo que abre, también en su `exception`; no cuente con la liberación al terminar la ejecución.