aptible-cli 0.18.2 → 0.19.2

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

@@ -39,16 +39,17 @@ module Aptible
                 type: 'restore',
                 handle: handle,
                 container_size: options[:container_size],
-                disk_size: options[:disk_size] || options[:size],
+                disk_size: options[:disk_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]
+              if options[:size]
+                m = 'You have used the "--size" option to specify a disk size.'\
+                    'This abiguous option has been removed.'\
+                    'Please use the "--disk-size" option, instead.'
+                raise Thor::Error, m
+              end
 
               operation = backup.create_operation!(opts)
               CLI.logger.info "Restoring backup into #{handle}"
@@ -123,7 +124,14 @@ module Aptible
 
               operation = backup.create_operation!(type: 'purge')
               CLI.logger.info "Purging backup #{backup_id}"
-              attach_to_operation_logs(operation)
+              begin
+                attach_to_operation_logs(operation)
+              rescue HyperResource::ClientError => e
+                # A 404 here means that the operation completed successfully,
+                # and was removed faster than attach_to_operation_logs
+                # could attach to the logs.
+                raise if e.response.status != 404
+              end
             end
           end
         end

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

@@ -59,8 +59,8 @@ module Aptible
             option :type, type: :string
             option :version, type: :string
             option :container_size, type: :numeric
-            option :size, type: :numeric
             option :disk_size, default: 10, type: :numeric
+            option :size, type: :numeric
             option :key_arn, type: :string
             option :environment
             define_method 'db:create' do |handle|
