pg_export 1.0.0.rc4 → 1.0.0.rc8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0f62f09db68ae3716d4ae83fea7780240cc66af83d7cbe813cd5d2e7bfae3e7
-  data.tar.gz: 0f80f6ad47217232ec83877f4bfc1b15c62a248e214229a9a6444bdecee61f44
+  metadata.gz: 653b33873daaa6f1c9c23e494f140980d8618d811b4cbff5e7209cd20d854b23
+  data.tar.gz: 4aeedec88429805b47e15fd389c02a2a870ec7aeb1b81b7d1e782c57536bce90
 SHA512:
-  metadata.gz: ecb017891a15fd94e15eef06972066655f13aeff22a4030ea840dc1ff2df6dd00451b2c7eb2e1dad248f95bc27b63d56cfe6275f675c0f2a2be6ab6f0ad7bdcd
-  data.tar.gz: e89de78f4a3a3d804f3ee82573fd97d03154a8f792f3e1a63a52f475798a091e96d0fc556e4dabbe8aa3c37497a7ae69c743a232e7bdd8a3a19d70547468df69
+  metadata.gz: 43af8e5f80571fb4de1e361097719e89732c99d0e85c4c488d3644a76d31eafd44cc12b0e82258a1d849d393c4324f03e29385dcda725d0606379ee3a9e38a58
+  data.tar.gz: 284bb265abde342da455849a18e4a27af9e20d2ae4fe38960b7b3b118f20154828348b9cb2f33b4c9e6c81fdd19a7f0b68a0e8f290a261f193bf1e100ac322fa

data/.rubocop.yml

@@ -2,21 +2,57 @@ AllCops:
   TargetRubyVersion: 2.3
 
 Metrics/BlockLength:
-  Exclude:
-    - 'bin/pg_export'
   ExcludedMethods: ['describe', 'context']
 
-Metrics/LineLength:
-  Max: 200
+Layout/LineLength:
+  Max: 140
 
 Style/ParallelAssignment:
   Enabled: false
 
-Naming/UncommunicativeMethodParamName:
+Naming/MethodParameterName:
   Enabled: false
 
-Documentation:
+Style/Documentation:
   Enabled: false
 
 Lint/UnusedMethodArgument:
   Enabled: false
+
+Metrics/MethodLength:
+  Max: 50
+
+Metrics/CyclomaticComplexity:
+  Max: 30
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: false
+
+Metrics/AbcSize:
+  Max: 30
+  Exclude:
+    - 'lib/pg_export/configuration_parser.rb'
+    - 'lib/pg_export/configuration.rb'
+
+Metrics/PerceivedComplexity:
+  Max: 30
+
+Lint/AmbiguousOperator:
+  Enabled: false
+
+Metrics/ClassLength:
+  Max: 200
+
+Layout/ExtraSpacing:
+  Exclude:
+    - 'lib/pg_export/configuration_parser.rb'
+
+Metrics/ParameterLists:
+  Exclude:
+    - 'lib/pg_export/configuration.rb'
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Style/Semicolon:
+  Enabled: false

data/CHANGELOG.md

@@ -1,4 +1,4 @@
-### 1.0.0 - 2021.03.20
+### 1.0.0 - 2022.05.18
 - Make it compatible with Ruby 3.0
 - Change configuration envs:
   - BACKUP_FTP_HOST -> PG_EXPORT_GATEWAY_HOST
@@ -7,15 +7,20 @@
   - DUMP_ENCRYPTION_KEY -> PG_EXPORT_ENCRYPTION_KEY
 - Drop Ruby 2.3 support
 - Add SSH option
-- Add +encryption_algorith+ moption to interface
+- Add `encryption_algorithm` option
+- All command line options has now their equivalents in ENVs (and vice-versa)
+- Remove dry libraries dependencies
+- In case of failure bin/pg_export now returns exit value 1
+- Improve performance
+- Improve error handling
 
 ### 0.7.7 - 2020.09.07
 
-- Upgrade dry-initializer 
+- Upgrade dry-initializer
 
 ### 0.7.6 - 2020.09.05
 
-- Upgrade dry-types, dry-struct dry-system 
+- Upgrade dry-types, dry-struct dry-system
 
 ### 0.7.0 - 2018.10.18
 
@@ -41,7 +46,7 @@
 
 ### 0.5.0 - 2017.03.11
 
-- Add restriction on DUMP_ENCRYPTION_KEY, to be exactly 16 characters length 
+- Add restriction on DUMP_ENCRYPTION_KEY, to be exactly 16 characters length
 - Make interactive mode more verbose by adding more messages
 - Fix concurrently opening ftp connection
 - Add closing ftp connection while importing dump in interactive mode

