aptible-cli 0.18.2 → 0.19.2

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

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe Aptible::CLI::Agent do
+  let(:account) { Fabricate(:account) }
+  let!(:log_drain) do
+    Fabricate(:log_drain, handle: 'test', account: account)
+  end
+
+  let(:token) { double('token') }
+  before { allow(subject).to receive(:fetch_token).and_return(token) }
+
+  before do
+    allow(Aptible::Api::Account).to receive(:all)
+      .with(token: token).and_return([account])
+  end
+
+  describe '#log_drain:list' do
+    it 'lists a log drains for an account' do
+      subject.send('log_drain:list')
+
+      out = "=== aptible\n" \
+            "test\n"
+      expect(captured_output_text).to eq(out)
+    end
+
+    it 'lists log drains across multiple accounts' do
+      other_account = Fabricate(:account)
+      Fabricate(:log_drain, handle: 'test2', account: other_account)
+      accounts = [account, other_account]
+      allow(Aptible::Api::Account).to receive(:all).and_return(accounts)
+
+      subject.send('log_drain:list')
+
+      out = "=== aptible\n" \
+            "test\n" \
+            "test2\n"
+      expect(captured_output_text).to eq(out)
+    end
+
+    it 'lists log drains for a single account when --environment is included' do
+      other_account = Fabricate(:account)
+      Fabricate(:log_drain, handle: 'test2', account: other_account)
+      accounts = [account, other_account]
+      allow(Aptible::Api::Account).to receive(:all).and_return(accounts)
+
+      subject.options = { environment: account.handle }
+      subject.send('log_drain:list')
+
+      out = "=== aptible\n" \
+            "test\n"
+      expect(captured_output_text).to eq(out)
+    end
+  end
+
+  describe '#log_drain:create' do
+    def expect_provision_log_drain(create_opts, provision_opts = {})
+      log_drain = Fabricate(:log_drain, account: account)
+      op = Fabricate(:operation)
+
+      expect(account).to receive(:create_log_drain!)
+        .with(**create_opts).and_return(log_drain)
+
+      expect(log_drain).to receive(:create_operation)
+        .with(type: :provision, **provision_opts).and_return(op)
+
+      expect(subject).to receive(:attach_to_operation_logs).with(op)
+    end
+
+    context 'elasticsearch' do
+      let(:db) { Fabricate(:database, account: account, id: 5) }
+
+      it 'creates a new Elasticsearch log drain' do
+        opts = {
+          handle: 'test',
+          drain_apps: nil,
+          drain_databases: nil,
+          drain_ephemeral_sessions: nil,
+          drain_proxies: nil,
+          drain_type: :elasticsearch_database,
+          logging_token: nil,
+          database_id: db.id
+        }
+        expect_provision_log_drain(opts)
+
+        subject.options = {
+          db: db.handle,
+          environment: account.handle
+        }
+        subject.send('log_drain:create:elasticsearch', 'test')
+      end
+
+      it 'creates a new Elasticsearch log drain with a pipeline' do
+        opts = {
+          handle: 'test-es',
+          drain_apps: nil,
+          drain_databases: nil,
+          drain_ephemeral_sessions: nil,
+          drain_proxies: nil,
+          drain_type: :elasticsearch_database,
+          logging_token: 'test-pipeline',
+          database_id: db.id
+        }
+        expect_provision_log_drain(opts)
+
+        subject.options = {
+          db: db.handle,
+          environment: account.handle,
+          pipeline: 'test-pipeline'
+        }
+        subject.send('log_drain:create:elasticsearch', 'test-es')
+      end
+    end
+
+    # HTTPS, Datadog, Sumologic, and LogDNA are all similar enough
+    # that they're not tested individually
+    context 'https' do
+      it 'creates a new HTTPS log drain' do
+        opts = {
+          handle: 'test-https',
+          drain_apps: nil,
+          drain_databases: nil,
+          drain_ephemeral_sessions: nil,
+          drain_proxies: nil,
+          drain_type: :https_post,
+          url: 'https://test.foo.com'
+        }
+        expect_provision_log_drain(opts)
+
+        subject.options = {
+          environment: account.handle,
+          url: 'https://test.foo.com'
+        }
+        subject.send('log_drain:create:https', 'test-https')
+      end
+    end
+
+    # Syslog and Papertrail are similar enough that they're
+    # not tested individually
+    context 'syslog' do
+      it 'creates a new syslog log drain' do
+        opts = {
+          handle: 'test-syslog',
+          drain_host: 'test.foo.com',
+          drain_port: 2468,
+          logging_token: nil,
+          drain_apps: nil,
+          drain_databases: nil,
+          drain_ephemeral_sessions: nil,
+          drain_proxies: nil,
+          drain_type: :syslog_tls_tcp
+        }
+        expect_provision_log_drain(opts)
+
+        subject.options = {
+          environment: account.handle,
+          host: 'test.foo.com',
+          port: 2468
+        }
+        subject.send('log_drain:create:syslog', 'test-syslog')
+      end
+
+      it 'creates a new syslog log drain with a logging token' do
+        opts = {
+          handle: 'test-syslog',
+          drain_host: 'test.foo.com',
+          drain_port: 2468,
+          logging_token: 'test-token',
+          drain_apps: nil,
+          drain_databases: nil,
+          drain_ephemeral_sessions: nil,
+          drain_proxies: nil,
+          drain_type: :syslog_tls_tcp
+        }
+        expect_provision_log_drain(opts)
+
+        subject.options = {
+          environment: account.handle,
+          host: 'test.foo.com',
+          port: 2468,
+          token: 'test-token'
+        }
+        subject.send('log_drain:create:syslog', 'test-syslog')
+      end
+    end
+  end
+
+  describe '#log_drain:deprovision' do
+    let(:operation) { Fabricate(:operation, resource: log_drain) }
+
+    it 'deprovisions a log drain' do
+      expect(log_drain).to receive(:create_operation)
+        .with(type: :deprovision).and_return(operation)
+      expect(subject).to receive(:attach_to_operation_logs).with(operation)
+      subject.send('log_drain:deprovision', log_drain.handle)
+    end
+
+    it 'does not fail if the operation cannot be found' do
+      expect(log_drain).to receive(:create_operation)
+        .with(type: :deprovision).and_return(operation)
+      response = Faraday::Response.new(status: 404)
+      error = HyperResource::ClientError.new('Not Found', response: response)
+      expect(subject).to receive(:attach_to_operation_logs).with(operation)
+        .and_raise(error)
+      subject.send('log_drain:deprovision', log_drain.handle)
+    end
+  end
+end

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

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+describe Aptible::CLI::Agent do
+  let(:account) { Fabricate(:account) }
+  let!(:metric_drain) do
+    Fabricate(:metric_drain, handle: 'test', account: account)
+  end
+
+  let(:token) { double('token') }
+  before { allow(subject).to receive(:fetch_token).and_return(token) }
+
+  before do
+    allow(Aptible::Api::Account).to receive(:all)
+      .with(token: token).and_return([account])
+  end
+
+  describe '#metric_drain:list' do
+    it 'lists a metric drains for an account' do
+      subject.send('metric_drain:list')
+
+      out = "=== aptible\n" \
+            "test\n"
+      expect(captured_output_text).to eq(out)
+    end
+
+    it 'lists metric drains across multiple accounts' do
+      other_account = Fabricate(:account)
+      Fabricate(:metric_drain, handle: 'test2', account: other_account)
+      accounts = [account, other_account]
+      allow(Aptible::Api::Account).to receive(:all).and_return(accounts)
+
+      subject.send('metric_drain:list')
+
+      out = "=== aptible\n" \
+            "test\n" \
+            "test2\n"
+      expect(captured_output_text).to eq(out)
+    end
+
+    it 'lists metric drains for a single account with --environment' do
+      other_account = Fabricate(:account)
+      Fabricate(:metric_drain, handle: 'test2', account: other_account)
+      accounts = [account, other_account]
+      allow(Aptible::Api::Account).to receive(:all).and_return(accounts)
+
+      subject.options = { environment: account.handle }
+      subject.send('metric_drain:list')
+
+      out = "=== aptible\n" \
+            "test\n"
+      expect(captured_output_text).to eq(out)
+    end
+  end
+
+  describe '#metric_drain:create' do
+    def expect_provision_metric_drain(create_opts, provision_opts = {})
+      metric_drain = Fabricate(:metric_drain, account: account)
+      op = Fabricate(:operation)
+
+      expect(account).to receive(:create_metric_drain!)
+        .with(**create_opts).and_return(metric_drain)
+
+      expect(metric_drain).to receive(:create_operation)
+        .with(type: :provision, **provision_opts).and_return(op)
+
+      expect(subject).to receive(:attach_to_operation_logs).with(op)
+    end
+
+    context 'influxdb' do
+      let(:db) { Fabricate(:database, account: account, id: 5) }
+
+      it 'creates a new InfluxDB metric drain' do
+        opts = {
+          handle: 'test-influxdb',
+          drain_type: :influxdb_database,
+          database_id: db.id
+        }
+        expect_provision_metric_drain(opts)
+
+        subject.options = {
+          db: db.handle,
+          environment: account.handle
+        }
+        subject.send('metric_drain:create:influxdb', 'test-influxdb')
+      end
+    end
+
+    context 'influxdb:custom' do
+      it 'creates a new InfluxDB metric drain' do
+        opts = {
+          handle: 'test-influxdb-custom',
+          drain_type: :influxdb,
+          drain_configuration: {
+            address: 'https://test.foo.com:443',
+            database: 'foobar',
+            password: 'bar',
+            username: 'foo'
+          }
+        }
+        expect_provision_metric_drain(opts)
+
+        subject.options = {
+          environment: account.handle,
+          username: 'foo',
+          password: 'bar',
+          db: 'foobar',
+          url: 'https://test.foo.com:443'
+        }
+        subject.send('metric_drain:create:influxdb:custom',
+                     'test-influxdb-custom')
+      end
+    end
+
+    context 'datadog' do
+      it 'creates a new Datadog metric drain' do
+        opts = {
+          handle: 'test-datadog',
+          drain_type: :datadog,
+          drain_configuration: {
+            api_key: 'foobar'
+          }
+        }
+        expect_provision_metric_drain(opts)
+
+        subject.options = {
+          environment: account.handle,
+          api_key: 'foobar'
+        }
+        subject.send('metric_drain:create:datadog', 'test-datadog')
+      end
+
+      it 'raises an error when the Datadog site is invalid' do
+        subject.options = {
+          environment: account.handle,
+          api_key: 'foobar',
+          site: 'BAD'
+        }
+        expect { subject.send('metric_drain:create:datadog', 'test-datadog') }
+          .to raise_error(Thor::Error, /Invalid Datadog site/i)
+      end
+
+      it 'creates a new Datadog metric drain with a Datadog site defined' do
+        opts = {
+          handle: 'test-datadog',
+          drain_type: :datadog,
+          drain_configuration: {
+            api_key: 'foobar',
+            series_url: 'https://app.datadoghq.eu'
+          }
+        }
+        expect_provision_metric_drain(opts)
+
+        subject.options = {
+          environment: account.handle,
+          api_key: 'foobar',
+          site: 'EU1'
+        }
+        subject.send('metric_drain:create:datadog', 'test-datadog')
+      end
+    end
+  end
+
+  describe '#metric_drain:deprovision' do
+    let(:operation) { Fabricate(:operation, resource: metric_drain) }
+
+    it 'deprovisions a log drain' do
+      expect(metric_drain).to receive(:create_operation)
+        .with(type: :deprovision).and_return(operation)
+      expect(subject).to receive(:attach_to_operation_logs).with(operation)
+      subject.send('metric_drain:deprovision', metric_drain.handle)
+    end
+
+    it 'does not fail if the operation cannot be found' do
+      expect(metric_drain).to receive(:create_operation)
+        .with(type: :deprovision).and_return(operation)
+      response = Faraday::Response.new(status: 404)
+      error = HyperResource::ClientError.new('Not Found', response: response)
+      expect(subject).to receive(:attach_to_operation_logs).with(operation)
+        .and_raise(error)
+      subject.send('metric_drain:deprovision', metric_drain.handle)
+    end
+  end
+end

