kamal-backup 0.3.0.beta21 → 0.3.1

data/lib/kamal_backup/databases/postgres.rb

@@ -1,5 +1,7 @@
-require "uri"
-require_relative "base"
+# frozen_string_literal: true
+
+require 'uri'
+require_relative 'base'
 
 module KamalBackup
   module Databases
@@ -20,11 +22,11 @@ module KamalBackup
       ].freeze
 
       def adapter_name
-        "postgres"
+        'postgres'
       end
 
       def dump_extension
-        "pgdump"
+        'pgdump'
       end
 
       def dump_command
@@ -34,7 +36,7 @@ module KamalBackup
 
       def current_restore_command
         connection = current_connection
-        database = connection.fetch("PGDATABASE")
+        database = connection.fetch('PGDATABASE')
 
         argv = %w[pg_restore --clean --if-exists --no-owner --no-privileges --dbname]
         argv << database
@@ -42,7 +44,7 @@ module KamalBackup
       end
 
       def scratch_restore_command(target)
-        connection = current_connection.merge("PGDATABASE" => target)
+        connection = current_connection.merge('PGDATABASE' => target)
 
         argv = %w[pg_restore --clean --if-exists --no-owner --no-privileges --dbname]
         argv << target
@@ -50,74 +52,73 @@ module KamalBackup
       end
 
       def current_target_identifier
-        value("DATABASE_URL") || value("PGDATABASE")
+        value('DATABASE_URL') || value('PGDATABASE')
       end
 
       def scratch_target_identifier(target)
-        [current_connection["PGHOST"], target].compact.join("/")
+        [current_connection['PGHOST'], target].compact.join('/')
       end
 
       private
-        def validate_scratch_restore_target(target)
-          if current_connection.fetch("PGDATABASE") == target
-            raise ConfigurationError, "scratch database must differ from the current PostgreSQL database"
-          end
 
-          super
-        end
+      def validate_scratch_restore_target(target)
+        raise ConfigurationError, 'scratch database must differ from the current PostgreSQL database' if current_connection.fetch('PGDATABASE') == target
 
-        def current_connection
-          if value("DATABASE_URL")
-            connection_from_url(value("DATABASE_URL"), "DATABASE_URL").tap do |connection|
-              connection["PGPASSWORD"] ||= value("PGPASSWORD") if value("PGPASSWORD")
-            end
-          else
-            connection = prefixed_env("", SOURCE_ENV_KEYS)
-            raise ConfigurationError, "DATABASE_URL or PGDATABASE is required for PostgreSQL restore" unless connection["PGDATABASE"]
+        super
+      end
 
-            connection
+      def current_connection
+        if value('DATABASE_URL')
+          connection = connection_from_url(value('DATABASE_URL'), 'DATABASE_URL')
+          connection['PGPASSWORD'] ||= value('PGPASSWORD')
+          connection.compact
+        else
+          connection = prefixed_env('', SOURCE_ENV_KEYS)
+          unless connection['PGDATABASE']
+            raise ConfigurationError,
+                  'DATABASE_URL or PGDATABASE is required for PostgreSQL restore'
           end
-        end
 
-        def prefixed_env(prefix, keys)
-          keys.each_with_object({}) do |key, env|
-            env[key] = value("#{prefix}#{key}") if value("#{prefix}#{key}")
-          end
+          connection
         end
+      end
 
-        def connection_from_url(url, name)
-          uri = URI.parse(url)
-          unless %w[postgres postgresql].include?(uri.scheme)
-            raise ConfigurationError, "#{name} must use postgres:// or postgresql://"
-          end
-
-          database = URI.decode_www_form_component(uri.path.to_s.sub(%r{\A/}, ""))
-          raise ConfigurationError, "database name is missing in #{name}" if database.empty?
-
-          env = {
-            "PGHOST" => uri.host,
-            "PGPORT" => uri.port&.to_s,
-            "PGUSER" => uri.user ? URI.decode_www_form_component(uri.user) : nil,
-            "PGPASSWORD" => uri.password ? URI.decode_www_form_component(uri.password) : nil,
-            "PGDATABASE" => database
-          }.compact
-
-          query = URI.decode_www_form(uri.query.to_s).to_h
-          {
-            "sslmode" => "PGSSLMODE",
-            "sslrootcert" => "PGSSLROOTCERT",
-            "sslcert" => "PGSSLCERT",
-            "sslkey" => "PGSSLKEY",
-            "connect_timeout" => "PGCONNECT_TIMEOUT"
-          }.each do |source, target|
-            env[target] = query[source] if query[source]
-          end
+      def prefixed_env(prefix, keys)
+        keys.each_with_object({}) do |key, env|
+          env[key] = value("#{prefix}#{key}") if value("#{prefix}#{key}")
+        end
+      end
 
