aptible-cli 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0a4dc9b3d5de431e99e8aef2e76fdf0a352c03f7
-  data.tar.gz: eaaba80a605eff86cdddb3bec822a57ae928d871
+  metadata.gz: 82497046ef055642ef5009c32253a6ffdf7dfd5b
+  data.tar.gz: 791ede35111988aaf40ce86ff1ff7ebcf476a7a0
 SHA512:
-  metadata.gz: d86fdfec7a75ba6aa0234551c0b7c326ee6b408175ea41d7fb8e44c96f0f2db2ecd9346029f4ac36295f1e68d9690f9928a74efdba79c6f8e63d88a6905d5253
-  data.tar.gz: 7a115c06a8479359d96dade21f5467cdba4b50af226d828062b0b9a88722d46ef1772fc1e22c56f991e1d6e874bce0e0fb9105997d9a944d876c3fdd3df29852
+  metadata.gz: 090af05a44a38f86a746086df06a4c2d2531076752d8b819bcf9cfd9ef19f4bad03e4aa934ef93148d72e721b2f2cabade69184a817828300eaea39cc0e048be
+  data.tar.gz: 4ce62bac547f46a64d00b44d52f051205aaeb4cd40d5637d285a24bce278e1802083f00ce22343cc281a947fc7e30a225a74d32e6e1d1ff500cf1b685baf70dd

data/lib/aptible/cli/agent.rb

@@ -6,6 +6,7 @@ require_relative 'helpers/token'
 require_relative 'helpers/operation'
 require_relative 'helpers/environment'
 require_relative 'helpers/app'
+require_relative 'helpers/database'
 require_relative 'helpers/env'
 
 require_relative 'subcommands/apps'

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

@@ -0,0 +1,123 @@
+require 'aptible/api'
+
+module Aptible
+  module CLI
+    module Helpers
+      module Database
+        include Helpers::Token
+        include Helpers::Environment
+
+        def ensure_database(options = {})
+          db_handle = options[:db]
+          environment_handle = options[:environment]
+
+          fail Thor::Error, 'Database handle not specified' unless db_handle
+
+          environment = environment_from_handle(environment_handle)
+          if environment_handle && !environment
+            fail Thor::Error, "Could not find environment #{environment_handle}"
+          end
+          databases = databases_from_handle(db_handle, environment)
+          case databases.count
+          when 1
+            return databases.first
+          when 0
+            fail Thor::Error, "Could not find database #{db_handle}"
+          else
+            fail Thor::Error,
+                 'Multiple databases exist, please specify environment'
+          end
+        end
+
+        def databases_from_handle(handle, environment)
+          if environment
+            databases = environment.databases
+          else
+            databases = Aptible::Api::Database.all(token: fetch_token)
+          end
+          databases.select { |a| a.handle == handle }
+        end
+
+        def present_environment_databases(environment)
+          say "=== #{environment.handle}"
+          environment.databases.each { |db| say db.handle }
+          say ''
+        end
+
+        def establish_connection(database, local_port)
+          ENV['ACCESS_TOKEN'] = fetch_token
+          ENV['APTIBLE_DATABASE'] = database.handle
+
+          remote_port = claim_remote_port(database)
+          ENV['TUNNEL_PORT'] = remote_port
+
+          tunnel_args = "-L #{local_port}:localhost:#{remote_port}"
+          command = "ssh #{tunnel_args} #{common_ssh_args(database)}"
+          Kernel.exec(command)
+        end
+
+        def clone_database(source, dest_handle)
+          op = source.create_operation(type: 'clone', handle: dest_handle)
+          poll_for_success(op)
+
+          databases_from_handle(dest_handle, source.account).first
+        end
+
+        def dump_database(database)
+          execute_local_tunnel(database) do |url|
+            filename = "#{database.handle}.dump"
+            say "Dumping to #{filename}"
+            `pg_dump #{url} > #{filename}`
+          end
+        end
+
+        # Creates a local tunnel and yields the url to it
+        def execute_local_tunnel(database)
+          local_port = random_local_port
+          pid = fork { establish_connection(database, local_port) }
+
+          # TODO: Better test for connection readiness
+          sleep 10
+
+          auth = "aptible:#{database.passphrase}"
+          host = "localhost:#{local_port}"
+          yield "postgresql://#{auth}@#{host}/db"
+        ensure
+          Process.kill('HUP', pid) if pid
+        end
+
+        def random_local_port
+          # Allocate a dummy server to discover an available port
+          dummy = TCPServer.new('127.0.0.1', 0)
+          port = dummy.addr[1]
+          dummy.close
+          port
+        end
+
+        def local_url(database, local_port)
+          remote_url = database.connection_url
+          uri = URI.parse(remote_url)
+
+          "#{uri.scheme}://#{uri.user}:#{uri.password}@" \
+          "127.0.0.1:#{local_port}#{uri.path}"
+        end
+
+        def claim_remote_port(database)
+          ENV['ACCESS_TOKEN'] = fetch_token
+
+          `ssh #{common_ssh_args(database)} 2>/dev/null`.chomp
+        end
+
+        def common_ssh_args(database)
+          host = database.account.bastion_host
+          port = database.account.bastion_port
+
+          opts = " -o 'SendEnv=*' -o StrictHostKeyChecking=no " \
+                 '-o UserKnownHostsFile=/dev/null'
+          connection_args = "-p #{port} root@#{host}"
+          "#{opts} #{connection_args}"
+        end
+      end
+    end
+  end
+end

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

