652 lines
25 KiB
Ruby
652 lines
25 KiB
Ruby
# frozen_string_literal: true
|
||
|
||
require 'optparse'
|
||
require 'fileutils'
|
||
require 'date'
|
||
require_relative '../core/configurador'
|
||
|
||
module ADN
|
||
class SubcomandoBackup
|
||
def initialize(args, logger)
|
||
@args = args
|
||
@logger = logger
|
||
|
||
# Cargar valores predeterminados desde config.yml
|
||
defaults = Configurador.obtener('backup.defaults') || {}
|
||
@opciones = {
|
||
modo: defaults['modo'] || 'stop',
|
||
storage: defaults['storage'] || 'local',
|
||
compress: defaults['compress'] || 'gzip',
|
||
retencion: defaults['retencion_dias'] || 6
|
||
}
|
||
end
|
||
|
||
def ejecutar
|
||
parser = OptionParser.new do |opts|
|
||
opts.banner = "Uso: ./tools/adn/run backup <nodo|estados> [OPCIONES]"
|
||
opts.separator ""
|
||
opts.separator "Ejecuta un backup remoto o consulta el estado actual."
|
||
opts.separator ""
|
||
opts.separator "Acciones:"
|
||
opts.separator " <nodo> Ejecutar backup del nodo especificado"
|
||
opts.separator " estados Ver estado actual de los backups en Proxmox"
|
||
opts.separator " sanear Limpiar backups antiguos según retención"
|
||
opts.separator " predeterminar Configurar valores por defecto"
|
||
opts.separator ""
|
||
opts.separator "Opciones:"
|
||
opts.on("--mode MODO", "Modo de backup (stop, snapshot, suspend. Default: #{@opciones[:modo]})") do |m|
|
||
@opciones[:modo] = m
|
||
end
|
||
opts.on("--storage STORAGE", "Nombre del storage en Proxmox (Default: #{@opciones[:storage]})") do |s|
|
||
@opciones[:storage] = s
|
||
end
|
||
opts.on("-h", "--help", "Mostrar esta ayuda") do
|
||
puts opts
|
||
exit
|
||
end
|
||
end
|
||
|
||
begin
|
||
parser.parse!(@args)
|
||
rescue OptionParser::InvalidOption => e
|
||
@logger.error("Opción inválida: #{e.message}")
|
||
puts parser
|
||
exit 1
|
||
end
|
||
|
||
if @args.empty?
|
||
@logger.error("Se requiere nombre de nodo o acción")
|
||
puts parser
|
||
exit 1
|
||
end
|
||
|
||
case @args[0]
|
||
when 'predeterminar'
|
||
comando_predeterminar(@args[1..-1])
|
||
when 'estados', 'estado'
|
||
comando_estados
|
||
when 'sanear'
|
||
comando_sanear
|
||
else
|
||
ejecutar_backup(@args[0])
|
||
end
|
||
end
|
||
|
||
private
|
||
|
||
def ejecutar_backup(nodo)
|
||
@logger.info("Iniciando flujo ADN-Backup para nodo: #{nodo}")
|
||
|
||
# 1. Obtener contexto del nodo
|
||
datos = obtener_contexto_nodo(nodo)
|
||
unless datos
|
||
@logger.error("No se pudo determinar el contexto técnico para #{nodo}")
|
||
exit 1
|
||
end
|
||
|
||
@logger.info("Contexto validado: VM #{datos[:vmid]} en #{datos[:host_name]} (#{datos[:host_ip]})")
|
||
|
||
# 2. Registrar inicio en bitácora (Bitácora-First)
|
||
registrar_inicio_bitacora(nodo, datos)
|
||
|
||
# 3. Ejecución segura vía ns8-candados
|
||
@logger.info("Solicitando autorización y ejecutando backup remoto...")
|
||
|
||
comando_vzdump = "vzdump #{datos[:vmid]} --mode #{@opciones[:modo]} --storage #{@opciones[:storage]} --compress #{@opciones[:compress]}"
|
||
cmd_seguro = "sshpass -e ssh -o StrictHostKeyChecking=no root@#{datos[:host_ip]} \"#{comando_vzdump}\""
|
||
|
||
# Usamos el binario de ruby y la ruta absoluta para ns8-candados
|
||
candados_path = File.join(ADN::PROJECT_ROOT, 'tools', 'ns8-candados', 'ns8-candados.rb')
|
||
|
||
# Ejecutar con ns8-candados run
|
||
# Ejecutar con ns8-candados autorizando primero
|
||
system("ruby #{candados_path} authorize > /dev/null 2>&1")
|
||
|
||
task_id = nil
|
||
full_output = ""
|
||
|
||
# Usar popen para leer la salida en tiempo real
|
||
@logger.info("Conectando y monitoreando salida de Proxmox...")
|
||
|
||
IO.popen("ruby #{candados_path} run admindasu SSHPASS '#{cmd_seguro}' 2>&1") do |pf|
|
||
pf.each_line do |line|
|
||
# Imprimir flujo para el usuario
|
||
puts " #{Color::DIM}#{line.strip}#{Color::RESET}"
|
||
full_output += line
|
||
|
||
# Si detectamos el Task ID al inicio, lo registramos de inmediato
|
||
if task_id.nil? && match = line.match(/started backup task '([^']+)'/)
|
||
task_id = match[1]
|
||
@logger.info("Task ID detectado: #{task_id}. Registrando en bitácora...")
|
||
registrar_task_id_bitacora(nodo, task_id)
|
||
end
|
||
end
|
||
end
|
||
|
||
success = $?.success?
|
||
|
||
# 4. Finalizar y cerrar
|
||
system("ruby #{candados_path} cerrar > /dev/null 2>&1")
|
||
|
||
if success
|
||
@logger.exito("Backup de #{nodo} completado exitosamente.")
|
||
registrar_fin_bitacora(nodo, true, task_id)
|
||
else
|
||
@logger.error("La ejecución del backup falló.")
|
||
registrar_fin_bitacora(nodo, false, task_id)
|
||
exit 1
|
||
end
|
||
end
|
||
|
||
def obtener_contexto_nodo(nombre_nodo)
|
||
ruta_nodo = File.join(ADN::NODOS_DIR, "#{nombre_nodo}.md")
|
||
unless File.exist?(ruta_nodo)
|
||
@logger.error("No existe el archivo de nodo: #{ruta_nodo}")
|
||
@logger.sugerencia("./tools/adn/run db nodo:crear --nombre #{nombre_nodo} --tipo servidor --ip 0.0.0.0 --desc \"Servidor a configurar\"")
|
||
return nil
|
||
end
|
||
|
||
contenido = File.read(ruta_nodo)
|
||
vmid = contenido.match(/(?:VM ID|vmid|VMID)\*\*?:?\s*`?(\d+)`?/i)&.[](1)
|
||
host_name = contenido.match(/(?:Padre\/Host|Host Anfitrión|Anfitrión|Host)\*\*:?\s*`([^`]+)`/i)&.[](1)
|
||
|
||
unless vmid && host_name
|
||
@logger.error("Contexto incompleto en #{nombre_nodo}.md: VMID=#{vmid}, Host=#{host_name}")
|
||
@logger.sugerencia([
|
||
"Asegurate de que #{nombre_nodo}.md tenga las siguientes líneas:",
|
||
"- **Padre/Host**: `srv-proxmox-ejemplo`",
|
||
"- **VMID**: `1xx`"
|
||
])
|
||
return nil
|
||
end
|
||
|
||
# Buscar IP del host
|
||
ruta_host = File.join(ADN::NODOS_DIR, "#{host_name}.md")
|
||
host_ip = nil
|
||
if File.exist?(ruta_host)
|
||
c_host = File.read(ruta_host)
|
||
host_ip ||= c_host.match(/\|\s*IP[^\|]*\|\s*`([^`]+)`\s*\|/)&.[](1)
|
||
host_ip ||= c_host.match(/IP\*\*:?\s*`([^`]+)`/)&.[](1)
|
||
host_ip ||= c_host.match(/IP:\s*([\d\.]+)/)&.[](1)
|
||
end
|
||
|
||
unless host_ip
|
||
@logger.error("No se encontró IP para el host #{host_name}")
|
||
@logger.sugerencia([
|
||
"Verificá que el archivo #{host_name}.md exista.",
|
||
"Si no existe, crealo con: ./tools/adn/run db nodo:crear --nombre #{host_name} --tipo servidor --ip DIRECCION_IP",
|
||
"Asegurate de que incluya: **IP**: `DIRECCION_IP`"
|
||
])
|
||
return nil
|
||
end
|
||
|
||
host_ip = host_ip.split('/')[0] if host_ip.include?('/')
|
||
{ vmid: vmid, host_name: host_name, host_ip: host_ip }
|
||
end
|
||
|
||
def registrar_inicio_bitacora(nodo, datos)
|
||
require_relative '../db/core/bitacora_db'
|
||
|
||
BitacorasDB::BitacoraDB.with_connection do |db|
|
||
# Asegurar bitácora
|
||
bitacora = db.find_bitacora_by_fecha(Date.today)
|
||
bitacora ||= db.create_bitacora(fecha: Date.today)
|
||
|
||
# Buscar nodo en DB
|
||
nodo_db = db.find_nodo_by_nombre(nodo)
|
||
|
||
hora = Time.now.strftime('%H:%M')
|
||
entrada = db.create_entrada(
|
||
inicio: hora,
|
||
descripcion: "Inicio de backup remoto vía SSH para VM #{datos[:vmid]} en #{datos[:host_name]}.",
|
||
estado: '⏳',
|
||
modo: 'R',
|
||
bitacora_id: bitacora['id'],
|
||
nodo_id: nodo_db ? nodo_db['id'] : nil
|
||
)
|
||
|
||
# Guardar ID para actualizar después
|
||
@backup_entrada_id = entrada['id'].to_i
|
||
@backup_bitacora_id = bitacora['id'].to_i
|
||
end
|
||
rescue => e
|
||
@logger.error("Error registrando inicio en DB: #{e.message}")
|
||
end
|
||
|
||
def registrar_task_id_bitacora(nodo, task_id)
|
||
return unless @backup_entrada_id
|
||
|
||
require_relative '../db/core/bitacora_db'
|
||
|
||
BitacorasDB::BitacoraDB.with_connection do |db|
|
||
db.update_entrada(@backup_entrada_id, {
|
||
descripcion: "[task:#{task_id[0..7]}] Backup remoto en ejecución."
|
||
})
|
||
end
|
||
rescue => e
|
||
@logger.error("Error registrando task_id en DB: #{e.message}")
|
||
end
|
||
|
||
def registrar_fin_bitacora(nodo, exito, task_id = nil)
|
||
return unless @backup_entrada_id
|
||
|
||
require_relative '../db/core/bitacora_db'
|
||
require_relative '../db/exporters/md_exporter'
|
||
|
||
hora_fin = Time.now.strftime('%H:%M')
|
||
estado = exito ? '✅' : '⚠️'
|
||
desc = exito ? 'Backup completado exitosamente.' : 'Fallo en la ejecución del backup.'
|
||
desc = "[task:#{task_id[0..7]}] #{desc}" if task_id
|
||
|
||
BitacorasDB::BitacoraDB.with_connection do |db|
|
||
db.update_entrada(@backup_entrada_id, {
|
||
fin: hora_fin,
|
||
descripcion: desc,
|
||
estado: estado
|
||
})
|
||
end
|
||
rescue => e
|
||
@logger.error("Error registrando fin en DB: #{e.message}")
|
||
end
|
||
|
||
|
||
def comando_predeterminar(args)
|
||
if args.length < 2
|
||
puts "#{Color::YELLOW}Uso: adn backup predeterminar <parametro> <valor>#{Color::RESET}"
|
||
puts "Ej: adn backup predeterminar modo snapshot"
|
||
exit 1
|
||
end
|
||
|
||
param = args[0].downcase
|
||
valor = args[1]
|
||
param = 'modo' if param == 'mode'
|
||
param = 'retencion_dias' if param == 'edad'
|
||
|
||
unless ['modo', 'storage', 'compress', 'retencion_dias'].include?(param)
|
||
@logger.error("Parámetro no predeterminable: #{param}")
|
||
exit 1
|
||
end
|
||
|
||
Configurador.establecer("backup.defaults.#{param}", valor)
|
||
@logger.exito("Valor predeterminado establecido: backup.#{param} = #{valor}")
|
||
puts "#{Color::GREEN}✓ Se ha predeterminado el #{param} a '#{valor}' para futuros backups.#{Color::RESET}"
|
||
end
|
||
|
||
def comando_estados
|
||
@logger.info("Consultando estado de backups en cluster Proxmox")
|
||
|
||
# Lista de hosts a consultar
|
||
hosts = [
|
||
{ nombre: 'srv-pmox1', ip: '10.0.10.201' },
|
||
{ nombre: 'srv-dasu', ip: '10.0.10.205' }
|
||
]
|
||
|
||
puts "\n#{Color::BOLD}🔍 Estado de Backups en Tiempo Real (Proxmox)#{Color::RESET}"
|
||
puts "─" * 60
|
||
|
||
candados_path = File.join(ADN::PROJECT_ROOT, 'tools', 'ns8-candados', 'ns8-candados.rb')
|
||
# Asegurar autorización general para el lote
|
||
system("ruby #{candados_path} authorize > /dev/null 2>&1")
|
||
|
||
all_tasks_accumulated = []
|
||
|
||
hosts.each do |h|
|
||
print "📡 Conectando a #{h[:nombre]} (#{h[:ip]})... "
|
||
|
||
# Intentamos obtener tareas
|
||
cmd = "/usr/bin/pvesh get /cluster/tasks --output-format json"
|
||
cmd_seguro = "ssh -o StrictHostKeyChecking=no root@#{h[:ip]} '#{cmd}'"
|
||
|
||
# Ejecutamos vía candados run
|
||
output = `ruby #{candados_path} run admindasu SSHPASS '#{cmd_seguro}' 2>&1`
|
||
|
||
if output.include?('[')
|
||
begin
|
||
# Extraer el JSON
|
||
json_str = output[output.index('[')..output.rindex(']')]
|
||
tasks_host = JSON.parse(json_str)
|
||
all_tasks_accumulated.concat(tasks_host)
|
||
|
||
# Filtrar tareas vzdump activas de ESTE host para mostrar
|
||
tasks_activas = tasks_host.select { |t| t['type'] == 'vzdump' && t['endtime'].nil? }
|
||
|
||
puts "#{Color::GREEN}OK#{Color::RESET}"
|
||
if tasks_activas.empty?
|
||
puts " #{Color::DIM}Sin tareas de backup activas en este host.#{Color::RESET}"
|
||
else
|
||
tasks_activas.each do |t|
|
||
msg = t['status'] || 'ejecutando'
|
||
print " ▶ #{Color::CYAN}#{t['id']}#{Color::RESET} "
|
||
puts "[#{msg}] (Iniciado: #{Time.at(t['starttime']).strftime('%H:%M:%S')})"
|
||
end
|
||
end
|
||
rescue => e
|
||
puts "#{Color::YELLOW}JSON ERROR#{Color::RESET}"
|
||
puts " #{Color::DIM}Error parseando respuesta: #{e.message}#{Color::RESET}"
|
||
end
|
||
else
|
||
puts "#{Color::RED}ERROR#{Color::RESET}"
|
||
if output.include?('Permission denied')
|
||
puts " #{Color::DIM}Error de permisos/candado puesto.#{Color::RESET}"
|
||
else
|
||
puts " #{Color::DIM}No se detectaron tareas activas o el host no respondió.#{Color::RESET}"
|
||
end
|
||
end
|
||
end
|
||
|
||
system("ruby #{candados_path} cerrar > /dev/null 2>&1")
|
||
|
||
# 2. Sincronización Automática: Auto-reconciliación y Migración
|
||
fecha_hoy = Date.today.iso8601
|
||
archivo_md = File.join(ADN::BITACORAS_DIR, "#{fecha_hoy}.md")
|
||
|
||
if File.exist?(archivo_md)
|
||
print "#{Color::DIM}🔄 Reconciliando tareas pendientes... #{Color::RESET}"
|
||
auto_reconciliar_bitacora(all_tasks_accumulated)
|
||
puts "#{Color::DIM}OK#{Color::RESET}"
|
||
|
||
print "#{Color::DIM}🔄 Sincronizando bitácora digital... #{Color::RESET}"
|
||
# Ejecutamos la migración de forma silenciosa
|
||
cmd_migrar = "#{File.join(ADN::PROJECT_ROOT, 'tools/adn/run')} db migrar:md #{fecha_hoy} --sobrescribir > /dev/null 2>&1"
|
||
system(cmd_migrar)
|
||
puts "#{Color::DIM}OK#{Color::RESET}"
|
||
end
|
||
|
||
# 3. Historial de la DB (Sincronizado)
|
||
puts "\n#{Color::BOLD}📅 Historial de hoy (Sincronizado)#{Color::RESET}"
|
||
puts "─" * 60
|
||
|
||
db_tool = "./tools/adn/run"
|
||
# Buscamos por "backup" o "BKP"
|
||
system("#{db_tool} db evento:listar --desde '#{fecha_hoy}' --buscar 'ackup'")
|
||
|
||
puts "\n#{Color::DIM}Para historial completo use: ./tools/adn/run db evento:listar --desde '#{fecha_hoy}'#{Color::RESET}"
|
||
end
|
||
|
||
def comando_sanear
|
||
dias = @opciones[:retencion].to_i
|
||
storage = @opciones[:storage]
|
||
@logger.info("Iniciando saneamiento de backups (Retención: #{dias} días en '#{storage}')")
|
||
|
||
# 1. Obtener lista de VMs directamente de Proxmox para nombres precisos
|
||
host = { nombre: 'srv-pmox1', ip: '10.0.10.201' }
|
||
candados_path = File.join(ADN::PROJECT_ROOT, 'tools', 'ns8-candados', 'ns8-candados.rb')
|
||
system("ruby #{candados_path} authorize > /dev/null 2>&1")
|
||
|
||
@logger.info("Consultando inventario de VMs en Proxmox...")
|
||
cmd_vms = "/usr/bin/pvesh get /cluster/resources --type vm --output-format json"
|
||
output_vms = `ruby #{candados_path} run admindasu SSHPASS 'ssh -o StrictHostKeyChecking=no root@#{host[:ip]} "#{cmd_vms}"' 2>/dev/null`
|
||
|
||
vmid_map = cargar_mapa_vmid_nodos # Cargar local primero
|
||
|
||
begin
|
||
if output_vms.include?('[')
|
||
json_vms = output_vms[output_vms.index('[')..output_vms.rindex(']')]
|
||
JSON.parse(json_vms).each do |vm|
|
||
id = vm['vmid'].to_s
|
||
# Priorizar nombre de Proxmox si el local no existe o es genérico
|
||
vmid_map[id] = vm['name'] if vm['name'] && (!vmid_map[id] || vmid_map[id] == id)
|
||
end
|
||
end
|
||
rescue => e
|
||
@logger.advertencia("No se pudo completar el mapa de VMs desde Proxmox: #{e.message}")
|
||
end
|
||
|
||
# 2. Obtener lista de archivos en el storage
|
||
# Intentar con varios hosts del cluster por si uno está caído
|
||
ruta_dump = "/mnt/pve/#{storage}/dump"
|
||
@logger.info("Listando archivos en #{storage}...")
|
||
|
||
output_ls = ""
|
||
[ '10.0.10.201', '10.0.10.202', '10.0.10.203' ].each do |ip|
|
||
cmd_ls = "ls -1 --full-time #{ruta_dump}/vzdump-*"
|
||
res = `ruby #{candados_path} run admindasu SSHPASS 'ssh -o StrictHostKeyChecking=no root@#{ip} "#{cmd_ls}"' 2>&1`
|
||
unless res.include?('No such file') || res.include?('Connection refused')
|
||
output_ls = res
|
||
break
|
||
end
|
||
end
|
||
|
||
if output_ls.empty? || output_ls.include?('No such file')
|
||
@logger.error("No se encontró la ruta de backups en ningún host: #{ruta_dump}")
|
||
system("ruby #{candados_path} cerrar > /dev/null 2>&1")
|
||
exit 1
|
||
end
|
||
|
||
# 3. Filtrar archivos por antigüedad
|
||
ahora = Time.now
|
||
limite = ahora - (dias * 24 * 60 * 60)
|
||
|
||
backups_agrupados = {}
|
||
|
||
output_ls.split("\n").each do |linea|
|
||
next if linea.include?('OPTIONS]') || linea.empty?
|
||
|
||
partes = linea.split(/\s+/)
|
||
next if partes.length < 9
|
||
|
||
fecha_str = "#{partes[5]} #{partes[6]}"
|
||
ruta_archivo = partes[8..-1].join(' ')
|
||
nombre = File.basename(ruta_archivo)
|
||
|
||
fingerprint = nombre.sub(/\.(log|vma\.zst|tar\.zst|vma\.zst\.notes|tar\.zst\.notes)$/, '')
|
||
|
||
begin
|
||
mtime = Time.parse(fecha_str)
|
||
if mtime < limite
|
||
vmid = fingerprint.match(/vzdump-(?:qemu|lxc)-(\d+)-/)&.[](1)
|
||
nodo_humano = vmid ? vmid_map[vmid] : "ID:#{vmid}"
|
||
|
||
backups_agrupados[fingerprint] ||= {
|
||
fingerprint: fingerprint,
|
||
fecha: mtime,
|
||
vmid: vmid,
|
||
nodo: nodo_humano,
|
||
archivos: []
|
||
}
|
||
backups_agrupados[fingerprint][:archivos] << { ruta: ruta_archivo, nombre: nombre }
|
||
end
|
||
rescue
|
||
next
|
||
end
|
||
end
|
||
|
||
if backups_agrupados.empty?
|
||
puts "#{Color::GREEN}✓ No se encontraron backups mayores a #{dias} días en #{storage}.#{Color::RESET}"
|
||
system("ruby #{candados_path} cerrar > /dev/null 2>&1")
|
||
return
|
||
end
|
||
|
||
# Convertir a array ordenado por fecha
|
||
lista_final = backups_agrupados.values.sort_by { |b| b[:fecha] }
|
||
|
||
# 4. Mostrar lista con nuevo formato solicitado
|
||
puts "\n#{Color::BOLD}🗑️ Propuesta de Saneamiento de Backups#{Color::RESET} (Retención: #{dias} días)"
|
||
puts "─" * 90
|
||
puts "#{Color::BOLD}ID Nombre_VMID_Fecha Componentes detectados#{Color::RESET}"
|
||
puts "─" * 90
|
||
|
||
lista_final.each_with_index do |b, idx|
|
||
num = (idx + 1).to_s.rjust(2, '0')
|
||
fecha_corta = b[:fecha].strftime('%Y-%m-%d')
|
||
|
||
# Formato solicitado: XX - VMNombre_VMid_Fecha
|
||
entrada_label = "#{num} - #{Color::BOLD}#{Color::CYAN}#{b[:nodo]}_#{b[:vmid]}_#{fecha_corta}#{Color::RESET}".ljust(60)
|
||
|
||
tipos = b[:archivos].map { |a| a[:nombre].split('.').last }.uniq.join(", ")
|
||
total_archivos = "(#{b[:archivos].length} arch.)"
|
||
|
||
puts "#{entrada_label} #{Color::DIM}#{tipos.ljust(15)} #{total_archivos}#{Color::RESET}"
|
||
end
|
||
puts "─" * 90
|
||
puts "Total detectado: #{lista_final.length} backups completos (#{backups_agrupados.values.sum { |b| b[:archivos].length }} archivos en total)."
|
||
|
||
puts "\n#{Color::BOLD}Acciones:#{Color::RESET}"
|
||
puts " • Escriba #{Color::BOLD}'S'#{Color::RESET} para borrar TODOS los backups listados."
|
||
puts " • Escriba #{Color::BOLD}excluir 1, 3-5#{Color::RESET} para conservar backups específicos."
|
||
puts " • Escriba #{Color::BOLD}'N'#{Color::RESET} para cancelar."
|
||
|
||
print "\n👉 #{Color::BOLD}¿Qué deseas hacer?#{Color::RESET}: "
|
||
input = STDIN.gets.chomp.strip.downcase
|
||
|
||
if input == 'n' || input == ''
|
||
puts "#{Color::YELLOW}Operación cancelada.#{Color::RESET}"
|
||
system("ruby #{candados_path} cerrar > /dev/null 2>&1")
|
||
exit
|
||
end
|
||
|
||
# Procesar exclusiones
|
||
seleccionados = lista_final.dup
|
||
if input.start_with?('excluir')
|
||
exclusiones = []
|
||
patron = input.sub('excluir', '').strip
|
||
|
||
patron.split(/[\s,]+/).each do |p|
|
||
next if p.empty?
|
||
if p.include?('-')
|
||
inicio, fin = p.split('-').map(&:to_i)
|
||
exclusiones.concat((inicio..fin).to_a)
|
||
else
|
||
exclusiones << p.to_i
|
||
end
|
||
end
|
||
|
||
seleccionados = lista_final.reject.with_index { |_, idx| exclusiones.include?(idx + 1) }
|
||
|
||
if seleccionados.empty?
|
||
puts "#{Color::YELLOW}Has excluido todos los backups. Nada que hacer.#{Color::RESET}"
|
||
system("ruby #{candados_path} cerrar > /dev/null 2>&1")
|
||
exit
|
||
end
|
||
|
||
puts "#{Color::CYAN}ℹ Has excluido #{lista_final.length - seleccionados.length} backups. Procediendo con #{seleccionados.length}...#{Color::RESET}"
|
||
elsif input != 's'
|
||
puts "#{Color::RED}Opción no válida. Cancelando.#{Color::RESET}"
|
||
system("ruby #{candados_path} cerrar > /dev/null 2>&1")
|
||
exit
|
||
end
|
||
|
||
# 5. Borrado final
|
||
total_a_borrar = seleccionados.sum { |b| b[:archivos].length }
|
||
puts "\n#{Color::BOLD}🗑️ Borrando #{total_a_borrar} archivos asociados a #{seleccionados.length} backups...#{Color::RESET}"
|
||
|
||
seleccionados.each_with_index do |b, i|
|
||
puts "\n #{Color::BOLD}[#{i+1}/#{seleccionados.length}] Procesando #{b[:nodo]}...#{Color::RESET}"
|
||
b[:archivos].each do |a|
|
||
print " Eliminando #{a[:nombre]}... "
|
||
del_cmd = "rm -f '#{a[:ruta]}'"
|
||
del_seguro = "ssh -o StrictHostKeyChecking=no root@#{host[:ip]} '#{del_cmd}'"
|
||
system("ruby #{candados_path} run admindasu SSHPASS '#{del_seguro}' > /dev/null 2>&1")
|
||
puts "#{Color::GREEN}OK#{Color::RESET}"
|
||
end
|
||
end
|
||
|
||
@logger.exito("Saneamiento completado. Se limpiaron #{seleccionados.length} sets de backup.")
|
||
system("ruby #{candados_path} cerrar > /dev/null 2>&1")
|
||
end
|
||
|
||
def cargar_mapa_vmid_nodos
|
||
mapa = {}
|
||
Dir.glob(File.join(ADN::NODOS_DIR, "*.md")).each do |f|
|
||
next if File.directory?(f)
|
||
begin
|
||
contenido = File.read(f)
|
||
# Buscar nombre en h1 o metadatos
|
||
nombre = File.basename(f, ".md")
|
||
vmid = contenido.match(/(?:VM ID|vmid|VMID)\*\*?:?\s*`?(\d+)`?/i)&.[](1)
|
||
mapa[vmid.to_s] = nombre if vmid
|
||
rescue
|
||
next
|
||
end
|
||
end
|
||
mapa
|
||
end
|
||
|
||
def auto_reconciliar_bitacora(all_tasks)
|
||
fecha = Date.today.iso8601
|
||
ruta = File.join(ADN::BITACORAS_DIR, "#{fecha}.md")
|
||
return unless File.exist?(ruta)
|
||
|
||
contenido = File.read(ruta)
|
||
vmid_map = cargar_mapa_vmid_nodos
|
||
|
||
# Encontrar todas las filas que tienen un reloj de arena
|
||
lineas = contenido.lines
|
||
nodo_actual = nil
|
||
|
||
lineas.each do |linea|
|
||
if linea.start_with?('### srvv-')
|
||
nodo_actual = linea.sub('### ', '').strip
|
||
next
|
||
end
|
||
|
||
# Si es una fila de tabla en progreso (⏳)
|
||
if nodo_actual && linea.include?('|') && linea.include?('⏳')
|
||
match_hora = linea.match(/\|\s*(\d{2}:\d{2})\s*\|/)
|
||
next unless match_hora
|
||
|
||
hora_inicio_str = match_hora[1]
|
||
vmid = vmid_map.key(nodo_actual)
|
||
next unless vmid
|
||
|
||
# Buscar última tarea vzdump de este VMID que ya terminó
|
||
hora_inicio_t = Time.parse("#{fecha} #{hora_inicio_str}") rescue nil
|
||
|
||
tarea = all_tasks.select { |t|
|
||
vmid_task = (t['vmid'] || t['id']).to_s
|
||
t['type'] == 'vzdump' &&
|
||
vmid_task == vmid &&
|
||
!t['endtime'].nil? &&
|
||
(hora_inicio_t ? Time.at(t['starttime']) >= (hora_inicio_t - 3600) : true)
|
||
}.max_by { |t| t['endtime'] }
|
||
|
||
if tarea
|
||
exito = (tarea['status'] == 'OK')
|
||
hora_fin = Time.at(tarea['endtime']).strftime('%H:%M')
|
||
|
||
@logger.info("Auto-cerrando backup de #{nodo_actual} (Task ID: #{tarea['id']})")
|
||
cerrar_entrada_especifica(nodo_actual, hora_inicio_str, exito, tarea['id'], hora_fin)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
def cerrar_entrada_especifica(nodo, hora_ini, exito, task_id, hora_fin)
|
||
fecha = Date.today.iso8601
|
||
ruta = File.join(ADN::BITACORAS_DIR, "#{fecha}.md")
|
||
return unless File.exist?(ruta)
|
||
|
||
estado_ico = exito ? '✅' : '⚠️'
|
||
desc = exito ? 'Backup completado exitosamente.' : 'Fallo en la ejecución del backup.'
|
||
desc = "[task:#{task_id[0..7]}] #{desc}" if task_id
|
||
|
||
linea_nueva = "| #{hora_ini} | #{hora_fin} | #{desc} | R | #{estado_ico} |"
|
||
|
||
contenido = File.read(ruta)
|
||
# Buscamos la fila específica que coincida con el nodo Y la hora de inicio
|
||
# Capturamos el bloque del nodo para evitar errores si otros nodos tienen la misma hora
|
||
regex_seccion = /(### #{Regexp.escape(nodo)}.*?)(?=^###\s|<!--|\z)/m
|
||
seccion = contenido.match(regex_seccion)&.[](0)
|
||
unless seccion
|
||
return
|
||
end
|
||
|
||
# Regex para la fila exacta que tenga la hora de inicio Y un reloj ⏳ en la última columna
|
||
regex_fila = /\|\s*#{Regexp.escape(hora_ini)}\s*\|\s*\|\s*[^|]*\|\s*[^|]*\|\s*[^|]*⏳[^|]*\|/
|
||
|
||
if seccion.match?(regex_fila)
|
||
@logger.exito("Reconciliado: #{nodo} (#{hora_ini} -> #{hora_fin})")
|
||
nueva_seccion = seccion.sub(regex_fila, linea_nueva)
|
||
# Si ya no quedan ⏳ en esta sección, actualizamos su icono #### ⏳ -> ✅
|
||
# Buscamos cualquier reloj de arena que quede en la sección
|
||
unless nueva_seccion.include?('⏳')
|
||
nueva_seccion.gsub!(/#### [⏳⏳] - BKP-ADN/, "#### #{estado_ico} - BKP-ADN")
|
||
end
|
||
|
||
nuevo_contenido = contenido.gsub(seccion, nueva_seccion)
|
||
File.write(ruta, nuevo_contenido)
|
||
end
|
||
end
|
||
end
|
||
end
|