Tests ADN / test (push) Canceled after 0s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-Authored-By: GEMMA <noreply@gemma.dtic>
221 lines
8.4 KiB
Ruby
221 lines
8.4 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'
|
|
require_relative 'lib_estado'
|
|
|
|
module Nexxa
|
|
module Pools
|
|
STATE_FILE = Estado.ruta('pools')
|
|
ROLES = %w[mente red].freeze
|
|
|
|
module_function
|
|
|
|
# Estado vía Nexxa::Estado (P335/Fase 17)
|
|
def leer
|
|
d = Estado.leer('pools', STATE_FILE, { 'individuos' => {} })
|
|
d['individuos'] ||= {}
|
|
d
|
|
end
|
|
|
|
def guardar(state)
|
|
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)
|
|
"#{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)
|
|
|
|
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)
|
|
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:
|
|
# una sola inválida y no se toca nada. Lista vacía = vaciar el pool. => refs finales
|
|
def reemplazar(individuo:, rol:, refs:, existe: nil)
|
|
validar!(individuo, rol)
|
|
existe ||= ->(p, i) { Nexxa::Registro.todas.any? { |k| k['provider'] == p && k['identificador'] == i } }
|
|
refs = Array(refs).map(&:to_s).uniq
|
|
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?
|
|
|
|
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
|
|
|
|
# Pasa una key del rol 'de' al otro rol del mismo individuo, en una sola escritura. => rol destino
|
|
def mover(individuo:, de:, provider:, identificador:)
|
|
validar!(individuo, de)
|
|
a = (ROLES - [de.to_s]).first
|
|
r = ref(provider, identificador)
|
|
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)
|
|
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:)
|
|
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
|
|
cambio
|
|
end
|
|
|
|
# Al eliminar una key del registro, se saca de todos los pools (sin referencias colgadas).
|
|
def olvidar_key(provider:, identificador:)
|
|
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)
|
|
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'=>}, ... }
|
|
def resumen(individuo)
|
|
ROLES.to_h do |rol|
|
|
filas = Nexxa::Registro.estado_en(refs(individuo, rol))
|
|
[rol, { 'total' => filas.size, 'disponibles' => filas.count { |f| f['estado'] == 'disponible' } }]
|
|
end
|
|
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
|
|
|
|
# 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
|
|
|
|
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
|