@@ -69,15 +69,16 @@ module Aptible
               db_opts = {
                 handle: handle,
                 initial_container_size: options[:container_size],
-                initial_disk_size: options[:disk_size] || options[:size],
+                initial_disk_size: options[:disk_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]
+              if options[:size]
+                m = 'You have used the "--size" option to specify a disk size.'\
+                    'This abiguous option has been removed.'\
+                    'Please use the "--disk-size" option, instead.'
+                raise Thor::Error, m
+              end
 
               type = options[:type]
               version = options[:version]
@@ -97,7 +98,7 @@ module Aptible
               op_opts = {
                 type: 'provision',
                 container_size: options[:container_size],
-                disk_size: options[:disk_size] || options[:size]
+                disk_size: options[:disk_size]
               }.delete_if { |_, v| v.nil? }
               op = database.create_operation(op_opts)
 
@@ -156,17 +157,18 @@ module Aptible
               opts = {
                 environment: options[:environment],
                 container_size: options[:container_size],
-                size: options[:disk_size] || options[:size],
+                size: options[:disk_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]
+              if options[:size]
+                m = 'You have used the "--size" option to specify a disk size.'\
+                    'This abiguous option has been removed.'\
+                    'Please use the "--disk-size" option, instead.'
+                raise Thor::Error, m
+              end
 
               database = replicate_database(source, dest_handle, opts)
               render_database(database.reload, database.account)
@@ -279,7 +281,7 @@ module Aptible
             end
 
             desc 'db:restart HANDLE ' \
-                 '[--container-size SIZE_MB] [--disk-size SIZE_GB]' \
+                 '[--container-size SIZE_MB] [--disk-size SIZE_GB] ' \
                  '[--iops IOPS] [--volume-type [gp2, gp3]]',
                  'Restart a database'
             option :environment
@@ -294,16 +296,17 @@ module Aptible
               opts = {
                 type: 'restart',
                 container_size: options[:container_size],
-                disk_size: options[:disk_size] || options[:size],
+                disk_size: options[:disk_size],
                 provisioned_iops: options[:iops],
                 ebs_volume_type: options[:volume_type]
               }.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]
+              if options[:size]
+                m = 'You have used the "--size" option to specify a disk size.'\
+                    'This abiguous option has been removed.'\
+                    'Please use the "--disk-size" option, instead.'
+                raise Thor::Error, m
+              end
 
               CLI.logger.info "Restarting #{database.handle}..."
               op = database.create_operation!(opts)

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

@@ -33,6 +33,22 @@ module Aptible
               provision_vhost_and_explain(service, vhost)
             end
 
+            database_modify_flags = Helpers::Vhost::OptionSetBuilder.new do
+              database!
+            end
+
+            desc 'endpoints:database:modify --database DATABASE ' \
+                 'ENDPOINT_HOSTNAME',
+                 'Modify a Database Endpoint'
+            database_modify_flags.declare_options(self)
+            define_method 'endpoints:database:modify' do |hostname|
+              database = ensure_database(options.merge(db: options[:database]))
+              vhost = find_vhost(each_service(database), hostname)
+              vhost.update!(**database_modify_flags.prepare(database.account,
+                                                            options))
+              provision_vhost_and_explain(vhost.service, vhost)
+            end
+
             tcp_create_flags = Helpers::Vhost::OptionSetBuilder.new do
               app!
               create!

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

@@ -0,0 +1,159 @@
+module Aptible
+  module CLI
+    module Subcommands
+      module LogDrain
+        def self.included(thor)
+          thor.class_eval do
+            include Helpers::Token
+            include Helpers::Database
+            include Helpers::LogDrain
+
+            drain_flags = '--environment ENVIRONMENT ' \
+                          '[--drain-apps true/false] ' \
+                          '[--drain_databases true/false] ' \
+                          '[--drain_ephemeral_sessions true/false] ' \
+                          '[--drain_proxies true/false]'
+
+            def self.drain_options
+              option :drain_apps, default: true, type: :boolean
+              option :drain_databases, default: true, type: :boolean
+              option :drain_ephemeral_sessions, default: true, type: :boolean
+              option :drain_proxies, default: true, type: :boolean
+              option :environment
+            end
+
+            desc 'log_drain:list', 'List all Log Drains'
+            option :environment
+            define_method 'log_drain:list' do
+              Formatter.render(Renderer.current) do |root|
+                root.grouped_keyed_list(
+                  { 'environment' => 'handle' },
+                  'handle'
+                ) do |node|
+                  scoped_environments(options).each do |account|
+                    account.log_drains.each do |drain|
+                      node.object do |n|
+                        ResourceFormatter.inject_log_drain(n, drain, account)
+                      end
+                    end
+                  end
+                end
+              end
+            end
+
+            desc 'log_drain:create:elasticsearch HANDLE '\
+                 '--db DATABASE_HANDLE ' \
+                 + drain_flags,
+                 'Create an Elasticsearch Log Drain'
+            drain_options
+            option :db, type: :string
+            option :pipeline, type: :string
+            define_method 'log_drain:create:elasticsearch' do |handle|
+              account = ensure_environment(options)
+              database = ensure_database(options)
+
+              opts = {
+                handle: handle,
+                database_id: database.id,
+                logging_token: options[:pipeline],
+                drain_apps: options[:drain_apps],
+                drain_databases: options[:drain_databases],
+                drain_ephemeral_sessions: options[:drain_ephemeral_sessions],
+                drain_proxies: options[:drain_proxies],
+                drain_type: :elasticsearch_database
+              }
+
+              create_log_drain(account, opts)
+            end
+
+            desc 'log_drain:create:datadog HANDLE ' \
+                 '--url DATADOG_URL ' \
+                 + drain_flags,
+                 'Create a Datadog Log Drain'
+            drain_options
+            option :url, type: :string
+            define_method 'log_drain:create:datadog' do |handle|
+              msg = 'Must be in the format of ' \
+                    '"https://http-intake.logs.datadoghq.com' \
+                    '/v1/input/<DD_API_KEY>".'
+              create_https_based_log_drain(handle, options, url_format_msg: msg)
+            end
+
+            desc 'log_drain:create:https HANDLE ' \
+                 '--url URL ' \
+                 + drain_flags,
+                 'Create a HTTPS Drain'
+            option :url, type: :string
+            drain_options
+            define_method 'log_drain:create:https' do |handle|
+              create_https_based_log_drain(handle, options)
+            end
+
+            desc 'log_drain:create:sumologic HANDLE ' \
+                 '--url SUMOLOGIC_URL ' \
+                 + drain_flags,
+                 'Create a Sumologic Drain'
+            option :url, type: :string
+            drain_options
+            define_method 'log_drain:create:sumologic' do |handle|
+              create_https_based_log_drain(handle, options)
+            end
+
+            desc 'log_drain:create:logdna HANDLE ' \
+                 '--url LOGDNA_URL ' \
+                 + drain_flags,
+                 'Create a LogDNA Log Drain'
+            option :url, type: :string
+            drain_options
+            define_method 'log_drain:create:logdna' do |handle|
+              msg = 'Must be in the format of ' \
+                    '"https://logs.logdna.com/aptible/ingest/<INGESTION KEY>".'
+              create_https_based_log_drain(handle, options, url_format_msg: msg)
+            end
+
+            desc 'log_drain:create:papertrail HANDLE ' \
+                 '--host PAPERTRAIL_HOST --port PAPERTRAIL_PORT ' \
+                 + drain_flags,
+                 'Create a Papertrail Log Drain'
+            option :host, type: :string
+            option :port, type: :string
+            drain_options
+            define_method 'log_drain:create:papertrail' do |handle|
+              create_syslog_based_log_drain(handle, options)
+            end
+
+            desc 'log_drain:create:syslog HANDLE ' \
+                 '--host SYSLOG_HOST --port SYSLOG_PORT ' \
+                 '[--token TOKEN] ' \
+                 + drain_flags,
+                 'Create a Papertrail Log Drain'
+            option :host, type: :string
+            option :port, type: :string
+            option :token, type: :string
+            drain_options
+            define_method 'log_drain:create:syslog' do |handle|
+              create_syslog_based_log_drain(handle, options)
+            end
+
+            desc 'log_drain:deprovision HANDLE --environment ENVIRONMENT',
+                 'Deprovisions a log drain'
+            option :environment
+            define_method 'log_drain:deprovision' do |handle|
+              account = ensure_environment(options)
+              drain = ensure_log_drain(account, handle)
+              op = drain.create_operation(type: :deprovision)
+              begin
+                attach_to_operation_logs(op)
+              rescue HyperResource::ClientError => e
+                # A 404 here means that the operation completed successfully,
+                # and was removed faster than attach_to_operation_logs
+                # could attach to the logs.
+                raise if e.response.status != 404
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+module Aptible
+  module CLI
+    module Subcommands
+      module MetricDrain
+        SITES = {
+          'US1' => 'https://app.datadoghq.com',
+          'US3' => 'https://us3.datadoghq.com',
+          'EU1' => 'https://app.datadoghq.eu',
+          'US1-FED' => 'https://app.ddog-gov.com'
+        }.freeze
+
+        def self.included(thor)
+          thor.class_eval do
+            include Helpers::Token
+            include Helpers::Database
+            include Helpers::MetricDrain
+
+            desc 'metric_drain:list', 'List all Metric Drains'
+            option :environment
+            define_method 'metric_drain:list' do
+              Formatter.render(Renderer.current) do |root|
+                root.grouped_keyed_list(
+                  { 'environment' => 'handle' },
+                  'handle'
+                ) do |node|
+                  scoped_environments(options).each do |account|
+                    account.metric_drains.each do |drain|
+                      node.object do |n|
+                        ResourceFormatter.inject_metric_drain(n, drain, account)
+                      end
+                    end
+                  end
+                end
+              end
+            end
+
+            desc 'metric_drain:create:influxdb HANDLE '\
+                 '--db DATABASE_HANDLE --environment ENVIRONMENT',
+                 'Create an InfluxDB Metric Drain'
+            option :db, type: :string
+            option :environment
+
+            define_method 'metric_drain:create:influxdb' do |handle|
+              account = ensure_environment(options)
+              database = ensure_database(options)
+
+              opts = {
+                handle: handle,
+                database_id: database.id,
+                drain_type: :influxdb_database
+              }
+
+              create_metric_drain(account, opts)
+            end
+
+            desc 'metric_drain:create:influxdb:custom HANDLE '\
+                 '--username USERNAME --password PASSWORD ' \
+                 '--url URL_INCLUDING_PORT ' \
+                 '--db INFLUX_DATABASE_NAME ' \
+                 '--environment ENVIRONMENT',
+                 'Create an InfluxDB Metric Drain'
+            option :db, type: :string
+            option :username, type: :string
+            option :password, type: :string
+            option :url, type: :string
+            option :db, type: :string
+            option :environment
+            define_method 'metric_drain:create:influxdb:custom' do |handle|
+              account = ensure_environment(options)
+
+              config = {
+                address: options[:url],
+                username: options[:username],
+                password: options[:password],
+                database: options[:db]
+              }
+              opts = {
+                handle: handle,
+                drain_configuration: config,
+                drain_type: :influxdb
+              }
+
+              create_metric_drain(account, opts)
+            end
+
+            desc 'metric_drain:create:datadog HANDLE '\
+                 '--api_key DATADOG_API_KEY '\
+                 '--site DATADOG_SITE ' \
+                 '--environment ENVIRONMENT',
+                 'Create a Datadog Metric Drain'
+            option :api_key, type: :string
+            option :site, type: :string
+            option :environment
+            define_method 'metric_drain:create:datadog' do |handle|
+              account = ensure_environment(options)
+
+              config = {
+                api_key: options[:api_key]
+              }
+              unless options[:site].nil?
+                site = SITES[options[:site]]
+
+                unless site
+                  sites = SITES.keys.join(', ')
+                  raise Thor::Error, 'Invalid Datadog site. ' \
+                                     "Valid options are #{sites}"
+                end
+
+                config[:series_url] = site
+              end
+              opts = {
+                handle: handle,
+                drain_type: :datadog,
+                drain_configuration: config
+              }
+
+              create_metric_drain(account, opts)
+            end
+
+            desc 'metric_drain:deprovision HANDLE --environment ENVIRONMENT',
+                 'Deprovisions a Metric Drain'
+            option :environment
+            define_method 'metric_drain:deprovision' do |handle|
+              account = ensure_environment(options)
+              drain = ensure_metric_drain(account, handle)
+              op = drain.create_operation(type: :deprovision)
+              begin
+                attach_to_operation_logs(op)
+              rescue HyperResource::ClientError => e
+                # A 404 here means that the operation completed successfully,
+                # and was removed faster than attach_to_operation_logs
+                # could attach to the logs.
+                raise if e.response.status != 404
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aptible/cli/version.rb

@@ -1,5 +1,5 @@
 module Aptible
   module CLI
-    VERSION = '0.18.2'.freeze
+    VERSION = '0.19.2'.freeze
   end
 end

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

@@ -253,42 +253,6 @@ describe Aptible::CLI::Agent do
           .to raise_error(/provide at least/im)
       end
 
-      it 'should scale container count (legacy)' do
-        stub_options
-        expect(service).to receive(:create_operation!)
-          .with(type: 'scale', container_count: 3)
-          .and_return(op)
-        subject.send('apps:scale', 'web', '3')
-        expect(captured_logs).to match(/deprecated/i)
-      end
-
-      it 'should scale container size (legacy)' do
-        stub_options(size: 90210)
-        expect(service).to receive(:create_operation!)
-          .with(type: 'scale', container_size: 90210)
-          .and_return(op)
-        subject.send('apps:scale', 'web')
-        expect(captured_logs).to match(/deprecated/i)
-      end
-
-      it 'should fail when using both current and legacy count' do
-        stub_options(container_count: 2)
-        expect { subject.send('apps:scale', 'web', '3') }
-          .to raise_error(/count was passed via both/im)
-      end
-
-      it 'should fail when using both current and legacy size' do
-        stub_options(container_size: 1024, size: 512)
-        expect { subject.send('apps:scale', 'web') }
-          .to raise_error(/size was passed via both/im)
-      end
-
-      it 'should fail when using too many arguments' do
-        stub_options
-        expect { subject.send('apps:scale', 'web', '3', '4') }
-          .to raise_error(/usage:.*apps:scale/im)
-      end
-
       it 'should fail if the service does not exist' do
         stub_options(container_count: 2)
 
@@ -323,17 +287,6 @@ describe Aptible::CLI::Agent do
         subject.send('apps:scale', 'web')
       end.to raise_error(Thor::Error)
     end
-
-    it 'should fail if number is not a valid number (legacy)' do
-      allow(subject).to receive(:options) { { app: 'hello' } }
-      allow(service).to receive(:create_operation) { op }
-
-      expect do
-        subject.send('apps:scale', 'web', 'potato')
-      end.to raise_error(ArgumentError)
-
-      expect(captured_logs).to match(/deprecated/i)
-    end
   end
 
   describe '#apps:deprovision' do

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

@@ -112,7 +112,7 @@ describe Aptible::CLI::Agent do
           Fabricate(:database, account: account, handle: default_handle)
         end
 
-        subject.options = { size: s }
+        subject.options = { disk_size: s }
         subject.send('backup:restore', 1)
       end
 

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

@@ -57,16 +57,6 @@ describe Aptible::CLI::Agent do
       subject.send('db:create', 'foo')
     end
 
-    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 }
-      )
-
-      subject.options = { type: 'postgresql', size: 200 }
-      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 },
@@ -414,18 +404,6 @@ describe Aptible::CLI::Agent do
       expect(captured_logs).to match(/restarting foobar/i)
     end
 
