From 82e56aad0e44753d7d7923a79528827454188a9a Mon Sep 17 00:00:00 2001 From: Ricardo Monla Date: Mon, 5 Oct 2026 03:29:40 -0300 Subject: [PATCH] =?UTF-8?q?feat(nexxa):=20taxonom=C3=ADa=20cerrada=20de=20?= =?UTF-8?q?estados=20y=20registro=20completo=20de=20eventos=20(motivo,=20h?= =?UTF-8?q?asta,=20qui=C3=A9n),=20/resumen=20y=20/usos=20filtrable;=202.0.?= =?UTF-8?q?0=20(P337/F1)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 Co-Authored-By: GEMMA --- servicios/nexxa/organismo/VERSION | 2 +- servicios/nexxa/organismo/cli_estado.rb | 4 +- servicios/nexxa/organismo/cli_registrar.rb | 3 +- servicios/nexxa/organismo/lib_estado.rb | 45 ++++++--- servicios/nexxa/organismo/lib_registro.rb | 102 ++++++++++++++------ servicios/nexxa/organismo/lib_usos.rb | 41 ++++++-- servicios/nexxa/organismo/server.rb | 34 ++++++- servicios/nexxa/organismo/tool_humo_pool.rb | 16 +-- servicios/nexxa/test/humo_http_test.rb | 16 ++- servicios/nexxa/test/pools_test.rb | 4 +- servicios/nexxa/test/revertir_test.rb | 47 +++++++-- 11 files changed, 233 insertions(+), 81 deletions(-) diff --git a/servicios/nexxa/organismo/VERSION b/servicios/nexxa/organismo/VERSION index 661e7aea..227cea21 100644 --- a/servicios/nexxa/organismo/VERSION +++ b/servicios/nexxa/organismo/VERSION @@ -1 +1 @@ -1.7.3 +2.0.0 diff --git a/servicios/nexxa/organismo/cli_estado.rb b/servicios/nexxa/organismo/cli_estado.rb index 08df7f43..7faf3e0b 100644 --- a/servicios/nexxa/organismo/cli_estado.rb +++ b/servicios/nexxa/organismo/cli_estado.rb @@ -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)") diff --git a/servicios/nexxa/organismo/cli_registrar.rb b/servicios/nexxa/organismo/cli_registrar.rb index 0d300cb6..ed599c52 100644 --- a/servicios/nexxa/organismo/cli_registrar.rb +++ b/servicios/nexxa/organismo/cli_registrar.rb @@ -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})" diff --git a/servicios/nexxa/organismo/lib_estado.rb b/servicios/nexxa/organismo/lib_estado.rb index 9b960538..d3d144ef 100644 --- a/servicios/nexxa/organismo/lib_estado.rb +++ b/servicios/nexxa/organismo/lib_estado.rb @@ -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 diff --git a/servicios/nexxa/organismo/lib_registro.rb b/servicios/nexxa/organismo/lib_registro.rb index 1ad72ff0..0403d324 100644 --- a/servicios/nexxa/organismo/lib_registro.rb +++ b/servicios/nexxa/organismo/lib_registro.rb @@ -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:', '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' - 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'] } - end + keys.map { |k| { 'provider' => k['provider'], 'identificador' => k['identificador'] }.merge(estado_de_key(k, ahora)) } + end + + 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) diff --git a/servicios/nexxa/organismo/lib_usos.rb b/servicios/nexxa/organismo/lib_usos.rb index dbfb1ab3..75261986 100644 --- a/servicios/nexxa/organismo/lib_usos.rb +++ b/servicios/nexxa/organismo/lib_usos.rb @@ -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 diff --git a/servicios/nexxa/organismo/server.rb b/servicios/nexxa/organismo/server.rb index e2b39c90..bbd74d77 100644 --- a/servicios/nexxa/organismo/server.rb +++ b/servicios/nexxa/organismo/server.rb @@ -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///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 diff --git a/servicios/nexxa/organismo/tool_humo_pool.rb b/servicios/nexxa/organismo/tool_humo_pool.rb index 0773d4c6..deb4ede9 100644 --- a/servicios/nexxa/organismo/tool_humo_pool.rb +++ b/servicios/nexxa/organismo/tool_humo_pool.rb @@ -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 diff --git a/servicios/nexxa/test/humo_http_test.rb b/servicios/nexxa/test/humo_http_test.rb index fd2d696b..3c3cbebc 100644 --- a/servicios/nexxa/test/humo_http_test.rb +++ b/servicios/nexxa/test/humo_http_test.rb @@ -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] diff --git a/servicios/nexxa/test/pools_test.rb b/servicios/nexxa/test/pools_test.rb index ee9d589e..6b1909cb 100644 --- a/servicios/nexxa/test/pools_test.rb +++ b/servicios/nexxa/test/pools_test.rb @@ -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 diff --git a/servicios/nexxa/test/revertir_test.rb b/servicios/nexxa/test/revertir_test.rb index bfdc002f..6c8c0ccd 100644 --- a/servicios/nexxa/test/revertir_test.rb +++ b/servicios/nexxa/test/revertir_test.rb @@ -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