Tests ADN / test (push) Canceled after 0s
- 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>
133 lines
5.3 KiB
Ruby
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
|