Tests ADN / test (push) Canceled after 0s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-Authored-By: GEMMA <noreply@gemma.dtic>
224 lines
8.7 KiB
Ruby
224 lines
8.7 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
# lib_estado.rb — Único punto de acceso al estado de NEXXA (P335/Fase 17, REG002 R15)
|
|
# ==============================================================================
|
|
# registro, tokens, pools, checkins, usuarios y sesiones (blobs JSON) y el log de usos pasan por acá. Dos motores:
|
|
# archivo — el de siempre: un JSON 0600 junto al código por clave (escritura atómica tmp+rename) y usos.log JSONL.
|
|
# pg — Postgres PROPIO de srvv-nexxa (decisión del Operador 2026-10-05: NEXXA sigue en pie aunque srv-ns8
|
|
# caiga). Tablas estado (clave, valor jsonb) y usos. Socket local con autenticación peer: el usuario del
|
|
# servicio es el rol, sin contraseña que guardar.
|
|
# El motor se elige EXPLÍCITO con NEXXA_ESTADO=pg (drop-in systemd de los dos servicios); sin la variable, archivo.
|
|
# Nunca cae solo de pg a archivo: nexxa-http y nexxa con motores distintos partirían el estado en dos.
|
|
#
|
|
# mutar(clave) { |v| ...; v } es leer-modificar-guardar ATÓMICO: SELECT ... FOR UPDATE en una transacción (pg) o
|
|
# flock exclusivo (archivo). Antes los dos servicios leían, modificaban y guardaban el mismo archivo sin bloqueo.
|
|
# ==============================================================================
|
|
|
|
require 'json'
|
|
require 'monitor'
|
|
require 'time'
|
|
|
|
module Nexxa
|
|
module Estado
|
|
MOTORES = %w[archivo pg].freeze
|
|
DIR = __dir__
|
|
USOS_LOG = File.join(__dir__, 'usos.log').freeze
|
|
MONITOR = Monitor.new
|
|
# Fuente única clave → archivo del motor archivo (los libs toman su STATE_FILE de acá y cli_estado recorre esto)
|
|
ARCHIVOS = {
|
|
'registro' => 'registro.json', 'tokens' => 'tokens.json', 'pools' => 'pools.json',
|
|
'checkins' => 'checkins.json', 'usuarios' => '.usuarios.json', 'sesiones' => '.sessions.json'
|
|
}.freeze
|
|
DEFECTOS = {
|
|
'registro' => { 'keys' => [] }, 'tokens' => { 'tokens' => [] }, 'pools' => { 'individuos' => {} },
|
|
'checkins' => {}, 'usuarios' => [], 'sesiones' => {}
|
|
}.freeze
|
|
|
|
module_function
|
|
|
|
def motor
|
|
m = ENV.fetch('NEXXA_ESTADO', 'archivo')
|
|
raise ArgumentError, "NEXXA_ESTADO=#{m} inválido (#{MOTORES.join('|')})" unless MOTORES.include?(m)
|
|
|
|
m
|
|
end
|
|
|
|
def pg?
|
|
motor == 'pg'
|
|
end
|
|
|
|
def ruta(clave)
|
|
File.join(DIR, ARCHIVOS.fetch(clave))
|
|
end
|
|
|
|
# archivo: ruta del JSON de esa clave (el mismo nombre que tenía antes de esta capa)
|
|
def leer(clave, archivo, defecto)
|
|
pg? ? pg_leer(clave, defecto) : archivo_leer(archivo, defecto)
|
|
end
|
|
|
|
def guardar(clave, archivo, valor)
|
|
pg? ? pg_guardar(clave, valor) : archivo_guardar(archivo, valor)
|
|
valor
|
|
end
|
|
|
|
def mutar(clave, archivo, defecto)
|
|
if pg?
|
|
# BEGIN/COMMIT a mano con ensure: un error o un 'return' dentro del bloque (salida no local) hacen ROLLBACK y
|
|
# nunca dejan la conexión a mitad de una transacción. Igual que el motor archivo: sin salida normal no se guarda.
|
|
# Los bloques no usan 'return'.
|
|
sincronizado do
|
|
con.exec('BEGIN')
|
|
begin
|
|
con.exec_params('INSERT INTO estado (clave, valor) VALUES ($1, $2::jsonb) ON CONFLICT (clave) DO NOTHING',
|
|
[clave, JSON.generate(defecto)])
|
|
fila = con.exec_params('SELECT valor FROM estado WHERE clave = $1 FOR UPDATE', [clave]).first
|
|
nuevo = yield(JSON.parse(fila['valor']))
|
|
con.exec_params('UPDATE estado SET valor = $2::jsonb, actualizado_en = NOW() WHERE clave = $1', [clave, JSON.generate(nuevo)])
|
|
nuevo
|
|
rescue Exception # rubocop:disable Lint/RescueException -- todo error deshace y se re-lanza
|
|
con.exec('ROLLBACK')
|
|
raise
|
|
else
|
|
con.exec('COMMIT')
|
|
nuevo
|
|
ensure
|
|
con.exec('ROLLBACK') unless con.transaction_status.zero? # 0 = PQTRANS_IDLE
|
|
end
|
|
end
|
|
else
|
|
File.open("#{archivo}.lock", File::RDWR | File::CREAT, 0o600) do |l|
|
|
l.flock(File::LOCK_EX)
|
|
nuevo = yield(archivo_leer(archivo, defecto))
|
|
archivo_guardar(archivo, nuevo)
|
|
nuevo
|
|
end
|
|
end
|
|
end
|
|
|
|
# ---------- usos (append-only) ----------
|
|
|
|
def usos_registrar(linea)
|
|
pg? ? usos_registrar_pg(linea) : File.open(USOS_LOG, 'a') { |f| f.puts(linea.to_json) }
|
|
end
|
|
|
|
def usos_registrar_pg(linea)
|
|
sincronizado do
|
|
con.exec_params('INSERT INTO usos (provider, identificador, individuo, evento, en, motivo, hasta) ' \
|
|
'VALUES ($1, $2, $3, $4, $5, $6, $7)',
|
|
linea.values_at('provider', 'identificador', 'individuo', 'evento', 'en', 'motivo', 'hasta'))
|
|
end
|
|
end
|
|
|
|
FILTROS_USOS = %w[provider identificador individuo evento].freeze
|
|
|
|
# Más reciente primero. Filtros exactos por campo y 'desde' (Time) para una ventana (P337/Fase 1)
|
|
def usos_historial(provider: nil, identificador: nil, individuo: nil, evento: nil, desde: nil, limit: 100)
|
|
f = { 'provider' => provider, 'identificador' => identificador, 'individuo' => individuo, 'evento' => evento }
|
|
return usos_archivo(f, desde, limit) unless pg?
|
|
|
|
sincronizado do
|
|
con.exec_params(<<~SQL, f.values_at(*FILTROS_USOS) + [desde&.iso8601, limit]).map { |u| normalizar_uso(u) }
|
|
SELECT provider, identificador, individuo, evento, en, motivo, hasta FROM usos
|
|
WHERE ($1::text IS NULL OR provider = $1) AND ($2::text IS NULL OR identificador = $2)
|
|
AND ($3::text IS NULL OR individuo = $3) AND ($4::text IS NULL OR evento = $4)
|
|
AND ($5::timestamptz IS NULL OR en >= $5)
|
|
ORDER BY id DESC LIMIT $6
|
|
SQL
|
|
end
|
|
end
|
|
|
|
# Fechas en ISO 8601 con zona, igual en los dos motores
|
|
def normalizar_uso(u)
|
|
u.merge('en' => Time.parse(u['en'].to_s).iso8601, 'hasta' => u['hasta'] && Time.parse(u['hasta'].to_s).iso8601(3),
|
|
'motivo' => u['motivo'])
|
|
end
|
|
|
|
# ---------- motor archivo ----------
|
|
|
|
def archivo_leer(archivo, defecto)
|
|
return defecto unless File.exist?(archivo)
|
|
|
|
JSON.parse(File.read(archivo, encoding: 'UTF-8'))
|
|
rescue JSON::ParserError
|
|
defecto
|
|
end
|
|
|
|
def archivo_guardar(archivo, valor)
|
|
tmp = "#{archivo}.tmp-#{Process.pid}-#{Thread.current.object_id}"
|
|
File.open(tmp, File::WRONLY | File::CREAT | File::TRUNC, 0o600) { |f| f.write(JSON.pretty_generate(valor) + "\n") }
|
|
File.rename(tmp, archivo)
|
|
end
|
|
|
|
def usos_archivo(filtros, desde, limit)
|
|
return [] unless File.exist?(USOS_LOG)
|
|
|
|
lineas = File.readlines(USOS_LOG, encoding: 'UTF-8').filter_map do |l| # locale C del servicio (ME-1216)
|
|
JSON.parse(l)
|
|
rescue JSON::ParserError
|
|
nil
|
|
end
|
|
filtros.each { |campo, valor| lineas.select! { |l| l[campo] == valor } if valor }
|
|
lineas.select! { |l| l['en'] && Time.parse(l['en']) >= desde } if desde
|
|
lineas.last(limit).reverse.map { |u| normalizar_uso(u) }
|
|
end
|
|
|
|
# ---------- motor pg ----------
|
|
|
|
def pg_leer(clave, defecto)
|
|
fila = sincronizado { con.exec_params('SELECT valor FROM estado WHERE clave = $1', [clave]).first }
|
|
fila ? JSON.parse(fila['valor']) : defecto
|
|
end
|
|
|
|
def pg_guardar(clave, valor)
|
|
sincronizado do
|
|
con.exec_params('INSERT INTO estado (clave, valor) VALUES ($1, $2::jsonb) ' \
|
|
'ON CONFLICT (clave) DO UPDATE SET valor = EXCLUDED.valor, actualizado_en = NOW()',
|
|
[clave, JSON.generate(valor)])
|
|
end
|
|
end
|
|
|
|
ESQUEMA = <<~SQL
|
|
CREATE TABLE IF NOT EXISTS estado (
|
|
clave TEXT PRIMARY KEY,
|
|
valor JSONB NOT NULL,
|
|
actualizado_en TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
|
);
|
|
CREATE TABLE IF NOT EXISTS usos (
|
|
id BIGSERIAL PRIMARY KEY,
|
|
provider TEXT NOT NULL,
|
|
identificador TEXT NOT NULL,
|
|
individuo TEXT,
|
|
evento TEXT NOT NULL,
|
|
en TIMESTAMPTZ NOT NULL
|
|
);
|
|
CREATE INDEX IF NOT EXISTS usos_key ON usos (provider, identificador);
|
|
ALTER TABLE usos ADD COLUMN IF NOT EXISTS motivo TEXT;
|
|
ALTER TABLE usos ADD COLUMN IF NOT EXISTS hasta TIMESTAMPTZ;
|
|
CREATE INDEX IF NOT EXISTS usos_en ON usos (en);
|
|
SQL
|
|
|
|
def crear_esquema!
|
|
sincronizado { con.exec(ESQUEMA) }
|
|
end
|
|
|
|
# Conexión única por proceso (inyectable en tests). Monitor reentrante: WEBrick atiende en varios hilos y un bloque
|
|
# de mutar puede llamar a otra operación de Estado.
|
|
def con
|
|
@con ||= begin
|
|
require 'pg'
|
|
c = PG.connect(dbname: ENV.fetch('NEXXA_PG_DB', 'nexxa'))
|
|
c.exec(ESQUEMA) # idempotente: un despliegue que amplía el esquema se aplica solo al arrancar (P337/Fase 1)
|
|
c
|
|
end
|
|
end
|
|
|
|
def con=(otra)
|
|
@con = otra
|
|
end
|
|
|
|
def sincronizado(&)
|
|
MONITOR.synchronize(&)
|
|
end
|
|
end
|
|
end
|