ruborg 0.3.1 → 0.4.0

data/lib/ruborg/config.rb

@@ -5,13 +5,14 @@ require "psych"
 
 module Ruborg
   # Configuration management for ruborg
+  # Only supports multi-repository format
   class Config
     attr_reader :data
 
     def initialize(config_path)
       @config_path = config_path
       load_config
-      detect_format
+      validate_format
     end
 
     def load_config
@@ -24,91 +25,49 @@ module Ruborg
       raise ConfigError, "Invalid YAML content: #{e.message}"
     end
 
-    # Legacy single-repo accessors (for backward compatibility)
-    def repository
-      @data["repository"]
-    end
-
-    def backup_paths
-      @data["backup_paths"] || []
-    end
-
-    def exclude_patterns
-      patterns = @data["exclude_patterns"] || []
-      validate_exclude_patterns(patterns)
-    end
-
-    def compression
-      value = @data["compression"] || "lz4"
-      validate_compression(value)
-    end
-
-    def encryption_mode
-      value = @data["encryption"] || "repokey"
-      validate_encryption(value)
-    end
-
-    def passbolt_integration
-      @data["passbolt"] || {}
-    end
-
-    def auto_init?
-      @data["auto_init"] || false
-    end
-
-    def log_file
-      @data["log_file"]
-    end
-
-    def borg_options
-      @data["borg_options"] || {}
-    end
-
-    # New multi-repo support
-    def multi_repo?
-      @multi_repo
-    end
-
     def repositories
-      return [] unless multi_repo?
       @data["repositories"] || []
     end
 
     def get_repository(name)
-      return nil unless multi_repo?
       repositories.find { |r| r["name"] == name }
     end
 
     def repository_names
-      return [] unless multi_repo?
       repositories.map { |r| r["name"] }
     end
 
     def global_settings
-      @data.slice("passbolt", "compression", "encryption", "auto_init")
+      @data.slice("passbolt", "compression", "encryption", "auto_init", "borg_options", "log_file", "retention",
+                  "auto_prune")
     end
 
     private
 
-    VALID_COMPRESSION = ["lz4", "zstd", "zlib", "lzma", "none"].freeze
-    VALID_ENCRYPTION = ["repokey", "keyfile", "none", "authenticated", "repokey-blake2",
-                        "keyfile-blake2", "authenticated-blake2"].freeze
+    VALID_COMPRESSION = %w[lz4 zstd zlib lzma none].freeze
+    VALID_ENCRYPTION = %w[repokey keyfile none authenticated repokey-blake2
+                          keyfile-blake2 authenticated-blake2].freeze
+
+    def validate_format
+      return if @data.key?("repositories")
 
-    def detect_format
-      @multi_repo = @data.key?("repositories")
+      raise ConfigError,
+            "Invalid configuration format. Multi-repository format required. See documentation for details."
     end
 
     def validate_compression(compression)
       unless VALID_COMPRESSION.include?(compression)
-        raise ConfigError, "Invalid compression '#{compression}'. Must be one of: #{VALID_COMPRESSION.join(', ')}"
+        raise ConfigError, "Invalid compression '#{compression}'. Must be one of: #{VALID_COMPRESSION.join(", ")}"
       end
+
       compression
     end
 
     def validate_encryption(encryption)
       unless VALID_ENCRYPTION.include?(encryption)
-        raise ConfigError, "Invalid encryption mode '#{encryption}'. Must be one of: #{VALID_ENCRYPTION.join(', ')}"
+        raise ConfigError, "Invalid encryption mode '#{encryption}'. Must be one of: #{VALID_ENCRYPTION.join(", ")}"
       end
+
       encryption
     end
 
@@ -116,9 +75,7 @@ module Ruborg
       return patterns if patterns.empty?
 
       patterns.each do |pattern|
-        if pattern.nil? || pattern.to_s.strip.empty?
-          raise ConfigError, "Exclude pattern cannot be empty or nil"
-        end
+        raise ConfigError, "Exclude pattern cannot be empty or nil" if pattern.nil? || pattern.to_s.strip.empty?
 
         if pattern.length > 1000
           raise ConfigError, "Exclude pattern too long (max 1000 characters): #{pattern[0..50]}..."
@@ -128,4 +85,4 @@ module Ruborg
       patterns
     end
   end
-end
+end

data/lib/ruborg/logger.rb

@@ -13,8 +13,8 @@ module Ruborg
       validate_and_ensure_log_directory
       @logger = Logger.new(@log_file, "daily")
       @logger.level = Logger::INFO
