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
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:
co-authored by
Claude Opus 5.5
GEMMA
parent
4df538283f
commit
84d51ed669
@@ -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
|
||||
Reference in New Issue
Block a user