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
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:
co-authored by
Claude Opus 5.5
GEMMA
parent
08aa45117e
commit
82e56aad0e
@@ -1 +1 @@
|
||||
1.7.3
|
||||
2.0.0
|
||||
|
||||
@@ -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)")
|
||||
|
||||
@@ -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})"
|
||||
|
||||
@@ -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,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)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user