-      @logger.formatter = proc do |severity, datetime, progname, msg|
-        "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity}: #{msg}\n"
+      @logger.formatter = proc do |severity, datetime, _progname, msg|
+        "[#{datetime.strftime("%Y-%m-%d %H:%M:%S")}] #{severity}: #{msg}\n"
       end
     end
 
@@ -41,8 +41,7 @@ module Ruborg
     end
 
     def log_directory
-      dir = File.expand_path("~/.ruborg/logs")
-      dir
+      File.expand_path("~/.ruborg/logs")
     end
 
     def validate_and_ensure_log_directory
@@ -62,4 +61,4 @@ module Ruborg
       FileUtils.mkdir_p(log_dir) unless File.directory?(log_dir)
     end
   end
-end
+end

data/lib/ruborg/passbolt.rb

@@ -24,14 +24,14 @@ module Ruborg
     private
 
     def check_passbolt_cli
-      unless system("which passbolt > /dev/null 2>&1")
-        raise PassboltError, "Passbolt CLI not found. Please install it first."
-      end
+      return if system("which passbolt > /dev/null 2>&1")
+
+      raise PassboltError, "Passbolt CLI not found. Please install it first."
     end
 
     def execute_command(cmd)
       require "open3"
-      stdout, stderr, status = Open3.capture3(*cmd)
+      stdout, _, status = Open3.capture3(*cmd)
       [stdout, status.success?]
     end
 
@@ -42,4 +42,4 @@ module Ruborg
       raise PassboltError, "Failed to parse Passbolt response: #{e.message}"
     end
   end
-end
+end

data/lib/ruborg/repository.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
+require "English"
 module Ruborg
   # Borg repository management
   class Repository
-    attr_reader :path
+    attr_reader :path, :borg_path
 
-    def initialize(path, passphrase: nil, borg_options: {})
+    def initialize(path, passphrase: nil, borg_options: {}, borg_path: nil)
       @path = validate_repo_path(path)
       @passphrase = passphrase
       @borg_options = borg_options
+      @borg_path = validate_borg_path(borg_path || "borg")
     end
 
     def exists?
@@ -18,26 +20,253 @@ module Ruborg
     def create
       raise BorgError, "Repository already exists at #{@path}" if exists?
 
-      cmd = ["borg", "init", "--encryption=repokey", @path]
+      cmd = [@borg_path, "init", "--encryption=repokey", @path]
       execute_borg_command(cmd)
     end
 
     def info
       raise BorgError, "Repository does not exist at #{@path}" unless exists?
 
-      cmd = ["borg", "info", @path]
+      cmd = [@borg_path, "info", @path]
       execute_borg_command(cmd)
     end
 
     def list
       raise BorgError, "Repository does not exist at #{@path}" unless exists?
 
-      cmd = ["borg", "list", @path]
+      cmd = [@borg_path, "list", @path]
       execute_borg_command(cmd)
     end
 
