← Comunicación entre ProcesosBloque 10 · Protocolos, fallos y diagnóstico · Tema 43 de 52

Tema 43

Gestionar desconexiones y procesos caídos

Vas a separar lo que sabes del transporte, del proceso y del resultado de una tarea cuando algo falla. Construirás un supervisor que limita la espera y recoge a su hijo, y un registro transaccional que permite repetir una operación sin duplicar su efecto. Los ejemplos muestran por qué un timeout no revierte trabajo y por qué perder una respuesta puede dejar un resultado desconocido para el cliente.

1. Distinguir evidencias y resultados

Los temas anteriores permitieron detectar EOF, errores y vencimientos, pero detectar no decide por sí solo qué ocurrió con una operación. Un socket cerrado, un hijo terminado y una respuesta válida son evidencias diferentes.

Un fallo puede dejar una tarea confirmada, rechazada o sin resultado confirmado. «No recibí respuesta» no demuestra «no se ejecutó».

ObservaciónQué permite afirmarQué no demuestra por sí sola
send aceptó toda la petición.El transporte aceptó esos bytes localmente.Que el servidor la validó o ejecutó.
recv devuelve cero.Terminó esa dirección de entrada, después de lo pendiente.Que el proceso remoto murió o que la tarea no ocurrió.
Venció un plazo.El cliente dejó de esperar según su presupuesto.Que el servidor dejó de trabajar.
waitpid recoge al hijo.Se conoce su terminación y se recoge su estado.Que no produjo efectos antes de terminar.
Respuesta completa y válida.Se recibió el resultado definido por el protocolo.Garantías de persistencia que el contrato no haya prometido.

El tema 41 definió qué cuenta como respuesta válida. El tema 42 integró señales y tiempo. Aquí usaremos esas piezas para decidir cancelación, limpieza y recuperación.

2. La ventana entre ejecutar y responder

secuencia · un efecto confirmado localmente puede perder su respuesta
CLIENTE                              SERVIDOR
enviar operacion ------------------> validar peticion
                                     aplicar cambio
                                     confirmar transaccion
esperar resultado <----------------- preparar respuesta
      X conexion perdida             respuesta no llega al cliente

Cliente: resultado desconocido.
Servidor: el cambio puede estar confirmado.

Repetir una operación de incremento podría aplicarla dos veces. En cambio, si el proceso cayó antes de confirmar su transacción, el cambio puede no haberse conservado. El cliente necesita una forma de consultar o repetir con una identidad estable que permita distinguir esos casos.

La ausencia de confirmación es una situación del conocimiento del cliente, no necesariamente una ausencia de efecto. Esa distinción debe reflejarse en los códigos y mensajes de la aplicación.

3. Plazos de trabajo y de cancelación

Un supervisor puede separar un plazo para obtener resultado de otro para permitir terminación ordenada. El ejemplo concede un segundo al trabajo, solicita SIGTERM si debe abandonarlo y espera 250 ms antes de escalar a SIGKILL.

EtapaDecisiónEstado conservado
Espera de respuesta.Leer sin bloquear y comprobar el hijo.Bytes parciales, EOF y fecha límite.
Abandono.Cerrar el canal y solicitar terminación.Resultado no confirmado y motivo de cancelación.
Gracia.Permitir que el hijo termine.Otra fecha límite, sin renovar la tarea original.
Escalado.Solicitar SIGKILL si aún no se recogió.Obligación de recoger su estado.

Los plazos limitan etapas de decisión; no garantizan que el sistema operativo complete cualquier acción en un tiempo exacto. Una tarea en una espera no interrumpible puede tardar en terminar incluso con SIGKILL pendiente. La recogida final del ejemplo puede esperar esa terminación.

Los reintentos, la gracia y las conexiones nuevas deben consumir un presupuesto total explícito. Reabrir un socket no concede automáticamente un nuevo tiempo ilimitado para la misma tarea.

4. Cancelar no equivale a revertir

Cerrar una conexión impide continuar el diálogo por esa referencia, pero no obliga al otro proceso a abandonar una tarea de aplicación. shutdown controla direcciones de la conexión, no una transacción remota; véase shutdown(2).

Una cancelación de protocolo necesita identidad de operación y estados definidos: solicitada, aceptada antes del efecto, demasiado tarde o ya terminada. Una respuesta «cancelación recibida» no debería confundirse con «efecto revertido».

SIGTERM permite al proceso aplicar una política o terminar por su disposición normal. SIGKILL fuerza la terminación sin ejecutar los manejadores ni la limpieza de usuario. Ninguna señal deshace escrituras ya confirmadas, mensajes enviados o actualizaciones previas de memoria compartida.

El supervisor de este tema es dueño de su único hijo y puede terminarlo. No se aplica esa autoridad a cualquier proceso con el que se perdió una conexión. kill acepta PIDs y grupos con significados diferentes; el ejemplo solo usa un PID positivo propio, según kill(2).

5. Estado del hijo y recogida

Un hijo detenido por SIGSTOP sigue existiendo; no equivale a uno terminado. waitpid con WNOHANG sin WUNTRACED no entrega ese estado como una terminación. Un zombie, en cambio, ya terminó pero conserva información que su padre aún debe recoger.

