kamal-backup 0.3.0.beta21 → 0.3.1

data/lib/kamal_backup/restic.rb

@@ -1,8 +1,11 @@
-require "fileutils"
-require "json"
-require "open3"
-require "time"
-require_relative "command"
+# frozen_string_literal: true
+
+require 'English'
+require 'fileutils'
+require 'json'
+require 'open3'
+require 'time'
+require_relative 'command'
 
 module KamalBackup
   class Restic
@@ -18,36 +21,42 @@ module KamalBackup
     def ensure_repository
       run(%w[snapshots --json], log_output: false)
     rescue CommandError => e
-      if config.restic_init_if_missing?
-        log("restic repository not ready, running restic init")
-        run(%w[init])
-      else
-        raise e
-      end
+      raise e unless config.restic_init_if_missing?
+
+      log('restic repository not ready, running restic init')
+      run(%w[init])
     end
 
     def backup_stream(command, filename:, tags:)
       restic_command = CommandSpec.new(
-        argv: ["restic", "backup"] + host_args + ["--stdin", "--stdin-filename", filename] + tag_args(common_tags + tags),
+        argv: %w[restic
+                 backup] + host_args + ['--stdin', '--stdin-filename', filename] + tag_args(common_tags + tags),
         env: restic_env
       )
       log("backing up stream as #{filename}")
-      pipe_commands(command, restic_command, producer_label: "dump", consumer_label: "restic backup")
+      pipe_commands(command, restic_command, producer_label: 'dump', consumer_label: 'restic backup')
     end
 
     def backup_file(path, filename:, tags:)
       command = CommandSpec.new(
-        argv: ["restic", "backup"] + host_args + ["--stdin", "--stdin-filename", filename] + tag_args(common_tags + tags),
+        argv: %w[restic
+                 backup] + host_args + ['--stdin', '--stdin-filename', filename] + tag_args(common_tags + tags),
         env: restic_env
       )
       log("backing up file content as #{filename}")
 
-      File.open(path, "rb") do |file|
+      File.open(path, 'rb') do |file|
         output = Command.output
         context = output&.command_start(command, redactor: redactor)
         Open3.popen3(command.env, *command.argv) do |stdin, stdout, stderr, wait_thread|
-          stdout_reader = Thread.new { Command.collect_stream(stdout, command_output: output, context: context, stream: :stdout, redactor: redactor) }
-          stderr_reader = Thread.new { Command.collect_stream(stderr, command_output: output, context: context, stream: :stderr, redactor: redactor) }
+          stdout_reader = Thread.new do
+            Command.collect_stream(stdout, command_output: output, context: context, stream: :stdout,
+                                           redactor: redactor)
+          end
+          stderr_reader = Thread.new do
+            Command.collect_stream(stderr, command_output: output, context: context, stream: :stderr,
+                                           redactor: redactor)
+          end
           copy_error = nil
           begin
             IO.copy_stream(file, stdin)
@@ -67,31 +76,24 @@ module KamalBackup
         end
       end
     rescue Errno::ENOENT => e
-      raise CommandError.new("command not found: #{command.argv.first}", command: command, status: 127, stderr: e.message)
+      raise CommandError.new("command not found: #{command.argv.first}", command: command, status: 127,
+                                                                         stderr: e.message)
     end
 
     def backup_paths(paths, tags:)
       paths = Array(paths).compact.map(&:to_s).reject(&:empty?)
 
-      if paths.any?
-        path_tags = paths.map { |path| "path:#{config.backup_path_label(path)}" }
-        excludes = config.backup_path_excludes(paths)
-        log("backing up #{paths.size} file path(s): #{paths.join(", ")}")
-        run(["backup"] + host_args + exclude_args(excludes) + paths + tag_args(common_tags + tags + path_tags))
-      end
-    end
-
-    def backup_path(path, tags:)
-      backup_paths([path], tags: tags)
-    end
+      return unless paths.any?
 
