1. Del servidor de un proceso a una arquitectura cooperativa
En un servidor de un solo proceso, un cálculo largo o una operación bloqueante puede impedir que se atiendan otras conversaciones. Un bucle de eventos permite intercalar conexiones, pero no convierte automáticamente trabajo de CPU en trabajo paralelo. Varios procesos permiten repartir ejecución y aislar parte de los fallos, a cambio de necesitar coordinación.
En una arquitectura supervisor–trabajadores, el supervisor administra la vida de los procesos y los recursos comunes; cada trabajador ejecuta una parte de la atención. El protocolo entre ellos determina preparación, admisión, drenaje y terminación.
No hay una única arquitectura «de servidor web». Un proceso puede atender muchas conexiones mediante epoll; un conjunto prefork puede asignar una conexión por trabajador; otro diseño puede usar hilos o procesos auxiliares para tareas concretas. La elección depende de bloqueos, estado, carga y requisitos de aislamiento.
El ejemplo de este tema es local: usa AF_UNIX para mantener el foco en IPC. HTTP es el contenido intercambiado. Sustituir el transporte por TCP exige estudiar direcciones de red y otras condiciones; ese paso pertenece al curso de redes. En una instalación real también puede haber un proxy de entrada que se comunique con un servicio de aplicación mediante un socket Unix.
cliente local ── conexión HTTP ──► socket Unix de escucha
│
┌────────┴────────┐
▼ ▼
trabajador A trabajador B
conexión propia conexión propia
▲ ▲
└──── supervisor ─┘
señales / preparación / waitpidCompartir la escucha no significa que ambos trabajadores reciban los mismos bytes de una conexión. accept entrega un conectado al proceso que consigue extraer esa conexión pendiente. A partir de allí, la conversación corresponde a ese conectado y a las referencias que se hayan conservado.
2. Separar datos, control y observación
| Plano | Información | Mecanismo posible |
|---|---|---|
| Datos. | Peticiones, respuestas y bytes de una conexión. | Socket conectado con estado por sesión. |
| Control. | Preparado, dejar de aceptar, terminar o cambiar configuración. | Señales, pipe o canal Unix con mensajes definidos. |
| Observación. | Contadores, errores, identidad y duración de solicitudes. | Registros estructurados y métricas con límites. |
Una orden de drenaje no necesita viajar dentro del flujo HTTP del cliente. Mantener el control separado permite solicitar la parada mientras un trabajador espera bytes de una petición incompleta. Si el trabajador solo consulta su control entre clientes, un cliente lento puede retrasar esa decisión indefinidamente.
En el laboratorio, una tubería transporta una confirmación R por trabajador. SIGTERM y SIGINT son solicitudes de drenaje, leídas con signalfd. SIGCHLD avisa al supervisor de que debe revisar waitpid. Estos significados pertenecen a este programa; otros servidores asignan acciones distintas a las mismas señales.
Los registros no son la autoridad sobre el estado de un hijo. Que aparezca «terminando» no implica que el proceso ya haya salido; waitpid confirma su final y permite recogerlo. Una métrica de conexiones tampoco sustituye la propiedad de sus descriptores.
El control necesita su propio límite: una cola llena de mensajes de diagnóstico no debería impedir la orden de parada. Si se usa un mismo canal para varias clases de mensajes, hay que presupuestar capacidad, prioridad y comportamiento ante desconexión.
3. Tres formas de repartir conexiones
| Modelo | Quién acepta | Ventaja y responsabilidad |
|---|---|---|
| Escucha heredada. | Los trabajadores llaman accept sobre referencias al mismo socket. | Evita reenviar conectados; requiere tratar la competencia y coordinar la parada. |
| Aceptador central. | Un proceso acepta y pasa referencias a trabajadores. | Permite seleccionar destino; necesita cola acotada, transferencia y recuperación. |
| Escuchas distintas. | Cada proceso tiene una escucha creada para un diseño específico. | No equivale a duplicar un descriptor; requiere estudiar el reparto que ofrece ese transporte. |
El laboratorio utiliza la primera opción. Dos trabajadores pueden despertar al observar la escucha, pero uno puede consumir la conexión antes del accept del otro. Por eso la escucha es no bloqueante y EAGAIN es una situación normal, no una razón para terminar al trabajador.
Ni el despertar ni la secuencia de accept garantizan alternancia. Un trabajador puede aceptar varias conexiones consecutivas. No se prueba «reparto correcto» exigiendo que la primera petición vaya a A y la siguiente a B: se comprueba integridad de cada respuesta y pertenencia del PID al conjunto de trabajadores conocidos.
En el reparto central, enviar el entero 7 por un pipe no entrega el descriptor 7 del aceptador. La tabla de descriptores es local. Para transferir una referencia a un conectado se emplea, por ejemplo, SCM_RIGHTS sobre un canal Unix, junto con un protocolo de asignación.
También importa la unidad repartida. Asignar una conexión HTTP persistente no reparte automáticamente cada petición de esa conexión. Un cliente con muchas peticiones puede mantener ocupado al mismo trabajador; el balance por conexiones puede diferir mucho del balance por tiempo de CPU.
4. Escucha heredada y propiedad de descriptores
El supervisor crea, enlaza y pone en escucha el socket antes de fork. Los hijos heredan referencias a ese socket. La descripción abierta subyacente es compartida; cerrar una referencia en el padre no cierra las referencias que conservan los hijos. Los detalles de herencia están documentados en fork(2).
| Recurso | Supervisor | Cada trabajador |
|---|---|---|
| Escucha. | Conserva una referencia durante servicio; la cierra al iniciar parada. | Conserva una referencia hasta recibir drenaje. |
| Conectado aceptado. | No lo recibe ni lo cierra. | Solo lo conserva el trabajador que lo aceptó; lo cierra al completar o abandonar. |
| Pipe de preparación. | Lee; cierra su copia de escritura. | Escribe un byte R; cierra esa escritura y la lectura heredada. |
| signalfd del supervisor. | Lo usa para señales propias. | Cierra la copia heredada y crea un signalfd propio. |
| Nombre y directorio. | Los crea y retira bajo una política de propiedad. | No borra la ruta ni el directorio. |
accept4 crea otro socket, conectado; no transforma la escucha en una conversación. En Linux se solicita SOCK_NONBLOCK explícitamente para el conectado, además de SOCK_CLOEXEC. No se supone que el aceptado hereda automáticamente el modo no bloqueante. Véase accept(2).
CLOEXEC evita fugas al ejecutar otro programa, pero no impide la herencia por fork. Tampoco protege de una referencia conservada accidentalmente en un hijo. El inventario de recursos se hace por rama y por fase, como en los temas anteriores.
Un contador global ordinario después de fork tampoco se comparte: cada proceso modifica su copia. Para estadísticas comunes hay que usar mensajes o memoria compartida con sincronización. En este ejemplo el supervisor cuenta preparación y salidas, y cada respuesta identifica al trabajador que la produjo.
5. Confirmar preparación antes de anunciar disponibilidad
Que fork haya devuelto un PID solo confirma que se creó un proceso. Todavía pueden fallar inicialización, canales o datos del trabajador. Un supervisor debería anunciar disponibilidad cuando se cumple una condición de preparación definida.
Cada hijo del laboratorio crea su signalfd, conserva la escucha válida y escribe un byte R en un pipe común. Son escrituras de un byte, por debajo de PIPE_BUF. El padre acumula dos confirmaciones, comprueba salidas de hijos y entonces imprime WEB45 listo. La tubería no transporta registros de tamaño variable ni requiere atribuir cada byte a un hijo: todos ejecutan exactamente una confirmación.
Hay un plazo de cinco segundos para el arranque. EOF prematuro del pipe, un byte inesperado o una salida de trabajador provocan el cierre del grupo propio. Si fork falla después de crear el primer hijo, ese hijo también recibe la solicitud de parada y es recogido.
La disponibilidad es un instante observado, no una promesa de que ningún proceso fallará un microsegundo después. El cliente sigue necesitando gestionar una conexión fallida. En una arquitectura con identidad de trabajador y generaciones se usarían mensajes READY con identificadores, versión y número de generación.
El cliente de integración espera la línea WEB45 listo por un descriptor con plazo. No utiliza sleep para suponer que el servidor ya está preparado.
6. Definir un laboratorio HTTP acotado
El programa web45.c es autónomo y está pensado para Linux. Crea un directorio privado nuevo con mkdtemp, publica dentro http.sock y crea dos trabajadores. Cada uno atiende como máximo un conectado a la vez; el otro puede seguir aceptando. Esto permite observar reparto y agotamiento con pocos procesos.
| Parte | Contrato del laboratorio |
|---|---|
| Petición admitida. | Los primeros 18 bytes deben ser GET / HTTP/1.0 seguidos de dos CRLF. No se analizan más peticiones. |
| Respuesta. | HTTP/1.0, Content-Length, Connection: close y cuerpo ASCII con el PID del trabajador. |
| Error de prefijo. | Respuesta 400 con cuerpo fijo cuando llega un prefijo incompatible. |
| Tamaño de entrada. | Se reciben únicamente los 18 bytes del contrato; no se acumula una cabecera sin límite. |
| Tiempo. | Tres segundos desde accept para recepción y envío juntos, con CLOCK_MONOTONIC. |
| Cierre. | Una conexión por respuesta; sin keep-alive, pipelining, cuerpos de petición, TLS ni archivos. |
No es un analizador HTTP general. Una petición normal de curl agrega cabeceras y usa otra forma de conversación: utiliza el cliente incluido para comprobar este contrato deliberadamente mínimo. El ejercicio no debe colocarse frente a tráfico público ni utilizarse como componente de un proxy HTTP; un servidor completo necesita un analizador de protocolo y reglas de framing completas.
Un EOF antes de los 18 bytes, una desconexión durante el envío o el vencimiento del plazo hacen que se cierre esa sesión. El trabajador continúa disponible. Un fallo interno de reloj, control o escucha sí termina al trabajador y lleva al supervisor a detener el servicio.
El plazo no se reinicia al recibir cada fragmento. Un cliente que envía un byte cada tanto no puede retener indefinidamente al trabajador. La gracia del supervisor es de cinco segundos, superior al plazo de tres segundos de una sesión ya aceptada.
7. Servidor prefork completo en C
Guarda este código como web45.c. No requiere archivos de apoyo. La espera combina siempre conexión o escucha con el canal de señales; recibir drenaje durante una sesión cierra la escucha del trabajador y permite que esa sesión use el tiempo restante de su plazo original.
#define _GNU_SOURCE
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/signalfd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <poll.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define TRAB45 2
#define SESION45 3000
#define GRACIA45 5000
static int cerrar45(int *fd)
{
if (*fd < 0) return 0;
int n = *fd; *fd = -1;
if (close(n) == -1) { perror("close"); return -1; }
return 0;
}
static int64_t ahora45(void)
{
struct timespec t;
if (clock_gettime(CLOCK_MONOTONIC, &t) == -1) return -1;
return (int64_t)t.tv_sec * 1000 + t.tv_nsec / 1000000;
}
/* Solo se invoca con la ruta creada en nuestro directorio privado. */
static int retirar45(const char *ruta, const struct stat *identidad)
{
struct stat actual;
if (lstat(ruta, &actual) == -1) return errno == ENOENT ? 0 : -1;
if (!S_ISSOCK(actual.st_mode) || actual.st_dev != identidad->st_dev ||
actual.st_ino != identidad->st_ino) {
errno = ESTALE; return -1;
}
return unlink(ruta);
}
static int senales45(int fd, int *parar)
{
for (;;) {
struct signalfd_siginfo s;
ssize_t n = read(fd, &s, sizeof s);
if (n == (ssize_t)sizeof s) {
if (s.ssi_signo == SIGTERM || s.ssi_signo == SIGINT) *parar = 1;
} else if (n == -1 && errno == EINTR) continue;
else if (n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) return 0;
else { errno = EIO; return -1; }
}
}
/* fin=-1: espera ociosa. fin>=0: plazo absoluto de una sesion. */
static int esperar45(int fd, short eventos, int control,
int *escucha, int *parar, int64_t fin)
{
for (;;) {
if (*parar && fin < 0) return 0;
int ms = -1;
if (fin >= 0) {
int64_t ahora = ahora45();
if (ahora < 0) return -1;
if (ahora >= fin) return 0;
ms = (int)(fin - ahora);
}
struct pollfd p[2] = {
{ .fd = fd, .events = eventos },
{ .fd = control, .events = POLLIN }
};
int r = poll(p, 2, ms);
if (r == -1) { if (errno == EINTR) continue; return -1; }
if (p[1].revents & (POLLERR | POLLHUP | POLLNVAL)) return -1;
if (p[1].revents & POLLIN) {
if (senales45(control, parar) == -1) return -1;
if (*parar && cerrar45(escucha) == -1) return -1;
}
if (*parar && fin < 0) return 0;
if (p[0].revents & POLLNVAL) { errno = EBADF; return -1; }
if (p[0].revents & (eventos | POLLERR | POLLHUP)) return 1;
/* Recalcular el plazo; una señal no lo reinicia. */
}
}
/* 0: sesion terminada (tambien timeout/error del cliente); -1: fallo interno. */
static int atender45(int fd, int control, int *escucha, int *parar)
{
static const char pedido[] = "GET / HTTP/1.0\r\n\r\n";
char entrada[sizeof pedido - 1];
size_t usados = 0;
int valido = 1;
int64_t ahora = ahora45();
if (ahora < 0) return -1;
int64_t fin = ahora + SESION45;
while (usados < sizeof entrada) {
int r = esperar45(fd, POLLIN, control, escucha, parar, fin);
if (r <= 0) return r;
ssize_t n = recv(fd, entrada + usados, sizeof entrada - usados, 0);
if (n > 0) {
usados += (size_t)n;
if (memcmp(entrada, pedido, usados) != 0) { valido = 0; break; }
} else if (n == 0) return 0;
else if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK) return 0;
}
char cuerpo[96], respuesta[512];
int nb = valido ? snprintf(cuerpo, sizeof cuerpo, "Hola desde trabajador %jd\n", (intmax_t)getpid()) :
snprintf(cuerpo, sizeof cuerpo, "Peticion fuera del contrato\n");
if (nb < 0 || (size_t)nb >= sizeof cuerpo) return -1;
int nr = snprintf(respuesta, sizeof respuesta,
"HTTP/1.0 %s\r\nContent-Type: text/plain\r\n"
"Content-Length: %d\r\nConnection: close\r\n\r\n%s",
valido ? "200 OK" : "400 Bad Request", nb, cuerpo);
if (nr < 0 || (size_t)nr >= sizeof respuesta) return -1;
size_t enviados = 0;
while (enviados < (size_t)nr) {
int r = esperar45(fd, POLLOUT, control, escucha, parar, fin);
if (r <= 0) return r;
ssize_t n = send(fd, respuesta + enviados, (size_t)nr - enviados, MSG_NOSIGNAL);
if (n > 0) enviados += (size_t)n;
else if (n == 0) return 0;
else if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK) return 0;
}
return 0;
}
static int trabajador45(int escucha, int aviso, const sigset_t *mascara)
{
int control = signalfd(-1, mascara, SFD_NONBLOCK | SFD_CLOEXEC);
int salida = EXIT_FAILURE, parar = 0;
if (control == -1) goto fin;
ssize_t n;
do { n = write(aviso, "R", 1); } while (n == -1 && errno == EINTR);
if (n != 1 || cerrar45(&aviso) == -1) goto fin;
for (;;) {
int r = esperar45(escucha, POLLIN, control, &escucha, ¶r, -1);
if (r == -1) goto fin;
if (r == 0) break;
int cliente = accept4(escucha, NULL, NULL, SOCK_NONBLOCK | SOCK_CLOEXEC);
if (cliente == -1) {
if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK ||
errno == ECONNABORTED) continue;
perror("accept4"); goto fin;
}
r = atender45(cliente, control, &escucha, ¶r);
if (cerrar45(&cliente) == -1 || r == -1) goto fin;
if (parar) break;
}
salida = EXIT_SUCCESS;
fin:
if (cerrar45(&aviso) == -1) salida = EXIT_FAILURE;
if (cerrar45(&escucha) == -1) salida = EXIT_FAILURE;
if (cerrar45(&control) == -1) salida = EXIT_FAILURE;
return salida;
}
static int avisar45(pid_t hijos[TRAB45], int signo)
{
int fallo = 0;
for (unsigned i = 0; i < TRAB45; ++i)
if (hijos[i] > 0 && kill(hijos[i], signo) == -1 && errno != ESRCH) {
perror("kill propio"); fallo = 1;
}
return fallo ? -1 : 0;
}
int main(void)
{
sigset_t mascara;
sigemptyset(&mascara); sigaddset(&mascara, SIGINT);
sigaddset(&mascara, SIGTERM); sigaddset(&mascara, SIGCHLD);
if (signal(SIGCHLD, SIG_DFL) == SIG_ERR ||
sigprocmask(SIG_BLOCK, &mascara, NULL) == -1) {
perror("senales"); return EXIT_FAILURE;
}
int control = -1, escucha = -1, aviso[2] = { -1, -1 };
int salida = EXIT_FAILURE, propio = 0, directorio = 0;
char dir[] = "/tmp/web45.XXXXXX";
struct sockaddr_un direccion = { .sun_family = AF_UNIX };
struct stat identidad;
pid_t hijos[TRAB45] = {0};
unsigned vivos = 0, preparados = 0;
int solicitud = 0, fase = 0, anunciado = 0;
int64_t limite = 0;
control = signalfd(-1, &mascara, SFD_NONBLOCK | SFD_CLOEXEC);
if (control == -1 || mkdtemp(dir) == NULL) { perror("preparar"); goto fin; }
directorio = 1;
int largo = snprintf(direccion.sun_path, sizeof direccion.sun_path, "%s/http.sock", dir);
if (largo < 0 || (size_t)largo >= sizeof direccion.sun_path) goto fin;
escucha = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
if (escucha == -1 || bind(escucha, (struct sockaddr *)&direccion, sizeof direccion) == -1) {
perror("socket/bind"); goto fin;
}
if (lstat(direccion.sun_path, &identidad) == -1) { perror("lstat"); goto fin; }
propio = 1;
if (listen(escucha, 16) == -1 || pipe2(aviso, O_NONBLOCK | O_CLOEXEC) == -1) {
perror("listen/pipe2"); goto fin;
}
limite = ahora45();
if (limite < 0) goto fin;
limite += 5000;
salida = EXIT_SUCCESS;
for (unsigned i = 0; i < TRAB45; ++i) {
pid_t p = fork();
if (p == -1) { perror("fork"); salida = EXIT_FAILURE; solicitud = 1; break; }
if (p == 0) {
if (cerrar45(&control) == -1 || cerrar45(&aviso[0]) == -1) _exit(2);
_exit(trabajador45(escucha, aviso[1], &mascara));
}
hijos[i] = p; ++vivos;
}
if (cerrar45(&aviso[1]) == -1) { salida = EXIT_FAILURE; solicitud = 1; }
while (vivos > 0) {
for (unsigned i = 0; i < TRAB45; ++i) if (hijos[i] > 0) {
int estado;
pid_t r;
do { r = waitpid(hijos[i], &estado, WNOHANG); } while (r == -1 && errno == EINTR);
if (r == hijos[i] || (r == -1 && errno == ECHILD)) {
if (r == -1 || !WIFEXITED(estado) || WEXITSTATUS(estado) != 0 || fase == 0)
salida = EXIT_FAILURE;
hijos[i] = 0; --vivos;
if (fase == 0) solicitud = 1;
} else if (r == -1) { perror("waitpid"); salida = EXIT_FAILURE; solicitud = 1; }
}
if (vivos == 0) break;
struct pollfd p[2] = {
{ .fd = control, .events = POLLIN },
{ .fd = aviso[0], .events = POLLIN }
};
int r = poll(p, 2, 100);
if (r == -1 && errno != EINTR) { perror("poll padre"); solicitud = 1; salida = EXIT_FAILURE; }
if (r > 0) {
if (p[0].revents & (POLLERR | POLLHUP | POLLNVAL)) { solicitud = 1; salida = EXIT_FAILURE; }
if ((p[0].revents & POLLIN) && senales45(control, &solicitud) == -1) {
solicitud = 1; salida = EXIT_FAILURE;
}
if (p[1].revents & (POLLERR | POLLNVAL)) { solicitud = 1; salida = EXIT_FAILURE; }
if (p[1].revents & (POLLIN | POLLHUP)) {
char datos[8];
ssize_t n = read(aviso[0], datos, sizeof datos);
if (n > 0) {
for (ssize_t j = 0; j < n; ++j) {
if (datos[j] != 'R' || preparados >= TRAB45) { solicitud = 1; salida = EXIT_FAILURE; }
else ++preparados;
}
} else if (n == 0) {
if (cerrar45(&aviso[0]) == -1) salida = EXIT_FAILURE;
if (preparados != TRAB45) { solicitud = 1; salida = EXIT_FAILURE; }
} else if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK) {
solicitud = 1; salida = EXIT_FAILURE;
}
}
}
int64_t ahora = ahora45();
if (ahora < 0) { solicitud = 1; salida = EXIT_FAILURE; }
if (!fase && !anunciado && preparados == TRAB45 && !solicitud) {
printf("WEB45 listo pid=%jd socket=%s trabajadores=%jd,%jd\n", (intmax_t)getpid(),
direccion.sun_path, (intmax_t)hijos[0], (intmax_t)hijos[1]);
if (fflush(stdout) == EOF) { solicitud = 1; salida = EXIT_FAILURE; }
anunciado = 1;
}
if (!fase && !anunciado && ahora >= limite) { solicitud = 1; salida = EXIT_FAILURE; }
if (!fase && solicitud) {
fase = 1;
if (cerrar45(&escucha) == -1) salida = EXIT_FAILURE;
if (propio) {
if (retirar45(direccion.sun_path, &identidad) == -1) { perror("retirar socket"); salida = EXIT_FAILURE; }
else propio = 0;
}
if (avisar45(hijos, SIGTERM) == -1) salida = EXIT_FAILURE;
if (cerrar45(&aviso[0]) == -1) salida = EXIT_FAILURE;
fprintf(stderr, "WEB45 drenando\n");
limite = ahora < 0 ? 0 : ahora + GRACIA45;
}
if (fase == 1 && (ahora < 0 || ahora >= limite)) {
salida = EXIT_FAILURE; fase = 2;
fprintf(stderr, "WEB45 agotada la gracia; SIGKILL\n");
if (avisar45(hijos, SIGKILL) == -1) salida = EXIT_FAILURE;
}
}
fin:
/* Antes del bucle no hay hijos. Dentro del bucle se recogen todos. */
if (cerrar45(&escucha) == -1) salida = EXIT_FAILURE;
if (cerrar45(&control) == -1) salida = EXIT_FAILURE;
if (cerrar45(&aviso[0]) == -1) salida = EXIT_FAILURE;
if (cerrar45(&aviso[1]) == -1) salida = EXIT_FAILURE;
if (propio && retirar45(direccion.sun_path, &identidad) == -1) { perror("retirar final"); salida = EXIT_FAILURE; }
if (directorio && rmdir(dir) == -1) { perror("rmdir propio"); salida = EXIT_FAILURE; }
return salida;
}Leer el flujo por responsabilidades
esperar45 concentra la espera y el procesamiento de control. atender45 conserva desplazamientos independientes de recepción y envío. trabajador45 es el propietario de cada conectado que acepta. main conserva el inventario de hijos, decide cuándo retirar el nombre y confirma sus salidas.
Las sesiones rechazadas no hacen caer el servicio. En cambio, una escucha inválida o un fallo de control interrumpen al trabajador: el supervisor detectará esa salida. Esta distinción evita tratar la desconexión ordinaria de un cliente como un fallo de toda la arquitectura.
El programa invalida cada variable antes de cerrar y no reintenta close. El directorio se crea con nombre nuevo y privado; antes de unlink se contrasta tipo, dispositivo e inodo. Esa comprobación no sería por sí sola una defensa frente a cambios concurrentes en un directorio hostil. Aquí la política presupone que otros procesos con el mismo usuario no manipulan el directorio privado.
8. Compilar, consultar y detener el servicio
gcc -std=c11 -Wall -Wextra -Wpedantic -O2 web45.c -o web45
./web45
# Esperar: WEB45 listo pid=... socket=/tmp/web45.XXXXXX/http.sock trabajadores=...,...Conserva la ruta, PID del supervisor y PIDs de trabajadores que imprime esta ejecución. No reutilices los de otra corrida. Cada arranque utiliza un directorio nuevo; no necesitas borrar un socket de un experimento anterior para iniciar este.
padre=12345 # reemplazar por el valor WEB45 de esta ejecucion
kill -TERM "$padre"
# La primera terminal muestra WEB45 drenando y termina tras recoger los hijos.Cuando la parada solicitada termina sin fallos, el supervisor devuelve cero. Una muerte inesperada de trabajador, un fallo interno o un escalado por gracia agotada producen retorno no cero. Esta convención corresponde al laboratorio y debe integrarse explícitamente con la política de reinicio del gestor de servicios.
No envíes SIGTERM a un PID ilustrativo sin reemplazarlo. El cliente de pruebas siguiente utiliza el proceso que acaba de lanzar y recoge ese mismo supervisor. Permite repetir el ensayo sin depender de copiar números entre terminales.
Ctrl+C en la terminal puede enviar SIGINT a todo el grupo de primer plano. Para observar primero la propagación desde el supervisor y su política de recogida, envía la señal solo a su PID. El código considera fallo cualquier salida de trabajador que observe antes de tener una solicitud de parada.
9. Cliente verificable y peticiones fragmentadas
Guarda probar45.py y ejecútalo con el binario recién compilado. Usa dos clientes concurrentes y veinte conexiones independientes. Alterna sendall del mensaje completo con envíos de un byte; el sistema puede agrupar esos envíos, por lo que esta variante comprueba tolerancia al fragmentado sin prometer un recv por cada send.
import argparse
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
import os
import re
import selectors
import signal
import socket
import subprocess
import time
PEDIDO = b"GET / HTTP/1.0\r\n\r\n"
def consultar(ruta, fragmentado=False):
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.settimeout(5)
s.connect(ruta)
if fragmentado:
for byte in PEDIDO:
s.sendall(bytes([byte]))
else:
s.sendall(PEDIDO)
s.shutdown(socket.SHUT_WR)
respuesta = bytearray()
while True:
bloque = s.recv(1024)
if not bloque:
break
respuesta.extend(bloque)
if len(respuesta) > 2048:
raise ValueError("respuesta fuera de limite")
cabecera, cuerpo = bytes(respuesta).split(b"\r\n\r\n", 1)
lineas = cabecera.split(b"\r\n")
if lineas[0] != b"HTTP/1.0 200 OK":
raise ValueError("estado HTTP inesperado")
campos = dict(linea.split(b": ", 1) for linea in lineas[1:])
if campos.get(b"Connection") != b"close" or int(campos[b"Content-Length"]) != len(cuerpo):
raise ValueError("framing de respuesta invalido")
m = re.fullmatch(rb"Hola desde trabajador ([0-9]+)\n", cuerpo)
if m is None:
raise ValueError("cuerpo inesperado")
return int(m[1])
def listo(proceso):
# Lectura binaria: sin buffering de TextIOWrapper.
fin = time.monotonic() + 7
datos = bytearray()
with selectors.DefaultSelector() as sel:
sel.register(proceso.stdout, selectors.EVENT_READ)
while b"\n" not in datos:
resto = fin - time.monotonic()
if resto <= 0 or not sel.select(resto):
raise TimeoutError("sin confirmacion de arranque")
bloque = os.read(proceso.stdout.fileno(), 256)
if not bloque:
raise ValueError("supervisor termino antes de estar listo")
datos.extend(bloque)
if len(datos) > 1024:
raise ValueError("anuncio demasiado grande")
m = re.fullmatch(rb"WEB45 listo pid=([0-9]+) socket=(\S+) trabajadores=([0-9]+),([0-9]+)\n", bytes(datos))
if m is None or int(m[1]) != proceso.pid:
raise ValueError("anuncio incompatible")
return os.fsdecode(m[2]), {int(m[3]), int(m[4])}
def main():
p = argparse.ArgumentParser()
p.add_argument("servidor", type=Path)
a = p.parse_args()
proceso = subprocess.Popen([str(a.servidor.resolve(strict=True))],
stdout=subprocess.PIPE, start_new_session=True)
ruta = None
try:
ruta, trabajadores = listo(proceso)
with ThreadPoolExecutor(max_workers=2) as grupo:
resultados = list(grupo.map(lambda i: consultar(ruta, i % 2 == 0), range(20)))
if not set(resultados) <= trabajadores:
raise ValueError("respondio un PID ajeno al grupo")
os.kill(proceso.pid, signal.SIGTERM)
if proceso.wait(timeout=8) != 0:
raise ValueError("parada no exitosa")
if Path(ruta).exists() or Path(ruta).parent.exists():
raise ValueError("recursos publicados sin retirar")
print("20 respuestas verificadas; PIDs observados:", sorted(set(resultados)))
print("Supervisor recogido; socket y directorio retirados")
finally:
# El grupo pertenece exclusivamente a esta prueba.
try:
os.killpg(proceso.pid, signal.SIGKILL)
except ProcessLookupError:
pass
proceso.wait()
proceso.stdout.close()
if __name__ == "__main__":
main()python3 probar45.py ./web45El cliente valida estado, Content-Length, cuerpo, identidad del trabajador y EOF. shutdown(SHUT_WR) comunica que no enviará más, sin cerrar su lectura de la respuesta. Esta media desconexión no equivale a que el servidor deba abandonar una petición completa ya recibida.
No se exige observar ambos PIDs: el planificador y el tiempo de cada solicitud pueden favorecer a uno. La prueba verifica que quien responda pertenece al grupo y que cada sesión conserva su contenido. Para demostrar ocupación simultánea de ambos hace falta otra prueba, con un punto de sincronización que confirme dos accept.
El grupo de procesos nuevo permite que el controlador termine sus propios participantes si falla una aserción. Un SIGKILL de emergencia no ejecuta la limpieza del supervisor: una prueba fallida puede dejar su directorio privado para inspección. El programa verifica la retirada automática únicamente en la parada normal.
10. Clientes lentos, capacidad y contrapresión
Con dos trabajadores secuenciales, dos clientes que mantengan peticiones incompletas ocupan toda la capacidad de ejecución. Una tercera conexión puede completarse a nivel de transporte y seguir esperando en la cola de escucha. connect exitoso no confirma que un trabajador ya haya comenzado a leer.
El backlog de listen no es un número de trabajadores ni una cola ilimitada de peticiones procesables. Tampoco convierte un proceso ocupado en uno disponible. Al agotar las colas o los descriptores aparecen errores o esperas adicionales que el cliente debe limitar con su propio plazo.
El límite de tres segundos evita que una sesión lenta ocupe un trabajador sin fin. No garantiza una latencia máxima para todas las conexiones pendientes: el reloj de la sesión empieza al aceptar y el cliente puede haber esperado antes en la cola. Para limitar el tiempo extremo a extremo se necesita presupuesto en cada tramo y un límite del cliente.
| Recurso | Límite útil | Al agotarse |
|---|---|---|
| Sesiones activas por trabajador. | Una en este programa. | El trabajador deja de aceptar hasta liberar su sesión. |
| Bytes de petición. | 18 para el contrato fijo. | No se reserva memoria por tamaños enviados por el cliente. |
| Tiempo de sesión. | 3000 ms absolutos. | Se cierra el conectado; se recupera capacidad. |
| Cola de despacho central. | Capacidad explícita si se añade ese modelo. | Pausar admisión o rechazar según política; no acumular sin límite. |
| Trabajo de CPU. | Presupuesto o aislamiento separado. | Evitar que impida observar control y plazos. |
Para atender muchas conexiones lentas sin un proceso por conexión, cada trabajador puede integrar varios conectados con epoll. Entonces los desplazamientos, plazos y buffers deben pertenecer a cada sesión, no a una única variable global. El proyecto del tema 49 desarrolla ese tipo de bucle.
11. Drenar conexiones con un plazo
Drenar significa dejar de admitir trabajo nuevo y permitir que el trabajo ya admitido llegue a una condición definida. En el laboratorio, el supervisor cierra su referencia de escucha, retira el nombre público y solicita drenaje a los trabajadores. Cada uno cierra su referencia de escucha al leer la señal; si tenía una sesión, conserva su conectado hasta terminarla o alcanzar su plazo.
SERVICIO ── solicitud de parada ──► DRENAJE ── todos recogidos ──► FIN
│
└── gracia agotada ──► SIGKILL ──► RECOGIDA
trabajador OCIOSO + drenaje → cerrar escucha → salir
trabajador ACTIVO + drenaje → cerrar escucha → terminar/limitar sesion → salirRetirar la ruta impide nuevas búsquedas de ese nombre, pero no destruye conectados establecidos. Cerrar la escucha tampoco equivale a cerrar todas las conversaciones: son recursos distintos. Las conexiones todavía pendientes no tienen una promesa de respuesta y pueden fallar al desaparecer la última referencia de escucha.
La parada de un grupo no ocurre en un instante atómico compartido. Una conexión puede ser aceptada mientras llega la orden de drenaje. Si ya fue aceptada, el trabajador la trata como sesión activa y queda sujeta a su plazo. Un sistema que necesita un corte exacto debe definir un punto de admisión y coordinar su confirmación con todos los participantes.
El supervisor concede cinco segundos y luego solicita SIGKILL a hijos propios que aún no haya recogido. SIGKILL no ejecuta limpieza de aplicación ni revierte efectos externos. La recogida sigue siendo obligatoria y un proceso en espera no interrumpible del núcleo puede retrasarla: la gracia limita la espera cooperativa, no promete un tiempo físico absoluto de desaparición.
Con keep-alive habría que impedir nuevas peticiones sobre conexiones antiguas, no solo nuevos accept. Con WebSocket o respuestas en streaming habría que definir avisos de cierre y duración máxima. El ejemplo evita esos protocolos para hacer verificable la frontera entre sesión activa y conexión nueva.
12. Detectar trabajadores caídos y recoger procesos
SIGCHLD es un aviso para revisar estados; no contiene necesariamente un mensaje separado por cada hijo. El supervisor conserva PIDs propios y ejecuta waitpid con WNOHANG. También revisa periódicamente el inventario, por lo que no cuenta señales como si fueran salidas.
Una salida no solicitada, aunque tenga código cero, es un fallo del conjunto de trabajadores esperado. Este laboratorio aplica una política sencilla: deja de servir, drena al resto y retorna error. No reinicia automáticamente hijos. Eso permite comprobar un resultado concreto sin ocultar fallos mediante reinicios continuos.
En producción puede elegirse reponer un trabajador. Se necesita limitar la frecuencia de reinicio, distinguir fallos transitorios de errores de configuración y definir cuándo declarar el servicio no disponible. Una tormenta de reinicios consume recursos y no hace saludable un proceso que falla siempre al arrancar.
Al morir un trabajador, el núcleo cierra sus descriptores. Una respuesta parcial no se vuelve completa por ese cierre. Si el cliente no recibió una respuesta válida, su resultado puede ser desconocido, especialmente cuando se habían producido efectos externos. Las reglas de reintento e idempotencia del tema 43 siguen aplicándose.
Si muere el supervisor con SIGKILL, los trabajadores de este ejemplo no reciben automáticamente drenaje. Para cubrir esa dirección del fallo hace falta un gestor que administre todo el grupo o un mecanismo adicional de detección de la pérdida del supervisor. La prueba integrada crea un grupo propio para poder terminar sus participantes si falla el experimento.
13. Cambiar de generación sin mezclar estados
Una recarga ordenada introduce dos generaciones temporalmente: la antigua termina trabajo activo y la nueva acepta trabajo con la configuración nueva. No consiste en modificar unas variables globales del supervisor y suponer que los hijos ya las ven.
- Leer y validar la nueva configuración sin destruir la que funciona.
- Crear recursos y trabajadores de una nueva generación identificada.
- Esperar confirmaciones READY con versión y generación.
- Habilitar la nueva admisión y solicitar drenaje de la generación anterior.
- Aplicar un límite a las sesiones antiguas y recoger todos los hijos retirados.
Si la preparación nueva falla, la política puede conservar la generación anterior. Para que ese resultado sea posible, no debe haberse destruido antes su único recurso de escucha. También se deben separar recursos compartidos por generaciones de recursos que pertenecen a una sola.
La identidad de configuración debe viajar con registros y métricas: ver dos PIDs no dice cuál aplica una regla concreta. Un número de generación ayuda a distinguir una respuesta tardía de un trabajador antiguo de una respuesta del grupo actual.
Como ejemplo real, la documentación de control de nginx describe la creación de trabajadores nuevos al recargar y la retirada gradual de los anteriores. Ese servidor usa señales y políticas propias; en particular, no hay que extrapolar el significado de SIGTERM de este laboratorio a nginx.
El programa web45 no implementa recarga. Añadir una señal HUP sin mensajes de preparación, identidad de generaciones y política de fallo produciría una apariencia de recarga sin sus garantías.
14. Reparto explícito mediante SCM_RIGHTS
Un aceptador central puede observar cargas y elegir un trabajador. Para entregarle una conexión ya aceptada, envía una referencia mediante datos auxiliares SCM_RIGHTS en un canal Unix; se describe en unix(7). El descriptor recibido puede tener un número diferente y remite a la misma descripción abierta.
aceptador: accept → conectado C → elegir trabajador con credito
aceptador: sendmsg(canal, JOB(id, generacion), SCM_RIGHTS(C))
trabajador: recvmsg → validar mensaje y derechos → registrar propietario
trabajador: confirmar RECEIVED(id) → atender → informar DONE(id)
aceptador: cerrar copia local segun el protocolo y actualizar creditoSi se conserva una copia en el aceptador mientras se espera confirmación, esa copia también mantiene viva la conexión. Debe existir un plazo y una política de cierre para cada transición. sendmsg exitoso no demuestra que el trabajador leyó o ejecutó el trabajo.
Hay que comprobar MSG_CTRUNC, nivel y tipo de cada control, longitud, cantidad esperada de descriptores y banderas del recibido. Todo descriptor inesperado o perteneciente a un mensaje rechazado debe cerrarse. En Linux, MSG_CMSG_CLOEXEC permite pedir cierre al exec en la recepción; esto no reemplaza la validación del protocolo.
Los derechos entregan acceso a un recurso: se autentica el canal y se limita qué recursos puede transferir cada participante. El proceso que recibe no debe empezar a usar un entero sin verificar de dónde vino y cuál es el estado esperado del mensaje.
Un crédito puede representar una ranura disponible del trabajador. Con dos créditos no se deben encolar diez mil conectados suponiendo que la memoria es infinita. Si todos los trabajadores agotan crédito, el aceptador debe pausar admisión o rechazar bajo una política definida.
RECEIVED y DONE son confirmaciones distintas. Si se pierde DONE después de una operación con efectos, volver a asignarla puede duplicarlos. Transferir un descriptor no proporciona semántica de «exactamente una vez» para el trabajo de aplicación.
15. Simular admisión, drenaje y referencias
Este modelo didáctico separa la referencia de escucha del supervisor de las de sus dos trabajadores. Cada trabajador tiene una ranura. Puedes cerrar solo la referencia del supervisor y comprobar que aún quedan trabajadores capaces de aceptar, o solicitar un drenaje completo y observar la finalización de sesiones activas.
Supervisor—
Referencias de escucha—
Trabajador A—
Trabajador B—
Sesiones completadas / abandonadas—
Hijos recogidos—
—
El botón de nueva conexión elige la primera ranura disponible para que el resultado sea fácil de seguir. Es una regla del simulador; el sistema real no garantiza ese orden. No se modela la cola de listen ni el tiempo del núcleo. Agotar gracia representa la pérdida de la sesión activa al terminar forzosamente un trabajador, no la reversión de efectos ya producidos.
16. Observar procesos y conexiones reales
padre=12345
hijo_a=12346
hijo_b=12347
ps -o pid,ppid,stat,wchan:24,cmd -p "$padre,$hijo_a,$hijo_b"
lsof -nP -a -p "$padre,$hijo_a,$hijo_b" -U
ss -xlnp
ls -l "/proc/$hijo_a/fd"Durante servicio, las referencias heredadas de escucha se relacionan con el mismo recurso de socket. Los conectados que acepte cada trabajador son otros recursos. El entero del descriptor puede coincidir entre procesos por casualidad, sin identificar la misma conversación.
ensayo=$(mktemp -d)
strace -ff -tt -T -yy -s 64 -o "$ensayo/traza" -e trace=socket,bind,listen,clone,clone3,accept4,poll,signalfd4,read,write,recvfrom,sendto,close,kill,wait4,unlink,rmdir ./web45Con probar45.py guardado en el directorio actual, consulta la ejecución trazada desde otra terminal. Aquí se importa solo su función de consulta; el programa de pruebas completo crea su propio servidor.
ruta=/tmp/web45.ABC123/http.sock # reemplazar por la ruta de la corrida trazada
python3 -c 'import sys; from probar45 import consultar; print(consultar(sys.argv[1], True))' "$ruta"Solicita luego la parada de ese supervisor. Busca la escucha antes de fork, los accept4 en hijos, los cierres por rol, la retirada del nombre y los wait4 del padre. El programa no utiliza sendmsg para despacho: esa operación pertenece a la alternativa de SCM_RIGHTS.
Para capturar sesiones que terminan muy rápido hace falta un cliente que mantenga un prefijo incompleto. En lugar de una pausa arbitraria, confirma el accept con instrumentación de prueba o con un punto de sincronización. Conectar dos sockets no demuestra por sí solo que los dos ya fueron aceptados.
El tema 44 explica las limitaciones de estas capturas. No compares rendimiento bajo strace como si fuera una ejecución sin instrumentación. Una espera en poll puede ser una sesión ociosa saludable; se interpreta según su conjunto de descriptores y el estado del trabajador.
17. Pruebas de integración y fallos
| Ensayo | Resultado esperado | Qué valida |
|---|---|---|
| Veinte consultas completas y fragmentadas. | 200, longitud y cuerpo correctos; PID conocido; EOF. | Integridad por sesión sin exigir alternancia. |
| Enviar solo GET y mantener escritura abierta. | Cierre de esa sesión al vencer su plazo. | El cliente lento no retiene indefinidamente una ranura. |
| Prefijo incompatible con el contrato. | 400 y cierre. | Rechazo acotado sin derribar al trabajador. |
| Cerrar antes de completar la petición. | Se abandona la sesión y el servicio responde a otro cliente. | EOF no provoca bucle ni caída global. |
| Desconectar sin leer respuesta. | El trabajador sobrevive y atiende después. | MSG_NOSIGNAL y error de envío local a la sesión. |
| Drenar con una sesión activa confirmada. | Se retira la ruta; esa sesión puede completar dentro del plazo. | Escucha y conectado tienen vidas distintas. |
| Matar un trabajador propio. | Supervisor drena al restante y termina con error. | Detección y política de fallo del grupo. |
| Detener un trabajador con SIGSTOP y solicitar parada. | Gracia agotada, SIGKILL y recogida; retorno de fallo. | La señal cooperativa no basta para un proceso detenido. |
| Fallar segundo fork en una copia de prueba. | Primer hijo terminado y recogido; recursos propios retirados. | Limpieza del arranque parcial. |
Sincronizar las pruebas sensibles
Para la prueba de drenaje activo, una copia de prueba puede escribir un byte en un pipe de instrumentación inmediatamente después de accept4. El controlador espera ese byte con plazo, envía SIGTERM al supervisor, espera WEB45 drenando y completa los bytes pendientes por el conectado ya establecido. Esa sincronización distingue una sesión activa de una conexión todavía en backlog.
Para comprobar recepción y envío parciales de manera determinista, limita las llamadas reales recv y send a un byte en una copia de prueba. Introduce también retornos -1 con errno=EINTR sin afirmar progreso ficticio. Las mismas peticiones deben producir respuestas completas y Content-Length correcto.
En todos los fallos comprueba descriptores, hijos recogidos y nombres propios. No borres rutas por patrones amplios ni señales PIDs obtenidos de otro ensayo. El controlador debe poder terminar su grupo propio si una aserción falla, sin afectar a otro servidor en ejecución.
La prueba básica no sustituye estas inyecciones. Tampoco un conjunto de pruebas de funcionamiento demuestra seguridad de un analizador HTTP general: este programa reconoce un contrato mucho más pequeño.
18. Errores frecuentes y criterios de diseño
| Error | Consecuencia | Criterio correcto |
|---|---|---|
| Cerrar solo la escucha del padre. | Los hijos siguen aceptando. | Contabilizar todas las referencias y propagar control. |
| Tratar EAGAIN de accept como caída. | Un trabajador termina por una competencia normal. | Volver al bucle de espera. |
| Reiniciar plazo por cada byte. | Un cliente lento prolonga indefinidamente su ocupación. | Plazo absoluto desde admisión. |
| Usar un contador global tras fork. | Cada hijo muestra un total distinto. | Mensajes o memoria compartida sincronizada. |
| Escribir el número de descriptor en un pipe. | El receptor usa un descriptor local distinto o inválido. | Herencia controlada o SCM_RIGHTS con protocolo. |
| Suponer que salir equivale a recoger. | Quedan estados de hijo sin consumir. | Mantener inventario y waitpid. |
| Confundir conexión con petición. | Keep-alive rompe el supuesto de balance. | Definir unidad de admisión y drenaje. |
| Reintentar tras respuesta perdida sin identidad. | Se pueden duplicar efectos. | Contrato de idempotencia y resultado desconocido. |
| Reiniciar hijos sin límite. | Se oculta un fallo permanente y se agotan recursos. | Presupuesto de reinicios y señal de no disponibilidad. |
| Borrar el nombre del socket desde cada hijo. | Un trabajador retira el servicio de los demás. | Un responsable de publicación y retirada. |
Una arquitectura es revisable cuando se puede responder quién posee cada descriptor, qué transición libera capacidad, qué observación confirma la salida y qué límite evita una espera sin fin. El número de procesos es solo uno de sus parámetros.
Para medir capacidad, separa establecimiento, tiempo en cola, servicio y finalización. Un PID distinto en cada respuesta no demuestra mayor throughput; hacen falta carga comparable, resultados completos y CPU de todos los participantes. Reutiliza el método del tema 44 y define las partes incluidas en cada duración.
19. Resumen, repaso y práctica
El servidor combina herencia de escucha, aceptación no bloqueante, confirmación por pipe, control mediante señales y recogida explícita de hijos. La atención está acotada por tamaño, capacidad y tiempo. El drenaje retira admisión y conserva temporalmente las sesiones activas; los fallos se distinguen por sesión, trabajador y conjunto.
- Recurso: escucha y conectado tienen propietarios y vidas distintos.
- Control: preparación y drenaje son transiciones explícitas, observables durante las esperas.
- Capacidad: una cola del núcleo no sustituye ranuras de ejecución disponibles.
- Finalización: solicitar, salir y recoger son pasos diferentes.
- Extensión: balance central y recarga requieren protocolos adicionales.
Preguntas de repaso
1. ¿Qué coordina el supervisor?
Recursos comunes, preparación, inventario de hijos y política de parada o recuperación. La atención de cada sesión pertenece a un trabajador.
2. ¿Por qué dos procesos pueden compartir una escucha?
fork hereda referencias al socket preparado. accept entrega conectados distintos; no difunde cada petición a todos.
3. ¿Cerrar en el padre cierra en los hijos?
No. Cada proceso conserva sus referencias hasta cerrarlas o terminar.
4. ¿Qué significa EAGAIN después de un despertar?
La conexión pudo ser consumida por otro trabajador. La escucha no bloqueante permite volver a esperar.
5. ¿La distribución es round-robin?
No hay esa garantía. El simulador usa un orden pedagógico y el programa real compite por la escucha.
6. ¿Qué certifica R?
Que ese trabajador alcanzó el punto de preparación del código. No garantiza su salud futura ni que ya atendió clientes.
7. ¿Por qué signalfd se incluye al esperar un cliente?
Permite observar drenaje mientras la sesión espera bytes o capacidad de envío.
8. ¿Un byte de un cliente renueva sus tres segundos?
No. Todas las operaciones de esa sesión usan el mismo plazo absoluto.
9. ¿Una conexión exitosa ya fue aceptada?
No necesariamente. Puede estar pendiente en la cola del núcleo.
10. ¿Qué conserva un trabajador activo al drenar?
Su conectado y el tiempo restante. Cierra su referencia de escucha y no busca nuevas sesiones.
11. ¿Qué significa SIGCHLD para el padre?
Que debe revisar waitpid. No se utiliza como contador exacto de hijos terminados.
12. ¿Qué pasa si cae un trabajador en este programa?
El supervisor detiene el servicio completo, drena al resto y devuelve error. No repone trabajadores.
13. ¿Para qué sirve SCM_RIGHTS?
Para transferir referencias a recursos mediante un canal Unix. No copia una respuesta HTTP ni confirma ejecución de una tarea.
14. ¿Qué falta para una recarga con garantías?
Preparación de una generación nueva, identidad de configuración, política de fallo y drenaje acotado de la anterior.
15. ¿La gracia garantiza desaparición instantánea?
No. Al vencer se solicita SIGKILL y se sigue recogiendo. La espera en el núcleo puede retrasar la salida efectiva.
Para practicar y ampliar
- Dibuja las referencias de cada proceso antes y después de fork.
- Ejecuta el cliente y contrasta sus PIDs con ps y lsof.
- Fuerza recv y send de un byte y comprueba las respuestas.
- Prueba EOF parcial, prefijo inválido y desconexión durante envío.
- Sincroniza dos accept y demuestra que dos clientes lentos ocupan las dos ranuras.
- Comprueba que el plazo no se renueva al recibir otro byte.
- Drena una sesión confirmada y verifica que puede terminar por su conectado aunque desaparezca la ruta.
- Detén un hijo con SIGSTOP y observa escalado y recogida.
- Diseña mensajes de preparación con PID, versión y generación.
- Propón créditos y estados para un aceptador central con transferencia de descriptores.
- Añade varios conectados por trabajador con buffers y plazos independientes.
- Define métricas por generación sin usar contadores globales privados tras fork.
El tema 46 aplica IPC en bases de datos: búferes compartidos, colas de trabajo y la diferencia entre que un cambio sea visible a otro proceso y que sea persistente frente a un fallo.