WIFEXITED y WEXITSTATUS describen una salida normal; WIFSIGNALED y WTERMSIG, una terminación por señal. Solo se consulta el estado después de que waitpid lo haya devuelto para el hijo esperado. Véase waitpid(2).

El programa fija SIGCHLD en su disposición normal, no usa SA_NOCLDWAIT y no tiene otros recolectores. Mientras su hijo propio no se recoge, no se reutiliza ese PID para otro proceso. Después de recogerlo no vuelve a enviarle señales.

Para procesos no controlados de esa forma, un PID leído de un archivo puede quedar obsoleto y kill(pid, 0) no autentica al propietario del recurso. En Linux, pidfd permite referenciar una identidad de proceso con reglas más estables; véase pidfd_open(2).

6. Supervisor completo en C

Guarda supervisor43.c junto a plazo37.h del tema 37. El programa Linux crea un trabajador y espera exactamente ocho bytes conocidos y EOF. La respuesta representa un resultado didáctico 42 y no produce efectos externos.

Los modos son normal, caida, parcial, lento, resiste y detenido. El padre recibe SIGINT y SIGTERM mediante signalfd, comprueba waitpid cada vuelta y no confunde una respuesta incompleta con el estado del proceso.

supervisor43.c · respuesta, plazo, escalado y recogida del hijo propio
#define _GNU_SOURCE
#include "plazo37.h"
#include <sys/socket.h>
#include <sys/signalfd.h>
#include <sys/wait.h>
#include <poll.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>

static const unsigned char resultado43[8] = { 'O', 'K', '4', '3', 0, 0, 0, 42 };

static int cerrar43(int *fd)
{
    if (*fd == -1) return 0;
    int numero = *fd; *fd = -1;
    if (close(numero) == -1) { perror("close"); return -1; }
    return 0;
}
static int plazo43(struct timespec *limite, unsigned ms)
{
    if (fijar_plazo37(limite, (int)(ms / 1000u)) == -1) return -1;
    limite->tv_nsec += (long)(ms % 1000u) * 1000000L;
    if (limite->tv_nsec >= 1000000000L) {
        ++limite->tv_sec; limite->tv_nsec -= 1000000000L;
    }
    return 0;
}
static int senalar43(pid_t hijo, int signo)
{
    if (hijo <= 0) { errno = EINVAL; return -1; }
    if (kill(hijo, signo) == -1 && errno != ESRCH) { perror("kill hijo"); return -1; }
    return 0;
}

static void trabajador43(int fd, const char *modo, const sigset_t *original)
{
    struct sigaction accion = {0};
    accion.sa_handler = strcmp(modo, "resiste") == 0 ? SIG_IGN : SIG_DFL;
    sigemptyset(&accion.sa_mask);
    if (sigaction(SIGTERM, &accion, NULL) == -1) _exit(90);
    sigset_t mascara = *original;
    sigdelset(&mascara, SIGINT); sigdelset(&mascara, SIGTERM);
    if (sigprocmask(SIG_SETMASK, &mascara, NULL) == -1) _exit(90);
    char peticion;
    ssize_t n;
    do { n = recv(fd, &peticion, 1, 0); } while (n == -1 && errno == EINTR);
    if (n != 1 || peticion != 'T') _exit(9);
    if (strcmp(modo, "caida") == 0) _exit(7);
    if (strcmp(modo, "detenido") == 0 && raise(SIGSTOP) != 0) _exit(90);
    if (strcmp(modo, "lento") == 0 || strcmp(modo, "resiste") == 0 ||
        strcmp(modo, "detenido") == 0) {
        for (;;) pause();
    }
    size_t total = strcmp(modo, "parcial") == 0 ? 3u : sizeof resultado43;
    size_t hechos = 0;
    while (hechos < total) {
        n = send(fd, resultado43 + hechos, total - hechos, MSG_NOSIGNAL);
        if (n > 0) hechos += (size_t)n;
        else if (n == -1 && errno == EINTR) continue;
        else _exit(6);
    }
    if (close(fd) == -1) _exit(6);
    _exit(strcmp(modo, "parcial") == 0 ? 8 : 0);
}