data/spec/fabricators/account_fabricator.rb

@@ -26,5 +26,7 @@ Fabricator(:account, from: :stub_account) do
   apps { [] }
   databases { [] }
   certificates { [] }
+  log_drains { [] }
+  metric_drains { [] }
   created_at { Time.now }
 end

data/spec/fabricators/log_drain_fabricator.rb

@@ -0,0 +1,21 @@
+class StubLogDrain < OpenStruct
+  def attributes
+    # I foresee hard-coding values like this
+    # being hard to debug in the future,
+    # so sorry if you're here and cursing me, but
+    # I can't think of a better way to fake this.
+    {
+      'drain_username' => drain_username,
+      'drain_host' => drain_host,
+      'drain_port' => drain_port,
+      'url' => url
+    }
+  end
+end
+
+Fabricator(:log_drain, from: :stub_log_drain) do
+  id { sequence(:log_drain_id) }
+  account
+
+  after_create { |drain| drain.account.log_drains << drain }
+end

data/spec/fabricators/metric_drain_fabricator.rb

@@ -0,0 +1,8 @@
+class StubMetricDrain < OpenStruct; end
+
+Fabricator(:metric_drain, from: :stub_metric_drain) do
+  id { sequence(:metric_drain_id) }
+  account
+
+  after_create { |drain| drain.account.metric_drains << drain }
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aptible-cli
 version: !ruby/object:Gem::Version
