kamal-backup 0.3.0.beta21 → 0.3.0

data/lib/kamal_backup/databases/base.rb

@@ -1,16 +1,18 @@
-require_relative "../command"
-require_relative "../errors"
+# frozen_string_literal: true
+
+require_relative '../command'
+require_relative '../errors'
 
 module KamalBackup
   module Databases
     class Base
       def self.build(config, redactor:)
         case config.database_adapter
-        when "postgres"
+        when 'postgres'
           Postgres.new(config, redactor: redactor)
-        when "mysql"
+        when 'mysql'
           Mysql.new(config, redactor: redactor)
-        when "sqlite"
+        when 'sqlite'
           Sqlite.new(config, redactor: redactor)
         else
           raise ConfigurationError, "unsupported DATABASE_ADAPTER: #{config.database_adapter.inspect}"
@@ -42,13 +44,13 @@ module KamalBackup
       end
 
       def database_filename
-        app = config.app_name.gsub(/[^A-Za-z0-9_.-]+/, "-")
-        database = config.database_name.gsub(/[^A-Za-z0-9_.-]+/, "-")
+        app = config.app_name.gsub(/[^A-Za-z0-9_.-]+/, '-')
+        database = config.database_name.gsub(/[^A-Za-z0-9_.-]+/, '-')
         "databases/#{app}/#{database}/#{adapter_name}.#{dump_extension}"
       end
 
       def backup_tags
-        ["type:database", "database:#{config.database_name}", "adapter:#{adapter_name}"]
+        ['type:database', "database:#{config.database_name}", "adapter:#{adapter_name}"]
       end
 
       def adapter_name
@@ -84,13 +86,14 @@ module KamalBackup
       end
 
       private
-        def value(key)
-          config.value(key)
-        end
 
-        def executable_available?(name)
-          Command.available?(name)
-        end
+      def value(key)
+        config.value(key)
+      end
+
+      def executable_available?(name)
+        Command.available?(name)
+      end
     end
   end
 end

data/lib/kamal_backup/databases/mysql.rb

@@ -1,26 +1,28 @@
-require "uri"
-require_relative "base"
+# frozen_string_literal: true
+
+require 'uri'
+require_relative 'base'
 
 module KamalBackup
   module Databases
     class Mysql < Base
       def adapter_name
-        "mysql"
+        'mysql'
       end
 
       def dump_extension
-        "sql"
+        'sql'
       end
 
       def dump_command
         connection = current_connection
         argv = [
           dump_binary,
-          "--single-transaction",
-          "--quick",
-          "--routines",
-          "--triggers",
-          "--events"
+          '--single-transaction',
+          '--quick',
+          '--routines',
+          '--triggers',
+          '--events'
         ] + connection_args(connection)
         argv << connection.fetch(:database)
         CommandSpec.new(argv: argv, env: password_env(connection))
@@ -42,80 +44,79 @@ module KamalBackup
 
       def current_target_identifier
         connection = current_connection
-        [connection[:host], connection[:database]].compact.join("/")
+        [connection[:host], connection[:database]].compact.join('/')
       end
 
       def scratch_target_identifier(target)
-        [current_connection[:host], target].compact.join("/")
+        [current_connection[:host], target].compact.join('/')
       end
 
       private
-        def validate_scratch_restore_target(target)
-          if current_connection.fetch(:database) == target
-            raise ConfigurationError, "scratch database must differ from the current MySQL database"
-          end
 
-          super
-        end
+      def validate_scratch_restore_target(target)
+        raise ConfigurationError, 'scratch database must differ from the current MySQL database' if current_connection.fetch(:database) == target
 
-        def dump_binary
-          value("MYSQL_DUMP_BIN") || (executable_available?("mariadb-dump") ? "mariadb-dump" : "mysqldump")
-        end
+        super
+      end
 
-        def client_binary
-          value("MYSQL_CLIENT_BIN") || (executable_available?("mariadb") ? "mariadb" : "mysql")
-        end
+      def dump_binary
+        value('MYSQL_DUMP_BIN') || (executable_available?('mariadb-dump') ? 'mariadb-dump' : 'mysqldump')
+      end
+
+      def client_binary
+        value('MYSQL_CLIENT_BIN') || (executable_available?('mariadb') ? 'mariadb' : 'mysql')
+      end
 
-        def current_connection
-          if value("DATABASE_URL")
-            parse_url(value("DATABASE_URL")).tap do |connection|
-              connection[:password] ||= value("MYSQL_PWD") || value("MYSQL_PASSWORD") || value("MARIADB_PASSWORD")
-            end
-          else
-            connection_from_env("")
+      def current_connection
+        if value('DATABASE_URL')
+          parse_url(value('DATABASE_URL')).tap do |connection|
+            connection[:password] ||= value('MYSQL_PWD') || value('MYSQL_PASSWORD') || value('MARIADB_PASSWORD')
           end