data/README.md

@@ -11,7 +11,7 @@ Can be used for backups or synchronizing databases between production and develo
 Example:
 
     pg_export --database database_name --keep 5
-    
+
 Above command will perform database dump, encrypt it, upload it to FTP and remove old dumps from FTP, keeping newest 5.
 
 FTP connection params and encryption key are configured by env variables.
@@ -50,20 +50,52 @@ Or install it yourself as:
 
     $ pg_export -h
 
-    Usage: pg_export [options]
-        -g, --gateway GATEWAY            [Optional] ssh or ftp (default: ftp)
-        -d, --database DATABASE          [Required] Name of the database to export
-        -k, --keep [KEEP]                [Optional] Number of dump files to keep on FTP (default: 10)
-        -t, --timestamped                [Optional] Enables log messages with timestamps
-        -m, --muted                      [Optional] Mutes log messages (overrides -t option)
-        -i, --interactive                [Optional] Interactive command line mode - for restoring dumps into databases
-        -v, --version                    Show version
-        -h, --help                       Show this message
-
-    Setting can be verified by running following commands:
-        -c, --configuration              Prints the configuration
-        -w, --welcome                    Tries connecting to the gateway (FTP or SSH) to verify the connection
-
+    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
+      -g, --gateway GATEWAY      Allowed values: ftp, ssh. Default: ftp. Credentials need to be set via ENVs
+      -U, --user USER            Gateway (ftp or ssh) user
+      -H, --host HOST            Gateway (ftp or ssh) host
+      -P, --password PASSWORD    Gateway (ftp or ssh) password
+      -d, --database DATABASE    In plain mode: database name to export;
+                                 In interactive mode: phrase to filter by
+      -e, --encryption_key KEY   Dumps will be SSL encrypted using this key. Should have exactly 16 characters
+      -a, --algorithm ALGORITHM  Encryption cipher algorithm (default: AES-128-CBC);
+                                 For available option see `$ openssl list -cipher-algorithms`
+      -k, --keep KEEP            Number of dump files to keep on FTP (default: 10)
+      -s, --ssh                  Same as "--gateway ssh". When set, the --gateway option is ignored
+      -f, --ftp                  Same as "--gateway ftp". When set, the --gateway option is ignored
+      -t, --timestamped          Prepends log messages with timestamps
+      -m, --muted                Mutes log messages. When set, the -t option is ignored. Prints message only on error
+      -i, --interactive          Interactive mode, for importing dumps. Whan set, the -t and -m options are ignored
+      -w, --welcome              Try connecting to the gateway (FTP or SSH) to verify the connection and exit
+      -c, --configuration        Print the configuration and exit
+      -v, --version              Print version
+      -h, --help                 Print this message and exit
+
+    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
 
 ## How to start
 
@@ -73,42 +105,41 @@ __Step 1.__ Prepare ENV variables.
     PG_EXPORT_GATEWAY_HOST=yourftp.example.com
     PG_EXPORT_GATEWAY_USER=user
     PG_EXPORT_GATEWAY_PASSWORD=password
-    
+
     /* Encryption key should have exactly 16 characters. */
     /* Dumps will be SSL(AES-128-CBC) encrypted using this key. */
     PG_EXPORT_ENCRYPTION_KEY=1234567890abcdef
