pg_export 1.0.0.rc4 → 1.0.0.rc8

data/lib/pg_export/operations/decrypt_dump.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'pg_export'
+require 'pg_export/value_objects/result'
+
+class PgExport
+  module Operations
+    class DecryptDump
+      def initialize(cipher_factory:)
+        @cipher_factory = cipher_factory
+      end
+
+      def name
+        :decrypt_dump
+      end
+
+      def call(dump:)
+        dump.decrypt(cipher_factory: cipher_factory)
+
+        ValueObjects::Success.new(dump: dump)
+      rescue OpenSSL::Cipher::CipherError => e
+        ValueObjects::Failure.new(message: "Problem decrypting dump file: #{e}. Try again.")
+      end
+
+      private
+
+      attr_reader :cipher_factory
+    end
+  end
+end

data/lib/pg_export/operations/encrypt_dump.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'pg_export/value_objects/result'
+
+class PgExport
+  module Operations
+    class EncryptDump
+      def initialize(cipher_factory:)
+        @cipher_factory = cipher_factory
+      end
+
+      def name
+        :encrypt_dump
+      end
+
+      def call(dump:)
+        dump.encrypt(cipher_factory: cipher_factory)
+
+        ValueObjects::Success.new(dump: dump)
+      end
+
+      private
+
+      attr_reader :cipher_factory
+    end
+  end
+end

data/lib/pg_export/operations/open_connection.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'pg_export/value_objects/result'
+
+class PgExport
+  module Operations
+    class OpenConnection
+      def initialize(gateway_factory:)
+        @gateway_factory = gateway_factory
+      end
+
+      def name
+        :open_connection
+      end
+
+      def call(inputs)
+        gateway = gateway_factory.gateway
+        gateway.open
+
+        ValueObjects::Success.new(inputs.merge(gateway: gateway))
+      end
+
+      private
+
+      attr_reader :gateway_factory
+    end
+  end
+end

data/lib/pg_export/operations/remove_old_dumps.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'pg_export/value_objects/result'
+
+class PgExport
+  module Operations
+    class RemoveOldDumps
+      def initialize(gateway_dump_repository:, keep:)
+        @gateway_dump_repository, @keep = gateway_dump_repository, keep
+      end
+
+      def name
+        :remove_old_dumps
+      end
+
+      def call(dump:, gateway:)
+        dumps = gateway_dump_repository.by_database_name(
+          database_name: dump.database,
+          gateway: gateway,
+          offset: keep
+        )
+        dumps.each do |d|
+          gateway.delete(d.name)
+        end
+
+        ValueObjects::Success.new(removed_dumps: dumps, gateway: gateway)
+      end
+
+      private
+
+      attr_reader :gateway_dump_repository, :keep
+    end
+  end
+end

data/lib/pg_export/{lib/pg_export/repositories → repositories}/gateway_dump_repository.rb

@@ -1,20 +1,15 @@
 # frozen_string_literal: true
 
 require 'open3'
-require 'pg_export/import'
-require 'pg_export/lib/pg_export/entities/dump'
-require 'pg_export/lib/pg_export/value_objects/dump_file'
+require 'pg_export/entities/dump'
+require 'pg_export/value_objects/dump_file'
 
 class PgExport
   module Repositories
     class GatewayDumpRepository
       def all(database_name:, gateway:)
         gateway.list(database_name).map do |item|
-          begin
-            dump(item[:name], database_name, item[:size])
-          rescue Dry::Types::ConstraintError
-            nil
-          end
+          dump(item[:name], database_name, item[:size])
         end.compact
       end
 
@@ -22,7 +17,7 @@ class PgExport
         gateway.list(database_name).drop(offset).map do |item|
           begin
             dump(item[:name], database_name, item[:size])
-          rescue Dry::Types::ConstraintError
+          rescue ArgumentError
             nil
           end
         end.compact