+    def prune(retention_policy = {}, retention_mode: "standard")
+      raise BorgError, "Repository does not exist at #{@path}" unless exists?
+      raise BorgError, "No retention policy specified" if retention_policy.nil? || retention_policy.empty?
+
+      if retention_mode == "per_file"
+        prune_per_file_archives(retention_policy)
+      else
+        prune_standard_archives(retention_policy)
+      end
+    end
+
+    private
+
+    def prune_standard_archives(retention_policy)
+      cmd = [@borg_path, "prune", @path, "--stats"]
+
+      # Add count-based retention options
+      cmd += ["--keep-hourly", retention_policy["keep_hourly"].to_s] if retention_policy["keep_hourly"]
+      cmd += ["--keep-daily", retention_policy["keep_daily"].to_s] if retention_policy["keep_daily"]
+      cmd += ["--keep-weekly", retention_policy["keep_weekly"].to_s] if retention_policy["keep_weekly"]
+      cmd += ["--keep-monthly", retention_policy["keep_monthly"].to_s] if retention_policy["keep_monthly"]
+      cmd += ["--keep-yearly", retention_policy["keep_yearly"].to_s] if retention_policy["keep_yearly"]
+
+      # Add time-based retention options
+      cmd += ["--keep-within", retention_policy["keep_within"]] if retention_policy["keep_within"]
+      cmd += ["--keep-last", retention_policy["keep_last"]] if retention_policy["keep_last"]
+
+      execute_borg_command(cmd)
+    end
+
+    def prune_per_file_archives(retention_policy)
+      # Get file metadata-based retention setting
+      keep_files_modified_within = retention_policy["keep_files_modified_within"]
+
+      unless keep_files_modified_within
+        # Fall back to standard pruning if no file metadata retention specified
+        prune_standard_archives(retention_policy)
+        return
+      end
+
+      # Parse time duration (e.g., "30d" -> 30 days)
+      cutoff_time = Time.now - parse_time_duration(keep_files_modified_within)
+
+      # Get all archives with metadata
+      archives = list_archives_with_metadata
+
+      archives_to_delete = []
+
+      archives.each do |archive|
+        # Get file metadata from archive
+        file_mtime = get_file_mtime_from_archive(archive[:name])
+
+        # Delete archive if file was modified before cutoff
+        archives_to_delete << archive[:name] if file_mtime && file_mtime < cutoff_time
+      end
+
+      # Delete archives
+      archives_to_delete.each do |archive_name|
+        delete_archive(archive_name)
+      end
+
+      return if archives_to_delete.empty?
+
+      puts "Pruned #{archives_to_delete.size} archive(s) based on file modification time"
+    end
+
+    def list_archives_with_metadata
+      require "json"
+      require "time"
+      require "open3"
+
+      cmd = [@borg_path, "list", @path, "--json"]
+      env = build_borg_env
+
+      # Use Open3.capture3 for safe command execution with environment variables
+      stdout, stderr, status = Open3.capture3(env, *cmd)
+
+      raise BorgError, "Failed to list archives: #{stderr}" unless status.success?
+
+      json_data = JSON.parse(stdout)
+      archives = json_data["archives"] || []
+
+      archives.map do |archive|
+        {
+          name: archive["name"],
+          time: Time.parse(archive["time"])
+        }
+      end
+    rescue JSON::ParserError => e
+      raise BorgError, "Failed to parse archive list: #{e.message}"
+    end
+
+    def get_file_mtime_from_archive(archive_name)
+      require "json"
+      require "time"
+      require "open3"
+
+      cmd = [@borg_path, "list", "#{@path}::#{archive_name}", "--json-lines"]
+      env = build_borg_env
+
+      # Use Open3.capture3 for safe command execution with environment variables
+      stdout, _stderr, status = Open3.capture3(env, *cmd)
+
+      unless status.success?
+        return nil # Archive might be corrupted or inaccessible
+      end
+
+      # Parse first line (should be the only file in per-file archives)
+      first_line = stdout.lines.first
+      return nil unless first_line
+
+      file_data = JSON.parse(first_line)
+      mtime_str = file_data["mtime"]
+
+      return nil unless mtime_str
+
+      # Parse mtime (format: "2025-10-06T12:34:56.123456")
+      Time.parse(mtime_str)
+    rescue JSON::ParserError, ArgumentError
+      nil # Failed to parse, skip this archive
+    end
+
+    def delete_archive(archive_name)
+      cmd = [@borg_path, "delete", "#{@path}::#{archive_name}"]
+      execute_borg_command(cmd)
+    end
+
+    def parse_time_duration(duration_str)
+      # Parse duration strings like "30d", "7w", "6m", "1y"
+      match = duration_str.match(/^(\d+)([dwmy])$/)
+      raise BorgError, "Invalid time duration format: #{duration_str}" unless match
+
+      value = match[1].to_i
+      unit = match[2]
+
+      case unit
+      when "d"
+        value * 24 * 60 * 60 # days to seconds
+      when "w"
+        value * 7 * 24 * 60 * 60 # weeks to seconds
+      when "m"
+        value * 30 * 24 * 60 * 60 # months (approx) to seconds
+      when "y"
+        value * 365 * 24 * 60 * 60 # years (approx) to seconds
+      end
+    end
+
+    def build_borg_env
+      env = {}
+      env["BORG_PASSPHRASE"] = @passphrase if @passphrase
+
+      allow_relocated = @borg_options.fetch("allow_relocated_repo", true)
+      allow_unencrypted = @borg_options.fetch("allow_unencrypted_repo", true)
+
+      env["BORG_RELOCATED_REPO_ACCESS_IS_OK"] = allow_relocated ? "yes" : "no"
+      env["BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK"] = allow_unencrypted ? "yes" : "no"
+
+      env
+    end
+
+    public
+
+    def check
+      raise BorgError, "Repository does not exist at #{@path}" unless exists?
+
+      cmd = [@borg_path, "check", @path]
+      execute_borg_command(cmd)
+    end
+
+    # Get Borg version
+    def self.borg_version(borg_path = "borg")
+      output, status = execute_version_command(borg_path)
+      raise BorgError, "Borg is not installed or not in PATH" unless status.success?
+
+      # Parse version from output like "borg 1.2.8"
+      match = output.match(/borg (\d+\.\d+\.\d+)/)
+      raise BorgError, "Could not parse Borg version from: #{output}" unless match
+
+      match[1]
+    end
+
+    # Execute borg version command (extracted for testing)
+    def self.execute_version_command(borg_path = "borg")
+      require "open3"
+
+      # Use Open3.capture2e for safe command execution
+      output, status = Open3.capture2e(borg_path, "--version")
+      [output.strip, status]
+    end
+
+    # Check compatibility between Borg version and repository
+    def check_compatibility
+      raise BorgError, "Repository does not exist at #{@path}" unless exists?
+
+      borg_version = self.class.borg_version(@borg_path)
+      borg_major, borg_minor = borg_version.split(".").map(&:to_i)
+
+      # Get repository version from config
+      config_file = File.join(@path, "config")
+      config_content = File.read(config_file)
+
+      # Extract version from config (format: version = 1)
+      repo_version = config_content.match(/version\s*=\s*(\d+)/)&.captures&.first&.to_i
+
+      {
+        borg_version: borg_version,
+        repository_version: repo_version,
+        compatible: check_version_compatibility(borg_major, borg_minor, repo_version)
+      }
+    end
+
     private
 
