Semana 5 — Estilos distribuidos: servicios, microservicios y eventos
Objetivos
- Explicar qué cambia cuando una llamada cruza la red (latencia, fallas parciales, concurrencia real) usando las falacias de la computación distribuida.
- Comparar los estilos service-based y de microservicios por su granularidad, por quién es owner de los datos y por lo que cuestan de operar.
- Describir el estilo event-driven en sus dos topologías, broker y mediator, y distinguir un evento de un comando.
- Elegir un estilo para un sistema a partir de sus escenarios de calidad y de su equipo, y defender la elección frente a una alternativa.
Sesión A — Estilos distribuidos: service-based y microservicios; las falacias de la computación distribuida
Lecturas:
- Richards y Ford, Fundamentals of Software Architecture (2.ª ed.), cap. 14 Service-Based Architecture Style y cap. 18 Microservices Architecture.
- Lectura libre: James Lewis y Martin Fowler, Microservices (2014).
Lecturas complementarias:
- Software Architecture in Practice, cap. 17 The Cloud and Distributed Computing.
- Chris Richardson, microservices.io: los patrones Database per Service y API Gateway.
- Kleppmann y Riccomini, Designing Data-Intensive Applications (2.ª ed.), cap. 1, la sección Distributed Versus Single-Node Systems.
Temas:
- Por qué distribuir: escalar una parte sin escalar todo, desplegar una parte sin desplegar todo, aislar una falla, que varios equipos trabajen sin pisarse, o porque la carga ya no cabe en una máquina. Cada razón es un escenario de calidad; sin escenario, no hay razón.
- Lo que cambia al cruzar la red. Una llamada local tarda nanosegundos y termina o lanza un error; una remota tarda milisegundos y además puede no llegar, llegar y no responder, responder tarde o llegar dos veces. Quien llama no puede distinguir “no llegó” de “llegó y la respuesta se perdió”.
- Las ocho falacias de la computación distribuida (Deutsch y otros, Sun): la red es confiable; la latencia es cero; el ancho de banda es infinito; la red es segura; la topología no cambia; hay un solo administrador; el costo de transporte es cero; la red es homogénea. Cada una es un supuesto que un diseño monolítico hace gratis y uno distribuido tiene que pagar.
- Service-based: pocos servicios grandes (de cuatro a doce, por dominio), cada uno desplegado por separado, normalmente con una base de datos compartida o partida por esquemas, detrás de una interfaz común. Es el paso más barato desde un modular monolith: se gana despliegue y escalado por partes sin renunciar todavía a las transacciones de una sola base de datos.
- Microservicios: servicios pequeños, cada uno con un solo propósito y con sus propios datos (nadie más lee su base), que se despliegan y se escalan por separado y son de un equipo. El límite de un servicio es un bounded context: un modelo del dominio con significado propio.
- Lo que cuestan los microservicios: los datos ya no se pueden unir con un
JOINni proteger con una transacción (semanas 12 y 13); cada llamada puede fallar (semana 14); hay que operar muchos despliegues, y seguir una petición exige observabilidad. Granularidad: qué empuja a partir (tasas de cambio distintas, escalado distinto, aislamiento) y qué empuja a unir (transacciones, flujos que conversan mucho, datos compartidos). - Comunicación síncrona (petición y respuesta, HTTP o gRPC) y asíncrona (mensajes). API gateway: una entrada única que enruta, autentica y limita.
- En Tinkuy: ¿qué parte se beneficia de salir del monolito? Los pagos (dependen de un servicio externo lento, tienen requisitos de seguridad propios) son el candidato de P4. El catálogo, que se lee mil veces más de lo que se escribe, se resuelve antes con una réplica y una cache (P3) que con un servicio.
- Error común: el monolito distribuido. Servicios que comparten tablas, que deben desplegarse juntos o que se llaman en cadena de forma síncrona tienen los costos de los dos mundos y los beneficios de ninguno.
- Error común: partir por sustantivos (“servicio de usuarios”, “servicio de órdenes”) antes de entender el dominio. Los límites equivocados entre servicios cuestan mucho más de mover que entre módulos.
Sesión B — Event-driven: broker y mediator · Cómo se elige un estilo
Lecturas:
- Fundamentals of Software Architecture (2.ª ed.), cap. 15 Event-Driven Architecture Style y cap. 19 Choosing the Appropriate Architecture Style.
- Lectura libre: Martin Fowler, What do you mean by “Event-Driven”? (2017).
Lecturas complementarias:
- Fundamentals of Software Architecture (2.ª ed.), cap. 16 Space-Based Architecture Style y cap. 17 Orchestration-Driven Service-Oriented Architecture, para ver dos estilos que el curso no desarrolla.
- Fallacies of distributed computing, con el origen de cada falacia.
Temas:
- Evento y comando. Un evento dice que algo ya pasó (
OrderPaid) y quien lo publica no sabe ni le importa quién lo escucha. Un comando pide que algo pase (ChargeCard) y va dirigido a alguien de quien se espera un resultado. La diferencia decide quién conoce a quién. - Event-driven: componentes que reaccionan a eventos en vez de llamarse. El productor publica y sigue; los consumidores procesan cuando pueden. Se gana desacoplamiento en el tiempo (el consumidor puede estar caído), capacidad de absorber picos y facilidad para agregar un consumidor nuevo. Se paga con consistencia eventual, con flujos difíciles de seguir y con un manejo de errores que hay que diseñar.
- Topología broker: no hay coordinador; cada componente escucha eventos y publica otros, en cadena. Muy desacoplado y escalable; nadie tiene el flujo completo, así que cuesta saber en qué estado quedó un proceso y qué hacer si un paso falla.
- Topología mediator: un coordinador conoce el flujo y envía comandos a cada paso. Se gana control, manejo de errores y la posibilidad de reanudar; se paga con el acoplamiento al coordinador, que además puede convertirse en cuello de botella. (El mismo par aparece como coreografía y orquestación en las sagas, semana 12.)
- Los cuatro usos de “event-driven” que distingue Fowler: notificación de eventos, transferencia de estado en el evento, event sourcing y CQRS. Los dos últimos se ven en la semana 13.
- Lo que un diseño con eventos debe responder: ¿qué pasa si el consumidor falla a la mitad?, ¿y si el mensaje llega dos veces?, ¿y si llegan en otro orden? Las respuestas (reintentos, idempotencia, orden por clave) son el tema de las semanas 12 y 13.
- En Tinkuy: después de pagar, hoy se envía el correo dentro de la petición. Con un evento
OrderPaid, las notificaciones, los reportes y un futuro programa de puntos lo escuchan sin que órdenes lo sepa. - Cómo se elige un estilo. No hay estilo mejor: cada uno puntúa distinto en cada atributo. El procedimiento: tomar los escenarios (A, A) del utility tree; para cada estilo candidato, decir cómo los cumple o por qué no; sumar el costo (operación, tamaño del equipo, experiencia); elegir y escribir qué se sacrifica. Un sistema puede usar un estilo distinto en cada parte.
- La pregunta que más descarta: ¿el equipo puede operar esto? Un equipo de cinco personas no tiene la organización que justifica veinte servicios (ley de Conway, semana 15).
- Error común: usar eventos donde quien llama necesita la respuesta para continuar. Lo que queda es una llamada síncrona disfrazada, más lenta y más difícil de depurar.
- Error común: elegir el estilo por la empresa que lo hizo famoso. El contexto de esa empresa (miles de ingenieros, cientos de despliegues al día) es parte de la decisión.
Laboratorio — El mismo caso en dos estilos, comparado con escenarios
Referencias: Fowler, What do you mean by “Event-Driven”?; documentación de NATS. Material: code/week-05/. En parejas.
- El caso de
code/week-05/: después de una compra hay que enviar el correo, actualizar el reporte de ventas y sumar puntos al comprador. Viene implementado dos veces:sync/(el módulo de órdenes llama a los tres, uno tras otro) yevents/(publicaOrderPaiden NATS y tres consumidores reaccionan). Leer ambas versiones y dibujar quién conoce a quién en cada una. - Correr las dos con
make syncymake eventsy hacer diez compras en cada una. Medir con el script de la carpeta cuánto tarda en responder la compra en cada versión. - Hacer lento un paso (
EMAIL_LATENCY_MS=800) y repetir. ¿Qué le pasa a la latencia de la compra en cada versión? - Hacer fallar un paso (
POINTS_FAIL=1). Ensync/, ¿qué recibe el comprador y en qué estado queda la compra? Enevents/, ¿qué pasa con el mensaje que no se pudo procesar? Mirar el estado del consumidor connats consumer info. - Detener un consumidor, hacer cinco compras y volver a iniciarlo. ¿Se perdieron los cinco eventos? ¿Por qué?
- Agregar un cuarto efecto (registrar la compra en un archivo de auditoría) a cada versión. Contar los archivos existentes que tocaron en cada una.
- Escribir tres escenarios (uno de rendimiento, uno de disponibilidad y uno de modificabilidad) y llenar una tabla: qué versión cumple cada uno y a qué costo. Agregar una fila para lo que la versión con eventos hace más difícil: saber si los tres efectos ya ocurrieron.
- Discusión con otra pareja: para Tinkuy, hoy, ¿cuál elegirían? ¿Qué tendría que cambiar para elegir la otra?
Entregas
- P1 · Módulos con límites se entrega esta semana (
projects/p1-modulos/README.md). - Se publica P2 · La apertura de ventas (
projects/p2-apertura-de-ventas/README.md), que se entrega en la semana 8.
Preguntas de repaso
- Un servicio llama a otro y no recibe respuesta en dos segundos. Enumeren las cosas distintas que pudieron pasar. ¿Cuáles puede distinguir quien llamó?
- Elijan tres falacias y den, para cada una, un error de diseño concreto que produce.
- ¿En qué se diferencian service-based y microservicios respecto de los datos? ¿Qué se pierde al pasar del primero al segundo?
- Clasifiquen como evento o comando y justifiquen:
SendConfirmationEmail,SeatReserved,RefundRequested,ReserveSeat. - Un proceso de cinco pasos falla en el tercero. ¿Qué topología, broker o mediator, hace más fácil saber qué pasó y compensar? ¿Qué se paga por eso?
- Describan un monolito distribuido y dos señales que permiten reconocerlo.
Código de la semana
Compilar y probar dentro del contenedor del curso con make y make test.
Ejemplos (27)Pruebas (5)Compilación (3)
Ejemplos
Los programas que usan los apuntes y la clase.
-- Semana 5: el caso de "después de una compra", en pequeño. No es el esquema
-- de Tinkuy: tiene lo justo para comparar las dos versiones.
-- Lo que es del módulo de órdenes.
CREATE TABLE concerts (
id integer PRIMARY KEY,
title text NOT NULL,
price_cents integer NOT NULL CHECK (price_cents > 0)
);
CREATE TABLE orders (
id integer GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
concert_id integer NOT NULL REFERENCES concerts (id),
buyer_email text NOT NULL,
buyer_name text NOT NULL,
quantity integer NOT NULL CHECK (quantity BETWEEN 1 AND 6),
total_cents integer NOT NULL,
status text NOT NULL CHECK (status IN ('paid')),
created_at timestamptz NOT NULL DEFAULT now()
);
-- Lo que es de cada efecto. Ninguna de estas tablas tiene una clave foránea
-- hacia orders: cada efecto guarda lo suyo y podría vivir en otra base de datos.
-- Notificaciones: un registro por correo enviado.
CREATE TABLE emails (
id integer GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
order_id integer NOT NULL,
recipient text NOT NULL,
subject text NOT NULL,
sent_at timestamptz NOT NULL DEFAULT now()
);
-- Reportes: el acumulado de ventas por concierto.
CREATE TABLE sales_report (
concert_id integer PRIMARY KEY,
orders integer NOT NULL,
tickets integer NOT NULL,
revenue_cents bigint NOT NULL
);
-- Programa de puntos: el saldo de cada comprador.
CREATE TABLE loyalty_points (
buyer_email text PRIMARY KEY,
points integer NOT NULL
);
INSERT INTO concerts (id, title, price_cents) VALUES
(1, 'Killa Sónica en el Estadio Nacional', 16000),
(2, 'Los Apus en Arequipa', 9000),
(3, 'Noche de cumbia en Trujillo', 4500);import { setTimeout as sleep } from 'node:timers/promises';
import { db } from '../shared/db.ts';
import { log, settings } from '../shared/settings.ts';
import type { PaidOrder } from '../shared/types.ts';
// Efecto 1: el correo de confirmación. No hay un proveedor de correo: la
// demora de uno real se simula con EMAIL_LATENCY_MS y el envío queda
// registrado en la tabla emails.
export async function sendConfirmationEmail(order: PaidOrder): Promise<void> {
await sleep(settings.emailLatencyMs);
await db().query('INSERT INTO emails (order_id, recipient, subject) VALUES ($1, $2, $3)', [
order.orderId,
order.buyerEmail,
`Tus ${order.quantity} entradas para ${order.concertTitle}`,
]);
log('email', `orden ${order.orderId}: correo enviado a ${order.buyerEmail}`);
}import { db } from '../shared/db.ts';
import { log, settings } from '../shared/settings.ts';
import type { PaidOrder } from '../shared/types.ts';
// Efecto 3: el programa de puntos. Un punto por cada sol pagado.
export function pointsFor(order: PaidOrder): number {
return Math.floor(order.totalCents / 100);
}
export async function addLoyaltyPoints(order: PaidOrder): Promise<void> {
if (settings.pointsFail) {
log('points', `orden ${order.orderId}: el programa de puntos no responde`);
throw new Error('El programa de puntos no responde');
}
// Suma sobre lo que haya: si la misma orden llega dos veces, suma dos veces.
await db().query(
`INSERT INTO loyalty_points (buyer_email, points) VALUES ($1, $2)
ON CONFLICT (buyer_email) DO UPDATE SET points = loyalty_points.points + EXCLUDED.points`,
[order.buyerEmail, pointsFor(order)],
);
log('points', `orden ${order.orderId}: ${pointsFor(order)} puntos para ${order.buyerEmail}`);
}import { db } from '../shared/db.ts';
import { log } from '../shared/settings.ts';
import type { PaidOrder } from '../shared/types.ts';
// Efecto 2: el reporte de ventas, un acumulado por concierto.
export async function addToSalesReport(order: PaidOrder): Promise<void> {
await db().query(
`INSERT INTO sales_report (concert_id, orders, tickets, revenue_cents) VALUES ($1, 1, $2, $3)
ON CONFLICT (concert_id) DO UPDATE SET
orders = sales_report.orders + 1,
tickets = sales_report.tickets + EXCLUDED.tickets,
revenue_cents = sales_report.revenue_cents + EXCLUDED.revenue_cents`,
[order.concertId, order.quantity, order.totalCents],
);
log('report', `orden ${order.orderId}: reporte del concierto ${order.concertId} actualizado`);
}import {
AckPolicy,
connect,
DeliverPolicy,
nanos,
type ConsumerMessages,
type JetStreamClient,
type JetStreamManager,
type NatsConnection,
} from 'nats';
import { log, settings } from '../shared/settings.ts';
import type { OrderPaid } from './order-paid.ts';
// Todo lo que este ejemplo sabe de NATS JetStream está en este archivo.
//
// - Un stream guarda en disco cada mensaje publicado en su subject.
// - Un consumer durable es un cursor sobre el stream, guardado en el servidor:
// recuerda qué mensajes ya confirmó (ack) cada consumidor. Por eso un
// consumidor puede detenerse y seguir después donde se quedó.
type Bus = { nc: NatsConnection; js: JetStreamClient; jsm: JetStreamManager };
let bus: Promise<Bus> | undefined;
function connectBus(): Promise<Bus> {
bus ??= (async () => {
const nc = await connect({ servers: settings.natsServer });
return { nc, js: nc.jetstream(), jsm: await nc.jetstreamManager() };
})();
return bus;
}
/** Cierra la conexión con NATS después de enviar lo pendiente. */
export async function closeBus(): Promise<void> {
const open = bus;
bus = undefined;
if (open) await (await open).nc.drain();
}
/** Crea el stream si no existe. Repetirlo con la misma configuración no cambia nada. */
export async function ensureStream(): Promise<void> {
const { jsm } = await connectBus();
await jsm.streams.add({ name: settings.stream, subjects: [settings.subject] });
}
/** Borra el stream con sus mensajes y sus consumers. */
export async function deleteStream(): Promise<void> {
const { jsm } = await connectBus();
await jsm.streams.delete(settings.stream).catch(() => undefined);
}
/**
* Publica el evento y espera a que el stream confirme que lo guardó. Si esta
* promesa se cumple, el evento ya no depende de que haya algún consumidor vivo.
*/
export async function publishOrderPaid(event: OrderPaid): Promise<void> {
const { js } = await connectBus();
await js.publish(settings.subject, JSON.stringify(event));
}
export type Handler = (event: OrderPaid) => Promise<void>;
export type RunningConsumer = { stop(): Promise<void> };
/**
* Empieza a consumir con el consumer durable `name` (lo crea si no existe) y
* llama a `handler` con cada evento, de uno en uno.
*
* - Si `handler` termina bien, se confirma el mensaje (ack) y el servidor no
* lo vuelve a entregar.
* - Si `handler` lanza un error, se devuelve el mensaje (nak) y el servidor lo
* entrega otra vez después de una espera. No hay límite de intentos.
*
* La confirmación va después del trabajo: si el proceso muere entre las dos
* cosas, el mensaje se entrega de nuevo y el efecto se repite.
*/
export async function startConsumer(name: string, handler: Handler): Promise<RunningConsumer> {
const { js, jsm } = await connectBus();
await jsm.consumers.add(settings.stream, {
durable_name: name,
ack_policy: AckPolicy.Explicit,
// Un consumer nuevo empieza por el primer mensaje del stream.
deliver_policy: DeliverPolicy.All,
// Si en 30 s no llega ni ack ni nak, el servidor da el mensaje por perdido y lo reenvía.
ack_wait: nanos(30_000),
});
const consumer = await js.consumers.get(settings.stream, name);
// De uno en uno: no se pide el siguiente mensaje hasta terminar con el actual.
const messages: ConsumerMessages = await consumer.consume({ max_messages: 1 });
const loop = (async () => {
for await (const message of messages) {
const event = message.json<OrderPaid>();
try {
await handler(event);
await message.ackAck();
} catch (error) {
log(name, `orden ${event.order.orderId}: intento ${message.info.deliveryCount} falló (${String(error)})`);
message.nak(settings.redeliveryDelayMs);
}
}
})();
return {
async stop() {
await messages.close();
await loop;
},
};
}
/** El estado de un consumer durable, como lo ve el servidor. */
export async function consumerState(name: string): Promise<{ pending: number; ackPending: number; redelivered: number }> {
const { jsm } = await connectBus();
const info = await jsm.consumers.info(settings.stream, name);
return { pending: info.num_pending, ackPending: info.num_ack_pending, redelivered: info.num_redelivered };
}import { closeDb } from '../shared/db.ts';
import { log } from '../shared/settings.ts';
import { closeBus, ensureStream, startConsumer, type Handler } from './bus.ts';
/**
* Lo que tiene en común todo consumidor que corre como proceso: consume hasta
* que le piden terminar (Ctrl+C o `make stop`) y cierra sus conexiones.
*/
export async function runConsumerProcess(name: string, handler: Handler): Promise<void> {
await ensureStream();
const consumer = await startConsumer(name, handler);
log(name, 'esperando eventos OrderPaid');
const stop = async (): Promise<void> => {
await consumer.stop();
await Promise.all([closeBus(), closeDb()]);
log(name, 'detenido');
};
for (const signal of ['SIGINT', 'SIGTERM'] as const) {
process.once(signal, () => void stop());
}
}import { closeDb } from '../shared/db.ts';
import { createOrdersServer } from '../shared/http.ts';
import { log, settings } from '../shared/settings.ts';
import { closeBus, ensureStream } from './bus.ts';
import { placeOrder } from './place-order.ts';
await ensureStream();
const server = createOrdersServer(placeOrder);
server.listen(settings.port, () => {
log('orders', `versión con eventos en http://localhost:${settings.port} (stream ${settings.stream})`);
});
for (const signal of ['SIGINT', 'SIGTERM'] as const) {
process.once(signal, () => {
server.close(() => void Promise.all([closeBus(), closeDb()]));
server.closeAllConnections();
});
}import type { PaidOrder } from '../shared/types.ts';
// El contrato entre quien publica y quienes consumen. Es lo único que las dos
// partes conocen en común: quien publica no importa ningún consumidor.
//
// El evento lleva los datos de la orden (transferencia de estado en el
// evento), así ningún consumidor tiene que volver a preguntarle a órdenes.
export type OrderPaid = {
type: 'OrderPaid';
// Identifica este hecho. Un consumidor que quisiera descartar duplicados lo
// usaría; los de esta semana no lo hacen.
id: string;
occurredAt: string;
order: PaidOrder;
};import { randomUUID } from 'node:crypto';
import { savePaidOrder } from '../shared/orders-store.ts';
import type { NewOrder, PaidOrder } from '../shared/types.ts';
import { publishOrderPaid } from './bus.ts';
// Versión con eventos: el módulo de órdenes guarda la orden, publica que ya
// se pagó y responde. No importa ningún efecto ni sabe cuántos hay.
//
// Guardar y publicar son dos operaciones sobre dos sistemas distintos: si el
// proceso muere entre una y otra, la orden existe y el evento no. El arreglo
// (la tabla outbox) es tema de la semana 12; aquí el hueco se deja a la vista.
export async function placeOrder(input: NewOrder): Promise<PaidOrder> {
const order = await savePaidOrder(input);
await publishOrderPaid({
type: 'OrderPaid',
id: randomUUID(),
occurredAt: new Date().toISOString(),
order,
});
return order;
}#!/usr/bin/env bash
# Levanta la versión con eventos en una sola terminal: los tres consumidores
# en segundo plano y el servidor de órdenes al frente. Ctrl+C detiene todo.
# El id de proceso de cada consumidor queda en build/pids/ para `make stop`.
set -u
mkdir -p build/pids
for name in email report points; do
node "events/consumers/$name.ts" &
echo $! > "build/pids/$name.pid"
done
stop_all() {
for pidfile in build/pids/*.pid; do
[ -f "$pidfile" ] && kill "$(cat "$pidfile")" 2>/dev/null
rm -f "$pidfile"
done
wait
}
trap stop_all EXIT
trap 'exit 0' INT TERM
node events/main.ts &
echo $! > build/pids/orders.pid
wait "$(cat build/pids/orders.pid)"import { createServer } from 'node:http';
import type { AddressInfo } from 'node:net';
// La misma función, llamada de dos maneras: dentro del proceso y por HTTP a
// un servidor en la misma máquina (la red más rápida y confiable que existe).
//
// node network/local-vs-remote.ts
function priceWithFee(cents: number): number {
return Math.round(cents * 1.035) + 30;
}
const LOCAL_CALLS = 1_000_000;
const REMOTE_CALLS = 2_000;
// Llamada local.
let checksum = 0;
const localStart = performance.now();
for (let i = 0; i < LOCAL_CALLS; i += 1) checksum += priceWithFee(16_000 + (i % 100));
const localNs = ((performance.now() - localStart) * 1e6) / LOCAL_CALLS;
// Llamada remota: el servidor hace exactamente lo mismo.
const server = createServer((request, response) => {
const cents = Number(new URL(request.url ?? '/', 'http://localhost').searchParams.get('cents'));
response.end(String(priceWithFee(cents)));
});
await new Promise<void>((resolve) => server.listen(0, resolve));
const { port } = server.address() as AddressInfo;
const times: number[] = [];
for (let i = 0; i < REMOTE_CALLS; i += 1) {
const start = performance.now();
const response = await fetch(`http://localhost:${port}/?cents=${16_000 + (i % 100)}`);
checksum -= Number(await response.text());
times.push(performance.now() - start);
}
await new Promise<void>((resolve) => {
server.close(() => resolve());
server.closeAllConnections();
});
times.sort((a, b) => a - b);
const medianUs = times[Math.floor(times.length / 2)]! * 1000;
const p99Us = times[Math.ceil(times.length * 0.99) - 1]! * 1000;
console.log(`llamada local: ${localNs.toFixed(0)} ns por llamada (promedio de ${LOCAL_CALLS} llamadas)`);
console.log(`llamada remota: ${medianUs.toFixed(0)} µs por llamada (mediana de ${REMOTE_CALLS}; p99 ${p99Us.toFixed(0)} µs)`);
console.log(`la remota tarda unas ${Math.round((medianUs * 1000) / localNs)} veces más, sin salir de la máquina`);import { createServer, type Server } from 'node:http';
import type { AddressInfo } from 'node:net';
import { setTimeout as sleep } from 'node:timers/promises';
import { pathToFileURL } from 'node:url';
// Lo que ve quien llama cuando una llamada remota falla, y lo que pasó de
// verdad en el otro lado. Un servicio de cobros de juguete con tres fallas:
//
// lost-request el pedido no llega a procesarse: se corta la conexión antes de cobrar
// lost-reply se cobra, y la conexión se corta antes de responder
// slow se cobra, y la respuesta tarda más de lo que el cliente espera
//
// node network/lost-reply.ts
export type Failure = 'none' | 'lost-request' | 'lost-reply' | 'slow';
export type ChargeService = { url: string; charges(): number; close(): Promise<void> };
export async function startChargeService(failure: Failure): Promise<ChargeService> {
let charges = 0;
const server: Server = createServer((request, response) => {
void (async () => {
if (failure === 'lost-request') return request.socket.destroy();
charges += 1; // aquí se cobra
if (failure === 'lost-reply') return request.socket.destroy();
if (failure === 'slow') await sleep(600);
response.end(JSON.stringify({ status: 'approved' }));
})();
});
await new Promise<void>((resolve) => server.listen(0, resolve));
const { port } = server.address() as AddressInfo;
return {
url: `http://localhost:${port}/charges`,
charges: () => charges,
close: () =>
new Promise<void>((resolve) => {
server.close(() => resolve());
server.closeAllConnections();
}),
};
}
/** Lo que el cliente puede decir de su llamada: respondió, o no sabe. */
export async function charge(url: string, timeoutMs = 300): Promise<string> {
try {
const response = await fetch(url, { method: 'POST', signal: AbortSignal.timeout(timeoutMs) });
return `respuesta ${response.status}`;
} catch (error) {
const cause = (error as { cause?: { code?: string } }).cause?.code;
return `sin respuesta (${(error as Error).name}${cause ? `, ${cause}` : ''})`;
}
}
if (import.meta.url === pathToFileURL(process.argv[1] ?? '').href) {
for (const failure of ['none', 'lost-request', 'lost-reply', 'slow'] as const) {
const service = await startChargeService(failure);
const seen = await charge(service.url);
await sleep(700); // se le da tiempo al caso lento para terminar
console.log(`${failure.padEnd(13)} el cliente ve: ${seen.padEnd(45)} cobros en el servidor: ${service.charges()}`);
await service.close();
}
}import { closeDb } from '../shared/db.ts';
import { createOrdersServer } from '../shared/http.ts';
import { log, settings } from '../shared/settings.ts';
import { placeOrder } from './place-order.ts';
const server = createOrdersServer(placeOrder);
server.listen(settings.port, () => {
log('orders', `versión síncrona en http://localhost:${settings.port}`);
});
for (const signal of ['SIGINT', 'SIGTERM'] as const) {
process.once(signal, () => {
server.close(() => void closeDb());
server.closeAllConnections();
});
}import { sendConfirmationEmail } from '../effects/email.ts';
import { addLoyaltyPoints } from '../effects/loyalty-points.ts';
import { addToSalesReport } from '../effects/sales-report.ts';
import { savePaidOrder } from '../shared/orders-store.ts';
import type { NewOrder, PaidOrder } from '../shared/types.ts';
// Versión síncrona: el módulo de órdenes conoce a los tres efectos y los
// llama uno tras otro. La compra responde cuando terminó el último.
export async function placeOrder(input: NewOrder): Promise<PaidOrder> {
const order = await savePaidOrder(input);
await sendConfirmationEmail(order);
await addToSalesReport(order);
await addLoyaltyPoints(order);
return order;
}import { setTimeout as sleep } from 'node:timers/promises';
import { closeDb } from '../shared/db.ts';
import { percentile } from './percentile.ts';
import { describe, isComplete, reconcile } from './reconcile.ts';
// Hace N compras, una después de otra, y mide cuánto tarda en responder cada
// una, vista desde quien compra. Sirve igual para las dos versiones.
//
// N=10 node tools/measure.ts solo las compras
// N=10 WAIT=1 node tools/measure.ts además espera a que los tres efectos
// de todas las órdenes hayan ocurrido
//
// Las compras van de una en una: se mide el tiempo de respuesta sin carga, no
// el throughput.
const baseUrl = process.env.BASE_URL ?? 'http://localhost:3000';
const purchases = Number(process.env.N ?? 10);
const waitForEffects = process.env.WAIT === '1';
const waitLimitMs = Number(process.env.WAIT_LIMIT_MS ?? 30_000);
const BUYERS = [
{ email: 'rosa.quispe@correo.pe', name: 'Rosa Quispe' },
{ email: 'luis.mamani@correo.pe', name: 'Luis Mamani' },
{ email: 'carmen.huaman@correo.pe', name: 'Carmen Huamán' },
];
const times: number[] = [];
let failed = 0;
for (let i = 0; i < purchases; i += 1) {
const body = JSON.stringify({ concertId: (i % 3) + 1, quantity: (i % 2) + 1, buyer: BUYERS[i % BUYERS.length] });
const start = performance.now();
const response = await fetch(`${baseUrl}/orders`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body,
});
const text = await response.text();
const elapsed = performance.now() - start;
times.push(elapsed);
if (response.status !== 201) failed += 1;
const detail = response.status === 201 ? '' : ` ${text}`;
console.log(`compra ${String(i + 1).padStart(2)}: ${response.status} en ${elapsed.toFixed(0).padStart(5)} ms${detail}`);
}
const lastResponseAt = performance.now();
const sorted = [...times].sort((a, b) => a - b);
const ms = (value: number): string => `${value.toFixed(0)} ms`;
console.log(
`${purchases} compras, ${failed} con error. Tiempo de respuesta: ` +
`mín ${ms(sorted[0]!)} · p50 ${ms(percentile(sorted, 50))} · p95 ${ms(percentile(sorted, 95))} · máx ${ms(sorted.at(-1)!)}`,
);
if (waitForEffects) {
let state = await reconcile();
while (!isComplete(state) && performance.now() - lastResponseAt < waitLimitMs) {
await sleep(50);
state = await reconcile();
}
const waited = ((performance.now() - lastResponseAt) / 1000).toFixed(1);
console.log(
isComplete(state)
? `Los tres efectos de todas las órdenes estaban hechos ${waited} s después de la última respuesta.`
: `Después de ${waited} s todavía faltan efectos:`,
);
console.log(describe(state));
}
await closeDb();/**
* Percentil por rango más cercano sobre una lista ya ordenada: el menor valor
* que tiene al menos p % de las muestras por debajo o iguales a él.
*/
export function percentile(sorted: number[], p: number): number {
if (sorted.length === 0) throw new Error('No hay muestras');
const rank = Math.max(1, Math.ceil((p / 100) * sorted.length));
return sorted[rank - 1]!;
}import { db } from '../shared/db.ts';
// ¿Ya ocurrieron los tres efectos de todas las órdenes? Nadie lo sabe por sí
// solo: hay que comparar lo que dice órdenes con lo que dice cada efecto.
export type Reconciliation = {
orders: number;
emails: number;
ordersWithEmail: number;
reportOrders: number;
expectedPoints: number;
points: number;
};
export async function reconcile(): Promise<Reconciliation> {
const result = await db().query<Record<keyof Reconciliation, string>>(`
SELECT
(SELECT count(*) FROM orders) AS orders,
(SELECT count(*) FROM emails) AS emails,
(SELECT count(DISTINCT order_id) FROM emails) AS "ordersWithEmail",
(SELECT coalesce(sum(orders), 0) FROM sales_report) AS "reportOrders",
(SELECT coalesce(sum(total_cents / 100), 0) FROM orders) AS "expectedPoints",
(SELECT coalesce(sum(points), 0) FROM loyalty_points) AS points`);
const row = result.rows[0]!;
return {
orders: Number(row.orders),
emails: Number(row.emails),
ordersWithEmail: Number(row.ordersWithEmail),
reportOrders: Number(row.reportOrders),
expectedPoints: Number(row.expectedPoints),
points: Number(row.points),
};
}
/** Todos los efectos de todas las órdenes ocurrieron al menos una vez. */
export function isComplete(state: Reconciliation): boolean {
return (
state.ordersWithEmail >= state.orders &&
state.reportOrders >= state.orders &&
state.points >= state.expectedPoints
);
}
export function describe(state: Reconciliation): string {
const line = (label: string, have: number, want: number, unit: string): string => {
const note = have === want ? 'completo' : have < want ? `faltan ${want - have}` : `sobran ${have - want}`;
return `${label.padEnd(20)}${String(have).padStart(6)} de ${String(want).padEnd(6)} ${unit} (${note})`;
};
return [
`órdenes pagadas ${String(state.orders).padStart(6)}`,
line('correos enviados', state.emails, state.orders, 'correos'),
line('reporte de ventas', state.reportOrders, state.orders, 'órdenes'),
line('puntos sumados', state.points, state.expectedPoints, 'puntos'),
].join('\n');
}import { closeDb } from '../shared/db.ts';
import { describe, reconcile } from './reconcile.ts';
// make status: compara las órdenes con lo que registró cada efecto.
console.log(describe(await reconcile()));
await closeDb();#!/usr/bin/env bash
# Mide en una copia del Tinkuy inicial (build/tinkuy) cuánto tarda en responder
# la compra según lo que tarde el correo. No modifica el Tinkuy del curso.
#
# bash tools/tinkuy-email.sh con el correo por omisión (120 ms)
# EMAIL_LATENCY_MS=800 bash tools/tinkuy-email.sh
# EMAIL_FAIL_EVERY=1 bash tools/tinkuy-email.sh el servidor de correo rechaza todo
set -u
cd build/tinkuy
export TINKUY_LOG=off PORT=3100 GATEWAY_PORT=4100 GATEWAY_URL=http://localhost:4100 BASE_URL=http://localhost:3100
make -s db >/dev/null
node tools/fake-gateway.ts >/dev/null 2>&1 &
gateway=$!
node src/main.ts >/dev/null 2>&1 &
server=$!
trap 'kill $gateway $server 2>/dev/null; wait' EXIT
until curl -fs "$BASE_URL/health" >/dev/null 2>&1 && curl -fs "$GATEWAY_URL/health" >/dev/null 2>&1; do sleep 0.2; done
echo "Tinkuy inicial, EMAIL_LATENCY_MS=${EMAIL_LATENCY_MS:-120} EMAIL_FAIL_EVERY=${EMAIL_FAIL_EVERY:-0}"
for seat in 1 2 3 4 5; do
curl -s -o /dev/null -w "compra del asiento $seat: %{http_code} en %{time_total} s\n" \
-X POST "$BASE_URL/orders" -H 'content-type: application/json' \
-d "{\"eventId\":1,\"seatIds\":[$seat],\"buyer\":{\"email\":\"rosa.quispe@correo.pe\",\"name\":\"Rosa Quispe\"},\"payment\":{\"method\":\"yape\",\"phone\":\"987654321\",\"approvalCode\":\"482913\"}}"
done
echo "órdenes nuevas en la base de datos: $(psql -At -d tinkuy -c "SELECT count(*) FROM orders WHERE id > 1303")"
# La pasarela numera los cobros que aprueba: el número del siguiente dice cuántos aprobó antes.
next=$(curl -s -X POST "$GATEWAY_URL/charges" -H 'content-type: application/json' \
-d '{"amountCents":100,"reference":"sonda","method":"yape","yape":{"phone":"987654321"}}' | jq -r .chargeId)
echo "cobros que la pasarela aprobó antes de esta sonda: $((10#${next#ch_} - 1)) (la sonda recibió $next)"import { sendConfirmationEmail } from '../../effects/email.ts';
import { runConsumerProcess } from '../consumer-process.ts';
await runConsumerProcess('email', (event) => sendConfirmationEmail(event.order));import { addLoyaltyPoints } from '../../effects/loyalty-points.ts';
import { runConsumerProcess } from '../consumer-process.ts';
await runConsumerProcess('points', (event) => addLoyaltyPoints(event.order));import { addToSalesReport } from '../../effects/sales-report.ts';
import { runConsumerProcess } from '../consumer-process.ts';
await runConsumerProcess('report', (event) => addToSalesReport(event.order));Pruebas
Comprueban lo que afirman los apuntes; se ejecutan con make test.
import assert from 'node:assert/strict';
import { after, beforeEach, test } from 'node:test';
import { sendConfirmationEmail } from '../effects/email.ts';
import { addLoyaltyPoints } from '../effects/loyalty-points.ts';
import { addToSalesReport } from '../effects/sales-report.ts';
import { closeBus, consumerState, startConsumer, type RunningConsumer } from '../events/bus.ts';
import { placeOrder } from '../events/place-order.ts';
import { closeDb } from '../shared/db.ts';
import { settings } from '../shared/settings.ts';
import { buy, count, eventually, pointsOf, reportOrders, reset, startServer } from './helpers.ts';
// Lo que los apuntes afirman de la versión con eventos. Los consumidores
// corren dentro del proceso de pruebas, con los mismos handlers que los de
// events/consumers/.
const ROSA = 'rosa.quispe@correo.pe';
const emailConsumer = (): Promise<RunningConsumer> => startConsumer('email', (event) => sendConfirmationEmail(event.order));
const reportConsumer = (): Promise<RunningConsumer> => startConsumer('report', (event) => addToSalesReport(event.order));
const pointsConsumer = (): Promise<RunningConsumer> => startConsumer('points', (event) => addLoyaltyPoints(event.order));
beforeEach(reset);
after(async () => {
await closeBus();
await closeDb();
});
test('la compra responde aunque no haya ningún consumidor, y el evento espera en el stream', async () => {
const server = await startServer(placeOrder);
let email: RunningConsumer | undefined;
try {
for (let i = 0; i < 3; i += 1) assert.equal((await buy(server)).status, 201);
assert.equal(await count('orders'), 3);
assert.equal(await count('emails'), 0);
// El consumidor aparece después de las compras y recibe las tres.
email = await emailConsumer();
await eventually('tres correos', async () => (await count('emails')) === 3);
} finally {
await email?.stop();
await server.close();
}
});
test('la compra no espera al correo: responde antes de que el correo termine', async () => {
settings.emailLatencyMs = 500;
const server = await startServer(placeOrder);
const email = await emailConsumer();
try {
const purchase = await buy(server);
assert.equal(purchase.status, 201);
assert.ok(purchase.elapsedMs < 400, `respondió en ${purchase.elapsedMs.toFixed(0)} ms`);
// Consistencia eventual: cuando la compra responde, el correo todavía no existe.
assert.equal(await count('emails'), 0);
await eventually('el correo', async () => (await count('emails')) === 1);
} finally {
await email.stop();
await server.close();
}
});
test('si un consumidor falla, la compra y los demás consumidores no se enteran, y el mensaje se entrega de nuevo', async () => {
settings.pointsFail = true;
const server = await startServer(placeOrder);
const report = await reportConsumer();
const points = await pointsConsumer();
try {
assert.equal((await buy(server)).status, 201);
await eventually('el reporte', async () => (await reportOrders()) === 1);
await eventually('una reentrega', async () => (await consumerState('points')).redelivered >= 1);
assert.equal(await pointsOf(ROSA), 0);
// Se arregla el programa de puntos: el mismo mensaje, en su siguiente entrega, se procesa.
settings.pointsFail = false;
await eventually('los puntos', async () => (await pointsOf(ROSA)) === 320);
await eventually('nada por confirmar', async () => (await consumerState('points')).ackPending === 0);
} finally {
await points.stop();
await report.stop();
await server.close();
}
});
test('un consumidor detenido no pierde eventos: al volver sigue donde se quedó', async () => {
const server = await startServer(placeOrder);
const report = await reportConsumer();
let email = await emailConsumer();
try {
for (let i = 0; i < 2; i += 1) await buy(server);
await eventually('dos correos', async () => (await count('emails')) === 2);
await eventually('dos confirmados', async () => (await consumerState('email')).ackPending === 0);
await email.stop();
for (let i = 0; i < 5; i += 1) assert.equal((await buy(server)).status, 201);
await eventually('el reporte al día', async () => (await reportOrders()) === 7);
// El cursor de email quedó en el segundo mensaje: tiene cinco sin entregar.
assert.equal((await consumerState('email')).pending, 5);
assert.equal(await count('emails'), 2);
email = await emailConsumer();
await eventually('siete correos', async () => (await count('emails')) === 7);
} finally {
await email.stop();
await report.stop();
await server.close();
}
});
test('un consumidor nuevo recibe los eventos publicados antes de que existiera', async () => {
const server = await startServer(placeOrder);
const seen: number[] = [];
let audit: RunningConsumer | undefined;
try {
for (let i = 0; i < 4; i += 1) await buy(server);
audit = await startConsumer('audit', async (event) => {
seen.push(event.order.orderId);
});
await eventually('cuatro eventos', async () => seen.length === 4);
assert.deepEqual(seen, [1, 2, 3, 4]);
} finally {
await audit?.stop();
await server.close();
}
});
test('sin idempotencia, un mensaje que se entrega dos veces suma los puntos dos veces', async () => {
const server = await startServer(placeOrder);
let deliveries = 0;
// Un consumidor que aplica el efecto y muere antes de confirmar, una sola vez.
const points = await startConsumer('points', async (event) => {
deliveries += 1;
await addLoyaltyPoints(event.order);
if (deliveries === 1) throw new Error('el proceso murió antes del ack');
});
try {
assert.equal((await buy(server)).status, 201);
await eventually('la segunda entrega', async () => deliveries === 2);
await eventually('confirmado', async () => (await consumerState('points')).ackPending === 0);
// Una orden de S/ 320 dejó 640 puntos.
assert.equal(await pointsOf(ROSA), 640);
} finally {
await points.stop();
await server.close();
}
});import type { AddressInfo } from 'node:net';
import { setTimeout as sleep } from 'node:timers/promises';
import { deleteStream, ensureStream } from '../events/bus.ts';
import { db } from '../shared/db.ts';
import { createOrdersServer, type PlaceOrder } from '../shared/http.ts';
import { settings } from '../shared/settings.ts';
/** Deja la base de datos y el stream de pruebas vacíos, y los ajustes en su valor normal. */
export async function reset(): Promise<void> {
settings.emailLatencyMs = 0;
settings.pointsFail = false;
await db().query('TRUNCATE orders, emails, sales_report, loyalty_points RESTART IDENTITY');
await deleteStream();
await ensureStream();
}
export type TestServer = { url: string; close(): Promise<void> };
export async function startServer(placeOrder: PlaceOrder): Promise<TestServer> {
const server = createOrdersServer(placeOrder);
await new Promise<void>((resolve) => server.listen(0, resolve));
const { port } = server.address() as AddressInfo;
return {
url: `http://localhost:${port}`,
close: () =>
new Promise<void>((resolve) => {
server.close(() => resolve());
server.closeAllConnections();
}),
};
}
export type Purchase = { status: number; elapsedMs: number; body: unknown };
/** Una compra de Rosa: dos entradas del concierto 1 (S/ 320, 320 puntos). */
export async function buy(server: TestServer): Promise<Purchase> {
const start = performance.now();
const response = await fetch(`${server.url}/orders`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ concertId: 1, quantity: 2, buyer: { email: 'rosa.quispe@correo.pe', name: 'Rosa Quispe' } }),
});
const body: unknown = await response.json();
return { status: response.status, elapsedMs: performance.now() - start, body };
}
/** Espera, consultando cada 20 ms, a que `check` devuelva true. Falla si pasan 15 s. */
export async function eventually(what: string, check: () => Promise<boolean>): Promise<void> {
const deadline = performance.now() + 15_000;
while (!(await check())) {
if (performance.now() > deadline) throw new Error(`No ocurrió en 15 s: ${what}`);
await sleep(20);
}
}
export async function count(table: 'orders' | 'emails'): Promise<number> {
const result = await db().query<{ n: string }>(`SELECT count(*) AS n FROM ${table}`);
return Number(result.rows[0]!.n);
}
export async function pointsOf(email: string): Promise<number> {
const result = await db().query<{ points: number }>('SELECT points FROM loyalty_points WHERE buyer_email = $1', [
email,
]);
return result.rows[0]?.points ?? 0;
}
export async function reportOrders(): Promise<number> {
const result = await db().query<{ n: string }>('SELECT coalesce(sum(orders), 0) AS n FROM sales_report');
return Number(result.rows[0]!.n);
}import assert from 'node:assert/strict';
import { setTimeout as sleep } from 'node:timers/promises';
import { test } from 'node:test';
import { charge, startChargeService } from '../network/lost-reply.ts';
// Quien llama no puede distinguir "no llegó" de "llegó y la respuesta se perdió".
test('el pedido perdido y la respuesta perdida se ven igual desde el cliente, y el servidor quedó distinto', async () => {
const lostRequest = await startChargeService('lost-request');
const lostReply = await startChargeService('lost-reply');
try {
const seenA = await charge(lostRequest.url);
const seenB = await charge(lostReply.url);
assert.equal(seenA, seenB);
assert.match(seenA, /^sin respuesta/);
assert.equal(lostRequest.charges(), 0);
assert.equal(lostReply.charges(), 1);
} finally {
await lostRequest.close();
await lostReply.close();
}
});
test('un timeout no cancela nada: el cliente se rinde y el servidor cobra igual', async () => {
const slow = await startChargeService('slow');
try {
assert.match(await charge(slow.url, 100), /^sin respuesta \(TimeoutError/);
await sleep(50);
assert.equal(slow.charges(), 1);
} finally {
await slow.close();
}
});import assert from 'node:assert/strict';
import { test } from 'node:test';
import { percentile } from '../tools/percentile.ts';
test('percentil por rango más cercano', () => {
const ten = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert.equal(percentile(ten, 50), 5);
assert.equal(percentile(ten, 90), 9);
// Con diez muestras, el p95 es la más lenta: no hay muestras para distinguirlo del máximo.
assert.equal(percentile(ten, 95), 10);
assert.equal(percentile([7], 99), 7);
});import assert from 'node:assert/strict';
import { after, beforeEach, test } from 'node:test';
import { closeBus } from '../events/bus.ts';
import { closeDb } from '../shared/db.ts';
import { settings } from '../shared/settings.ts';
import { placeOrder } from '../sync/place-order.ts';
import { buy, count, pointsOf, reportOrders, reset, startServer } from './helpers.ts';
// Lo que los apuntes afirman de la versión síncrona.
beforeEach(reset);
after(async () => {
await closeBus();
await closeDb();
});
test('cuando la compra responde, los tres efectos ya ocurrieron', async () => {
const server = await startServer(placeOrder);
try {
const purchase = await buy(server);
assert.equal(purchase.status, 201);
assert.equal(await count('emails'), 1);
assert.equal(await reportOrders(), 1);
assert.equal(await pointsOf('rosa.quispe@correo.pe'), 320);
} finally {
await server.close();
}
});
test('la compra tarda por lo menos lo que tarda el correo', async () => {
settings.emailLatencyMs = 300;
const server = await startServer(placeOrder);
try {
const purchase = await buy(server);
assert.equal(purchase.status, 201);
assert.ok(purchase.elapsedMs >= 290, `respondió en ${purchase.elapsedMs.toFixed(0)} ms`);
} finally {
await server.close();
}
});
test('si falla el último efecto, el comprador recibe un 500 y la orden queda pagada, con correo y sin puntos', async () => {
settings.pointsFail = true;
const server = await startServer(placeOrder);
try {
const purchase = await buy(server);
assert.equal(purchase.status, 500);
assert.deepEqual(purchase.body, { error: { code: 'INTERNAL_ERROR', message: 'Ocurrió un error inesperado' } });
assert.equal(await count('orders'), 1);
assert.equal(await count('emails'), 1);
assert.equal(await reportOrders(), 1);
assert.equal(await pointsOf('rosa.quispe@correo.pe'), 0);
} finally {
await server.close();
}
});
test('el comprador que reintenta después del 500 queda con dos órdenes pagadas y dos correos', async () => {
settings.pointsFail = true;
const server = await startServer(placeOrder);
try {
assert.equal((await buy(server)).status, 500);
settings.pointsFail = false;
assert.equal((await buy(server)).status, 201);
assert.equal(await count('orders'), 2);
assert.equal(await count('emails'), 2);
// Los puntos de la primera orden no llegaron nunca: nadie los va a reintentar.
assert.equal(await pointsOf('rosa.quispe@correo.pe'), 320);
} finally {
await server.close();
}
});Compilación
Cómo se compilan y ejecutan los ejemplos.
# Semana 5: el mismo caso en dos estilos. Después de una compra hay que enviar
# el correo, actualizar el reporte de ventas y sumar puntos al comprador.
# Se usa dentro del contenedor del curso.
#
# make crea la base de datos arq_w05 y borra el stream W05_ORDERS
# make sync levanta la versión síncrona en http://localhost:3000
# make events levanta la versión con eventos: el servidor de órdenes
# y los tres consumidores, en una sola terminal
# make buy N=5 hace N compras y mide cuánto tarda en responder cada una
# make measure N=10 lo mismo, y además espera a que los efectos terminen
# make status compara las órdenes con lo que registró cada efecto
# make info C=points el estado de un consumer, con nats consumer info
# make stop C=points detiene un consumidor de make events
# make consumer C=points inicia un consumidor en esta terminal
# make remote una llamada local y una remota, medidas (network/local-vs-remote.ts)
# make lost-reply lo que ve quien llama cuando una llamada remota falla
# make tinkuy-email el Tinkuy inicial (una copia en build/tinkuy): cuánto tarda
# la compra según el correo; acepta EMAIL_LATENCY_MS y EMAIL_FAIL_EVERY
# make test revisa los tipos (tsc) y corre las pruebas (test/*.test.ts)
# make clean borra las bases de datos, los streams y build/
#
# Consumidores: email, report, points. Variables para sync, events y consumer:
# EMAIL_LATENCY_MS=800 el servidor de correo simulado tarda 800 ms (por omisión, 100)
# POINTS_FAIL=1 el programa de puntos falla siempre
#
# make sync y make events empiezan siempre con datos nuevos. Necesitan una
# terminal para ellos; las compras se hacen desde otra.
N ?= 10
C ?= points
STREAM = W05_ORDERS
TINKUY ?= ../../tinkuy
# psql no avisa cuando la base de datos que se va a borrar todavía no existe.
PGOPTIONS = --client-min-messages=warning
export PGOPTIONS N
.PHONY: all db sync events buy measure status info stop consumer remote lost-reply tinkuy-email test clean
all: db
db:
@psql -q -d postgres -c "DROP DATABASE IF EXISTS arq_w05 WITH (FORCE)" -c "CREATE DATABASE arq_w05"
@psql -q -d arq_w05 -v ON_ERROR_STOP=1 -f db/schema.sql
@nats stream rm -f $(STREAM) >/dev/null 2>&1 || true
@echo "Base de datos arq_w05 recién creada; stream $(STREAM) vacío."
sync: db
node sync/main.ts
events: db
bash events/run.sh
buy:
@node tools/measure.ts
measure:
@WAIT=1 node tools/measure.ts
status:
@node tools/status.ts
info:
nats consumer info $(STREAM) $(C)
stop:
@kill "$$(cat build/pids/$(C).pid)" && rm -f build/pids/$(C).pid
consumer:
node events/consumers/$(C).ts
remote:
@node network/local-vs-remote.ts
lost-reply:
@node network/lost-reply.ts
# Nada de esto modifica el Tinkuy del curso (../../tinkuy): se trabaja sobre una copia.
build/tinkuy:
mkdir -p build
cp -r $(TINKUY) $@
tinkuy-email: build/tinkuy
@bash tools/tinkuy-email.sh
# Las pruebas usan su propia base de datos y su propio stream, y levantan los
# servidores y los consumidores dentro del proceso de pruebas: no necesitan
# nada corriendo ni tocan los datos de make sync o make events.
test:
tsc -p .
@psql -q -d postgres -c "DROP DATABASE IF EXISTS arq_w05_test WITH (FORCE)" -c "CREATE DATABASE arq_w05_test"
@psql -q -d arq_w05_test -v ON_ERROR_STOP=1 -f db/schema.sql
W05_DB=arq_w05_test W05_STREAM=W05_TEST_ORDERS W05_SUBJECT=w05test.orders.paid W05_LOG=off \
REDELIVERY_DELAY_MS=100 node --test --test-concurrency=1 "test/*.test.ts"
clean:
@psql -q -d postgres -c "DROP DATABASE IF EXISTS arq_w05 WITH (FORCE)" -c "DROP DATABASE IF EXISTS arq_w05_test WITH (FORCE)"
@nats stream rm -f $(STREAM) >/dev/null 2>&1 || true
@nats stream rm -f W05_TEST_ORDERS >/dev/null 2>&1 || true
rm -rf build{
"name": "week-05",
"private": true,
"type": "module"
}{
"compilerOptions": {
"target": "es2024",
"lib": ["es2024"],
"module": "nodenext",
"moduleResolution": "nodenext",
"types": ["node"],
"strict": true,
"noEmit": true,
"allowImportingTsExtensions": true,
"erasableSyntaxOnly": true,
"verbatimModuleSyntax": true,
"skipLibCheck": true
},
"include": ["shared", "effects", "sync", "events", "tools", "test", "solution"]
}