int main(int argc, char **argv)
{
    if (argc != 2 || (strcmp(argv[1], "normal") && strcmp(argv[1], "caida") &&
        strcmp(argv[1], "parcial") && strcmp(argv[1], "lento") &&
        strcmp(argv[1], "resiste") && strcmp(argv[1], "detenido"))) {
        fprintf(stderr, "Uso: %s normal|caida|parcial|lento|resiste|detenido\n", argv[0]);
        return EXIT_FAILURE;
    }
    sigset_t control, original;
    sigemptyset(&control); sigaddset(&control, SIGINT); sigaddset(&control, SIGTERM);
    if (sigprocmask(SIG_BLOCK, &control, &original) == -1) {
        perror("bloquear control"); return EXIT_FAILURE;
    }
    struct sigaction normal = {0};
    normal.sa_handler = SIG_DFL; sigemptyset(&normal.sa_mask);
    if (sigaction(SIGCHLD, &normal, NULL) == -1 ||
        sigaction(SIGINT, &normal, NULL) == -1 ||
        sigaction(SIGTERM, &normal, NULL) == -1) {
        perror("sigaction"); return EXIT_FAILURE;
    }
    int sfd = -1, par[2] = { -1, -1 }, estado = 0, recogido = 0;
    int salida = EXIT_FAILURE, cancelando = 0, usuario = 0, eof = 0, invalida = 0;
    size_t usados = 0;
    unsigned char datos[sizeof resultado43];
    pid_t hijo = -1;
    sfd = signalfd(-1, &control, SFD_NONBLOCK | SFD_CLOEXEC);
    if (sfd == -1) { perror("signalfd"); goto fin; }
    if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, par) == -1) {
        perror("socketpair"); goto fin;
    }
    int flags = fcntl(par[0], F_GETFL);
    if (flags == -1 || fcntl(par[0], F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("fcntl padre"); goto fin;
    }
    hijo = fork();
    if (hijo == -1) { perror("fork"); goto fin; }
    if (hijo == 0) {
        if (close(par[0]) == -1 || close(sfd) == -1) _exit(90);
        trabajador43(par[1], argv[1], &original);
    }
    if (cerrar43(&par[1]) == -1) goto fin;
    ssize_t n;
    do { n = send(par[0], "T", 1, MSG_NOSIGNAL); } while (n == -1 && errno == EINTR);
    if (n != 1) { fprintf(stderr, "No se envio la peticion de prueba\n"); goto fin; }
    struct timespec limite;
    if (plazo43(&limite, 1000) == -1) goto fin;
    printf("Supervisor43 listo; PID=%jd; hijo=%jd; modo=%s\n",
           (intmax_t)getpid(), (intmax_t)hijo, argv[1]);
    if (fflush(stdout) == EOF) goto fin;
    for (;;) {
        if (!recogido) {
            pid_t r;
            do { r = waitpid(hijo, &estado, WNOHANG); } while (r == -1 && errno == EINTR);
            if (r == hijo) recogido = 1;
            else if (r == -1) { perror("waitpid WNOHANG"); goto fin; }
        }
        if (recogido && (cancelando || eof)) break;
        if (!cancelando && (usuario || invalida)) {
            cancelando = 1;
            puts("Abandono de la respuesta; solicitando SIGTERM");
            if (cerrar43(&par[0]) == -1) goto fin;
            eof = 1;
            if (!recogido && senalar43(hijo, SIGTERM) == -1) goto fin;
            if (plazo43(&limite, 250) == -1) goto fin;
            continue;
        }
        struct timeval tv;
        int tiempo = restante37(&limite, &tv);
        if (tiempo == -1) goto fin;
        if (tiempo == 0) {
            if (!cancelando) {
                puts("Plazo de trabajo agotado; resultado no confirmado");
                invalida = 1; continue;
            }
            if (!recogido) {
                puts("Gracia agotada; solicitando SIGKILL");
                if (senalar43(hijo, SIGKILL) == -1) goto fin;
            }
            break;
        }
        int ms = tv.tv_sec >= 1 ? 50 : (int)((tv.tv_usec + 999) / 1000);
        if (ms > 50) ms = 50;
        struct pollfd p[2] = {
            { .fd = eof ? -1 : par[0], .events = POLLIN },
            { .fd = sfd, .events = POLLIN }
        };
        int r = poll(p, 2, ms);
        if (r == -1) {
            if (errno == EINTR) continue;
            perror("poll"); goto fin;
        }
        if (p[1].revents & (POLLERR | POLLHUP | POLLNVAL)) goto fin;
        if (p[1].revents & POLLIN) {
            struct signalfd_siginfo info;
            ssize_t leidos = read(sfd, &info, sizeof info);
            if (leidos == (ssize_t)sizeof info && !usuario) usuario = (int)info.ssi_signo;
            else if (leidos == -1 && errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK)
                goto fin;
        }
        if (p[0].revents & POLLNVAL) goto fin;
        if (p[0].revents & (POLLIN | POLLHUP | POLLERR)) {
            unsigned char bloque[16];
            n = recv(par[0], bloque, sizeof bloque, 0);
            if (n > 0) {
                if ((size_t)n > sizeof datos - usados) invalida = 1;
                else { memcpy(datos + usados, bloque, (size_t)n); usados += (size_t)n; }
            } else if (n == 0) {
                eof = 1;
                if (usados != sizeof resultado43 || memcmp(datos, resultado43, usados) != 0)
                    invalida = 1;
            } else if (errno != EINTR &&
                       ((errno != EAGAIN && errno != EWOULDBLOCK) ||
                        (p[0].revents & (POLLHUP | POLLERR)))) {
                perror("recv respuesta"); invalida = 1;
            }
        }
    }
    if (!cancelando && !invalida && eof && usados == sizeof resultado43 &&
        recogido && WIFEXITED(estado) && WEXITSTATUS(estado) == 0)
        salida = EXIT_SUCCESS;
    if (usuario) salida = 128 + usuario;
fin:
    if (cerrar43(&par[0]) == -1) salida = EXIT_FAILURE;
    if (cerrar43(&par[1]) == -1) salida = EXIT_FAILURE;
    if (hijo > 0 && !recogido) {
        if (senalar43(hijo, SIGKILL) == -1) salida = EXIT_FAILURE;
        pid_t r;
        do { r = waitpid(hijo, &estado, 0); } while (r == -1 && errno == EINTR);
        if (r == hijo) recogido = 1;
        else { perror("waitpid final"); salida = EXIT_FAILURE; }
    }
    if (cerrar43(&sfd) == -1) salida = EXIT_FAILURE;
    if (recogido) {
        if (WIFEXITED(estado)) printf("Hijo recogido: exit=%d\n", WEXITSTATUS(estado));
        else if (WIFSIGNALED(estado)) printf("Hijo recogido: senal=%d\n", WTERMSIG(estado));
        printf("Bytes de respuesta: %zu; resultado %s\n", usados,
               salida == EXIT_SUCCESS ? "verificado" : "no confirmado por este intercambio");
    }
    if (fflush(stdout) == EOF) salida = EXIT_FAILURE;
    return salida;
}