-    
-    /* Dumps to be kept on FTP */
-    /* Optional, defaults to 10 */
-    KEEP_DUMPS=5
-    
-Note, that variables cannot include `#` sign, [more info](http://serverfault.com/questions/539730/environment-variable-in-etc-environment-with-pound-hash-sign-in-the-value). 
 
 __Step 2.__ Print the configuration to verify if env variables has been loaded properly.
 
     $ pg_export --configuration
-    => {:encryption_key=>"k4***", :gateway_host=>"yourftp.example.com", :gateway_user=>"your_gateway_user",
-       :gateway_password=>"pass***", :logger_format=>"plain", :keep_dumps=>2}
-       
+    => encryption_key k4***
+       gateway_host yourftp.example.com
+       gateway_user your_gateway_user
+       gateway_password
+       logger_format plain
+       keep_dumps 10
+       ....
+
 __Step 3.__ Try connecting to FTP to verify the connection.
 
     $ pg_export --gateway ftp --welcome
     => 230 User your_ftp_user logged in
-    
+
 __Step 4.__ Perform database export.
 
-    $ pg_export -d your_database [-k 5]
-    => Dump database your_database to your_database_20181016_121314 (1.36MB)
-       Encrypt your_database_20181016_121314 (1.34MB)
+    $ pg_export -d your_database -k 5
+    => Dump database your_database to database_name (1.36MB)
+       Encrypt database_name_20181016_121314 (1.34MB)
        Connect to yourftp.example.com
-       Upload your_database_20181016_121314 (1.34MB) to yourftp.example.com
+       Upload database_name_20181016_121314 (1.34MB) to yourftp.example.com
        Close FTP
-       
+
 ## How to restore a dump?
 
 Run interactive mode and follow the instructions:
 
-    pg_export [-d your_database] -i
+    pg_export [-d database_name] -i
 
 ## Development
 

data/bin/pg_export

@@ -1,147 +1,28 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'optparse'
+lib = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require 'pg_export'
 
-ENV['KEEP_DUMPS'] = ENV['KEEP_DUMPS'] || '10'
-ENV['GATEWAY'] = 'ftp'
-ENV['PG_EXPORT_MODE'] = 'plain'
-ENV['PG_EXPORT_ENCRYPTION_ALGORITHM'] = 'AES-128-CBC'
-
-database = nil
-
-option_parser = OptionParser.new do |opts|
-  opts.banner = <<~TXT
-    NAME
-        pg_export - CLI for exporting/importing PostgreSQL dumps via FTP/SSH
-
-    SYNOPSIS (default mode)
-        pg_export DATABASE [options]
-
-    SYNOPSIS (interactive mode)
-        pg_export --interactive [DATABASE] [options]
-
-    ARGUMENTS
-        DATABASE - database name to export (when default mode)
-                 - phrase to filter database dumps by (when interactive mode)
-
-    OPTIONS
-  TXT
-
-  opts.program_name = 'pg_export'
-  opts.version = PgExport::VERSION
-
-  opts.on('-g', '--gateway GATEWAY', %w[ftp ssh], 'Allowed values: ftp, ssh. Default: ftp. Credentials need to be set via ENVs') do |g|
-    ENV['GATEWAY'] = g
-  end
-
-  opts.on('-s', '--ssh', 'Same as "--gateway ssh"') do
-    ENV['GATEWAY'] = 'ssh'
-  end
-
-  opts.on('-f', '--ftp', 'Same as "--gateway ftp"') do
-    ENV['GATEWAY'] = 'ftp'
-  end
-
-  opts.on('-d', '--database DATABASE', String, 'Alternative way of specifying name of the database to export or phrase to filter by') do |d|
-    database = d
-  end
-
-  opts.on('-e', '--encryption_key KEY', String, 'Dumps will be SSL encrypted using this key. Should have exactly 16 characters. Overwrites PG_EXPORT_ENCRYPTION_KEY env') do |key|
-    ENV['PG_EXPORT_ENCRYPTION_KEY'] = key
-  end
-
-  opts.on('-a', '--algorithm ALGORITHM', String, 'Encryption cipher algorithm (default: AES-128-CBC). Overwrites PG_EXPORT_ENCRYPTION_ALGORITHM env. For available option see `$ openssl list -cipher-algorithms`') do |key|
-    ENV['PG_EXPORT_ENCRYPTION_KEY'] = key
-  end
-
-  opts.on('-k', '--keep KEEP', String, 'Number of dump files to keep on FTP (default: 10). Overwrites KEEP_DUMPS env') do |keep|
-    ENV['KEEP_DUMPS'] = keep
-  end
-
-  opts.on('-t', '--timestamped', 'Enables log messages with timestamps') do
-    ENV['LOGGER_FORMAT'] = 'timestamped'
-  end
-
-  opts.on('-m', '--muted', 'Mutes log messages (overrides -t option)') do
-    ENV['LOGGER_FORMAT'] = 'muted'
-  end
-
-  opts.on('-i', '--interactive', 'Interactive mode, for importing dumps') do
-    ENV['PG_EXPORT_MODE'] = 'interactive'
-  end
-
-  opts.on('-v', '--version', 'Show version') do
-    puts PgExport::VERSION
-    exit
-  end
-
-  opts.on('-h', '--help', 'Show this message') do
-    puts opts
-    exit
-  end
-
-  opts.separator <<~TXT
-
-    ENV
-        PG_EXPORT_GATEWAY_HOST           required
-        PG_EXPORT_GATEWAY_USER           required
-        PG_EXPORT_GATEWAY_PASSWORD       optional when eg. authorized key is added
-        PG_EXPORT_ENCRYPTION_KEY         required or set by --encryption_key)
-        PG_EXPORT_ENCRYPTION_ALGORITHM   required or set by --algorithm)
-  TXT
-
-  opts.separator "\nTEST RUN"
-
-  opts.on('-c', '--configuration', 'Print the configuration') do
-    require 'pg_export/container'
-    PgExport::Container.start(:config)
-    puts PgExport::Container['config'].to_h
-    exit
-  end
-
-  opts.on('-w', '--welcome', 'Try connecting to the gateway (FTP or SSH) to verify the connection') do
-    require 'pg_export/container'
-    PgExport::Container.start(ENV['GATEWAY'].to_sym)
-    gateway = PgExport::Container['factories.gateway_factory'].gateway
-    puts gateway.welcome
-    exit
-  end
-
-  if ARGV.empty?
-    puts opts
-    exit
-  end
-end
-
 begin
