aptible-cli 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d0afaea6319a0ba8278d83dc1de979778dd5842
-  data.tar.gz: 6d087bb9b0de9c1da3855e4ea85c38a18f48820d
+  metadata.gz: 4caf3814e0cffe6799a62625c5d9fb9f79dbd016
+  data.tar.gz: dbe1d0e306d35ce276c4ac0d323d0e1ea706aba4
 SHA512:
-  metadata.gz: 12d928e9a1fc0266a38e81052132759873220f6ecdc60d4c93a3769a651a39b40ba350efc5140365da88b2ccc25175d63b73c0c7f8d1d0797f8a56128247a48f
-  data.tar.gz: 634e77e72b255e67b2ecff6df9391d16b2d06052ecfc92f582247e650ee8e81d457a2de55d92635f04f130dc287b241472e1be4e1c0bcc4554346b9e5ece1456
+  metadata.gz: 1149e64d3194970dd488a36519eb07d1783d9ef860b587bd04f844de452afb848980ee4340e2e6a2cef0a10afa148812e48fdce7d9f18c296d072e52da5d45f0
+  data.tar.gz: 7aed71d453418b1d887d214974a6e60903338154c866d1a5ec90e59ab185f0ad02d0e06bc929046bc1290234572c3785c60fa5ac50c91498f9c6513f628a0127

data/.travis.yml

@@ -5,3 +5,8 @@ rvm:
   - 2.1.0
   - 2.2.0
   - 2.3.0
+
+script:
+  - bundle exec rake
+  - bundle exec script/sync-readme-usage README.md
+  - git diff --exit-code

data/README.md

@@ -26,39 +26,43 @@ And then run `bundle install`.
 
 From `aptible help`:
 
+<!-- BEGIN USAGE -->
 ```
 Commands:
-  aptible apps                                                                  # List all applications
-  aptible apps:create HANDLE                                                    # Create a new application
-  aptible apps:deprovision                                                      # Deprovision an app
-  aptible apps:scale SERVICE [--container-count COUNT] [--container-size SIZE]  # Scale a service
-  aptible backup:list DB_HANDLE                                                 # List backups for a database
-  aptible backup:restore [--handle HANDLE] [--size SIZE_GB]                     # Restore a backup
-  aptible config                                                                # Print an app's current configuration
-  aptible config:add                                                            # Add an ENV variable to an app
-  aptible config:rm                                                             # Remove an ENV variable from an app
-  aptible config:set                                                            # Alias for config:add
-  aptible config:unset                                                          # Alias for config:rm
-  aptible db:backup HANDLE                                                      # Backup a database
-  aptible db:clone SOURCE DEST                                                  # Clone a database to create a new one
-  aptible db:create HANDLE                                                      # Create a new database
-  aptible db:deprovision HANDLE                                                 # Deprovision a database
-  aptible db:dump HANDLE                                                        # Dump a remote database to file
-  aptible db:execute HANDLE SQL_FILE                                            # Executes sql against a database
-  aptible db:list                                                               # List all databases
-  aptible db:reload HANDLE                                                      # Reload a database
-  aptible db:tunnel HANDLE                                                      # Create a local tunnel to a database
-  aptible domains                                                               # Print an app's current virtual domains
-  aptible help [COMMAND]                                                        # Describe available commands or one specific command
-  aptible login                                                                 # Log in to Aptible
-  aptible logs                                                                  # Follows logs from a running app or database
-  aptible operation:cancel OPERATION_ID                                         # Cancel a running operation
-  aptible ps                                                                    # Display running processes for an app - DEPRECATED
-  aptible rebuild                                                               # Rebuild an app, and restart its services
-  aptible restart                                                               # Restart all services associated with an app
-  aptible ssh [COMMAND]                                                         # Run a command against an app
-  aptible version                                                               # Print Aptible CLI version
+  aptible apps                                                                                    # List all applications
+  aptible apps:create HANDLE                                                                      # Create a new application
+  aptible apps:deprovision                                                                        # Deprovision an app
+  aptible apps:scale SERVICE [--container-count COUNT] [--container-size SIZE_MB]                 # Scale a service
+  aptible backup:list DB_HANDLE                                                                   # List backups for a database
+  aptible backup:restore BACKUP_ID [--handle HANDLE] [--container-size SIZE_MB] [--size SIZE_GB]  # Restore a backup
+  aptible config                                                                                  # Print an app's current configuration
+  aptible config:add                                                                              # Add an ENV variable to an app
+  aptible config:rm                                                                               # Remove an ENV variable from an app
+  aptible config:set                                                                              # Alias for config:add
+  aptible config:unset                                                                            # Alias for config:rm
+  aptible db:backup HANDLE                                                                        # Backup a database
+  aptible db:clone SOURCE DEST                                                                    # Clone a database to create a new one
+  aptible db:create HANDLE[--type TYPE] [--container-size SIZE_MB] [--size SIZE_GB]               # Create a new database
+  aptible db:deprovision HANDLE                                                                   # Deprovision a database
+  aptible db:dump HANDLE                                                                          # Dump a remote database to file
+  aptible db:execute HANDLE SQL_FILE                                                              # Executes sql against a database
+  aptible db:list                                                                                 # List all databases
+  aptible db:reload HANDLE                                                                        # Reload a database
+  aptible db:restart HANDLE [--container-size SIZE_MB] [--size SIZE_GB]                           # Restart a database
+  aptible db:tunnel HANDLE                                                                        # Create a local tunnel to a database
+  aptible deploy [OPTIONS] [VAR1=VAL1] [VAR=VAL2] ...                                             # Deploy an app
+  aptible domains                                                                                 # Print an app's current virtual domains
+  aptible help [COMMAND]                                                                          # Describe available commands or one specific command
+  aptible login                                                                                   # Log in to Aptible
+  aptible logs                                                                                    # Follows logs from a running app or database
+  aptible operation:cancel OPERATION_ID                                                           # Cancel a running operation
+  aptible ps                                                                                      # Display running processes for an app - DEPRECATED
+  aptible rebuild                                                                                 # Rebuild an app, and restart its services
+  aptible restart                                                                                 # Restart all services associated with an app
+  aptible ssh [COMMAND]                                                                           # Run a command against an app
+  aptible version                                                                                 # Print Aptible CLI version
 ```