El padre marca solo su extremo como no bloqueante. El hijo utiliza el otro socket y responde un bloque diminuto; al enviar datos mayores necesitaría su propia política de espera y presupuesto. El byte T es la petición de este laboratorio, no una implementación del protocolo IPC4.

La consulta periódica de waitpid tiene una latencia de hasta aproximadamente 50 ms más planificación. No se usa SIGCHLD para despertar el bucle, de modo que no se depende de una señal que haya llegado antes de poll. Las señales externas de cancelación sí quedan observables en signalfd.

La limpieza final solo señala al hijo propio que todavía no se recogió. Si se solicita SIGKILL en el escalado y otra vez en la salida de emergencia, ambas solicitudes siguen refiriéndose a ese hijo no recogido. La llamada final waitpid puede esperar la terminación real; no se promete un límite duro para cualquier estado del núcleo.

7. Ejecutar los escenarios de fallo

Bash en Linux · resultado válido y respuesta incompleta
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 supervisor43.c -o supervisor43
$ ./supervisor43 normal
Supervisor43 listo; PID=4200; hijo=4201; modo=normal
Hijo recogido: exit=0
Bytes de respuesta: 8; resultado verificado
$ ./supervisor43 parcial
...
Hijo recogido: exit=8
Bytes de respuesta: 3; resultado no confirmado por este intercambio
$ echo $?
1
ModoConducta del trabajadorResultado esperado
normal.Responde ocho bytes y termina.Respuesta verificada, hijo recogido y retorno cero.
caida.Termina con código siete sin responder.Cero bytes, fallo del intercambio y retorno uno.
parcial.Envía tres bytes y termina con ocho.Truncamiento, retorno uno.
lento.No responde y conserva SIGTERM normal.Plazo, terminación por SIGTERM y retorno uno.
resiste.Ignora SIGTERM.Plazo, gracia, SIGKILL y retorno uno.
detenido.Se detiene con SIGSTOP.No se confunde con terminado; el ejemplo escala a SIGKILL.

Los PIDs son ilustrativos y los mensajes de cancelación pueden variar según cuándo se observe EOF o la terminación. Si el hijo todavía no se recogió al detectar una respuesta inválida, puede aparecer una solicitud de SIGTERM que ya no cambie el estado final.

Para probar cancelación del supervisor, espera su mensaje inicial en modo lento o resiste y envíale SIGTERM. Debe recoger al hijo y retornar 143. El modo detenido no envía SIGCONT: una terminación ordenada que necesite ejecutar código en un proceso detenido tendría que decidir también si lo reanuda.

8. Recursos huérfanos y propiedad

Recurso o estadoQué hace el núcleo al terminar un procesoQué sigue siendo responsabilidad de la aplicación
Descriptores del proceso.Cierra sus referencias.Otras copias pueden seguir abiertas en otros procesos.
Ruta de socket o FIFO.No ejecuta el unlink del programa.Retirada por un propietario autorizado y con identidad comprobada.
Objeto POSIX con nombre.Cierra referencias del proceso.La política de shm_unlink, mq_unlink o sem_unlink es explícita.
Memoria compartida.Retira los mapeos de ese proceso.No revierte escrituras parciales ni repara estructuras.
Hijo que sigue vivo.Puede quedar reparentado si muere el padre.Supervisión del árbol y recursos de la tarea.
Hijo terminado.Conserva estado hasta su recogida, salvo políticas específicas.waitpid o la API de espera apropiada.

Unlink retira un nombre; no significa que desaparecieron todas las referencias abiertas. Las reglas de archivos y objetos compartidos se describen en unlink(2) y shm_unlink(3).

Un archivo residual con un PID no concede permiso para borrar una ruta ni para señalar ese número. El tema 32 utilizó directorio privado e identidad dev/ino para retirar únicamente el socket de la ejecución, bajo administración exclusiva. La limpieza por patrones de nombres no sustituye esa propiedad.

Si el trabajador crea nietos, terminar solo su PID no administra todo el árbol. Se necesita definir grupos, supervisor del servicio o mecanismos de agrupación del sistema, además de quién recoge y quién elimina cada recurso.

9. Recuperar estado compartido y trabajo

Una caída durante la actualización de un anillo, una lista o un contador compartido puede dejar invariantes rotas. El sistema no conoce el significado de esas escrituras. Un semáforo POSIX tampoco devuelve automáticamente un token porque muriera quien lo había tomado.

