# Semana 11: sharding, cache y escalabilidad. El ejemplo es Qhatu, el catálogo
# de una bodega en línea: se lee mucho más de lo que se escribe.
# Se usa dentro del contenedor del curso.
#
#   make              crea la base de datos arq_w11 (Qhatu y una copia de los datos
#                     de ejemplo de Tinkuy) y borra las claves w11:* de Redis
#   make start        levanta Qhatu en http://localhost:3000 (ver las variables abajo)
#   make load         k6: 50 usuarios mirando el catálogo durante 15 segundos
#   make compare      mide Qhatu sin cache, con cache-aside y con single-flight
#   make race         la carrera entre una lectura y una escritura (race.ts)
#   make stampede     cuenta las consultas que llegan a PostgreSQL cuando vence la lista,
#                     con cache-aside y con single-flight
#   make jitter       1000 entradas guardadas a la vez: cuándo vencen sin y con jitter
#   make negative     200 pedidos de un producto que no existe, sin y con cache negativa
#   make eviction    qué hace Redis cuando se llena: noeviction y allkeys-lru
#   make redis-down   mata Redis con la carga corriendo (CACHE_FAILURE=open o closed)
#   make local-cache  el error de la semana: cache en el proceso con dos instancias
#   make shards       reparte los eventos y asientos de Tinkuy en 8 shards, por hash y por rango
#   make rebalance    cuántas claves se mueven al pasar de 8 a 9 nodos, con tres esquemas
#   make scatter      qué consultas de Tinkuy tocan un shard y cuáles todos
#   make test         revisa los tipos (tsc) y corre las pruebas (test/*.test.ts)
#   make test-lab     corre las pruebas del módulo del laboratorio (lab/cache-aside.ts)
#   make clean        borra las bases de datos, las claves w11:* y build/
#
# Para contar consultas en PostgreSQL desde otra aplicación (el laboratorio):
#   make pg-on                              empieza a registrar las consultas
#   make pg-report DB=tinkuy MATCH='FROM events'   cuántas hubo y en qué ráfagas
#   make pg-off                             deja de registrar
#
# Variables de make start:
#   CACHE_MODE=off|aside|single-flight   por omisión, aside
#   LIST_TTL_MS=5000  DETAIL_TTL_MS=30000  NEGATIVE_TTL_MS=5000  JITTER=0.1
#   INVALIDATE=off        las escrituras no borran nada de la cache
#   CACHE_FAILURE=closed  un error de Redis llega a quien llama
#   STATS_LOG=1           una línea de estadísticas por segundo

TINKUY ?= ../../tinkuy
DB ?= arq_w11
MATCH ?= SELECT
GAP ?= 300
# psql no avisa cuando la base de datos que se va a borrar todavía no existe.
PGOPTIONS = --client-min-messages=warning
export PGOPTIONS

.PHONY: all db start load compare race stampede jitter negative eviction redis-down local-cache \
        shards rebalance scatter pg-on pg-report pg-off test test-lab clean

all: db

# Nada de esto modifica el Tinkuy del curso (../../tinkuy): se trabaja sobre una copia.
build/tinkuy:
	mkdir -p build
	cp -r $(TINKUY) $@

# En arq_w11 viven las tablas de Qhatu y, para los ejercicios de sharding, los
# datos de ejemplo de Tinkuy (semilla 7), cargados por su propio programa.
db: build/tinkuy
	@psql -q -d postgres -c "DROP DATABASE IF EXISTS arq_w11 WITH (FORCE)" -c "CREATE DATABASE arq_w11"
	@psql -q -d arq_w11 -v ON_ERROR_STOP=1 -f db/schema.sql -f db/seed.sql
	@psql -q -d arq_w11 -v ON_ERROR_STOP=1 -f build/tinkuy/db/schema.sql
	@cd build/tinkuy && TINKUY_DB=arq_w11 node db/seed.ts --seed 7 >/dev/null
	@node tools/flush.ts
	@psql -q -d arq_w11 -At -c "SELECT 'Qhatu: ' || (SELECT count(*) FROM products) || ' productos, ' || (SELECT count(*) FROM stock_movements) || ' movimientos de stock. Tinkuy: ' || (SELECT count(*) FROM events) || ' eventos, ' || (SELECT count(*) FROM seats) || ' asientos.'"

start:
	node src/main.ts

load:
	k6 run --quiet load/browse.js

compare:
	@bash tools/compare.sh

race:
	node race.ts L1 L2 E1 E2 L3

stampede:
	@bash tools/stampede.sh

jitter:
	@node tools/jitter.ts

negative:
	@node tools/negative.ts

eviction:
	@node tools/eviction.ts

redis-down:
	@bash tools/redis-down.sh

local-cache:
	@node errors/local-cache.ts

shards:
	@node shards/assign.ts

rebalance:
	@node shards/rebalance.ts

scatter:
	@node shards/scatter.ts

pg-on:
	@node tools/pg-queries.ts on

pg-report:
	@node tools/pg-queries.ts report --db "$(DB)" --match "$(MATCH)" --gap $(GAP)

pg-off:
	@node tools/pg-queries.ts off

# Las pruebas usan su propia base de datos y su propio prefijo de Redis, y
# levantan el servidor dentro del proceso: no necesitan nada corriendo ni
# tocan los datos de make start. Comparten la base, así que van una tras otra.
# La solución del laboratorio se prueba solo si está en la carpeta.
test: build/tinkuy
	tsc -p .
	@psql -q -d postgres -c "DROP DATABASE IF EXISTS arq_w11_test WITH (FORCE)" -c "CREATE DATABASE arq_w11_test"
	@psql -q -d arq_w11_test -v ON_ERROR_STOP=1 -f db/schema.sql -f db/seed.sql
	@psql -q -d arq_w11_test -v ON_ERROR_STOP=1 -f build/tinkuy/db/schema.sql
	@cd build/tinkuy && TINKUY_DB=arq_w11_test node db/seed.ts --seed 7 >/dev/null
	W11_DB=arq_w11_test W11_PREFIX=w11:test: node --test --test-concurrency=1 "test/*.test.ts"

test-lab:
	W11_PREFIX=w11:lab: CACHE_MODULE=lab node --test --test-concurrency=1 test/cache-module.test.ts

clean:
	@psql -q -d postgres -c "DROP DATABASE IF EXISTS arq_w11 WITH (FORCE)" -c "DROP DATABASE IF EXISTS arq_w11_test WITH (FORCE)"
	@node tools/flush.ts || true
	rm -rf build
