aptible-cli 0.16.3 → 0.16.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3eb92fffdc685a61fd06c0d5b38b485395eccb0e1762d8efeab0514e74c61b6b
-  data.tar.gz: 2237aacb034a1f7f7b1ae41328f0c05ee9393b7d48d6bdca93ca72072e867183
+  metadata.gz: 7f9abbc0bef99a8ca0f69c0b3d9751e529d9b37b5528315b03481acc84b68868
+  data.tar.gz: 916d97a558b654865ae9cbcf4532058a9070d19dbe6d984be7a5f233eb2884e6
 SHA512:
-  metadata.gz: c3ad2d2c88fa090eb8f65a9f4b91b1c3bccf180764a69ef6d60c3f068e37b6fafbbea515f9a6451b2983aa6e44dcd82bee1020003069e644c3389a2011207764
-  data.tar.gz: 63cc2f56d9f14f9c5981cae0df45d1de16bf03ee714ddb8635641176ad8f6315d1a00ca154b8ad377274a7494d8ca268e9873ea0b51eb1aa8186a1094f444ad6
+  metadata.gz: 6ef0c0c9dc25afdf19b680fcabcfd589cd74f246d7442361e79ef5f01d73382bd10ee21c9ca63a31a3f6a003ef0405c651b03e251c6e36525ddfebc86df7aeee
+  data.tar.gz: 3457904ef7ab8e5ff0a5a63fd856633fea48460e8dd88b0ae5ba8181494d893bfe45027927e57c7b217cc89fb39f09eb3fe27abdcb929d1b6fd8d6ca7a6a5b18

data/.travis.yml

@@ -1,3 +1,4 @@
+dist: xenial
 sudo: false
 
 rvm:

data/Gemfile

@@ -6,7 +6,6 @@ gem 'rack', '~> 1.0'
 
 group :test do
   gem 'webmock'
-  gem 'codecov', require: false
 end
 
 # Specify your gem's dependencies in aptible-cli.gemspec

data/README.md