No reinicialices un semáforo o una región mientras otros participantes puedan estar usándolos. Una recuperación necesita exclusión, una generación de la región, estado de inicialización y reglas para reparar, reconstruir o descartar trabajo.

Una concesión temporal puede ayudar a detectar actividad ausente, pero su vencimiento no demuestra que el trabajador anterior dejó de ejecutar: pudo estar pausado o retrasado. Si se permite otro propietario, los recursos que reciben efectos deben rechazar generaciones antiguas mediante una regla de exclusión o fencing validada donde se modifica el estado.

Los datos «asignados» y «completados» necesitan transiciones reconocibles. Una cola que entregó una tarea a un proceso no prueba que el resultado se confirmó. La recuperación debe definir qué tareas se pueden repetir y con qué identidad.

10. Decidir si se puede reintentar

SituaciónPolítica razonableCondición que debe verificarse
Una tarea nueva nunca llegó a transmitirse.Puede intentarse su primer envío efectivo.No existe otro intento anterior de esa misma tarea con efecto desconocido.
Operación de consulta o efecto idempotente definido.Repetir dentro del presupuesto y del contrato.La repetición conserva los parámetros y las garantías prometidas.
Cambio no idempotente sin registro de operación.Consultar o reconciliar antes de repetir automáticamente.La ausencia de respuesta no descarta el efecto previo.
Clave de operación conservada y deduplicación válida.Repetir con la misma clave y contenido.El registro cubre la operación y la ventana de reintento.

Una política completa limita intentos y tiempo total, distingue errores permanentes de temporales y evita que muchos clientes reintenten a la vez. El retroceso progresivo con dispersión puede reducir esa sincronización, pero no vuelve segura una operación que no admite repetición.

Reintentar requiere un destino conocido y una conexión nueva cuando el estado del socket anterior ya no es reutilizable según su contrato. No se vuelve a enviar un prefijo desde cero dentro de un flujo parcialmente escrito sin una regla de aplicación.

11. Idempotencia y claves de operación

Una operación es idempotente respecto de un estado definido si repetirla tiene el mismo efecto pretendido que aplicarla una vez. «Fijar el valor en siete» puede serlo; «sumar siete» no lo es por sí solo. Las auditorías u otros efectos adicionales también deben tener una política.

La definición aparece asimismo en protocolos como HTTP, pero aquí diseñamos un contrato de IPC propio, no aplicamos automáticamente sus reglas de métodos. Véase RFC 9110, métodos idempotentes.

Para una operación no idempotente se puede usar una clave estable que identifique el trabajo lógico. El servidor conserva clave, parámetros y resultado. Si vuelve la misma clave con los mismos parámetros, devuelve el resultado original sin repetir el cambio; si los parámetros difieren, rechaza el conflicto.

La clave no debe renovarse al cambiar de conexión o al reiniciar el cliente. Su alcance debe incluir al solicitante autorizado y el tipo de operación; un id corto reutilizado en cada sesión, como los del tema 41, no ofrece por sí solo esa identidad durable.

12. La frontera transaccional de la deduplicación

regla · efecto, identidad y resultado se confirman juntos
BEGIN
    buscar clave de operacion
    si existe: comprobar parametros y reutilizar resultado
    si no existe:
        aplicar cambio
        registrar clave, parametros y resultado
COMMIT
enviar respuesta

caida antes de COMMIT: recuperar sin el cambio no confirmado
caida despues de COMMIT: conservar cambio y resultado para el reintento

Guardar la clave antes del efecto en una operación separada puede dejar una clave «completada» sin efecto. Guardarla después, también por separado, puede dejar un efecto sin registro y permitir duplicarlo. El ejemplo confirma ambos en la misma base y transacción.

SQLite permite delimitar transacciones explícitas; BEGIN IMMEDIATE serializa este acceso de escritura antes de la lectura que decide si la clave existe. Las reglas están en transacciones de SQLite.

La garantía queda limitada a esa frontera: actualizar SQLite y luego enviar un correo o modificar otro servicio no convierte ambos efectos en una única transacción. Para efectos externos se necesita un diseño adicional, por ejemplo registro de salida y consumo idempotente, o reconciliación.

La recuperación y persistencia dependen también de la configuración y del almacenamiento. El laboratorio usa sincronización FULL y no desactiva el journal; no promete sobrevivir a cualquier fallo de hardware. Véase commit atómico en SQLite.

13. Laboratorio persistente con SQLite

Guarda deduplicar43.py. Usa el módulo sqlite3 de Python y una base exclusiva del ensayo. La operación suma una cantidad positiva a un contador y registra su resultado. No realiza otros efectos externos.

La tabla conserva hasta cien claves; al llenarse rechaza operaciones nuevas sin borrar automáticamente las anteriores. Los reintentos conocidos siguen siendo válidos. La cantidad está entre uno y un millón, y el contador no puede superar mil millones.

deduplicar43.py · incremento y registro en una misma transacción
import argparse
import json
import os
from pathlib import Path
import re
import sqlite3
import sys

MAX_CLAVES = 100
MAX_CONTADOR = 1_000_000_000

def abrir(ruta, crear=False):
    nombre = str(ruta) if crear else ruta.resolve().as_uri() + "?mode=rw"
    con = sqlite3.connect(nombre, uri=not crear, timeout=2.0, isolation_level=None)
    try:
        con.execute("PRAGMA synchronous=FULL")
    except BaseException:
        con.close()
        raise
    return con

