kamal-backup 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13bcc6ed2c0eefd5883e432c6a71b760df37ee20cf4b4d1ca87252c8fd22d9f0
-  data.tar.gz: b1fd3699bee9882492e7889054ef282c99ec18d8dbe74d224ada437b0f055794
+  metadata.gz: 801ab5f224e1e018805b65650da3c0946d6c785eb8b2a3e3e3256bcf97649abb
+  data.tar.gz: 60e98bfe053103b3405d483902a167ee2d86f7a723448e06eacb2937b56fd4d3
 SHA512:
-  metadata.gz: 191e6b31b9688ec807ba6f85ea8fe89bbda5c383248e7c307cc4ef863fab3eccd427add8bb230540cb449d22791756b32e98e0cda0f001f662bcbb67dc0c9973
-  data.tar.gz: e7569830ce203f34695c71f2d05338d8a32eeed3627010608714f1a4dae77301eb56d289aa7dee8b8fa497eaf4531ff4acc15114c7693d5f897b544a4e715fbb
+  metadata.gz: b1dbd9a03222917490629d56a4bfca69e1abbac79ed241bf480ba0da50453e67e1224dcf5f6d315ce23039b31febe2d449300dae167ddf19e627decd07c6116e
+  data.tar.gz: c4392a6048ceea5ec81b20cedad84f15d864ecb37a83337571cc857de8c730c0a84629df335e9b6c4f273868ad86a6ddcc631c00315ff8ff965ac0230bcf1f5a

data/README.md

