@rlabs-cl/arketum 0.0.0-stage → 1.0.0

package/catalogo-de-ejemplo/formas/monorepo-de-aplicaciones.yaml

@@ -0,0 +1,207 @@
+# Forma de sistema: dos o tres aplicaciones que se despliegan por separado, en
+# un mismo repositorio, con frontera.
+#
+# Cambios:
+# - 1.2.0: los papeles de la fase 2 (`implementador` y `revisor`) en las
+#   dos variantes. Sin salidas: el suelo y el e2e de varios despliegues
+#   levantan el sistema entero, y eso no cabe en las salidas de un artefacto.
+# - 1.1.0: señales `actores`, `consumidores` y `volumen`; variantes (`simple` y
+#   `completa`, con los componentes `duena` y `consumidora`) y los escalones
+#   `varios-actores`, `consumido-por-sistemas`, `mucho-volumen` e
+#   `integraciones`. Un artefacto con capas declara `stack` y `componente`.
+name: monorepo-de-aplicaciones
+version: 1.2.0
+description: >-
+  Dos o tres aplicaciones que se despliegan por separado en un mismo repositorio, con frontera: la que mantiene el dato principal es su dueña y las demás lo leen por su API.
+orden: 3
+senales:
+  despliegues: numero
+  integraciones: numero
+  actores: numero
+  consumidores: texto
+  volumen: numero
+aplica:
+  - [despliegues, '>=', 2]
+  - [despliegues, '<=', 3]
+  - [integraciones, '<=', 3]
+diseno:
+  - Son dos aplicaciones que se despliegan por separado; la que mantiene el dato principal es su dueña.
+  - La dueña del dato es la única que lo escribe; las demás (y cualquier otro sistema) solo lo leen, y solo a través de su API.
+  - Cada aplicación que no es dueña tiene que poder cambiarse o sustituirse sin tocar a la dueña.
+  - Lo que cada aplicación guarda por su cuenta es suyo y está separado del dato principal.
+  - El dato principal y lo que guarda cada aplicación sobreviven a reinicios; los datos de partida se cargan una vez desde lo que se usa hoy.
+huecos:
+  - Cuáles son las aplicaciones (lo que usa cada tipo de persona o sistema) y si cada una tiene que poder cambiarse o sustituirse sin tocar la otra.
+  - De quién es cada dato (quién lo escribe y lo corrige) y quién solo lo lee.
+  - Qué otros sistemas usan alguna de las aplicaciones, qué pueden hacer con ellas y qué no.
+  - Qué guarda cada aplicación por su cuenta, además del dato principal.
+  - De dónde salen los datos de hoy, cuántos son, cómo se pasan al sistema y qué tiene que sobrevivir a un reinicio.
+  - Cuándo tiene que verse en una aplicación un cambio hecho en la otra.
+
+variantes:
+  - nombre: simple
+    aplica:
+      - [despliegues, '<=', 2]
+      - [actores, '<=', 1]
+    papeles: &papeles
+      - nombre: implementador
+        para_que: construye el sistema en el paso de sistema (el código, sus pruebas y las salidas que exige el paso de evidencia)
+        texto: >-
+          PAPEL: IMPLEMENTADOR (fase 2). Construyes lo acordado, nada más: los requisitos que trae la unidad y los técnicos vigentes, con el oficio del arquetipo.
+          Desciendes cada artefacto tocado nivel a nivel y el código se queda como lo pide su stack; no lo deformas para encajar.
+          Cada funcional que construyes lleva su prueba de extremo a extremo, que arranca el artefacto por su contrato de arranque y lo usa como una persona:
+          una prueba que llama por dentro a una función que el camino real no usa no demuestra nada.
+          Copias las fijaciones del catálogo tal cual y no las editas. Corres tú las pruebas, el suelo y la suite e2e entera, y vinculas cada ejecución
+          a sus requisitos con `satisfies`. No rebajas ni borras una prueba para que pase. Si algo que funcionaba se rompe, lo arreglas;
+          si no puedes, lo reportas con `solicitar` (`pide: defecto`) y decide la persona. Nunca lo escondes.
+      - nombre: revisor
+        para_que: revisa en el paso de evidencia que lo construido funciona por el camino real, antes de entregar la evidencia
+        texto: >-
+          PAPEL: REVISOR (fase 2). No escribes el código: lo revisas como lo usaría la persona. Compruebas que cada funcional construido tiene su prueba e2e,
+          que arranca el artefacto por su contrato de arranque y no lo llama por dentro, y que pasa; que las fijaciones del catálogo no se tocaron;
+          y miras las pruebas modificadas o borradas desde la foto (las lista el resumen del paso): si alguna se rebajó para que pase, lo dices.
+          Corres el suelo y la suite e2e entera con el comando compuesto exacto y entregas esa evidencia. Lo que falla no lo das por bueno:
+          se arregla, o se reporta como defecto con `solicitar` y decide la persona. Si un funcional no admite una prueba automática
+          (un correo, algo visual, una integración externa), lo pides con `solicitar` (`pide: sin_e2e`), con el motivo.
+    componentes:
+      - nombre: duena
+        description: >-
+          La aplicación dueña del dato principal, en tres peldaños: lo que se pide, sus piezas y el código. Es la única que lo escribe, y lo ofrece por su API.
+        kinds:
+          - { name: objetivo, describes: "pieza de la solicitud (L0), sin ubicación en el árbol", ubicado: false }
+          - { name: modulo, describes: la definición del paquete o del módulo, ubicado: true }
+          - { name: dominio, describes: "las entidades del dato principal y sus reglas, puras", ubicado: true }
+          - { name: almacen, describes: guardar y cargar el dato principal, ubicado: true }
+          - { name: servicio, describes: "un caso de uso por acción, sobre el dominio y el almacén, sin HTTP", ubicado: true }
+          - { name: api, describes: "la API con que las demás leen el dato; solo traduce peticiones a servicios", ubicado: true }
+          - { name: arranque, describes: el punto de entrada de la aplicación, ubicado: true }
+          - { name: prueba, describes: fichero de prueba, ubicado: true }
+        coRequirements:
+          - { when: servicio, requires: [prueba] }
+        levels: &niveles-simples
+          - id: L0
+            requiredRoles: []
+            title: SOLICITUD
+            instruction: Declara qué tiene que hacer esta aplicación, para quién, y qué datos son suyos.
+          - id: L1
+            requiredRoles: []
+            title: PIEZAS
+            instruction: Propón sus piezas, con la frontera con la otra aplicación a la vista.
+            fanout: { min: 3, max: 16 }
+          - id: L2
+            requiredRoles: []
+            title: IMPLEMENTACIÓN
+            instruction: Escribe el código; lo que habla con la otra aplicación lo hace solo por su API.
+            fanout: { min: 1, max: 60 }
+      - nombre: consumidora
+        description: >-
+          Una aplicación que lee el dato principal por la API de la dueña, en tres peldaños. Se puede cambiar o sustituir sin tocar a la dueña.
+        kinds:
+          - { name: objetivo, describes: "pieza de la solicitud (L0), sin ubicación en el árbol", ubicado: false }
+          - { name: modulo, describes: la definición del paquete o del módulo, ubicado: true }
+          - { name: cliente, describes: el único sitio que llama a la API de la dueña, ubicado: true }
+          - { name: dominio, describes: "lo que la aplicación hace con lo que lee, puro", ubicado: true }
+          - { name: almacen, describes: "lo que guarda por su cuenta, separado del dato principal", ubicado: true }
+          - { name: interfaz, describes: lo que ve quien la usa, ubicado: true }
+          - { name: arranque, describes: el punto de entrada de la aplicación, ubicado: true }
+          - { name: prueba, describes: fichero de prueba, ubicado: true }
+        coRequirements:
+          - { when: cliente, requires: [prueba] }
+        levels: *niveles-simples
+  - nombre: completa
+    aplica: []
+    papeles: *papeles
+    componentes:
+      - nombre: duena
+        description: >-
+          La aplicación dueña del dato principal, en cinco peldaños: lo que se pide, sus piezas, sus contratos, el cableado y el código.
+        kinds:
+          - { name: objetivo, describes: "pieza de la solicitud (L0), sin ubicación en el árbol", ubicado: false }
+          - { name: modulo, describes: la definición del paquete o del módulo, ubicado: true }
+          - { name: dominio, describes: "las entidades del dato principal y sus reglas, puras", ubicado: true }
+          - { name: almacen, describes: guardar y cargar el dato principal, ubicado: true }
+          - { name: servicio, describes: "un caso de uso por acción, sobre el dominio y el almacén, sin HTTP", ubicado: true }
+          - { name: api, describes: "la API con que las demás leen el dato; solo traduce peticiones a servicios", ubicado: true }
+          - { name: arranque, describes: el punto de entrada de la aplicación, ubicado: true }
+          - { name: prueba, describes: fichero de prueba, ubicado: true }
+          - { name: dependencia, describes: "arista del cableado (L3) entre dos piezas declaradas", ubicado: false }
+        coRequirements:
+          - { when: servicio, requires: [prueba] }
+          - { when: almacen, requires: [prueba] }
+        levels: &niveles-completos
+          - id: L0
+            requiredRoles: []
+            title: SOLICITUD
+            instruction: Declara qué tiene que hacer esta aplicación, para quién, y qué datos son suyos.
+          - id: L1
+            requiredRoles: []
+            title: PIEZAS
+            instruction: Propón sus piezas, con la frontera con la otra aplicación a la vista.
+            fanout: { min: 3, max: 20 }
+          - id: L2
+            requiredRoles: []
+            title: CONTRATOS
+            instruction: Declara cada operación de la API (o cada llamada a ella) con lo que recibe, lo que devuelve y sus errores.
+            fanout: { min: 1, max: 40 }
+          - id: L3
+            requiredRoles: []
+            title: CABLEADO
+            instruction: Declara qué depende de qué; nada de una aplicación importa la otra.
+            fanout: { min: 1, max: 50 }
+          - id: L4
+            requiredRoles: []
+            title: IMPLEMENTACIÓN
+            instruction: Escribe el código; lo que habla con la otra aplicación lo hace solo por su API.
+            fanout: { min: 1, max: 90 }
+      - nombre: consumidora
+        description: >-
+          Una aplicación que lee el dato principal por la API de la dueña, en cinco peldaños. Se puede cambiar o sustituir sin tocar a la dueña.
+        kinds:
+          - { name: objetivo, describes: "pieza de la solicitud (L0), sin ubicación en el árbol", ubicado: false }
+          - { name: modulo, describes: la definición del paquete o del módulo, ubicado: true }
+          - { name: cliente, describes: el único sitio que llama a la API de la dueña, ubicado: true }
+          - { name: dominio, describes: "lo que la aplicación hace con lo que lee, puro", ubicado: true }
+          - { name: almacen, describes: "lo que guarda por su cuenta, separado del dato principal", ubicado: true }
+          - { name: interfaz, describes: lo que ve quien la usa, ubicado: true }
+          - { name: arranque, describes: el punto de entrada de la aplicación, ubicado: true }
+          - { name: prueba, describes: fichero de prueba, ubicado: true }
+          - { name: dependencia, describes: "arista del cableado (L3) entre dos piezas declaradas", ubicado: false }
+        coRequirements:
+          - { when: cliente, requires: [prueba] }
+        levels: *niveles-completos
+
+escalones:
+  - nombre: varios-actores
+    cuando:
+      - [actores, '>=', 2]
+    diseno:
+      - Cada actor tiene su vía; mantener el dato se hace del lado de la aplicación dueña, y la que usa el público nunca escribe en él.
+    huecos:
+      - Quién mantiene el dato principal y desde dónde.
+    oficio:
+      - Mantener el dato principal se hace del lado de la dueña; la consumidora nunca escribe en él.
+  - nombre: consumido-por-sistemas
+    cuando:
+      - [consumidores, 'en', [sistemas, ambos]]
+    diseno:
+      - La API de la aplicación dueña es un contrato estable para otros sistemas.
+    huecos:
+      - Qué otros sistemas usan la API, qué pueden hacer con ella y cómo se enteran de un cambio.
+    oficio:
+      - La API es un contrato - respuestas estables, errores con código y mensaje, y cada ruta descrita con un ejemplo.
+    coRequirements:
+      - { when: api, requires: [prueba], componentes: [duena] }
+  - nombre: mucho-volumen
+    cuando:
+      - [volumen, '>=', 1000]
+    oficio:
+      - Con miles de registros nada recorre ni descarga el dato entero en cada petición; los listados se paginan.
+  - nombre: integraciones
+    cuando:
+      - [integraciones, '>=', 1]
+    diseno:
+      - Cada sistema ajeno se usa a través de un solo sitio, que se puede sustituir por un doble para probar.
+    oficio:
+      - Cada llamada a otro sistema tiene un doble para probar sin el sistema real, que cubre el fallo y la demora.
+    coRequirements:
+      - { when: servicio, requires: [prueba] }

