pg_export 1.0.0.rc4 → 1.0.0.rc8

data/lib/pg_export/configuration.rb

@@ -1,42 +1,85 @@
 # frozen_string_literal: true
 
-require 'pg_export/lib/pg_export/types'
-require 'dry-struct'
+require 'optparse'
 
 class PgExport
-  class Configuration < Dry::Struct
-    attribute :encryption_key,       PgExport::Types::Strict::String.constrained(size: 16)
-    attribute :encryption_algorithm, PgExport::Types::Strict::String
-    attribute :gateway_host,         PgExport::Types::Strict::String
-    attribute :gateway_user,         PgExport::Types::Strict::String
-    attribute :gateway_password,     PgExport::Types::Strict::String.optional
-    attribute :logger_format,        PgExport::Types::Coercible::String.enum('plain', 'timestamped', 'muted')
-    attribute :keep_dumps,           PgExport::Types::Coercible::Integer.constrained(gteq: 0)
-
-    def self.build(env)
-      new(
-        encryption_key: env['PG_EXPORT_ENCRYPTION_KEY'],
-        encryption_algorithm: env['PG_EXPORT_ENCRYPTION_ALGORITHM'],
-        gateway_host: env['PG_EXPORT_GATEWAY_HOST'],
-        gateway_user: env['PG_EXPORT_GATEWAY_USER'],
-        gateway_password: env['PG_EXPORT_GATEWAY_PASSWORD'] == '' ? nil : env['PG_EXPORT_GATEWAY_PASSWORD'],
-        logger_format: env['LOGGER_FORMAT'] || 'plain',
-        keep_dumps: env['KEEP_DUMPS'] || 10
-      )
-    rescue Dry::Struct::Error => e
-      raise PgExport::InitializationError, e.message.gsub('[PgExport::Configuration.new] ', '')
-    end
+  class Configuration
+    ATTRS = %i[
+      encryption_key
+      encryption_algorithm
+      gateway_host
+      gateway_user
+      gateway_password
+      logger_format
+      keep_dumps
+      gateway mode
+      database
+      command
+    ].freeze
 
-    def gateway
-      ENV['GATEWAY'].to_sym
-    end
+    attr_reader *ATTRS
+
+    def initialize(
+      encryption_key: nil,
+      encryption_algorithm: nil,
+      gateway_host: nil,
+      gateway_user: nil,
+      gateway_password: nil,
+      logger_format: nil,
+      keep_dumps: nil,
+      gateway: nil,
+      mode: nil,
+      database: nil,
+      command: nil
+    )
+
+      @encryption_key = String(encryption_key)
+      raise ArgumentError, 'Encryption key must be 16 chars long' if @encryption_key.length != 16
+
+      @encryption_algorithm = String(encryption_algorithm)
+      @encryption_algorithm = 'AES-128-CBC' if @encryption_algorithm.empty?
+
+      @gateway_host = String(gateway_host)
+      raise ArgumentError, 'Gatway host must not be empty' if @gateway_host.empty?
+
+      @gateway_user = String(gateway_user)
+      raise ArgumentError, 'Gatway user must not be empty' if @gateway_user.empty?
 
-    def mode
-      ENV['PG_EXPORT_MODE'].to_sym
+      @gateway_password = nil if gateway_password.nil? || gateway_password.to_s.empty?
+
+      @logger_format = logger_format.to_s.to_sym
+      @logger_format = :plain if @logger_format.empty?
+      unless %i[plain timestamped muted].include?(@logger_format)
+        raise ArgumentError, 'Logger format must be one of: plain, timestamped, muted'
+      end
+
+      @keep_dumps = Integer(keep_dumps || 10)
+      raise ArgumentError, 'Keep dumps must greater or equal to 1' unless @keep_dumps >= 1
+
+      @gateway = gateway.to_s.to_sym
+      @gateway = :ftp if @gateway.empty?
+      raise ArgumentError, 'Gateway must be one of: ftp, ssh' unless %i[ftp ssh].include?(@gateway)
+
+      @mode = mode.to_s.to_sym
+      @mode = :plain if @mode.empty?
+      raise ArgumentError, 'Mode must be one of: plain, interactive' unless %i[plain interactive].include?(@mode)
+
+      @database = String(database) unless database.nil?
+
+      @command = command.to_s.to_sym
+      @command = :export_dump if @command.empty?
     end
 