+        else
+          connection_from_env('')
         end
+      end
 
-        def connection_from_env(prefix)
-          database = value("#{prefix}MYSQL_DATABASE") || value("#{prefix}MARIADB_DATABASE")
-          raise ConfigurationError, "#{prefix}MYSQL_DATABASE or #{prefix}MARIADB_DATABASE is required" unless database
-
-          {
-            host: value("#{prefix}MYSQL_HOST") || value("#{prefix}MARIADB_HOST"),
-            port: value("#{prefix}MYSQL_PORT") || value("#{prefix}MARIADB_PORT"),
-            user: value("#{prefix}MYSQL_USER") || value("#{prefix}MARIADB_USER"),
-            password: value("#{prefix}MYSQL_PWD") || value("#{prefix}MYSQL_PASSWORD") || value("#{prefix}MARIADB_PASSWORD"),
-            database: database
-          }
-        end
+      def connection_from_env(prefix)
+        database = value("#{prefix}MYSQL_DATABASE") || value("#{prefix}MARIADB_DATABASE")
+        raise ConfigurationError, "#{prefix}MYSQL_DATABASE or #{prefix}MARIADB_DATABASE is required" unless database
+
+        {
+          host: value("#{prefix}MYSQL_HOST") || value("#{prefix}MARIADB_HOST"),
+          port: value("#{prefix}MYSQL_PORT") || value("#{prefix}MARIADB_PORT"),
+          user: value("#{prefix}MYSQL_USER") || value("#{prefix}MARIADB_USER"),
+          password: value("#{prefix}MYSQL_PWD") || value("#{prefix}MYSQL_PASSWORD") || value("#{prefix}MARIADB_PASSWORD"),
+          database: database
+        }
+      end
 
-        def parse_url(url)
-          uri = URI.parse(url)
-          database = uri.path.to_s.sub(%r{\A/}, "")
-          raise ConfigurationError, "database name is missing in #{uri.scheme} DATABASE_URL" if database.empty?
-
-          {
-            host: uri.host,
-            port: uri.port,
-            user: uri.user ? URI.decode_www_form_component(uri.user) : nil,
-            password: uri.password ? URI.decode_www_form_component(uri.password) : nil,
-            database: URI.decode_www_form_component(database)
-          }
-        rescue URI::InvalidURIError => e
-          raise ConfigurationError, "invalid database URL: #{e.message}"
-        end
+      def parse_url(url)
+        uri = URI.parse(url)
+        database = uri.path.to_s.sub(%r{\A/}, '')
+        raise ConfigurationError, "database name is missing in #{uri.scheme} DATABASE_URL" if database.empty?
+
+        {
+          host: uri.host,
+          port: uri.port,
+          user: uri.user ? URI.decode_www_form_component(uri.user) : nil,
+          password: uri.password ? URI.decode_www_form_component(uri.password) : nil,
+          database: URI.decode_www_form_component(database)
+        }
+      rescue URI::InvalidURIError => e
+        raise ConfigurationError, "invalid database URL: #{e.message}"
+      end
 
-        def connection_args(connection)
-          args = []
-          args.concat(["--host", connection[:host]]) if connection[:host]
-          args.concat(["--port", connection[:port].to_s]) if connection[:port]
-          args.concat(["--user", connection[:user]]) if connection[:user]
-          args
-        end
+      def connection_args(connection)
+        args = []
+        args.concat(['--host', connection[:host]]) if connection[:host]
+        args.concat(['--port', connection[:port].to_s]) if connection[:port]
+        args.concat(['--user', connection[:user]]) if connection[:user]
+        args
+      end
 
-        def password_env(connection)
-          connection[:password] ? { "MYSQL_PWD" => connection[:password] } : {}
-        end
+      def password_env(connection)
+        connection[:password] ? { 'MYSQL_PWD' => connection[:password] } : {}
+      end
     end
   end
 end

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_from_url(value('DATABASE_URL'), 'DATABASE_URL').tap do |connection|
+            connection['PGPASSWORD'] ||= value('PGPASSWORD') if value('PGPASSWORD')
           end
-        end
-
-        def prefixed_env(prefix, keys)
-          keys.each_with_object({}) do |key, env|
-            env[key] = value("#{prefix}#{key}") if value("#{prefix}#{key}")
+        else
+          connection = prefixed_env('', SOURCE_ENV_KEYS)
+          unless connection['PGDATABASE']
+            raise ConfigurationError,
+                  'DATABASE_URL or PGDATABASE is required for PostgreSQL restore'
           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
+          connection
+        end
+      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,21 @@ 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_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 +43,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