@@ -3,7 +3,6 @@
 [![Gem Version](https://badge.fury.io/rb/aptible-cli.png)](https://rubygems.org/gems/aptible-cli)
 [![Build Status](https://travis-ci.org/aptible/aptible-cli.png?branch=master)](https://travis-ci.org/aptible/aptible-cli)
 [![Dependency Status](https://gemnasium.com/aptible/aptible-cli.png)](https://gemnasium.com/aptible/aptible-cli)
-[![codecov](https://codecov.io/gh/aptible/aptible-cli/branch/master/graph/badge.svg)](https://codecov.io/gh/aptible/aptible-cli)
 [![Roadmap](https://badge.waffle.io/aptible/aptible-cli.svg?label=ready&title=roadmap)](http://waffle.io/aptible/aptible-cli)
 
 Command-line interface for Aptible services.
@@ -29,52 +28,54 @@ From `aptible help`:
 <!-- BEGIN USAGE -->
 ```
 Commands:
-  aptible apps                                                                                                                       # List all applications
-  aptible apps:create HANDLE                                                                                                         # Create a new application
-  aptible apps:deprovision                                                                                                           # Deprovision an app
-  aptible apps:scale SERVICE [--container-count COUNT] [--container-size SIZE_MB]                                                    # Scale a service
-  aptible backup:list DB_HANDLE                                                                                                      # List backups for a database
-  aptible backup:restore BACKUP_ID [--environment ENVIRONMENT_HANDLE] [--handle HANDLE] [--container-size SIZE_MB] [--size SIZE_GB]  # Restore a backup
-  aptible config                                                                                                                     # Print an app's current configuration
-  aptible config:add [VAR1=VAL1] [VAR2=VAL2] [...]                                                                                   # Add an ENV variable to an app
-  aptible config:rm [VAR1] [VAR2] [...]                                                                                              # Remove an ENV variable from an app
-  aptible config:set [VAR1=VAL1] [VAR2=VAL2] [...]                                                                                   # Add an ENV variable to an app
-  aptible config:unset [VAR1] [VAR2] [...]                                                                                           # Remove an ENV variable from an app
-  aptible db:backup HANDLE                                                                                                           # Backup a database
-  aptible db:clone SOURCE DEST                                                                                                       # Clone a database to create a new one
-  aptible db:create HANDLE [--type TYPE] [--version VERSION] [--container-size SIZE_MB] [--size SIZE_GB]                             # Create a new database
-  aptible db:deprovision HANDLE                                                                                                      # Deprovision a database
-  aptible db:dump HANDLE [pg_dump options]                                                                                           # Dump a remote database to file
-  aptible db:execute HANDLE SQL_FILE [--on-error-stop]                                                                               # Executes sql against a database
-  aptible db:list                                                                                                                    # List all databases
-  aptible db:reload HANDLE                                                                                                           # Reload a database
-  aptible db:replicate HANDLE REPLICA_HANDLE [--container-size SIZE_MB] [--size SIZE_GB]                                             # Create a replica/follower of a database
-  aptible db:restart HANDLE [--container-size SIZE_MB] [--size SIZE_GB]                                                              # Restart a database
-  aptible db:tunnel HANDLE                                                                                                           # Create a local tunnel to a database
-  aptible db:url HANDLE                                                                                                              # Display a database URL
-  aptible db:versions                                                                                                                # List available database versions
-  aptible deploy [OPTIONS] [VAR1=VAL1] [VAR2=VAL2] [...]                                                                             # Deploy an app
-  aptible domains                                                                                                                    # Print an app's current virtual domains - DEPRECATED
-  aptible endpoints:database:create DATABASE                                                                                         # Create a Database Endpoint
-  aptible endpoints:deprovision [--app APP | --database DATABASE] ENDPOINT_HOSTNAME                                                  # Deprovision an App or Database Endpoint
-  aptible endpoints:https:create [--app APP] SERVICE                                                                                 # Create an App HTTPS Endpoint
-  aptible endpoints:https:modify [--app APP] ENDPOINT_HOSTNAME                                                                       # Modify an App HTTPS Endpoint
-  aptible endpoints:list [--app APP | --database DATABASE]                                                                           # List Endpoints for an App or Database
-  aptible endpoints:renew [--app APP] ENDPOINT_HOSTNAME                                                                              # Renew an App Managed TLS Endpoint
-  aptible endpoints:tcp:create [--app APP] SERVICE                                                                                   # Create an App TCP Endpoint
-  aptible endpoints:tcp:modify [--app APP] ENDPOINT_HOSTNAME                                                                         # Modify an App TCP Endpoint
-  aptible endpoints:tls:create [--app APP] SERVICE                                                                                   # Create an App TLS Endpoint
-  aptible endpoints:tls:modify [--app APP] ENDPOINT_HOSTNAME                                                                         # Modify an App TLS Endpoint
-  aptible help [COMMAND]                                                                                                             # Describe available commands or one specific command
-  aptible login                                                                                                                      # Log in to Aptible
-  aptible logs [--app APP | --database DATABASE]                                                                                     # Follows logs from a running app or database
-  aptible operation:cancel OPERATION_ID                                                                                              # Cancel a running operation
-  aptible ps                                                                                                                         # Display running processes for an app - DEPRECATED
-  aptible rebuild                                                                                                                    # Rebuild an app, and restart its services
-  aptible restart                                                                                                                    # Restart all services associated with an app
-  aptible services                                                                                                                   # List Services for an App
-  aptible ssh [COMMAND]                                                                                                              # Run a command against an app
-  aptible version                                                                                                                    # Print Aptible CLI version
+  aptible apps                                                                                                                                                # List all applications
+  aptible apps:create HANDLE                                                                                                                                  # Create a new application
+  aptible apps:deprovision                                                                                                                                    # Deprovision an app
+  aptible apps:scale SERVICE [--container-count COUNT] [--container-size SIZE_MB]                                                                             # Scale a service
+  aptible backup:list DB_HANDLE                                                                                                                               # List backups for a database
+  aptible backup:orphaned                                                                                                                                     # List backups associated with deprovisioned databases
+  aptible backup:purge BACKUP_ID                                                                                                                              # Permanently delete a backup and any copies of it
+  aptible backup:restore BACKUP_ID [--environment ENVIRONMENT_HANDLE] [--handle HANDLE] [--container-size SIZE_MB] [--disk-size SIZE_GB] [--key-arn KEY_ARN]  # Restore a backup
+  aptible config                                                                                                                                              # Print an app's current configuration
+  aptible config:add [VAR1=VAL1] [VAR2=VAL2] [...]                                                                                                            # Add an ENV variable to an app
+  aptible config:rm [VAR1] [VAR2] [...]                                                                                                                       # Remove an ENV variable from an app
+  aptible config:set [VAR1=VAL1] [VAR2=VAL2] [...]                                                                                                            # Add an ENV variable to an app
+  aptible config:unset [VAR1] [VAR2] [...]                                                                                                                    # Remove an ENV variable from an app
+  aptible db:backup HANDLE                                                                                                                                    # Backup a database
+  aptible db:clone SOURCE DEST                                                                                                                                # Clone a database to create a new one
+  aptible db:create HANDLE [--type TYPE] [--version VERSION] [--container-size SIZE_MB] [--disk-size SIZE_GB] [--key-arn KEY_ARN]                             # Create a new database
+  aptible db:deprovision HANDLE                                                                                                                               # Deprovision a database
+  aptible db:dump HANDLE [pg_dump options]                                                                                                                    # Dump a remote database to file
+  aptible db:execute HANDLE SQL_FILE [--on-error-stop]                                                                                                        # Executes sql against a database
+  aptible db:list                                                                                                                                             # List all databases
+  aptible db:reload HANDLE                                                                                                                                    # Reload a database
+  aptible db:replicate HANDLE REPLICA_HANDLE [--container-size SIZE_MB] [--disk-size SIZE_GB] [--logical --version VERSION] [--key-arn KEY_ARN]               # Create a replica/follower of a database
+  aptible db:restart HANDLE [--container-size SIZE_MB] [--disk-size SIZE_GB]                                                                                  # Restart a database
+  aptible db:tunnel HANDLE                                                                                                                                    # Create a local tunnel to a database
+  aptible db:url HANDLE                                                                                                                                       # Display a database URL
+  aptible db:versions                                                                                                                                         # List available database versions
+  aptible deploy [OPTIONS] [VAR1=VAL1] [VAR2=VAL2] [...]                                                                                                      # Deploy an app
+  aptible domains                                                                                                                                             # Print an app's current virtual domains - DEPRECATED
+  aptible endpoints:database:create DATABASE                                                                                                                  # Create a Database Endpoint
+  aptible endpoints:deprovision [--app APP | --database DATABASE] ENDPOINT_HOSTNAME                                                                           # Deprovision an App or Database Endpoint
+  aptible endpoints:https:create [--app APP] SERVICE                                                                                                          # Create an App HTTPS Endpoint
+  aptible endpoints:https:modify [--app APP] ENDPOINT_HOSTNAME                                                                                                # Modify an App HTTPS Endpoint
+  aptible endpoints:list [--app APP | --database DATABASE]                                                                                                    # List Endpoints for an App or Database
+  aptible endpoints:renew [--app APP] ENDPOINT_HOSTNAME                                                                                                       # Renew an App Managed TLS Endpoint
+  aptible endpoints:tcp:create [--app APP] SERVICE                                                                                                            # Create an App TCP Endpoint
+  aptible endpoints:tcp:modify [--app APP] ENDPOINT_HOSTNAME                                                                                                  # Modify an App TCP Endpoint
+  aptible endpoints:tls:create [--app APP] SERVICE                                                                                                            # Create an App TLS Endpoint
+  aptible endpoints:tls:modify [--app APP] ENDPOINT_HOSTNAME                                                                                                  # Modify an App TLS Endpoint
+  aptible help [COMMAND]                                                                                                                                      # Describe available commands or one specific command
+  aptible login                                                                                                                                               # Log in to Aptible
+  aptible logs [--app APP | --database DATABASE]                                                                                                              # Follows logs from a running app or database
+  aptible operation:cancel OPERATION_ID                                                                                                                       # Cancel a running operation
+  aptible ps                                                                                                                                                  # Display running processes for an app - DEPRECATED
+  aptible rebuild                                                                                                                                             # Rebuild an app, and restart its services
+  aptible restart                                                                                                                                             # Restart all services associated with an app
+  aptible services                                                                                                                                            # List Services for an App
+  aptible ssh [COMMAND]                                                                                                                                       # Run a command against an app
+  aptible version                                                                                                                                             # Print Aptible CLI version
 ```
 <!-- END USAGE -->
 

data/appveyor.yml

@@ -8,12 +8,6 @@ environment:
     - RUBY_VERSION: 23
 
 install:
-  # The SSL_CERT_* environment variables are here since otherwise calls to
-  # codecov.io wtill not work. These variables do have to be set in order for
-  # the gem to make calls to the Aptible API, since otherwise Ruby will fail
-  # with a certificate verification error.
-  - set SSL_CERT_DIR=%PROGRAMFILES%\Git\mingw64\ssl\certs
-  - set SSL_CERT_FILE=%PROGRAMFILES%\Git\mingw64\ssl\cert.pem
   # Override PATHEXT so our ssh bat file has a higher precedence.
   - set PATHEXT=.BAT;.COM;.EXE;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC
   - set PATH=C:\Ruby%RUBY_VERSION%-x64\bin;%PATH%
@@ -28,4 +22,4 @@ before_test:
   - bundle -v
 
 test_script:
-  - bundle exec rake ci
+  - bundle exec rake ci

data/aptible-cli.gemspec

@@ -21,8 +21,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'aptible-resource', '~> 1.1'
-  spec.add_dependency 'aptible-api', '~> 1.0'
-  spec.add_dependency 'aptible-auth', '~> 1.0'
+  spec.add_dependency 'aptible-api', '~> 1.2'
+  spec.add_dependency 'aptible-auth', '~> 1.2.3'
   spec.add_dependency 'aptible-billing', '~> 1.0'
   spec.add_dependency 'thor', '~> 0.20.0'
   spec.add_dependency 'git'

data/lib/aptible/cli/agent.rb

@@ -1,3 +1,4 @@
+require 'base64'
 require 'uri'
 
 require 'aptible/auth'
@@ -66,6 +67,7 @@ module Aptible
       def initialize(*)
         nag_toolbelt unless toolbelt?
         Aptible::Resource.configure { |conf| conf.user_agent = version_string }
+        warn_sso_enforcement
         super
       end
 
@@ -84,7 +86,22 @@ module Aptible
       option :lifetime, desc: 'The duration the token should be valid for ' \
                               '(example usage: 24h, 1d, 600s, etc.)'
       option :otp_token, desc: 'A token generated by your second-factor app'
+      option :sso, desc: 'Use a token from a Single Sign On login on the ' \
+                         'dashboard'
       def login
+        if options[:sso]
+          begin
+            token = options[:sso]
+            token = ask('Paste token copied from Dashboard:') if token == 'sso'
+            Base64.urlsafe_decode64(token.split('.').first)
+            save_token(token)
+            CLI.logger.info "Token written to #{token_file}"
+            return
+          rescue StandardError
+            raise Thor::Error, 'Invalid token provided for SSO'
+          end
+        end
+
         email = options[:email] || ask('Email: ')
         password = options[:password] || ask_then_line(
           'Password: ', echo: false
@@ -216,6 +233,22 @@ module Aptible
         end
       end
 
+      def warn_sso_enforcement
+        # If the user is also a member of
+        begin
+          token = fetch_token
+        rescue StandardError
+          return
+        end
+        reauth = Aptible::Auth::ReauthenticateOrganization.all(token: token)
+        return if reauth.empty?
+
+        CLI.logger.warn(['WARNING: You will need to use the appropriate',
+                         'login method (SSO or Aptible credentials) to access',
+                         'these organizations:',
+                         reauth.map(&:name)].join(' '))
+      end
+
       def version_string
         bits = [
           'aptible-cli',

data/lib/aptible/cli/helpers/database.rb

@@ -49,11 +49,20 @@ module Aptible
 
         def replicate_database(source, dest_handle, options)
           replication_params = {
-            type: 'replicate',
             handle: dest_handle,
             container_size: options[:container_size],
-            disk_size: options[:size]
+            disk_size: options[:size],
+            key_arn: options[:key_arn]
           }.reject { |_, v| v.nil? }
+
+          if options[:logical]
+            replication_params[:type] = 'replicate_logical'
+            replication_params[:docker_ref] =
+              options[:database_image].docker_repo
+          else
+            replication_params[:type] = 'replicate'
+          end
+
           op = source.create_operation!(replication_params)
           attach_to_operation_logs(op)
 
@@ -96,10 +105,11 @@ module Aptible
 
         def local_url(credential, local_port)
           remote_url = credential.connection_url
-          uri = URI.parse(remote_url)
 
+          uri = URI.parse(remote_url)
+          domain = credential.database.account.stack.internal_domain
           "#{uri.scheme}://#{uri.user}:#{uri.password}@" \
-          "localhost.aptible.in:#{local_port}#{uri.path}"
+          "localhost.#{domain}:#{local_port}#{uri.path}"
         end
 
         def find_credential(database, type = nil)

data/lib/aptible/cli/resource_formatter.rb

@@ -4,6 +4,41 @@ module Aptible
       class << self
         NO_NESTING = Object.new.freeze
 
+        def inject_backup(node, backup, include_db: false)
+          description = "#{backup.id}: #{backup.created_at}, " \
+                        "#{backup.aws_region}"
+
+          if include_db
+            db = backup.database_with_deleted
+            node.keyed_object('database', 'id') do |n|
+              inject_deleted_database(n, db, backup.account)
+            end
+
+            description = "#{description}, " \
+                          "#{db.handle} deleted at #{db.deleted_at}"
+          end
+
+          node.value('id', backup.id)
+          node.value('description', description)
+          node.value('created_at', backup.created_at)
+          node.value('region', backup.aws_region)
+          node.value('size', backup.size)
+
+          if backup.copied_from
+            node.keyed_object('copied_from', 'description') do |n|
+              inject_backup(n, backup.copied_from)
+            end
+          end
+        end
+
+        def inject_deleted_database(node, database, account)
+          node.value('id', database.id)
+          node.value('handle', database.handle)
+          node.value('type', database.type)
+          node.value('deleted_at', database.deleted_at)
+          attach_account(node, account)
+        end
+
         def inject_account(node, account)
           node.value('id', account.id)
           node.value('handle', account.handle)
@@ -47,6 +82,7 @@ module Aptible
 
           node.value('type', database.type)
           node.value('status', database.status)
+
           node.value('connection_url', database.connection_url)
 
           node.list('credentials') do |creds_list|
@@ -54,7 +90,6 @@ module Aptible
               creds_list.object { |n| inject_credential(n, cred) }
             end
           end
-
           attach_account(node, account)
         end
 

data/lib/aptible/cli/subcommands/backup.rb

@@ -9,12 +9,15 @@ module Aptible
 
             desc 'backup:restore BACKUP_ID ' \
                  '[--environment ENVIRONMENT_HANDLE] [--handle HANDLE] ' \
-                 '[--container-size SIZE_MB] [--size SIZE_GB]',
+                 '[--container-size SIZE_MB] [--disk-size SIZE_GB] ' \
+                 '[--key-arn KEY_ARN]',
                  'Restore a backup'
             option :handle, desc: 'a name to use for the new database'
             option :environment, desc: 'a different environment to restore to'
             option :container_size, type: :numeric
             option :size, type: :numeric
+            option :disk_size, type: :numeric
+            option :key_arn, type: :string
             define_method 'backup:restore' do |backup_id|
               backup = Aptible::Api::Backup.find(backup_id, token: fetch_token)
               raise Thor::Error, "Backup ##{backup_id} not found" if backup.nil?
@@ -22,7 +25,8 @@ module Aptible
               handle = options[:handle]
               unless handle
                 ts_suffix = backup.created_at.getgm.strftime '%Y-%m-%d-%H-%M-%S'
-                handle = "#{backup.database.handle}-at-#{ts_suffix}"
+                handle =
+                  "#{backup.database_with_deleted.handle}-at-#{ts_suffix}"
               end
 
               destination_account = if options[:environment]
@@ -35,10 +39,17 @@ module Aptible
                 type: 'restore',
                 handle: handle,
                 container_size: options[:container_size],
-                disk_size: options[:size],
-                destination_account: destination_account
+                disk_size: options[:disk_size] || options[:size],
+                destination_account: destination_account,
+                key_arn: options[:key_arn]
               }.delete_if { |_, v| v.nil? }
 
+              CLI.logger.warn([
+                'You have used the "--size" option to specify a disk size.',
+                'This option which be deprecated in a future version.',
+                'Please use the "--disk-size" option, instead.'
+              ].join("\n")) if options[:size]
+
               operation = backup.create_operation!(opts)
               CLI.logger.info "Restoring backup into #{handle}"
               attach_to_operation_logs(operation)
@@ -62,22 +73,58 @@ module Aptible
               database = ensure_database(options.merge(db: handle))
 
               Formatter.render(Renderer.current) do |root|
-                root.keyed_list('description') do |l|
+                root.keyed_list('description') do |node|
                   database.each_backup do |backup|
-                    break if backup.created_at < min_created_at
-                    description = "#{backup.id}: #{backup.created_at}, " \
-                      "#{backup.aws_region}"
+                    if backup.created_at < min_created_at && !backup.copied_from
+                      break
+                    end
+                    node.object do |n|
+                      ResourceFormatter.inject_backup(n, backup)
+                    end
+                  end
+                end
+              end
+            end
 
-                    l.object do |o|
-                      o.value('id', backup.id)
-                      o.value('description', description)
-                      o.value('created_at', backup.created_at)
-                      o.value('region', backup.aws_region)
+            desc 'backup:orphaned', 'List backups associated with ' \
+                                    'deprovisioned databases'
+            option :environment
+            option :max_age, default: '1y',
+                             desc: 'Limit backups returned '\
+                                   '(example usage: 1w, 1y, etc.)'
+            define_method 'backup:orphaned' do
+              age = ChronicDuration.parse(options[:max_age])
+              raise Thor::Error, "Invalid age: #{options[:max_age]}" if age.nil?
+              min_created_at = Time.now - age
+
+              Formatter.render(Renderer.current) do |root|
+                root.keyed_list('description') do |node|
+                  scoped_environments(options).each do |account|
+                    account.each_orphaned_backup do |backup|
+                      created_at = backup.created_at
+                      copied_from = backup.copied_from
+                      break if created_at < min_created_at && !copied_from
+                      node.object do |n|
+                        ResourceFormatter.inject_backup(
+                          n, backup, include_db: true
+                        )
+                      end
                     end
                   end
                 end
               end
             end
+
+            desc 'backup:purge BACKUP_ID',
+                 'Permanently delete a backup and any copies of it'
+            define_method 'backup:purge' do |backup_id|
+              backup = Aptible::Api::Backup.find(backup_id, token: fetch_token)
+              raise Thor::Error, "Backup ##{backup_id} not found" if backup.nil?
+
+              operation = backup.create_operation!(type: 'purge')
+              CLI.logger.info "Purging backup #{backup_id}"
+              attach_to_operation_logs(operation)
+            end
           end
         end
       end

data/lib/aptible/cli/subcommands/db.rb

@@ -53,12 +53,15 @@ module Aptible
 
             desc 'db:create HANDLE ' \
                  '[--type TYPE] [--version VERSION] ' \
-                 '[--container-size SIZE_MB] [--size SIZE_GB]',
+                 '[--container-size SIZE_MB] [--disk-size SIZE_GB] ' \
+                 '[--key-arn KEY_ARN]',
                  'Create a new database'
             option :type, type: :string
             option :version, type: :string
             option :container_size, type: :numeric
-            option :size, default: 10, type: :numeric
+            option :size, type: :numeric
+            option :disk_size, default: 10, type: :numeric
+            option :key_arn, type: :string
             option :environment
             define_method 'db:create' do |handle|
               account = ensure_environment(options)
@@ -66,9 +69,16 @@ module Aptible
               db_opts = {
                 handle: handle,
                 initial_container_size: options[:container_size],
-                initial_disk_size: options[:size]
+                initial_disk_size: options[:disk_size] || options[:size],
+                current_kms_arn: options[:key_arn]
               }.delete_if { |_, v| v.nil? }
 
+              CLI.logger.warn([
+                'You have used the "--size" option to specify a disk size.',
+                'This option which be deprecated in a future version.',
+                'Please use the "--disk-size" option, instead.'
+              ].join("\n")) if options[:size]
+
               type = options[:type]
               version = options[:version]
 
@@ -87,7 +97,7 @@ module Aptible
               op_opts = {
                 type: 'provision',
                 container_size: options[:container_size],
-                disk_size: options[:size]
+                disk_size: options[:disk_size] || options[:size]
               }.delete_if { |_, v| v.nil? }
               op = database.create_operation(op_opts)
 
@@ -115,15 +125,50 @@ module Aptible
             end
 
             desc 'db:replicate HANDLE REPLICA_HANDLE ' \
-                 '[--container-size SIZE_MB] [--size SIZE_GB]',
+                 '[--container-size SIZE_MB] [--disk-size SIZE_GB] ' \
+                 '[--logical --version VERSION] [--key-arn KEY_ARN]',
                  'Create a replica/follower of a database'
             option :environment
             option :container_size, type: :numeric
             option :size, type: :numeric
+            option :disk_size, type: :numeric
+            option :logical, type: :boolean
+            option :version, type: :string
+            option :key_arn, type: :string
             define_method 'db:replicate' do |source_handle, dest_handle|
               source = ensure_database(options.merge(db: source_handle))
+
+              if options[:logical]
+                if source.type != 'postgresql'
+                  raise Thor::Error, 'Logical replication only works for ' \
+                                     'PostgreSQL'
+                end
+                if options[:version]
+                  image = find_database_image(source.type, options[:version])
+                else
+                  raise Thor::Error, '--version is required for logical ' \
+                                     'replication'
+                end
+              end
+
               CLI.logger.info "Replicating #{source_handle}..."
-              database = replicate_database(source, dest_handle, options)
+
+              opts = {
+                environment: options[:environment],
+                container_size: options[:container_size],
+                size: options[:disk_size] || options[:size],
+                logical: options[:logical],
+                database_image: image || nil,
+                key_arn: options[:key_arn]
+              }.delete_if { |_, v| v.nil? }
+
+              CLI.logger.warn([
+                'You have used the "--size" option to specify a disk size.',
+                'This option which be deprecated in a future version.',
+                'Please use the "--disk-size" option, instead.'
+              ].join("\n")) if options[:size]
+
+              database = replicate_database(source, dest_handle, opts)
               render_database(database.reload, database.account)
             end
 
@@ -234,10 +279,11 @@ module Aptible
             end
 
             desc 'db:restart HANDLE ' \
-                 '[--container-size SIZE_MB] [--size SIZE_GB]',
+                 '[--container-size SIZE_MB] [--disk-size SIZE_GB]',
                  'Restart a database'
             option :environment
             option :container_size, type: :numeric
+            option :disk_size, type: :numeric
             option :size, type: :numeric
             define_method 'db:restart' do |handle|
               database = ensure_database(options.merge(db: handle))
@@ -245,9 +291,15 @@ module Aptible
               opts = {
                 type: 'restart',
                 container_size: options[:container_size],
-                disk_size: options[:size]
+                disk_size: options[:disk_size] || options[:size]
               }.delete_if { |_, v| v.nil? }
 
+              CLI.logger.warn([
+                'You have used the "--size" option to specify a disk size.',
+                'This option which be deprecated in a future version.',
+                'Please use the "--disk-size" option, instead.'
+              ].join("\n")) if options[:size]
+
               CLI.logger.info "Restarting #{database.handle}..."
               op = database.create_operation!(opts)
               attach_to_operation_logs(op)

data/lib/aptible/cli/subcommands/inspect.rb

@@ -19,7 +19,7 @@ module Aptible
             raise "Invalid scheme: #{uri.scheme} (use https)"
           end
 
-          apis = [Aptible::Auth, Aptible::Api, Aptible::Billing]
+          apis = [Aptible::Auth, Aptible::Api]
 
           api = apis.find do |klass|
             uri.host == URI(klass.configuration.root_url).host

data/lib/aptible/cli/version.rb

@@ -1,5 +1,5 @@
 module Aptible
   module CLI
-    VERSION = '0.16.3'.freeze
+    VERSION = '0.16.8'.freeze
   end
 end

data/spec/aptible/cli/agent_spec.rb

@@ -258,6 +258,36 @@ describe Aptible::CLI::Agent do
           subject.login
         end
       end
+
+      context 'SSO logins' do
+        let(:token) { 'eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzUxMiJ9.eyJpZCI6I' }
+
+        it 'accepts a token as an argument' do
+          options = { sso: token }
+          allow(subject).to receive(:options).and_return options
+
+          expect(subject).to receive(:save_token).with(token)
+
+          subject.login
+        end
+
+        it 'rejects clearly invalid tokens' do
+          options = { sso: 'blarg' }
+          allow(subject).to receive(:options).and_return options
+
+          expect { subject.login }.to raise_error Thor::Error
+        end
+
+        it 'prompts for a token if none provided' do
+          options = { sso: 'sso' }
+          allow(subject).to receive(:options).and_return options
+
+          expect(subject).to receive(:ask).once.and_return(token)
+          expect(subject).to receive(:save_token).with(token)
+
+          subject.login
+        end
+      end
     end
   end
 

data/spec/aptible/cli/subcommands/backup_spec.rb

@@ -2,14 +2,17 @@ require 'spec_helper'
 
 describe Aptible::CLI::Agent do
   let(:token) { 'some-token' }
-  let(:account) { Fabricate(:account, handle: 'test') }
+  let(:account) { Fabricate(:account, handle: 'test', id: 1) }
   let(:alt_account) { Fabricate(:account, handle: 'alt') }
   let(:database) { Fabricate(:database, account: account, handle: 'some-db') }
   let!(:backup) do
     # created_at: 2016-06-14 13:24:11 +0000
     Fabricate(
       :backup,
-      database: database, created_at: Time.at(1465910651), account: account
+      database_with_deleted: database,
+      created_at: Time.at(1465910651),
+      account: account,
+      id: 1
     )
   end
 
@@ -178,4 +181,78 @@ describe Aptible::CLI::Agent do
         .to raise_error(Thor::Error, 'Could not find database nope')
     end
   end
+
+  describe '#backup:orphaned' do
+    before { allow(Aptible::Api::Account).to receive(:all) { [account] } }
+    before do
+      m = allow(account).to receive(:each_orphaned_backup)
+      ages = [
+        1.day, 2.days, 3.days, 4.days,
+        5.days, 2.weeks, 3.weeks, 1.month,
+        1.year
+      ]
+      ages.each do |age|
+        b = Fabricate(:backup, database: database, created_at: age.ago,
+                               account: account)
+        allow(b).to receive(:database_with_deleted).and_return(database)
+        m.and_yield(b)
+        b
+      end
+    end
+    before { subject.options = { max_age: '1w' } }
+
+    it 'can show a subset of backups' do
+      subject.send('backup:orphaned')
+      puts captured_output_text
+      expect(captured_output_text.split("\n").size).to eq(5)
+    end
+
+    it 'allows scoping via environment' do
+      subject.options = { max_age: '1w', environment: database.account.handle }
+      subject.send('backup:orphaned')
+      expect(captured_output_text.split("\n").size).to eq(5)
+    end
+
+    it 'shows more backups if requested' do
+      subject.options = { max_age: '2y' }
+      subject.send('backup:orphaned')
+      expect(captured_output_text.split("\n").size).to eq(9)
+    end
+
+    it 'errors out if max_age is invalid' do
+      subject.options = { max_age: 'foobar' }
+      expect { subject.send('backup:orphaned') }
+        .to raise_error(Thor::Error, 'Invalid age: foobar')
+    end
+  end
+
+  describe '#backup:purge' do
+    it 'fails if the backup cannot be found' do
+      expect(Aptible::Api::Backup).to receive(:find)
+        .with(1, token: token).and_return(nil)
+
+      expect { subject.send('backup:purge', 1) }
+        .to raise_error('Backup #1 not found')
+    end
+
+    context 'successful purge' do
+      let(:op) { Fabricate(:operation, resource: backup) }
+
+      before do
+        expect(Aptible::Api::Backup).to receive(:find)
+          .with(1, token: token).and_return(backup)
+      end
+
+      it 'creates a purge operation on the backup' do
+        expect(backup).to receive(:create_operation!) do |options|
+          expect(options[:type]).to eq('purge')
+          op
+        end
+
+        expect(subject).to receive(:attach_to_operation_logs).with(op)
+
+        subject.send('backup:purge', 1)
+      end
+    end
+  end
 end

data/spec/aptible/cli/subcommands/db_spec.rb

@@ -13,7 +13,9 @@ describe Aptible::CLI::Agent do
   end
 
   let(:handle) { 'foobar' }
-  let(:database) { Fabricate(:database, handle: handle) }
+  let(:stack) { Fabricate(:stack, internal_domain: 'aptible.in') }
+  let(:account) { Fabricate(:account, stack: stack) }
+  let(:database) { Fabricate(:database, handle: handle, account: account) }
   let(:socat_helper) { SocatHelperMock.new(port: 4242) }
 
   describe '#db:create' do
@@ -55,7 +57,7 @@ describe Aptible::CLI::Agent do
       subject.send('db:create', 'foo')
     end
 
-    it 'creates a new DB with a disk size' do
+    it 'creates a new DB with a (implicitly) disk size' do
       expect_provision_database(
         { handle: 'foo', type: 'postgresql', initial_disk_size: 200 },
         { disk_size: 200 }
@@ -65,6 +67,16 @@ describe Aptible::CLI::Agent do
       subject.send('db:create', 'foo')
     end
 
+    it 'creates a new DB with a disk-size' do
+      expect_provision_database(
+        { handle: 'foo', type: 'postgresql', initial_disk_size: 200 },
+        { disk_size: 200 }
+      )
+
+      subject.options = { type: 'postgresql', disk_size: 200 }
+      subject.send('db:create', 'foo')
+    end
+
     it 'deprovisions the database if the operation cannot be created' do
       db = Fabricate(:database)
 
@@ -377,7 +389,7 @@ describe Aptible::CLI::Agent do
       expect(captured_logs).to match(/restarting foobar/i)
     end
 
-    it 'allows restarting a database with a disk size' do
+    it 'allows restarting a database with (implicitly disk) size' do
       expect(database).to receive(:create_operation!)
         .with(type: 'restart', disk_size: 40).and_return(op)
 
@@ -389,6 +401,18 @@ describe Aptible::CLI::Agent do
       expect(captured_logs).to match(/restarting foobar/i)
     end
 
+    it 'allows restarting a database with a disk-size' do
+      expect(database).to receive(:create_operation!)
+        .with(type: 'restart', disk_size: 40).and_return(op)
+
+      expect(subject).to receive(:attach_to_operation_logs).with(op)
+
+      subject.options = { disk_size: 40 }
+      subject.send('db:restart', handle)
+
+      expect(captured_logs).to match(/restarting foobar/i)
+    end
+
     it 'fails if the DB is not found' do
       expect { subject.send('db:restart', 'nope') }
         .to raise_error(Thor::Error, 'Could not find database nope')
@@ -485,14 +509,81 @@ describe Aptible::CLI::Agent do
       expect_replicate_database(container_size: 40)
     end
 
-    it 'allows replicating a database with a disk size' do
+    it 'allows replicating a database with an (implicitly) disk size option' do
       expect_replicate_database(size: 40)
     end
 
+    it 'allows replicating a database with a disk-size option' do
+      expect_replicate_database(disk_size: 40)
+    end
+
     it 'fails if the DB is not found' do
       expect { subject.send('db:replicate', 'nope', 'replica') }
         .to raise_error(Thor::Error, 'Could not find database nope')
     end
+
+    it 'allows logical replication of a database with --version set' do
+      master = Fabricate(:database, handle: 'master')
+      databases << master
+      replica = Fabricate(:database,
+                          account: master.account,
+                          handle: 'replica')
+
+      dbimg = Fabricate(:database_image,
+                        type: 'postgresql',
+                        version: 10,
+                        docker_repo: 'aptible/postgresql:10')
+
+      expect(subject).to receive(:find_database_image).with('postgresql', 10)
+        .and_return(dbimg)
+
+      op = Fabricate(:operation)
+
+      params = { type: 'replicate_logical', handle: 'replica',
+                 docker_ref: dbimg.docker_repo }
+      expect(master).to receive(:create_operation!)
+        .with(**params).and_return(op)
+
+      expect(subject).to receive(:attach_to_operation_logs).with(op) do
+        databases << replica
+        replica
+      end
+
+      provision = Fabricate(:operation)
+
+      expect(replica).to receive_message_chain(:operations, :last)
+        .and_return(provision)
+
+      expect(subject).to receive(:attach_to_operation_logs).with(provision)
+
+      expect(replica).to receive(:reload).and_return(replica)
+
+      subject.options = { logical: true, version: 10 }
+      subject.send('db:replicate', 'master', 'replica')
+
+      expect(captured_logs).to match(/replicating master/i)
+    end
+
+    it 'fails if logical replication requested without --version' do
+      master = Fabricate(:database, handle: 'master', type: 'postgresql')
+      databases << master
+
+      subject.options = { type: 'replicate', handle: 'replica', logical: true }
+      expect { subject.send('db:replicate', 'master', 'replica') }
+        .to raise_error(Thor::Error, '--version is required for logical ' \
+                                     'replication')
+    end
+
+    it 'fails if logical replication requested for non-postgres db' do
+      master = Fabricate(:database, handle: 'master', type: 'mysql')
+      databases << master
+
+      subject.options = { type: 'replicate', handle: 'replica',
+                          logical: true, version: 10 }
+      expect { subject.send('db:replicate', 'master', 'replica') }
+        .to raise_error(Thor::Error, 'Logical replication only works for ' \
+                                     'PostgreSQL')
+    end
   end
 
   describe '#db:dump' do

data/spec/spec_helper.rb

@@ -3,14 +3,6 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 Bundler.require :development
 
-require 'simplecov'
-SimpleCov.start
-
-if ENV['CI']
-  require 'codecov'
-  SimpleCov.formatter = SimpleCov::Formatter::Codecov
-end
-
 # Load shared spec files
 Dir["#{File.dirname(__FILE__)}/shared/**/*.rb"].each do |file|
   require file

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aptible-cli
 version: !ruby/object:Gem::Version
-  version: 0.16.3
+  version: 0.16.8
 platform: ruby
 authors:
 - Frank Macreery
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-24 00:00:00.000000000 Z
+date: 2020-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aptible-resource
@@ -30,28 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: aptible-auth
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.2.3
 - !ruby/object:Gem::Dependency
   name: aptible-billing
   requirement: !ruby/object:Gem::Requirement
@@ -359,7 +359,7 @@ homepage: https://github.com/aptible/aptible-cli
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -374,9 +374,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: Command-line interface for Aptible services
 test_files: