Files
dtic-DIIAA/servicios/nexxa/organismo/lib_estado.rb
T

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