ruborg 0.9.0 → 0.9.4

data/lib/ruborg/repository.rb

@@ -6,11 +6,13 @@ module Ruborg
   class Repository
     attr_reader :path, :borg_path
 
-    def initialize(path, passphrase: nil, borg_options: {}, borg_path: nil, logger: nil)
+    def initialize(path, passphrase: nil, borg_options: {}, borg_path: nil, lock_wait: nil, logger: nil)
+      @original_path = path
       @path = validate_repo_path(path)
       @passphrase = passphrase
       @borg_options = borg_options
       @borg_path = validate_borg_path(borg_path || "borg")
+      @lock_wait = lock_wait&.to_i
       @logger = logger
     end
 
@@ -18,6 +20,48 @@ module Ruborg
       File.directory?(@path) && File.exist?(File.join(@path, "config"))
     end
 
+    MINIMUM_BORG_VERSION = "1.4.0"
+
+    def locked?
+      File.exist?(File.join(@path, "lock.exclusive")) ||
+        File.exist?(File.join(@path, "lock.roster"))
+    end
+
+    def cache_locked?
+      File.exist?(cache_lock_path)
+    end
+
+    def break_lock
+      raise BorgError, "Repository does not exist at #{@path}" unless exists?
+
+      check_borg_version!
+      cmd = [@borg_path, "break-lock", @path]
+      execute_borg_command(cmd)
+      @logger&.info("Lock broken for repository at #{@path}")
+    end
+
+    def force_break_lock
+      raise BorgError, "Repository does not exist at #{@path}" unless exists?
+
+      require "fileutils"
+      removed = %w[lock.exclusive lock.roster].select do |name|
+        target = File.join(@path, name)
+        next false unless File.exist?(target)
+
+        FileUtils.rm_rf(target)
+        true
+      end
+
+      cache_lock = cache_lock_path
+      if File.exist?(cache_lock)
+        FileUtils.rm_f(cache_lock)
+        removed << "cache:lock.exclusive"
+      end
+
+      @logger&.info("Force-removed lock files at #{@path}: #{removed.join(", ")}")
+      removed
+    end
+
     def create
       raise BorgError, "Repository already exists at #{@path}" if exists?
 
@@ -278,62 +322,67 @@ module Ruborg
       nil # Failed to parse, skip this archive
     end
 
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def get_archives_grouped_by_source_dir
       require "json"
       require "time"
       require "open3"
 
-      # Get list of all archives
       cmd = [@borg_path, "list", @path, "--json"]
       env = build_borg_env
 
       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"] || []
-
-      # Group archives by source directory from metadata
+      archives = JSON.parse(stdout)["archives"] || []
+      cache = ArchiveCache.new(@original_path).fetch
       archives_by_source = Hash.new { |h, k| h[k] = [] }
 
       archives.each do |archive|
         archive_name = archive["name"]
-
-        # Get archive info to read comment (metadata)
-        info_cmd = [@borg_path, "info", "#{@path}::#{archive_name}", "--json"]
-        info_stdout, _, info_status = Open3.capture3(env, *info_cmd)
-
-        unless info_status.success?
-          # If we can't get info, put in legacy group
-          archives_by_source[""] << {
-            name: archive_name,
-            time: Time.parse(archive["time"])
-          }
-          next
-        end
-
-        info_data = JSON.parse(info_stdout)
-        comment = info_data.dig("archives", 0, "comment") || ""
-
-        # Parse source_dir from comment
-        # Format: path|||size|||hash|||source_dir
-        source_dir = if comment.include?("|||")
-                       parts = comment.split("|||")
-                       parts.length >= 4 ? (parts[3] || "") : ""
+        archive_time = Time.parse(archive["time"])
+
+        metadata = if (cached = cache[archive_name])
+                     cached
+                   else
+                     info_cmd = [@borg_path, "info", "#{@path}::#{archive_name}", "--json"]
+                     info_stdout, _, info_status = Open3.capture3(env, *info_cmd)
+
+                     if info_status.success?
+                       comment = JSON.parse(info_stdout).dig("archives", 0, "comment") || ""
+                       parsed = parse_archive_comment(comment)
+                       cache.store(archive_name, parsed)
+                       parsed
                      else
-                       ""
+                       cache.store(archive_name, { path: "", size: 0, hash: "", source_dir: "" })
+                       { path: "", size: 0, hash: "", source_dir: "" }
                      end
+                   end
 
-        archives_by_source[source_dir] << {
-          name: archive_name,
-          time: Time.parse(archive["time"])
-        }
+        archives_by_source[metadata[:source_dir] || ""] << { name: archive_name, time: archive_time }
       end
 
