aptible-cli 0.18.1 → 0.19.1

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

@@ -52,52 +52,17 @@ module Aptible
             app_options
             option :container_count, type: :numeric
             option :container_size, type: :numeric
-            option :size, type: :numeric,
-                          desc: 'DEPRECATED, use --container-size'
-            define_method 'apps:scale' do |type, *more|
+            define_method 'apps:scale' do |type|
               service = ensure_service(options, type)
 
               container_count = options[:container_count]
               container_size = options[:container_size]
 
-              # There are two legacy options we have to process here:
-              # - We used to accept apps:scale SERVICE COUNT
-              # - We used to accept --size
-              case more.size
-              when 0
-                # Noop
-              when 1
-                if container_count.nil?
-                  m = 'Passing container count as a positional ' \
-                      'argument is deprecated, use --container-count'
-                  CLI.logger.warn(m)
-                  container_count = Integer(more.first)
-                else
-                  raise Thor::Error, 'Container count was passed via both ' \
-                                     'the --container-count keyword argument ' \
-                                     'and a positional argument. ' \
-                                     'Use only --container-count to proceed.'
-                end
-              else
-                # Unfortunately, Thor does not want to let us easily hook into
-                # its usage formatting, so we have to work around it here.
-                command = thor.commands.fetch('apps:scale')
-                error = ArgumentError.new
-                args = [type] + more
-                thor.handle_argument_error(command, error, args, 1)
-              end
-
               if options[:size]
-                if container_size.nil?
-                  m = 'Passing container size via the --size keyword ' \
-                      'argument is deprecated, use --container-size'
-                  CLI.logger.warn(m)
-                  container_size = options[:size]
-                else
-                  raise Thor::Error, 'Container size was passed via both ' \
-                                     '--container-size and --size. ' \
-                                     'Use only --container-size to proceed.'
-                end
+                m = 'You have used the "--size" option to specify a container '\
+                    'size. This abiguous option has been removed.'\
+                    'Please use the "--container-size" option, instead.'
+                raise Thor::Error, m
               end
 
               if container_count.nil? && container_size.nil?

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