@@ -7,6 +7,7 @@ module Aptible
         def self.included(thor)
           thor.class_eval do
             include Helpers::Operation
+            include Helpers::Database
             include Helpers::Token
             include Term::ANSIColor
 
@@ -40,24 +41,24 @@ module Aptible
             desc 'db:clone SOURCE DEST', 'Clone a database to create a new one'
             option :environment
             define_method 'db:clone' do |source_handle, dest_handle|
-              environment = ensure_environment(options)
-              dest = clone_database(source_handle, dest_handle, environment)
+              source = ensure_database(options.merge(db: source_handle))
+              dest = clone_database(source, dest_handle)
               say dest.connection_url
             end
 
             desc 'db:dump HANDLE', 'Dump a remote database to file'
             option :environment
             define_method 'db:dump' do |handle|
-              environment = ensure_environment(options)
-              dump_database(handle, environment)
+              database = ensure_database(options.merge(db: handle))
+              dump_database(database)
             end
 
             desc 'db:execute HANDLE SQL_FILE', 'Executes sql against a database'
             option :environment
             define_method 'db:execute' do |handle, sql_path|
-              environment = ensure_environment(options)
-              execute_local_tunnel(handle, environment) do |url|
-                say "Executing #{sql_path} against #{handle}"
+              database = ensure_database(options.merge(db: handle))
+              execute_local_tunnel(database) do |url|
+                say "Executing #{sql_path} against #{database.handle}"
                 `psql #{url} < #{sql_path}`
               end
             end
@@ -66,8 +67,7 @@ module Aptible
             option :environment
             option :port, type: :numeric
             define_method 'db:tunnel' do |handle|
-              environment = ensure_environment(options)
-              database = database_from_handle(handle, environment)
+              database = ensure_database(options.merge(db: handle))
               local_port = options[:port] || random_local_port
 
               say 'Creating tunnel...', :green
@@ -87,117 +87,11 @@ module Aptible
             desc 'db:deprovision HANDLE', 'Deprovision a database'
             option :environment
             define_method 'db:deprovision' do |handle|
-              environment = ensure_environment(options)
-              database = database_from_handle(handle, environment)
-              say "Deprovisioning #{handle}..."
+              database = ensure_database(options.merge(db: handle))
+              say "Deprovisioning #{database.handle}..."
               database.update!(status: 'deprovisioned')
               database.create_operation!(type: 'deprovision')
             end
