aptible-cli 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5e3e03cae11a2a3bab84c225df322c9fe8c75ab6
-  data.tar.gz: aafef516b5c3bc4996317cf977e3cb403d3f7496
+  metadata.gz: 5d0afaea6319a0ba8278d83dc1de979778dd5842
+  data.tar.gz: 6d087bb9b0de9c1da3855e4ea85c38a18f48820d
 SHA512:
-  metadata.gz: 0ef871ee863e4f5e49a82acd02b7062e20c93c11138e3aa3eae2918c82090b0991a198c5166f765b8d75b576a71ac5508ec014774bded52518d9008448dc4597
-  data.tar.gz: 6f40a10270be6929ad61c11a42fb11bc3d68dc3a5d62a3d4713a7101fb4eb065005816ed93f7ad2bc561dc0285fadd4f5ca0991b01efde892da59cde25a5da16
+  metadata.gz: 12d928e9a1fc0266a38e81052132759873220f6ecdc60d4c93a3769a651a39b40ba350efc5140365da88b2ccc25175d63b73c0c7f8d1d0797f8a56128247a48f
+  data.tar.gz: 634e77e72b255e67b2ecff6df9391d16b2d06052ecfc92f582247e650ee8e81d457a2de55d92635f04f130dc287b241472e1be4e1c0bcc4554346b9e5ece1456

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

@@ -35,7 +35,7 @@ module Aptible
             end
 
             desc 'apps:scale SERVICE ' \
-                 '[--container-count COUNT] [--container-size SIZE]',
+                 '[--container-count COUNT] [--container-size SIZE_MB]',
                  'Scale a service'
             app_options
             option :container_count, type: :numeric

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

@@ -7,9 +7,11 @@ module Aptible
             include Helpers::Token
             include Helpers::Database
 
-            desc 'backup:restore [--handle HANDLE] [--size SIZE_GB]',
+            desc 'backup:restore BACKUP_ID [--handle HANDLE] ' \
+                 '[--container-size SIZE_MB] [--size SIZE_GB]',
                  'Restore a backup'
             option :handle
+            option :container_size, type: :numeric
             option :size, type: :numeric
             define_method 'backup:restore' do |backup_id|
               backup = Aptible::Api::Backup.find(backup_id, token: fetch_token)
@@ -23,6 +25,7 @@ module Aptible
               opts = {
                 type: 'restore',
                 handle: handle,
+                container_size: options[:container_size],
                 disk_size: options[:size]
               }.delete_if { |_, v| v.nil? }
 

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

@@ -20,23 +20,42 @@ module Aptible
               end
             end
 
-            desc 'db:create HANDLE', 'Create a new database'
+            desc 'db:create HANDLE' \
+                 '[--type TYPE] [--container-size SIZE_MB] [--size SIZE_GB]',
+                 'Create a new database'
             option :type, default: 'postgresql'
+            option :container_size, type: :numeric
             option :size, default: 10, type: :numeric
             option :environment
             define_method 'db:create' do |handle|
               environment = ensure_environment(options)
-              database = environment.create_database(handle: handle,
-                                                     type: options[:type])
-
-              if database.errors.any?
-                raise Thor::Error, database.errors.full_messages.first
-              else
-                op = database.create_operation!(type: 'provision',
-                                                disk_size: options[:size])
-                attach_to_operation_logs(op)
-                say database.reload.connection_url
+
+              db_opts = {
+                handle: handle,
+                type: options[:type],
+                initial_container_size: options[:container_size],
+                initial_disk_size: options[:size]
+              }.delete_if { |_, v| v.nil? }
+              database = environment.create_database!(db_opts)
+
+              op_opts = {
+                type: 'provision',
+                container_size: options[:container_size],
+                disk_size: options[:size]
+              }.delete_if { |_, v| v.nil? }
+              op = database.create_operation(op_opts)
+
+              if op.errors.any?
+                # NOTE: If we fail to provision the database, we should try and
+                # clean it up immediately. Note that this will not be possible
+                # if we have an account that's not activated, but that's
+                # arguably the desired UX here.
+                database.create_operation!(type: 'deprovision')
+                raise Thor::Error, op.errors.full_messages.first
               end
+
+              attach_to_operation_logs(op)
+              say database.reload.connection_url
             end
 
             desc 'db:clone SOURCE DEST', 'Clone a database to create a new one'
@@ -138,6 +157,26 @@ module Aptible
               op = database.create_operation!(type: 'reload')
               attach_to_operation_logs(op)
             end
+
+            desc 'db:restart HANDLE ' \
+                 '[--container-size SIZE_MB] [--size SIZE_GB]',
+                 'Restart a database'
+            option :environment
+            option :container_size, type: :numeric
+            option :disk_size, type: :numeric
+            define_method 'db:restart' do |handle|
+              database = ensure_database(options.merge(db: handle))
+
+              opts = {
+                type: 'restart',
+                container_size: options[:container_size],
+                disk_size: options[:size]
+              }.delete_if { |_, v| v.nil? }
+
+              say "Restarting #{database.handle}..."
+              op = database.create_operation!(opts)
+              attach_to_operation_logs(op)
+            end
           end
         end
       end

data/lib/aptible/cli/version.rb

@@ -1,5 +1,5 @@
 module Aptible
   module CLI
-    VERSION = '0.9.0'.freeze
+    VERSION = '0.10.0'.freeze
   end
 end

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

@@ -47,20 +47,48 @@ describe Aptible::CLI::Agent do
         expect(messages).to eq(["Restoring backup into #{h}"])
       end
 
-      it 'accepts a custom handle and disk size' do
+      it 'accepts a handle' do
         h = 'some-handle'
-        s = 40
 
         expect(backup).to receive(:create_operation!) do |options|
           expect(options[:handle]).to eq(h)