-  option_parser.parse!
-  database = ARGV.first unless ARGV.empty?
-rescue OptionParser::ParseError => e
+  config = PgExport::ConfigurationParser.parse
+  pg_export = PgExport.new(config)
+  result = pg_export.call
+  result
+    .on_success { |outcome| puts outcome if outcome }
+    .on_failure { |outcome| warn outcome[:message]; exit 1 }
+rescue PgExport::ConfigurationParser::Error => e
   warn e.message.capitalize
-  warn 'Details:'
-  warn option_parser.to_s.split("\n").grep(/ #{e.args.first}/).join("\n")
-  warn 'Type "pg_export" for available options'
-  exit
-end
 
-require 'pg_export/container'
-
-begin
-  pg_export = PgExport.boot
-rescue PgExport::InitializationError => e
-  warn 'Unable to initialize PgExport due to invalid configuration. Check you ENVs.'
-  warn "Detailed message: #{e.message}"
-  exit
-end
-
-begin
-  pg_export.call(database) do |result|
-    result.success { puts 'Success' }
-    result.failure { |outcome| warn outcome[:message] }
+  if e.reason == 'missing argument'
+    warn "\nHint for the #{e.args.first} option:"
+    warn PgExport::ConfigurationParser.help.to_s.split("\n").grep(/ #{e.args.first}/).join("\n")
   end
+
+  warn 'Type "pg_export -h" to print options.'
+  exit 1
 rescue Interrupt
   puts
 end

data/lib/pg_export/{lib/pg_export/adapters/bash_adapter.rb → adapters/shell_adapter.rb}

@@ -4,7 +4,7 @@ require 'open3'
 
 class PgExport
   module Adapters
-    class BashAdapter
+    class ShellAdapter
       class PgRestoreError < StandardError; end
       class PgDumpError < StandardError; end
 

data/lib/pg_export/commands_factory.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'pg_export/value_objects/result'
+
+class PgExport
+  class CommandsFactory
+    attr_reader :config
+
+    def initialize(config:)
+      @config = config
+    end
+
+    def print_configuration
+      ->(_) { ValueObjects::Success.new(config) }
+    end
+
+    def gateway_welcome
+      ->(_) { ValueObjects::Success.new(gateway_factory.gateway.welcome) }
+    end
+
+    def print_version
+      ->(_) { ValueObjects::Success.new(PgExport::VERSION) }
+    end
+
+    def print_help
+      ->(_) { ValueObjects::Success.new(PgExport::ConfigurationParser.help) }
+    end
+
+    def export_dump
+      require 'pg_export/transactions/export_dump'
+      require 'pg_export/factories/dump_factory'
+      require 'pg_export/adapters/shell_adapter'
+      require 'pg_export/operations/encrypt_dump'
+      require 'pg_export/operations/open_connection'
+      require 'pg_export/operations/remove_old_dumps'
+      require 'pg_export/repositories/gateway_dump_repository'
+
+      PgExport::Transactions::ExportDump.new(
+        dump_factory: Factories::DumpFactory.new,
+        shell_adapter: Adapters::ShellAdapter.new,
+        encrypt_dump: Operations::EncryptDump.new(cipher_factory: cipher_factory),
+        open_connection: Operations::OpenConnection.new(gateway_factory: gateway_factory),
+        remove_old_dumps: Operations::RemoveOldDumps.new(
+          gateway_dump_repository: Repositories::GatewayDumpRepository.new,
+          keep: config.keep_dumps
+        ),
+        listeners: plain_listeners
+      )
+    end
+
+    def import_dump_interactively
+      require 'pg_export/transactions/import_dump_interactively'
+      require 'pg_export/ui/interactive/input'
+      require 'pg_export/adapters/shell_adapter'
+      require 'pg_export/factories/gateway_dump_file_factory'
+      require 'pg_export/repositories/gateway_dump_repository'
+      require 'pg_export/operations/open_connection'
+      require 'pg_export/operations/decrypt_dump'
+
+      PgExport::Transactions::ImportDumpInteractively.new(
+        input: Ui::Interactive::Input.new,
+        shell_adapter: Adapters::ShellAdapter.new,
+        gateway_dump_file_factory: Factories::GatewayDumpFileFactory.new,
+        gateway_dump_repository: Repositories::GatewayDumpRepository.new,
+        open_connection: Operations::OpenConnection.new(gateway_factory: gateway_factory),
+        decrypt_dump: Operations::DecryptDump.new(cipher_factory: cipher_factory),
+        listeners: interactive_listeners
+      )
+    end
+
+    private
+
+    def gateway_factory
+      if config.gateway == :ftp
+        require 'pg_export/factories/ftp_gateway_factory'
+
+        Factories::FtpGatewayFactory.new(config: config)
+      elsif config.gateway == :ssh
+        require 'pg_export/factories/ssh_gateway_factory'
+
+        Factories::SshGatewayFactory.new(config: config)
+      else
+        raise ArgumentError, "Unknown gateway #{config.gateway}"
+      end
+    end
+
+    def cipher_factory
+      require 'pg_export/factories/cipher_factory'
+
+      Factories::CipherFactory.new(
+        encryption_algorithm: config.encryption_algorithm,
+        encryption_key: config.encryption_key
+      )
+    end
+
+    def plain_listeners
+      require 'pg_export/listeners/plain/prepare_params'
+      require 'pg_export/listeners/plain/build_dump'
+      require 'pg_export/listeners/plain/close_connection'
+      require 'pg_export/listeners/plain/decrypt_dump'
+      require 'pg_export/listeners/plain/download_dump'
+      require 'pg_export/listeners/plain/encrypt_dump'
+      require 'pg_export/listeners/plain/fetch_dumps'
+      require 'pg_export/listeners/plain/open_connection'
+      require 'pg_export/listeners/plain/remove_old_dumps'
+      require 'pg_export/listeners/plain/restore'
+      require 'pg_export/listeners/plain/upload_dump'
+
+      logger = build_logger(config.logger_format)
+
+      {
+        prepare_params: Listeners::Plain::PrepareParams.new(logger: logger),
+        build_dump: Listeners::Plain::BuildDump.new(logger: logger),
+        encrypt_dump: Listeners::Plain::EncryptDump.new(logger: logger),
+        open_connection: Listeners::Plain::OpenConnection.new(logger: logger),
+        upload_dump: Listeners::Plain::UploadDump.new(logger: logger),
+        remove_old_dumps: Listeners::Plain::RemoveOldDumps.new(logger: logger),
+        close_connection: Listeners::Plain::CloseConnection.new(logger: logger)
+      }
+    end
+
+    def interactive_listeners
+      require 'pg_export/listeners/interactive/open_connection'
+      require 'pg_export/listeners/interactive/fetch_dumps'
+      require 'pg_export/listeners/interactive/select_dump'
+      require 'pg_export/listeners/interactive/download_dump'
+      require 'pg_export/listeners/interactive/close_connection'
+      require 'pg_export/listeners/interactive/decrypt_dump'
+      require 'pg_export/listeners/interactive/select_database'
+      require 'pg_export/listeners/interactive/restore'
+
+      {
+        open_connection: Listeners::Interactive::OpenConnection.new,
+        fetch_dumps: Listeners::Interactive::FetchDumps.new,
+        select_dump: Listeners::Interactive::SelectDump.new,
+        download_dump: Listeners::Interactive::DownloadDump.new,
+        close_connection: Listeners::Interactive::CloseConnection.new,
+        decrypt_dump: Listeners::Interactive::DecryptDump.new,
+        select_database: Listeners::Interactive::SelectDatabase.new,
+        restore: Listeners::Interactive::Restore.new,
+      }
+    end
+
+    def build_logger(logger_format)
+      require 'logger'
+
+      formatters = {
+        plain: ->(_, _, _, message) { "#{message}\n" },
+        muted: ->(*) {},
+        timestamped: lambda do |severity, datetime, progname, message|
+          "#{datetime} #{Process.pid} TID-#{Thread.current.object_id.to_s(36)}#{progname} #{severity}: #{message}\n"
+        end
+      }
+
+      Logger.new($stdout, formatter: formatters.fetch(logger_format))
+    end
+  end
+end