+      cache.save_if_changed
       archives_by_source
     rescue JSON::ParserError => e
       raise BorgError, "Failed to parse archive metadata: #{e.message}"
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def parse_archive_comment(comment)
+      if comment.include?("|||")
+        parts = comment.split("|||")
+        if parts.length >= 4
+          { path: parts[0], size: parts[1].to_i, hash: parts[2] || "", source_dir: parts[3] || "" }
+        elsif parts.length >= 3
+          { path: parts[0], size: parts[1].to_i, hash: parts[2] || "", source_dir: "" }
+        else
+          { path: parts[0], size: 0, hash: parts[1] || "", source_dir: "" }
+        end
+      else
+        { path: comment, size: 0, hash: "", source_dir: "" }
+      end
+    end
 
     def prune_per_directory_standard(retention_policy)
       # Apply standard retention policies (keep_daily, etc.) per source directory
@@ -587,6 +636,39 @@ module Ruborg
       borg_path
     end
 
+    def inject_lock_wait(cmd)
+      return cmd if @lock_wait.nil? || cmd[1] == "break-lock"
+
+      [cmd[0], "--lock-wait", @lock_wait.to_s] + cmd[1..]
+    end
+
+    def check_borg_version!
+      version = self.class.borg_version(@borg_path)
+      return if version_sufficient?(version, MINIMUM_BORG_VERSION)
+
+      raise BorgError,
+            "Borg #{MINIMUM_BORG_VERSION}+ is required but found #{version}. Please upgrade Borg."
+    end
+
+    def version_sufficient?(actual, minimum)
+      actual_parts  = actual.split(".").map(&:to_i)
+      minimum_parts = minimum.split(".").map(&:to_i)
+      (actual_parts <=> minimum_parts) >= 0
+    end
+
+    def cache_lock_path
+      cache_dir = ENV.fetch("BORG_CACHE_DIR", File.join(Dir.home, ".cache", "borg"))
+      repo_id = read_repo_id
+      File.join(cache_dir, repo_id, "lock.exclusive")
+    end
+
+    def read_repo_id
+      config_file = File.join(@path, "config")
+      return "" unless File.exist?(config_file)
+
+      File.read(config_file).match(/^\s*id\s*=\s*([0-9a-f]+)/)&.captures&.first || ""
+    end
+
     def find_in_path(command)
       ENV["PATH"].split(File::PATH_SEPARATOR).each do |directory|
         path = File.join(directory, command)
@@ -610,6 +692,9 @@ module Ruborg
       env["BORG_RELOCATED_REPO_ACCESS_IS_OK"] = allow_relocated ? "yes" : "no"
       env["BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK"] = allow_unencrypted ? "yes" : "no"
 
+      # Inject --lock-wait for all commands except break-lock (which breaks, not acquires)
+      cmd = inject_lock_wait(cmd)
+
       # 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

data/lib/ruborg/version.rb

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

data/lib/ruborg.rb

@@ -3,6 +3,9 @@
 require_relative "ruborg/version"
 require_relative "ruborg/logger"
 require_relative "ruborg/config"
+require_relative "ruborg/archive_cache"
+require_relative "ruborg/catalog"
+require_relative "ruborg/progress"
 require_relative "ruborg/repository"
 require_relative "ruborg/backup"
 require_relative "ruborg/passbolt"
@@ -13,4 +16,5 @@ module Ruborg
   class ConfigError < Error; end
   class BorgError < Error; end
   class PassboltError < Error; end
+  class CatalogError < Error; end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruborg
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.4
 platform: ruby
 authors:
 - Michail Pantelelis
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: psych
@@ -144,11 +143,14 @@ files:
 - SECURITY.md
 - exe/ruborg
 - lib/ruborg.rb
+- lib/ruborg/archive_cache.rb
 - lib/ruborg/backup.rb
+- lib/ruborg/catalog.rb
 - lib/ruborg/cli.rb
 - lib/ruborg/config.rb
 - lib/ruborg/logger.rb
 - lib/ruborg/passbolt.rb
+- lib/ruborg/progress.rb
 - lib/ruborg/repository.rb
 - lib/ruborg/version.rb
 - ruborg.gemspec
@@ -161,7 +163,6 @@ metadata:
   source_code_uri: https://github.com/mpantel/ruborg.git
   changelog_uri: https://github.com/mpantel/ruborg/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -176,8 +177,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.7.1
 specification_version: 4
 summary: A friendly Ruby frontend for Borg backup
 test_files: []