-    def forget_after_success
-      prune
+      path_tags = paths.map { |path| "path:#{config.backup_path_label(path)}" }
+      excludes = config.backup_path_excludes(paths)
+      log("backing up #{paths.size} file path(s): #{paths.join(', ')}")
+      run(['backup'] + host_args + exclude_args(excludes) + paths + tag_args(common_tags + tags + path_tags))
     end
 
     def prune
       retention_tag_sets.map do |tags|
-        args = ["forget", "--prune", "--group-by", "host"] + config.retention_args + filter_tag_args(tags)
+        args = ['forget', '--prune', '--group-by', 'host'] + config.retention_args + filter_tag_args(tags)
         log("running restic forget/prune with retention policy for #{retention_scope(tags)}")
         run(args)
       end
@@ -99,39 +101,40 @@ module KamalBackup
 
     def check
       args = %w[check]
-      args.concat(["--read-data-subset", config.check_read_data_subset]) if config.check_read_data_subset
+      args.concat(['--read-data-subset', config.check_read_data_subset]) if config.check_read_data_subset
       started_at = Time.now.utc
       result = run(args)
-      write_last_check(status: "ok", started_at: started_at, finished_at: Time.now.utc, output: result.stdout)
+      write_last_check(status: 'ok', started_at: started_at, finished_at: Time.now.utc, output: result.stdout)
       result
     rescue CommandError => e
-      write_last_check(status: "failed", started_at: started_at || Time.now.utc, finished_at: Time.now.utc, error: e.message)
+      write_last_check(status: 'failed', started_at: started_at || Time.now.utc, finished_at: Time.now.utc,
+                       error: e.message)
       raise
     end
 
     def snapshots(tags: common_tags)
-      run(["snapshots"] + filter_tag_args(tags))
+      run(['snapshots'] + filter_tag_args(tags))
     end
 
     def snapshots_json(tags: common_tags)
-      output = run(["snapshots", "--json"] + filter_tag_args(tags), log_output: false).stdout
+      output = run(['snapshots', '--json'] + filter_tag_args(tags), log_output: false).stdout
       snapshots = JSON.parse(output)
       required_tags = tags.compact
       snapshots.select do |snapshot|
-        snapshot_tags = Array(snapshot["tags"])
+        snapshot_tags = Array(snapshot['tags'])
         required_tags.all? { |tag| snapshot_tags.include?(tag) }
       end
     end
 
     def latest_snapshot(tags:)
       snapshots = snapshots_json(tags: common_tags + tags)
-      snapshots.max_by { |snapshot| Time.parse(snapshot.fetch("time")) }
+      snapshots.max_by { |snapshot| Time.parse(snapshot.fetch('time')) }
     rescue JSON::ParserError
       nil
     end
 
     def ls_json(snapshot)
-      output = run(["ls", "--json", snapshot], log_output: false).stdout
+      output = run(['ls', '--json', snapshot], log_output: false).stdout
       output.lines.filter_map do |line|
         JSON.parse(line)
       rescue JSON::ParserError
@@ -139,51 +142,58 @@ module KamalBackup
       end
     end
 
-    def database_file(snapshot, adapter, database_name: nil)
+    # Database dumps from 0.2 and earlier used different layouts. Keep matching
+    # them so snapshots taken before 0.3 stay restorable:
+    # databases/<app>/<database>/<adapter>.<ext> is current,
+    # databases/<app>/<adapter>/... is 0.2 (no database name), and the
+    # databases-<app>-... basenames are the earliest flat filenames.
+    def database_file(snapshot, adapter, database_name:)
       legacy_prefix = "databases/#{config.app_name}/#{adapter}/"
-      app = config.app_name.gsub(/[^A-Za-z0-9_.-]+/, "-")
-      database = database_name.to_s.gsub(/[^A-Za-z0-9_.-]+/, "-")
-      stable_prefix = database.empty? ? nil : "databases/#{app}/#{database}/#{adapter}."
+      app = config.app_name.gsub(/[^A-Za-z0-9_.-]+/, '-')
+      database = database_name.to_s.gsub(/[^A-Za-z0-9_.-]+/, '-')
+      prefix = "databases/#{app}/#{database}/#{adapter}."
       flat_prefix = "databases-#{app}-#{adapter}-"