+    def check_version_compatibility(borg_major, _borg_minor, repo_version)
+      # Borg 1.x can ONLY work with repository version 1
+      return true if borg_major == 1 && repo_version == 1
+      return false if borg_major == 1 && repo_version == 2
+
+      # Borg 2.x can work with repository version 2
+      # Borg 2.x can READ from version 1 repos (read-only, for migration)
+      # but for regular operations, version 2 repos are required
+      return true if borg_major == 2 && repo_version == 2
+      # Version 1 repos with Borg 2.x are limited (read-only for migration)
+      return false if borg_major == 2 && repo_version == 1
+
+      # Unknown combinations - assume incompatible
+      false
+    end
+
     def validate_repo_path(path)
       raise BorgError, "Repository path cannot be empty" if path.nil? || path.empty?
 
@@ -54,6 +283,45 @@ module Ruborg
       normalized
     end
 
+    def validate_borg_path(borg_path)
+      raise BorgError, "Borg path cannot be empty" if borg_path.nil? || borg_path.to_s.strip.empty?
+
+      # Check if the command is executable
+      # For commands in PATH (like "borg"), use which to find the full path
+      full_path = if borg_path.include?("/")
+                    # Absolute or relative path provided
+                    File.expand_path(borg_path)
+                  else
+                    # Command name only - search in PATH
+                    find_in_path(borg_path)
+                  end
+
+      # Verify the executable exists and is actually executable
+      unless full_path && File.executable?(full_path)
+        raise BorgError, "Borg executable not found or not executable: #{borg_path}"
+      end
+
+      # Verify it's actually borg by checking version output
+      begin
+        output, status = self.class.execute_version_command(borg_path)
+        unless status.success? && output.match?(/borg \d+\.\d+/)
+          raise BorgError, "Command '#{borg_path}' does not appear to be Borg backup"
+        end
+      rescue StandardError => e
+        raise BorgError, "Failed to verify Borg executable: #{e.message}"
+      end
+
+      borg_path
+    end
+
+    def find_in_path(command)
+      ENV["PATH"].split(File::PATH_SEPARATOR).each do |directory|
+        path = File.join(directory, command)
+        return path if File.executable?(path)
+      end
+      nil
+    end
+
     def execute_borg_command(cmd)
       env = {}
       env["BORG_PASSPHRASE"] = @passphrase if @passphrase
@@ -67,9 +335,9 @@ module Ruborg
 
       # Redirect stdin from /dev/null to prevent interactive prompts
       result = system(env, *cmd, in: "/dev/null")
-      raise BorgError, "Borg command failed: #{cmd.join(' ')}" unless result
+      raise BorgError, "Borg command failed: #{cmd.join(" ")}" unless result
 
       result
     end
   end
-end
+end

data/lib/ruborg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruborg
-  VERSION = "0.3.1"
-end
+  VERSION = "0.4.0"
+end

data/lib/ruborg.rb

@@ -13,4 +13,4 @@ module Ruborg
   class ConfigError < Error; end
   class BorgError < Error; end
   class PassboltError < Error; end
-end
+end