diff --git a/servicios/nexxa/.gitignore b/servicios/nexxa/.gitignore index 88725321..82045d96 100644 --- a/servicios/nexxa/.gitignore +++ b/servicios/nexxa/.gitignore @@ -11,3 +11,7 @@ organismo/pools.json organismo/*.log *.bak* organismo/COMMIT +# Motor archivo de Nexxa::Estado (P335/Fase 17): bloqueos de mutar, temporales de escritura atómica y respaldos de cli_estado +organismo/*.lock +organismo/*.tmp-* +organismo/bkp_estado_*.tgz diff --git a/servicios/nexxa/README.md b/servicios/nexxa/README.md index 2bc26f23..77983f6d 100644 --- a/servicios/nexxa/README.md +++ b/servicios/nexxa/README.md @@ -32,5 +32,11 @@ por consulta, cifrada de punta a punta para el consumidor, y recibe el reporte d Se sube `organismo/VERSION` en el mismo commit del cambio. - **Estado y secretos nunca acá** (ver `.gitignore`): `registro.json`, `tokens.json`, usuarios, sesiones, la master key y los logs viven solo en el nodo (Regla de Oro 15). +- **Estado en su Postgres propio** (P335/Fase 17, decisión del Operador 2026-10-05: NEXXA sigue en pie aunque srv-ns8 + caiga): todo pasa por `organismo/lib_estado.rb` (`Nexxa::Estado`), con motor `archivo` (JSON 0600, el de siempre y el + de los tests) o `pg` (base `nexxa` local, socket peer con el usuario del servicio, sin contraseña), elegido EXPLÍCITO con + `NEXXA_ESTADO=pg` en un drop-in systemd de los dos servicios. `mutar` es leer-modificar-guardar atómico y la dispensa + elige y reserva la key en un solo paso. Pasar de un motor al otro: `organismo/cli_estado.rb migrar|verificar|exportar`, + que desde GEMMA corre `gemma nexxa estado:pg --accion preparar|activar|revertir`. Plan vigente: `dtic-GEMMA/_docs/DIIAA/p_P335_nexxa-pools-por-individuo-mente-y-red-con-gestion-web.md`. diff --git a/servicios/nexxa/organismo/VERSION b/servicios/nexxa/organismo/VERSION index dc1e644a..bd8bf882 100644 --- a/servicios/nexxa/organismo/VERSION +++ b/servicios/nexxa/organismo/VERSION @@ -1 +1 @@ -1.6.0 +1.7.0 diff --git a/servicios/nexxa/organismo/cli_estado.rb b/servicios/nexxa/organismo/cli_estado.rb new file mode 100644 index 00000000..40fe5e10 --- /dev/null +++ b/servicios/nexxa/organismo/cli_estado.rb @@ -0,0 +1,132 @@ +# frozen_string_literal: true + +# cli_estado.rb — Mover el estado de NEXXA entre el motor archivo y su Postgres propio (P335/Fase 17) +# ============================================================================== +# Corre EN el nodo, en organismo/, con el usuario del servicio (autenticación peer al Postgres local): +# ruby cli_estado.rb esquema # crea las tablas estado y usos si faltan +# ruby cli_estado.rb migrar # archivos → pg. Respalda los JSON y usos.log en bkp_estado_.tgz antes de +# # escribir. Idempotente: una segunda corrida informa 'igual' en todo y no escribe. +# ruby cli_estado.rb verificar # pg == archivos clave por clave y usos por cantidad; sale 1 si difiere +# ruby cli_estado.rb exportar # pg → archivos: la VUELTA ATRÁS (respaldo previo de lo que haya en disco) +# Independiente de NEXXA_ESTADO: lee y escribe los dos motores explícitamente. Nunca imprime valores, solo claves y +# conteos (el registro tiene los secretos cifrados y usuarios los hashes). +# ============================================================================== + +require 'json' +require 'time' +require_relative 'lib_estado' + +module Nexxa + module CliEstado + E = Nexxa::Estado + USO = 'ruby cli_estado.rb esquema|migrar|verificar|exportar' + + module_function + + def call(accion, salida: $stdout) + case accion + when 'esquema' + E.crear_esquema! + salida.puts('✅ tablas estado y usos listas') + 0 + when 'migrar' then migrar(salida) + when 'verificar' then verificar(salida) + when 'exportar' then exportar(salida) + else + salida.puts("Uso: #{USO}") + 2 + end + end + + def migrar(salida) + E.crear_esquema! + dif = diferencias + if dif.values.none? + salida.puts('✅ igual: pg ya coincide con los archivos, nada que migrar') + return 0 + end + + salida.puts("🗄 respaldo: #{respaldar}") + E::ARCHIVOS.each_key do |clave| + next salida.puts(" = #{clave}: igual") unless dif[clave] + + E.pg_guardar(clave, E.archivo_leer(E.ruta(clave), E::DEFECTOS[clave])) + salida.puts(" → #{clave}: migrada") + end + if dif['usos'] + n_pg = contar_usos_pg + unless n_pg.zero? + salida.puts("❌ usos: pg ya tiene #{n_pg} fila(s) que no coinciden con usos.log (#{usos_archivo.size}); no reimporto para no duplicar") + return 1 + end + usos_archivo.each { |u| E.usos_registrar_pg(u) } + salida.puts(" → usos: #{usos_archivo.size} fila(s)") + end + verificar(salida) + end + + def verificar(salida) + dif = diferencias + dif.each { |clave, distinta| salida.puts(" #{distinta ? '≠' : '='} #{clave}") } + if dif.values.any? + salida.puts("❌ pg difiere de los archivos en: #{dif.select { |_, d| d }.keys.join(', ')}") + 1 + else + salida.puts("✅ pg coincide con los archivos (#{E::ARCHIVOS.size} claves, #{contar_usos_pg} usos)") + 0 + end + end + + def exportar(salida) + salida.puts("🗄 respaldo de lo que había en disco: #{respaldar}") + E::ARCHIVOS.each_key do |clave| + fila = E.sincronizado { E.con.exec_params('SELECT valor FROM estado WHERE clave = $1', [clave]).first } + next salida.puts(" · #{clave}: no está en pg, el archivo queda como estaba") unless fila + + E.archivo_guardar(E.ruta(clave), JSON.parse(fila['valor'])) + salida.puts(" ← #{clave}") + end + usos = E.sincronizado { E.con.exec('SELECT provider, identificador, individuo, evento, en FROM usos ORDER BY id').to_a } + File.open("#{E::USOS_LOG}.tmp", 'w', 0o600) do |f| + usos.each { |u| f.puts(u.merge('en' => Time.parse(u['en']).iso8601).to_json) } + end + File.rename("#{E::USOS_LOG}.tmp", E::USOS_LOG) + salida.puts(" ← usos: #{usos.size} fila(s)") + verificar(salida) + end + + # { clave => true si pg difiere del archivo, ..., 'usos' => true si la cantidad difiere } + def diferencias + d = E::ARCHIVOS.keys.to_h do |clave| + [clave, E.pg_leer(clave, nil) != E.archivo_leer(E.ruta(clave), E::DEFECTOS[clave])] + end + d.merge('usos' => contar_usos_pg != usos_archivo.size) + end + + def contar_usos_pg + E.sincronizado { E.con.exec('SELECT count(*) AS n FROM usos').first['n'].to_i } + end + + def usos_archivo + @usos_archivo ||= begin + return [] unless File.exist?(E::USOS_LOG) + + File.readlines(E::USOS_LOG).filter_map do |l| + JSON.parse(l) + rescue JSON::ParserError + nil + end + end + end + + def respaldar + archivos = (E::ARCHIVOS.values + ['usos.log']).select { |a| File.exist?(File.join(E::DIR, a)) } + tgz = File.join(E::DIR, "bkp_estado_#{Time.now.strftime('%Y%m%d%H%M%S')}.tgz") + system('tar', 'czf', tgz, '-C', E::DIR, *archivos, exception: true) unless archivos.empty? + File.chmod(0o600, tgz) if File.exist?(tgz) + archivos.empty? ? 'sin archivos que respaldar' : tgz + end + end +end + +exit Nexxa::CliEstado.call(ARGV.first) if $PROGRAM_NAME == __FILE__ diff --git a/servicios/nexxa/organismo/lib_auth.rb b/servicios/nexxa/organismo/lib_auth.rb index d02058c9..46973d5b 100644 --- a/servicios/nexxa/organismo/lib_auth.rb +++ b/servicios/nexxa/organismo/lib_auth.rb @@ -31,28 +31,25 @@ require 'securerandom' require 'openssl' require 'base64' require 'time' +require_relative 'lib_estado' module Nexxa module Auth - USERS_FILE = File.expand_path('.usuarios.json', __dir__).freeze - SESSIONS_FILE = File.expand_path('.sessions.json', __dir__).freeze + USERS_FILE = Estado.ruta('usuarios') + SESSIONS_FILE = Estado.ruta('sesiones') PBKDF2_ITER = 100_000 SESSION_TTL = 8 * 3600 # 8 horas — re-login diario razonable PERFILES_VALIDOS = %w[admin operador].freeze # ---------- Usuarios ---------- + # Estado vía Nexxa::Estado (P335/Fase 17) def self.leer_usuarios - return [] unless File.exist?(USERS_FILE) - - JSON.parse(File.read(USERS_FILE)) - rescue JSON::ParserError - [] + Estado.leer('usuarios', USERS_FILE, []) end def self.guardar_usuarios(lista) - File.write(USERS_FILE, JSON.pretty_generate(lista) + "\n") - File.chmod(0o600, USERS_FILE) + Estado.guardar('usuarios', USERS_FILE, lista) end def self.derivar(password, salt) @@ -68,20 +65,21 @@ module Nexxa raise 'Usuario vacío' if usuario.empty? raise "Perfil inválido: #{perfil} (válidos: #{PERFILES_VALIDOS.join(', ')})" unless PERFILES_VALIDOS.include?(perfil) - lista = leer_usuarios - raise "Usuario '#{usuario}' ya existe" if lista.any? { |u| u['usuario'] == usuario } + Estado.mutar('usuarios', USERS_FILE, []) do |lista| + raise "Usuario '#{usuario}' ya existe" if lista.any? { |u| u['usuario'] == usuario } - salt = SecureRandom.random_bytes(16) - hash = derivar(password, salt) - lista << { - 'usuario' => usuario, - 'perfil' => perfil, - 'salt' => Base64.strict_encode64(salt), - 'hash' => Base64.strict_encode64(hash), - 'activo' => true, - 'creado' => Time.now.iso8601 - } - guardar_usuarios(lista) + salt = SecureRandom.random_bytes(16) + hash = derivar(password, salt) + lista << { + 'usuario' => usuario, + 'perfil' => perfil, + 'salt' => Base64.strict_encode64(salt), + 'hash' => Base64.strict_encode64(hash), + 'activo' => true, + 'creado' => Time.now.iso8601 + } + lista + end usuario end @@ -112,21 +110,23 @@ module Nexxa # Edita perfil/activo de un usuario existente. password_nueva opcional # (rotación). raise si no existe o el perfil no es válido. def self.actualizar(usuario:, perfil: nil, activo: nil, password_nueva: nil) - lista = leer_usuarios - entrada = lista.find { |u| u['usuario'] == usuario.to_s.strip } - raise "Usuario '#{usuario}' no encontrado" unless entrada + entrada = nil + Estado.mutar('usuarios', USERS_FILE, []) do |lista| + entrada = lista.find { |u| u['usuario'] == usuario.to_s.strip } + raise "Usuario '#{usuario}' no encontrado" unless entrada - if perfil - raise "Perfil inválido: #{perfil} (válidos: #{PERFILES_VALIDOS.join(', ')})" unless PERFILES_VALIDOS.include?(perfil) - entrada['perfil'] = perfil + if perfil + raise "Perfil inválido: #{perfil} (válidos: #{PERFILES_VALIDOS.join(', ')})" unless PERFILES_VALIDOS.include?(perfil) + entrada['perfil'] = perfil + end + entrada['activo'] = activo unless activo.nil? + if password_nueva && !password_nueva.to_s.strip.empty? + salt = SecureRandom.random_bytes(16) + entrada['salt'] = Base64.strict_encode64(salt) + entrada['hash'] = Base64.strict_encode64(derivar(password_nueva, salt)) + end + lista end - entrada['activo'] = activo unless activo.nil? - if password_nueva && !password_nueva.to_s.strip.empty? - salt = SecureRandom.random_bytes(16) - entrada['salt'] = Base64.strict_encode64(salt) - entrada['hash'] = Base64.strict_encode64(derivar(password_nueva, salt)) - end - guardar_usuarios(lista) entrada.reject { |k, _| %w[salt hash].include?(k) } end @@ -134,9 +134,11 @@ module Nexxa # de impedir que el último admin se borre a sí mismo (guardia de negocio, # no de esta capa de datos). def self.eliminar(usuario) - lista = leer_usuarios - existia = lista.reject! { |u| u['usuario'] == usuario.to_s.strip } - guardar_usuarios(lista) if existia + existia = nil + Estado.mutar('usuarios', USERS_FILE, []) do |lista| + existia = lista.reject! { |u| u['usuario'] == usuario.to_s.strip } + lista + end !existia.nil? end @@ -147,27 +149,23 @@ module Nexxa # ---------- Sesiones ---------- def self.leer_sesiones - return {} unless File.exist?(SESSIONS_FILE) - - JSON.parse(File.read(SESSIONS_FILE)) - rescue JSON::ParserError - {} + Estado.leer('sesiones', SESSIONS_FILE, {}) end def self.guardar_sesiones(sesiones) - File.write(SESSIONS_FILE, JSON.pretty_generate(sesiones) + "\n") - File.chmod(0o600, SESSIONS_FILE) + Estado.guardar('sesiones', SESSIONS_FILE, sesiones) end def self.crear_sesion(usuario, perfil) token = SecureRandom.hex(32) - sesiones = leer_sesiones - sesiones[token] = { - 'usuario' => usuario, - 'perfil' => perfil, - 'expira' => (Time.now + SESSION_TTL).iso8601 - } - guardar_sesiones(sesiones) + Estado.mutar('sesiones', SESSIONS_FILE, {}) do |sesiones| + sesiones[token] = { + 'usuario' => usuario, + 'perfil' => perfil, + 'expira' => (Time.now + SESSION_TTL).iso8601 + } + sesiones + end token end @@ -175,13 +173,12 @@ module Nexxa def self.sesion(token) return nil if token.to_s.strip.empty? - sesiones = leer_sesiones - entrada = sesiones[token] + entrada = leer_sesiones[token] return nil unless entrada + # Vencida: se borra con la escritura atómica de cerrar_sesion (la lectura de cada pedido web no toma bloqueo) if Time.parse(entrada['expira']) < Time.now - sesiones.delete(token) - guardar_sesiones(sesiones) + cerrar_sesion(token) return nil end @@ -193,9 +190,11 @@ module Nexxa end def self.cerrar_sesion(token) - sesiones = leer_sesiones - existia = sesiones.delete(token) - guardar_sesiones(sesiones) if existia + existia = nil + Estado.mutar('sesiones', SESSIONS_FILE, {}) do |sesiones| + existia = sesiones.delete(token) + sesiones + end !existia.nil? end end diff --git a/servicios/nexxa/organismo/lib_checkins.rb b/servicios/nexxa/organismo/lib_checkins.rb index 38461135..b2f3ecd3 100644 --- a/servicios/nexxa/organismo/lib_checkins.rb +++ b/servicios/nexxa/organismo/lib_checkins.rb @@ -11,35 +11,37 @@ require 'json' require 'time' +require_relative 'lib_estado' module Nexxa module Checkins - STATE_FILE = File.expand_path('checkins.json', __dir__).freeze + STATE_FILE = Estado.ruta('checkins') + # Estado vía Nexxa::Estado (P335/Fase 17) def self.leer - return {} unless File.exist?(STATE_FILE) - - JSON.parse(File.read(STATE_FILE)) - rescue JSON::ParserError - {} + Estado.leer('checkins', STATE_FILE, {}) end def self.guardar(state) - File.write(STATE_FILE, JSON.pretty_generate(state) + "\n") - File.chmod(0o600, STATE_FILE) + Estado.guardar('checkins', STATE_FILE, state) + end + + def self.mutar(&) + Estado.mutar('checkins', STATE_FILE, {}, &) end # El individuo llega autenticado (individuo_autenticado(req) en server.rb, # vía Nexxa::Tokens.verificar) — nunca confiar en un id que venga en el # body, el token YA identifica quién reporta. def self.registrar(individuo, estado:, detalle: nil) - state = leer - state[individuo] = { - 'estado' => estado.to_s, - 'detalle' => detalle, - 'ultimo_reporte' => Time.now.utc.iso8601 - } - guardar(state) + mutar do |state| + state[individuo] = { + 'estado' => estado.to_s, + 'detalle' => detalle, + 'ultimo_reporte' => Time.now.utc.iso8601 + } + state + end state[individuo] end diff --git a/servicios/nexxa/organismo/lib_estado.rb b/servicios/nexxa/organismo/lib_estado.rb new file mode 100644 index 00000000..9b960538 --- /dev/null +++ b/servicios/nexxa/organismo/lib_estado.rb @@ -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 diff --git a/servicios/nexxa/organismo/lib_pools.rb b/servicios/nexxa/organismo/lib_pools.rb index cd47dda4..57037dca 100644 --- a/servicios/nexxa/organismo/lib_pools.rb +++ b/servicios/nexxa/organismo/lib_pools.rb @@ -14,28 +14,31 @@ # Referencia de una key en un pool: "provider/identificador" (las dos partes juntas la identifican en registro.json). require 'json' +require_relative 'lib_estado' module Nexxa module Pools - STATE_FILE = File.expand_path('pools.json', __dir__).freeze + STATE_FILE = Estado.ruta('pools') ROLES = %w[mente red].freeze module_function + # Estado vía Nexxa::Estado (P335/Fase 17) def leer - return { 'individuos' => {} } unless File.exist?(STATE_FILE) - - d = JSON.parse(File.read(STATE_FILE)) + d = Estado.leer('pools', STATE_FILE, { 'individuos' => {} }) d['individuos'] ||= {} d - rescue JSON::ParserError - { 'individuos' => {} } end def guardar(state) - tmp = "#{STATE_FILE}.tmp-#{Process.pid}" - File.open(tmp, File::WRONLY | File::CREAT | File::TRUNC, 0o600) { |f| f.write(JSON.pretty_generate(state) + "\n") } - File.rename(tmp, STATE_FILE) + Estado.guardar('pools', STATE_FILE, state) + end + + def mutar + Estado.mutar('pools', STATE_FILE, { 'individuos' => {} }) do |d| + d['individuos'] ||= {} + yield d + end end def ref(provider, identificador) @@ -53,25 +56,30 @@ module Nexxa existe ||= ->(p, i) { Nexxa::Registro.todas.any? { |k| k['provider'] == p && k['identificador'] == i } } raise "Key no encontrada: #{ref(provider, identificador)}" unless existe.call(provider, identificador) - state = leer - pool = (state['individuos'][individuo] ||= {})[rol] ||= [] - r = ref(provider, identificador) - pool << r unless pool.include?(r) - guardar(state) + pool = nil + mutar do |state| + pool = (state['individuos'][individuo] ||= {})[rol] ||= [] + r = ref(provider, identificador) + pool << r unless pool.include?(r) + state + end pool end # Quita una key de un pool. => true si estaba. def quitar(individuo:, rol:, provider:, identificador:) validar!(individuo, rol) - state = leer - pool = state.dig('individuos', individuo, rol) - return false unless pool&.delete(ref(provider, identificador)) - - state['individuos'][individuo].delete(rol) if pool.empty? - state['individuos'].delete(individuo) if state['individuos'][individuo].empty? - guardar(state) - true + quitado = nil + mutar do |state| + pool = state.dig('individuos', individuo, rol) + quitado = pool&.delete(ref(provider, identificador)) + if quitado + state['individuos'][individuo].delete(rol) if pool.empty? + state['individuos'].delete(individuo) if state['individuos'][individuo].empty? + end + state + end + !quitado.nil? end # Deja el pool EXACTAMENTE con estas refs (editar desde nexxa-web, P335/Fase 12). Valida todas antes de escribir: @@ -83,11 +91,12 @@ module Nexxa malas = refs.reject { |r| (p, i = r.split('/', 2)) && i && existe.call(p, i) } raise "Key(s) no encontrada(s): #{malas.join(', ')}" unless malas.empty? - state = leer - roles = (state['individuos'][individuo] ||= {}) - refs.empty? ? roles.delete(rol) : roles[rol] = refs - state['individuos'].delete(individuo) if roles.empty? - guardar(state) + mutar do |state| + roles = (state['individuos'][individuo] ||= {}) + refs.empty? ? roles.delete(rol) : roles[rol] = refs + state['individuos'].delete(individuo) if roles.empty? + state + end refs end @@ -96,49 +105,55 @@ module Nexxa validar!(individuo, de) a = (ROLES - [de.to_s]).first r = ref(provider, identificador) - state = leer - roles = state.dig('individuos', individuo) - raise "#{r} no está en #{individuo}/#{de}" unless roles && Array(roles[de]).include?(r) + mutar do |state| + roles = state.dig('individuos', individuo) + raise "#{r} no está en #{individuo}/#{de}" unless roles && Array(roles[de]).include?(r) - roles[de].delete(r) - roles.delete(de) if roles[de].empty? - (roles[a] ||= []) << r unless Array(roles[a]).include?(r) - guardar(state) + roles[de].delete(r) + roles.delete(de) if roles[de].empty? + (roles[a] ||= []) << r unless Array(roles[a]).include?(r) + state + end a end # Al renombrar una key, sus refs en todos los pools pasan al nombre nuevo (P335/Fase 13) def renombrar_key(provider:, de:, a:) - state = leer - viejo = ref(provider, de) - nuevo = ref(provider, a) - cambio = false - state['individuos'].each_value do |roles| - roles.each_value { |pool| (i = pool.index(viejo)) && (pool[i] = nuevo) && (cambio = true) } + cambio = nil + mutar do |state| + viejo = ref(provider, de) + nuevo = ref(provider, a) + cambio = false + state['individuos'].each_value do |roles| + roles.each_value { |pool| (i = pool.index(viejo)) && (pool[i] = nuevo) && (cambio = true) } + end + state end - guardar(state) if cambio cambio end # Al eliminar una key del registro, se saca de todos los pools (sin referencias colgadas). def olvidar_key(provider:, identificador:) - state = leer - r = ref(provider, identificador) - cambio = false - state['individuos'].each_value { |roles| roles.each_value { |pool| cambio = true if pool.delete(r) } } - state['individuos'].each_value { |roles| roles.delete_if { |_, pool| pool.empty? } } - state['individuos'].delete_if { |_, roles| roles.empty? } - guardar(state) if cambio + cambio = nil + mutar do |state| + r = ref(provider, identificador) + cambio = false + state['individuos'].each_value { |roles| roles.each_value { |pool| cambio = true if pool.delete(r) } } + state['individuos'].each_value { |roles| roles.delete_if { |_, pool| pool.empty? } } + state['individuos'].delete_if { |_, roles| roles.empty? } + state + end cambio end # Al revocar un individuo (sin token ya no puede pedir) sus pools se borran: sin referencias colgadas (P335/F12) def olvidar_individuo(individuo) - state = leer - return false unless state['individuos'].delete(individuo.to_s) - - guardar(state) - true + borrado = nil + mutar do |state| + borrado = state['individuos'].delete(individuo.to_s) + state + end + !borrado.nil? end # Resumen por rol para la sección Individuos y el Dashboard: { 'mente' => {'total'=>, 'disponibles'=>}, ... } @@ -172,6 +187,16 @@ module Nexxa rol?(nombre) ? Nexxa::Registro.disponible_en(refs(individuo, nombre)) : Nexxa::Registro.disponible(nombre) end + # Elegir y reservar la key en UN paso atómico (P335/Fase 17): mismo criterio de candidatas que disponible. + # => entrada reservada, entrada solo-metadata sin reservar (sin valor_cifrado) o nil si no hay libre. + def dispensar(individuo, nombre) + if rol?(nombre) + Nexxa::Registro.reservar_libre(individuo: individuo, refs: refs(individuo, nombre)) + else + Nexxa::Registro.reservar_libre(individuo: individuo, provider: nombre) + end + end + def proxima(individuo, nombre) rol?(nombre) ? Nexxa::Registro.proxima_en(refs(individuo, nombre)) : Nexxa::Registro.proxima(nombre) end diff --git a/servicios/nexxa/organismo/lib_registro.rb b/servicios/nexxa/organismo/lib_registro.rb index 925d3e27..e622fff4 100644 --- a/servicios/nexxa/organismo/lib_registro.rb +++ b/servicios/nexxa/organismo/lib_registro.rb @@ -32,10 +32,11 @@ require 'json' require 'time' require_relative 'lib_cripto' require_relative 'lib_usos' +require_relative 'lib_estado' module Nexxa module Registro - STATE_FILE = File.expand_path('registro.json', __dir__).freeze + STATE_FILE = Estado.ruta('registro') # Reserva corta de contención (P204/Fase3, D045 §8) — no asume agotamiento, # solo evita que 2 consumidores reciban la misma key mientras uno la está @@ -43,18 +44,18 @@ module Nexxa # aparte) si nadie reporta nada; self.reportar la renueva o la libera. RESERVA_TTL_SEGUNDOS = 600 + # Estado vía Nexxa::Estado (P335/Fase 17): archivo o Postgres según NEXXA_ESTADO def self.leer - if File.exist?(STATE_FILE) - JSON.parse(File.read(STATE_FILE)) - else - { 'keys' => [] } - end - rescue JSON::ParserError - { 'keys' => [] } + Estado.leer('registro', STATE_FILE, { 'keys' => [] }) end def self.guardar(state) - File.write(STATE_FILE, JSON.pretty_generate(state) + "\n") + Estado.guardar('registro', STATE_FILE, state) + end + + # Leer-modificar-guardar atómico (nexxa-http y nexxa comparten el registro) + def self.mutar(&) + Estado.mutar('registro', STATE_FILE, { 'keys' => [] }, &) end # provider: "gemini"/"groq"/... ; identificador: ETIQUETA legible (ej. "gemini-01"), @@ -70,56 +71,61 @@ module Nexxa # error, ME-603). Pasar ultimo_uso explícito solo cuando se sabe que la key # SÍ se agotó en ese momento. def self.registrar(provider:, identificador:, cuenta_origen:, reset_segundos:, valor: nil, ultimo_uso: nil) - state = leer ahora = Time.now disponible_desde = ultimo_uso ? (Time.parse(ultimo_uso) + reset_segundos).iso8601(3) : ahora.iso8601(3) ultimo_uso ||= ahora.iso8601(3) valor_cifrado = valor ? cifrar(valor) : nil - existente = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador } - if existente - existente.merge!( - 'ultimo_uso' => ultimo_uso, - 'disponible_desde' => disponible_desde, - 'cuenta_origen' => cuenta_origen, - 'reset_segundos' => reset_segundos - ) - existente['valor_cifrado'] = valor_cifrado if valor_cifrado - else - state['keys'] << { - 'provider' => provider, - 'identificador' => identificador, - 'cuenta_origen' => cuenta_origen, - 'reset_segundos' => reset_segundos, - 'ultimo_uso' => ultimo_uso, - 'ultimo_individuo' => nil, - 'disponible_desde' => disponible_desde, - 'valor_cifrado' => valor_cifrado, - 'activo' => true, - 'reservado_por' => nil, - 'reservado_hasta' => nil - } + mutar do |state| + existente = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador } + if existente + existente.merge!( + 'ultimo_uso' => ultimo_uso, + 'disponible_desde' => disponible_desde, + 'cuenta_origen' => cuenta_origen, + 'reset_segundos' => reset_segundos + ) + existente['valor_cifrado'] = valor_cifrado if valor_cifrado + else + state['keys'] << { + 'provider' => provider, + 'identificador' => identificador, + 'cuenta_origen' => cuenta_origen, + 'reset_segundos' => reset_segundos, + 'ultimo_uso' => ultimo_uso, + 'ultimo_individuo' => nil, + 'disponible_desde' => disponible_desde, + 'valor_cifrado' => valor_cifrado, + 'activo' => true, + 'reservado_por' => nil, + 'reservado_hasta' => nil + } + end + state end - guardar(state) - state end # Edita metadata de una key existente (P201/Fase3) — NUNCA el valor (eso no # se re-muestra, se reemplaza vía 'registrar' con un valor nuevo si hace # falta rotarlo). Cada parámetro es opcional: solo se actualiza lo pasado. def self.actualizar(provider:, identificador:, cuenta_origen: nil, reset_segundos: nil, activo: nil) - state = leer - entrada = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador } - raise "Key no encontrada: #{provider}/#{identificador}" unless entrada - - entrada['cuenta_origen'] = cuenta_origen unless cuenta_origen.nil? - entrada['reset_segundos'] = reset_segundos unless reset_segundos.nil? - entrada['activo'] = activo unless activo.nil? - guardar(state) + entrada = nil + mutar do |state| + entrada = buscar!(state, provider, identificador) + entrada['cuenta_origen'] = cuenta_origen unless cuenta_origen.nil? + entrada['reset_segundos'] = reset_segundos unless reset_segundos.nil? + entrada['activo'] = activo unless activo.nil? + state + end entrada end + def self.buscar!(state, provider, identificador) + state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador } || + raise("Key no encontrada: #{provider}/#{identificador}") + end + IDENTIFICADOR_VALIDO = /\A[a-z0-9][a-z0-9._-]{0,63}\z/.freeze # Cambia el identificador de una key (P335/Fase 13). Único dentro del provider; rechazado mientras esté RESERVADA @@ -130,16 +136,17 @@ module Nexxa raise "Identificador inválido: '#{a}' (minúsculas, números, punto, guion o guion bajo)" unless a.match?(IDENTIFICADOR_VALIDO) return leer['keys'].find { |k| k['provider'] == provider && k['identificador'] == de } if a == de - state = leer - entrada = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == de } - raise "Key no encontrada: #{provider}/#{de}" unless entrada - raise "Ya existe #{provider}/#{a}" if state['keys'].any? { |k| k['provider'] == provider && k['identificador'] == a } - if entrada['reservado_hasta'] && Time.parse(entrada['reservado_hasta']) > ahora - raise "#{provider}/#{de} está reservada por #{entrada['reservado_por']}: esperá a que la libere para renombrarla" - end + entrada = nil + mutar do |state| + entrada = buscar!(state, provider, de) + raise "Ya existe #{provider}/#{a}" if state['keys'].any? { |k| k['provider'] == provider && k['identificador'] == a } + if entrada['reservado_hasta'] && Time.parse(entrada['reservado_hasta']) > ahora + raise "#{provider}/#{de} está reservada por #{entrada['reservado_por']}: esperá a que la libere para renombrarla" + end - entrada['identificador'] = a - guardar(state) + entrada['identificador'] = a + state + end Nexxa::Usos.registrar(provider: provider, identificador: a, individuo: usuario ? "web:#{usuario}" : 'web', en: ahora, evento: "renombrada (antes #{de})") entrada @@ -148,9 +155,11 @@ module Nexxa # Elimina una key del registro — destructivo, sin deshacer (P201/Fase3). # No borra su historial en lib_usos.rb (log append-only, queda como evidencia). def self.eliminar(provider:, identificador:) - state = leer - existia = state['keys'].reject! { |k| k['provider'] == provider && k['identificador'] == identificador } - guardar(state) if existia + existia = nil + mutar do |state| + existia = state['keys'].reject! { |k| k['provider'] == provider && k['identificador'] == identificador } + state + end !existia.nil? end @@ -177,18 +186,43 @@ module Nexxa # self.reportar(estado: 'agotada'), con la señal del consumidor. Se llama # automático al dispensar (server.rb, GET /disponible). def self.reservar(provider:, identificador:, individuo:) - state = leer - entrada = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador } - raise "Key no encontrada: #{provider}/#{identificador}" unless entrada - ahora = Time.now + entrada = nil + mutar do |state| + entrada = aplicar_reserva(buscar!(state, provider, identificador), individuo, ahora) + state + end + Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: 'dispensada') + entrada + end + + # Elegir la key libre y reservarla en UN paso atómico (P335/Fase 17). Antes se elegía (leer) y se reservaba después + # (otro leer/guardar): dos consumidores simultáneos podían recibir la misma key. Candidatas: las refs de un pool + # o todas las de un provider. Una key solo-metadata (sin valor_cifrado, D045 §9) se devuelve SIN reservar para que + # el llamador responda sin_valor_migrado como antes. => entrada (con valor_cifrado) o nil si no hay libre. + def self.reservar_libre(individuo:, refs: nil, provider: nil) + ahora = Time.now + elegida = nil + mutar do |state| + candidatas = state['keys'].select do |k| + refs ? Array(refs).include?("#{k['provider']}/#{k['identificador']}") : k['provider'] == provider + end + elegida = elegir_libre(candidatas) + aplicar_reserva(elegida, individuo, ahora) if elegida && elegida['valor_cifrado'] + state + end + if elegida && elegida['valor_cifrado'] + Nexxa::Usos.registrar(provider: elegida['provider'], identificador: elegida['identificador'], individuo: individuo, + en: ahora, evento: 'dispensada') + end + elegida + end + + def self.aplicar_reserva(entrada, individuo, ahora) entrada['ultimo_uso'] = ahora.iso8601(3) entrada['ultimo_individuo'] = individuo entrada['reservado_por'] = individuo entrada['reservado_hasta'] = (ahora + RESERVA_TTL_SEGUNDOS).iso8601(3) - guardar(state) - - Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: 'dispensada') entrada end @@ -208,57 +242,67 @@ module Nexxa # 2026-10-01 19:46: un 429 por minuto reportado como agotada bloqueó el pool compartido y el consumidor no podía # revertirlo (409). Solo el autor del reporte: nadie libera lo que bloqueó otro. def self.reportar(provider:, identificador:, individuo:, estado:, liberar_en_segundos: nil, motivo: nil) - state = leer - entrada = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador } - raise "Key no encontrada: #{provider}/#{identificador}" unless entrada - ahora = Time.now - if estado == 'liberada' && entrada['reservado_por'] != individuo && revertible_por?(entrada, individuo, ahora) - entrada['disponible_desde'] = ahora.iso8601(3) - entrada['agotada_por'] = nil - guardar(state) - Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: 'revertida') - return entrada - end - raise "Key #{provider}/#{identificador} no está reservada por #{individuo}" unless entrada['reservado_por'] == individuo + entrada = nil + evento = nil + mutar do |state| # sin 'return' adentro (P335/Fase 17): el bloque es una transacción + entrada = buscar!(state, provider, identificador) + if estado == 'liberada' && entrada['reservado_por'] != individuo && revertible_por?(entrada, individuo, ahora) + entrada['disponible_desde'] = ahora.iso8601(3) + entrada['agotada_por'] = nil + evento = 'revertida' + else + raise "Key #{provider}/#{identificador} no está reservada por #{individuo}" unless entrada['reservado_por'] == individuo + evento = aplicar_reporte(entrada, estado, individuo, ahora, liberar_en_segundos, motivo) + end + state + end + Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: evento) if evento + entrada + end + + # => evento de usos a registrar ('agotada') o nil + def self.aplicar_reporte(entrada, estado, individuo, ahora, liberar_en_segundos, motivo) case estado when 'sana' entrada['reservado_hasta'] = (ahora + RESERVA_TTL_SEGUNDOS).iso8601(3) + nil when 'liberada' entrada['reservado_por'] = nil entrada['reservado_hasta'] = nil + nil when 'agotada' reset_segundos = entrada['reset_segundos'] - raise "Key #{provider}/#{identificador} sin reset_segundos persistido — no se puede reportar agotada" unless reset_segundos + unless reset_segundos + raise "Key #{entrada['provider']}/#{entrada['identificador']} sin reset_segundos persistido — no se puede reportar agotada" + end entrada['disponible_desde'] = (ahora + (liberar_en_segundos || reset_segundos)).iso8601(3) entrada['agotada_por'] = individuo entrada['motivo_agotada'] = motivo.to_s[0, 200] unless motivo.to_s.empty? entrada['reservado_por'] = nil entrada['reservado_hasta'] = nil - Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: 'agotada') + 'agotada' else raise "estado inválido: #{estado} (esperado: sana|liberada|agotada)" end - guardar(state) - entrada end # Liberación por un ADMIN desde nexxa-web (P335/Fase 7): la key queda disponible ya, sin reserva ni marca de # agotada, sea quien sea que la bloqueó. El rastro queda en usos ('liberada-admin', con el usuario de la web). def self.liberar_admin(provider:, identificador:, usuario:) - state = leer - entrada = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador } - raise "Key no encontrada: #{provider}/#{identificador}" unless entrada - ahora = Time.now - entrada['disponible_desde'] = ahora.iso8601(3) if Time.parse(entrada['disponible_desde']) > ahora - entrada['reservado_por'] = nil - entrada['reservado_hasta'] = nil - entrada['agotada_por'] = nil - entrada['motivo_agotada'] = nil - guardar(state) + entrada = nil + mutar do |state| + entrada = buscar!(state, provider, identificador) + entrada['disponible_desde'] = ahora.iso8601(3) if Time.parse(entrada['disponible_desde']) > ahora + entrada['reservado_por'] = nil + entrada['reservado_hasta'] = nil + entrada['agotada_por'] = nil + entrada['motivo_agotada'] = nil + state + end Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: "web:#{usuario}", en: ahora, evento: 'liberada-admin') entrada diff --git a/servicios/nexxa/organismo/lib_tokens.rb b/servicios/nexxa/organismo/lib_tokens.rb index 6f3cbf26..9b4713c6 100644 --- a/servicios/nexxa/organismo/lib_tokens.rb +++ b/servicios/nexxa/organismo/lib_tokens.rb @@ -14,24 +14,23 @@ require 'securerandom' require 'digest' require 'time' require 'openssl' +require_relative 'lib_estado' module Nexxa module Tokens - STATE_FILE = File.expand_path('tokens.json', __dir__).freeze + STATE_FILE = Estado.ruta('tokens') + # Estado vía Nexxa::Estado (P335/Fase 17) def self.leer - if File.exist?(STATE_FILE) - JSON.parse(File.read(STATE_FILE)) - else - { 'tokens' => [] } - end - rescue JSON::ParserError - { 'tokens' => [] } + Estado.leer('tokens', STATE_FILE, { 'tokens' => [] }) end def self.guardar(state) - File.write(STATE_FILE, JSON.pretty_generate(state) + "\n") - File.chmod(0o600, STATE_FILE) + Estado.guardar('tokens', STATE_FILE, state) + end + + def self.mutar(&) + Estado.mutar('tokens', STATE_FILE, { 'tokens' => [] }, &) end # Genera un token nuevo para un individuo — devuelve el token EN CLARO, @@ -40,14 +39,15 @@ module Nexxa # (rotación simple). def self.generar(individuo) token = SecureRandom.hex(32) - state = leer - state['tokens'].reject! { |t| t['individuo'] == individuo } - state['tokens'] << { - 'individuo' => individuo, - 'token_hash' => Digest::SHA256.hexdigest(token), - 'creado' => Time.now.iso8601 - } - guardar(state) + mutar do |state| + state['tokens'].reject! { |t| t['individuo'] == individuo } + state['tokens'] << { + 'individuo' => individuo, + 'token_hash' => Digest::SHA256.hexdigest(token), + 'creado' => Time.now.iso8601 + } + state + end token end @@ -77,9 +77,11 @@ module Nexxa # Revoca el acceso de un individuo — borra su entrada, sin deshacer. El # individuo necesita un token nuevo (generar) para volver a consultar NEXXA. def self.revocar(individuo) - state = leer - existia = state['tokens'].reject! { |t| t['individuo'] == individuo } - guardar(state) if existia + existia = nil + mutar do |state| + existia = state['tokens'].reject! { |t| t['individuo'] == individuo } + state + end !existia.nil? end @@ -96,12 +98,13 @@ module Nexxa # rápido con un error claro en vez de guardar basura silenciosamente. OpenSSL::PKey::RSA.new(clave_publica_pem) - state = leer - entrada = state['tokens'].find { |t| t['individuo'] == individuo } - raise "Individuo sin token: #{individuo}" unless entrada + mutar do |state| + entrada = state['tokens'].find { |t| t['individuo'] == individuo } + raise "Individuo sin token: #{individuo}" unless entrada - entrada['clave_publica_pem'] = clave_publica_pem - guardar(state) + entrada['clave_publica_pem'] = clave_publica_pem + state + end true rescue OpenSSL::PKey::RSAError raise 'Clave pública inválida — se espera PEM RSA (ej. openssl rsa -pubout)' diff --git a/servicios/nexxa/organismo/lib_usos.rb b/servicios/nexxa/organismo/lib_usos.rb index cee533ff..dbfb1ab3 100644 --- a/servicios/nexxa/organismo/lib_usos.rb +++ b/servicios/nexxa/organismo/lib_usos.rb @@ -10,10 +10,11 @@ require 'json' require 'time' +require_relative 'lib_estado' module Nexxa module Usos - LOG_FILE = File.expand_path('usos.log', __dir__).freeze + LOG_FILE = Estado::USOS_LOG # fuente única de la ruta (P335/Fase 17) # evento (P204/Fase3): 'dispensada' (reserva al entregar la key) o 'agotada' # (el consumidor reportó agotamiento real) — default compat con llamadas @@ -26,21 +27,12 @@ module Nexxa 'evento' => evento, 'en' => en.iso8601 } - File.open(LOG_FILE, 'a') { |f| f.puts(linea.to_json) } + Estado.usos_registrar(linea) end - # Historial más reciente primero, opcionalmente filtrado por key + # Historial más reciente primero, opcionalmente filtrado por key (Nexxa::Estado, P335/Fase 17) def self.historial(provider: nil, identificador: nil, limit: 50) - return [] unless File.exist?(LOG_FILE) - - lineas = File.readlines(LOG_FILE).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 + Estado.usos_historial(provider: provider, identificador: identificador, limit: limit) end end end diff --git a/servicios/nexxa/organismo/server.rb b/servicios/nexxa/organismo/server.rb index 7131955e..e2b39c90 100644 --- a/servicios/nexxa/organismo/server.rb +++ b/servicios/nexxa/organismo/server.rb @@ -702,14 +702,12 @@ server.mount_proc '/disponible' do |req, res| resp = { provider: provider, identificador: identificador, estado: estado } if estado == 'agotada' - siguiente = Nexxa::Pools.disponible(individuo, nombre) # del mismo pool (rol) o del mismo provider - if siguiente - sp = siguiente['provider'] - valor_siguiente = Nexxa::Registro.revelar(provider: sp, identificador: siguiente['identificador']) - if valor_siguiente - Nexxa::Registro.reservar(provider: sp, identificador: siguiente['identificador'], individuo: individuo) - resp[:siguiente] = { provider: sp, identificador: siguiente['identificador'] }.merge(empaquetar_valor(individuo, valor_siguiente)) - end + # Del mismo pool (rol) o del mismo provider, elegida y reservada en un solo paso atómico (P335/Fase 17) + siguiente = Nexxa::Pools.dispensar(individuo, nombre) + if siguiente&.dig('valor_cifrado') + valor_siguiente = Nexxa::Registro.descifrar(siguiente['valor_cifrado']) + resp[:siguiente] = { provider: siguiente['provider'], identificador: siguiente['identificador'] } + .merge(empaquetar_valor(individuo, valor_siguiente)) end end @@ -752,7 +750,9 @@ server.mount_proc '/disponible' do |req, res| end donde = Nexxa::Pools.rol?(nombre) ? { rol: nombre } : { provider: nombre } - key = Nexxa::Pools.disponible(individuo, nombre) + # Elegir y reservar en UN paso atómico (P335/Fase 17): antes se elegía y se reservaba después, y dos consumidores + # simultáneos podían recibir la misma key. dry_run solo mira, nunca reserva. + key = req.query['dry_run'] ? Nexxa::Pools.disponible(individuo, nombre) : Nexxa::Pools.dispensar(individuo, nombre) if key.nil? proxima = Nexxa::Pools.proxima(individuo, nombre) res.status = 404 @@ -777,7 +777,7 @@ server.mount_proc '/disponible' do |req, res| next end - valor = Nexxa::Registro.revelar(provider: provider, identificador: key['identificador']) + valor = key['valor_cifrado'] && Nexxa::Registro.descifrar(key['valor_cifrado']) if valor.nil? # Key registrada solo como metadata (no migrada todavía, D045 §9→§10) — # respuesta explícita, nunca silenciosa (mismo criterio que router.rb) @@ -787,11 +787,8 @@ server.mount_proc '/disponible' do |req, res| next end - # Reserva corta de contención (P204/Fase3, D045 §8) — ya no asume agotamiento - # completo al dispensar (eso lo decide el consumidor vía POST .../reportar); - # solo evita que 2 consumidores reciban la misma key mientras uno la prueba. - Nexxa::Registro.reservar(provider: provider, identificador: key['identificador'], individuo: individuo) - + # La reserva corta de contención (P204/Fase3, D045 §8) ya la aplicó dispensar: no asume agotamiento (eso lo + # decide el consumidor vía POST .../reportar), solo evita que 2 consumidores reciban la misma key. res.status = 200 res.content_type = 'application/json' res.body = { provider: provider, identificador: key['identificador'] }.merge(empaquetar_valor(individuo, valor)).to_json diff --git a/servicios/nexxa/test/estado_test.rb b/servicios/nexxa/test/estado_test.rb new file mode 100644 index 00000000..545bc4be --- /dev/null +++ b/servicios/nexxa/test/estado_test.rb @@ -0,0 +1,224 @@ +# frozen_string_literal: true + +# estado_test.rb — Nexxa::Estado (P335/Fase 17): motor archivo con concurrencia REAL entre procesos y motor pg con una +# conexión simulada (no toca ningún Postgres). Corre sobre una COPIA de organismo/. ruby servicios/nexxa/test/estado_test.rb +require 'minitest/autorun' +require 'tmpdir' +require 'fileutils' +require 'json' +require 'stringio' + +DIR_ESTADO = Dir.mktmpdir('nexxa-estado') +Dir[File.expand_path('../organismo/*.rb', __dir__)].each { |f| FileUtils.cp(f, DIR_ESTADO) } +require File.join(DIR_ESTADO, 'lib_estado') +require File.join(DIR_ESTADO, 'lib_registro') +require File.join(DIR_ESTADO, 'lib_pools') +require File.join(DIR_ESTADO, 'cli_estado') +Minitest.after_run { FileUtils.rm_rf(DIR_ESTADO) } + +class EstadoArchivoTest < Minitest::Test + E = Nexxa::Estado + R = Nexxa::Registro + + def setup + ENV.delete('NEXXA_ESTADO') + FileUtils.rm_f(Dir[File.join(DIR_ESTADO, '*.json')] + [Nexxa::Usos::LOG_FILE]) + end + + def test_sin_variable_el_motor_es_archivo_y_uno_invalido_falla + assert_equal 'archivo', E.motor + ENV['NEXXA_ESTADO'] = 'mongo' + assert_raises(ArgumentError) { E.motor } + ensure + ENV.delete('NEXXA_ESTADO') + end + + def test_guardar_es_0600_y_leer_devuelve_el_defecto_si_falta + ruta = File.join(DIR_ESTADO, 'x.json') + assert_equal({ 'a' => [] }, E.leer('x', ruta, { 'a' => [] })) + E.guardar('x', ruta, { 'a' => [1] }) + assert_equal '600', format('%o', File.stat(ruta).mode & 0o777) + assert_equal({ 'a' => [1] }, E.leer('x', ruta, {})) + end + + # La carrera que cierra la fase: 2 procesos x 50 incrementos sobre el mismo archivo no pierden ninguno + def test_mutar_no_pierde_escrituras_entre_procesos + ruta = File.join(DIR_ESTADO, 'contador.json') + pids = 2.times.map do + fork { 50.times { E.mutar('contador', ruta, { 'n' => 0 }) { |v| v.merge('n' => v['n'] + 1) } } } + end + pids.each { |p| Process.wait(p) } + assert_equal 100, E.leer('contador', ruta, {})['n'] + end + + # Dispensa atómica: 6 procesos piden a la vez de un pool de 3 keys — nunca la misma key a dos, y 3 se quedan sin + def test_dispensar_nunca_entrega_la_misma_key_dos_veces + pasado = (Time.now - 3600).iso8601(3) + R.guardar('keys' => %w[k1 k2 k3].map do |i| + { 'provider' => 'p', 'identificador' => i, 'disponible_desde' => pasado, 'reset_segundos' => 60, 'valor_cifrado' => 'x' } + end) + lectores = 6.times.map do |n| + r, w = IO.pipe + pid = fork do + r.close + w.write(R.reservar_libre(individuo: "ind#{n}", provider: 'p')&.dig('identificador').to_s) + w.close + end + w.close + [pid, r] + end + entregadas = lectores.map { |pid, r| Process.wait(pid) && r.read.tap { r.close } }.reject(&:empty?) + assert_equal %w[k1 k2 k3], entregadas.sort + end + + def test_una_key_solo_metadata_se_devuelve_sin_reservar + R.guardar('keys' => [{ 'provider' => 'p', 'identificador' => 'm', 'disponible_desde' => (Time.now - 60).iso8601(3) }]) + entrada = R.reservar_libre(individuo: 'i', provider: 'p') + assert_equal 'm', entrada['identificador'] + assert_nil R.leer['keys'].first['reservado_por'] + end + + def test_usos_en_archivo_mas_reciente_primero + E.usos_registrar('provider' => 'p', 'identificador' => 'a', 'individuo' => 'i', 'evento' => 'dispensada', 'en' => '2026-10-05T01:00:00-03:00') + E.usos_registrar('provider' => 'p', 'identificador' => 'b', 'individuo' => 'i', 'evento' => 'agotada', 'en' => '2026-10-05T02:00:00-03:00') + assert_equal %w[b a], E.usos_historial.map { |u| u['identificador'] } + assert_equal ['a'], E.usos_historial(identificador: 'a').map { |u| u['identificador'] } + end +end + +# Conexión simulada con la forma de PG::Connection que usa Estado (exec, exec_params, transaction_status) +class ConexionFalsa + attr_reader :sql + + def initialize = (@filas = {}; @usos = []; @sql = []; @tx = 0) + def transaction_status = @tx + + def exec(q) + @sql << q + return [{ 'n' => @usos.size }] if q.start_with?('SELECT count(*)') + return @usos.map { |u| %w[provider identificador individuo evento en].zip(u).to_h } if q.include?('FROM usos ORDER BY id') + + @tx = 2 if q == 'BEGIN' + if %w[COMMIT ROLLBACK].include?(q) + @tx = 0 + @filas = @copia if q == 'ROLLBACK' && @copia + end + @copia = Marshal.load(Marshal.dump(@filas)) if q == 'BEGIN' + [] + end + + def exec_params(q, params) + @sql << q.split.first(2).join(' ') + case q + when /\AINSERT INTO usos/m then @usos << params + when /\AINSERT INTO estado .* DO NOTHING/m then @filas[params[0]] ||= params[1] + when /\AINSERT INTO estado/m, /\AUPDATE estado/m then @filas[params[0]] = params[1] + when /\ASELECT valor FROM estado/m then return @filas.key?(params[0]) ? [{ 'valor' => @filas[params[0]] }] : [] + end + [] + end +end + +class EstadoPgTest < Minitest::Test + E = Nexxa::Estado + + def setup + ENV['NEXXA_ESTADO'] = 'pg' + @c = ConexionFalsa.new + E.con = @c + end + + def teardown + ENV.delete('NEXXA_ESTADO') + E.con = nil + end + + def test_leer_guardar_por_clave_sin_tocar_archivos + assert_equal({ 'keys' => [] }, E.leer('registro', '/no/existe.json', { 'keys' => [] })) + E.guardar('registro', '/no/existe.json', { 'keys' => [1] }) + assert_equal({ 'keys' => [1] }, E.leer('registro', '/no/existe.json', {})) + end + + def test_mutar_hace_begin_commit_y_devuelve_el_valor_nuevo + nuevo = E.mutar('pools', nil, { 'n' => 0 }) { |v| v.merge('n' => v['n'] + 1) } + assert_equal({ 'n' => 1 }, nuevo) + assert_equal 'BEGIN', @c.sql.first + assert_equal 'COMMIT', @c.sql.last + assert(@c.sql.any? { |q| q.include?('SELECT') }) + assert_equal 0, @c.transaction_status + end + + def test_un_error_en_el_bloque_hace_rollback_y_no_guarda + E.guardar('pools', nil, { 'n' => 5 }) + assert_raises(RuntimeError) { E.mutar('pools', nil, {}) { |_v| raise 'no' } } + assert_includes @c.sql, 'ROLLBACK' + assert_equal 0, @c.transaction_status + assert_equal({ 'n' => 5 }, E.leer('pools', nil, {})) + end + + def salida_no_local + E.mutar('pools', nil, {}) { |_v| return :afuera } + end + + def test_un_return_en_el_bloque_no_deja_la_transaccion_abierta + assert_equal :afuera, salida_no_local + assert_equal 'ROLLBACK', @c.sql.last + assert_equal 0, @c.transaction_status + end +end + +class CliEstadoTest < Minitest::Test + E = Nexxa::Estado + C = Nexxa::CliEstado + + def setup + ENV.delete('NEXXA_ESTADO') + FileUtils.rm_f(Dir[File.join(DIR_ESTADO, '{*.json,.*.json,*.tgz}')] + [E::USOS_LOG]) + E.con = ConexionFalsa.new + C.instance_variable_set(:@usos_archivo, nil) + E.archivo_guardar(E.ruta('registro'), { 'keys' => [{ 'provider' => 'p', 'identificador' => 'k1' }] }) + E.archivo_guardar(E.ruta('usuarios'), [{ 'usuario' => 'admin' }]) + File.write(E::USOS_LOG, %({"provider":"p","identificador":"k1","individuo":"i","evento":"dispensada","en":"2026-10-05T01:00:00-03:00"}\n)) + end + + def teardown + E.con = nil + end + + def corre(accion) + out = StringIO.new + [C.call(accion, salida: out), out.string] + end + + def test_migrar_es_idempotente_y_respalda_antes_de_escribir + codigo, texto = corre('migrar') + assert_equal 0, codigo, texto + assert_match(/registro: migrada/, texto) + assert_equal 1, Dir[File.join(DIR_ESTADO, 'bkp_estado_*.tgz')].size + assert_equal({ 'keys' => [{ 'provider' => 'p', 'identificador' => 'k1' }] }, E.pg_leer('registro', nil)) + + codigo2, texto2 = corre('migrar') + assert_equal 0, codigo2 + assert_match(/igual: pg ya coincide/, texto2) + assert_equal 1, Dir[File.join(DIR_ESTADO, 'bkp_estado_*.tgz')].size, 'la segunda corrida no respalda ni escribe' + end + + def test_verificar_detecta_una_diferencia + corre('migrar') + E.archivo_guardar(E.ruta('pools'), { 'individuos' => { 'gemma' => { 'mente' => ['p/k1'] } } }) + codigo, texto = corre('verificar') + assert_equal 1, codigo + assert_match(/difiere de los archivos en: pools/, texto) + end + + def test_exportar_es_la_vuelta_atras + corre('migrar') + E.pg_guardar('registro', { 'keys' => [] }) + FileUtils.rm_f(E::USOS_LOG) + codigo, texto = corre('exportar') + assert_equal 0, codigo, texto + assert_equal({ 'keys' => [] }, E.archivo_leer(E.ruta('registro'), nil)) + assert_equal 1, File.readlines(E::USOS_LOG).size + end +end +