data/lib/pg_export/transactions/evaluator.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class PgExport
+  module Transactions
+    class Evaluator
+      def initialize(listeners)
+        @operations = []
+        @listeners = listeners
+      end
+
+      def <<(operation)
+        operations << operation
+      end
+
+      def call(input)
+        result = ValueObjects::Success.new(input)
+
+        operations.each do |operation|
+          result = result.bind do
+            call_operation(operation, result)
+          end
+        end
+
+        result
+      end
+
+      private
+
+      attr_reader :operations, :listeners
+
+      def call_operation(operation, input)
+        listener = listeners[operation.name]
+
+        before_call(listener, input)
+        result = operation.call(**input.value)
+        after_call(listener, result)
+        result
+      end
+
+      def before_call(listener, input)
+        return if listener.nil?
+
+        listener.on_step(value: input.value)
+      end
+
+      def after_call(listener, result)
+        return if listener.nil?
+
+        result.on_success do
+          listener.on_step_succeeded(value: result.value)
+        end
+
+        result.on_failure do
+          listener.on_step_failed(value: result.value)
+        end
+      end
+    end
+  end
+end

data/lib/pg_export/transactions/export_dump.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'pg_export/transactions/evaluator'
+require 'pg_export/value_objects/dump_file'
+require 'pg_export/adapters/shell_adapter'
+require 'pg_export/value_objects/result'
+
+class PgExport
+  module Transactions
+    class ExportDump
+      def initialize(dump_factory:, shell_adapter:, encrypt_dump:, open_connection:, remove_old_dumps:, listeners:)
+        @dump_factory = dump_factory
+        @shell_adapter = shell_adapter
+
+        @evaluator = Evaluator.new(listeners)
+        @evaluator << method(:prepare_params)
+        @evaluator << method(:build_dump)
+        @evaluator << encrypt_dump
+        @evaluator << open_connection
+        @evaluator << method(:upload_dump)
+        @evaluator << remove_old_dumps
+        @evaluator << method(:close_connection)
+      end
+
+      def call(input)
+        evaluator.call(input)
+      end
+
+      private
+
+      attr_reader :evaluator, :dump_factory, :shell_adapter
+
+      def prepare_params(database_name:)
+        database_name = database_name.to_s
+
+        return ValueObjects::Failure.new(message: 'Invalid database name') if database_name.empty?
+
+        ValueObjects::Success.new(database_name: database_name)
+      end
+
+      def build_dump(database_name:)
+        dump = dump_factory.plain(
+          database: database_name,
+          file: shell_adapter.pg_dump(ValueObjects::DumpFile.new, database_name)
+        )
+        ValueObjects::Success.new(dump: dump)
+      rescue Adapters::ShellAdapter::PgDumpError => e
+        ValueObjects::Failure.new(message: 'Unable to dump database: ' + e.to_s)
+      end
+
+      def upload_dump(dump:, gateway:)
+        gateway.persist(dump.file, dump.name)
+        ValueObjects::Success.new(dump: dump, gateway: gateway)
+      end
+
+      def close_connection(removed_dumps:, gateway:)
+        gateway.close
+        ValueObjects::Success.new
+      end
+    end
+  end
+end

data/lib/pg_export/transactions/import_dump_interactively.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'pg_export/transactions/evaluator'
+require 'pg_export/adapters/shell_adapter'
+require 'pg_export/value_objects/result'
+
+class PgExport
+  module Transactions
+    class ImportDumpInteractively
+      def initialize(
+        input:,
+        shell_adapter:,
+        gateway_dump_repository:,
+        gateway_dump_file_factory:,
+        open_connection:,
+        decrypt_dump:,
+        listeners:
+      )
+        @input = input
+        @shell_adapter = shell_adapter
+        @gateway_dump_repository = gateway_dump_repository
+        @gateway_dump_file_factory = gateway_dump_file_factory
+
+        @evaluator = Evaluator.new(listeners)
+        @evaluator << open_connection
+        @evaluator << method(:fetch_dumps)
+        @evaluator << method(:select_dump)
+        @evaluator << method(:download_dump)
+        @evaluator << method(:close_connection)
+        @evaluator << decrypt_dump
+        @evaluator << method(:select_database)
+        @evaluator << method(:restore)
+      end
+
+      def call(input)
+        evaluator.call(input)
+      end
+
+      private
+
+      attr_reader :evaluator, :input, :shell_adapter, :gateway_dump_repository, :gateway_dump_file_factory
+
+      def fetch_dumps(database_name:, gateway:)
+        dumps = gateway_dump_repository.all(database_name: database_name, gateway: gateway)
+        return ValueObjects::Failure.new(message: 'No dumps') if dumps.none?
+
+        ValueObjects::Success.new(gateway: gateway, dumps: dumps)
+      end
+
+      def select_dump(dumps:, gateway:)
+        dump = input.select_dump(dumps)
+        ValueObjects::Success.new(dump: dump, gateway: gateway)
+      end
+
+      def download_dump(dump:, gateway:)
+        dump.file = gateway_dump_file_factory.by_name(name: dump.name, gateway: gateway)
+        ValueObjects::Success.new(dump: dump, gateway: gateway)
+      end
+
+      def close_connection(dump:, gateway:)
+        Thread.new { gateway.close }
+        ValueObjects::Success.new(dump: dump)
+      end
+
+      def select_database(dump:)
+        name = input.enter_database_name(dump.database)
+        ValueObjects::Success.new(dump: dump, database: name)
+      end
+
+      def restore(dump:, database:)
+        shell_adapter.pg_restore(dump.file, database)
+        ValueObjects::Success.new(nil)
+      rescue Adapters::ShellAdapter::PgRestoreError => e
+        ValueObjects::Failure.new(message: e.to_s)
+      end
+    end
+  end
+end