-      named_flat_prefix = database.empty? ? nil : "databases-#{app}-#{database}-#{adapter}-"
+      named_flat_prefix = "databases-#{app}-#{database}-#{adapter}-"
       ls_json(snapshot).find do |entry|
-        next false unless entry["type"] == "file"
+        next false unless entry['type'] == 'file'
 
-        normalized = entry["path"].to_s.sub(%r{\A/+}, "")
-        (stable_prefix && normalized.start_with?(stable_prefix)) ||
+        normalized = entry['path'].to_s.sub(%r{\A/+}, '')
+        normalized.start_with?(prefix) ||
           normalized.start_with?(legacy_prefix) ||
-          File.basename(normalized).start_with?(flat_prefix) ||
-          (named_flat_prefix && File.basename(normalized).start_with?(named_flat_prefix))
-      end&.fetch("path")
+          File.basename(normalized).start_with?(flat_prefix, named_flat_prefix)
+      end&.fetch('path')
     end
 
     def pipe_dump_to_command(snapshot, filename, command)
-      restic_command = CommandSpec.new(argv: ["restic", "dump", snapshot, filename], env: restic_env)
-      pipe_commands(restic_command, command, producer_label: "restic dump", consumer_label: command.argv.first)
+      restic_command = CommandSpec.new(argv: ['restic', 'dump', snapshot, filename], env: restic_env)
+      pipe_commands(restic_command, command, producer_label: 'restic dump', consumer_label: command.argv.first)
     end
 
     def write_dump_to_path(snapshot, filename, target_path)
-      command = CommandSpec.new(argv: ["restic", "dump", snapshot, filename], env: restic_env)
+      command = CommandSpec.new(argv: ['restic', 'dump', snapshot, filename], env: restic_env)
       target_path = File.expand_path(target_path)
       FileUtils.mkdir_p(File.dirname(target_path))
-      temp_path = "#{target_path}.kamal-backup-#{$$}.tmp"
+      temp_path = "#{target_path}.kamal-backup-#{$PROCESS_ID}.tmp"
 
       output = Command.output
       context = output&.command_start(command, redactor: redactor)
       Open3.popen3(command.env, *command.argv) do |stdin, stdout, stderr, wait_thread|
         stdin.close
-        stderr_reader = Thread.new { Command.collect_stream(stderr, command_output: output, context: context, stream: :stderr, redactor: redactor) }
-        File.open(temp_path, "wb") { |file| IO.copy_stream(stdout, file) }
+        stderr_reader = Thread.new do
+          Command.collect_stream(stderr, command_output: output, context: context, stream: :stderr, redactor: redactor)
+        end
+        File.open(temp_path, 'wb') { |file| IO.copy_stream(stdout, file) }
         err = stderr_reader.value
         status = wait_thread.value
         output&.command_exit(context, status.exitstatus)
-        raise_command_error(command, status, "", err) unless status.success?
+        raise_command_error(command, status, '', err) unless status.success?
       end
       File.rename(temp_path, target_path)
       target_path
     rescue Errno::ENOENT => e
       FileUtils.rm_f(temp_path) if temp_path
-      raise CommandError.new("command not found: #{command.argv.first}", command: command, status: 127, stderr: e.message)
+      raise CommandError.new("command not found: #{command.argv.first}", command: command, status: 127,
+                                                                         stderr: e.message)
     rescue StandardError
       FileUtils.rm_f(temp_path) if temp_path
       raise
@@ -191,162 +201,176 @@ module KamalBackup
 
     def restore_snapshot(snapshot, target)
       log("restoring file snapshot #{snapshot} to #{target}")
-      run(["restore", snapshot, "--target", target])
+      run(['restore', snapshot, '--target', target])
     end
 