package/catalogo-de-ejemplo/incluido.yaml

@@ -0,0 +1,3 @@
+# El marcador del catálogo que trae Arketum (ds-f06): lo reconoce por sí mismo, se llame como se llame el
+# paquete donde está instalado. No es política: el lector de catálogos no lo lee.
+nombre: ejemplo

package/catalogo-de-ejemplo/stacks/go/e2e-terminal/e2e_http.py

@@ -0,0 +1,36 @@
+"""Peticiones HTTP para las pruebas de extremo a extremo (fijación del catálogo de Arketum: no se edita). Solo la biblioteca estándar."""
+import json, urllib.error, urllib.parse, urllib.request
+
+
+def _hacer(req, timeout=15):
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:
+            return r.status, r.read().decode('utf8', 'replace')
+    except urllib.error.HTTPError as e:
+        return e.code, e.read().decode('utf8', 'replace')
+
+
+def get(url, **params):
+    if params:
+        url += ('&' if '?' in url else '?') + urllib.parse.urlencode(params)
+    return _hacer(url)
+
+
+def get_json(url, **params):
+    st, t = get(url, **params)
+    try:
+        return st, json.loads(t)
+    except ValueError:
+        return st, t
+
+
+def post_json(url, datos, metodo='POST'):
+    st, t = _hacer(urllib.request.Request(url, data=json.dumps(datos).encode(), method=metodo, headers={'Content-Type': 'application/json'}))
+    try:
+        return st, json.loads(t)
+    except ValueError:
+        return st, t
+
+
+def post_form(url, datos):
+    return _hacer(urllib.request.Request(url, data=urllib.parse.urlencode(datos).encode(), headers={'Content-Type': 'application/x-www-form-urlencoded'}))