-    def logger_muted?
-      logger_format == 'muted'
+    def to_s
+      ATTRS.map do |name|
+        value = public_send(name)
+
+        if %i[encryption_key gateway_password].include?(name)
+          "  #{name} #{value.nil? ? '' : value[0..2] + '***'}"
+        else
+          "  #{name} #{value}"
+        end
+      end.join("\n")
     end
   end
 end

data/lib/pg_export/configuration_parser.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'pg_export/configuration'
+
+class PgExport
+  class ConfigurationParser
+    class Error < OptionParser::ParseError; end
+
+    class << self
+      def parse
+        h = {
+          encryption_key: ENV['PG_EXPORT_ENCRYPTION_KEY'],
+          encryption_algorithm: ENV['PG_EXPORT_ENCRYPTION_ALGORITHM'],
+          gateway_user: ENV['PG_EXPORT_GATEWAY_USER'],
+          gateway_host: ENV['PG_EXPORT_GATEWAY_HOST'],
+          gateway_password: ENV['PG_EXPORT_GATEWAY_PASSWORD'],
+          logger_format: ENV['PG_EXPORT_LOGGER_FORMAT'],
+          keep_dumps: ENV['PG_EXPORT_KEEP_DUMPS'],
+          gateway: ENV['PG_EXPORT_GATEWAY'],
+          database: ENV['PG_EXPORT_DATABASE'],
+          mode: ENV['PG_EXPORT_MODE'],
+          command: :export_dump
+        }
+
+        option_parser(h).parse!
+        h[:database] = ARGV.first unless ARGV.empty?
+
+        Configuration.new(**h)
+      rescue OptionParser::ParseError => e
+        error = Error.new(*e.args)
+        error.reason = e.reason
+        raise error
+      end
+
+      def help
+        option_parser.to_s
+      end
+
+      BANNER = <<~TXT
+        NAME
+            pg_export - CLI for exporting/importing PostgreSQL dumps via FTP/SSH
+
+        SYNOPSIS
+            pg_export DATABASE [OPTION..]
+            pg_export --interactive DATABASE [OPTION..]
+
+        EXIT VALUES
+            0 - Success
+            1 - Error
+
+        ARGUMENTS
+            DATABASE - database name to export (when default mode)
+                     - phrase to filter database dumps by (when interactive mode)
+
+        OPTIONS
+      TXT
+
+      EXAMPLE = <<~TXT
+        ENV
+          Each of the above options can be also set using enviromental variables.
+          Use full option names prepending with PG_EXPORT_ phrase.
+          Command line options takes precedence over the ENVs.
+
+          Eg. below two commands are equivalent:
+            pg_export -s -U user -H host database_name -k 10
+
+          Is equivalent to:
+            export PG_EXPORT_GATEWAY_USER=user
+            export PG_EXPORT_GATEWAY_HOST=host
+            export PG_EXPORT_KEEP=20
+            pg_export -s database_name -k 10
+      TXT
+
+      N = "\n                                     "
+
+      O = {
+        g: 'Allowed values: ftp, ssh. Default: ftp',
+        U: 'Gateway (ftp or ssh) user',
+        H: 'Gateway (ftp or ssh) host',
+        P: 'Gateway (ftp or ssh) password',
+        d: "In plain mode: database name to export;#{N}In interactive mode: phrase to filter by",
+        e: 'Dumps will be SSL encrypted using this key. Should have exactly 16 characters',
+        a: "Encryption cipher algorithm (default: AES-128-CBC);#{N}For available option see `$ openssl list -cipher-algorithms`",
+        k: 'Number of dump files to keep on FTP (default: 10)',
+        s: 'Same as "--gateway ssh". When set, the --gateway option is ignored',
+        f: 'Same as "--gateway ftp". When set, the --gateway option is ignored',
+        t: 'Prepends log messages with timestamps',
+        m: 'Mutes log messages. When set, the -t option is ignored. Prints message only on error',
+        i: 'Interactive mode, for importing dumps. Whan set, the -t and -m options are ignored',
+        w: 'Try connecting to the gateway (FTP or SSH) to verify the connection and exit',
+        c: 'Print the configuration and exit',
+        v: 'Print version',
+        h: 'Print this message and exit'
+      }.freeze
+      private_constant :BANNER, :EXAMPLE, :N, :O
+
+      def option_parser(h = {})
+        OptionParser.new do |o|
+          o.banner = BANNER
+          o.program_name = 'pg_export'
+          o.version = PgExport::VERSION
+          o.on('-g', '--gateway GATEWAY', %w[ftp ssh], O[:g]) { |v| h[:gateway] = v }
+          o.on('-U', '--user USER',            String, O[:U]) { |v| h[:gateway_user] = v }
+          o.on('-H', '--host HOST',            String, O[:H]) { |v| h[:gateway_host] = v }
+          o.on('-P', '--password PASSWORD',    String, O[:P]) { |v| h[:gateway_password] = v }
+          o.on('-d', '--database DATABASE',    String, O[:d]) { |v| h[:database] = v }
+          o.on('-e', '--encryption_key KEY',   String, O[:e]) { |v| h[:encryption_key] = v }
+          o.on('-a', '--algorithm ALGORITHM',  String, O[:a]) { |v| h[:encryption_algorithm] = v }
+          o.on('-k', '--keep KEEP',           Integer, O[:k]) { |v| h[:keep_dumps] = v }
+          o.on('-s', '--ssh',                          O[:s]) { h[:gateway] = 'ssh' }
+          o.on('-f', '--ftp',                          O[:f]) { h[:gateway] = 'ftp' }
+          o.on('-t', '--timestamped',                  O[:t]) { h[:logger_format] = 'timestamped' }
+          o.on('-m', '--muted',                        O[:m]) { h[:logger_format] = 'muted' }
+          o.on('-i', '--interactive',                  O[:i]) { h[:command] = :import_dump_interactively }
+          o.on('-w', '--welcome',                      O[:w]) { h[:command] = :gateway_welcome }
+          o.on('-c', '--configuration',                O[:c]) { h[:command] = :print_configuration }
+          o.on('-v', '--version',                      O[:v]) { h[:command] = :print_version }
+          o.on('-h', '--help',                         O[:h]) { h[:command] = :print_help }
+          o.separator ''
+          o.separator EXAMPLE
+        end
+      end
+    end
+  end
+end