-          env
-        rescue URI::InvalidURIError => e
-          raise ConfigurationError, "invalid #{name}: #{e.message}"
+      def connection_from_url(url, name)
+        uri = URI.parse(url)
+        raise ConfigurationError, "#{name} must use postgres:// or postgresql://" unless %w[postgres postgresql].include?(uri.scheme)
+
+        database = URI.decode_www_form_component(uri.path.to_s.sub(%r{\A/}, ''))
+        raise ConfigurationError, "database name is missing in #{name}" if database.empty?
+
+        env = {
+          'PGHOST' => uri.host,
+          'PGPORT' => uri.port&.to_s,
+          'PGUSER' => uri.user ? URI.decode_www_form_component(uri.user) : nil,
+          'PGPASSWORD' => uri.password ? URI.decode_www_form_component(uri.password) : nil,
+          'PGDATABASE' => database
+        }.compact
+
+        query = URI.decode_www_form(uri.query.to_s).to_h
+        {
+          'sslmode' => 'PGSSLMODE',
+          'sslrootcert' => 'PGSSLROOTCERT',
+          'sslcert' => 'PGSSLCERT',
+          'sslkey' => 'PGSSLKEY',
+          'connect_timeout' => 'PGCONNECT_TIMEOUT'
+        }.each do |source, target|
+          env[target] = query[source] if query[source]
         end
 
+        env
+      rescue URI::InvalidURIError => e
+        raise ConfigurationError, "invalid #{name}: #{e.message}"
+      end
     end
   end
 end

data/lib/kamal_backup/databases/sqlite.rb

@@ -1,24 +1,26 @@
-require "fileutils"
-require "tempfile"
-require_relative "base"
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tempfile'
+require_relative 'base'
 
 module KamalBackup
   module Databases
     class Sqlite < Base
       def adapter_name
-        "sqlite"
+        'sqlite'
       end
 
       def dump_extension
-        "sqlite3"
+        'sqlite3'
       end
 
       def backup(restic)
         source = sqlite_source
