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

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Co-Authored-By: GEMMA <noreply@gemma.dtic>
This commit is contained in:
Ricardo Monla
2026-10-05 02:37:26 -03:00
co-authored by Claude Opus 5.5 GEMMA
parent 4df538283f
commit 84d51ed669
13 changed files with 904 additions and 270 deletions
+78 -53
View File
@@ -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