data/lib/pg_export/{lib/pg_export/value_objects → value_objects}/dump_file.rb

@@ -54,9 +54,9 @@ class PgExport
 
       private
 
-      CHUNK_SIZE = (2**16).freeze
+      CHUNK_SIZE = (2**16)
       MAPPING = {
-        'B'  => 1024,
+        'B' => 1024,
         'kB' => 1024 * 1024,
         'MB' => 1024 * 1024 * 1024,
         'GB' => 1024 * 1024 * 1024 * 1024,

data/lib/pg_export/value_objects/result.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class PgExport
+  module ValueObjects
+    class Result
+      attr_reader :value
+
+      def initialize(value = nil)
+        @value = value
+      end
+    end
+
+    class Success < Result
+      def success
+        value
+      end
+
+      def bind
+        yield
+      end
+
+      def on_success
+        yield value
+
+        self
+      end
+
+      def on_failure
+        self
+      end
+    end
+
+    class Failure < Result
+      def bind
+        self
+      end
+
+      def on_success
+        self
+      end
+
+      def on_failure
+        yield value
+
+        self
+      end
+    end
+  end
+end

data/lib/pg_export/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class PgExport
-  VERSION = '1.0.0.rc4'
+  VERSION = '1.0.0.rc8'
 end

data/lib/pg_export.rb

@@ -1,23 +1,26 @@
 # frozen_string_literal: true
 
-require 'pg_export/container'
-require 'pg_export/import'
+require 'pg_export/version'
+require 'pg_export/configuration'
+require 'pg_export/configuration_parser'
+require 'pg_export/commands_factory'
 
 class PgExport
-  class InitializationError < StandardError; end
+  def initialize(config)
+    raise ArgumentError, 'config is not a PgExport::Configuration' unless config.is_a?(PgExport::Configuration)
 
-  include Import['transaction']
-
-  def self.boot
-    PgExport::Container.start(:main)
-    new
+    @command_name = config.command
+    @database_name = config.database
+    @commands_factory = PgExport::CommandsFactory.new(config: config)
   end
 
-  def call(database_name, &block)
-    transaction.call(database_name: database_name, &block)
+  def call
+    commands_factory
+      .public_send(command_name)
+      .call(database_name: database_name)
   end
 
   private
 
-  attr_reader :transaction
+  attr_reader :command_name, :database_name, :commands_factory
 end

data/pg_export.gemspec

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'pg_export/version'
+require_relative 'lib/pg_export/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'pg_export'
@@ -22,11 +20,6 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.3.0'
 
   spec.add_dependency 'bcrypt_pbkdf'
-  spec.add_dependency 'dry-initializer', '~> 3.0'
-  spec.add_dependency 'dry-struct', '~> 1.0'
-  spec.add_dependency 'dry-system', '~> 0.18'
-  spec.add_dependency 'dry-transaction', '~> 0.13'
-  spec.add_dependency 'dry-types', '~> 1.0'
   spec.add_dependency 'ed25519'
   spec.add_dependency 'net-scp'
   spec.add_dependency 'net-ssh'
@@ -38,5 +31,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'rspec', '~> 3.4'
-  spec.add_development_dependency 'rubocop', '~> 0.59.2'
+  spec.add_development_dependency 'rubocop', '= 0.81'
 end