-        Tempfile.create(["kamal-backup-", ".sqlite3"]) do |tempfile|
+        Tempfile.create(['kamal-backup-', '.sqlite3']) do |tempfile|
           tempfile.close
           Command.capture(
-            CommandSpec.new(argv: ["sqlite3", source, ".backup #{sqlite_literal(tempfile.path)}"]),
+            CommandSpec.new(argv: ['sqlite3', source, ".backup #{sqlite_literal(tempfile.path)}"]),
             redactor: redactor
           )
           restic.backup_file(
@@ -39,7 +41,7 @@ module KamalBackup
       end
 
       def dump_command
-        raise NotImplementedError, "SQLite backup uses .backup into a temporary file"
+        raise NotImplementedError, 'SQLite backup uses .backup into a temporary file'
       end
 
       def current_target_identifier
@@ -51,21 +53,20 @@ module KamalBackup
       end
 
       private
-        def sqlite_source
-          config.required_value("SQLITE_DATABASE_PATH")
-        end
 
-        def validate_scratch_restore_target(target)
-          if File.expand_path(sqlite_source) == File.expand_path(target)
-            raise ConfigurationError, "scratch SQLite path must differ from SQLITE_DATABASE_PATH"
-          end
+      def sqlite_source
+        config.required_value('SQLITE_DATABASE_PATH')
+      end
 
-          super
-        end
+      def validate_scratch_restore_target(target)
+        raise ConfigurationError, 'scratch SQLite path must differ from SQLITE_DATABASE_PATH' if File.expand_path(sqlite_source) == File.expand_path(target)
 
-        def sqlite_literal(value)
-          "'#{value.to_s.gsub("'", "''")}'"
-        end
+        super
+      end
+
+      def sqlite_literal(value)
+        "'#{value.to_s.gsub("'", "''")}'"
+      end
     end
   end
 end

data/lib/kamal_backup/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module KamalBackup
   class Error < StandardError; end
   class ConfigurationError < Error; end
@@ -5,7 +7,7 @@ module KamalBackup
   class CommandError < Error
     attr_reader :command, :status, :stdout, :stderr
 
-    def initialize(message, command:, status: nil, stdout: "", stderr: "")
+    def initialize(message, command:, status: nil, stdout: '', stderr: '')
       super(message)
       @command = command
       @status = status

data/lib/kamal_backup/evidence.rb

@@ -1,8 +1,10 @@
-require "json"
-require "time"
-require_relative "command"
-require_relative "schema"
-require_relative "version"
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+require_relative 'command'
+require_relative 'schema'
+require_relative 'version'
 
 module KamalBackup
   class Evidence
@@ -14,19 +16,18 @@ module KamalBackup
 
     def to_h
       Schema.record(
-        kind: "evidence",
+        kind: 'evidence',
         app_name: @config.app_name,
         generated_at: Time.now.utc.iso8601,
-        database_adapter: @config.database_adapter,
-        databases: @config.databases.map { |database| { name: database.database_name, adapter: database.database_adapter } },
+        databases: @config.databases.map do |database|
+          { name: database.database_name, adapter: database.database_adapter }
+        end,
         restic_repository: @redactor.redact_string(@config.restic_repository.to_s),
-        backup_paths: @config.backup_paths,
         paths: @config.backup_paths,
         forget_after_backup: @config.forget_after_backup?,
         retention: @config.retention,
-        latest_database_backup: latest_snapshot_summary(["type:database"]),
         latest_database_backups: latest_database_backups,
-        latest_file_backup: latest_snapshot_summary(["type:files"]),
+        latest_file_backup: latest_snapshot_summary(['type:files']),
         last_restic_check: last_check,
         last_restore_drill: last_restore_drill,
         image_version: VERSION,
@@ -39,67 +40,64 @@ module KamalBackup
     end
 
     private
-      def latest_snapshot_summary(tags)
-        snapshot = @restic.latest_snapshot(tags: tags)
 
-        if snapshot
-          {
-            id: snapshot["short_id"] || snapshot["id"],
-            time: snapshot["time"],
-            tags: snapshot["tags"]
-          }
-        end
-      rescue Error => e
-        { error: @redactor.redact_string(e.message) }
-      end
+    def latest_snapshot_summary(tags)
+      snapshot = @restic.latest_snapshot(tags: tags)
 
-      def latest_database_backups
-        @config.databases.each_with_object({}) do |database, backups|
-          backups[database.database_name] = latest_snapshot_summary([
-            "type:database",
-            "database:#{database.database_name}",
-            "adapter:#{database.database_adapter}"
-          ])
-        end
+      if snapshot
+        {
+          id: snapshot['short_id'] || snapshot['id'],
+          time: snapshot['time'],
+          tags: snapshot['tags']
+        }
       end
+    rescue Error => e
+      { error: @redactor.redact_string(e.message) }
+    end
 
-      def last_check
-        if File.file?(@config.last_check_path)
-          JSON.parse(File.read(@config.last_check_path))
-        end
-      rescue JSON::ParserError, SystemCallError => e
-        { error: @redactor.redact_string(e.message) }
+    def latest_database_backups
+      @config.databases.each_with_object({}) do |database, backups|
+        backups[database.database_name] = latest_snapshot_summary([
+                                                                    'type:database',
+                                                                    "database:#{database.database_name}",
+                                                                    "adapter:#{database.database_adapter}"
+                                                                  ])
       end
+    end
 
-      def last_restore_drill
-        if File.file?(@config.last_restore_drill_path)
-          JSON.parse(File.read(@config.last_restore_drill_path))
-        end
-      rescue JSON::ParserError, SystemCallError => e
-        { error: @redactor.redact_string(e.message) }
-      end
+    def last_check
+      JSON.parse(File.read(@config.last_check_path)) if File.file?(@config.last_check_path)
+    rescue JSON::ParserError, SystemCallError => e
+      { error: @redactor.redact_string(e.message) }
+    end
 
-      def tool_versions
-        {
-          pg_dump: version_for(["pg_dump", "--version"]),
-          pg_restore: version_for(["pg_restore", "--version"]),
-          mysql_dump: version_for(["mariadb-dump", "--version"], ["mysqldump", "--version"]),
-          mysql_client: version_for(["mariadb", "--version"], ["mysql", "--version"]),
-          sqlite3: version_for(["sqlite3", "--version"]),
-          restic: version_for(["restic", "version"])
-        }
-      end
+    def last_restore_drill
+      JSON.parse(File.read(@config.last_restore_drill_path)) if File.file?(@config.last_restore_drill_path)
+    rescue JSON::ParserError, SystemCallError => e
+      { error: @redactor.redact_string(e.message) }
+    end
 
-      def version_for(*commands)
-        commands.each do |argv|
-          result = Command.capture(CommandSpec.new(argv: argv), redactor: @redactor)
-          output = result.stdout.empty? ? result.stderr : result.stdout
-          return @redactor.redact_string(output.strip)
-        rescue CommandError
-          next
-        end
+    def tool_versions
+      {
+        pg_dump: version_for(['pg_dump', '--version']),
+        pg_restore: version_for(['pg_restore', '--version']),
+        mysql_dump: version_for(['mariadb-dump', '--version'], ['mysqldump', '--version']),
+        mysql_client: version_for(['mariadb', '--version'], ['mysql', '--version']),
+        sqlite3: version_for(['sqlite3', '--version']),
+        restic: version_for(%w[restic version])
+      }
+    end
 
-        "unavailable"
+    def version_for(*commands)
+      commands.each do |argv|
+        result = Command.capture(CommandSpec.new(argv: argv), redactor: @redactor)
+        output = result.stdout.empty? ? result.stderr : result.stdout
+        return @redactor.redact_string(output.strip)
+      rescue CommandError
+        next
       end
+
+      'unavailable'
+    end
   end
 end