-  version: 0.18.2
+  version: 0.19.2
 platform: ruby
 authors:
 - Frank Macreery
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-09 00:00:00.000000000 Z
+date: 2022-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aptible-resource
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.3
+        version: 1.2.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.3
+        version: 1.2.4
 - !ruby/object:Gem::Dependency
   name: aptible-billing
   requirement: !ruby/object:Gem::Requirement
@@ -274,8 +274,11 @@ files:
 - lib/aptible/cli/formatter/value.rb
 - lib/aptible/cli/helpers/app.rb
 - lib/aptible/cli/helpers/app_or_database.rb
+- lib/aptible/cli/helpers/config_path.rb
 - lib/aptible/cli/helpers/database.rb
 - lib/aptible/cli/helpers/environment.rb
+- lib/aptible/cli/helpers/log_drain.rb
+- lib/aptible/cli/helpers/metric_drain.rb
 - lib/aptible/cli/helpers/operation.rb
 - lib/aptible/cli/helpers/security_key.rb
 - lib/aptible/cli/helpers/ssh.rb
@@ -294,11 +297,12 @@ files:
 - lib/aptible/cli/subcommands/config.rb
 - lib/aptible/cli/subcommands/db.rb
 - lib/aptible/cli/subcommands/deploy.rb
-- lib/aptible/cli/subcommands/domains.rb
 - lib/aptible/cli/subcommands/endpoints.rb
 - lib/aptible/cli/subcommands/environment.rb
 - lib/aptible/cli/subcommands/inspect.rb
