Files
dtic-DIIAA/servicios/nexxa/organismo/cli_estado.rb
T

163 lines
6.5 KiB
Ruby

# frozen_string_literal: true
# cli_estado.rb — Mover el estado de NEXXA entre el motor archivo y su Postgres propio (P335/Fase 17)
# ==============================================================================
# Corre EN el nodo, en organismo/, con el usuario del servicio (autenticación peer al Postgres local):
# ruby cli_estado.rb esquema # crea las tablas estado y usos si faltan
# ruby cli_estado.rb migrar # archivos → pg. Respalda los JSON y usos.log en bkp_estado_<fecha>.tgz antes de
# # escribir. Idempotente: una segunda corrida informa 'igual' en todo y no escribe.
# ruby cli_estado.rb verificar # pg == archivos clave por clave y usos por cantidad; sale 1 si difiere
# ruby cli_estado.rb exportar # pg → archivos: la VUELTA ATRÁS (respaldo previo de lo que haya en disco)
# Independiente de NEXXA_ESTADO: lee y escribe los dos motores explícitamente. Nunca imprime valores, solo claves y
# conteos (el registro tiene los secretos cifrados y usuarios los hashes).
# ==============================================================================
require 'json'
require 'time'
require_relative 'lib_estado'
module Nexxa
module CliEstado
E = Nexxa::Estado
USO = 'ruby cli_estado.rb esquema|migrar|verificar|exportar'
# El drop-in que activa el motor pg en los servicios (lo escribe nexxa estado:pg --accion activar)
DROPIN = '/etc/systemd/system/nexxa.service.d/estado.conf'
module_function
def call(accion, salida: $stdout)
case accion
when 'esquema'
E.crear_esquema!
salida.puts('✅ tablas estado y usos listas')
0
when 'migrar' then migrar(salida)
when 'verificar' then verificar(salida)
when 'exportar' then exportar(salida)
else
salida.puts("Uso: #{USO}")
2
end
end
# Con el motor pg ya activo, los archivos quedaron viejos: migrar pisaría el estado vivo con ellos. Se niega (repetir
# 'activar' es seguro: frena acá y el trap vuelve a arrancar los servicios como estaban).
def pg_activo?(dropin = DROPIN)
File.exist?(dropin) && File.read(dropin).include?('NEXXA_ESTADO=pg')
end
def migrar(salida, dropin: DROPIN)
if pg_activo?(dropin)
salida.puts("❌ el motor pg ya está activo (#{dropin}): migrar pisaría el estado vivo con archivos viejos. " \
'Para volver a archivos: exportar (nexxa estado:pg --accion revertir)')
return 1
end
E.crear_esquema!
dif = diferencias
if dif.values.none?
salida.puts('✅ igual: pg ya coincide con los archivos, nada que migrar')
return 0
end
salida.puts("🗄 respaldo: #{respaldar}")
E::ARCHIVOS.each_key do |clave|
next salida.puts(" = #{clave}: igual") unless dif[clave]
E.pg_guardar(clave, E.archivo_leer(E.ruta(clave), E::DEFECTOS[clave]))
salida.puts(" → #{clave}: migrada")
end
if dif['usos']
n_pg = contar_usos_pg
unless n_pg.zero?
salida.puts("❌ usos: pg ya tiene #{n_pg} fila(s) que no coinciden con usos.log (#{usos_archivo.size}); no reimporto para no duplicar")
return 1
end
# Todo o nada: una carga parcial dejaría la cuenta desigual y migrar ya no podría reintentarse (no reimporta)
E.sincronizado do
E.con.exec('BEGIN')
begin
usos_archivo.each { |u| E.usos_registrar_pg(normalizar_uso(u)) }
E.con.exec('COMMIT')
rescue StandardError
E.con.exec('ROLLBACK')
raise
end
end
salida.puts(" → usos: #{usos_archivo.size} fila(s)")
end
verificar(salida)
end
def verificar(salida)
dif = diferencias
dif.each { |clave, distinta| salida.puts(" #{distinta ? '≠' : '='} #{clave}") }
if dif.values.any?
salida.puts("❌ pg difiere de los archivos en: #{dif.select { |_, d| d }.keys.join(', ')}")
1
else
salida.puts("✅ pg coincide con los archivos (#{E::ARCHIVOS.size} claves, #{contar_usos_pg} usos)")
0
end
end
def exportar(salida)
salida.puts("🗄 respaldo de lo que había en disco: #{respaldar}")
E::ARCHIVOS.each_key do |clave|
fila = E.sincronizado { E.con.exec_params('SELECT valor FROM estado WHERE clave = $1', [clave]).first }
next salida.puts(" · #{clave}: no está en pg, el archivo queda como estaba") unless fila
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, motivo, hasta FROM usos ORDER BY id').to_a }
File.open("#{E::USOS_LOG}.tmp", 'w', 0o600) do |f|
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)")
verificar(salida)
end
# { clave => true si pg difiere del archivo, ..., 'usos' => true si la cantidad difiere }
def diferencias
d = E::ARCHIVOS.keys.to_h do |clave|
[clave, E.pg_leer(clave, nil) != E.archivo_leer(E.ruta(clave), E::DEFECTOS[clave])]
end
d.merge('usos' => contar_usos_pg != usos_archivo.size)
end
# Líneas viejas de usos.log (anteriores a P204/Fase 3) no traen 'evento': eran todas dispensas (contrato de
# Nexxa::Usos). Sin esto la columna NOT NULL frenó la primera activación real (2026-10-05 02:43).
def normalizar_uso(u)
u.merge('evento' => u['evento'] || 'dispensada', 'individuo' => u['individuo'], 'en' => u['en'] || Time.at(0).iso8601)
end
def contar_usos_pg
E.sincronizado { E.con.exec('SELECT count(*) AS n FROM usos').first['n'].to_i }
end
def usos_archivo
@usos_archivo ||= begin
return [] unless File.exist?(E::USOS_LOG)
File.readlines(E::USOS_LOG).filter_map do |l|
JSON.parse(l)
rescue JSON::ParserError
nil
end
end
end
def respaldar
archivos = (E::ARCHIVOS.values + ['usos.log']).select { |a| File.exist?(File.join(E::DIR, a)) }
tgz = File.join(E::DIR, "bkp_estado_#{Time.now.strftime('%Y%m%d%H%M%S')}.tgz")
system('tar', 'czf', tgz, '-C', E::DIR, *archivos, exception: true) unless archivos.empty?
File.chmod(0o600, tgz) if File.exist?(tgz)
archivos.empty? ? 'sin archivos que respaldar' : tgz
end
end
end
exit Nexxa::CliEstado.call(ARGV.first) if $PROGRAM_NAME == __FILE__