+    private
+
     def run(args, log_output: true)
       Command.capture(
-        CommandSpec.new(argv: ["restic"] + args, env: restic_env),
+        CommandSpec.new(argv: ['restic'] + args, env: restic_env),
         redactor: redactor,
         log_output: log_output
       )
     end
 
     def common_tags
-      ["kamal-backup", "app:#{config.app_name}"]
+      ['kamal-backup', "app:#{config.app_name}"]
     end
 
-    private
-      def retention_tag_sets
-        database_retention_tag_sets + file_retention_tag_sets
-      end
+    def host_args
+      ['--host', restic_host]
+    end
+
+    def restic_host
+      normalize_restic_host([config.app_name, config.accessory_name || 'backup'].compact.join('-'))
+    end
 
-      def database_retention_tag_sets
-        config.databases.group_by(&:database_adapter).flat_map do |adapter, databases|
-          if databases.one?
-            # Pre-0.3 database snapshots did not include database:<name>, so keep
-            # the single-database filter broad enough for retention to prune them.
-            [common_tags + ["type:database", "adapter:#{adapter}"]]
-          else
-            databases.map do |database|
-              common_tags + ["type:database", "database:#{database.database_name}", "adapter:#{adapter}"]
-            end
+    def normalize_restic_host(value)
+      normalized = value.to_s.gsub(/[^A-Za-z0-9_.-]+/, '-').gsub(/\A-+|-+\z/, '')
+      normalized.empty? ? 'kamal-backup' : normalized
+    end
+
+    def tag_args(tags)
+      tags.compact.each_with_object([]) { |tag, args| args.concat(['--tag', tag]) }
+    end
+
+    def exclude_args(patterns)
+      patterns.compact.each_with_object([]) { |pattern, args| args.concat(['--exclude', pattern]) }
+    end
+
+    def retention_tag_sets
+      database_retention_tag_sets + file_retention_tag_sets
+    end
+
+    def database_retention_tag_sets
+      config.databases.group_by(&:database_adapter).flat_map do |adapter, databases|
+        if databases.one?
+          # Snapshots from 0.2 carry no database:<name> tag, so keep the
+          # single-database filter broad enough for retention to prune them too.
+          [common_tags + ['type:database', "adapter:#{adapter}"]]
+        else
+          databases.map do |database|
+            common_tags + ['type:database', "database:#{database.database_name}", "adapter:#{adapter}"]
           end
         end
       end
+    end
 
-      def file_retention_tag_sets
-        config.backup_paths.any? ? [common_tags + ["type:files"]] : []
-      end
+    def file_retention_tag_sets
+      config.backup_paths.any? ? [common_tags + ['type:files']] : []
+    end
 
-      def retention_scope(tags)
-        tags.reject { |tag| tag == "kamal-backup" || tag.start_with?("app:") }.join(", ")
-      end
+    def retention_scope(tags)
+      tags.reject { |tag| tag == 'kamal-backup' || tag.start_with?('app:') }.join(', ')
+    end
 
-      def tag_args(tags)
-        tags.compact.each_with_object([]) { |tag, args| args.concat(["--tag", tag]) }
-      end
+    def write_last_check(payload)
+      FileUtils.mkdir_p(config.state_dir)
+      File.write(config.last_check_path, JSON.pretty_generate(payload.transform_values do |value|
+        value.respond_to?(:iso8601) ? value.iso8601 : redactor.redact_string(value.to_s)
+      end))
+    rescue SystemCallError
+      nil
+    end
 
-      def exclude_args(patterns)
-        patterns.compact.each_with_object([]) { |pattern, args| args.concat(["--exclude", pattern]) }
-      end
+    def filter_tag_args(tags)
+      tags = tags.compact
+      tags.empty? ? [] : ['--tag', tags.join(',')]
+    end
 
-      def host_args
-        ["--host", restic_host]
+    def restic_env
+      config.env.each_with_object({}) do |(key, value), env|
+        env[key] = value if key.to_s.match?(RESTIC_ENV_PATTERN)
       end