+<!-- END USAGE -->
 
 ## Contributing
 

data/aptible-cli.gemspec

@@ -20,9 +20,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{spec/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'aptible-api', '~> 0.9.20'
-  spec.add_dependency 'aptible-auth', '~> 0.11.12'
-  spec.add_dependency 'aptible-resource', '~> 0.3.6'
+  spec.add_dependency 'aptible-resource', '~> 0.4.0'
+  spec.add_dependency 'aptible-api', '~> 0.9.27'
+  spec.add_dependency 'aptible-auth', '~> 0.11.13'
   spec.add_dependency 'thor', '~> 0.19.1'
   spec.add_dependency 'git'
   spec.add_dependency 'term-ansicolor'

data/lib/aptible/cli/agent.rb

@@ -20,6 +20,7 @@ require_relative 'subcommands/domains'
 require_relative 'subcommands/logs'
 require_relative 'subcommands/ps'
 require_relative 'subcommands/rebuild'
+require_relative 'subcommands/deploy'
 require_relative 'subcommands/restart'
 require_relative 'subcommands/ssh'
 require_relative 'subcommands/backup'
@@ -40,6 +41,7 @@ module Aptible
       include Subcommands::Logs
       include Subcommands::Ps
       include Subcommands::Rebuild
+      include Subcommands::Deploy
       include Subcommands::Restart
       include Subcommands::SSH
       include Subcommands::Backup

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

@@ -140,6 +140,21 @@ module Aptible
           end.select { |a| a.handle == handle }
         end
 
+        def extract_env(args)
+          Hash[args.map do |arg|
+            k, v = arg.split('=', 2)
+            validate_env_key!(k)
+            [k, v]
+          end]
+        end
+
+        def validate_env_key!(k)
+          # Keys that start with '-' are likely to be mispelled options. As of
+          # May 2017 (> 3 years of Aptible!), there are only 2 such cases, both
+          # of which are indeed mispelled options.
+          raise Thor::Error, "Invalid argument: #{k}" if k.start_with?('-')
+        end
+
         private
 
         def handle_strategies

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

@@ -28,7 +28,7 @@ module Aptible
           # connecting for. There might be ways to make this better.
           ENV['ACCESS_TOKEN'] = fetch_token
 
-          success = connect_to_ssh_portal(
+          code = connect_to_ssh_portal(
             operation,
             '-o', 'SendEnv=ACCESS_TOKEN'
           )
@@ -36,7 +36,10 @@ module Aptible
           # If the portal is down, fall back to polling for success. If the
           # operation failed, poll_for_success will immediately fall through to
           # the error message.
-          poll_for_success(operation) unless success
+          unless code == 0
+            puts 'Disconnected from logs, waiting for operation to complete'
+            poll_for_success(operation)
+          end
         end
 
         def cancel_operation(operation)

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

@@ -3,33 +3,50 @@ module Aptible
     module Helpers
       module Ssh
         def connect_to_ssh_portal(operation, *extra_ssh_args)
+          # NOTE: This is a little tricky to get rigt, so before you make any
+          # changes, read this.
+          #
+          # - The first gotcha is that we cannot use Kernel.exec here, because
+          # we need to perform cleanup when exiting from
+          # operation#with_ssh_cmd.
+          #
+          # - The second gotcha is that we need to somehow capture the exit
+          # status, so that CLI commands that call the SSH portal can proxy
+          # this back to their own caller (the most important one here is
+          # aptible ssh).
+          #
+          # To do this, we have to handle interrutps as a signal, as opposed to
+          # handle an Interrupt exception. The reason for this has to do with
+          # how Ruby's wait is implemented (this happens in process.c's
+          # rb_waitpid). There are two main considerations here:
+          #
+          # - It automatically resumes when it receives EINTR, so our control
+          # is pretty high-level here.
+          # - It handles interrupts prior to setting $? (this appears to have
+          # changed between Ruby 2.2 and 2.3, perhaps the newer implementation
+          # behaves differently).
+          #
+          # Unfortunately, this means that if we receive SIGINT while in
+          # Process::wait2, then we never get access to SSH's exitstatus: Ruby
+          # throws a Interrupt so we don't have a return value, and it doesn't
+          # set $?, so we can't read it back there.
+          #
+          # Of course, we can't just call Proces::wait2 again, because at this
+          # point, we've reaped our child.
+          #
+          # To solve this, we add our own signal handler on SIGINT, which
+          # simply proxies SIGINT to SSH if we happen to have a different
+          # process group (which shouldn't be the case), just to be safe and
+          # let users exit the CLI.
           with_ssh_cmd(operation) do |base_ssh_cmd|
-            ssh_cmd = base_ssh_cmd + extra_ssh_args
-            begin
-              Kernel.system(*ssh_cmd)
-            rescue Interrupt
-              # Assuming we have a TTY, there are two cases here. Either SSH
-              # itself has a TTY, in which case it is controlling the TTY and
-              # the CLI won't be receiving SIGINT when CTRL+C is pressed, or
-              # SSH has no TTY, in which case the CLI and SSH are sharing the
-              # same process group, and will both receive SIGINT when CTRL+C
-              # is pressed and exit accordingly.
-              #
-              # I'm not sure how this *should* work on Windows, but it appears
-              # to work pretty much the same way, except that we'll get an ugly
-              # "Terminate batch job (Y/N)?" prompt in the no-TTY-for-SSH case,
-              # which we're likely to have a hard time handling.
-              #
-              # Note that this DOES NOT handle the case where the CLI is sent
-              # SIGINT by another process (as opposed to the line discipline).
-              # In this case, SSH will continue running in the background. This
-              # is something we should fix, but for now this 'simple' fix is
-              # enough to addresses the ugly stack trace we show when
-              # CTRL+C'ing out of logs.
-            end
+            spawn_passthrough(base_ssh_cmd + extra_ssh_args)
           end
         end
 
+        def exit_with_ssh_portal(*args)
+          exit connect_to_ssh_portal(*args)
+        end
+
         def with_ssh_cmd(operation)
           ensure_ssh_dir!
           ensure_config!
@@ -42,6 +59,40 @@ module Aptible
 
         private
 
+        def spawn_passthrough(command)
+          redirection = { in: :in, out: :out, err: :err, close_others: true }
+          pid = Process.spawn(*command, redirection)
+
+          reset = Signal.trap('SIGINT') do
+            # FIXME: If we're on Windows, we don't really know whether SSH
+            # received SIGINT or not, so for now, we just ignore it.
+            next if Gem.win_platform?
+
+            begin
+              # SSH should be running in our process group, which means that
+              # if the user sends CTRL+C, we'll both receive it. In this
+              # case, just ignore the signal and let SSH handle it.
+              next if Process.getpgid(Process.pid) == Process.getpgid(pid)
+
+              # If we get here, then oddly, SSH is not running in our process
+              # group and yet we got the signal. In this case, let's simply
+              # ignore it.
+              Process.kill(:SIGINT, pid)
+            rescue Errno::ESRCH
+              # This could happen if SSH exited after receiving the SIGINT,
+              # Ruby waited it, then ran our signal handler. In this case, we
+              # don't need to do anything, so we proceed.
+            end
+          end
+
+          begin
+            _, status = Process.wait2(pid)
+            return status.exited? ? status.exitstatus : 128 + status.termsig
+          ensure
+            Signal.trap('SIGINT', reset)
+          end
+        end
+
         def ensure_ssh_dir!
           FileUtils.mkdir_p(ssh_dir, mode: 0o700)
         end

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

@@ -23,7 +23,7 @@ module Aptible
             define_method 'config:add' do |*args|
               # FIXME: define_method - ?! Seriously, WTF Thor.
               app = ensure_app(options)
-              env = Hash[args.map { |arg| arg.split('=', 2) }]
+              env = extract_env(args)
               operation = app.create_operation!(type: 'configure', env: env)
               puts 'Updating configuration and restarting app...'
               attach_to_operation_logs(operation)
@@ -40,7 +40,10 @@ module Aptible
             define_method 'config:rm' do |*args|
               # FIXME: define_method - ?! Seriously, WTF Thor.
               app = ensure_app(options)
-              env = Hash[args.map { |arg| [arg, ''] }]
+              env = Hash[args.map do |arg|
+                validate_env_key!(arg)
+                [arg, '']
+              end]
               operation = app.create_operation!(type: 'configure', env: env)
               puts 'Updating configuration and restarting app...'
               attach_to_operation_logs(operation)

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

@@ -0,0 +1,89 @@
+module Aptible
+  module CLI
+    module Subcommands
+      module Deploy
+        DOCKER_IMAGE_DEPLOY_ARGS = Hash[%w(
+          APTIBLE_DOCKER_IMAGE
+          APTIBLE_PRIVATE_REGISTRY_EMAIL
+          APTIBLE_PRIVATE_REGISTRY_USERNAME
+          APTIBLE_PRIVATE_REGISTRY_PASSWORD
+        ).map do |var|
+          opt = var.gsub(/^APTIBLE_/, '').downcase.to_sym
+          [opt, var]
+        end]
+
+        NULL_SHA1 = '0000000000000000000000000000000000000000'.freeze
+
+        def self.included(thor)
+          thor.class_eval do
+            include Helpers::Operation
+            include Helpers::App
+
+            desc 'deploy [OPTIONS] [VAR1=VAL1] [VAR=VAL2] ...', 'Deploy an app'
+            option :git_commitish,
+                   desc: 'Deploy a specific git commit or branch: the ' \
+                         'commitish must have been pushed to Aptible beforehand'
+            option :git_detach,
+                   type: :boolean, default: false,
+                   desc: 'Detach this app from its git repository: ' \
+                         'its Procfile, Dockerfile, and .aptible.yml will be ' \
+                         'ignored until you deploy again with git'
+            DOCKER_IMAGE_DEPLOY_ARGS.each_pair do |opt, var|
+              option opt,
+                     type: :string, banner: var,
+                     desc: "Shorthand for #{var}=..."
+            end
+            app_options
+            def deploy(*args)
+              app = ensure_app(options)
+
+              git_ref = options[:git_commitish]
+              if options[:git_detach]
+                if git_ref
+                  raise Thor::Error, 'The options --git-committish and ' \
+                                     '--git-detach are incompatible'
+                end
+                git_ref = NULL_SHA1
+              end
+
+              env = extract_env(args)
+
+              DOCKER_IMAGE_DEPLOY_ARGS.each_pair do |opt, var|
+                val = options[opt]
+                next unless val
+                if env[var] && env[var] != val
+                  dasherized = "--#{opt.to_s.tr('_', '-')}"
+                  raise Thor::Error, "The options #{dasherized} and #{var} " \
+                                     'cannot be set to different values'
+                end
+                env[var] = val
+              end
+
+              opts = {
+                type: 'deploy',
+                env: env,
+                git_ref: git_ref
+              }.delete_if { |_, v| v.nil? || v.empty? }
+
+              allow_it = [
+                opts[:git_ref],
+                opts[:env].try(:[], 'APTIBLE_DOCKER_IMAGE'),
+                app.status == 'provisioned'
+              ].any? { |x| x }
+
+              unless allow_it
+                m = 'You need to deploy either from git or a Docker image'
+                raise Thor::Error, m
+              end
+
+              operation = app.create_operation!(opts)
+
+              puts 'Deploying app...'
+              attach_to_operation_logs(operation)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -34,7 +34,7 @@ module Aptible
               op = resource.create_operation!(type: 'logs', status: 'succeeded')
 
               ENV['ACCESS_TOKEN'] = fetch_token
-              connect_to_ssh_portal(op, '-o', 'SendEnv=ACCESS_TOKEN', '-T')
+              exit_with_ssh_portal(op, '-o', 'SendEnv=ACCESS_TOKEN', '-T')
             end
           end
         end

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

@@ -20,7 +20,7 @@ module Aptible
 
               ENV['ACCESS_TOKEN'] = fetch_token
               opts = ['-o', 'SendEnv=ACCESS_TOKEN']
-              connect_to_ssh_portal(op, *opts)
+              exit_with_ssh_portal(op, *opts)
             end
           end
         end

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

@@ -57,7 +57,7 @@ module Aptible
                          end
               opts << tty_mode
 
-              connect_to_ssh_portal(op, *opts)
+              exit_with_ssh_portal(op, *opts)
             end
 
             private

data/lib/aptible/cli/version.rb

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

data/script/sync-readme-usage

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require 'open3'
+
+USAGE = ARGV.fetch(0)
+
+puts "Sync CLI usage in #{USAGE}"
+
+txt, err, status = Open3.capture3(
+  { 'THOR_COLUMNS' => '1000' },
+  'aptible', 'help'
+)
+
+raise "Failed to extract usage: #{err}" unless status.success?
+
+usage = "```\n#{txt.gsub(/^$\n/, '')}```\n"
+
+bits = []
+
+File.open(USAGE) do |f|
+  in_usage = false
+
+  f.each_line do |l|
+    in_usage = false if l.include?('END USAGE')
+
+    bits << l unless in_usage
+
+    if l.include?('BEGIN USAGE')
+      in_usage = true
+      bits << usage
+    end
+  end
+end
+
+File.write(USAGE, bits.join(''))

data/spec/aptible/cli/helpers/ssh_spec.rb

@@ -89,4 +89,125 @@ describe Aptible::CLI::Helpers::Ssh do
       expect(has_yielded).to be_truthy
     end
   end
+
+  describe '#spawn_passthrough' do
+    let(:bins) { File.expand_path('../../../../script', __FILE__) }
+    let(:ruby) { Gem.win_platform? ? 'ruby.exe' : 'ruby' }
+    let(:wrapper) { [ruby, File.join(bins, 'ssh-spawn')] }
+    let(:exit_with) { [ruby, File.join(bins, 'exit-with')] }
+    let(:sigint) { [ruby, File.join(bins, 'pid-signal')] }
+    let(:setpgid) { [ruby, File.join(bins, 'setpgid')] }
+
+    let(:cleanup) { [] }
+
+    after do
+      cleanup.each do |pid|
+        begin
+          Process.kill(:SIGKILL, -pid)
+        rescue Errno::ESRCH, Errno::EINVAL
+        end
+      end
+    end
+
+    def spawn_with_cleanup(*args)
+      kw = Gem.win_platform? ? { new_pgroup: true } : { pgroup: true }
+      Process.spawn(*args, **kw).tap { |pid| cleanup << pid }
+    end
+
+    def wait_for_file(file)
+      50.times do
+        return if File.exist?(file)
+        sleep 0.1
+      end
+
+      raise "File never showed up: #{file}"
+    end
+
+    def wait_for_pid(pid, timeout = 5)
+      (timeout * 10).times do
+        _, status = Process.wait2(pid, Process::WNOHANG)
+        return status if status
+        sleep 0.1
+      end
+
+      raise "PID never exited: #{pid}"
+    end
+
+    [0, 1].each do |c|
+      it "returns the command exit code (#{c})" do
+        pid = spawn_with_cleanup(*wrapper, *exit_with, c.to_s)
+        status = wait_for_pid(pid)
+        expect(status.exitstatus).to eq(c)
+      end
+    end
+
+    context 'signals' do
+      # Don't run these on Windows: sending SIGINT will send it to the entire
+      # console group, which includes the process running the specs.
+      before { skip 'Windows' if Gem.win_platform? }
+
+      it 'returns 128 + signal number when signalled' do
+        Dir.mktmpdir do |dir|
+          pid_file = File.join(dir, 'pid')
+          pid = spawn_with_cleanup(*wrapper, *sigint, pid_file)
+          wait_for_file(pid_file)
+
+          child_pid = Integer(File.read(pid_file).chomp)
+          Process.kill('INT', child_pid)
+
+          status = wait_for_pid(pid)
+
+          if Gem.win_platform?
+            expect(status.exitstatus).not_to eq(0)
+          else
+            expect(status.exitstatus).to eq(128 + Signal.list.fetch('INT'))
+          end
+        end
+      end
+
+      it 'does not proxy SIGINT when part of the same process group' do
+        Dir.mktmpdir do |dir|
+          pid_file = File.join(dir, 'pid')
+          pid = spawn_with_cleanup(*wrapper, *sigint, pid_file)
+          wait_for_file(pid_file)
+
+          child_pid = Integer(File.read(pid_file).chomp)
+          expect(Process.getpgid(child_pid)).to eq(Process.getpgid(pid))
+          Process.kill('INT', pid)
+
+          expect { wait_for_pid(pid, 2) }.to raise_error(/never exited/im)
+        end
+      end
+
+      it 'proxies SIGINT when process groups are different' do
+        Dir.mktmpdir do |dir|
+          pid_file = File.join(dir, 'pid')
+          pid = spawn_with_cleanup(*wrapper, *setpgid, *sigint, pid_file)
+          wait_for_file(pid_file)
+
+          child_pid = Integer(File.read(pid_file).chomp)
+          expect(Process.getpgid(child_pid)).not_to eq(Process.getpgid(pid))
+          Process.kill('INT', pid)
+
+          status = wait_for_pid(pid)
+          expect(status.exitstatus).to eq(128 + Signal.list.fetch('INT'))
+        end
+      end
+
+      it 'does not crash when receiving SIGINT concurrently' do
+        Dir.mktmpdir do |dir|
+          pid_file = File.join(dir, 'pid')
+          pid = spawn_with_cleanup(*wrapper, *sigint, pid_file)
+          wait_for_file(pid_file)
+
+          child_pid = Integer(File.read(pid_file).chomp)
+          expect(Process.getpgid(child_pid)).to eq(Process.getpgid(pid))
+          Process.kill('INT', -pid)
+
+          status = wait_for_pid(pid)
+          expect(status.exitstatus).to eq(128 + Signal.list.fetch('INT'))
+        end
+      end
+    end
+  end
 end

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

@@ -165,6 +165,34 @@ describe Aptible::CLI::Agent do
     end
   end
 
+  describe '#config:set' do
+    before do
+      allow(Aptible::Api::App).to receive(:all) { [app] }
+      allow(Aptible::Api::Account).to receive(:all) { [account] }
+    end
+
+    it 'should reject environment variables that start with -' do
+      allow(subject).to receive(:options) { { app: 'hello' } }
+
+      expect { subject.send('config:set', '-foo=bar') }
+        .to raise_error(/invalid argument/im)
+    end
+  end
+
+  describe '#config:rm' do
+    before do
+      allow(Aptible::Api::App).to receive(:all) { [app] }
+      allow(Aptible::Api::Account).to receive(:all) { [account] }
+    end
+
+    it 'should reject environment variables that start with -' do
+      allow(subject).to receive(:options) { { app: 'hello' } }
+
+      expect { subject.send('config:rm', '-foo') }
+        .to raise_error(/invalid argument/im)
+    end
+  end
+
   describe '#ensure_app' do
     it 'fails if no usable strategy is found' do
       strategies = [dummy_strategy_factory(nil, nil, false)]

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

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+describe Aptible::CLI::Agent do
+  let!(:account) { Fabricate(:account, handle: 'foobar') }
+  let!(:app) { Fabricate(:app, handle: 'hello', account: account) }
+  let(:operation) { Fabricate(:operation) }
+
+  describe '#deploy' do
+    before do
+      allow(Aptible::Api::App).to receive(:all) { [app] }
+      allow(Aptible::Api::Account).to receive(:all) { [account] }
+      subject.stub(:fetch_token) { double 'token' }
+    end
+
+    context 'with app' do
+      let(:base_options) { { app: app.handle, environment: account.handle } }
+
+      def stub_options(**opts)
+        allow(subject).to receive(:options).and_return(base_options.merge(opts))
+      end
+
+      it 'deploys' do
+        stub_options
+
+        expect(app).to receive(:create_operation!)
+          .with(type: 'deploy').and_return(operation)
+        expect(subject).to receive(:attach_to_operation_logs)
+          .with(operation)
+
+        subject.deploy
+      end
+
+      it 'deploys a committish' do
+        stub_options(git_commitish: 'foobar')
+
+        expect(app).to receive(:create_operation!)
+          .with(type: 'deploy', git_ref: 'foobar').and_return(operation)
+        expect(subject).to receive(:attach_to_operation_logs)
+          .with(operation)
+
+        subject.deploy
+      end
+
+      it 'deploys a Docker image' do
+        stub_options(docker_image: 'foobar')
+
+        expect(app).to receive(:create_operation!)
+          .with(type: 'deploy', env: { 'APTIBLE_DOCKER_IMAGE' => 'foobar' })
+          .and_return(operation)
+        expect(subject).to receive(:attach_to_operation_logs)
+          .with(operation)
+
+        subject.deploy
+      end
+
+      it 'deploys with credentials' do
+        stub_options(
+          private_registry_email: 'foo',
+          private_registry_username: 'bar',
+          private_registry_password: 'qux'
+        )
+
+        env = {
+          'APTIBLE_PRIVATE_REGISTRY_EMAIL' => 'foo',
+          'APTIBLE_PRIVATE_REGISTRY_USERNAME' => 'bar',
+          'APTIBLE_PRIVATE_REGISTRY_PASSWORD' => 'qux'
+        }
+
+        expect(app).to receive(:create_operation!)
+          .with(type: 'deploy', env: env)
+          .and_return(operation)
+        expect(subject).to receive(:attach_to_operation_logs)
+          .with(operation)
+
+        subject.deploy
+      end
+
+      it 'detaches a git repo' do
+        stub_options(git_detach: true)
+
+        ref = '0000000000000000000000000000000000000000'
+
+        expect(app).to receive(:create_operation!)
+          .with(type: 'deploy', git_ref: ref)
+          .and_return(operation)
+        expect(subject).to receive(:attach_to_operation_logs)
+          .with(operation)
+
+        subject.deploy
+      end
+
+      it 'fails if detaching the git repo and providing a commitish' do
+        stub_options(git_commitish: 'foo', git_detach: true)
+
+        expect { subject.deploy }.to raise_error(/are incompatible/im)
+      end
+
+      it 'allows setting configuration variables' do
+        stub_options
+
+        expect(app).to receive(:create_operation!)
+          .with(type: 'deploy', env: { 'FOO' => 'bar', 'BAR' => 'qux' })
+          .and_return(operation)
+        expect(subject).to receive(:attach_to_operation_logs)
+          .with(operation)
+
+        subject.deploy('FOO=bar', 'BAR=qux')
+      end
+
+      it 'allows unsetting configuration variables' do
+        stub_options
+
+        expect(app).to receive(:create_operation!)
+          .with(type: 'deploy', env: { 'FOO' => '' })
+          .and_return(operation)
+        expect(subject).to receive(:attach_to_operation_logs)
+          .with(operation)
+
+        subject.deploy('FOO=')
+      end
+
+      it 'rejects arguments with a leading -' do
+        stub_options
+
+        expect { subject.deploy('--aptible-docker-image=bar') }
+          .to raise_error(/invalid argument/im)
+      end
+
+      it 'allows redundant command line arguments' do
+        stub_options(docker_image: 'foobar')
+
+        expect(app).to receive(:create_operation!)
+          .with(type: 'deploy', env: { 'APTIBLE_DOCKER_IMAGE' => 'foobar' })
+          .and_return(operation)
+        expect(subject).to receive(:attach_to_operation_logs)
+          .with(operation)
+
+        subject.deploy('APTIBLE_DOCKER_IMAGE=foobar')
+      end
+
+      it 'reject contradictory command line argumnts' do
+        stub_options(docker_image: 'foobar')
+
+        expect { subject.deploy('APTIBLE_DOCKER_IMAGE=qux') }
+          .to raise_error(/different values/im)
+      end
+
+      it 'does not allow deploying nothing on an unprovisioned app' do
+        stub_options
+
+        app.stub(status: 'pending')
+
+        expect { subject.deploy }
+          .to raise_error(/either from git.*docker/im)
+      end
+    end
+  end
+end

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

@@ -27,7 +27,7 @@ describe Aptible::CLI::Agent do
         expect(app).to receive(:create_operation!).with(
           type: 'logs', status: 'succeeded'
         ).and_return(op)
-        expect(subject).to receive(:connect_to_ssh_portal).with(op, any_args)
+        expect(subject).to receive(:exit_with_ssh_portal).with(op, any_args)
         subject.send('logs')
       end
     end
@@ -47,7 +47,7 @@ describe Aptible::CLI::Agent do
         expect(database).to receive(:create_operation!).with(
           type: 'logs', status: 'succeeded'
         ).and_return(op)
-        expect(subject).to receive(:connect_to_ssh_portal).with(op, any_args)
+        expect(subject).to receive(:exit_with_ssh_portal).with(op, any_args)
         subject.send('logs')
       end
     end

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

@@ -19,7 +19,7 @@ describe Aptible::CLI::Agent do
         allow(STDIN).to receive(:tty?).and_return(true)
         allow(STDOUT).to receive(:tty?).and_return(true)
 
-        expect(subject).to receive(:connect_to_ssh_portal).with(
+        expect(subject).to receive(:exit_with_ssh_portal).with(
           operation, '-o', 'SendEnv=ACCESS_TOKEN', '-t'
         )
         subject.ssh
@@ -30,7 +30,7 @@ describe Aptible::CLI::Agent do
         allow(STDOUT).to receive(:tty?).and_return(true)
         allow(STDERR).to receive(:tty?).and_return(false)
 
-        expect(subject).to receive(:connect_to_ssh_portal).with(
+        expect(subject).to receive(:exit_with_ssh_portal).with(
           operation, '-o', 'SendEnv=ACCESS_TOKEN', '-t'
         )
         subject.ssh
@@ -40,7 +40,7 @@ describe Aptible::CLI::Agent do
         allow(STDIN).to receive(:tty?).and_return(false)
         allow(STDOUT).to receive(:tty?).and_return(true)
 
-        expect(subject).to receive(:connect_to_ssh_portal).with(
+        expect(subject).to receive(:exit_with_ssh_portal).with(
           operation, '-o', 'SendEnv=ACCESS_TOKEN', '-T'
         )
         subject.ssh
@@ -50,7 +50,7 @@ describe Aptible::CLI::Agent do
         allow(STDIN).to receive(:tty?).and_return(true)
         allow(STDOUT).to receive(:tty?).and_return(false)
 
-        expect(subject).to receive(:connect_to_ssh_portal).with(
+        expect(subject).to receive(:exit_with_ssh_portal).with(
           operation, '-o', 'SendEnv=ACCESS_TOKEN', '-T'
         )
         subject.ssh
@@ -62,7 +62,7 @@ describe Aptible::CLI::Agent do
         allow(STDIN).to receive(:tty?).and_return(false)
         allow(STDOUT).to receive(:tty?).and_return(false)
 
-        expect(subject).to receive(:connect_to_ssh_portal).with(
+        expect(subject).to receive(:exit_with_ssh_portal).with(
           operation, '-o', 'SendEnv=ACCESS_TOKEN', '-tt'
         )
         subject.ssh

data/spec/script/exit-with

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+exit Integer(ARGV.fetch(0))

data/spec/script/pid-signal

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+File.write(ARGV.fetch(0), Process.pid.to_s)
+Signal.trap('INT', 'SYSTEM_DEFAULT')
+sleep 30

data/spec/script/setpgid

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+kw = Gem.win_platform? ? { new_pgroup: true } : { pgroup: true }
+exec(*ARGV, **kw)

data/spec/script/ssh-spawn

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'aptible/cli/helpers/ssh'
+include Aptible::CLI::Helpers::Ssh
+exit spawn_passthrough(ARGV)

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: aptible-cli
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Frank Macreery
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-16 00:00:00.000000000 Z
+date: 2017-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: aptible-api
+  name: aptible-resource
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.20
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.20
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
-  name: aptible-auth
+  name: aptible-api
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.12
+        version: 0.9.27
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.12
+        version: 0.9.27
 - !ruby/object:Gem::Dependency
-  name: aptible-resource
+  name: aptible-auth
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.6
+        version: 0.11.13
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.6
+        version: 0.11.13
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -238,6 +238,7 @@ files:
 - lib/aptible/cli/subcommands/backup.rb
 - 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/inspect.rb
 - lib/aptible/cli/subcommands/logs.rb
@@ -247,6 +248,7 @@ files:
 - lib/aptible/cli/subcommands/restart.rb
 - lib/aptible/cli/subcommands/ssh.rb
 - lib/aptible/cli/version.rb
+- script/sync-readme-usage
 - spec/aptible/cli/agent_spec.rb
 - spec/aptible/cli/helpers/git_remote_handle_strategy_spec.rb
 - spec/aptible/cli/helpers/handle_from_git_remote_spec.rb
@@ -257,6 +259,7 @@ files:
 - spec/aptible/cli/subcommands/apps_spec.rb
 - spec/aptible/cli/subcommands/backup_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/inspect_spec.rb
 - spec/aptible/cli/subcommands/logs_spec.rb
@@ -276,6 +279,10 @@ files:
 - spec/mock/ssh
 - spec/mock/ssh.bat
 - spec/mock/ssh_mock.rb
+- spec/script/exit-with
+- spec/script/pid-signal
+- spec/script/setpgid
+- spec/script/ssh-spawn
 - spec/shared/mock_ssh_context.rb
 - spec/spec_helper.rb
 homepage: https://github.com/aptible/aptible-cli
@@ -313,6 +320,7 @@ test_files:
 - spec/aptible/cli/subcommands/apps_spec.rb
 - spec/aptible/cli/subcommands/backup_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/inspect_spec.rb
 - spec/aptible/cli/subcommands/logs_spec.rb
@@ -332,5 +340,9 @@ test_files:
 - spec/mock/ssh
 - spec/mock/ssh.bat
 - spec/mock/ssh_mock.rb
+- spec/script/exit-with
+- spec/script/pid-signal
+- spec/script/setpgid
+- spec/script/ssh-spawn
 - spec/shared/mock_ssh_context.rb
 - spec/spec_helper.rb