data/lib/pg_export/entities/dump.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class PgExport
+  module Entities
+    class Dump
+      attr_reader :name, :type, :database, :file
+
+      def initialize(name: nil, type: nil, database: nil, file: nil)
+        @name = String(name)
+        raise ArgumentError, 'Dump name must not be empty' if @name.empty?
+        raise ArgumentError, 'Dump name does not match criteria' unless /.+_20[0-9]{6}_[0-9]{6}\Z/.match?(@name)
+
+        @type = String(type)
+        @type = 'plain' if @type.empty?
+        raise ArgumentError, 'Dump type must be one of: plain, encrypted' unless %w[plain encrypted].include?(@type)
+
+        @database = database
+
+        @file = file
+        @file = ValueObjects::DumpFile.new if @file.nil?
+        raise ArgumentError, "Invalid file type: #{@file.class}" unless @file.is_a?(ValueObjects::DumpFile)
+      end
+
+      def encrypt(cipher_factory:)
+        self.file = file.copy(cipher: cipher_factory.encryptor)
+        self.type = :encrypted
+
+        self
+      end
+
+      def decrypt(cipher_factory:)
+        self.file = file.copy(cipher: cipher_factory.decryptor)
+        self.type = :plain
+
+        self
+      end
+
+      def to_s
+        "#{name} (#{file.size_human})"
+      end
+
+      def file=(f)
+        @file = f
+
+        raise ArgumentError, "Invalid file type: '#{f}'" unless @file.is_a?(ValueObjects::DumpFile)
+      end
+
+      protected
+
+      def type=(t)
+        @type = t.to_s
+
+        raise ArgumentError, "Dump type '#{t}' must be one of: plain, encrypted" unless %w[plain encrypted].include?(@type)
+      end
+    end
+  end
+end

