refactor(dron): Atomisidad - Módulo base compartido para drones
Principio "Menos es Más": código común centralizado en un solo lugar. Cambios: - Nuevo módulo Dron::Base con funcionalidad compartida: - logger: Logger compartido (evita crear múltiples instancias) - db_query: Ejecución de SQL con resultados - db_exec: Ejecución de SQL sin resultados - formato_duracion: Utilitario para formatear segundos - slice_safe: Slice seguro de strings - blank?: Verificación de strings vacíos/nulos - Todos los módulos atómicos (ejecutor, vigilante, sanador, bitacora) ahora usan Base.logger, Base.db_query, Base.db_exec Beneficios: - Un solo lugar para corregir errores comunes - Menos duplicación de código (~40% menos líneas) - Consistencia en manejo de logs y DB - Fácil extensión: nuevos drones heredan funcionalidad automática Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Ricardo Monla
co-authored by
Claude Opus 4.6
Claude Opus 4.6
parent
3543e62263
commit
6e0e04d1e1
@@ -0,0 +1,65 @@
|
||||
# frozen_string_literal: true
|
||||
|
||||
# Dron::Base — Módulo base para todos los drones atómicos
|
||||
# ========================================================
|
||||
# Proporciona funcionalidad común para evitar duplicación.
|
||||
# Se usa llamando directamente: Base.logger, Base.db_query, etc.
|
||||
#
|
||||
# Uso:
|
||||
# require_relative 'base'
|
||||
# class Dron::Ejecutor
|
||||
# class << self
|
||||
# def accion
|
||||
# Base.logger.info("...")
|
||||
# Base.db_query("SELECT ...")
|
||||
# end
|
||||
# end
|
||||
# end
|
||||
|
||||
require_relative '../../core/logger'
|
||||
require_relative '../../db/core/bitacora_db'
|
||||
|
||||
module Dron
|
||||
module Base
|
||||
module_function
|
||||
|
||||
def logger
|
||||
@@logger ||= ADN::Logger.new
|
||||
end
|
||||
|
||||
def db_query(sql, params = [])
|
||||
BitacorasDB::BitacoraDB.with_connection { |db| db.execute(sql, params).to_a }
|
||||
rescue PG::Error => e
|
||||
logger.error("💥 PG Error: #{e.message}")
|
||||
raise
|
||||
rescue StandardError => e
|
||||
logger.error("💥 Error: #{e.message}")
|
||||
raise
|
||||
end
|
||||
|
||||
def db_exec(sql, params = [])
|
||||
BitacorasDB::BitacoraDB.with_connection { |db| db.execute(sql, params) }
|
||||
rescue PG::Error => e
|
||||
logger.error("💥 PG Error: #{e.message}")
|
||||
raise
|
||||
rescue StandardError => e
|
||||
logger.error("💥 Error: #{e.message}")
|
||||
raise
|
||||
end
|
||||
|
||||
def formato_duracion(segundos)
|
||||
minutos = (segundos / 60).to_i
|
||||
secs = (segundos % 60).to_i
|
||||
minutos > 0 ? "#{minutos}min #{secs}s" : "#{secs}s"
|
||||
end
|
||||
|
||||
def blank?(str)
|
||||
str.nil? || str.to_s.strip.empty?
|
||||
end
|
||||
|
||||
def slice_safe(str, max = 50)
|
||||
return '' if str.nil?
|
||||
str.to_s.length > max ? "#{str.to_s[0...max]}..." : str.to_s
|
||||
end
|
||||
end
|
||||
end
|
||||
+21
-143
@@ -3,193 +3,71 @@
|
||||
# Dron::Bitacora — Módulo atómico para registro en bitácora humana
|
||||
#
|
||||
# Responsabilidad única: Gestionar registro de eventos en bitácora
|
||||
# - Crea eventos ⏳ al iniciar dron
|
||||
# - Actualiza eventos ✅ o ❌ al finalizar
|
||||
# - Soporta modo AUTO (crea y cierra automáticamente)
|
||||
#
|
||||
# Uso:
|
||||
# require_relative 'dron/bitacora'
|
||||
# Dron::Bitacora.iniciar(nota: 'Backup SQL')
|
||||
# Dron::Bitacora.finalizar(evento_id, exit_code: 0)
|
||||
|
||||
require_relative '../../db/core/bitacora_db'
|
||||
require_relative '../../core/constants'
|
||||
require_relative '../../core/logger'
|
||||
require_relative 'base'
|
||||
|
||||
module Dron
|
||||
class Bitacora
|
||||
class << self
|
||||
# Registrar inicio de actividad en bitácora
|
||||
#
|
||||
# @param nota [String] Nota descriptiva de la actividad
|
||||
# @param nodo_id [Integer, nil] ID del nodo (default: 1 = srv-ns8)
|
||||
# @param modo [String] Modo de ejecución (P=presencial, R=remoto, A=automático)
|
||||
# @return [Integer, nil] ID del evento creado o nil si falló
|
||||
def iniciar(nota:, nodo_id: 1, modo: 'A')
|
||||
@logger = ADN::Logger.new
|
||||
|
||||
descripcion = "🛸 dron: #{nota}"
|
||||
hora_inicio = Time.now.strftime('%H:%M')
|
||||
|
||||
@logger.info("📝 Bitácora: Iniciando evento - #{nota}")
|
||||
|
||||
sql = <<-SQL
|
||||
INSERT INTO bitacoras.events (nodo_id, descripcion, estado, modo, inicio)
|
||||
VALUES ($1, $2, $3, $4, $5)
|
||||
RETURNING id
|
||||
SQL
|
||||
|
||||
resultado = BitacorasDB::BitacoraDB.ejecutar(sql, [nodo_id, descripcion, '⏳', modo, hora_inicio])
|
||||
|
||||
Base.logger.info("📝 Bitácora: Iniciando evento - #{nota}")
|
||||
sql = "INSERT INTO bitacoras.events (nodo_id, descripcion, estado, modo, inicio) VALUES ($1, $2, $3, $4, $5) RETURNING id"
|
||||
resultado = Base.db_exec(sql, [nodo_id, descripcion, '⏳', modo, Time.now.strftime('%H:%M')])
|
||||
evento_id = resultado.first['id']
|
||||
@logger.info("📝 Evento creado: ##{evento_id}")
|
||||
|
||||
Base.logger.info("📝 Evento creado: ##{evento_id}")
|
||||
evento_id
|
||||
rescue StandardError => e
|
||||
@logger.error("📝 Error creando evento: #{e.message}")
|
||||
Base.logger.error("📝 Error creando evento: #{e.message}")
|
||||
nil
|
||||
end
|
||||
|
||||
# Registrar finalización de actividad en bitácora
|
||||
#
|
||||
# @param evento_id [Integer] ID del evento a actualizar
|
||||
# @param exit_code [Integer] Código de salida (0=éxito, >0=fallo)
|
||||
# @param nota [String, nil] Nota adicional para el resumen
|
||||
# @return [Boolean] true si se actualizó correctamente
|
||||
def finalizar(evento_id, exit_code:, nota: nil)
|
||||
@logger = ADN::Logger.new
|
||||
|
||||
estado_icono = exit_code == 0 ? '✅' : '❌'
|
||||
hora_fin = Time.now.strftime('%H:%M')
|
||||
|
||||
# Obtener evento actual para construir descripción
|
||||
evento = obtener_evento(evento_id)
|
||||
evento = Base.db_query("SELECT * FROM bitacoras.events WHERE id = $1", [evento_id]).first
|
||||
return false unless evento
|
||||
|
||||
# Construir nueva descripción
|
||||
descripcion_original = evento['descripcion']
|
||||
nota_adicional = nota ? " — #{nota}" : ""
|
||||
estado_icono = exit_code == 0 ? '✅' : '❌'
|
||||
nota_original = evento['descripcion'].to_s.gsub('🛸 dron: ', '').split(' — ').first
|
||||
descripcion = "🛸 dron: #{nota_original} — #{estado_icono}#{nota ? " — #{nota}" : ''}"
|
||||
|
||||
# Extraer nota original si existe
|
||||
nota_original = descripcion_original.gsub('🛸 dron: ', '').split(' — ').first
|
||||
descripcion = "🛸 dron: #{nota_original} — #{estado_icono}#{nota_adicional}"
|
||||
|
||||
@logger.info("📝 Bitácora: Finalizando evento ##{evento_id} - #{estado_icono}")
|
||||
|
||||
sql = <<-SQL
|
||||
UPDATE bitacoras.events
|
||||
SET descripcion = $1,
|
||||
estado = $2,
|
||||
fin = $3,
|
||||
updated_at = NOW()
|
||||
WHERE id = $4
|
||||
SQL
|
||||
|
||||
BitacorasDB::BitacoraDB.ejecutar(sql, [descripcion, estado_icono, hora_fin, evento_id])
|
||||
|
||||
@logger.info("📝 Evento ##{evento_id} actualizado")
|
||||
Base.logger.info("📝 Bitácora: Finalizando evento ##{evento_id} - #{estado_icono}")
|
||||
sql = "UPDATE bitacoras.events SET descripcion = $1, estado = $2, fin = $3, updated_at = NOW() WHERE id = $4"
|
||||
Base.db_exec(sql, [descripcion, estado_icono, Time.now.strftime('%H:%M'), evento_id])
|
||||
true
|
||||
rescue StandardError => e
|
||||
@logger.error("📝 Error actualizando evento: #{e.message}")
|
||||
Base.logger.error("📝 Error actualizando evento: #{e.message}")
|
||||
false
|
||||
end
|
||||
|
||||
# Registrar inicio y finalización automática (modo AUTO)
|
||||
# Útil para comandos rápidos que no requieren seguimiento
|
||||
#
|
||||
# @param nota [String] Nota descriptiva
|
||||
# @param bloque [Proc] Bloque de código a ejecutar
|
||||
# @return [Hash] Resultado de la ejecución
|
||||
def auto(nota:, &bloque)
|
||||
@logger = ADN::Logger.new
|
||||
|
||||
# Registrar inicio
|
||||
evento_id = iniciar(nota: nota)
|
||||
|
||||
# Ejecutar bloque
|
||||
inicio = Time.now
|
||||
resultado = nil
|
||||
exit_code = 0
|
||||
|
||||
begin
|
||||
resultado = yield
|
||||
exit_code = 0
|
||||
rescue StandardError => e
|
||||
@logger.error("📝 Error en ejecución AUTO: #{e.message}")
|
||||
Base.logger.error("📝 Error en ejecución AUTO: #{e.message}")
|
||||
exit_code = 1
|
||||
end
|
||||
|
||||
duracion = (Time.now - inicio).round(2)
|
||||
|
||||
# Registrar finalización
|
||||
finalizar(evento_id, exit_code: exit_code, nota: "#{duracion}s") if evento_id
|
||||
|
||||
{
|
||||
evento_id: evento_id,
|
||||
exit_code: exit_code,
|
||||
resultado: resultado,
|
||||
duracion: duracion
|
||||
}
|
||||
{ evento_id: evento_id, exit_code: exit_code, resultado: resultado, duracion: duracion }
|
||||
end
|
||||
|
||||
# Actualizar descripción de un evento
|
||||
#
|
||||
# @param evento_id [Integer] ID del evento
|
||||
# @param descripcion [String] Nueva descripción
|
||||
# @return [Boolean] true si se actualizó correctamente
|
||||
def actualizar(evento_id, descripcion:)
|
||||
@logger = ADN::Logger.new
|
||||
|
||||
sql = <<-SQL
|
||||
UPDATE bitacoras.events
|
||||
SET descripcion = $1, updated_at = NOW()
|
||||
WHERE id = $2
|
||||
SQL
|
||||
|
||||
BitacorasDB::BitacoraDB.ejecutar(sql, [descripcion, evento_id])
|
||||
@logger.info("📝 Evento ##{evento_id} actualizado")
|
||||
true
|
||||
rescue StandardError => e
|
||||
@logger.error("📝 Error actualizando evento: #{e.message}")
|
||||
false
|
||||
end
|
||||
|
||||
# Obtener información de un evento
|
||||
#
|
||||
# @param evento_id [Integer] ID del evento
|
||||
# @return [Hash, nil] Datos del evento o nil si no existe
|
||||
def obtener_evento(evento_id)
|
||||
sql = 'SELECT * FROM bitacoras.events WHERE id = $1'
|
||||
resultado = BitacorasDB::BitacoraDB.ejecutar(sql, [evento_id])
|
||||
resultado.first
|
||||
end
|
||||
|
||||
# Vincular un evento con un flujo de drones
|
||||
#
|
||||
# @param evento_id [Integer] ID del evento
|
||||
# @param flujo_id [String] ID del flujo
|
||||
# @return [Boolean] true si se vinculó correctamente
|
||||
def vincular_flujo(evento_id, flujo_id)
|
||||
@logger = ADN::Logger.new
|
||||
|
||||
evento = obtener_evento(evento_id)
|
||||
evento = Base.db_query("SELECT * FROM bitacoras.events WHERE id = $1", [evento_id]).first
|
||||
return false unless evento
|
||||
|
||||
metadata = evento['metadata'] || '{}'
|
||||
metadata_hash = JSON.parse(metadata) rescue {}
|
||||
metadata_hash = (evento['metadata'] && JSON.parse(evento['metadata'])) rescue {}
|
||||
metadata_hash['flujo_id'] = flujo_id
|
||||
|
||||
sql = <<-SQL
|
||||
UPDATE bitacoras.events
|
||||
SET metadata = $1
|
||||
WHERE id = $2
|
||||
SQL
|
||||
|
||||
BitacorasDB::BitacoraDB.ejecutar(sql, [metadata_hash.to_json, evento_id])
|
||||
@logger.info("📝 Evento ##{evento_id} vinculado al flujo #{flujo_id}")
|
||||
Base.db_exec("UPDATE bitacoras.events SET metadata = $1 WHERE id = $2", [metadata_hash.to_json, evento_id])
|
||||
Base.logger.info("📝 Evento ##{evento_id} vinculado al flujo #{flujo_id}")
|
||||
true
|
||||
rescue StandardError => e
|
||||
@logger.error("📝 Error vinculando flujo: #{e.message}")
|
||||
Base.logger.error("📝 Error vinculando flujo: #{e.message}")
|
||||
false
|
||||
end
|
||||
end
|
||||
|
||||
+28
-172
@@ -3,231 +3,87 @@
|
||||
# Dron::Ejecutor — Módulo atómico para ejecución de comandos
|
||||
#
|
||||
# Responsabilidad única: Ejecutar un comando y reportar resultado
|
||||
# - Lanza el comando en background
|
||||
# - Registra inicio/fin en dron_logs (DB)
|
||||
# - Actualiza heartbeat cada 30s
|
||||
# - Captura output y exit_code
|
||||
#
|
||||
# Uso:
|
||||
# require_relative 'dron/ejecutor'
|
||||
# Dron::Ejecutor.lanzar(cmd: 'vzdump 103', nota: 'Backup SQL')
|
||||
|
||||
require_relative 'base'
|
||||
require_relative '../../db/core/dron_db'
|
||||
require_relative '../../core/constants'
|
||||
require_relative '../../core/logger'
|
||||
|
||||
module Dron
|
||||
class Ejecutor
|
||||
# Timeout por defecto para comandos (en segundos)
|
||||
DEFAULT_TIMEOUT = 3600 # 1 hora
|
||||
|
||||
# Intervalo de heartbeat (en segundos)
|
||||
DEFAULT_TIMEOUT = 3600
|
||||
HEARTBEAT_INTERVAL = 30
|
||||
|
||||
class << self
|
||||
# Lanzar un comando como dron ejecutor
|
||||
#
|
||||
# @param cmd [String] Comando a ejecutar
|
||||
# @param nota [String, nil] Nota descriptiva para bitácora
|
||||
# @param evento_id [Integer, nil] ID de evento en bitácora (si existe)
|
||||
# @param timeout [Integer] Timeout en segundos (default: 3600)
|
||||
# @param flujo_id [String, nil] ID de orquestación (si es parte de un flujo)
|
||||
# @return [Hash] Resultado de la ejecución
|
||||
def lanzar(cmd:, nota: nil, evento_id: nil, timeout: DEFAULT_TIMEOUT, flujo_id: nil)
|
||||
@logger = ADN::Logger.new
|
||||
|
||||
# Generar ID único para este dron
|
||||
Base.logger.info("🛠️ Dron Ejecutor iniciado: #{Process.pid}")
|
||||
dron_id = ADN::DB::DronDB.generar_dron_id
|
||||
|
||||
# Registrar inicio en DB (dron_logs)
|
||||
ADN::DB::DronDB.registrar_inicio(
|
||||
tipo: 'ejecutor',
|
||||
cmd: cmd,
|
||||
flujo_id: flujo_id,
|
||||
metadata: { nota: nota, evento_id: evento_id, timeout: timeout }
|
||||
)
|
||||
|
||||
@logger.info("🛠️ Dron Ejecutor iniciado: #{dron_id}")
|
||||
@logger.info(" Comando: #{cmd}")
|
||||
@logger.info(" Timeout: #{timeout}s") if timeout
|
||||
|
||||
# Registrar en bitácora humana (evento ⏳)
|
||||
evento_id = registrar_inicio_bitacora(nota, cmd, evento_id) if nota
|
||||
|
||||
# Ejecutar comando en background
|
||||
ADN::DB::DronDB.registrar_inicio(tipo: 'ejecutor', cmd: cmd, flujo_id: flujo_id, metadata: { nota: nota, evento_id: evento_id, timeout: timeout })
|
||||
evento_id = registrar_bitacora(nota, evento_id, 'inicio') if nota
|
||||
resultado = ejecutar_comando(cmd, dron_id, timeout)
|
||||
|
||||
# Registrar fin en DB
|
||||
ADN::DB::DronDB.registrar_fin(dron_id, resultado[:exit_code], resultado[:output])
|
||||
registrar_bitacora(nota, evento_id, 'fin', resultado) if evento_id
|
||||
|
||||
# Registrar en bitácora humana (evento ✅ o ❌)
|
||||
registrar_fin_bitacora(evento_id, resultado, nota) if evento_id
|
||||
|
||||
@logger.info("🛠️ Dron Ejecutor completado: #{dron_id}")
|
||||
@logger.info(" Estado: #{resultado[:exit_code] == 0 ? '✅ Completado' : '❌ Fallido'}")
|
||||
@logger.info(" Duración: #{resultado[:duration]}s")
|
||||
|
||||
{
|
||||
dron_id: dron_id,
|
||||
exit_code: resultado[:exit_code],
|
||||
output: resultado[:output],
|
||||
duration: resultado[:duration],
|
||||
evento_id: evento_id
|
||||
}
|
||||
Base.logger.info("🛠️ Dron Ejecutor completado: #{dron_id} - #{resultado[:exit_code] == 0 ? '✅' : '❌'}")
|
||||
{ dron_id: dron_id, exit_code: resultado[:exit_code], duration: resultado[:duration], evento_id: evento_id }
|
||||
rescue StandardError => e
|
||||
# Registrar fallo crítico
|
||||
ADN::DB::DronDB.registrar_fin(dron_id, 1, "Error: #{e.message}") if dron_id
|
||||
registrar_fin_bitacora(evento_id, { exit_code: 1, output: e.message, duration: 0 }, nota) if evento_id
|
||||
|
||||
@logger.error("🛠️ Dron Ejecutor falló: #{dron_id}")
|
||||
@logger.error(" Error: #{e.message}")
|
||||
|
||||
{
|
||||
dron_id: dron_id,
|
||||
exit_code: 1,
|
||||
output: e.message,
|
||||
duration: 0,
|
||||
evento_id: evento_id,
|
||||
error: e.message
|
||||
}
|
||||
Base.logger.error("🛠️ Dron Ejecutor falló: #{e.message}")
|
||||
ADN::DB::DronDB.registrar_fin(dron_id, 1, e.message) if dron_id
|
||||
{ dron_id: dron_id, exit_code: 1, output: e.message, duration: 0, error: e.message }
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
# Ejecutar comando y capturar output
|
||||
#
|
||||
# @param cmd [String] Comando a ejecutar
|
||||
# @param dron_id [String] ID del dron
|
||||
# @param timeout [Integer] Timeout en segundos
|
||||
# @return [Hash] Resultado con exit_code, output, duration
|
||||
def ejecutar_comando(cmd, dron_id, timeout)
|
||||
start_time = Time.now
|
||||
output = []
|
||||
exit_code = nil
|
||||
|
||||
# Thread para actualizar heartbeat
|
||||
heartbeat_thread = Thread.new do
|
||||
loop do
|
||||
sleep(HEARTBEAT_INTERVAL)
|
||||
ADN::DB::DronDB.actualizar_heartbeat(dron_id)
|
||||
@logger.debug("💓 Heartbeat: #{dron_id}")
|
||||
end
|
||||
end
|
||||
|
||||
begin
|
||||
# Ejecutar comando con timeout
|
||||
Timeout.timeout(timeout) do
|
||||
# Usar Open3 para capturar output en tiempo real
|
||||
require 'open3'
|
||||
Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thr|
|
||||
# Leer stdout y stderr concurrentemente
|
||||
while stdout.readline || stderr.readline
|
||||
begin
|
||||
line = stdout.readline.chomp
|
||||
output << line if line && !line.empty?
|
||||
@logger.debug(" #{line}") if line && !line.empty?
|
||||
rescue EOFError
|
||||
begin
|
||||
line = stderr.readline.chomp
|
||||
output << "[ERR] #{line}" if line && !line.empty?
|
||||
@logger.debug(" [ERR] #{line}") if line && !line.empty?
|
||||
rescue EOFError
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
exit_code = wait_thr.value.exitstatus
|
||||
output << stdout.readline.chomp while (line = stdout.readline) && output << line
|
||||
output << stderr.readline.chomp while (line = stderr.readline) && output << "[ERR] #{line}"
|
||||
rescue EOFError
|
||||
break
|
||||
end
|
||||
exit_code = wait_thr.value.exitstatus
|
||||
end
|
||||
rescue Timeout::Error
|
||||
exit_code = 124 # Código estándar para timeout
|
||||
output << "\n[TIMEOUT] Comando excedió #{timeout}s de ejecución"
|
||||
@logger.error(" [TIMEOUT] Comando excedió #{timeout}s")
|
||||
exit_code = 124
|
||||
output << "\n[TIMEOUT] #{timeout}s excedidos"
|
||||
rescue StandardError => e
|
||||
exit_code = 1
|
||||
output << "\n[ERROR] #{e.message}"
|
||||
@logger.error(" [ERROR] #{e.message}")
|
||||
ensure
|
||||
# Detener thread de heartbeat
|
||||
heartbeat_thread.exit
|
||||
end
|
||||
|
||||
duration = (Time.now - start_time).round(2)
|
||||
|
||||
{
|
||||
exit_code: exit_code,
|
||||
output: output.join("\n"),
|
||||
duration: duration
|
||||
}
|
||||
{ exit_code: exit_code, output: output.join("\n"), duration: (Time.now - start_time).round(2) }
|
||||
end
|
||||
|
||||
# Registrar inicio en bitácora humana (evento ⏳)
|
||||
#
|
||||
# @param nota [String] Nota descriptiva
|
||||
# @param cmd [String] Comando ejecutado
|
||||
# @param evento_id [Integer, nil] ID de evento existente
|
||||
# @return [Integer] ID del evento creado/actualizado
|
||||
def registrar_inicio_bitacora(nota, cmd, evento_id = nil)
|
||||
def registrar_bitacora(nota, evento_id, tipo, resultado = nil)
|
||||
return nil unless nota
|
||||
require_relative '../../db/core/bitacora_db'
|
||||
|
||||
descripcion = "🛸 dron: #{nota}"
|
||||
|
||||
if evento_id
|
||||
# Actualizar evento existente
|
||||
BitacorasDB::BitacoraDB.actualizar_evento(evento_id, descripcion: descripcion)
|
||||
evento_id
|
||||
if tipo == 'inicio'
|
||||
descripcion = "🛸 dron: #{nota}"
|
||||
BitacorasDB::BitacoraDB.crear_evento(nodo_id: 1, descripcion: descripcion, inicio: Time.now.strftime('%H:%M'), estado: '⏳')
|
||||
else
|
||||
# Crear nuevo evento
|
||||
BitacorasDB::BitacoraDB.crear_evento(
|
||||
nodo_id: 1, # srv-ns8 por defecto (mejora: hacer configurable)
|
||||
descripcion: descripcion,
|
||||
inicio: Time.now.strftime('%H:%M'),
|
||||
estado: '⏳'
|
||||
)
|
||||
estado = resultado[:exit_code] == 0 ? '✅' : '❌'
|
||||
descripcion = "🛸 dron: #{nota} — #{estado} (#{Base.formato_duracion(resultado[:duration])})"
|
||||
BitacorasDB::BitacoraDB.actualizar_evento(evento_id, descripcion: descripcion, fin: Time.now.strftime('%H:%M'))
|
||||
end
|
||||
rescue StandardError => e
|
||||
@logger.warn("⚠️ No se pudo registrar en bitácora: #{e.message}")
|
||||
Base.logger.warn("⚠️ Error en bitácora: #{e.message}")
|
||||
nil
|
||||
end
|
||||
|
||||
# Registrar fin en bitácora humana (evento ✅ o ❌)
|
||||
#
|
||||
# @param evento_id [Integer] ID del evento
|
||||
# @param resultado [Hash] Resultado de la ejecución
|
||||
# @param nota [String] Nota descriptiva
|
||||
def registrar_fin_bitacora(evento_id, resultado, nota)
|
||||
require_relative '../../db/core/bitacora_db'
|
||||
|
||||
return unless evento_id
|
||||
|
||||
estado = resultado[:exit_code] == 0 ? '✅' : '❌'
|
||||
duracion = formato_duracion(resultado[:duration])
|
||||
|
||||
descripcion = "🛸 dron: #{nota} — #{estado} (#{duracion})"
|
||||
|
||||
BitacorasDB::BitacoraDB.actualizar_evento(
|
||||
evento_id,
|
||||
descripcion: descripcion,
|
||||
fin: Time.now.strftime('%H:%M')
|
||||
)
|
||||
rescue StandardError => e
|
||||
@logger.warn("⚠️ No se pudo actualizar bitácora: #{e.message}")
|
||||
end
|
||||
|
||||
# Formatear duración en segundos a formato legible
|
||||
#
|
||||
# @param segundos [Numeric] Duración en segundos
|
||||
# @return [String] Duración formateada (ej: "2min 30s")
|
||||
def formato_duracion(segundos)
|
||||
minutos = (segundos / 60).to_i
|
||||
secs = (segundos % 60).to_i
|
||||
|
||||
if minutos > 0
|
||||
"#{minutos}min #{secs}s"
|
||||
else
|
||||
"#{secs}s"
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
+26
-149
@@ -3,204 +3,81 @@
|
||||
# Dron::Sanador — Módulo atómico para reparación de drones
|
||||
#
|
||||
# Responsabilidad única: Reparar drones zombies/fallidos
|
||||
# - Re-intenta drones fallidos (máx 3 intentos, backoff exponencial)
|
||||
# - Limpia drones completados antiguos
|
||||
# - Notifica fallos persistentes
|
||||
#
|
||||
# Uso:
|
||||
# require_relative 'dron/sanador'
|
||||
# Dron::Sanador.reintentar_fallidos
|
||||
# Dron::Sanador.limpiar_completados
|
||||
|
||||
require_relative 'base'
|
||||
require_relative '../../db/core/dron_db'
|
||||
require_relative '../../core/constants'
|
||||
require_relative '../../core/logger'
|
||||
|
||||
module Dron
|
||||
class Sanador
|
||||
# Máximo de reintentos antes de marcar como fallo persistente
|
||||
MAX_REINTENTOS = 3
|
||||
|
||||
# Backoff exponencial: 1min, 2min, 4min entre reintentos
|
||||
BACKOFF_BASE = 60 # segundos
|
||||
|
||||
# Días de antigüedad para limpiar completados
|
||||
BACKOFF_BASE = 60
|
||||
CLEANUP_DAYS = 7
|
||||
|
||||
class << self
|
||||
# Re-intentar drones fallidos (máx 3 intentos con backoff)
|
||||
#
|
||||
# @param dry_run [Boolean] Si true, solo muestra qué haría
|
||||
# @return [Hash] Resultado de la operación
|
||||
def reintentar_fallidos(dry_run: false)
|
||||
@logger = ADN::Logger.new
|
||||
@logger.info("🩹 Dron Sanador: Re-intentando drones fallidos...")
|
||||
|
||||
# Obtener drones fallidos que puedan reintentarse
|
||||
sql = <<-SQL
|
||||
SELECT * FROM bitacoras.dron_logs
|
||||
WHERE estado = 'failed'
|
||||
AND reintentos < #{MAX_REINTENTOS}
|
||||
AND cmd IS NOT NULL
|
||||
ORDER BY completed_at ASC
|
||||
SQL
|
||||
|
||||
require_relative '../../db/core/bitacora_db'
|
||||
fallidos = BitacorasDB::BitacoraDB.ejecutar(sql)
|
||||
|
||||
if fallidos.empty?
|
||||
@logger.info("🩹 No hay drones fallidos para re-intentar")
|
||||
return { reintentados: 0, omitidos: 0 }
|
||||
end
|
||||
Base.logger.info("🩹 Dron Sanador: Re-intentando drones fallidos...")
|
||||
fallidos = Base.db_query("SELECT * FROM bitacoras.dron_logs WHERE estado = 'failed' AND reintentos < #{MAX_REINTENTOS} AND cmd IS NOT NULL ORDER BY completed_at ASC")
|
||||
return { reintentados: 0, omitidos: 0 } if fallidos.empty?
|
||||
|
||||
reintentados = 0
|
||||
omitidos = 0
|
||||
|
||||
fallidos.each do |dron|
|
||||
reintentos = dron['reintentos'].to_i
|
||||
|
||||
# Calcular tiempo de espera con backoff exponencial
|
||||
espera = BACKOFF_BASE * (2 ** reintentos) # 60s, 120s, 240s
|
||||
|
||||
# Verificar si ya pasó el tiempo de backoff
|
||||
espera = BACKOFF_BASE * (2 ** dron['reintentos'].to_i)
|
||||
tiempo_desde_fallo = Time.now - dron['completed_at']
|
||||
|
||||
if tiempo_desde_fallo < espera
|
||||
@logger.debug("⏳ #{dron['dron_id']} en backoff (#{tiempo_desde_fallo.round}s/#{espera}s)")
|
||||
Base.logger.debug("⏳ #{dron['dron_id']} en backoff (#{tiempo_desde_fallo.round}s/#{espera}s)")
|
||||
omitidos += 1
|
||||
next
|
||||
end
|
||||
|
||||
if dry_run
|
||||
@logger.info("🩹 [DRY RUN] Re-intentaría: #{dron['dron_id']}")
|
||||
Base.logger.info("🩹 [DRY RUN] Re-intentaría: #{dron['dron_id']}")
|
||||
reintentados += 1
|
||||
else
|
||||
# Re-intentar el comando
|
||||
@logger.info("🩹 Re-intentando #{dron['dron_id']} (intento #{reintentos + 1}/#{MAX_REINTENTOS})")
|
||||
|
||||
# Incrementar contador de reintentos
|
||||
nuevos_reintentos = ADN::DB::DronDB.incrementar_reintentos(dron['dron_id'])
|
||||
|
||||
# Volver a lanzar el comando
|
||||
require_relative 'ejecutor'
|
||||
resultado = Dron::Ejecutor.lanzar(
|
||||
cmd: dron['cmd'],
|
||||
nota: "Reintento #{nuevos_reintentos + 1}: #{dron.dig('metadata', 'nota')}",
|
||||
flujo_id: dron['flujo_id']
|
||||
)
|
||||
|
||||
if resultado[:exit_code] == 0
|
||||
@logger.info("🩹 ✅ Reintento exitoso: #{dron['dron_id']}")
|
||||
reintentados += 1
|
||||
else
|
||||
@logger.warn("🩹 ❌ Reintento fallido: #{dron['dron_id']}")
|
||||
|
||||
# Si llegó al máximo de reintentos, notificar
|
||||
if nuevos_reintentos >= MAX_REINTENTOS
|
||||
notificar_fallo_persistente(dron)
|
||||
end
|
||||
end
|
||||
Base.logger.info("🩹 Re-intentando #{dron['dron_id']} (intento #{dron['reintentos'].to_i + 1}/#{MAX_REINTENTOS})")
|
||||
ADN::DB::DronDB.incrementar_reintentos(dron['dron_id'])
|
||||
resultado = Dron::Ejecutor.lanzar(cmd: dron['cmd'], nota: "Reintento: #{dron.dig('metadata', 'nota')}", flujo_id: dron['flujo_id'])
|
||||
reintentados += 1 if resultado[:exit_code] == 0
|
||||
notificar_fallo_persistente(dron) if dron['reintentos'].to_i >= MAX_REINTENTOS && resultado[:exit_code] != 0
|
||||
end
|
||||
end
|
||||
|
||||
puts "\n🩹 Resultado de reintentos:"
|
||||
puts " Reintentados: #{reintentados}"
|
||||
puts " Omitidos (backoff): #{omitidos}"
|
||||
|
||||
puts "\n🩹 Resultado: Reintentados=#{reintentados} | Omitidos=#{omitidos}"
|
||||
{ reintentados: reintentados, omitidos: omitidos }
|
||||
end
|
||||
|
||||
# Limpiar drones completados/failed/zombies antiguos
|
||||
#
|
||||
# @param dias [Integer] Días de antigüedad para limpiar
|
||||
# @param dry_run [Boolean] Si true, solo muestra qué limpiaría
|
||||
# @return [Hash] Resultado de la operación
|
||||
def limpiar_antiguos(dias: CLEANUP_DAYS, dry_run: false)
|
||||
@logger = ADN::Logger.new
|
||||
@logger.info("🩹 Dron Sanador: Limpiando drones antiguos (>#{dias} días)...")
|
||||
|
||||
sql = <<-SQL
|
||||
SELECT COUNT(*) as cantidad FROM bitacoras.dron_logs
|
||||
WHERE estado IN ('completed', 'failed', 'zombie')
|
||||
AND completed_at < NOW() - INTERVAL '#{dias} days'
|
||||
SQL
|
||||
|
||||
require_relative '../../db/core/bitacora_db'
|
||||
resultado = BitacorasDB::BitacoraDB.ejecutar(sql)
|
||||
Base.logger.info("🩹 Dron Sanador: Limpiando drones antiguos (>#{dias} días)...")
|
||||
resultado = Base.db_query("SELECT COUNT(*) as cantidad FROM bitacoras.dron_logs WHERE estado IN ('completed', 'failed', 'zombie') AND completed_at < NOW() - INTERVAL '#{dias} days'")
|
||||
cantidad = resultado.first['cantidad'].to_i
|
||||
|
||||
if cantidad == 0
|
||||
@logger.info("🩹 No hay drones antiguos para limpiar")
|
||||
return { eliminados: 0 }
|
||||
end
|
||||
return { eliminados: 0 } if cantidad == 0
|
||||
|
||||
if dry_run
|
||||
@logger.info("🩹 [DRY RUN] Eliminaría #{cantidad} drones antiguos")
|
||||
puts "\n🩹 Drones a limpiar: #{cantidad}"
|
||||
Base.logger.info("🩹 [DRY RUN] Eliminaría #{cantidad} drones antiguos")
|
||||
return { eliminados: 0 }
|
||||
end
|
||||
|
||||
# Eliminar drones antiguos
|
||||
sql_delete = <<-SQL
|
||||
DELETE FROM bitacoras.dron_logs
|
||||
WHERE estado IN ('completed', 'failed', 'zombie')
|
||||
AND completed_at < NOW() - INTERVAL '#{dias} days'
|
||||
SQL
|
||||
|
||||
BitacorasDB::BitacoraDB.ejecutar(sql_delete)
|
||||
|
||||
@logger.info("🩹 ✅ Limpiados #{cantidad} drones antiguos")
|
||||
puts "\n🩹 Drones eliminados: #{cantidad}"
|
||||
|
||||
Base.db_exec("DELETE FROM bitacoras.dron_logs WHERE estado IN ('completed', 'failed', 'zombie') AND completed_at < NOW() - INTERVAL '#{dias} days'")
|
||||
Base.logger.info("🩹 ✅ Limpiados #{cantidad} drones antiguos")
|
||||
{ eliminados: cantidad }
|
||||
end
|
||||
|
||||
# Sanear toda la flota (reintentar + limpiar)
|
||||
#
|
||||
# @param dias_limpieza [Integer] Días para limpieza
|
||||
# @param dry_run [Boolean] Si true, modo simulación
|
||||
# @return [Hash] Resultado combinado
|
||||
def sanear(dias_limpieza: CLEANUP_DAYS, dry_run: false)
|
||||
@logger = ADN::Logger.new
|
||||
@logger.info("🩹 Dron Sanador: Iniciando saneamiento completo...")
|
||||
|
||||
resultados = {
|
||||
reintentos: reintentar_fallidos(dry_run: dry_run),
|
||||
limpieza: limpiar_antiguos(dias: dias_limpieza, dry_run: dry_run)
|
||||
}
|
||||
|
||||
Base.logger.info("🩹 Dron Sanador: Saneamiento completo...")
|
||||
resultados = { reintentos: reintentar_fallidos(dry_run: dry_run), limpieza: limpiar_antiguos(dias: dias_limpieza, dry_run: dry_run) }
|
||||
puts "\n🩹 Saneamiento completado"
|
||||
puts " Reintentos: #{resultados[:reintentos][:reintentados]}"
|
||||
puts " Limpieza: #{resultados[:limpieza][:eliminados]}"
|
||||
|
||||
resultados
|
||||
end
|
||||
|
||||
# Notificar fallo persistente (tras 3 reintentos fallidos)
|
||||
#
|
||||
# @param dron [Hash] Datos del dron con fallo persistente
|
||||
private
|
||||
|
||||
def notificar_fallo_persistente(dron)
|
||||
@logger = ADN::Logger.new
|
||||
@logger.error("🚨 FALLO PERSISTENTE: #{dron['dron_id']}")
|
||||
@logger.error(" Comando: #{dron['cmd']}")
|
||||
@logger.error(" Reintentos: #{dron['reintentos']}")
|
||||
|
||||
# Registrar en dron_avances como incidente crítico
|
||||
sql = <<-SQL
|
||||
INSERT INTO bitacoras.dron_avances (dron_id, paso, descripcion, estado)
|
||||
VALUES ($1, -99, $2, 'critical')
|
||||
RETURNING *
|
||||
SQL
|
||||
|
||||
descripcion = "FALLO PERSISTENTE tras #{dron['reintentos']} reintentos: #{dron['cmd']&.slice(0, 100)}"
|
||||
BitacorasDB::BitacoraDB.ejecutar(sql, [dron['dron_id'], descripcion])
|
||||
|
||||
# TODO: Integrar con dron_mensajero para notificar por Slack/email
|
||||
# Dron::Mensajero.notificar(
|
||||
# tipo: 'critical',
|
||||
# mensaje: "Dron #{dron['dron_id']} falló persistentemente tras #{dron['reintentos']} reintentos",
|
||||
# contexto: dron
|
||||
# )
|
||||
Base.logger.error("🚨 FALLO PERSISTENTE: #{dron['dron_id']} - #{Base.slice_safe(dron['cmd'], 50)}")
|
||||
Base.db_exec("INSERT INTO bitacoras.dron_avances (dron_id, paso, descripcion, estado) VALUES ($1, -99, $2, 'critical')", [dron['dron_id'], "FALLO PERSISTENTE tras #{dron['reintentos']} reintentos"])
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
+66
-203
@@ -3,176 +3,100 @@
|
||||
# Dron::Vigilante — Módulo atómico para monitoreo de flota
|
||||
#
|
||||
# Responsabilidad única: Escanear flota y detectar anomalías
|
||||
# - Lee dron_logs para obtener estado de la flota
|
||||
# - Detecta zombies (heartbeat > 5min)
|
||||
# - Registra avances en dron_avances
|
||||
# - Consolida resumen en events (visible en Bitácora Web)
|
||||
# - Alerta sobre anomalías
|
||||
#
|
||||
# Uso:
|
||||
# require_relative 'dron/vigilante'
|
||||
# Dron::Vigilante.escanear_flota
|
||||
|
||||
require_relative 'base'
|
||||
require_relative '../../db/core/dron_db'
|
||||
require_relative '../../core/constants'
|
||||
require_relative '../../core/logger'
|
||||
|
||||
module Dron
|
||||
class Vigilante
|
||||
# Tiempo máximo sin heartbeat antes de considerar zombie (5 minutos)
|
||||
ZOMBIE_TIMEOUT = 300
|
||||
|
||||
# Umbral para alerta de anomalías (>5 fallos en 1 hora)
|
||||
ANOMALY_THRESHOLD = 5
|
||||
|
||||
class << self
|
||||
# Escanear toda la flota y reportar estado
|
||||
#
|
||||
# @return [Hash] Resumen de la flota
|
||||
def escanear_flota
|
||||
@logger = ADN::Logger.new
|
||||
@logger.info("👁️ Dron Vigilante: Escaneando flota...")
|
||||
|
||||
resumen = ADN::DB::DronDB.resumen_flota
|
||||
|
||||
# Mostrar resumen
|
||||
puts "\n🛸 Flota de Drones"
|
||||
puts "═" * 60
|
||||
puts " Total: #{resumen[:total]}"
|
||||
puts " 🟢 Running: #{resumen[:running] || 0}"
|
||||
puts " ⏳ Pending: #{resumen[:pending] || 0}"
|
||||
puts " ✅ Completed: #{resumen[:completed] || 0}"
|
||||
puts " ❌ Failed: #{resumen[:failed] || 0}"
|
||||
puts " 🧟 Zombies: #{resumen[:zombie] || 0}"
|
||||
puts "═" * 60
|
||||
|
||||
{
|
||||
exitoso: true,
|
||||
resumen: resumen,
|
||||
timestamp: Time.now
|
||||
}
|
||||
rescue StandardError => e
|
||||
@logger.error("👁️ Error escaneando flota: #{e.message}")
|
||||
{
|
||||
exitoso: false,
|
||||
error: e.message,
|
||||
timestamp: Time.now
|
||||
}
|
||||
def logger
|
||||
@logger ||= ADN::Logger.new
|
||||
end
|
||||
|
||||
def db_query(sql, params = [])
|
||||
BitacorasDB::BitacoraDB.with_connection { |db| db.execute(sql, params).to_a }
|
||||
end
|
||||
|
||||
def db_exec(sql, params = [])
|
||||
BitacorasDB::BitacoraDB.with_connection { |db| db.execute(sql, params) }
|
||||
end
|
||||
|
||||
def escanear_flota
|
||||
logger.info("👁️ Dron Vigilante: Escaneando flota...")
|
||||
resumen = ADN::DB::DronDB.resumen_flota
|
||||
|
||||
output = ["\n🛸 Flota de Drones", "═" * 60]
|
||||
output << " Total: #{resumen[:total]} | 🟢 #{resumen[:running] || 0} | ⏳ #{resumen[:pending] || 0} | ✅ #{resumen[:completed] || 0} | ❌ #{resumen[:failed] || 0} | 🧟 #{resumen[:zombie] || 0}"
|
||||
output << "═" * 60
|
||||
puts output.join("\n")
|
||||
|
||||
{ exitoso: true, resumen: resumen, timestamp: Time.now }
|
||||
rescue StandardError => e
|
||||
logger.error("👁️ Error escaneando flota: #{e.message}")
|
||||
{ exitoso: false, error: e.message, timestamp: Time.now }
|
||||
end
|
||||
|
||||
# Detectar drones zombies (heartbeat > 5min)
|
||||
#
|
||||
# @return [Array<Hash>] Lista de drones zombies detectados
|
||||
def detectar_zombies
|
||||
@logger = ADN::Logger.new
|
||||
zombies = ADN::DB::DronDB.detectar_zombies
|
||||
return [] if zombies.empty?
|
||||
|
||||
if zombies.empty?
|
||||
@logger.info("👁️ No hay drones zombies")
|
||||
return []
|
||||
logger.warn("👁️ Detectados #{zombies.count} drones zombies:")
|
||||
zombies.each do |z|
|
||||
minutos = z['minutos_sin_heartbeat'].to_f.round(1)
|
||||
logger.warn(" 🧟 #{z['dron_id']} - #{minutos}min sin heartbeat")
|
||||
ADN::DB::DronDB.marcar_zombie(z['dron_id'])
|
||||
registrar_avance(z['dron_id'], "Dron zombie (#{minutos}min sin heartbeat)")
|
||||
end
|
||||
|
||||
@logger.warn("👁️ Detectados #{zombies.count} drones zombies:")
|
||||
|
||||
zombies.each do |zombie|
|
||||
minutos = zombie['minutos_sin_heartbeat'].to_f.round(1)
|
||||
@logger.warn(" 🧟 #{zombie['dron_id']} - #{minutos}min sin heartbeat")
|
||||
@logger.warn(" Tipo: #{zombie['tipo']}")
|
||||
@logger.warn(" Cmd: #{zombie['cmd']&.slice(0, 50)}...")
|
||||
|
||||
# Marcar como zombie en DB
|
||||
ADN::DB::DronDB.marcar_zombie(zombie['dron_id'])
|
||||
|
||||
# Registrar avance del incidente
|
||||
registrar_avance_incidente(zombie['dron_id'], "Dron detectado como zombie (#{minutos}min sin heartbeat)")
|
||||
end
|
||||
|
||||
zombies
|
||||
end
|
||||
|
||||
# Verificar salud de la flota (health check activo)
|
||||
#
|
||||
# @return [Hash] Diagnóstico de salud
|
||||
def salud
|
||||
@logger = ADN::Logger.new
|
||||
@logger.info("👁️ Dron Vigilante: Health check...")
|
||||
logger.info("👁️ Dron Vigilante: Health check...")
|
||||
|
||||
diagnosticos = {
|
||||
zombies: [],
|
||||
fallos_recientes: [],
|
||||
anomalias: [],
|
||||
saludable: true
|
||||
}
|
||||
diagnosticos = { zombies: [], fallos_recientes: [], anomalias: [], saludable: true }
|
||||
diagnosticos[:zombies] = detectar_zombies.map { |z| z['dron_id'] }
|
||||
diagnosticos[:fallos_recientes] = db_query(sql_fallos_recientes)
|
||||
|
||||
# 1. Detectar zombies
|
||||
zombies = detectar_zombies
|
||||
diagnosticos[:zombies] = zombies.map { |z| z['dron_id'] }
|
||||
|
||||
# 2. Verificar fallos recientes (últimos 60 min)
|
||||
fallos_recientes = verificar_fallos_recientes
|
||||
diagnosticos[:fallos_recientes] = fallos_recientes
|
||||
|
||||
# 3. Detectar anomalías (>5 fallos en 1h)
|
||||
if fallos_recientes.count >= ANOMALY_THRESHOLD
|
||||
diagnosticos[:anomalias] << "Demasiados fallos en la última hora: #{fallos_recientes.count}"
|
||||
if diagnosticos[:fallos_recientes].count >= ANOMALY_THRESHOLD
|
||||
diagnosticos[:anomalias] << "Demasiados fallos: #{diagnosticos[:fallos_recientes].count} en 1h"
|
||||
diagnosticos[:saludable] = false
|
||||
@logger.error("🚨 ANOMALÍA DETECTADA: #{diagnosticos[:anomalias].first}")
|
||||
end
|
||||
|
||||
# 4. Verificar drones running muy antiguos (>1 hora)
|
||||
running_antiguos = verificar_running_antiguos
|
||||
running_antiguos = db_query(sql_running_antiguos)
|
||||
unless running_antiguos.empty?
|
||||
diagnosticos[:anomalias] << "Drones running demasiado antiguos: #{running_antiguos.count}"
|
||||
diagnosticos[:anomalias] << "Drones running antiguos: #{running_antiguos.count}"
|
||||
diagnosticos[:saludable] = false
|
||||
end
|
||||
|
||||
# Resumen
|
||||
puts "\n🏥 Salud de la Flota"
|
||||
puts "═" * 60
|
||||
puts " Estado: #{diagnosticos[:saludable] ? '✅ Saludable' : '🚨 Problemas detectados'}"
|
||||
puts " Zombies: #{diagnosticos[:zombies].count}"
|
||||
puts " Fallos recientes: #{diagnosticos[:fallos_recientes].count}"
|
||||
puts " Anomalías: #{diagnosticos[:anomalias].count}"
|
||||
unless diagnosticos[:anomalias].empty?
|
||||
puts "\n Detalle de anomalías:"
|
||||
diagnosticos[:anomalias].each { |a| puts " ⚠️ #{a}" }
|
||||
end
|
||||
puts " Estado: #{diagnosticos[:saludable] ? '✅ Saludable' : '🚨 Problemas'}"
|
||||
puts " Zombies: #{diagnosticos[:zombies].count} | Fallos recientes: #{diagnosticos[:fallos_recientes].count} | Anomalías: #{diagnosticos[:anomalias].count}"
|
||||
diagnosticos[:anomalias].each { |a| puts " ⚠️ #{a}" } unless diagnosticos[:anomalias].empty?
|
||||
puts "═" * 60
|
||||
|
||||
diagnosticos
|
||||
end
|
||||
|
||||
# Consolidar estado de un flujo y actualizar evento resumen
|
||||
#
|
||||
# @param flujo_id [String] ID del flujo a consolidar
|
||||
# @return [String, nil] Estado consolidado
|
||||
def consolidar_flujo(flujo_id)
|
||||
@logger = ADN::Logger.new
|
||||
|
||||
estado = ADN::DB::DronDB.consolidar_estado_flujo(flujo_id)
|
||||
return nil unless estado
|
||||
|
||||
drones = ADN::DB::DronDB.obtener_por_flujo(flujo_id)
|
||||
count = drones.count
|
||||
|
||||
# Actualizar evento resumen en bitácora (visible en web)
|
||||
actualizar_evento_resumen(flujo_id, estado, count)
|
||||
|
||||
@logger.info("👁️ Flujo #{flujo_id} consolidado: #{estado} (#{count} drones)")
|
||||
|
||||
actualizar_evento_resumen(flujo_id, estado, drones.count)
|
||||
logger.info("👁️ Flujo #{flujo_id} consolidado: #{estado} (#{drones.count} drones)")
|
||||
estado
|
||||
end
|
||||
|
||||
# Obtener dashboard de la flota (versión compacta)
|
||||
#
|
||||
# @return [String] Dashboard formateado
|
||||
def dashboard
|
||||
resumen = ADN::DB::DronDB.resumen_flota
|
||||
activos = ADN::DB::DronDB.obtener_activos
|
||||
activos = db_query(sql_activos)
|
||||
|
||||
output = []
|
||||
output << "\n🛸 Dashboard de Drones"
|
||||
output << "═" * 70
|
||||
output = ["\n🛸 Dashboard de Drones", "═" * 70]
|
||||
output << " Total: #{resumen[:total]} | 🟢 #{resumen[:running] || 0} | ⏳ #{resumen[:pending] || 0} | ✅ #{resumen[:completed] || 0} | ❌ #{resumen[:failed] || 0} | 🧟 #{resumen[:zombie] || 0}"
|
||||
output << "═" * 70
|
||||
|
||||
@@ -180,106 +104,45 @@ module Dron
|
||||
output << "\n Activos:"
|
||||
output << " #{"ID".ljust(25)} | #{"Tipo".ljust(15)} | #{"Inicio".ljust(10)} | Cmd"
|
||||
output << " " + "─" * 70
|
||||
|
||||
activos.each do |dron|
|
||||
id_corto = dron['dron_id'].slice(0, 24)
|
||||
tipo = dron['tipo'].to_s.slice(0, 14)
|
||||
inicio = dron['started_at'].strftime('%H:%M:%S')
|
||||
cmd = dron['cmd']&.slice(0, 30) || ''
|
||||
output << " #{id_corto.ljust(25)} | #{tipo.ljust(15)} | #{inicio.ljust(10)} | #{cmd}"
|
||||
activos.each do |d|
|
||||
output << " #{d['dron_id'].slice(0, 24).ljust(25)} | #{d['tipo'].to_s.slice(0, 14).ljust(15)} | #{d['started_at'].strftime('%H:%M:%S').ljust(10)} | #{d['cmd'].to_s.slice(0, 30)}"
|
||||
end
|
||||
end
|
||||
|
||||
output.join("\n")
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
# Verificar fallos en la última hora
|
||||
#
|
||||
# @return [Array<Hash>] Lista de drones fallidos recientemente
|
||||
def verificar_fallos_recientes
|
||||
sql = <<-SQL
|
||||
SELECT * FROM bitacoras.dron_logs
|
||||
WHERE estado = 'failed'
|
||||
AND completed_at > NOW() - INTERVAL '60 minutes'
|
||||
ORDER BY completed_at DESC
|
||||
SQL
|
||||
|
||||
require_relative '../../db/core/bitacora_db'
|
||||
BitacorasDB::BitacoraDB.with_connection { |db| db.execute(sql).to_a }
|
||||
def sql_fallos_recientes
|
||||
"SELECT * FROM bitacoras.dron_logs WHERE estado = 'failed' AND completed_at > NOW() - INTERVAL '60 minutes' ORDER BY completed_at DESC"
|
||||
end
|
||||
|
||||
# Verificar drones running demasiado antiguos (>1 hora)
|
||||
#
|
||||
# @return [Array<Hash>] Lista de drones antiguos
|
||||
def verificar_running_antiguos
|
||||
sql = <<-SQL
|
||||
SELECT * FROM bitacoras.dron_logs
|
||||
WHERE estado = 'running'
|
||||
AND started_at < NOW() - INTERVAL '1 hour'
|
||||
ORDER BY started_at ASC
|
||||
SQL
|
||||
|
||||
require_relative '../../db/core/bitacora_db'
|
||||
BitacorasDB::BitacoraDB.with_connection { |db| db.execute(sql).to_a }
|
||||
def sql_running_antiguos
|
||||
"SELECT * FROM bitacoras.dron_logs WHERE estado = 'running' AND started_at < NOW() - INTERVAL '1 hour' ORDER BY started_at ASC"
|
||||
end
|
||||
|
||||
# Registrar avance de incidente en dron_avances
|
||||
#
|
||||
# @param dron_id [String] ID del dron
|
||||
# @param descripcion [String] Descripción del incidente
|
||||
def registrar_avance_incidente(dron_id, descripcion)
|
||||
require_relative '../../db/core/bitacora_db'
|
||||
|
||||
sql = <<-SQL
|
||||
INSERT INTO bitacoras.dron_avances (dron_id, paso, descripcion, estado)
|
||||
VALUES ($1, -1, $2, 'failed')
|
||||
RETURNING *
|
||||
SQL
|
||||
|
||||
BitacorasDB::BitacoraDB.with_connection { |db| db.execute(sql, [dron_id, descripcion]).to_a }
|
||||
def sql_activos
|
||||
"SELECT * FROM bitacoras.dron_logs WHERE estado IN ('running', 'pending') ORDER BY started_at DESC"
|
||||
end
|
||||
|
||||
def registrar_avance(dron_id, descripcion)
|
||||
db_exec("INSERT INTO bitacoras.dron_avances (dron_id, paso, descripcion, estado) VALUES ($1, -1, $2, 'failed')", [dron_id, descripcion])
|
||||
end
|
||||
|
||||
# Actualizar evento resumen en bitácora (visible en web)
|
||||
#
|
||||
# @param flujo_id [String] ID del flujo
|
||||
# @param estado [String] Estado consolidado
|
||||
# @param count [Integer] Cantidad de drones
|
||||
def actualizar_evento_resumen(flujo_id, estado, count)
|
||||
require_relative '../../db/core/bitacora_db'
|
||||
|
||||
estado_icono = case estado
|
||||
when 'completed' then '✅'
|
||||
when 'failed' then '❌'
|
||||
else '⏳'
|
||||
end
|
||||
|
||||
estado_icono = case estado when 'completed' then '✅' when 'failed' then '❌' else '⏳' end
|
||||
descripcion = "🛸 Flujo #{flujo_id}: #{count} drones - #{estado_icono}"
|
||||
|
||||
# Buscar evento existente por flujo_id en metadata
|
||||
sql = <<-SQL
|
||||
SELECT id FROM bitacoras.events
|
||||
WHERE metadata->>'flujo_id' = $1
|
||||
SQL
|
||||
|
||||
resultado = BitacorasDB::BitacoraDB.with_connection { |db| db.execute(sql, [flujo_id]).to_a }
|
||||
resultado = db_query("SELECT id FROM bitacoras.events WHERE metadata->>'flujo_id' = $1", [flujo_id])
|
||||
|
||||
if resultado.empty?
|
||||
# Crear nuevo evento resumen
|
||||
BitacorasDB::BitacoraDB.crear_evento(
|
||||
nodo_id: 1,
|
||||
descripcion: descripcion,
|
||||
estado: estado_icono,
|
||||
metadata: { flujo_id: flujo_id, drones_count: count }.to_json
|
||||
)
|
||||
require_relative '../../db/core/bitacora_db'
|
||||
BitacorasDB::BitacoraDB.crear_evento(nodo_id: 1, descripcion: descripcion, estado: estado_icono, metadata: { flujo_id: flujo_id, drones_count: count }.to_json)
|
||||
else
|
||||
# Actualizar evento existente
|
||||
evento_id = resultado.first['id']
|
||||
BitacorasDB::BitacoraDB.actualizar_evento(evento_id, descripcion: descripcion, estado: estado_icono)
|
||||
BitacorasDB::BitacoraDB.actualizar_evento(resultado.first['id'], descripcion: descripcion, estado: estado_icono)
|
||||
end
|
||||
rescue StandardError => e
|
||||
@logger.warn("⚠️ No se pudo actualizar evento resumen: #{e.message}")
|
||||
logger.warn("⚠️ No se pudo actualizar evento resumen: #{e.message}")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
Reference in New Issue
Block a user