+- lib/aptible/cli/subcommands/log_drain.rb
 - lib/aptible/cli/subcommands/logs.rb
+- lib/aptible/cli/subcommands/metric_drain.rb
 - lib/aptible/cli/subcommands/operation.rb
 - lib/aptible/cli/subcommands/rebuild.rb
 - lib/aptible/cli/subcommands/restart.rb
@@ -323,11 +327,12 @@ files:
 - spec/aptible/cli/subcommands/config_spec.rb
 - spec/aptible/cli/subcommands/db_spec.rb
 - spec/aptible/cli/subcommands/deploy_spec.rb
-- spec/aptible/cli/subcommands/domains_spec.rb
 - spec/aptible/cli/subcommands/endpoints_spec.rb
 - spec/aptible/cli/subcommands/environment_spec.rb
 - spec/aptible/cli/subcommands/inspect_spec.rb
+- spec/aptible/cli/subcommands/log_drain_spec.rb
 - spec/aptible/cli/subcommands/logs_spec.rb
+- spec/aptible/cli/subcommands/metric_drain_spec.rb
 - spec/aptible/cli/subcommands/operation_spec.rb
 - spec/aptible/cli/subcommands/rebuild_spec.rb
 - spec/aptible/cli/subcommands/restart_spec.rb
@@ -343,6 +348,8 @@ files:
 - spec/fabricators/database_disk_fabricator.rb
 - spec/fabricators/database_fabricator.rb
 - spec/fabricators/database_image_fabricator.rb
+- spec/fabricators/log_drain_fabricator.rb
+- spec/fabricators/metric_drain_fabricator.rb
 - spec/fabricators/operation_fabricator.rb
 - spec/fabricators/service_fabricator.rb
 - spec/fabricators/stack_fabricator.rb
@@ -361,7 +368,7 @@ homepage: https://github.com/aptible/aptible-cli
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -376,8 +383,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: Command-line interface for Aptible services
 test_files:
@@ -398,11 +405,12 @@ test_files:
 - spec/aptible/cli/subcommands/config_spec.rb
 - spec/aptible/cli/subcommands/db_spec.rb
 - spec/aptible/cli/subcommands/deploy_spec.rb
-- spec/aptible/cli/subcommands/domains_spec.rb
 - spec/aptible/cli/subcommands/endpoints_spec.rb
 - spec/aptible/cli/subcommands/environment_spec.rb
 - spec/aptible/cli/subcommands/inspect_spec.rb