data/lib/pg_export/{lib/pg_export/factories → factories}/cipher_factory.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 require 'openssl'
-require 'pg_export/import'
 
 class PgExport
   module Factories
     class CipherFactory
-      include Import['config']
+      def initialize(encryption_algorithm:, encryption_key:)
+        @encryption_algorithm = encryption_algorithm
+        @encryption_key = encryption_key
+      end
 
       def encryptor
         build_cipher(:encrypt)
@@ -18,10 +20,12 @@ class PgExport
 
       private
 
+      attr_reader :encryption_algorithm, :encryption_key
+
       def build_cipher(type)
-        cipher = OpenSSL::Cipher.new(config.encryption_algorithm)
+        cipher = OpenSSL::Cipher.new(encryption_algorithm)
         cipher.public_send(type)
-        cipher.key = config.encryption_key
+        cipher.key = encryption_key
         cipher
       end
     end

data/lib/pg_export/{lib/pg_export/factories → factories}/dump_factory.rb

@@ -3,8 +3,7 @@
 require 'open3'
 require 'tempfile'
 
-require 'pg_export/lib/pg_export/entities/dump'
-require 'pg_export/import'
+require 'pg_export/entities/dump'
 
 class PgExport
   module Factories

data/lib/pg_export/{lib/pg_export/factories → factories}/ftp_gateway_factory.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
-# auto_register: false
-
-require 'pg_export/lib/pg_export/gateways/ftp'
-require 'pg_export/import'
+require 'pg_export/gateways/ftp'
 
 class PgExport
   module Factories
     class FtpGatewayFactory
-      include Import['config']
+      def initialize(config:)
+        @config = config
+      end
 
       def gateway
         ::PgExport::Gateways::Ftp.new(
@@ -17,6 +16,10 @@ class PgExport
           password: config.gateway_password
         )
       end
+
+      private
+
+      attr_reader :config
     end
   end
 end

data/lib/pg_export/{lib/pg_export/repositories/gateway_dump_file_repository.rb → factories/gateway_dump_file_factory.rb}

@@ -1,13 +1,12 @@
 # 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 GatewayDumpFileRepository
+  module Factories
+    class GatewayDumpFileFactory
       def by_name(name:, gateway:)
         file = ValueObjects::DumpFile.new
         gateway.get(file, name)

data/lib/pg_export/{lib/pg_export/factories → factories}/ssh_gateway_factory.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
-# auto_register: false
-
-require 'pg_export/lib/pg_export/gateways/ssh'
-require 'pg_export/import'
+require 'pg_export/gateways/ssh'
 
 class PgExport
   module Factories
     class SshGatewayFactory
-      include Import['config']
+      def initialize(config:)
+        @config = config
+      end
 
       def gateway
         ::PgExport::Gateways::Ssh.new(
@@ -17,6 +16,10 @@ class PgExport
           password: config.gateway_password
         )
       end
+
+      private
+
+      attr_reader :config
     end
   end
 end

data/lib/pg_export/{lib/pg_export/gateways → gateways}/ftp.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-# auto_register: false
-
 require 'net/ftp'
 
 class PgExport
   module Gateways
     class Ftp
-      CHUNK_SIZE = (2**16).freeze
+      CHUNK_SIZE = (2**16)
 
       def initialize(host:, user:, password:)
         @host, @user, @password, @logger = host, user, password

data/lib/pg_export/{lib/pg_export/gateways → gateways}/ssh.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# auto_register: false
-
 require 'ed25519'
 require 'net/ssh'
 require 'net/scp'
@@ -9,8 +7,6 @@ require 'net/scp'
 class PgExport
   module Gateways
     class Ssh
-      CHUNK_SIZE = (2**16).freeze
-
       def initialize(host:, user:, password:)
         @host, @user, @password, @logger = host, user, password
       end
@@ -25,7 +21,7 @@ class PgExport
       end
 
       def welcome
-        open.exec!('hostname')
+        open.exec!('hostname; whoami')
       end
 
       def close
@@ -49,7 +45,7 @@ class PgExport
       end
 
       def delete(name)
-        # @TODO
+        ssh.exec!("rm #{name}")
       end
 
       def persist(file, name)