@@ -8,6 +8,7 @@
 
 [![Gem Version](https://img.shields.io/gem/v/kamal-backup.svg)](https://rubygems.org/gems/kamal-backup)
 [![CI](https://github.com/crmne/kamal-backup/actions/workflows/ci.yml/badge.svg)](https://github.com/crmne/kamal-backup/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/crmne/kamal-backup/branch/master/graph/badge.svg)](https://codecov.io/gh/crmne/kamal-backup)
 [![Docker Image](https://img.shields.io/badge/image-ghcr.io%2Fcrmne%2Fkamal--backup-blue)](https://github.com/crmne/kamal-backup/pkgs/container/kamal-backup)
 [![Docs](https://img.shields.io/badge/docs-kamal--backup.dev-blue)](https://kamal-backup.dev)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)

data/lib/kamal_backup/app.rb

@@ -22,14 +22,11 @@ module KamalBackup
 
     attr_reader :config, :redactor
 
-    def initialize(env: ENV, config: nil, redactor: nil, restic: nil, database: nil, evidence_class: Evidence,
-                   scheduler_class: Scheduler)
+    def initialize(env: ENV, config: nil, redactor: nil, restic: nil, database: nil)
       @config = config || Config.new(env: env)
       @redactor = redactor || Redactor.new(env: @config.env)
       @restic = restic
       @database = database
-      @evidence_class = evidence_class
-      @scheduler_class = scheduler_class
     end
 
     def backup(force: false)
@@ -37,13 +34,11 @@ module KamalBackup
       config.validate_backup
       return skipped_backup_result(started_at) unless force || backup_due?(started_at)
 
-      require_restic!
-
       restic.ensure_repository
       databases.each { |database| database.backup(restic) }
       restic.backup_paths(config.backup_paths, tags: ['type:files'])
 
-      restic.forget_after_success if config.forget_after_backup?
+      restic.prune if config.forget_after_backup?
 
       restic.check if config.check_after_backup?
 
@@ -60,46 +55,39 @@ module KamalBackup
 
     def restore_to_local_machine(snapshot = 'latest')
       validate_local_machine_restore
-      require_restic!
 
       build_restore_result('local', snapshot) do |result|
         databases.each { |adapter| validate_local_machine_database_target(adapter) }
-        database_results = perform_database_restores_to_current(snapshot)
-        file_results = perform_replacement_file_restores(snapshot, production_source: false)
-        assign_restore_results(result, database_results, file_results)
+        result[:databases] = perform_database_restores_to_current(snapshot)
+        result[:files] = perform_replacement_file_restore(snapshot, production_source: false)
       end
     end
 
     def restore_to_production(snapshot = 'latest')
       validate_production_restore
-      require_restic!
 
       build_restore_result('production', snapshot) do |result|
-        database_results = perform_database_restores_to_current(snapshot)
-        file_results = perform_replacement_file_restores(snapshot, production_source: true)
-        assign_restore_results(result, database_results, file_results)
+        result[:databases] = perform_database_restores_to_current(snapshot)
+        result[:files] = perform_replacement_file_restore(snapshot, production_source: true)
       end
     end
 
     def drill_on_local_machine(snapshot = 'latest', check_command: nil)
       validate_local_machine_restore
-      require_restic!
 
       run_drill('local', snapshot, check_command: check_command) do |result|
         databases.each { |adapter| validate_local_machine_database_target(adapter) }
-        database_results = perform_database_restores_to_current(snapshot)
-        file_results = perform_replacement_file_restores(snapshot, production_source: false)
-        assign_restore_results(result, database_results, file_results)
+        result[:databases] = perform_database_restores_to_current(snapshot)
+        result[:files] = perform_replacement_file_restore(snapshot, production_source: false)
       end
     end
 
     def drill_on_production(snapshot = 'latest', database_name: nil, sqlite_path: nil, file_target: '/restore/files',
                             check_command: nil)
       validate_production_drill(file_target, database_name, sqlite_path)
-      require_restic!
 
       run_drill('production', snapshot, check_command: check_command) do |result|
-        database_results = databases.map do |adapter|
+        result[:databases] = databases.map do |adapter|
           perform_database_restore_to_scratch(
             snapshot,
             adapter: adapter,
@@ -107,44 +95,33 @@ module KamalBackup
             sqlite_path: sqlite_path
           )
         end
-        file_results = [perform_file_restore(snapshot, target: file_target)]
-        assign_restore_results(result, database_results, file_results)
+        result[:files] = perform_file_restore(snapshot, target: file_target)
       end
     end
 
-    def drill_failed?(result)
-      result.fetch(:status) != 'ok'
-    rescue KeyError
-      true
-    end
-
     def snapshots
       config.validate_restic
-      require_restic!
       restic.snapshots.stdout
     end
 
     def check
       config.validate_restic
-      require_restic!
       restic.check.stdout
     end
 
     def prune
       config.validate_backup(check_files: false)
-      require_restic!
       restic.prune
     end
 
     def evidence
       config.validate_restic
-      require_restic!
-      @evidence_class.new(config, restic: restic, redactor: redactor).to_json
+      Evidence.new(config, restic: restic, redactor: redactor).to_json
     end
 
     def schedule
       config.validate_backup
-      @scheduler_class.new(config) { backup(force: true) }.run
+      Scheduler.new(config) { backup(force: true) }.run
     end
 
     private
@@ -155,7 +132,7 @@ module KamalBackup
     end
 
     def skipped_backup_result(now)
-      {
+      Schema.record(
         kind: 'backup_result',
         status: 'skipped',
         reason: 'not_due',
@@ -163,7 +140,7 @@ module KamalBackup
         next_backup_at: next_backup_at&.iso8601,
         force_command: 'kamal-backup backup --force',
         finished_at: now.iso8601
-      }
+      )
     end
 
     def next_backup_at
@@ -172,7 +149,7 @@ module KamalBackup
 
     def last_backup_finished_at
       @last_backup_finished_at ||= begin
-        value = last_backup_record['finished_at'] || last_backup_record['last_backup_at']
+        value = last_backup_record['finished_at']
         value ? Time.parse(value.to_s).utc : nil
       rescue ArgumentError
         nil
@@ -187,6 +164,68 @@ module KamalBackup
       end
     end
 
+    def backup_summary(started_at:, finished_at:)
+      Schema.record(
+        kind: 'backup_result',
+        status: 'ok',
+        started_at: started_at.iso8601,
+        finished_at: finished_at.iso8601,
+        databases: databases.map { |adapter| backup_snapshot_summary(adapter) },
+        files: backup_file_snapshot_summary
+      )
+    end
+
+    def backup_snapshot_summary(adapter)
+      snapshot = restic.latest_snapshot(tags: database_snapshot_tags(adapter))
+      snapshot_summary(snapshot).merge(
+        database: database_config_name(adapter),
+        adapter: adapter.adapter_name
+      )
+    end
+
+    def backup_file_snapshot_summary
+      return nil if config.backup_paths.empty?
+
+      snapshot_summary(restic.latest_snapshot(tags: ['type:files']))
+    end
+
+    def snapshot_summary(snapshot)
+      {
+        snapshot: snapshot && (snapshot['short_id'] || snapshot['id']),
+        time: snapshot && snapshot['time']
+      }
+    end
+
+    def validate_fresh_backup_summary!(summary, started_at:)
+      stale_databases = summary.fetch(:databases).reject { |entry| fresh_snapshot?(entry, started_at) }
+
+      unless stale_databases.empty?
+        names = stale_databases.map { |entry| entry.fetch(:database) }.join(', ')
+        raise ConfigurationError, "backup did not create a fresh database snapshot for #{names}"
+      end
+
+      files = summary[:files]
+      return unless files && !fresh_snapshot?(files, started_at)
+
+      raise ConfigurationError, 'backup did not create a fresh file snapshot'
+    end
+
+    def fresh_snapshot?(entry, started_at)
+      snapshot_time = Time.parse(entry[:time].to_s)
+      snapshot_time >= started_at - FRESH_BACKUP_GRACE_SECONDS
+    rescue ArgumentError
+      false
+    end
+
+    def write_last_backup(result)
+      FileUtils.mkdir_p(config.state_dir)
+      File.write(config.last_backup_path, JSON.pretty_generate(result))
+      @last_backup_record = result.transform_keys(&:to_s)
+      @last_backup_finished_at = Time.parse(result.fetch(:finished_at)).utc
+    rescue SystemCallError, ArgumentError
+      nil
+    end
+
     def build_restore_result(scope, snapshot)
       started_at = Time.now.utc
       result = Schema.record(
@@ -197,10 +236,8 @@ module KamalBackup
         started_at: started_at.iso8601,
         finished_at: nil,
         error: nil,
-        database: nil,
         databases: [],
-        files: nil,
-        paths: nil
+        files: nil
       )
       yield(result)
       result[:finished_at] = Time.now.utc.iso8601
@@ -218,10 +255,8 @@ module KamalBackup
         started_at: started_at.iso8601,
         finished_at: nil,
         error: nil,
-        database: nil,
         databases: [],
         files: nil,
-        paths: nil,
         check: nil
       )
 
@@ -247,6 +282,41 @@ module KamalBackup
       result
     end
 
+    def drill_operator
+      config.value('USER') || config.value('USERNAME')
+    end
+
+    def run_drill_check(command)
+      result = Command.capture(
+        CommandSpec.new(argv: ['sh', '-lc', command]),
+        redactor: redactor
+      )
+      output = result.stdout.empty? ? result.stderr : result.stdout
+
+      {
+        status: 'ok',
+        command: redactor.redact_string(command),
+        output: redactor.redact_string(output.strip)
+      }
+    rescue CommandError => e
+      {
+        status: 'failed',
+        command: redactor.redact_string(command),
+        error: redactor.redact_string(e.message)
+      }
+    end
+
+    def write_last_restore_drill(payload)
+      FileUtils.mkdir_p(config.state_dir)
+      File.write(config.last_restore_drill_path, JSON.pretty_generate(payload))
+    rescue SystemCallError
+      nil
+    end
+
+    def perform_database_restores_to_current(snapshot)
+      databases.map { |adapter| perform_database_restore_to_current(snapshot, adapter: adapter) }
+    end
+
     def perform_database_restore_to_current(snapshot, adapter:)
       resolved_snapshot = resolve_snapshot(snapshot, tags: database_snapshot_tags(adapter))
       filename = restic.database_file(resolved_snapshot, adapter.adapter_name,
@@ -270,114 +340,37 @@ module KamalBackup
       summarize_database_restore(adapter, resolved_snapshot, filename, adapter.scratch_target_identifier(target))
     end
 
-    def perform_database_restores_to_current(snapshot)
-      databases.map { |adapter| perform_database_restore_to_current(snapshot, adapter: adapter) }
-    end
-
-    def perform_replacement_file_restores(snapshot, production_source:)
-      source_paths = production_source ? config.backup_paths : config.local_restore_source_paths
-      [
-        perform_replacement_file_restore(
-          snapshot,
-          source_paths: source_paths,
-          target_paths: config.backup_paths
-        )
-      ]
-    end
-
-    def assign_restore_results(result, database_results, file_results)
-      result[:databases] = database_results
-      result[:database] = database_results.first
-      result[:paths] = file_results.first
-      result[:files] = file_results.size == 1 ? file_results.first : file_results
-    end
-
-    def backup_summary(started_at:, finished_at:)
-      {
-        kind: 'backup_result',
-        status: 'ok',
-        started_at: started_at.iso8601,
-        finished_at: finished_at.iso8601,
-        databases: databases.map { |adapter| backup_snapshot_summary(adapter) },
-        files: backup_file_snapshot_summary
-      }
-    end
-
-    def backup_snapshot_summary(adapter)
-      snapshot = restic.latest_snapshot(tags: database_snapshot_tags(adapter))
-      snapshot_summary(snapshot).merge(
-        database: database_config_name(adapter),
-        adapter: adapter.adapter_name
-      )
-    end
-
-    def backup_file_snapshot_summary
-      return nil if config.backup_paths.empty?
-
-      snapshot_summary(restic.latest_snapshot(tags: ['type:files']))
+    def scratch_database_target(adapter, database_name, sqlite_path)
+      case adapter.adapter_name
+      when 'sqlite'
+        target = sqlite_path || raise(ConfigurationError, 'scratch SQLite path is required')
+        databases.size > 1 ? File.join(target, "#{database_config_name(adapter)}.sqlite3") : target
+      else
+        target = database_name || raise(ConfigurationError, 'scratch database name is required')
+        databases.size > 1 ? "#{target}_#{database_config_name(adapter)}" : target
+      end
     end
 
-    def snapshot_summary(snapshot)
+    def summarize_database_restore(adapter, snapshot, filename, target)
       {
-        snapshot: snapshot && (snapshot['short_id'] || snapshot['id']),
-        time: snapshot && snapshot['time']
+        snapshot: snapshot,
+        adapter: adapter.adapter_name,
+        filename: filename,
+        target: redactor.redact_string(target.to_s)
       }
     end
 
-    def validate_fresh_backup_summary!(summary, started_at:)
-      stale_databases = summary.fetch(:databases).reject { |entry| fresh_snapshot?(entry, started_at) }
-
-      unless stale_databases.empty?
-        names = stale_databases.map { |entry| entry.fetch(:database) }.join(', ')
-        raise ConfigurationError, "backup did not create a fresh database snapshot for #{names}"
-      end
-
-      files = summary[:files]
-      return unless files && !fresh_snapshot?(files, started_at)
-
-      raise ConfigurationError, 'backup did not create a fresh file snapshot'
-    end
-
-    def fresh_snapshot?(entry, started_at)
-      snapshot_time = Time.parse(entry[:time].to_s)
-      snapshot_time >= started_at - FRESH_BACKUP_GRACE_SECONDS
-    rescue ArgumentError
-      false
-    end
-
-    def write_last_backup(result)
-      FileUtils.mkdir_p(config.state_dir)
-      File.write(config.last_backup_path, JSON.pretty_generate(result))
-      @last_backup_record = result.transform_keys(&:to_s)
-      @last_backup_finished_at = Time.parse(result.fetch(:finished_at)).utc
-    rescue SystemCallError, ArgumentError
-      nil
-    end
-
     def database_snapshot_tags(adapter)
       ['type:database', "database:#{database_config_name(adapter)}", "adapter:#{adapter.adapter_name}"]
     end
 
     def database_config_name(adapter)
-      if adapter.respond_to?(:config) && adapter.config.respond_to?(:database_name)
-        adapter.config.database_name
-      else
-        config.database_name
-      end
-    end
-
-    def perform_file_restore(snapshot, target:)
-      resolved_snapshot = resolve_snapshot(snapshot, tags: ['type:files'])
-      validated_target = config.validate_file_restore_target(target)
-      restic.restore_snapshot(resolved_snapshot, validated_target)
-
-      {
-        snapshot: resolved_snapshot,
-        target: validated_target
-      }
+      adapter.config.database_name
     end
 
-    def perform_replacement_file_restore(snapshot, source_paths:, target_paths:)
+    def perform_replacement_file_restore(snapshot, production_source:)
+      source_paths = production_source ? config.backup_paths : config.local_restore_source_paths
+      target_paths = config.backup_paths
       resolved_snapshot = resolve_snapshot(snapshot, tags: ['type:files'])
       Dir.mktmpdir('kamal-backup-restore-') do |stage_dir|
         restic.restore_snapshot(resolved_snapshot, stage_dir)
@@ -412,26 +405,17 @@ module KamalBackup
       File.join(stage_dir, path.to_s.sub(%r{\A/+}, ''))
     end
 
-    def summarize_database_restore(adapter, snapshot, filename, target)
+    def perform_file_restore(snapshot, target:)
+      resolved_snapshot = resolve_snapshot(snapshot, tags: ['type:files'])
+      validated_target = config.validate_file_restore_target(target)
+      restic.restore_snapshot(resolved_snapshot, validated_target)
+
       {
-        snapshot: snapshot,
-        adapter: adapter.adapter_name,
-        filename: filename,
-        target: redactor.redact_string(target.to_s)
+        snapshot: resolved_snapshot,
+        target: validated_target
       }
     end
 
-    def scratch_database_target(adapter, database_name, sqlite_path)
-      case adapter.adapter_name
-      when 'sqlite'
-        target = sqlite_path || raise(ConfigurationError, 'scratch SQLite path is required')
-        databases.size > 1 ? File.join(target, "#{database_config_name(adapter)}.sqlite3") : target
-      else
-        target = database_name || raise(ConfigurationError, 'scratch database name is required')
-        databases.size > 1 ? "#{target}_#{database_config_name(adapter)}" : target
-      end
-    end
-
     def validate_local_machine_restore
       config.validate_restic
       config.validate_database_backup
@@ -463,55 +447,15 @@ module KamalBackup
       config.validate_local_database_restore_target(adapter.current_target_identifier)
     end
 
-    def require_restic!
-      return unless using_builtin_restic?
-      return if Command.available?('restic')
-
-      raise ConfigurationError,
-            'restic is required on PATH for commands that run on this machine. Install restic locally and try again.'
-    end
-
-    def run_drill_check(command)
-      result = Command.capture(
-        CommandSpec.new(argv: ['sh', '-lc', command]),
-        redactor: redactor
-      )
-      output = result.stdout.empty? ? result.stderr : result.stdout
-
-      {
-        status: 'ok',
-        command: redactor.redact_string(command),
-        output: redactor.redact_string(output.strip)
-      }
-    rescue CommandError => e
-      {
-        status: 'failed',
-        command: redactor.redact_string(command),
-        error: redactor.redact_string(e.message)
-      }
-    end
-
-    def write_last_restore_drill(payload)
-      FileUtils.mkdir_p(config.state_dir)
-      File.write(config.last_restore_drill_path, JSON.pretty_generate(payload))
-    rescue SystemCallError
-      nil
-    end
-
-    def drill_operator
-      config.value('USER') || config.value('USERNAME')
-    end
-
     def restic
-      @restic ||= Restic.new(config, redactor: redactor)
-    end
-
-    def using_builtin_restic?
-      @restic.nil? || @restic.is_a?(Restic)
-    end
+      @restic ||= begin
+        unless Command.available?('restic')
+          raise ConfigurationError,
+                'restic is required on PATH for commands that run on this machine. Install restic locally and try again.'
+        end
 
-    def database
-      databases.first
+        Restic.new(config, redactor: redactor)
+      end
     end
 
     def databases
@@ -529,7 +473,6 @@ module KamalBackup
         raise ConfigurationError, "no restic snapshot found for #{tags.join(', ')}" unless snapshot
 
         snapshot['short_id'] || snapshot['id']
-
       else
         argument
       end