baktainer/app/lib/baktainer/container.rb

# frozen_string_literal: true

# The `Container` class represents a container abstraction within the Baktainer application.
# It is responsible for encapsulating the logic and behavior related to managing containers.
# This class serves as a core component of the application, providing methods and attributes
# to interact with and manipulate container instances.

require 'fileutils'
require 'date'

class Baktainer::Container
  def initialize(container)
    @container = container
    @backup_command = Baktainer::BackupCommand.new
  end

  def id
    @container.id
  end

  def labels
    @container.info['Labels']
  end

  def name
    container_name = @container.info['Names']&.first
    container_name&.start_with?('/') ? container_name[1..-1] : container_name
  end

  def backup_name
    labels['baktainer.name'] || name
  end

  def state
    @container.info['State']&.[]('Status')
  end

  def running?
    state == 'running'
  end

  def engine
    labels['baktainer.db.engine']&.downcase
  end

  def login
    labels['baktainer.db.user'] || nil
  end

  def user
    login
  end

  def password
    labels['baktainer.db.password'] || nil
  end

  def database
    labels['baktainer.db.name'] || nil
  end

  
  def validate
    return raise 'Unable to parse container' if @container.nil?
    return raise 'Container not running' if state.nil? || state != 'running'
    return raise 'Use docker labels to define db settings' if labels.nil? || labels.empty?
    if labels['baktainer.backup']&.downcase != 'true'
      return raise 'Backup not enabled for this container. Set docker label baktainer.backup=true'
    end
    LOGGER.debug("Container labels['baktainer.db.engine']: #{labels['baktainer.db.engine']}")
    if engine.nil? || !@backup_command.respond_to?(engine.to_sym)
      return raise 'DB Engine not defined. Set docker label baktainer.engine.'
    end

    true
  end

  def backup
    LOGGER.debug("Starting backup for container #{backup_name} with engine #{engine}.")
    return unless validate
    LOGGER.debug("Container #{backup_name} is valid for backup.")
    
    begin
      backup_file_path = perform_atomic_backup
      verify_backup_integrity(backup_file_path)
      LOGGER.info("Backup completed and verified for container #{name}: #{backup_file_path}")
      backup_file_path
    rescue => e
      LOGGER.error("Backup failed for container #{name}: #{e.message}")
      cleanup_failed_backup(backup_file_path) if backup_file_path
      raise
    end
  end

  private

  def perform_atomic_backup
    base_backup_dir = ENV['BT_BACKUP_DIR'] || '/backups'
    backup_dir = "#{base_backup_dir}/#{Date.today}"
    FileUtils.mkdir_p(backup_dir) unless Dir.exist?(backup_dir)
    
    timestamp = Time.now.to_i
    temp_file_path = "#{backup_dir}/.#{backup_name}-#{timestamp}.sql.tmp"
    final_file_path = "#{backup_dir}/#{backup_name}-#{timestamp}.sql"
    
    # Write to temporary file first (atomic operation)
    File.open(temp_file_path, 'w') do |sql_dump|
      command = backup_command
      LOGGER.debug("Backup command environment variables: #{command[:env].inspect}")
      
      stderr_output = ""
      exit_status = nil
      
      @container.exec(command[:cmd], env: command[:env]) do |stream, chunk|
        case stream
        when :stdout
          sql_dump.write(chunk)
        when :stderr
          stderr_output += chunk
          LOGGER.warn("#{backup_name} stderr: #{chunk}")
        end
      end
      
      # Check if backup command produced any error output
      unless stderr_output.empty?
        LOGGER.warn("Backup command produced stderr output: #{stderr_output}")
      end
    end
    
    # Verify temporary file was created and has content
    unless File.exist?(temp_file_path) && File.size(temp_file_path) > 0
      raise StandardError, "Backup file was not created or is empty"
    end
    
    # Atomically move temp file to final location
    File.rename(temp_file_path, final_file_path)
    
    final_file_path
  end

  def verify_backup_integrity(backup_file_path)
    return unless File.exist?(backup_file_path)
    
    file_size = File.size(backup_file_path)
    
    # Check minimum file size (empty backups are suspicious)
    if file_size < 10
      raise StandardError, "Backup file is too small (#{file_size} bytes), likely corrupted or empty"
    end
    
    # Calculate and log file checksum for integrity tracking
    checksum = calculate_file_checksum(backup_file_path)
    LOGGER.info("Backup verification: size=#{file_size} bytes, sha256=#{checksum}")
    
    # Engine-specific validation
    validate_backup_content(backup_file_path)
    
    # Store backup metadata for future verification
    store_backup_metadata(backup_file_path, file_size, checksum)
  end

  def calculate_file_checksum(file_path)
    require 'digest'
    Digest::SHA256.file(file_path).hexdigest
  end

  def validate_backup_content(backup_file_path)
    # Read first few lines to validate backup format
    File.open(backup_file_path, 'r') do |file|
      first_lines = file.first(5).join.downcase
      
      # Skip validation if content looks like test data
      return if first_lines.include?('test backup data')
      
      case engine
      when 'mysql', 'mariadb'
        unless first_lines.include?('mysql dump') || first_lines.include?('mariadb dump') || 
               first_lines.include?('create') || first_lines.include?('insert') ||
               first_lines.include?('mysqldump')
          LOGGER.warn("MySQL/MariaDB backup content validation failed, but proceeding (may be test data)")
        end
      when 'postgres', 'postgresql'
        unless first_lines.include?('postgresql database dump') || first_lines.include?('create') || 
               first_lines.include?('copy') || first_lines.include?('pg_dump')
          LOGGER.warn("PostgreSQL backup content validation failed, but proceeding (may be test data)")
        end
      when 'sqlite'
        unless first_lines.include?('pragma') || first_lines.include?('create') || 
               first_lines.include?('insert') || first_lines.include?('sqlite')
          LOGGER.warn("SQLite backup content validation failed, but proceeding (may be test data)")
        end
      end
    end
  end

  def store_backup_metadata(backup_file_path, file_size, checksum)
    metadata = {
      timestamp: Time.now.iso8601,
      container_name: name,
      engine: engine,
      database: database,
      file_size: file_size,
      checksum: checksum,
      backup_file: File.basename(backup_file_path)
    }
    
    metadata_file = "#{backup_file_path}.meta"
    File.write(metadata_file, metadata.to_json)
  end

  def cleanup_failed_backup(backup_file_path)
    return unless backup_file_path
    
    # Clean up failed backup file and metadata
    [backup_file_path, "#{backup_file_path}.meta", "#{backup_file_path}.tmp"].each do |file|
      File.delete(file) if File.exist?(file)
    end
    
    LOGGER.debug("Cleaned up failed backup files for #{backup_file_path}")
  end

  def backup_command
    if @backup_command.respond_to?(engine.to_sym)
      return @backup_command.send(engine.to_sym, login: login, password: password, database: database)
    elsif engine == 'custom'
      return @backup_command.custom(command: labels['baktainer.command']) || raise('Custom command not defined. Set docker label bt_command.')
    else
      raise "Unknown engine: #{engine}"
    end
  end
end

# :NODOC:
class Baktainer::Containers
  def self.find_all
    LOGGER.debug('Searching for containers with backup labels.')
    containers = Docker::Container.all.select do |container|
      labels = container.info['Labels']
      labels && labels['baktainer.backup'] == 'true'
    end
    LOGGER.debug("Found #{containers.size} containers with backup labels.")
    LOGGER.debug(containers.first.class) if containers.any?
    containers.map do |container|
      Baktainer::Container.new(container)
    end
  end
end