+    end
 
-      def restic_host
-        normalize_restic_host([config.app_name, config.accessory_name || "backup"].compact.join("-"))
-      end
+    def pipe_commands(producer, consumer, producer_label:, consumer_label:)
+      output = Command.output
+      producer_context = output&.command_start(producer, redactor: redactor)
+      Open3.popen3(producer.env, *producer.argv) do |producer_stdin, producer_stdout, producer_stderr, producer_wait|
+        producer_stdin.close
+
+        consumer_context = output&.command_start(consumer, redactor: redactor)
+        Open3.popen3(consumer.env,
+                     *consumer.argv) do |consumer_stdin, consumer_stdout, consumer_stderr, consumer_wait|
+          producer_err_reader = Thread.new do
+            Command.collect_stream(producer_stderr, command_output: output, context: producer_context, stream: :stderr,
+                                                    redactor: redactor)
+          end
+          consumer_out_reader = Thread.new do
+            Command.collect_stream(consumer_stdout, command_output: output, context: consumer_context, stream: :stdout,
+                                                    redactor: redactor)
+          end
+          consumer_err_reader = Thread.new do
+            Command.collect_stream(consumer_stderr, command_output: output, context: consumer_context, stream: :stderr,
+                                                    redactor: redactor)
+          end
 
-      def normalize_restic_host(value)
-        normalized = value.to_s.gsub(/[^A-Za-z0-9_.-]+/, "-").gsub(/\A-+|-+\z/, "")
-        normalized.empty? ? "kamal-backup" : normalized
-      end
+          copy_error = nil
+          copy_thread = Thread.new do
+            IO.copy_stream(producer_stdout, consumer_stdin)
+          rescue StandardError => e
+            copy_error = e
+          ensure
+            consumer_stdin.close unless consumer_stdin.closed?
+          end
 
-      def filter_tag_args(tags)
-        tags = tags.compact
-        tags.empty? ? [] : ["--tag", tags.join(",")]
-      end
+          copy_thread.join
+          producer_status = producer_wait.value
+          consumer_status = consumer_wait.value
+          output&.command_exit(producer_context, producer_status.exitstatus)
+          output&.command_exit(consumer_context, consumer_status.exitstatus)
+
+          producer_err = producer_err_reader.value
+          consumer_out = consumer_out_reader.value
+          consumer_err = consumer_err_reader.value
+
+          if copy_error
+            raise CommandError.new(
+              "failed to pipe #{producer_label} to #{consumer_label}: #{copy_error.message}",
+              command: consumer,
+              stderr: copy_error.message
+            )
+          end
 
-      def restic_env
-        config.env.each_with_object({}) do |(key, value), env|
-          env[key] = value if key.to_s.match?(RESTIC_ENV_PATTERN)
-        end
-      end
+          raise_command_error(producer, producer_status, '', producer_err) unless producer_status.success?
+          raise_command_error(consumer, consumer_status, consumer_out, consumer_err) unless consumer_status.success?
 
