Files
dtic-DIIAA/servicios/nexxa/organismo/lib_pools.rb
T
a60758875d
Tests ADN / test (push) Canceled after 0s
feat(nexxa): NEXXA versionada en dtic-DIIAA (1.3.0): pools por individuo mente/red, API por rol y gestión desde nexxa-web
- Base: código de producción de srvv-nexxa (1.2.1), importado y verificado por hash (P335/F3)
- Pools por individuo (lib_pools): mente y red, mezclan proveedores, keys compartidas o exclusivas
- API: /disponible/mente|red y /estado por rol, pool_vacio explícito, /pools (CRUD admin), liberar admin
- Revertir el agotada propio + motivo y quién la agotó (de P334/F4)
- nexxa-web: sección Pools, motivo y botón Liberar, provider libre con sugerencias, escape de texto externo
- Convención REG002: lib_*, cli_*, tool_humo_pool; contratos externos con su nombre
- Suite local sobre copia aislada: humo HTTP, pools, revertir; servidor_prueba para mirar la web

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

Co-Authored-By: GEMMA <noreply@gemma.dtic>
2026-10-04 16:42:13 -03:00

133 lines
5.3 KiB
Ruby

# frozen_string_literal: true
# lib_pools.rb — Pools de keys POR INDIVIDUO: mente y red de seguridad (P335/Fase 4, Operador 2026-10-04)
#
# Cada individuo tiene dos pools: MENTE (las keys con las que piensa y opera) y RED (solo para el aviso de batería
# baja). Un pool MEZCLA proveedores y una key puede estar en varios pools (exclusiva o compartida). Es el TERCER eje de
# una key (ME-609): `cuenta_origen` dice quién la aportó (permanente, informativo), `reservado_por` quién la tiene AHORA
# (efímero) y la asignación a pools es CONFIGURACIÓN permanente que decide un admin desde nexxa-web.
#
# Persistencia: pools.json junto a registro.json (0600). NEXXA guarda todo su estado en JSON en su hábitat y no tiene
# Postgres (REG002 R15 lo pide justificar: un individuo sin BD propia; migrarlo a BD es otra decisión). Separado de
# registro.json a propósito: lo que se edita a mano desde la web (config) no se mezcla con el estado vivo de cada key.
#
# Referencia de una key en un pool: "provider/identificador" (las dos partes juntas la identifican en registro.json).
require 'json'
module Nexxa
module Pools
STATE_FILE = File.expand_path('pools.json', __dir__).freeze
ROLES = %w[mente red].freeze
module_function
def leer
return { 'individuos' => {} } unless File.exist?(STATE_FILE)
d = JSON.parse(File.read(STATE_FILE))
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)
end
def ref(provider, identificador)
"#{provider}/#{identificador}"
end
# Refs del pool de un individuo para un rol. => ["gemini/abby", "deepseek/deepseek-01", ...]
def refs(individuo, rol)
Array(leer.dig('individuos', individuo.to_s, rol.to_s))
end
# Asigna una key al pool. Idempotente. Valida rol y que la key exista en el registro (inyectable para tests).
def asignar(individuo:, rol:, provider:, identificador:, existe: nil)
validar!(individuo, rol)
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
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
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
end
# Pools en los que está una key. => [{ 'individuo' =>, 'rol' => }]
def de_key(provider, identificador, state = leer)
r = ref(provider, identificador)
state['individuos'].flat_map do |ind, roles|
roles.select { |_, pool| pool.include?(r) }.map { |rol, _| { 'individuo' => ind, 'rol' => rol } }
end
end
# --- Selección por NOMBRE (P335/Fase 5): el único lugar que decide si /disponible/<nombre> es un rol o un provider.
# Rol (mente|red) → el pool del individuo; si está vacío NO cae al provider (respuesta explícita 'pool_vacio').
# Otro nombre → un provider, como antes (compatibilidad con los consumidores actuales).
def rol?(nombre)
ROLES.include?(nombre.to_s)
end
def pool_vacio?(individuo, nombre)
rol?(nombre) && refs(individuo, nombre).empty?
end
def disponible(individuo, nombre)
rol?(nombre) ? Nexxa::Registro.disponible_en(refs(individuo, nombre)) : Nexxa::Registro.disponible(nombre)
end
def proxima(individuo, nombre)
rol?(nombre) ? Nexxa::Registro.proxima_en(refs(individuo, nombre)) : Nexxa::Registro.proxima(nombre)
end
def estado(individuo, nombre)
rol?(nombre) ? Nexxa::Registro.estado_en(refs(individuo, nombre)) : Nexxa::Registro.estado_pool(nombre)
end
# Pools completos con el estado de cada key, para nexxa-web. Nunca valores.
def con_estado
leer['individuos'].transform_values do |roles|
roles.to_h { |rol, pool| [rol, Nexxa::Registro.estado_en(pool)] }
end
end
def validar!(individuo, rol)
raise 'Falta el individuo' if individuo.to_s.strip.empty?
raise "rol inválido: #{rol} (esperado: #{ROLES.join('|')})" unless ROLES.include?(rol.to_s)
end
end
end