def iniciar(con):
    version = con.execute("PRAGMA user_version").fetchone()[0]
    if version not in (0, 1):
        raise ValueError("version de base incompatible")
    con.execute("PRAGMA journal_mode=DELETE")
    con.execute("BEGIN IMMEDIATE")
    con.execute("CREATE TABLE IF NOT EXISTS contador ("
                "id INTEGER PRIMARY KEY CHECK(id=1), "
                "valor INTEGER NOT NULL CHECK(valor BETWEEN 0 AND 1000000000))")
    con.execute("CREATE TABLE IF NOT EXISTS operaciones ("
                "clave TEXT PRIMARY KEY, cantidad INTEGER NOT NULL, "
                "resultado INTEGER NOT NULL)")
    con.execute("INSERT OR IGNORE INTO contador VALUES(1, 0)")
    con.execute("PRAGMA user_version=1")
    con.execute("COMMIT")

def aplicar(con, clave, cantidad, fallo):
    if re.fullmatch(r"[A-Za-z0-9_-]{1,64}", clave) is None:
        raise ValueError("clave: de 1 a 64 caracteres ASCII alfanumericos, _ o -")
    if not 1 <= cantidad <= 1_000_000:
        raise ValueError("cantidad fuera de rango")
    con.execute("BEGIN IMMEDIATE")
    fila = con.execute("SELECT cantidad, resultado FROM operaciones WHERE clave=?",
                       (clave,)).fetchone()
    repetida = fila is not None
    if repetida:
        if fila[0] != cantidad:
            raise ValueError("misma clave con parametros diferentes")
        resultado = fila[1]
    else:
        n = con.execute("SELECT COUNT(*) FROM operaciones").fetchone()[0]
        if n >= MAX_CLAVES:
            raise ValueError("registro de claves lleno; no se aplica otro efecto")
        actual = con.execute("SELECT valor FROM contador WHERE id=1").fetchone()[0]
        if cantidad > MAX_CONTADOR - actual:
            raise ValueError("contador fuera de rango")
        resultado = actual + cantidad
        con.execute("UPDATE contador SET valor=? WHERE id=1", (resultado,))
        con.execute("INSERT INTO operaciones VALUES(?, ?, ?)",
                    (clave, cantidad, resultado))
    if fallo == "antes":
        os._exit(74)  # Caida deliberada: no ejecuta finally ni COMMIT.
    con.execute("COMMIT")
    if fallo == "respuesta":
        os._exit(75)  # Cambio confirmado, pero no se entrega resultado.
    return {"clave": clave, "resultado": resultado, "repetida": repetida}

def main():
    p = argparse.ArgumentParser()
    sub = p.add_subparsers(dest="accion", required=True)
    ini = sub.add_parser("iniciar")
    ini.add_argument("base", type=Path)
    ver = sub.add_parser("ver")
    ver.add_argument("base", type=Path)
    op = sub.add_parser("aplicar")
    op.add_argument("base", type=Path)
    op.add_argument("clave")
    op.add_argument("cantidad", type=int)
    op.add_argument("--fallo", choices=("antes", "respuesta"))
    a = p.parse_args()
    con = abrir(a.base, crear=a.accion == "iniciar")
    try:
        if a.accion == "iniciar":
            iniciar(con)
            salida = {"inicializada": True}
        else:
            if con.execute("PRAGMA user_version").fetchone()[0] != 1:
                raise ValueError("la base no tiene el formato del laboratorio")
            if a.accion == "aplicar":
                salida = aplicar(con, a.clave, a.cantidad, a.fallo)
            else:
                fila = con.execute("SELECT valor, (SELECT COUNT(*) FROM operaciones) "
                                   "FROM contador WHERE id=1").fetchone()
                salida = {"contador": fila[0], "operaciones": fila[1]}
        print(json.dumps(salida, ensure_ascii=False), flush=True)
    finally:
        try:
            if con.in_transaction:
                con.execute("ROLLBACK")
        finally:
            con.close()

if __name__ == "__main__":
    try:
        main()
    except (ValueError, OSError, sqlite3.Error) as error:
        print(error, file=sys.stderr)
        sys.exit(1)

Las consultas usan parámetros, y la apertura normal usa mode=rw para no crear silenciosamente otra base al escribir una ruta errónea. La inicialización se hace antes de lanzar operaciones concurrentes. La API y el control explícito de transacciones se documentan en sqlite3 de Python.

El registro es durable entre invocaciones y no depende de la conexión IPC. La respuesta repetida conserva el resultado original de esa operación, aunque otras claves hayan cambiado el contador después. No se elimina una clave para «hacer lugar» mientras aún puede llegar un reintento válido.

Los códigos 74 y 75 son fallos deliberados del laboratorio, no diagnósticos reales de una red. Sirven para colocar la caída en dos puntos conocidos sin depender del tiempo exacto de un kill externo.

14. Probar caída y respuesta perdida