-      def pipe_commands(producer, consumer, producer_label:, consumer_label:)
-        output = Command.output
-        producer_context = output&.command_start(producer, redactor: redactor)
-        Open3.popen3(producer.env, *producer.argv) do |producer_stdin, producer_stdout, producer_stderr, producer_wait|
-          producer_stdin.close
-
-          consumer_context = output&.command_start(consumer, redactor: redactor)
-          Open3.popen3(consumer.env, *consumer.argv) do |consumer_stdin, consumer_stdout, consumer_stderr, consumer_wait|
-            producer_err_reader = Thread.new { Command.collect_stream(producer_stderr, command_output: output, context: producer_context, stream: :stderr, redactor: redactor) }
-            consumer_out_reader = Thread.new { Command.collect_stream(consumer_stdout, command_output: output, context: consumer_context, stream: :stdout, redactor: redactor) }
-            consumer_err_reader = Thread.new { Command.collect_stream(consumer_stderr, command_output: output, context: consumer_context, stream: :stderr, redactor: redactor) }
-
-            copy_error = nil
-            copy_thread = Thread.new do
-              IO.copy_stream(producer_stdout, consumer_stdin)
-            rescue StandardError => e
-              copy_error = e
-            ensure
-              consumer_stdin.close unless consumer_stdin.closed?
-            end
-
-            copy_thread.join
-            producer_status = producer_wait.value
-            consumer_status = consumer_wait.value
-            output&.command_exit(producer_context, producer_status.exitstatus)
-            output&.command_exit(consumer_context, consumer_status.exitstatus)
-
-            producer_err = producer_err_reader.value
-            consumer_out = consumer_out_reader.value
-            consumer_err = consumer_err_reader.value
-
-            if copy_error
-              raise CommandError.new(
-                "failed to pipe #{producer_label} to #{consumer_label}: #{copy_error.message}",
-                command: consumer,
-                stderr: copy_error.message
-              )
-            end
-
-            raise_command_error(producer, producer_status, "", producer_err) unless producer_status.success?
-            raise_command_error(consumer, consumer_status, consumer_out, consumer_err) unless consumer_status.success?
-
-            CommandResult.new(stdout: consumer_out, stderr: consumer_err, status: consumer_status.exitstatus)
-          end
+          CommandResult.new(stdout: consumer_out, stderr: consumer_err, status: consumer_status.exitstatus)
         end
-      rescue Errno::ENOENT => e
-        command = e.message.include?(producer.argv.first) ? producer : consumer
-        raise CommandError.new("command not found: #{command.argv.first}", command: command, status: 127, stderr: e.message)
-      end
-
-      def raise_command_error(command, status, stdout, stderr)
-        raise CommandError.new(
-          "command failed (#{status.exitstatus}): #{command.display(redactor)}\n#{redactor.redact_string(stderr)}",
-          command: command,
-          status: status.exitstatus,
-          stdout: redactor.redact_string(stdout),
-          stderr: redactor.redact_string(stderr)
-        )
       end
+    rescue Errno::ENOENT => e
+      command = e.message.include?(producer.argv.first) ? producer : consumer
+      raise CommandError.new("command not found: #{command.argv.first}", command: command, status: 127,
+                                                                         stderr: e.message)
+    end
 
-      def raise_stream_error(command, error, stdout, stderr)
-        raise CommandError.new(
-          "failed to stream file to #{command.display(redactor)}: #{error.message}\n#{redactor.redact_string(stderr)}",
-          command: command,
-          stdout: redactor.redact_string(stdout),
-          stderr: redactor.redact_string(stderr)
-        )
-      end
+    def raise_command_error(command, status, stdout, stderr)
+      raise CommandError.new(
+        "command failed (#{status.exitstatus}): #{command.display(redactor)}\n#{redactor.redact_string(stderr)}",
+        command: command,
+        status: status.exitstatus,
+        stdout: redactor.redact_string(stdout),
+        stderr: redactor.redact_string(stderr)
+      )
+    end
 
-      def write_last_check(payload)
-        FileUtils.mkdir_p(config.state_dir)
-        File.write(config.last_check_path, JSON.pretty_generate(payload.transform_values { |value| value.respond_to?(:iso8601) ? value.iso8601 : redactor.redact_string(value.to_s) }))
-      rescue SystemCallError
-        nil
-      end
+    def raise_stream_error(command, error, stdout, stderr)
+      raise CommandError.new(
+        "failed to stream file to #{command.display(redactor)}: #{error.message}\n#{redactor.redact_string(stderr)}",
+        command: command,
+        stdout: redactor.redact_string(stdout),
+        stderr: redactor.redact_string(stderr)
+      )
+    end
 
