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
@@ -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
|
||||
|
||||
@@ -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`.
|
||||
|
||||
@@ -1 +1 @@
|
||||
1.6.0
|
||||
1.7.0
|
||||
|
||||
@@ -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_<fecha>.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__
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)'
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user