Bash · caída después del commit y repetición con la misma clave
$ ensayo=$(mktemp -d)
$ base="$ensayo/estado.db"
$ python3 deduplicar43.py iniciar "$base"
{"inicializada": true}
$ python3 deduplicar43.py aplicar "$base" op-A 7 --fallo respuesta
$ echo $?
75
$ python3 deduplicar43.py ver "$base"
{"contador": 7, "operaciones": 1}
$ python3 deduplicar43.py aplicar "$base" op-A 7
{"clave": "op-A", "resultado": 7, "repetida": true}
$ python3 deduplicar43.py aplicar "$base" op-A 9
misma clave con parametros diferentes

El intento con otra cantidad debe retornar uno y no cambiar el contador. Si en lugar de op-A se utiliza una clave nueva, el servidor la tratará como otra operación y sumará de nuevo: conservar la identidad es parte del contrato del cliente.

Bash · caída antes de confirmar y resultado original conservado
$ python3 deduplicar43.py aplicar "$base" op-B 3 --fallo antes
$ echo $?
74
$ python3 deduplicar43.py ver "$base"
{"contador": 7, "operaciones": 1}
$ python3 deduplicar43.py aplicar "$base" op-B 3
{"clave": "op-B", "resultado": 10, "repetida": false}
$ python3 deduplicar43.py aplicar "$base" op-A 7
{"clave": "op-A", "resultado": 7, "repetida": true}
$ python3 deduplicar43.py ver "$base"
{"contador": 10, "operaciones": 2}
$ rm -- "$base"
$ rmdir -- "$ensayo"

La recuperación de la transacción incompleta corresponde a SQLite al abrir y usar la base. No borres manualmente un journal de una base en uso para «repararla». La limpieza final del ejemplo se realiza cuando todas sus invocaciones ya terminaron y la recuperación se completó.

La espera de bloqueos de SQLite tiene su propio timeout de dos segundos; no es un plazo total de una operación ni una garantía de duración de la E/S de almacenamiento.

15. Explorar efecto, respuesta y reintento

El modelo suma siete a un contador. Puedes perder una respuesta, vencer el plazo del cliente o reiniciar el servidor. En modo con clave conserva el resultado junto al efecto; en modo sin clave cada ejecución vuelve a incrementar.

Estado real del contador0

Registro de resultadosNinguno

Conocimiento del clienteSin operación enviada

Estado del servidorDisponible

Intentos enviados0

Petición o respuesta actualNinguna

Perder la respuesta puede dejar un efecto real con resultado desconocido para el cliente.

Primero ejecuta, pierde la respuesta y reintenta. Compara la misma secuencia sin deduplicación. Luego prueba una caída antes y después de confirmar: el modelo conserva únicamente efectos y registros confirmados, como la transacción del laboratorio.

Para observar cancelación no efectiva, vence el plazo después de enviar y después ordena ejecutar en el servidor. El contador puede cambiar aunque el cliente ya abandonó la espera. En ese recorrido el modelo descarta la respuesta tardía y permite repetir cuando terminó ese intento.

La ejecución del servidor se representa de forma secuencial y su confirmación es atómica en el modelo. No se simula un sistema de archivos, una base real, efectos externos ni reintentos concurrentes. Reiniciar servidor conserva estado; «Reiniciar todo» borra solo el escenario didáctico.

16. Pruebas bajo fallos y diagnóstico

Proceso, canal y cancelación

Deduplicación y frontera del commit

Ejecuta la caída antes de commit y comprueba cero efecto nuevo y ninguna clave nueva. Ejecuta la pérdida de respuesta después de commit y comprueba un efecto, una clave y el resultado original en el reintento.

Lanza varios procesos con la misma clave y cantidad: debe aparecer una sola operación registrada y un solo incremento. Con claves distintas, cada operación debe sumarse una vez. Con la misma clave y otra cantidad debe haber conflicto sin cambio adicional.

Completa las cien claves del límite y comprueba que una nueva se rechaza, mientras un reintento conocido sigue devolviendo su resultado. Prueba también clave o cantidad inválida, base inexistente en modo normal y versión de base incompatible.

El cliente debe conservar la clave antes de poder necesitar un reintento; almacenarla solo después de recibir la respuesta no ayuda si esa respuesta se pierde. Un diseño real debe definir también cuánto tiempo conserva el servidor el registro y qué respuesta ofrece cuando ya no puede decidir con seguridad.

Bash en Linux · observar el ciclo del supervisor
$ strace -f -s 32 -e trace=clone,clone3,fork,wait4,poll,signalfd4,kill,sendto,recvfrom,close ./supervisor43 resiste

Busca petición enviada, espera, SIGTERM, gracia, SIGKILL y wait4 que recoge al hijo. Los nombres exactos de las syscalls pueden depender de la biblioteca. No uses pausas aproximadas para adivinar el arranque; el controlador debe leer el mensaje de disponibilidad.

Las pruebas deben tener un límite externo y un mecanismo para recoger los procesos que lanzaron si el supervisor de prueba falla. No envíes señales a un PID persistido sin verificar su propiedad y ciclo de vida.

17. Errores frecuentes

