feat(nexxa): taxonomía cerrada de estados y registro completo de eventos (motivo, hasta, quién), /resumen y /usos filtrable; 2.0.0 (P337/F1)
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 03:29:40 -03:00
co-authored by Claude Opus 5.5 GEMMA
parent 08aa45117e
commit 82e56aad0e
11 changed files with 233 additions and 81 deletions
+1 -1
View File
@@ -1 +1 @@
1.7.3
2.0.0
+2 -2
View File
@@ -110,9 +110,9 @@ module Nexxa
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 }
usos = E.sincronizado { E.con.exec('SELECT provider, identificador, individuo, evento, en, motivo, hasta 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) }
usos.each { |u| f.puts(E.normalizar_uso(u).to_json) }
end
File.rename("#{E::USOS_LOG}.tmp", E::USOS_LOG)
salida.puts(" ← usos: #{usos.size} fila(s)")
+2 -1
View File
@@ -31,7 +31,8 @@ Nexxa::Registro.registrar(
identificador: identificador,
cuenta_origen: cuenta_origen,
reset_segundos: reset_segundos.to_i,
valor: valor
valor: valor,
por: 'cli' # queda en el registro de usos (P337/Fase 1)
)
puts "Registrado: #{provider} → #{identificador} (cuenta: #{cuenta_origen})"
+31 -14
View File
@@ -103,24 +103,36 @@ module Nexxa
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'))
con.exec_params('INSERT INTO usos (provider, identificador, individuo, evento, en, motivo, hasta) ' \
'VALUES ($1, $2, $3, $4, $5, $6, $7)',
linea.values_at('provider', 'identificador', 'individuo', 'evento', 'en', 'motivo', 'hasta'))
end
end
# Más reciente primero
def usos_historial(provider: nil, identificador: nil, limit: 50)
return usos_archivo(provider, identificador, limit) unless pg?
FILTROS_USOS = %w[provider identificador individuo evento].freeze
# Más reciente primero. Filtros exactos por campo y 'desde' (Time) para una ventana (P337/Fase 1)
def usos_historial(provider: nil, identificador: nil, individuo: nil, evento: nil, desde: nil, limit: 100)
f = { 'provider' => provider, 'identificador' => identificador, 'individuo' => individuo, 'evento' => evento }
return usos_archivo(f, desde, 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
con.exec_params(<<~SQL, f.values_at(*FILTROS_USOS) + [desde&.iso8601, limit]).map { |u| normalizar_uso(u) }
SELECT provider, identificador, individuo, evento, en, motivo, hasta FROM usos
WHERE ($1::text IS NULL OR provider = $1) AND ($2::text IS NULL OR identificador = $2)
ORDER BY id DESC LIMIT $3
AND ($3::text IS NULL OR individuo = $3) AND ($4::text IS NULL OR evento = $4)
AND ($5::timestamptz IS NULL OR en >= $5)
ORDER BY id DESC LIMIT $6
SQL
end
end
# Fechas en ISO 8601 con zona, igual en los dos motores
def normalizar_uso(u)
u.merge('en' => Time.parse(u['en'].to_s).iso8601, 'hasta' => u['hasta'] && Time.parse(u['hasta'].to_s).iso8601(3),
'motivo' => u['motivo'])
end
# ---------- motor archivo ----------
def archivo_leer(archivo, defecto)
@@ -137,17 +149,17 @@ module Nexxa
File.rename(tmp, archivo)
end
def usos_archivo(provider, identificador, limit)
def usos_archivo(filtros, desde, limit)
return [] unless File.exist?(USOS_LOG)
lineas = File.readlines(USOS_LOG).filter_map do |l|
lineas = File.readlines(USOS_LOG, encoding: 'UTF-8').filter_map do |l| # locale C del servicio (ME-1216)
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
filtros.each { |campo, valor| lineas.select! { |l| l[campo] == valor } if valor }
lineas.select! { |l| l['en'] && Time.parse(l['en']) >= desde } if desde
lineas.last(limit).reverse.map { |u| normalizar_uso(u) }
end
# ---------- motor pg ----------
@@ -180,6 +192,9 @@ module Nexxa
en TIMESTAMPTZ NOT NULL
);
CREATE INDEX IF NOT EXISTS usos_key ON usos (provider, identificador);
ALTER TABLE usos ADD COLUMN IF NOT EXISTS motivo TEXT;
ALTER TABLE usos ADD COLUMN IF NOT EXISTS hasta TIMESTAMPTZ;
CREATE INDEX IF NOT EXISTS usos_en ON usos (en);
SQL
def crear_esquema!
@@ -191,7 +206,9 @@ module Nexxa
def con
@con ||= begin
require 'pg'
PG.connect(dbname: ENV.fetch('NEXXA_PG_DB', 'nexxa'))
c = PG.connect(dbname: ENV.fetch('NEXXA_PG_DB', 'nexxa'))
c.exec(ESQUEMA) # idempotente: un despliegue que amplía el esquema se aplica solo al arrancar (P337/Fase 1)
c
end
end
+70 -28
View File
@@ -70,8 +70,10 @@ module Nexxa
# P200/Fase4: registrar una key recién creada la dejaba "agotada" 24h por
# 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)
# por (P337/Fase 1): quién la dio de alta o la reemplazó, para el registro ('web:<usuario>', 'cli'...)
def self.registrar(provider:, identificador:, cuenta_origen:, reset_segundos:, valor: nil, ultimo_uso: nil, por: nil)
ahora = Time.now
evento = nil
disponible_desde = ultimo_uso ? (Time.parse(ultimo_uso) + reset_segundos).iso8601(3) : ahora.iso8601(3)
ultimo_uso ||= ahora.iso8601(3)
@@ -79,6 +81,7 @@ module Nexxa
mutar do |state|
existente = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador }
evento = existente ? 'editada' : 'alta'
if existente
existente.merge!(
'ultimo_uso' => ultimo_uso,
@@ -103,21 +106,33 @@ module Nexxa
}
end
state
end.tap do
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: por || 'desconocido', en: ahora,
evento: evento, motivo: evento == 'editada' && valor ? 'valor reemplazado' : nil)
end
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)
def self.actualizar(provider:, identificador:, cuenta_origen: nil, reset_segundos: nil, activo: nil, por: nil)
entrada = nil
cambios = []
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?
{ 'cuenta_origen' => cuenta_origen, 'reset_segundos' => reset_segundos, 'activo' => activo }.each do |campo, valor|
next if valor.nil? || entrada[campo] == valor
cambios << "#{campo}: #{entrada[campo].inspect} → #{valor.inspect}"
entrada[campo] = valor
end
state
end
# Qué cambió, sin ambigüedad (nunca el valor de la key: este método no lo toca)
unless cambios.empty?
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: por || 'desconocido',
evento: 'editada', motivo: cambios.join('; '))
end
entrada
end
@@ -148,21 +163,28 @@ module Nexxa
state
end
Nexxa::Usos.registrar(provider: provider, identificador: a, individuo: usuario ? "web:#{usuario}" : 'web',
en: ahora, evento: "renombrada (antes #{de})")
en: ahora, evento: 'renombrada', motivo: "antes #{de}")
entrada
end
# 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:)
def self.eliminar(provider:, identificador:, por: nil)
existia = nil
mutar do |state|
existia = state['keys'].reject! { |k| k['provider'] == provider && k['identificador'] == identificador }
state
end
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: por || 'desconocido', evento: 'baja') if existia
!existia.nil?
end
# Todas las keys con su estado de la taxonomía (P337/Fase 1), calculado sobre la key COMPLETA (sin valor_cifrado
# daría sin_valor) y recién después sin el valor (Regla 15). Lo que muestra nexxa-web: nada se recalcula allá.
def self.todas_con_estado(ahora = Time.now)
leer['keys'].map { |k| k.reject { |campo, _| campo == 'valor_cifrado' }.merge(estado_de_key(k, ahora)) }
end
# Todas las keys, solo metadata — para la vista de consulta de la mini-app
# (P201/Fase3). Nunca incluye valor_cifrado, bajo ningún caso (Regla 15).
def self.todas
@@ -192,7 +214,8 @@ module Nexxa
entrada = aplicar_reserva(buscar!(state, provider, identificador), individuo, ahora)
state
end
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: 'dispensada')
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: 'dispensada',
hasta: entrada['reservado_hasta'])
entrada
end
@@ -213,7 +236,7 @@ module Nexxa
end
if elegida && elegida['valor_cifrado']
Nexxa::Usos.registrar(provider: elegida['provider'], identificador: elegida['identificador'], individuo: individuo,
en: ahora, evento: 'dispensada')
en: ahora, evento: 'dispensada', hasta: elegida['reservado_hasta'])
end
elegida
end
@@ -244,7 +267,7 @@ module Nexxa
def self.reportar(provider:, identificador:, individuo:, estado:, liberar_en_segundos: nil, motivo: nil)
ahora = Time.now
entrada = nil
evento = nil
evento = hasta = 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)
@@ -254,24 +277,26 @@ module Nexxa
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)
evento, hasta = 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
# Registro completo (P337/Fase 1): cada reporte queda, con el motivo del proveedor y hasta cuándo
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: evento,
motivo: (motivo.to_s[0, 200] if %w[pausada agotada].include?(evento)), hasta: hasta)
entrada
end
# => evento de usos a registrar ('agotada') o nil
# => [evento de usos, hasta] — renovada (con el nuevo fin de reserva), liberada, pausada o agotada (con el fin del bloqueo)
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
['renovada', entrada['reservado_hasta']]
when 'liberada'
entrada['reservado_por'] = nil
entrada['reservado_hasta'] = nil
nil
['liberada', nil]
when 'agotada'
reset_segundos = entrada['reset_segundos']
unless reset_segundos
@@ -279,11 +304,12 @@ module Nexxa
end
entrada['disponible_desde'] = (ahora + (liberar_en_segundos || reset_segundos)).iso8601(3)
entrada['bloqueo'] = tipo_bloqueo(liberar_en_segundos)
entrada['agotada_por'] = individuo
entrada['motivo_agotada'] = motivo.to_s[0, 200] unless motivo.to_s.empty?
entrada['motivo_agotada'] = motivo.to_s.empty? ? nil : motivo.to_s[0, 200]
entrada['reservado_por'] = nil
entrada['reservado_hasta'] = nil
'agotada'
[entrada['bloqueo'] == 'pausa' ? 'pausada' : 'agotada', entrada['disponible_desde']]
else
raise "estado inválido: #{estado} (esperado: sana|liberada|agotada)"
end
@@ -301,6 +327,7 @@ module Nexxa
entrada['reservado_hasta'] = nil
entrada['agotada_por'] = nil
entrada['motivo_agotada'] = nil
entrada['bloqueo'] = nil
state
end
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: "web:#{usuario}", en: ahora,
@@ -324,20 +351,35 @@ module Nexxa
estado_de(de_refs(refs), ahora)
end
# Taxonomía CERRADA de estados (P337/Fase 1): la única fuente; nexxa-web y GEMMA la muestran, nunca la recalculan.
# Excluyentes y en este orden de precedencia. Campos uniformes: hasta = cuándo cambia de estado, por = quién
# reservó o bloqueó, motivo = lo que contestó el proveedor.
ESTADOS = %w[disponible en_uso en_pausa agotada desactivada sin_valor].freeze
# Un bloqueo de hasta esto es una PAUSA por límite del proveedor (el 429 por minuto); más largo, cuota agotada
PAUSA_MAX_SEG = 300
def self.estado_de(keys, ahora = Time.now)
keys.map do |k|
estado = if k['activo'] == false then 'inactiva'
elsif Time.parse(k['disponible_desde']) > ahora then 'agotada'
elsif k['reservado_hasta'] && Time.parse(k['reservado_hasta']) > ahora then 'reservada'
else 'disponible'
keys.map { |k| { 'provider' => k['provider'], 'identificador' => k['identificador'] }.merge(estado_de_key(k, ahora)) }
end
{ 'provider' => k['provider'], 'identificador' => k['identificador'], 'estado' => estado,
'libera_en' => (estado == 'agotada' ? k['disponible_desde'] : nil),
'reservado_por' => (estado == 'reservada' ? k['reservado_por'] : nil),
'agotada_por' => (estado == 'agotada' ? k['agotada_por'] : nil),
'motivo' => (estado == 'agotada' ? k['motivo_agotada'] : nil),
'ultimo_uso' => k['ultimo_uso'], 'ultimo_individuo' => k['ultimo_individuo'] }
def self.estado_de_key(k, ahora = Time.now)
bloqueada = Time.parse(k['disponible_desde']) > ahora
reservada = k['reservado_hasta'] && Time.parse(k['reservado_hasta']) > ahora
e = if k['activo'] == false then { 'estado' => 'desactivada' }
elsif !k.key?('valor_cifrado') || k['valor_cifrado'].nil? then { 'estado' => 'sin_valor' }
elsif bloqueada
{ 'estado' => k['bloqueo'] == 'pausa' ? 'en_pausa' : 'agotada', 'hasta' => k['disponible_desde'],
'por' => k['agotada_por'], 'motivo' => k['motivo_agotada'] }
elsif reservada then { 'estado' => 'en_uso', 'hasta' => k['reservado_hasta'], 'por' => k['reservado_por'] }
else { 'estado' => 'disponible' }
end
{ 'hasta' => nil, 'por' => nil, 'motivo' => nil }.merge(e)
.merge('ultimo_uso' => k['ultimo_uso'], 'ultimo_individuo' => k['ultimo_individuo'])
end
# 'pausa' (bloqueo corto, límite del proveedor) o 'agotada' (cuota del ciclo), decidido por la duración real
def self.tipo_bloqueo(segundos)
segundos && segundos.to_i <= PAUSA_MAX_SEG ? 'pausa' : 'agotada'
end
def self.cifrar(valor)
+33 -8
View File
@@ -16,23 +16,48 @@ module Nexxa
module Usos
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
# previas a Fase3 (todas eran dispensas).
def self.registrar(provider:, identificador:, individuo:, en: Time.now, evento: 'dispensada')
# Registro COMPLETO de lo que pasa con cada key (P337/Fase 1). Códigos estables (hay filas guardadas con ellos);
# nexxa-web los traduce a palabras:
EVENTOS = %w[dispensada liberada renovada pausada agotada revertida liberada-admin alta editada renombrada baja].freeze
# motivo: lo que contestó el proveedor (pausada/agotada), qué cambió (editada) o el nombre anterior (renombrada).
# hasta: hasta cuándo queda así (fin de la reserva o del bloqueo). Nunca valores de keys.
def self.registrar(provider:, identificador:, individuo:, en: Time.now, evento: 'dispensada', motivo: nil, hasta: nil)
linea = {
'provider' => provider,
'identificador' => identificador,
'individuo' => individuo,
'evento' => evento,
'en' => en.iso8601
'en' => en.iso8601,
'motivo' => motivo,
'hasta' => hasta
}
Estado.usos_registrar(linea)
end
# Historial más reciente primero, opcionalmente filtrado por key (Nexxa::Estado, P335/Fase 17)
def self.historial(provider: nil, identificador: nil, limit: 50)
Estado.usos_historial(provider: provider, identificador: identificador, limit: limit)
# Más reciente primero. Filtros opcionales; horas: solo la ventana de las últimas N horas
def self.historial(provider: nil, identificador: nil, individuo: nil, evento: nil, horas: nil, limit: 100)
Estado.usos_historial(provider: provider, identificador: identificador, individuo: individuo, evento: evento,
desde: horas && (Time.now - (horas.to_f * 3600)), limit: limit)
end
# Lo que muestra el Dashboard (P337/Fase 1): cuántas keys en cada estado AHORA (todos los estados, también los
# que están en 0: un número ausente se presta a interpretar) y qué pasó en las últimas N horas, en total y por key.
# keys: Registro.todas_con_estado. eventos: inyectable (tests); por defecto, el registro de la ventana.
def self.resumen(keys, horas: 24, eventos: nil)
eventos ||= historial(horas: horas, limit: 1_000_000)
contar = ->(lista) { EVENTOS.to_h { |e| [e, lista.count { |u| u['evento'] == e }] } }
por_key = keys.map do |k|
propios = eventos.select { |u| u['provider'] == k['provider'] && u['identificador'] == k['identificador'] }
k.slice('provider', 'identificador', 'estado', 'hasta', 'por', 'motivo', 'ultimo_uso', 'ultimo_individuo')
.merge('eventos' => contar.call(propios), 'ultimo_evento' => propios.first)
end
{
'horas' => horas,
'ahora' => Nexxa::Registro::ESTADOS.to_h { |e| [e, keys.count { |k| k['estado'] == e }] },
'eventos' => contar.call(eventos),
'por_key' => por_key.sort_by { |k| [k['provider'].to_s, k['identificador'].to_s] }
}
end
end
end
+29 -5
View File
@@ -104,6 +104,12 @@ def operador_autenticado?(req)
!sesion_actual(req).nil?
end
# Quién hizo algo desde la web, para el registro de usos (P337/Fase 1)
def quien(req)
u = sesion_actual(req)&.dig('usuario')
u ? "web:#{u}" : 'api'
end
def admin_autenticado?(req)
sesion_actual(req)&.dig('perfil') == 'admin'
end
@@ -244,7 +250,8 @@ class KeysServlet < WEBrick::HTTPServlet::AbstractServlet
res.status = 200
# Cada key trae en qué pools está (P335/Fase 12): la sección APIs lo muestra y avisa al eliminar
pools = Nexxa::Pools.leer
res.body = Nexxa::Registro.todas.map { |k| k.merge('pools' => Nexxa::Pools.de_key(k['provider'], k['identificador'], pools)) }.to_json
# Y su estado de la taxonomía calculado acá (P337/Fase 1): la web lo muestra, no lo recalcula
res.body = Nexxa::Registro.todas_con_estado.map { |k| k.merge('pools' => Nexxa::Pools.de_key(k['provider'], k['identificador'], pools)) }.to_json
end
# POST /keys/<provider>/<identificador>/liberar — admin libera una key agotada o reservada (P335/Fase 7)
@@ -302,7 +309,7 @@ class KeysServlet < WEBrick::HTTPServlet::AbstractServlet
identificador: identificador,
cuenta_origen: body['cuenta_origen'],
reset_segundos: body['reset_segundos']&.to_i,
activo: body.key?('activo') ? body['activo'] : nil
activo: body.key?('activo') ? body['activo'] : nil, por: quien(req)
)
res.status = 200
res.body = entrada.reject { |k, _| k == 'valor_cifrado' }.to_json
@@ -325,7 +332,7 @@ class KeysServlet < WEBrick::HTTPServlet::AbstractServlet
end
provider, identificador = partes
borrado = Nexxa::Registro.eliminar(provider: provider, identificador: identificador)
borrado = Nexxa::Registro.eliminar(provider: provider, identificador: identificador, por: quien(req))
Nexxa::Pools.olvidar_key(provider: provider, identificador: identificador) if borrado # sin refs colgadas (P335)
if borrado
res.status = 200
@@ -425,12 +432,28 @@ server.mount '/pools', PoolsServlet
# GET /usos — historial de eventos (dispensada/agotada) para la mini-app (P204/Fase4).
# Read-only, mismo criterio de auth que GET /keys (cualquier operador logueado).
# Usos.historial ya existía (P201/Fase3) — nunca se había montado por HTTP.
# P337/Fase 1: registro completo con filtros — ?provider=&identificador=&individuo=&evento=&horas=&limit= (máx 2000)
server.mount_proc '/usos' do |req, res|
next rechazar_no_autenticado(res) unless operador_autenticado?(req)
q = req.query
filtros = %w[provider identificador individuo evento].to_h { |k| [k.to_sym, q[k].to_s.empty? ? nil : q[k].to_s] }
limit = (q['limit'] || 100).to_i.clamp(1, 2000)
horas = q['horas'].to_s.empty? ? nil : q['horas'].to_f
res.status = 200
res.content_type = 'application/json'
res.body = Nexxa::Usos.historial(limit: 100).to_json
res.body = Nexxa::Usos.historial(**filtros, horas: horas, limit: limit).to_json
end
# GET /resumen?horas=24 — P337/Fase 1: cuántas keys en cada estado AHORA y qué pasó en la ventana (por evento y por
# key). Lo que el Dashboard muestra, calculado acá.
server.mount_proc '/resumen' do |req, res|
next rechazar_no_autenticado(res) unless operador_autenticado?(req)
horas = (req.query['horas'] || 24).to_f.clamp(1, 24 * 31)
res.status = 200
res.content_type = 'application/json'
res.body = Nexxa::Usos.resumen(Nexxa::Registro.todas_con_estado, horas: horas).to_json
end
# GET /consumidores — individuos con token registrado (metadata)
@@ -877,7 +900,8 @@ server.mount_proc '/alta' do |req, res|
identificador: body['identificador'],
cuenta_origen: body['cuenta_origen'],
reset_segundos: body['reset_segundos'].to_i,
valor: body['valor']
valor: body['valor'],
por: quien(req)
)
res.status = 201
+5 -11
View File
@@ -63,17 +63,11 @@ test('lee el registro real sin explotar') do
end
providers_reales.each do |provider|
keys = Nexxa::Registro.leer['keys'].select { |k| k['provider'] == provider }
keys.each do |k|
agotada = Time.parse(k['disponible_desde']) > ahora
reservada = !agotada && k['reservado_hasta'] && Time.parse(k['reservado_hasta']) > ahora
estado = if k['activo'] == false then 'desactivada'
elsif agotada then 'agotada'
elsif reservada then 'reservada'
else 'disponible'
end
icono = { 'disponible' => '🟢', 'reservada' => '🔵', 'agotada' => '🔴', 'desactivada' => '⚪' }[estado]
puts " #{icono} #{provider}/#{k['identificador']}: #{estado}"
# El estado de la taxonomía única (Registro.estado_de, P337/Fase 1), nunca recalculado acá
Nexxa::Registro.estado_pool(provider, ahora).each do |k|
icono = { 'disponible' => '🟢', 'en_uso' => '🔵', 'en_pausa' => '🟡', 'agotada' => '🔴', 'desactivada' => '⚪',
'sin_valor' => '▫️' }[k['estado']]
puts " #{icono} #{provider}/#{k['identificador']}: #{k['estado']}#{k['hasta'] ? " hasta #{k['hasta']}" : ''}"
end
end
+15 -1
View File
@@ -139,6 +139,20 @@ class HumoHttpTest < Minitest::Test
assert_equal 200, Net::HTTP.start('127.0.0.1', PUERTO) { |h| h.get("/js/app.js?v=#{version}") }.code.to_i
end
# P337/Fase 1: estado calculado en /keys, registro filtrable y resumen, por HTTP y con el locale C del nodo
def test_estado_registro_y_resumen_por_http
keys = pedir('get', '/keys', sesion: SES_OPER)[1]
assert(keys.all? { |k| %w[disponible en_uso en_pausa agotada desactivada sin_valor].include?(k['estado']) })
refute(keys.any? { |k| k.key?('valor_cifrado') })
cod, usos = pedir('get', '/usos?evento=alta&horas=24', sesion: SES_OPER)
assert_equal 200, cod
assert(usos.all? { |u| u['evento'] == 'alta' })
cod, res = pedir('get', '/resumen?horas=24', sesion: SES_OPER)
assert_equal 200, cod
assert_equal keys.size, res['ahora'].values.sum
assert_equal 401, pedir('get', '/resumen')[0]
end
# Fase 13: renombrar una key (key propia d-ren; vuelve a su nombre al final)
def test_renombrar_key_actualiza_pools_y_valida
assert_equal 200, pedir('put', '/pools/ren-humo/red', cuerpo: { refs: %w[deepseek/d-ren] }, sesion: SES_ADMIN)[0]
@@ -150,7 +164,7 @@ class HumoHttpTest < Minitest::Test
assert_equal [200, 'd-ren2', 'otra'], [c, b['identificador'], b['cuenta_origen']]
refs = pedir('get', '/pools', sesion: SES_OPER)[1].dig('individuos', 'ren-humo', 'red').map { |f| f['identificador'] }
assert_equal ['d-ren2'], refs
assert pedir('get', '/usos', sesion: SES_OPER)[1].to_a.any? { |u| u['evento'].to_s.include?('renombrada (antes d-ren)') }
assert pedir('get', '/usos', sesion: SES_OPER)[1].to_a.any? { |u| u['evento'] == 'renombrada' && u['motivo'] == 'antes d-ren' }
# limpieza: vuelve a su nombre y se vacía el pool
assert_equal 200, pedir('patch', '/keys/deepseek/d-ren2', cuerpo: { identificador: 'd-ren' }, sesion: SES_ADMIN)[0]
assert_equal 200, pedir('put', '/pools/ren-humo/red', cuerpo: { refs: [] }, sesion: SES_ADMIN)[0]
+2 -2
View File
@@ -19,7 +19,7 @@ class PoolsTest < Minitest::Test
def setup
FileUtils.rm_f([R::STATE_FILE, P::STATE_FILE])
pasado = (Time.now - 3600).iso8601(3)
key = ->(p, i, extra = {}) { { 'provider' => p, 'identificador' => i, 'disponible_desde' => pasado, 'reset_segundos' => 86_400 }.merge(extra) }
key = ->(p, i, extra = {}) { { 'provider' => p, 'identificador' => i, 'disponible_desde' => pasado, 'reset_segundos' => 86_400, 'valor_cifrado' => 'x' }.merge(extra) }
R.guardar('keys' => [key.('gemini', 'g-01', 'ultimo_uso' => (Time.now - 60).iso8601(3)),
key.('deepseek', 'd-01', 'ultimo_uso' => (Time.now - 600).iso8601(3)),
key.('gemini', 'g-red'),
@@ -94,7 +94,7 @@ class PoolsTest < Minitest::Test
filas = P.estado('gemma', 'mente').to_h { |f| [f['identificador'], f] }
assert_equal %w[d-01 g-01], filas.keys.sort
assert_equal %w[agotada gemini gemma cuota\ diaria],
filas['g-01'].values_at('estado', 'provider', 'agotada_por', 'motivo')
filas['g-01'].values_at('estado', 'provider', 'por', 'motivo')
assert_equal 'disponible', filas['d-01']['estado']
assert_equal 'deepseek', P.disponible('gemma', 'mente')['provider']
end
+41 -6
View File
@@ -17,8 +17,9 @@ class RevertirTest < Minitest::Test
def setup
FileUtils.rm_f([R::STATE_FILE, Nexxa::Usos::LOG_FILE])
pasado = (Time.now - 3600).iso8601(3)
R.guardar('keys' => %w[g-01 g-02 g-03].map { |i| { 'provider' => 'gemini', 'identificador' => i, 'disponible_desde' => pasado, 'reset_segundos' => 86_400, 'reservado_por' => nil } } +
[{ 'provider' => 'gemini', 'identificador' => 'g-off', 'activo' => false, 'disponible_desde' => pasado }])
R.guardar('keys' => %w[g-01 g-02 g-03].map { |i| { 'provider' => 'gemini', 'identificador' => i, 'disponible_desde' => pasado, 'reset_segundos' => 86_400, 'reservado_por' => nil, 'valor_cifrado' => 'x' } } +
[{ 'provider' => 'gemini', 'identificador' => 'g-off', 'activo' => false, 'disponible_desde' => pasado, 'valor_cifrado' => 'x' },
{ 'provider' => 'gemini', 'identificador' => 'g-meta', 'disponible_desde' => pasado }])
end
def test_quien_la_agoto_puede_deshacerlo_aunque_ya_no_la_tenga_reservada
@@ -44,13 +45,47 @@ class RevertirTest < Minitest::Test
assert_equal 'disponible', R.estado_pool('gemini').find { |k| k['identificador'] == 'g-02' }['estado']
end
def test_estado_del_pool_sin_valores_y_con_los_cuatro_estados
# Taxonomía cerrada (P337/Fase 1): un bloqueo de 60 s es una PAUSA por límite, uno largo es AGOTADA; sin valor y
# desactivada se distinguen; campos uniformes hasta/por/motivo
def test_estado_del_pool_sin_valores_y_con_la_taxonomia_completa
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1')
R.reservar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1', estado: 'agotada', liberar_en_segundos: 60)
R.reportar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1', estado: 'agotada', liberar_en_segundos: 60, motivo: '429')
R.reservar(provider: 'gemini', identificador: 'g-03', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-03', individuo: 'gemma-f1', estado: 'agotada', motivo: 'cuota diaria')
est = R.estado_pool('gemini').to_h { |k| [k['identificador'], k] }
assert_equal %w[reservada agotada disponible inactiva], %w[g-01 g-02 g-03 g-off].map { |i| est[i]['estado'] }
assert_equal 'gemma-f1', est['g-02']['agotada_por']
assert_equal %w[en_uso en_pausa agotada desactivada sin_valor], %w[g-01 g-02 g-03 g-off g-meta].map { |i| est[i]['estado'] }
assert_equal %w[gemma-f1 429], est['g-02'].values_at('por', 'motivo')
assert_operator Time.parse(est['g-02']['hasta']), :>, Time.now
assert_equal 'gemma-f1', est['g-01']['por']
refute est.values.any? { |k| k.key?('valor') || k.key?('valor_cifrado') }
end
# Registro completo: cada paso queda con su evento, motivo y hasta
def test_el_registro_anota_cada_paso
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'sana')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'agotada', liberar_en_segundos: 60, motivo: '429 por minuto')
R.actualizar(provider: 'gemini', identificador: 'g-03', activo: false, por: 'web:admin')
R.eliminar(provider: 'gemini', identificador: 'g-off', por: 'web:admin')
h = Nexxa::Usos.historial
assert_equal %w[baja editada pausada renovada dispensada], h.map { |u| u['evento'] }
assert_equal '429 por minuto', h[2]['motivo']
refute_nil h[2]['hasta']
assert_equal 'activo: nil → false', h[1]['motivo']
assert_equal ['web:admin'], Nexxa::Usos.historial(individuo: 'web:admin', evento: 'baja').map { |u| u['individuo'] }
end
def test_resumen_cuenta_todos_los_estados_y_los_eventos_de_la_ventana
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'agotada', liberar_en_segundos: 60)
r = Nexxa::Usos.resumen(R.todas_con_estado, horas: 24)
assert_equal R::ESTADOS.sort, r['ahora'].keys.sort, 'todos los estados, también los que están en 0'
assert_equal 1, r['ahora']['en_pausa']
assert_equal 0, r['ahora']['en_uso']
assert_equal({ 'dispensada' => 1, 'pausada' => 1 }, r['eventos'].select { |_, n| n.positive? })
g01 = r['por_key'].find { |k| k['identificador'] == 'g-01' }
assert_equal 'pausada', g01['ultimo_evento']['evento']
refute r['por_key'].any? { |k| k.key?('valor_cifrado') }
end
end