# Semana 6: tácticas. Un servicio pequeño, Qillqa (el catálogo de una red de
# bibliotecas), con variantes que se eligen por variables de entorno, para
# medir cada táctica antes y después. Se usa dentro del contenedor del curso.
#
#   make                crea la base de datos arq_w06 con sus datos de ejemplo
#   make test           revisa los tipos (tsc) y corre las pruebas (test/*.test.ts)
#   make serve          levanta Qillqa en http://localhost:3600 con la variante
#                       que digan las variables (ver abajo)
#   make load           k6 contra el Qillqa de make serve: 50 usuarios, 15 s
#   make endpoints      k6 con las métricas separadas por endpoint
#   make connections    cuántas conexiones tiene PostgreSQL, cada segundo
#   make measure V="baseline pool-10"   levanta cada variante, la mide y escribe
#                       una fila por variante (no necesita make serve)
#   make table          las filas de la tabla de la semana (unos 2 min)
#   make curve          el p95 según el tamaño del pool (2, 5, 10, 20, 50 y 90), con
#                       200 usuarios virtuales: más de los que PostgreSQL acepta
#   make connect-cost   cuánto cuesta abrir una conexión, comparado con una consulta
#   make db-curve       consultas en paralelo directo a PostgreSQL: 1, 2, 4 ... 64
#   make stale          presta un ejemplar y mira la lista durante el TTL
#   make cache-down     mata Redis con carga corriendo: fallar y degradar
#   make offline-queue  el cliente de Redis con su configuración por omisión
#   make sql-concat     una consulta armada concatenando texto, y su ataque
#   make privilege      mínimo privilegio con roles de PostgreSQL
#   make tinkuy-up      copia Tinkuy en build/tinkuy y lo levanta con su pasarela
#   make tinkuy-endpoints   k6 por endpoint contra ese Tinkuy (paso 2 del laboratorio)
#   make tinkuy-explain     EXPLAIN ANALYZE de la consulta de disponibilidad de Tinkuy
#   make tinkuy-down    detiene Tinkuy y la pasarela
#   make clean          borra la base de datos, las claves w06:* de Redis y build/
#
# Variables de make serve (y de node src/main.ts):
#   DB_MODE=connect|pool     una conexión por consulta, o un pool   (connect)
#   POOL_SIZE=10             tamaño del pool
#   LIST_MODE=nplus1|single  una consulta por título, o una sola     (nplus1)
#   CACHE=off|redis          cache de GET /titles en Redis           (off)
#   CACHE_TTL_S=5            cuánto vale una entrada de la cache
#   CACHE_ON_ERROR=fail|degrade   si Redis no responde: error, o base de datos (fail)
#
# Variables de las mediciones: VUS=50 DURATION=15s (make curve usa VUS=200)
#
# Nada de esto modifica el Tinkuy del curso (../../tinkuy).

TINKUY ?= ../../tinkuy
V ?= baseline
DB = arq_w06
# 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 test serve load endpoints connections measure table curve connect-cost db-curve \
        stale cache-down offline-queue sql-concat privilege \
        tinkuy-up tinkuy-endpoints tinkuy-explain tinkuy-down clean

all: db

db:
	@psql -q -d postgres -c "DROP DATABASE IF EXISTS $(DB) WITH (FORCE)" -c "CREATE DATABASE $(DB)"
	@psql -q -d $(DB) -v ON_ERROR_STOP=1 -f db/schema.sql -f db/seed.sql
	@psql -At -d $(DB) -c "SELECT format('Base de datos $(DB): %s sedes, %s títulos, %s ejemplares (%s disponibles)', \
	  (SELECT count(*) FROM branches), (SELECT count(*) FROM titles), count(*), \
	  count(*) FILTER (WHERE status = 'available')) FROM copies"

# Las pruebas usan su propia base de datos y sus propias claves de Redis, y
# levantan las variantes dentro del proceso de pruebas: no necesitan nada
# corriendo. La última mata Redis y lo vuelve a iniciar.
test:
	tsc -p .
	@psql -q -d postgres -c "DROP DATABASE IF EXISTS $(DB)_test WITH (FORCE)" -c "CREATE DATABASE $(DB)_test"
	@psql -q -d $(DB)_test -v ON_ERROR_STOP=1 -f db/schema.sql -f db/seed.sql
	@svc start redis
	W06_DB=$(DB)_test W06_PREFIX=w06test: node --test --test-concurrency=1 "test/*.test.ts"

serve:
	node src/main.ts

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

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

connections:
	@while true; do \
	  psql -At -d postgres -c "SELECT to_char(now(), 'HH24:MI:SS') || '  conexiones: ' || count(*) || '  (activas: ' || count(*) FILTER (WHERE state = 'active') || ')' FROM pg_stat_activity WHERE backend_type = 'client backend' AND pid <> pg_backend_pid()"; \
	  sleep 1; \
	done

measure:
	@node tools/measure.ts $(V)

table:
	@node tools/measure.ts baseline pool-10 single-nopool single cache-nplus1 cache

curve:
	@VUS=$${VUS:-200} node tools/measure.ts baseline pool-2 pool-5 pool-10 pool-20 pool-50 pool-90

connect-cost:
	@node tools/connect-cost.ts

db-curve:
	@node tools/db-curve.ts

stale:
	@bash tools/stale.sh

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

offline-queue:
	@node errors/redis-offline-queue.ts

sql-concat:
	@node errors/sql-concat.ts

privilege:
	@psql -X -d $(DB) -f security/least-privilege.sql 2>&1

build/tinkuy:
	mkdir -p build
	cp -r $(TINKUY) $@

tinkuy-up: build/tinkuy
	$(MAKE) --no-print-directory -C build/tinkuy db
	@cd build/tinkuy && (node tools/fake-gateway.ts > ../gateway.log 2>&1 & echo $$! > ../gateway.pid)
	@cd build/tinkuy && (node src/main.ts > ../tinkuy.log 2>&1 & echo $$! > ../tinkuy.pid)
	@sleep 1
	@curl -s http://localhost:3000/health ; echo

tinkuy-endpoints:
	TARGET=tinkuy k6 run --quiet load/endpoints.js

tinkuy-explain:
	psql -d tinkuy -c "EXPLAIN (ANALYZE, BUFFERS OFF) SELECT count(*)::int AS available FROM seats WHERE event_id = 1 AND status = 'available'"

tinkuy-down:
	@-kill `cat build/tinkuy.pid build/gateway.pid 2>/dev/null` 2>/dev/null ; rm -f build/tinkuy.pid build/gateway.pid

clean: tinkuy-down
	@psql -q -d postgres -c "DROP DATABASE IF EXISTS $(DB) WITH (FORCE)" -c "DROP DATABASE IF EXISTS $(DB)_test WITH (FORCE)" \
	  -c "DROP ROLE IF EXISTS w06_reports"
	@-redis-cli --scan --pattern 'w06*' 2>/dev/null | xargs -r redis-cli del >/dev/null 2>&1
	rm -rf build