-    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)
-
-      expect(subject).to receive(:attach_to_operation_logs).with(op)
-
-      subject.options = { size: 40 }
-      subject.send('db:restart', handle)
-
-      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)
@@ -581,10 +559,6 @@ describe Aptible::CLI::Agent do
       expect_replicate_database(container_size: 40)
     end
 
-    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

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

@@ -94,6 +94,45 @@ describe Aptible::CLI::Agent do
         stub_options(ip_whitelist: %w(1.1.1.1))
         subject.send('endpoints:database:create', 'mydb')
       end
+
+      it 'creates an internal Database Endpoint' do
+        expect_create_vhost(db.service, internal: true)
+        stub_options(internal: true)
+        subject.send('endpoints:database:create', 'mydb')
+      end
+    end
+
+    describe 'endpoints:database:modify' do
+      it 'does not change anything if no options are passed' do
+        v = Fabricate(:vhost, service: db.service)
+        expect_modify_vhost(v, {})
+        stub_options(database: 'mydb')
+        subject.send('endpoints:database:modify', v.external_host)
+      end
+
+      it 'adds an IP whitelist' do
+        v = Fabricate(:vhost, service: db.service)
+        expect_modify_vhost(v, ip_whitelist: %w(1.1.1.1))
+
+        stub_options(database: 'mydb', ip_whitelist: %w(1.1.1.1))
+        subject.send('endpoints:database:modify', v.external_host)
+      end
+
+      it 'removes an IP whitelist' do
+        v = Fabricate(:vhost, service: db.service)
+        expect_modify_vhost(v, ip_whitelist: [])
+
+        stub_options(database: 'mydb', :'no-ip_whitelist' => true)
+        subject.send('endpoints:database:modify', v.external_host)
+      end
+
+      it 'does not allow disabling and adding an IP whitelist' do
+        v = Fabricate(:vhost, service: db.service)
+        stub_options(database: 'mydb', ip_whitelist: %w(1.1.1.1),
+                     :'no-ip_whitelist' => true)
+        expect { subject.send('endpoints:database:modify', v.external_host) }
+          .to raise_error(/conflicting.*no-ip-whitelist.*ip-whitelist/im)
+      end
     end
 
     describe 'endpoints:list' do