aptible-cli 0.18.3 → 0.19.0

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)
@@ -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/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,137 @@
+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',
+                 '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 --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.3'.freeze
+    VERSION = '0.19.0'.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