# Semana 10: replicación. Una réplica de PostgreSQL dentro del contenedor (el
# principal en el puerto 5432, la réplica en el 5433) y un simulador de
# quórums para lo que PostgreSQL no hace. Se usa dentro del contenedor del curso.
#
#   make                 crea la base de datos arq_w10 y la réplica (pg-replica create)
#   make lag             el estado de la réplica según el principal (pg-replica lag)
#   make delay MS=2000   la réplica aplica cada transacción 2 s tarde (MS=0 lo quita)
#   make anomaly         read-your-writes.ts: cien compras leídas enseguida en la réplica
#   make burst           una ráfaga de escrituras: latencia y retraso (WRITES=2000 CLIENTS=4)
#   make monotonic       una lectura que retrocede al cambiar de servidor
#   make wrong-lsn       errors/lsn-before-commit.ts (necesita make delay MS=2000)
#   make compare         laboratorio, paso 5: las dos correcciones de lab/routing.ts
#   make test-lab        las pruebas de lab/routing.ts
#   make sync-on         replicación síncrona (synchronous_standby_names)
#   make sync-off        vuelve a asíncrona
#   make writer          failover: escribe órdenes numeradas hasta que el principal muera
#   make link-cut        failover: la réplica deja de recibir WAL (make link-restore lo repone)
#   make kill-primary    failover: mata solo al principal, sin aviso
#   make compare-failover  failover: lo confirmado al cliente contra lo que tiene el nuevo principal
#   make quorum          el simulador de quórums, caso por caso (quorum/demo.ts)
#   make test            revisa los tipos (tsc) y corre las pruebas (test/*.test.ts)
#   make clean           borra las bases de datos, la réplica y build/
#
# Después de un failover (pg-replica promote) la réplica ya no sigue al
# principal: para volver a empezar, svc start postgres, pg-replica destroy y make.

MS ?= 2000
REPLICA_DIR = /var/lib/postgresql/replica
# 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 replica lag delay anomaly burst monotonic wrong-lsn compare test-lab sync-on sync-off \
        writer link-cut link-restore kill-primary compare-failover quorum test clean

all: db replica

db:
	@psql -X -q -d postgres -c "DROP DATABASE IF EXISTS arq_w10 WITH (FORCE)" -c "CREATE DATABASE arq_w10"
	@psql -X -q -d arq_w10 -v ON_ERROR_STOP=1 -f db/schema.sql
	@echo "Base de datos arq_w10 recién creada en el principal."

# Crea la réplica si no existe y la inicia si estaba detenida. Si quedó
# promovida de un failover anterior, avisa: ya no es una réplica.
replica:
	@if [ ! -e $(REPLICA_DIR) ]; then pg-replica create; \
	 elif ! pg_isready -q -p 5433; then pg-replica start; fi
	@[ "$$(psql -X -At -p 5433 -c 'SELECT pg_is_in_recovery()')" = t ] || { \
	  echo "El servidor del puerto 5433 fue promovido y ya no sigue al principal:"; \
	  echo "  svc start postgres && pg-replica destroy && make"; exit 1; }

lag:
	@pg-replica lag

delay:
	@psql -X -q -p 5433 -c "ALTER SYSTEM SET recovery_min_apply_delay = '$(MS)ms'" -c "SELECT pg_reload_conf()" >/dev/null
	@sleep 0.3
	@echo "La réplica aplica cada transacción con una demora de: $$(psql -X -At -p 5433 -c 'SHOW recovery_min_apply_delay')"

anomaly:
	@node read-your-writes.ts

burst:
	@node replication/burst.ts

monotonic:
	@node replication/monotonic-reads.ts

wrong-lsn:
	@node errors/lsn-before-commit.ts

compare:
	@node lab/compare.ts

test-lab: replica
	node --test lab/routing.test.ts

# 'walreceiver' es el application_name con el que se presenta la réplica.
sync-on:
	@psql -X -q -c "ALTER SYSTEM SET synchronous_standby_names = 'walreceiver'" -c "SELECT pg_reload_conf()" >/dev/null
	@sleep 0.3
	@pg-replica lag

sync-off:
	@psql -X -q -c "ALTER SYSTEM RESET synchronous_standby_names" -c "SELECT pg_reload_conf()" >/dev/null
	@sleep 0.3
	@pg-replica lag

writer:
	@node failover/writer.ts

link-cut:
	@bash failover/link.sh cut

link-restore:
	@bash failover/link.sh restore

kill-primary:
	@bash failover/kill-primary.sh

compare-failover:
	@node failover/compare.ts

quorum:
	@node quorum/demo.ts

# Las pruebas usan su propia base de datos (arq_w10_test) y dejan la réplica
# como la encontraron: asíncrona y sin demora. La solución del laboratorio se
# prueba solo si está en la carpeta.
test: replica
	tsc -p .
	@psql -X -q -c "ALTER SYSTEM RESET synchronous_standby_names" -c "SELECT pg_reload_conf()" >/dev/null
	@psql -X -q -p 5433 -c "ALTER SYSTEM RESET recovery_min_apply_delay" -c "SELECT pg_reload_conf()" >/dev/null
	@psql -X -q -d postgres -c "DROP DATABASE IF EXISTS arq_w10_test WITH (FORCE)" -c "CREATE DATABASE arq_w10_test"
	@psql -X -q -d arq_w10_test -v ON_ERROR_STOP=1 -f db/schema.sql
	@until psql -X -q -p 5433 -d arq_w10_test -c "SELECT 1 FROM notes LIMIT 1" >/dev/null 2>&1; do sleep 0.2; done
	W10_DB=arq_w10_test node --test --test-concurrency=1 "test/*.test.ts"
	@if [ -f solution/routing.ts ]; then \
	  echo "W10_ROUTING=solution node --test lab/routing.test.ts"; \
	  W10_DB=arq_w10_test W10_ROUTING=solution node --test lab/routing.test.ts; fi

clean:
	@if pg_isready -q; then \
	  psql -X -q -c "ALTER SYSTEM RESET synchronous_standby_names" -c "SELECT pg_reload_conf()" >/dev/null; \
	  psql -X -q -d postgres -c "DROP DATABASE IF EXISTS arq_w10 WITH (FORCE)" -c "DROP DATABASE IF EXISTS arq_w10_test WITH (FORCE)"; fi
	@if [ -e $(REPLICA_DIR) ]; then pg-replica destroy; fi
	rm -rf build
