# 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