-      def log(message)
-        if Command.output
-          Command.output.info(message, redactor: redactor)
-        else
-          $stdout.puts("[kamal-backup] #{redactor.redact_string(message)}")
-        end
+    def log(message)
+      if Command.output
+        Command.output.info(message, redactor: redactor)
+      else
+        $stdout.puts("[kamal-backup] #{redactor.redact_string(message)}")
       end
+    end
   end
 end

data/lib/kamal_backup/scheduler.rb

@@ -1,4 +1,6 @@
-require "time"
+# frozen_string_literal: true
+
+require 'time'
 
 module KamalBackup
   class Scheduler
@@ -32,21 +34,22 @@ module KamalBackup
     end
 
     private
-      def install_signal_handlers
-        %w[TERM INT].each do |signal|
-          Signal.trap(signal) { @stop = true }
-        rescue ArgumentError
-          nil
-        end
-      end
 
-      def sleep_interruptibly(seconds)
-        deadline = Time.now + seconds
-        sleep([deadline - Time.now, 1].min) while !@stop && Time.now < deadline
+    def install_signal_handlers
+      %w[TERM INT].each do |signal|
+        Signal.trap(signal) { @stop = true }
+      rescue ArgumentError
+        nil
       end
+    end
 
-      def log(message)
-        $stdout.puts("[kamal-backup] #{message}")
-      end
+    def sleep_interruptibly(seconds)
+      deadline = Time.now + seconds
+      sleep([deadline - Time.now, 1].min) while !@stop && Time.now < deadline
+    end
+
+    def log(message)
+      $stdout.puts("[kamal-backup] #{message}")
+    end
   end
 end

data/lib/kamal_backup/schema.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module KamalBackup
   module Schema
     VERSION = 1

data/lib/kamal_backup/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module KamalBackup
-  VERSION = "0.3.0.beta21"
+  VERSION = '0.3.1'
 end

data/lib/kamal_backup/yaml_access.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module KamalBackup
+  # Kamal and Rails YAML configs mix string and symbol keys depending on how
+  # they were rendered, so look up both.
+  module YamlAccess
+    private
+
+    def fetch(hash, key)
+      hash[key] || hash[key.to_s] || hash[key.to_sym]
+    end
+  end
+end

data/lib/kamal_backup.rb

@@ -1,17 +1,22 @@
-require_relative "kamal_backup/version"
-require_relative "kamal_backup/schema"
-require_relative "kamal_backup/errors"
-require_relative "kamal_backup/command"
-require_relative "kamal_backup/redactor"
-require_relative "kamal_backup/config"
-require_relative "kamal_backup/rails_app"
-require_relative "kamal_backup/kamal_bridge"
-require_relative "kamal_backup/restic"
-require_relative "kamal_backup/evidence"
-require_relative "kamal_backup/scheduler"
-require_relative "kamal_backup/databases/base"
-require_relative "kamal_backup/databases/postgres"
-require_relative "kamal_backup/databases/mysql"
-require_relative "kamal_backup/databases/sqlite"
-require_relative "kamal_backup/app"
-require_relative "kamal_backup/cli"
+# frozen_string_literal: true
+
+require_relative 'kamal_backup/version'
+require_relative 'kamal_backup/schema'
+require_relative 'kamal_backup/errors'
+require_relative 'kamal_backup/yaml_access'
+require_relative 'kamal_backup/command'
+require_relative 'kamal_backup/command_output'
+require_relative 'kamal_backup/redactor'
+require_relative 'kamal_backup/config_file'
+require_relative 'kamal_backup/config'
+require_relative 'kamal_backup/rails_app'
+require_relative 'kamal_backup/kamal_bridge'
+require_relative 'kamal_backup/restic'
+require_relative 'kamal_backup/evidence'
+require_relative 'kamal_backup/scheduler'
+require_relative 'kamal_backup/databases/base'
+require_relative 'kamal_backup/databases/postgres'
+require_relative 'kamal_backup/databases/mysql'
+require_relative 'kamal_backup/databases/sqlite'
+require_relative 'kamal_backup/app'
+require_relative 'kamal_backup/cli'