# 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_.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 usos_archivo.each { |u| E.usos_registrar_pg(u) } 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 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) } 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 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__