+- spec/aptible/cli/subcommands/log_drain_spec.rb
 - spec/aptible/cli/subcommands/logs_spec.rb
+- spec/aptible/cli/subcommands/metric_drain_spec.rb
 - spec/aptible/cli/subcommands/operation_spec.rb
 - spec/aptible/cli/subcommands/rebuild_spec.rb
 - spec/aptible/cli/subcommands/restart_spec.rb
@@ -418,6 +426,8 @@ test_files:
 - spec/fabricators/database_disk_fabricator.rb
 - spec/fabricators/database_fabricator.rb
 - spec/fabricators/database_image_fabricator.rb
+- spec/fabricators/log_drain_fabricator.rb
+- spec/fabricators/metric_drain_fabricator.rb
 - spec/fabricators/operation_fabricator.rb
 - spec/fabricators/service_fabricator.rb
 - spec/fabricators/stack_fabricator.rb

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

@@ -1,40 +0,0 @@
-require 'shellwords'
-
-module Aptible
-  module CLI
-    module Subcommands
-      module Domains
-        def self.included(thor)
-          thor.class_eval do
-            include Helpers::Operation
-            include Helpers::App
-
-            desc 'domains',
-                 "Print an app's current virtual domains - DEPRECATED"
-            app_options
-            option :verbose, aliases: '-v'
-            def domains
-              deprecated 'This command is deprecated in favor of endpoints:list'
-              app = ensure_app(options)
-              print_vhosts(app) do |vhost|
-                if options[:verbose]
-                  "#{vhost.virtual_domain} -> #{vhost.external_host}"
-                else
-                  vhost.virtual_domain
-                end
-              end
-            end
-
-            private
-
-            def print_vhosts(app)
-              (app.vhosts || []).each do |vhost|
-                say yield(vhost)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-describe Aptible::CLI::Agent do
-  before do
-    allow(subject).to receive(:ask)
-    allow(subject).to receive(:save_token)
-    allow(subject).to receive(:fetch_token) { double 'token' }
-  end
-
-  let!(:account) { Fabricate(:account) }
-  let!(:app) { Fabricate(:app, handle: 'hello', account: account) }
-  let!(:service) { Fabricate(:service, app: app) }
-  let(:op) { Fabricate(:operation, status: 'succeeded', resource: app) }
-
-  before do
-    allow(Aptible::Api::App).to receive(:all) { [app] }
-    allow(Aptible::Api::Account).to receive(:all) { [account] }
-  end
-
-  let!(:vhost1) do
-    Fabricate(:vhost, virtual_domain: 'domain1', external_host: 'host1',
-                      service: service)
-  end
-
-  let!(:vhost2) do
-    Fabricate(:vhost, virtual_domain: 'domain2', external_host: 'host2',
-                      service: service)
-  end
-
-  describe '#domains' do
-    it 'should print out the hostnames' do
-      expect(subject).to receive(:environment_from_handle)
-        .with('foobar')
-        .and_return(account)
-      expect(subject).to receive(:apps_from_handle).and_return([app])
-      allow(subject).to receive(:options) do
-        { environment: 'foobar', app: 'web' }
-      end
-      expect(subject).to receive(:say).with('domain1')
-      expect(subject).to receive(:say).with('domain2')
-
-      subject.send('domains')
-    end
-
-    it 'should fail if app is non-existent' do
-      allow(subject).to receive(:options) { { app: 'not-an-app' } }
-
-      expect do
-        subject.send('domains')
-      end.to raise_error(Thor::Error, /Could not find app/)
-    end
-
-    it 'should fail if environment is non-existent' do
-      allow(Aptible::Api::Account).to receive(:all) { [] }
-
-      expect do
-        subject.send('domains')
-      end.to raise_error(Thor::Error)
-    end
-
-    it 'should print hostnames if -v is passed' do
-      expect(subject).to receive(:environment_from_handle)
-        .with('foobar')
-        .and_return(account)
-      expect(subject).to receive(:apps_from_handle).and_return([app])
-      allow(subject).to receive(:options) do
-        { verbose: true, app: 'hello', environment: 'foobar' }
-      end
-
-      expect(subject).to receive(:say).with('domain1 -> host1')
-      expect(subject).to receive(:say).with('domain2 -> host2')
-
-      subject.send('domains')
-    end
-  end
-end