ErrorConsecuenciaCorrección
Interpretar timeout como «no ejecutado».Se puede repetir un efecto ya confirmado.Estado de resultado desconocido y recuperación definida.
Suponer que close cancela la tarea remota.El trabajo continúa después de abandonar la conexión.Cancelación de protocolo o autoridad de supervisión explícita.
Señalar y olvidar al hijo.Queda estado sin recoger.Comprobar terminación y ejecutar la espera correspondiente.
Confundir detenido con terminado.Se anuncia una salida que no ocurrió.Interpretar los estados y opciones de wait correctamente.
Reutilizar un PID viejo como identidad.Se puede señalar un proceso ajeno.Propiedad, referencias estables y ciclo de vida controlado.
Borrar recursos por coincidencia de nombre.Se retira una entrada que puede pertenecer a otra ejecución.Propietario e identidad de recurso comprobados.
Reinicializar estado compartido con participantes activos.Se rompen exclusión e invariantes.Recuperación coordinada con generación y autoridad.
Cambiar clave en cada reintento.El servidor ve operaciones distintas.Conservar la identidad del trabajo lógico.
Aceptar una clave con otros parámetros.Se devuelve un resultado de otra petición o se cambia su significado.Detectar conflicto.
Separar efecto y registro en commits distintos.Queda una ventana de duplicación o falso completado.Misma frontera transaccional cuando el recurso lo permite.
Borrar claves sin definir ventana de repetición.Un reintento tardío vuelve a producir el efecto.Retención y política de resultados antiguos explícitas.
Prometer exactamente una vez para efectos externos no coordinados.Se oculta una ventana de fallo entre sistemas.Declarar el alcance y diseñar deduplicación o reconciliación adicional.

18. Resumen

19. Preguntas de repaso y práctica

Responde distinguiendo qué ocurrió, qué se observó y qué puede decidir con seguridad cada participante.

1. ¿EOF demuestra que el proceso remoto murió?

No. Puede haber terminado solo su dirección de envío y seguir vivo. El estado del proceso se observa por otra vía.

2. ¿Qué demuestra un timeout del cliente?

Que se agotó su presupuesto de espera, no que el servidor dejó de ejecutar ni que no hubo efecto.

3. ¿Por qué una respuesta perdida puede duplicar un incremento?

Porque el primer incremento pudo confirmarse antes de perderse la respuesta y el segundo intento puede volver a ejecutarlo.

4. ¿SIGTERM o SIGKILL deshacen cambios confirmados?

No. Afectan al proceso, no revierten automáticamente los efectos previos de aplicación.

5. ¿Por qué hay una espera después de señalar al hijo?

Porque solicitar terminación no equivale a recoger su estado. El padre sigue teniendo esa obligación.

6. ¿Un hijo con SIGSTOP es un zombie?

No. Está detenido y sigue vivo. Un zombie ya terminó y aún no fue recogido según la política de espera.

7. ¿Por qué el supervisor no vuelve a señalar después de recoger?

Porque el número podría reutilizarse. La autoridad del ejemplo se basa en el hijo propio aún no recogido.

8. ¿Cerrar la última referencia del proceso borra su ruta de socket?

No ejecuta el unlink de aplicación. El nombre necesita una política explícita de retirada.

9. ¿Vencer una concesión temporal prueba que el propietario anterior ya no ejecuta?

No. Puede estar pausado o retrasado. Los efectos necesitan una regla que excluya generaciones antiguas cuando corresponda.

10. ¿Sumar siete es idempotente por sí solo?

No. Repetirlo cambia otra vez el contador. El registro con clave permite suprimir la repetición de esa operación identificada.

11. ¿Qué debe conservarse durante un reintento?

La clave de la operación lógica y sus parámetros, dentro de la ventana y alcance de deduplicación acordados.

12. ¿Qué pasa si llega la misma clave con otra cantidad?

El servidor rechaza el conflicto y no aplica otro efecto.

13. ¿Por qué el resultado repetido de op-A puede ser siete cuando el contador ya vale diez?

Porque se devuelve el resultado original de esa operación, no una consulta nueva del estado actual.

14. ¿Qué ventana elimina la transacción del laboratorio?

La que separaría el cambio del contador y el registro de clave y resultado. Ambos se confirman o recuperan juntos en SQLite.

15. ¿Esa transacción garantiza un correo externo exactamente una vez?

No. El correo quedaría fuera de la frontera de la base y necesitaría su propio diseño de entrega, deduplicación o reconciliación.

Para practicar y ampliar

  1. Ejecuta los seis modos del supervisor y relaciona bytes, EOF y estado del hijo.
  2. Fuerza fragmentos de un byte y verifica la respuesta normal.
  3. Cancela al supervisor después del arranque y comprueba que recoge a su trabajador.
  4. Diseña cómo administrarías trabajadores que también crean nietos.
  5. Construye una tabla de propiedad y retirada para socket, FIFO, cola, semáforo y memoria compartida.
  6. Reproduce las caídas antes y después de commit con claves nuevas.
  7. Ejecuta reintentos concurrentes de una misma clave y compara efecto y respuestas.
  8. Prueba el registro lleno y una repetición de una clave ya conocida.
  9. Define ventana de retención, presupuesto y política de reintentos para un servicio.
  10. Diseña cómo consultarías un resultado desconocido sin repetir un efecto externo irreversible.
Próximo paso

El tema 44 utilizará strace, /proc, lsof, ss y clock_gettime para observar recursos, localizar esperas y comparar mecanismos de IPC. Las mediciones deben conservar las mismas garantías de protocolo y recuperación.