package/catalogo-de-ejemplo/stacks/go/e2e-terminal/pytest.ini

@@ -0,0 +1,5 @@
+# Fijación del catálogo de Arketum: no se edita. La suite e2e se corre desde la
+# raíz del artefacto con:
+#   PYTHONPATH=arketum/fijaciones/e2e python3 -m pytest -q -c arketum/fijaciones/e2e/pytest.ini --rootdir=. tests/e2e
+[pytest]
+addopts = -p terminal_e2e -p no:cacheprovider --confcutdir=.

package/catalogo-de-ejemplo/stacks/go/e2e-terminal/requirements.txt

@@ -0,0 +1,2 @@
+pyte
+pytest

package/catalogo-de-ejemplo/stacks/go/e2e-terminal/terminal_e2e.py

@@ -0,0 +1,112 @@
+"""
+AYUDA E2E (fijación del catálogo de Arketum: se copia tal cual en
+`arketum/fijaciones/e2e/` y no se edita; el cierre compara su checksum). Es un
+complemento de pytest que carga `pytest.ini` (`-p terminal_e2e`), con la carpeta en `PYTHONPATH`:
+
+    PYTHONPATH=arketum/fijaciones/e2e python3 -m pytest -q -c arketum/fijaciones/e2e/pytest.ini --rootdir=. tests/e2e
+
+Arranca el artefacto por el camino real, con su contrato de arranque
+(`sh arrancar.sh` desde su raíz), con datos nuevos: `HOME` y `DATOS_DIR` en una
+carpeta temporal propia y `PUERTO` libre. Las pruebas de `tests/e2e/` usan:
+
+- `app` (o `juego`): un lanzador.
+  - `app()` (o `app(columnas, filas)`): la aplicación en una terminal emulada
+    (`Terminal` de `terminal_prueba`: `tecla`, `esperar`, `pantalla`, `vivo`…).
+  - `app.reabrir()`: cierra lo abierto y vuelve a arrancar con los mismos datos.
+  - `app.servidor()`: la arranca sin terminal (para una aplicación que sirve
+    HTTP en `PUERTO`) y espera a que responda; devuelve su URL base.
+  - `app.url`, `app.datos`: la URL base (`http://127.0.0.1:<PUERTO>`) y la
+    carpeta de datos.
+- `e2e_http` (módulo): `get`, `get_json`, `post_json`, `post_form`.
+
+Una prueba e2e recorre lo que haría una persona por la interfaz real: nunca
+importa el código del artefacto ni llama a sus funciones por dentro.
+"""
+
+import os, signal, socket, subprocess, sys, tempfile, time, urllib.error, urllib.request
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+ARRANQUE = ['sh', 'arrancar.sh']
+
+
+def _libre():
+    with socket.socket() as s:
+        s.bind(('127.0.0.1', 0))
+        return s.getsockname()[1]
+
+
+def _responde(url):
+    try:
+        urllib.request.urlopen(url, timeout=2)
+        return True
+    except urllib.error.HTTPError:
+        return True
+    except Exception:  # noqa: BLE001
+        return False
+
+
+class Lanzador:
+    def __init__(self, raiz):
+        self.raiz = raiz
+        self.casa = tempfile.mkdtemp(prefix='e2e-')
+        self.datos = os.path.join(self.casa, 'datos')
+        self.puerto = _libre()
+        self.url = f'http://127.0.0.1:{self.puerto}'
+        self.abiertas = []
+        self.procesos = []
+
+    def entorno(self):
+        return {'HOME': self.casa, 'DATOS_DIR': self.datos, 'PUERTO': str(self.puerto), 'PYTHONUNBUFFERED': '1'}
+
+    def __call__(self, columnas=80, filas=24):
+        from terminal_prueba import Terminal  # necesita pyte; solo si se usa la terminal
+
+        t = Terminal(ARRANQUE, cwd=self.raiz, columnas=columnas, filas=filas, env=self.entorno())
+        self.abiertas.append(t)
+        return t
+
+    def reabrir(self, columnas=80, filas=24):
+        self.cerrar()
+        return self(columnas, filas)
+
+    def servidor(self, ruta='/', segundos=25):
+        p = subprocess.Popen(ARRANQUE, cwd=self.raiz, env=dict(os.environ, **self.entorno()), stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
+        self.procesos.append(p)
+        fin = time.time() + segundos
+        while time.time() < fin:
+            if p.poll() is not None:
+                raise AssertionError(f'`sh arrancar.sh` terminó con código {p.returncode} antes de responder en {self.url}')
+            if _responde(self.url + ruta):
+                return self.url
+            time.sleep(0.2)
+        raise AssertionError(f'`sh arrancar.sh` no respondió en {self.url}{ruta} en {segundos} s')
+
+    def cerrar(self):
+        for t in self.abiertas:
+            t.cerrar()
+        self.abiertas = []
+        for p in self.procesos:
+            try:
+                os.killpg(p.pid, signal.SIGTERM)
+                p.wait(timeout=5)
+            except Exception:  # noqa: BLE001
+                try:
+                    os.killpg(p.pid, signal.SIGKILL)
+                except Exception:  # noqa: BLE001
+                    pass
+        self.procesos = []
+
+
+@pytest.fixture
+def app(request):
+    l = Lanzador(str(request.config.rootpath))
+    yield l
+    l.cerrar()
+
+
+@pytest.fixture
+def juego(app):
+    return app

package/catalogo-de-ejemplo/stacks/go/e2e-terminal/terminal_prueba.py

@@ -0,0 +1,118 @@
+"""
+TERMINAL DE PRUEBA (fijación del catálogo de Arketum: se copia tal cual y no se
+edita). Prueba un programa de terminal como lo usaría una persona, en una
+pseudo-terminal emulada con pyte (`python3 -m pip install pyte`).
+
+    from terminal_prueba import Terminal
+
+    with Terminal(['sh', 'arrancar.sh'], cwd='.', columnas=80, filas=24) as t:
+        t.esperar(2)                 # deja correr el programa
+        t.tecla('ARRIBA')            # ARRIBA, ABAJO, IZQUIERDA, DERECHA, ENTER, ESC o un carácter
+        t.esperar(0.5)
+        texto = t.pantalla()         # lo que se ve, una cadena con una línea por fila
+        assert t.vivo()              # sigue corriendo
+        assert 'Traceback' not in texto
+
+`t.lineas()` da la lista de filas y `t.codigo` el código de salida cuando termina.
+"""
+
+import fcntl, os, pty, select, signal, struct, termios, time
+
+import pyte
+
+TECLAS = {'ARRIBA': b'\x1b[A', 'ABAJO': b'\x1b[B', 'DERECHA': b'\x1b[C', 'IZQUIERDA': b'\x1b[D', 'ENTER': b'\r', 'ESC': b'\x1b'}
+
+
+class Terminal:
+    def __init__(self, comando, cwd='.', columnas=80, filas=24, env=None):
+        self._pantalla = pyte.Screen(columnas, filas)
+        self._flujo = pyte.ByteStream(self._pantalla)
+        pid, fd = pty.fork()
+        if pid == 0:
+            entorno = dict(os.environ, LANG='en_US.UTF-8', LC_ALL='en_US.UTF-8', TERM='xterm-256color', COLUMNS=str(columnas), LINES=str(filas))
+            entorno.update(env or {})
+            os.chdir(cwd)
+            os.execvpe(comando[0], comando, entorno)
+        fcntl.ioctl(fd, termios.TIOCSWINSZ, struct.pack('HHHH', filas, columnas, 0, 0))
+        self.pid, self.fd, self._vivo, self.codigo = pid, fd, True, None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.cerrar()
+
+    def esperar(self, segundos):
+        fin = time.time() + segundos
+        while time.time() < fin:
+            r, _, _ = select.select([self.fd], [], [], 0.05)
+            if r:
+                try:
+                    datos = os.read(self.fd, 65536)
+                except OSError:
+                    datos = b''
+                if datos:
+                    self._flujo.feed(datos)
+                else:
+                    time.sleep(0.05)
+            self._comprobar()
+        self._comprobar()
+
+    def tecla(self, nombre):
+        datos = TECLAS.get(nombre, nombre.encode() if isinstance(nombre, str) else nombre)
+        # Como un terminal real: si el programa activó el modo de cursor de aplicación (DECCKM, el modo privado 1, que pyte guarda como 1 << 5; curses
+        # con keypad), las flechas van como ESC O x en vez de ESC [ x.
+        if datos[:2] == b'\x1b[' and len(datos) == 3 and datos[2:] in b'ABCD' and (1 << 5) in self._pantalla.mode:
+            datos = b'\x1bO' + datos[2:]
+        try:
+            os.write(self.fd, datos)
+        except OSError:
+            pass
+
+    def pantalla(self):
+        return '\n'.join(self._pantalla.display)
+
+    def lineas(self):
+        return list(self._pantalla.display)
+
+    def pintadas(self):
+        """Cuántas celdas se ven: con carácter, en vídeo inverso o con un fondo distinto del
+        dominante (al borrar, pyte rellena con el fondo del cursor: ese no cuenta)."""
+        from collections import Counter
+        filas, cols = self._pantalla.lines, self._pantalla.columns
+        celdas = [self._pantalla.buffer[y][x] for y in range(filas) for x in range(cols)]
+        fondo = Counter(c.bg for c in celdas).most_common(1)[0][0]
+        return sum(1 for c in celdas if c.data.strip() or c.reverse or c.bg != fondo)
+
+    def foto(self):
+        """Lo que se ve, con forma: el texto y dónde hay celdas en vídeo inverso o con fondo distinto del dominante."""
+        from collections import Counter
+        filas, cols = self._pantalla.lines, self._pantalla.columns
+        fondo = Counter(self._pantalla.buffer[y][x].bg for y in range(filas) for x in range(cols)).most_common(1)[0][0]
+        marcas = tuple((y, x) for y in range(filas) for x in range(cols) if self._pantalla.buffer[y][x].reverse or self._pantalla.buffer[y][x].bg != fondo)
+        return (self.pantalla(), marcas)
+
+    def vivo(self):
+        self._comprobar()
+        return self._vivo
+
+    def _comprobar(self):
+        if not self._vivo:
+            return
+        p, estado = os.waitpid(self.pid, os.WNOHANG)
+        if p != 0:
+            self._vivo = False
+            self.codigo = os.waitstatus_to_exitcode(estado)
+
+    def cerrar(self):
+        if self._vivo:
+            try:
+                os.kill(self.pid, signal.SIGKILL)
+                os.waitpid(self.pid, 0)
+            except OSError:
+                pass
+            self._vivo = False
+        try:
+            os.close(self.fd)
+        except OSError:
+            pass

package/catalogo-de-ejemplo/stacks/go/suelo-aplicacion-por-capas/requirements.txt

@@ -0,0 +1 @@
+pyte

package/catalogo-de-ejemplo/stacks/go/suelo-aplicacion-por-capas/suelo.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+SUELO FIJO de la forma `aplicacion-por-capas` (fijación del catálogo de Arketum:
+se copia tal cual en `arketum/fijaciones/suelo/` y no se edita; el cierre compara
+su checksum). Las comprobaciones de uso que no escribe quien construye: que la
+aplicación vive, se puede usar y cerrar, y vuelve a arrancar con sus datos; no
+que haga bien lo que pide el encargo.
+
+Arranca el artefacto por su contrato de arranque: `sh arrancar.sh` desde su raíz,
+en una terminal, con `DATOS_DIR` (la carpeta de sus datos), `HOME` y `PUERTO` (un
+puerto libre, por si sirve HTTP) en una carpeta temporal propia.
+
+  arranca    a 80x24, a los 3 s pinta algo y sin traza (vivo, o esperando órdenes)
+  responde   tras Enter y unas flechas sigue sin traza
+  sale       termina limpio (código 0) con `q`, con la orden `salir`/`q`/`exit` + Enter, con la opción de salir del menú, o con fin de entrada
+  rearranca  con los mismos datos (mismo HOME y DATOS_DIR) vuelve a arrancar sin traza
+
+Uso: python3 arketum/fijaciones/suelo/suelo.py <raíz del artefacto>  →  JSON; código 0 si pasa, 1 si no.
+Necesita `pyte` (`python3 -m pip install -r arketum/fijaciones/suelo/requirements.txt`).
+"""
+
+import faulthandler, json, os, re, socket, sys, tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from terminal_prueba import Terminal  # noqa: E402
+
+ARRANQUE = ['sh', 'arrancar.sh']
+SALIDAS = [b'q', b'\r', b'salir\r', b'q\r', b'exit\r']
+# Una opción de menú para salir, la que se vea en pantalla: «5. Salir», «[0] Exit»…
+OPCION_DE_SALIR = re.compile(r'[\[(]?\s*(\w)\s*[\])\.:-]\s*(?:salir|exit|quit|terminar|cerrar)\b', re.I)
+
+
+def libre():
+    with socket.socket() as s:
+        s.bind(('127.0.0.1', 0))
+        return s.getsockname()[1]
+
+
+def pintadas(t):
+    n = 0
+    for _ in range(5):
+        t.esperar(0.15)
+        n = max(n, t.pintadas())
+    return n
+
+
+def evaluar(raiz):
+    if not os.path.isfile(os.path.join(raiz, 'arrancar.sh')):
+        return {'ok': False, 'fallo': 'no hay `arrancar.sh` en la raíz del artefacto: es su contrato de arranque', 'pantalla': ''}
+    r = {'comando': ' '.join(ARRANQUE)}
+    casa = tempfile.mkdtemp(prefix='suelo-')
+    env = {'HOME': casa, 'DATOS_DIR': os.path.join(casa, 'datos'), 'PUERTO': str(libre())}
+    with Terminal(ARRANQUE, cwd=raiz, columnas=80, filas=24, env=env) as t:
+        t.esperar(3)
+        n = pintadas(t)
+        texto = t.pantalla()
+        r['arranca'] = 'Traceback' not in texto and n >= 10 and (t.vivo() or t.codigo == 0)
+        if not r['arranca'] or not t.vivo():
+            return {**r, 'ok': False, 'fallo': 'a 80x24 no arranca: muere, saca una traza o no pinta nada', 'pantalla': texto}
+        t.tecla('ENTER')
+        for k in ('ABAJO', 'ARRIBA'):
+            t.tecla(k)
+            t.esperar(0.3)
+        t.esperar(1)
+        texto = t.pantalla()
+        r['responde'] = 'Traceback' not in texto and (t.vivo() or t.codigo == 0)
+        if not r['responde']:
+            return {**r, 'ok': False, 'fallo': 'tras Enter y unas flechas saca una traza o muere con error', 'pantalla': texto}
+        for b in SALIDAS:
+            if not t.vivo():
+                break
+            t.tecla(b)
+            t.esperar(1.5)
+        for _ in range(2):  # la opción de salir del menú que se vea, y como último recurso, fin de entrada
+            m = OPCION_DE_SALIR.search(t.pantalla())
+            if not t.vivo() or m is None:
+                break
+            t.tecla(f'{m.group(1)}\r')
+            t.esperar(1.5)
+        if t.vivo():
+            t.tecla(b'\x04')
+            t.esperar(1.5)
+        texto = t.pantalla()
+        r['sale'] = not t.vivo() and t.codigo == 0 and 'Traceback' not in texto
+        if not r['sale']:
+            return {**r, 'ok': False, 'fallo': 'no termina limpio con `q`, ni con `salir`/`q`/`exit` + Enter, ni con fin de entrada' if t.vivo() else 'al salir saca una traza o termina con error', 'pantalla': texto}
+    env['PUERTO'] = str(libre())
+    with Terminal(ARRANQUE, cwd=raiz, columnas=80, filas=24, env=env) as t:
+        t.esperar(3)
+        texto = t.pantalla()
+        r['rearranca'] = 'Traceback' not in texto and (t.vivo() or t.codigo == 0)
+        if not r['rearranca']:
+            return {**r, 'ok': False, 'fallo': 'con los datos de la primera vez, al volver a abrir saca una traza o muere', 'pantalla': texto}
+    return {**r, 'ok': True}
+
+
+if __name__ == '__main__':
+    # Un suelo nunca se queda colgado: a los 150 s escribe dónde estaba y termina con error (1).
+    faulthandler.dump_traceback_later(150, exit=True)
+    resultado = evaluar(os.path.abspath(sys.argv[1] if len(sys.argv) > 1 else '.'))
+    print(json.dumps(resultado, ensure_ascii=False, indent=1))
+    sys.exit(0 if resultado['ok'] else 1)