-
-            private
-
-            def present_environment_databases(environment)
-              say "=== #{environment.handle}"
-              environment.databases.each { |db| say db.handle }
-              say ''
-            end
-
-            def establish_connection(database, local_port)
-              ENV['ACCESS_TOKEN'] = fetch_token
-              ENV['APTIBLE_DATABASE'] = database.handle
-
-              remote_port = claim_remote_port(database)
-              ENV['TUNNEL_PORT'] = remote_port
-
-              tunnel_args = "-L #{local_port}:localhost:#{remote_port}"
-              command = "ssh #{tunnel_args} #{common_ssh_args(database)}"
-              Kernel.exec(command)
-            end
-
-            def database_from_handle(handle,
-                                     environment,
-                                     options = { postgres_only: false })
-              all = environment.databases
-              database = all.find { |a|  a.handle == handle }
-
-              unless database
-                fail Thor::Error, "Could not find database #{handle}"
-              end
-
-              if options[:postgres_only] && database.type != 'postgresql'
-                fail Thor::Error, 'This command only works for PostgreSQL'
-              end
-
-              database
-            end
-
-            def clone_database(source_handle, dest_handle, environment)
-              source = database_from_handle(source_handle, environment)
-              op = source.create_operation(type: 'clone', handle: dest_handle)
-              poll_for_success(op)
-
-              database_from_handle(dest_handle)
-            end
-
-            def dump_database(handle, environment)
-              execute_local_tunnel(handle, environment) do |url|
-                filename = "#{handle}.dump"
-                say "Dumping to #{filename}"
-                `pg_dump #{url} > #{filename}`
-              end
-            end
-
-            # Creates a local tunnel and yields the url to it
-
-            def execute_local_tunnel(handle, environment)
-              database = database_from_handle(handle,
-                                              environment,
-                                              postgres_only: true)
-
-              local_port = random_local_port
-              pid = fork { establish_connection(database, local_port) }
-
-              # TODO: Better test for connection readiness
-              sleep 10
-
-              auth = "aptible:#{database.passphrase}"
-              host = "localhost:#{local_port}"
-              yield "postgresql://#{auth}@#{host}/db"
-            ensure
-              Process.kill('HUP', pid) if pid
-            end
-
-            def random_local_port
-              # Allocate a dummy server to discover an available port
-              dummy = TCPServer.new('127.0.0.1', 0)
-              port = dummy.addr[1]
-              dummy.close
-              port
-            end
-
-            def local_url(database, local_port)
-              remote_url = database.connection_url
-              uri = URI.parse(remote_url)
-
-              "#{uri.scheme}://#{uri.user}:#{uri.password}@" \
-              "127.0.0.1:#{local_port}#{uri.path}"
-            end
-
-            def claim_remote_port(database)
-              ENV['ACCESS_TOKEN'] = fetch_token
-
-              `ssh #{common_ssh_args(database)} 2>/dev/null`.chomp
-            end
-
-            def common_ssh_args(database)
-              host = database.account.bastion_host
-              port = database.account.bastion_port
-
-              opts = " -o 'SendEnv=*' -o StrictHostKeyChecking=no " \
-                     '-o UserKnownHostsFile=/dev/null'
-              connection_args = "-p #{port} root@#{host}"
-              "#{opts} #{connection_args}"
-            end
           end
         end
       end

data/lib/aptible/cli/version.rb

@@ -1,5 +1,5 @@
 module Aptible
   module CLI
-    VERSION = '0.6.1'
+    VERSION = '0.6.2'
   end
 end

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

@@ -30,16 +30,14 @@ describe Aptible::CLI::Agent do
 
   describe '#db:tunnel' do
     it 'should fail if database is non-existent' do
-      allow(Aptible::Api::Account).to receive(:all) { [account] }
-      allow(account).to receive(:databases) { [] }
+      allow(Aptible::Api::Database).to receive(:all) { [] }
       expect do
         subject.send('db:tunnel', 'foobar')
       end.to raise_error('Could not find database foobar')
     end
 
     it 'should print a message about how to connect' do
-      allow(Aptible::Api::Account).to receive(:all) { [account] }
-      allow(account).to receive(:databases) { [database] }
+      allow(Aptible::Api::Database).to receive(:all) { [database] }
       local_url = 'postgresql://aptible:password@127.0.0.1:4242/db'
       expect(subject).to receive(:say).with('Creating tunnel...', :green)
       expect(subject).to receive(:say).with("Connect at #{local_url}", :green)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aptible-cli
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Frank Macreery
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-24 00:00:00.000000000 Z
+date: 2016-02-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aptible-api
@@ -171,6 +171,7 @@ files:
 - lib/aptible/cli.rb
 - lib/aptible/cli/agent.rb
 - lib/aptible/cli/helpers/app.rb
+- lib/aptible/cli/helpers/database.rb
 - lib/aptible/cli/helpers/env.rb
 - lib/aptible/cli/helpers/environment.rb
 - lib/aptible/cli/helpers/operation.rb