# 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