-          expect(options[:disk_size]).to eq(s)
+          expect(options[:container_size]).to be_nil
+          expect(options[:disk_size]).to be_nil
           op
         end
 
-        subject.options = { handle: h, size: s }
+        subject.options = { handle: h }
         subject.send('backup:restore', 1)
         expect(messages).to eq(["Restoring backup into #{h}"])
       end
+
+      it 'accepts a container size' do
+        s = 40
+
+        expect(backup).to receive(:create_operation!) do |options|
+          expect(options[:handle]).to be_present
+          expect(options[:container_size]).to eq(s)
+          expect(options[:disk_size]).to be_nil
+          op
+        end
+
+        subject.options = { container_size: s }
+        subject.send('backup:restore', 1)
+      end
+
+      it 'accepts a disk size' do
+        s = 40
+
+        expect(backup).to receive(:create_operation!) do |options|
+          expect(options[:handle]).to be_present
+          expect(options[:container_size]).to be_nil
+          expect(options[:disk_size]).to eq(s)
+          op
+        end
+
+        subject.options = { size: s }
+        subject.send('backup:restore', 1)
+      end
     end
   end
 

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

@@ -12,6 +12,82 @@ describe Aptible::CLI::Agent do
   let(:database) { Fabricate(:database, handle: handle) }
   let(:socat_helper) { SocatHelperMock.new(port: 4242) }
 
+  describe '#db:create' do
+    let(:db) { Fabricate(:database) }
+    let(:op) { Fabricate(:operation) }
+    let(:account) { Fabricate(:account) }
+
+    before do
+      allow(Aptible::Api::Account).to receive(:all).and_return([account])
+      allow(db).to receive(:reload).and_return(db)
+      op.stub(errors: Aptible::Resource::Errors.new)
+    end
+
+    it 'creates a new DB' do
+      expect(account).to receive(:create_database!)
+        .with(handle: 'foo', type: 'postgresql')
+        .and_return(db)
+
+      expect(db).to receive(:create_operation)
+        .with(type: 'provision')
+        .and_return(op)
+
+      expect(subject).to receive(:attach_to_operation_logs)
+        .with(op)
+
+      subject.options = { type: 'postgresql' }
+      subject.send('db:create', 'foo')
+    end
+
+    it 'creates a new DB with a container size' do
+      expect(account).to receive(:create_database!)
+        .with(handle: 'foo', type: 'postgresql', initial_container_size: 1024)
+        .and_return(db)
+
+      expect(db).to receive(:create_operation)
+        .with(type: 'provision', container_size: 1024)
+        .and_return(op)
+
+      expect(subject).to receive(:attach_to_operation_logs)
+        .with(op)
+
+      subject.options = { type: 'postgresql', container_size: 1024 }
+      subject.send('db:create', 'foo')
+    end
+
+    it 'creates a new DB with a disk size' do
+      expect(account).to receive(:create_database!)
+        .with(handle: 'foo', type: 'postgresql', initial_disk_size: 200)
+        .and_return(db)
+
+      expect(db).to receive(:create_operation)
+        .with(type: 'provision', disk_size: 200)
+        .and_return(op)
+
+      expect(subject).to receive(:attach_to_operation_logs)
+        .with(op)
+
+      subject.options = { type: 'postgresql', size: 200 }
+      subject.send('db:create', 'foo')
+    end
+
+    it 'deprovisions the database if the operation cannot be created' do
+      op.errors.full_messages << 'oops!'
+
+      expect(account).to receive(:create_database!).and_return(db)
+
+      expect(db).to receive(:create_operation)
+        .with(type: 'provision')
+        .once.ordered.and_return(op)
+
+      expect(db).to receive(:create_operation!)
+        .with(type: 'deprovision')
+        .once.ordered
+
+      expect { subject.send('db:create', 'foo') }.to raise_error(/oops/im)
+    end
+  end
+
   describe '#db:tunnel' do
     it 'should fail if database is non-existent' do
       allow(Aptible::Api::Database).to receive(:all) { [] }
@@ -233,4 +309,48 @@ describe Aptible::CLI::Agent do
         .to raise_error(Thor::Error, 'Could not find database nope')
     end
   end
+
+  describe '#db:restart' do
+    before { allow(Aptible::Api::Account).to receive(:all) { [account] } }
+    before { allow(Aptible::Api::Database).to receive(:all) { [database] } }
+
+    let(:op) { Fabricate(:operation) }
+
+    it 'allows restarting a database' do
+      expect(database).to receive(:create_operation!)
+        .with(type: 'restart').and_return(op)
+
+      expect(subject).to receive(:say).with('Restarting foobar...')
+      expect(subject).to receive(:attach_to_operation_logs).with(op)
+
+      subject.send('db:restart', handle)
+    end
+
+    it 'allows restarting a database with a container size' do
+      expect(database).to receive(:create_operation!)
+        .with(type: 'restart', container_size: 40).and_return(op)
+
+      expect(subject).to receive(:say).with('Restarting foobar...')
+      expect(subject).to receive(:attach_to_operation_logs).with(op)
+
+      subject.options = { container_size: 40 }
+      subject.send('db:restart', handle)
+    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)
+
+      expect(subject).to receive(:say).with('Restarting foobar...')
+      expect(subject).to receive(:attach_to_operation_logs).with(op)
+
+      subject.options = { size: 40 }
+      subject.send('db:restart', handle)
+    end
+
+    it 'fails if the DB is not found' do
+      expect { subject.send('db:restart', 'nope') }
+        .to raise_error(Thor::Error, 'Could not find database nope')
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aptible-cli
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Frank Macreery
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-12 00:00:00.000000000 Z
+date: 2017-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aptible-api