data/lib/pg_export/{lib/pg_export/listeners → listeners}/interactive/build_dump.rb

@@ -7,7 +7,7 @@ class PgExport
     class Interactive
       class BuildDump < InteractiveListener
         def on_step(event)
-          @spinner = build_spinner("Dumping database #{event[:args].first[:database_name]}")
+          @spinner = build_spinner("Dumping database #{event[:value][:database_name]}")
         end
 
         def on_step_succeeded(event)

data/lib/pg_export/{lib/pg_export/listeners → listeners}/interactive/close_connection.rb

@@ -7,7 +7,7 @@ class PgExport
     class Interactive
       class CloseConnection < InteractiveListener
         def on_step(*)
-          @spinner = build_spinner('Closing FTP')
+          @spinner = build_spinner('Closing connection')
         end
 
         def on_step_succeeded(*)

data/lib/pg_export/{lib/pg_export/listeners → listeners}/interactive/remove_old_dumps.rb

@@ -7,7 +7,7 @@ class PgExport
     class Interactive
       class RemoveOldDumps < InteractiveListener
         def on_step(event)
-          @spinner = build_spinner("Checking for old dumps on #{event[:args].first[:gateway]}")
+          @spinner = build_spinner("Checking for old dumps on #{event[:value][:gateway]}")
         end
 
         def on_step_succeeded(event)

data/lib/pg_export/{lib/pg_export/listeners → listeners}/interactive/restore.rb

@@ -7,7 +7,7 @@ class PgExport
     class Interactive
       class Restore < InteractiveListener
         def on_step(event)
-          @spinner = build_spinner("Restoring dump to database #{event[:args].first[:database]}")
+          @spinner = build_spinner("Restoring dump to database #{event[:value][:database]}")
         end
 
         def on_step_succeeded(*)

data/lib/pg_export/listeners/interactive/select_database.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative '../interactive_listener'
+
+class PgExport
+  module Listeners
+    class Interactive
+      class SelectDatabase < InteractiveListener
+      end
+    end
+  end
+end

data/lib/pg_export/listeners/interactive/select_dump.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative '../interactive_listener'
+
+class PgExport
+  module Listeners
+    class Interactive
+      class SelectDump < InteractiveListener
+      end
+    end
+  end
+end

data/lib/pg_export/{lib/pg_export/listeners → listeners}/interactive/upload_dump.rb

@@ -7,7 +7,7 @@ class PgExport
     class Interactive
       class UploadDump < InteractiveListener
         def on_step(event)
-          @spinner = build_spinner("Uploading #{event[:args].first[:dump]} to #{event[:args].first[:gateway]}")
+          @spinner = build_spinner("Uploading #{event[:value][:dump]} to #{event[:value][:gateway]}")
         end
 
         def on_step_succeeded(*)

data/lib/pg_export/{lib/pg_export/listeners → listeners}/interactive_listener.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
-# auto_register: false
-
-require 'pg_export/import'
 require 'tty-spinner'
 
 class PgExport
   module Listeners
     class InteractiveListener
+      def on_step(*); end
+
+      def on_step_succeeded(*); end
+
       def on_step_failed(event)
         @spinner.error([error, self.class.red(event[:value][:message])].join("\n"))
       end

data/lib/pg_export/listeners/plain/prepare_params.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative '../plain_listener'
+
+class PgExport
+  module Listeners
+    class Plain
+      class PrepareParams < PlainListener
+        def on_step_succeeded(event)
+          logger.info('Init')
+        end
+      end
+    end
+  end
+end

data/lib/pg_export/{lib/pg_export/listeners → listeners}/plain_listener.rb

@@ -1,17 +1,23 @@
 # frozen_string_literal: true
 
-# auto_register: false
-
-require 'pg_export/import'
-
 class PgExport
   module Listeners
     class PlainListener
-      include Import['logger']
+      def initialize(logger:)
+        @logger = logger
+      end
+
+      def on_step(*); end
+
+      def on_step_succeeded(*); end
 
       def on_step_failed(event)
         logger.info("Error: #{event[:value][:message]}")
       end
+
+      private
+
+      attr_reader :logger
     end
   end
 end