feat(nexxa): estado en su Postgres propio con Nexxa::Estado (motores archivo|pg), mutar atómico y dispensa en un paso; 1.7.0 (P335/F17)
Tests ADN / test (push) Canceled after 0s

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Co-Authored-By: GEMMA <noreply@gemma.dtic>
This commit is contained in:
Ricardo Monla
2026-10-05 02:37:26 -03:00
co-authored by Claude Opus 5.5 GEMMA
parent 4df538283f
commit 84d51ed669
13 changed files with 904 additions and 270 deletions
+206
View File
@@ -0,0 +1,206 @@
# 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) VALUES ($1, $2, $3, $4, $5)',
linea.values_at('provider', 'identificador', 'individuo', 'evento', 'en'))
end
end
# Más reciente primero
def usos_historial(provider: nil, identificador: nil, limit: 50)
return usos_archivo(provider, identificador, limit) unless pg?
sincronizado do
con.exec_params(<<~SQL, [provider, identificador, limit]).map { |f| f.merge('en' => Time.parse(f['en']).iso8601) }
SELECT provider, identificador, individuo, evento, en FROM usos
WHERE ($1::text IS NULL OR provider = $1) AND ($2::text IS NULL OR identificador = $2)
ORDER BY id DESC LIMIT $3
SQL
end
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(provider, identificador, limit)
return [] unless File.exist?(USOS_LOG)
lineas = File.readlines(USOS_LOG).filter_map do |l|
JSON.parse(l)
rescue JSON::ParserError
nil
end
lineas.select! { |l| l['provider'] == provider } if provider
lineas.select! { |l| l['identificador'] == identificador } if identificador
lineas.last(limit).reverse
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);
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'
PG.connect(dbname: ENV.fetch('NEXXA_PG_DB', 'nexxa'))
end
end
def con=(otra)
@con = otra
end
def sincronizado(&)
MONITOR.synchronize(&)
end
end
end