[A04.P006] Exportar backup en doble ubicación (fenix + share ns8)

Cambios realizados:

1. dasuten_exportar_srvv-fenix.rb:
   - Genera backup en disco local: E:\BK_SQL\sysdasuten\
   - Copia automáticamente a unidad de red X: (share srv-ns8)
   - Usa PowerShell para copiar al share mapeado
   - Verifica ambos destinos

2. dasuten_transferir_srvv-fenix-srv-ns8.rb:
   - Simplificado: ya no descarga desde fenix vía SMB
   - El backup ya está en /mnt/ns8Disco2/bkps-dasuten/
   - Copia local: share → /var/tmp/ (para rclone upload)

Flujo actualizado:
  1. SQL Server → E:\BK_SQL\sysdasuten\archivo.bak (local fenix)
  2. PowerShell → X:\archivo.bak (share srv-ns8)
  3. Transfer dron → /var/tmp/archivo.bak (para rclone)
  4. Upload dron → Google Drive

Requisito en srvv-fenix:
  net use X: \\10.0.10.8\bkps-dasuten /user:rmonla <password>

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Ricardo Monla
2026-04-14 19:44:13 -03:00
co-authored by Claude Opus 4.6
parent c6970f7d7a
commit 900457a778
2 changed files with 96 additions and 85 deletions
@@ -4,95 +4,66 @@
# ==========================================================
# adn/tools/cli/drones/dasuten_transferir_srvv-fenix-srv-ns8.rb
# ==========================================================
# Dron: Transferencia SMB desde srvv-fenix a srv-ns8
# Flujo: srvv-fenix (E:\BK_SQL\) → srv-ns8 (/var/tmp/)
# Usa: smbclient con credenciales de candados
# Dron: Preparar backup desde share de srv-ns8 para upload
# Flujo: /mnt/ns8Disco2/bkps-dasuten/ → /var/tmp/ (para rclone)
# Nota: El backup ya está en el share gracias al dron de export
# ==========================================================
require 'time'
require 'json'
require 'shellwords'
require 'pathname'
# Ruta por defecto (backup completo)
BACKUP_REMOTO_DEFAULT = "sysdasuten_compressed_ADN.bak"
BACKUP_LOCAL_DEFAULT = "/var/tmp/sysdasuten_compressed_ADN.bak"
require 'fileutils'
# Si existe output del dron anterior (export o export_dif), leer la ruta
EXPORT_OUTPUT_FILE = '/tmp/dron_export_output.json'
EXPORT_DIF_OUTPUT_FILE = '/tmp/dron_export_dif_output.json'
backup_remoto_name = BACKUP_REMOTO_DEFAULT
backup_local = BACKUP_LOCAL_DEFAULT
backup_ns8_unix = nil
backup_name = nil
if File.exist?(EXPORT_DIF_OUTPUT_FILE)
output = JSON.parse(File.read(EXPORT_DIF_OUTPUT_FILE))
if output['backup_ruta']
# Extraer solo el nombre del archivo de la ruta completa (E:\BK_SQL\archivo.bak)
# Usar split para manejar tanto backslashes como forward slashes
backup_remoto_name = output['backup_ruta'].split(/[\\\/]/).last
backup_local = "/var/tmp/#{backup_remoto_name}"
puts "[*] Dron: Transferencia SMB srvv-fenix → srv-ns8 (DIFERENCIAL)"
if output['backup_ruta_ns8'] || output['backup_ruta_ns8_unix']
backup_ns8_unix = output['backup_ruta_ns8_unix'] || output['backup_ruta_ns8']
backup_name = File.basename(backup_ns8_unix)
puts "[*] Dron: Preparar backup DIFERENCIAL para upload"
end
elsif File.exist?(EXPORT_OUTPUT_FILE)
output = JSON.parse(File.read(EXPORT_OUTPUT_FILE))
if output['backup_ruta']
backup_remoto_name = output['backup_ruta'].split(/[\\\/]/).last
backup_local = "/var/tmp/#{backup_remoto_name}"
puts "[*] Dron: Transferencia SMB srvv-fenix → srv-ns8 (COMPLETO)"
if output['backup_ruta_ns8'] || output['backup_ruta_ns8_unix']
backup_ns8_unix = output['backup_ruta_ns8_unix'] || output['backup_ruta_ns8']
backup_name = File.basename(backup_ns8_unix)
puts "[*] Dron: Preparar backup COMPLETO para upload"
end
end
BACKUP_SERVER = "//10.0.10.200/BK_SQL"
BACKUP_FILE = backup_remoto_name
unless backup_ns8_unix
puts "[!] Error: No se encontró ruta de backup en output de export"
exit 1
end
# Directorio de destino en srv-ns8 (compartido para backups DASUTEN)
# Nota: Este directorio está expuesto vía Samba para acceso desde srvv-fenix
BACKUP_NS8_DIR = "/mnt/ns8Disco2/bkps-dasuten"
BACKUP_LOCAL = "/var/tmp/#{backup_name}"
puts "[*] Dron: Transferencia SMB srvv-fenix → srv-ns8"
puts " Share: #{BACKUP_SERVER}"
puts " Archivo: #{BACKUP_FILE}"
puts " Destino: #{backup_local}"
puts " Share: #{BACKUP_NS8_DIR}"
puts " Archivo: #{backup_name}"
puts " Destino: #{BACKUP_LOCAL}"
begin
# Autorizar candados primero
system("ruby adn/tools/candados/candados.rb authorize >/dev/null 2>&1")
# Obtener credencial de candados
pass_cmd = "ruby adn/tools/candados/candados.rb get utnlarioja.intranet:monlaricardo 2>/dev/null"
pass = `#{pass_cmd}`.strip
if pass.empty?
puts "[!] No se pudo obtener credencial de candados"
exit 1
end
# Transferencia SMB
puts "\n[1/2] Descargando vía SMB..."
puts "\n[1/2] Copiando desde share a /var/tmp..."
start = Time.now
# Escapar contraseña para smbclient (evitar problemas con $ y caracteres especiales)
pass_escaped = pass.gsub('$', '\\$')
cmd_smb = "smbclient #{BACKUP_SERVER} -U \"monlaricardo%#{pass_escaped}\" -W UTNlarioja -c \"lcd /var/tmp; get #{BACKUP_FILE}\" 2>&1"
system(cmd_smb)
# Copiar archivo del share al directorio temporal para rclone
FileUtils.cp(backup_ns8_unix, BACKUP_LOCAL)
if $?.success?
duracion = (Time.now - start).round(2)
puts "[+] Transferencia completada en #{duracion} segundos"
else
puts "[!] Error en transferencia SMB (código: #{$?.exitstatus})"
exit 1
end
duracion = (Time.now - start).round(2)
puts "[+] Copia completada en #{duracion} segundos"
# Verificar archivo local
puts "\n[2/2] Verificando archivo..."
if File.exist?(backup_local)
tamaño_mb = (File.size(backup_local) / 1024.0 / 1024.0).round(2)
if File.exist?(BACKUP_LOCAL)
tamaño_mb = (File.size(BACKUP_LOCAL) / 1024.0 / 1024.0).round(2)
puts "[+] Archivo verificado: #{tamaño_mb} MB"
puts " Nota: Para copiar al share SMB, ejecutar desde srvv-fenix:"
puts " net use X: \\\\10.0.10.8\\bkps-dasuten /user:rmonla <password>"
puts " copy #{backup_local} X:\\#{backup_remoto_name}"
puts " Ruta: #{BACKUP_LOCAL}"
else
puts "[!] Archivo no encontrado en destino"
exit 1
@@ -101,20 +72,21 @@ begin
# Output para orquestador
resultado = {
paso: 'transfer_complete',
backup_local: backup_local,
backup_ns8_share: "#{BACKUP_NS8_DIR}/#{backup_remoto_name}",
backup_local: BACKUP_LOCAL,
backup_ns8_share: backup_ns8_unix,
nodo: 'srv-ns8',
duracion: duracion,
timestamp: Time.now.iso8601,
siguiente_paso: 'upload_drive'
}
puts "\nTransferencia completada"
puts "\nBackup listo para upload"
puts " Output: #{resultado.to_json}"
File.write('/tmp/dron_transfer_output.json', resultado.to_json)
rescue => e
puts "[!] Error fatal: #{e.message}"
puts e.backtrace.first(5).join("\n")
exit 1
end