harrison 0.0.1 → 0.1.0

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - ruby-head
+  - 2.1.1
+  - 2.0.0
+  - 1.9.3

data/CHANGELOG

@@ -0,0 +1,10 @@
+0.1.0
+-------------------
+- Renamed --pkg_dir option of 'package' task to --destination
+- Implemented remote destinations for 'package' task.
+- Implemented remote artifact sources for 'deploy' task.
+- Added a default timeout of 10 seconds when establishing an SSH connection.
+
+0.0.1
+-------------------
+- Initial public release.

data/IDEAS

@@ -0,0 +1,12 @@
+Ideas:
+------
+[ ] Allow more elaborate hosts config, e.g.: h.hosts = [ { host: '10.16.18.207', tags: %w(util migrate) } ]
+[ ] Some kind of --dry-run option.
+[ ] Allow deploy_via to include alternate user/connection options.
+[ ] Rename "releases" => "builds" (and "deploys" => "releases"?)
+[ ] Upload artifact to all hosts before the rest of the deployment process begins.
+[ ] --force option for deploy task to overwrite an existing release
+[ ] Something like a "status" command that shows what commit is live for env (on each host?)
+[ ] Move artifacts out of pkg/ (and into like pkg/deployed) once they have been deployed? (Some sort of flag for the significant env?)
+[ ] Include branch name in artifact file name.
+[ ] Make --purge the default behavior for the package step.

data/README.md

@@ -2,6 +2,8 @@
 
 Simple artifact-based deployment for web applications.
 
+[![Build Status](https://travis-ci.org/scotje/harrison.svg?branch=master)](https://travis-ci.org/scotje/harrison)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -35,6 +37,10 @@ Harrison.package do |h|
   # Things we don't want to package.
   h.exclude = %w(.git ./config ./coverage ./examples ./log ./pkg ./tmp ./spec)
 
+  # Where to save the artifact by default.
+  h.destination = 'pkg' # Local folder
+  # h.destination = 'jesse@artifact-host.example.com:/tmp/artifacts' # Remote folder
+
   # Define the build process here.
   h.run do |h|
     # Bundle Install
@@ -82,7 +88,7 @@ The `--commit` option understands anything that `git rev-parse` understands. *NO
 reference must be pushed to the repository referenced as `git_src` in the Harrisonfile before
 you can build it.*
 
-The packaged release artifact will, by default, be saved into a 'pkg' subfolder:
+The packaged release artifact will, by default, be saved into a local 'pkg' subfolder:
 
 ```
 $ harrison package
@@ -90,6 +96,23 @@ Packaging 5a547d8 for "harrison" on build-server.example.com...
 Sucessfully packaged 5a547d8 to pkg/20140711170226-5a547d8.tar.gz
 ```
 
+You can set the destination on the command line with the `--destination` option, or
+specify a new default in your Harrisonfile:
+
+```
+h.destination = '/tmp'
+```
+
+You can also specify a remote destination:
+
+```
+h.destination = 'jesse@artifact-host.example.com:/tmp/artifacts'
+```
+
+The username is optional and, if omitted, the build user will be used. *NOTE: Your build server
+must have already accepted the SSH host key of the destination server in order to transfer the
+artifact.*
+
 There are some additional options available, run `harrison package --help` to see everything available.
 
 
@@ -101,7 +124,16 @@ Use the `harrison deploy` command passing the artifact to be deployed as an argu
 $ harrison deploy pkg/20140711170226-5a547d8.tar.gz
 ```
 
-By default, this will deploy to the list of hosts defined in your Harrisonfile.
+You can also deploy from a remote artifact source:
+
+```
+$ harrison deploy jesse@artifact-host.example.com:/tmp/artifacts/20140711170226-5a547d8.tar.gz
+```
+
+*NOTE: Each target server must have already accepted the SSH host key of the source server in order to
+transfer the artifact.*
+
+By default, the artifact will be deployed to the list of hosts defined in your Harrisonfile.
 
 You can override the target hosts by passing a `--hosts` option:
 

data/harrison.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "debugger" if RUBY_VERSION < "2.0.0"
   spec.add_development_dependency "byebug" if RUBY_VERSION >= "2.0.0"
   spec.add_development_dependency "sourcify"

data/lib/harrison/base.rb

@@ -87,15 +87,22 @@ module Harrison
       @ssh ||= Harrison::SSH.new(host: @options[:host], user: @options[:user])
     end
 
+    def remote_regex
+      /^(?:(\S+)@)?(\S+):(\S+)$/
+    end
+
     def ensure_local_dir(dir)
       @_ensured_local ||= {}
       @_ensured_local[dir] || (system("if [ ! -d #{dir} ] ; then mkdir -p #{dir} ; fi") && @_ensured_local[dir] = true) || abort("Error: Unable to create local directory \"#{dir}\".")
     end
 
-    def ensure_remote_dir(host, dir)
+    def ensure_remote_dir(dir, with_ssh = nil)
+      with_ssh = ssh if with_ssh.nil?
+      host = with_ssh.host
+
       @_ensured_remote ||= {}
       @_ensured_remote[host] ||= {}
-      @_ensured_remote[host][dir] || (ssh.exec("if [ ! -d #{dir} ] ; then mkdir -p #{dir} ; fi") && @_ensured_remote[host][dir] = true) || abort("Error: Unable to create remote directory \"#{dir}\" on \"#{host}\".")
+      @_ensured_remote[host][dir] || (with_ssh.exec("if [ ! -d #{dir} ] ; then mkdir -p #{dir} ; fi") && @_ensured_remote[host][dir] = true) || abort("Error: Unable to create remote directory \"#{dir}\" on \"#{host}\".")
     end
   end
 end

data/lib/harrison/deploy.rb

@@ -56,14 +56,22 @@ module Harrison
       hosts.each do |h|
         self.host = h
 
-        ensure_remote_dir(self.host, "#{remote_project_dir}/deploys")
-        ensure_remote_dir(self.host, "#{remote_project_dir}/releases")
+        ensure_remote_dir("#{remote_project_dir}/deploys", self.ssh)
+        ensure_remote_dir("#{remote_project_dir}/releases", self.ssh)
 
         # Make folder for release or bail if it already exists.
         remote_exec("mkdir #{release_dir}")
 
-        # Upload artifact to host.
-        upload(artifact, "#{remote_project_dir}/releases/")
+        if match = remote_regex.match(artifact)
+          # Copy artifact to host from remote source.
+          src_user, src_host, src_path = match.captures
+          src_user ||= self.user
+
+          remote_exec("scp #{src_user}@#{src_host}:#{src_path} #{remote_project_dir}/releases/")
+        else
+          # Upload artifact to host.
+          upload(artifact, "#{remote_project_dir}/releases/")
+        end
 
         # Unpack.
         remote_exec("cd #{release_dir} && tar -xzf ../#{File.basename(artifact)}")

data/lib/harrison/package.rb

@@ -5,7 +5,7 @@ module Harrison
       self.class.option_helper(:host)
       self.class.option_helper(:commit)
       self.class.option_helper(:purge)
-      self.class.option_helper(:pkg_dir)
+      self.class.option_helper(:destination)
       self.class.option_helper(:remote_dir)
       self.class.option_helper(:exclude)
 
@@ -13,7 +13,7 @@ module Harrison
       arg_opts = [
         [ :commit, "Specific commit to be packaged. Accepts anything that `git rev-parse` understands.", :type => :string, :default => "HEAD" ],
         [ :purge, "Remove all previously packaged commits and working copies from the build host when finished.", :type => :boolean, :default => false ],
-        [ :pkg_dir, "Local folder to save package to.", :type => :string, :default => "pkg" ],
+        [ :destination, "Local or remote folder to save package to. Remote syntax is: (user@)host:/path", :type => :string, :default => "pkg" ],
         [ :remote_dir, "Remote working folder.", :type => :string, :default => "~/.harrison" ],
       ]
 
@@ -21,7 +21,7 @@ module Harrison
     end
 
     def remote_exec(cmd)
-      ensure_remote_dir(self.host, "#{remote_project_dir}/package")
+      ensure_remote_dir("#{remote_project_dir}/package")
 
       super("cd #{remote_project_dir}/package && #{cmd}")
     end
@@ -35,7 +35,7 @@ module Harrison
       puts "Packaging #{commit} for \"#{project}\" on #{host}..."
 
       # Make sure the folder to save the artifact to locally exists.
-      ensure_local_dir(pkg_dir)
+      ensure_destination(destination)
 
       # Fetch/clone git repo on remote host.
       remote_exec("if [ -d cached ] ; then cd cached && git fetch origin -p ; else git clone #{git_src} cached ; fi")
@@ -53,14 +53,22 @@ module Harrison
       # Package build folder into tgz.
       remote_exec("rm -f #{artifact_name(commit)}.tar.gz && cd #{commit} && tar #{excludes_for_tar} -czf ../#{artifact_name(commit)}.tar.gz .")
 
-      # Download (Expand remote path since Net::SCP doesn't expand ~)
-      download(remote_exec("readlink -m #{artifact_name(commit)}.tar.gz"), "#{pkg_dir}/#{artifact_name(commit)}.tar.gz")
+      if match = remote_regex.match(destination)
+        # Copy artifact to remote destination.
+        dest_user, dest_host, dest_path = match.captures
+        dest_user ||= self.user
+
+        remote_exec("scp #{artifact_name(commit)}.tar.gz #{dest_user}@#{dest_host}:#{dest_path}")
+      else
+        # Download (Expand remote path since Net::SCP doesn't expand ~)
+        download(remote_exec("readlink -m #{artifact_name(commit)}.tar.gz"), "#{destination}/#{artifact_name(commit)}.tar.gz")
+      end
 
       if purge
         remote_exec("cd .. && rm -rf package")
       end
 
-      puts "Sucessfully packaged #{commit} to #{pkg_dir}/#{artifact_name(commit)}.tar.gz"
+      puts "Sucessfully packaged #{commit} to #{destination}/#{artifact_name(commit)}.tar.gz"
     end
 
     protected
@@ -83,5 +91,16 @@ module Harrison
       @_timestamp ||= Time.new.utc.strftime('%Y%m%d%H%M%S')
       "#{@_timestamp}-#{commit}"
     end
+
+    def ensure_destination(destination)
+      if match = remote_regex.match(destination)
+        dest_user, dest_host, dest_path = match.captures
+        dest_user ||= self.user
+
+        ensure_remote_dir(dest_path, Harrison::SSH.new(host: dest_host, user: dest_user))
+      else
+        ensure_local_dir(destination)
+      end
+    end
   end
 end

data/lib/harrison/ssh.rb

@@ -7,46 +7,23 @@ module Harrison
     def initialize(opts={})
       if opts[:proxy]
         @proxy = Net::SSH::Proxy::Command.new("ssh #{opts[:proxy]} \"nc %h %p\" 2>/dev/null")
-        @conn = Net::SSH.start(opts[:host], opts[:user], forward_agent: true, proxy: @proxy)
+        @conn = Net::SSH.start(opts[:host], opts[:user], forward_agent: true, proxy: @proxy, timeout: 10)
       else
-        @conn = Net::SSH.start(opts[:host], opts[:user], forward_agent: true)
+        @conn = Net::SSH.start(opts[:host], opts[:user], forward_agent: true, timeout: 10)
       end
     end
 
-    # Helper to catch non-zero exit status and report errors.
     def exec(command)
       puts "INFO (ssh-exec #{desc}): #{command}" if Harrison::DEBUG
 
-      stdout_data = ""
-      stderr_data = ""
-      exit_code = nil
-
-      @conn.open_channel do |channel|
-        channel.exec(command) do |ch, success|
-          warn "Couldn't execute command (ssh.channel.exec) on remote host: #{command}" unless success
-
-          channel.on_data do |ch,data|
-            stdout_data += data
-          end
-
-          channel.on_extended_data do |ch,type,data|
-            stderr_data += data
-          end
+      result = invoke(@conn, command)
 
-          channel.on_request("exit-status") do |ch,data|
-            exit_code = data.read_long
-          end
-        end
+      if Harrison::DEBUG || result[:status] != 0
+        warn "STDERR (ssh-exec #{desc}): #{result[:stderr]}" unless result[:stderr].empty?
+        warn "STDOUT (ssh-exec #{desc}): #{result[:stdout]}" unless result[:stdout].empty?
       end
 
-      @conn.loop
-
-      if Harrison::DEBUG || exit_code != 0
-        warn "STDERR (ssh-exec #{desc}): #{stderr_data.strip}" unless stderr_data.empty?
-        warn "STDOUT (ssh-exec #{desc}): #{stdout_data.strip}" unless stdout_data.empty?
-      end
-
-      (exit_code == 0) ? stdout_data : nil
+      (result[:status] == 0) ? result[:stdout] : nil
     end
 
     def download(remote_path, local_path)
@@ -76,5 +53,40 @@ module Harrison
         @conn.host
       end
     end
+
+    def host
+      @conn.host
+    end
+
+    protected
+    # ----------------------------------------
+
+    def invoke(conn, cmd)
+      stdout_data = ""
+      stderr_data = ""
+      exit_code = nil
+
+      conn.open_channel do |channel|
+        channel.exec(cmd) do |ch, success|
+          warn "Couldn't execute command (ssh.channel.exec) on remote host: #{cmd}" unless success
+
+          channel.on_data do |ch,data|
+            stdout_data += data
+          end
+
+          channel.on_extended_data do |ch,type,data|
+            stderr_data += data
+          end
+
+          channel.on_request("exit-status") do |ch,data|
+            exit_code = data.read_long
+          end
+        end
+      end
+
+      conn.loop
+
+      { status: exit_code, stdout: stdout_data.strip, stderr: stderr_data.strip }
+    end
   end
 end

data/lib/harrison/version.rb

@@ -1,3 +1,3 @@
 module Harrison
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/spec_helper.rb

@@ -5,7 +5,6 @@ require 'harrison'
 
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 
@@ -28,12 +27,12 @@ RSpec::Matchers.define :exit_with_code do |exp_code|
     actual and actual == exp_code
   end
 
-  failure_message_for_should do |block|
+  failure_message do |block|
     "expected block to call exit(#{exp_code}) but exit" +
       (actual.nil? ? " not called" : "(#{actual}) was called")
   end
 
-  failure_message_for_should_not do |block|
+  failure_message_when_negated do |block|
     "expected block not to call exit(#{exp_code})"
   end
 

data/spec/unit/harrison/base_spec.rb

@@ -7,17 +7,17 @@ describe Harrison::Base do
     it 'should persist arg_opts' do
       instance = Harrison::Base.new(['foo'])
 
-      instance.instance_variable_get('@arg_opts').should include('foo')
+      expect(instance.instance_variable_get('@arg_opts')).to include('foo')
     end
 
     it 'should add debug to arg_opts' do
-      instance.instance_variable_get('@arg_opts').to_s.should include(':debug')
+      expect(instance.instance_variable_get('@arg_opts').to_s).to include(':debug')
     end
 
     it 'should persist options' do
       instance = Harrison::Base.new([], testopt: 'foo')
 
-      instance.instance_variable_get('@options').should include(testopt: 'foo')
+      expect(instance.instance_variable_get('@options')).to include(testopt: 'foo')
     end
   end
 
@@ -26,13 +26,13 @@ describe Harrison::Base do
       it 'should define a getter instance method for the option' do
         Harrison::Base.option_helper('foo')
 
-        instance.methods.should include(:foo)
+        expect(instance.methods).to include(:foo)
       end
 
       it 'should define a setter instance method for the option' do
         Harrison::Base.option_helper('foo')
 
-        instance.methods.should include(:foo=)
+        expect(instance.methods).to include(:foo=)
       end
     end
   end
@@ -40,15 +40,15 @@ describe Harrison::Base do
   describe 'instance methods' do
     describe '#exec' do
       it 'should execute a command locally and return the output' do
-        instance.exec('echo "foo"').should == 'foo'
+        expect(instance.exec('echo "foo"')).to eq('foo')
       end
 
       it 'should complain if command returns non-zero' do
         output = capture(:stderr) do
-          lambda { instance.exec('cat noexist 2>/dev/null') }.should exit_with_code(1)
+          expect(lambda { instance.exec('cat noexist 2>/dev/null') }).to exit_with_code(1)
         end
 
-        output.should include('unable', 'execute', 'local', 'command')
+        expect(output).to include('unable', 'execute', 'local', 'command')
       end
     end
 
@@ -61,21 +61,29 @@ describe Harrison::Base do
       it 'should delegate command to ssh instance' do
         expect(@mock_ssh).to receive(:exec).and_return('remote_exec_return')
 
-        instance.remote_exec('remote exec').should == 'remote_exec_return'
+        expect(instance.remote_exec('remote exec')).to eq('remote_exec_return')
       end
 
       it 'should complain if command returns nil' do
         expect(@mock_ssh).to receive(:exec).and_return(nil)
 
         output = capture(:stderr) do
-          lambda { instance.remote_exec('remote exec fail') }.should exit_with_code(1)
+          expect(lambda { instance.remote_exec('remote exec fail') }).to exit_with_code(1)
         end
 
-        output.should include('unable', 'execute', 'remote', 'command')
+        expect(output).to include('unable', 'execute', 'remote', 'command')
       end
     end
 
     describe '#parse' do
+      before(:each) do
+        Harrison.send(:remove_const, "DEBUG") if Harrison.const_defined?("DEBUG")
+      end
+
+      after(:each) do
+        Harrison.send(:remove_const, "DEBUG") if Harrison.const_defined?("DEBUG")
+      end
+
       it 'should recognize options from the command line' do
         instance = Harrison::Base.new([
           [ :testopt, "Test option.", :type => :string ]
@@ -83,13 +91,13 @@ describe Harrison::Base do
 
         instance.parse(%w(test --testopt foozle))
 
-        instance.options.should include({testopt: 'foozle'})
+        expect(instance.options).to include({testopt: 'foozle'})
       end
 
       it 'should set the debug flag on the module when passed --debug' do
         instance.parse(%w(test --debug))
 
-        Harrison::DEBUG.should be_true
+        expect(Harrison::DEBUG).to be true
       end
     end
 
@@ -99,20 +107,20 @@ describe Harrison::Base do
           test_block = Proc.new { |test| "block_output" }
           instance.run(&test_block)
 
-          instance.instance_variable_get("@run_block").should == test_block
+          expect(instance.instance_variable_get("@run_block")).to eq(test_block)
         end
       end
 
       context 'when not given a block' do
         it 'should return nil if no block stored' do
-          instance.run.should == nil
+          expect(instance.run).to be_nil
         end
 
         it 'should invoke the previously stored block if it exists' do
           test_block = Proc.new { |test| "block_output" }
           instance.run(&test_block)
 
-          instance.run.should == "block_output"
+          expect(instance.run).to eq("block_output")
         end
       end
     end
@@ -124,9 +132,9 @@ describe Harrison::Base do
       end
 
       it 'should delegate downloads to the SSH class' do
-        expect(@mock_ssh).to receive(:download).with('remote', 'local').and_return(true)
+        expect(@mock_ssh).to receive(:download).with('remote', 'local')
 
-        instance.download('remote', 'local').should == true
+        instance.download('remote', 'local')
       end
     end
 
@@ -137,9 +145,9 @@ describe Harrison::Base do
       end
 
       it 'should delegate uploads to the SSH class' do
-        expect(@mock_ssh).to receive(:upload).with('local', 'remote').and_return(true)
+        expect(@mock_ssh).to receive(:upload).with('local', 'remote')
 
-        instance.upload('local', 'remote').should == true
+        instance.upload('local', 'remote')
       end
     end
 
@@ -151,9 +159,9 @@ describe Harrison::Base do
       end
 
       it 'should invoke close on ssh instance' do
-        expect(@mock_ssh).to receive(:close).and_return(true)
+        expect(@mock_ssh).to receive(:close)
 
-        instance.close.should == true
+        instance.close
       end
     end
   end
@@ -164,7 +172,7 @@ describe Harrison::Base do
         mock_ssh = double(:ssh)
         expect(Harrison::SSH).to receive(:new).and_return(mock_ssh)
 
-        instance.send(:ssh).should == mock_ssh
+        expect(instance.send(:ssh)).to be mock_ssh
       end
 
       it 'should return previously instantiated ssh instance' do
@@ -172,7 +180,21 @@ describe Harrison::Base do
         instance.instance_variable_set('@ssh', mock_ssh)
         expect(Harrison::SSH).to_not receive(:new)
 
-        instance.send(:ssh).should == mock_ssh
+        expect(instance.send(:ssh)).to be mock_ssh
+      end
+    end
+
+    describe '#remote_regex' do
+      it 'should match a standard remote SCP target without a username' do
+        expect(instance.send(:remote_regex)).to match("test_host1:/tmp/target")
+      end
+
+      it 'should match a standard remote SCP target with a username' do
+        expect(instance.send(:remote_regex)).to match("testuser@test_host:/tmp/target")
+      end
+
+      it 'should not match a local file path' do
+        expect(instance.send(:remote_regex)).not_to match("tmp/target")
       end
     end
 
@@ -180,41 +202,43 @@ describe Harrison::Base do
       it 'should try to create a directory locally' do
         expect(instance).to receive(:system).with(/local_dir/).and_return(true)
 
-        instance.send(:ensure_local_dir, 'local_dir').should == true
+        expect(instance.send(:ensure_local_dir, 'local_dir')).to be true
       end
 
       it 'should only try to create a directory once' do
         expect(instance).to receive(:system).with(/local_dir/).once.and_return(true)
 
-        instance.send(:ensure_local_dir, 'local_dir').should == true
-        instance.send(:ensure_local_dir, 'local_dir').should == true
+        expect(instance.send(:ensure_local_dir, 'local_dir')).to be true
+        expect(instance.send(:ensure_local_dir, 'local_dir')).to be true
       end
     end
 
     describe '#ensure_remote_dir' do
       before(:each) do
-        @mock_ssh = double(:ssh)
+        @mock_ssh = double(:ssh, host: 'test_host1')
+        @mock_ssh2 = double(:ssh, host: 'test_host2')
+
         allow(instance).to receive(:ssh).and_return(@mock_ssh)
       end
 
       it 'should try to create a directory remotely' do
         expect(@mock_ssh).to receive(:exec).with(/remote_dir/).and_return(true)
-
-        instance.send(:ensure_remote_dir, 'testhost', 'remote_dir').should == true
+        expect(instance.send(:ensure_remote_dir, 'remote_dir')).to be true
       end
 
-      it 'should try to create a directory once for each distinct host' do
-        expect(@mock_ssh).to receive(:exec).with(/remote_dir/).twice.and_return(true)
+      it 'should try to create a directory once for each distinct ssh connection' do
+        expect(@mock_ssh).to receive(:exec).with(/remote_dir/).once.and_return(true)
+        expect(@mock_ssh2).to receive(:exec).with(/remote_dir/).once.and_return(true)
 
-        instance.send(:ensure_remote_dir, 'test-host', 'remote_dir').should == true
-        instance.send(:ensure_remote_dir, 'another-host', 'remote_dir').should == true
+        expect(instance.send(:ensure_remote_dir, 'remote_dir')).to be true
+        expect(instance.send(:ensure_remote_dir, 'remote_dir', @mock_ssh2)).to be true
       end
 
-      it 'should only try to create a directory once for the same host' do
+      it 'should only try to create a directory once for the same ssh connection' do
         expect(@mock_ssh).to receive(:exec).with(/remote_dir/).once.and_return(true)
 
-        instance.send(:ensure_remote_dir, 'test-host', 'remote_dir').should == true
-        instance.send(:ensure_remote_dir, 'test-host', 'remote_dir').should == true
+        expect(instance.send(:ensure_remote_dir, 'remote_dir')).to be true
+        expect(instance.send(:ensure_remote_dir, 'remote_dir')).to be true
       end
     end
   end

data/spec/unit/harrison/deploy_spec.rb

@@ -10,17 +10,17 @@ describe Harrison::Deploy do
 
   describe '.initialize' do
     it 'should add --hosts to arg_opts' do
-      instance.instance_variable_get('@arg_opts').to_s.should include(':hosts')
+      expect(instance.instance_variable_get('@arg_opts').to_s).to include(':hosts')
     end
 
     it 'should add --env to arg_opts' do
-      instance.instance_variable_get('@arg_opts').to_s.should include(':env')
+      expect(instance.instance_variable_get('@arg_opts').to_s).to include(':env')
     end
 
     it 'should persist options' do
       instance = Harrison::Deploy.new(testopt: 'foo')
 
-      instance.instance_variable_get('@options').should include(testopt: 'foo')
+      expect(instance.instance_variable_get('@options')).to include(testopt: 'foo')
     end
   end
 
@@ -28,16 +28,16 @@ describe Harrison::Deploy do
     describe '#parse' do
       it 'should require an artifact to be passed in ARGV' do
         output = capture(:stderr) do
-          lambda { instance.parse(%w(deploy)) }.should exit_with_code(1)
+          expect(lambda { instance.parse(%w(deploy)) }).to exit_with_code(1)
         end
 
-        output.should include('must', 'specify', 'artifact')
+        expect(output).to include('must', 'specify', 'artifact')
       end
 
       it 'should use "base_dir" from Harrisonfile if present' do
         instance.parse(%w(deploy test_artifact.tar.gz))
 
-        instance.options.should include({ base_dir: '/hf_basedir' })
+        expect(instance.options).to include({ base_dir: '/hf_basedir' })
       end
     end
 
@@ -68,13 +68,13 @@ describe Harrison::Deploy do
           test_block = Proc.new { |test| "block_output" }
           instance.run(&test_block)
 
-          instance.instance_variable_get("@run_block").should == test_block
+          expect(instance.instance_variable_get("@run_block")).to be test_block
         end
       end
 
       context 'when not passed a block' do
         before(:each) do
-          @mock_ssh = double(:ssh, exec: '', upload: true, download: true)
+          @mock_ssh = double(:ssh, host: 'test_host1', exec: '', upload: true, download: true)
           allow(instance).to receive(:ssh).and_return(@mock_ssh)
 
           instance.instance_variable_set(:@run_block, Proc.new { |h| "block for #{h.host}" })
@@ -87,9 +87,9 @@ describe Harrison::Deploy do
             instance.run
           end
 
-          instance.hosts.should == [ 'argv_host1', 'argv_host2' ]
-          output.should include('argv_host1', 'argv_host2')
-          output.should_not include('hf_host')
+          expect(instance.hosts).to eq([ 'argv_host1', 'argv_host2' ])
+          expect(output).to include('argv_host1', 'argv_host2')
+          expect(output).to_not include('hf_host')
         end
 
         it 'should use hosts from Harrisonfile if --hosts not passed' do
@@ -97,18 +97,18 @@ describe Harrison::Deploy do
             instance.run
           end
 
-          instance.hosts.should == [ 'hf_host' ]
-          output.should include('hf_host')
+          expect(instance.hosts).to eq([ 'hf_host' ])
+          expect(output).to include('hf_host')
         end
 
         it 'should require hosts to be set somehow' do
           instance.hosts = nil
 
           output = capture(:stderr) do
-            lambda { instance.run }.should exit_with_code(1)
+            expect(lambda { instance.run }).to exit_with_code(1)
           end
 
-          output.should include('must', 'specify', 'hosts')
+          expect(output).to include('must', 'specify', 'hosts')
         end
 
         it 'should invoke the previously stored block once for each host' do
@@ -118,7 +118,34 @@ describe Harrison::Deploy do
             expect { |b| instance.run(&b); instance.run }.to yield_control.exactly(3).times
           end
 
-          output.should include('host1', 'host2', 'host3')
+          expect(output).to include('host1', 'host2', 'host3')
+        end
+
+        context 'when deploying from a remote artifact source' do
+          before(:each) do
+            instance.artifact = 'test_user@test_host1:/tmp/test_artifact.tar.gz'
+          end
+
+          it 'should invoke scp on the remote host' do
+            allow(instance).to receive(:remote_exec).and_return('')
+            expect(instance).to receive(:remote_exec).with(/scp test_user@test_host1:\/tmp\/test_artifact.tar.gz/).and_return('')
+
+            output = capture(:stdout) do
+              instance.run
+            end
+
+            expect(output).to include('deployed', 'test_user', 'test_host1', '/tmp/test_artifact.tar.gz')
+          end
+
+          it 'should not invoke Harrison::SSH.upload' do
+            expect(@mock_ssh).not_to receive(:upload)
+
+            output = capture(:stdout) do
+              instance.run
+            end
+
+            expect(output).to include('deployed', 'test_user', 'test_host1', '/tmp/test_artifact.tar.gz')
+          end
         end
       end
     end
@@ -156,7 +183,7 @@ describe Harrison::Deploy do
 
         instance.host = 'test_host'
 
-        instance.send(:ssh).should == mock_ssh
+        expect(instance.send(:ssh)).to be mock_ssh
       end
 
       it 'should reuse an existing connection to self.host' do
@@ -165,7 +192,7 @@ describe Harrison::Deploy do
 
         instance.host = :test_host2
 
-        instance.send(:ssh).should == mock_ssh
+        expect(instance.send(:ssh)).to be mock_ssh
       end
     end
 
@@ -174,7 +201,7 @@ describe Harrison::Deploy do
         instance.base_dir = '/test_base_dir'
         instance.project = 'test_project'
 
-        instance.send(:remote_project_dir).should include('/test_base_dir', 'test_project')
+        expect(instance.send(:remote_project_dir)).to include('/test_base_dir', 'test_project')
       end
     end
   end

data/spec/unit/harrison/package_spec.rb

@@ -11,25 +11,25 @@ describe Harrison::Package do
 
   describe '.initialize' do
     it 'should add --commit to arg_opts' do
-      instance.instance_variable_get('@arg_opts').to_s.should include(':commit')
+      expect(instance.instance_variable_get('@arg_opts').to_s).to include(':commit')
     end
 
     it 'should add --purge to arg_opts' do
-      instance.instance_variable_get('@arg_opts').to_s.should include(':purge')
+      expect(instance.instance_variable_get('@arg_opts').to_s).to include(':purge')
     end
 
-    it 'should add --pkg-dir to arg_opts' do
-      instance.instance_variable_get('@arg_opts').to_s.should include(':pkg_dir')
+    it 'should add --destination to arg_opts' do
+      expect(instance.instance_variable_get('@arg_opts').to_s).to include(':destination')
     end
 
     it 'should add --remote-dir to arg_opts' do
-      instance.instance_variable_get('@arg_opts').to_s.should include(':remote_dir')
+      expect(instance.instance_variable_get('@arg_opts').to_s).to include(':remote_dir')
     end
 
     it 'should persist options' do
       instance = Harrison::Package.new(testopt: 'foo')
 
-      instance.instance_variable_get('@options').should include(testopt: 'foo')
+      expect(instance.instance_variable_get('@options')).to include(testopt: 'foo')
     end
   end
 
@@ -57,16 +57,16 @@ describe Harrison::Package do
           test_block = Proc.new { |test| "block_output" }
           instance.run(&test_block)
 
-          instance.instance_variable_get("@run_block").should == test_block
+          expect(instance.instance_variable_get("@run_block")).to be test_block
         end
       end
 
       context 'when not passed a block' do
         before(:each) do
-          @mock_ssh = double(:ssh, exec: '', upload: true, download: true)
+          @mock_ssh = double(:ssh, host: 'test_host1', exec: '', upload: true, download: true)
           allow(instance).to receive(:ssh).at_least(:once).and_return(@mock_ssh)
 
-          allow(instance).to receive(:ensure_local_dir).and_return(true)
+          allow(instance).to receive(:ensure_destination).and_return(true)
           allow(instance).to receive(:resolve_commit!).and_return('test')
           allow(instance).to receive(:excludes_for_tar).and_return('')
         end
@@ -79,7 +79,7 @@ describe Harrison::Package do
             instance.run
           end
 
-          output.should include('block for hf_host')
+          expect(output).to include('block for hf_host')
         end
       end
     end
@@ -91,7 +91,7 @@ describe Harrison::Package do
         instance.remote_dir = '~/.harrison'
         instance.project = 'test_project'
 
-        instance.send(:remote_project_dir).should include('~/.harrison', 'test_project')
+        expect(instance.send(:remote_project_dir)).to include('~/.harrison', 'test_project')
       end
     end
 
@@ -100,7 +100,7 @@ describe Harrison::Package do
         instance.commit = 'giant'
         expect(instance).to receive(:exec).with(/git rev-parse.*giant/).and_return('fef1f0')
 
-        instance.send(:resolve_commit!).should == 'fef1f0'
+        expect(instance.send(:resolve_commit!)).to eq('fef1f0')
       end
     end
 
@@ -108,19 +108,35 @@ describe Harrison::Package do
       it 'should return an empty string if exclude is nil' do
         instance.exclude = nil
 
-        instance.send(:excludes_for_tar).should == ''
+        expect(instance.send(:excludes_for_tar)).to be_empty
       end
 
       it 'should return an empty string if exclude is empty' do
         instance.exclude = []
 
-        instance.send(:excludes_for_tar).should == ''
+        expect(instance.send(:excludes_for_tar)).to be_empty
       end
 
       it 'should return an --exclude option for each member of exclude' do
         instance.exclude = [ 'fee', 'fi', 'fo', 'fum' ]
 
-        instance.send(:excludes_for_tar).scan(/--exclude/).size.should == instance.exclude.size
+        expect(instance.send(:excludes_for_tar).scan(/--exclude/).size).to eq(instance.exclude.size)
+      end
+    end
+
+    describe '#ensure_destination' do
+      it 'should ensure a local destination' do
+        expect(instance).to receive(:ensure_local_dir).with('/tmp/test_path').and_return(true)
+
+        instance.send(:ensure_destination, '/tmp/test_path')
+      end
+
+      it 'should ensure a remote destination' do
+        mock_ssh = double(:ssh, host: 'test_host1')
+        expect(mock_ssh).to receive(:exec).with(/\/tmp\/test_path/).and_return(true)
+        expect(Harrison::SSH).to receive(:new).with({ host: 'test_host1', user: 'test_user' }).and_return(mock_ssh)
+
+        instance.send(:ensure_destination, 'test_user@test_host1:/tmp/test_path')
       end
     end
   end

data/spec/unit/harrison/ssh_spec.rb

@@ -1,5 +1,245 @@
 require 'spec_helper'
 
 describe Harrison::SSH do
-  pending
+  before(:all) do
+    Harrison.send(:remove_const, "DEBUG") if Harrison.const_defined?("DEBUG")
+    Harrison.const_set("DEBUG", false)
+  end
+
+  after(:all) do
+    Harrison.send(:remove_const, "DEBUG") if Harrison.const_defined?("DEBUG")
+  end
+
+  before(:each) do
+    @mock_ssh_chan = double(:ssh_channel)
+
+    @mock_ssh_conn = double(:ssh_conn, host: 'test.example.com')
+    allow(@mock_ssh_conn).to receive(:loop)
+    allow(@mock_ssh_conn).to receive(:open_channel).and_yield(@mock_ssh_chan)
+
+    allow(Net::SSH).to receive(:start).and_return(@mock_ssh_conn)
+  end
+
+  let(:instance) { Harrison::SSH.new(host: 'test.example.com', user: 'test_user') }
+
+  describe 'initialize' do
+    it 'should open an SSH connection' do
+      expect(Net::SSH).to receive(:start).with('test.example.com', 'test_user', anything).and_return(double(:ssh_conn))
+
+      Harrison::SSH.new(host: 'test.example.com', user: 'test_user')
+    end
+
+    context 'when passed a :proxy option' do
+      it 'should open an SSH connection with a proxy command' do
+        proxy = double(:ssh_proxy)
+
+        expect(Net::SSH::Proxy::Command).to receive(:new).and_return(proxy)
+        expect(Net::SSH).to receive(:start).with('test.example.com', 'test_user', { forward_agent: true, proxy: proxy, timeout: 10 }).and_return(double(:ssh_conn))
+
+        Harrison::SSH.new(host: 'test.example.com', user: 'test_user', proxy: 'test-proxy.example.com')
+      end
+    end
+  end
+
+  describe '#exec' do
+    it 'should exec the passed command on an SSH connection channel' do
+      command = "pwd"
+      expect(@mock_ssh_chan).to receive(:exec).with(command)
+
+      instance.exec(command)
+    end
+
+    context 'when the command exits non-zero' do
+      before(:each) do
+        allow(instance).to receive(:invoke).with(@mock_ssh_conn, anything).and_return({ status: 1, stdout: 'standard output', stderr: 'standard error' })
+      end
+
+      it 'should warn whatever the command emitted to stdout' do
+        output = capture(:stderr) do
+          instance.exec('cat noexist 2>/dev/null')
+        end
+
+        expect(output).to include('stdout', 'standard output')
+      end
+
+      it 'should warn whatever the command emitted to stderr' do
+        output = capture(:stderr) do
+          instance.exec('cat noexist 2>/dev/null')
+        end
+
+        expect(output).to include('stderr', 'standard error')
+      end
+
+      it 'should return nil' do
+        capture(:stderr) do
+          expect(instance.exec('cat noexist 2>/dev/null')).to be_nil
+        end
+      end
+    end
+
+    context 'when --debug is set' do
+      before(:each) do
+        allow(instance).to receive(:invoke).with(@mock_ssh_conn, anything).and_return({ status: 0, stdout: 'standard output', stderr: 'standard error' })
+      end
+
+      before(:each) do
+        Harrison.send(:remove_const, "DEBUG") if Harrison.const_defined?("DEBUG")
+        Harrison.const_set("DEBUG", true)
+      end
+
+      after(:each) do
+        Harrison.send(:remove_const, "DEBUG") if Harrison.const_defined?("DEBUG")
+        Harrison.const_set("DEBUG", false)
+      end
+
+      it 'should output the command being run' do
+        output = capture(:stdout) do
+          capture(:stderr) do
+            instance.exec('touch testfile')
+          end
+        end
+
+        expect(output).to include('info', 'touch testfile')
+      end
+
+      it 'should warn whatever the command emitted to stdout' do
+        output = capture(:stderr) do
+          capture(:stdout) do
+            instance.exec('touch testfile')
+          end
+        end
+
+        expect(output).to include('stdout', 'standard output')
+      end
+
+      it 'should warn whatever the command emitted to stderr' do
+        output = capture(:stderr) do
+          capture(:stdout) do
+            instance.exec('touch testfile')
+          end
+        end
+
+        expect(output).to include('stderr', 'standard error')
+      end
+    end
+  end
+
+  describe '#download' do
+    before(:each) do
+      @mock_scp = double(:net_scp)
+      allow(@mock_ssh_conn).to receive(:scp).and_return(@mock_scp)
+    end
+
+    it 'should delegate to net-scp' do
+      expect(@mock_scp).to receive(:download!).with('remote', 'local')
+
+      instance.download('remote', 'local')
+    end
+
+    context 'when --debug is set' do
+      before(:each) do
+        Harrison.send(:remove_const, "DEBUG") if Harrison.const_defined?("DEBUG")
+        Harrison.const_set("DEBUG", true)
+      end
+
+      after(:each) do
+        Harrison.send(:remove_const, "DEBUG") if Harrison.const_defined?("DEBUG")
+        Harrison.const_set("DEBUG", false)
+      end
+
+      it 'should output what is being downloaded and to where' do
+        expect(@mock_scp).to receive(:download!).with('remote', 'local')
+
+        output = capture(:stdout) do
+          instance.download('remote', 'local')
+        end
+
+        expect(output).to include('scp-down', 'local', 'remote')
+      end
+    end
+  end
+
+  describe '#upload' do
+    before(:each) do
+      @mock_scp = double(:net_scp)
+      allow(@mock_ssh_conn).to receive(:scp).and_return(@mock_scp)
+    end
+
+    it 'should delegate to net-scp' do
+      expect(@mock_scp).to receive(:upload!).with('local', 'remote')
+
+      instance.upload('local', 'remote')
+    end
+
+    context 'when --debug is set' do
+      before(:each) do
+        Harrison.send(:remove_const, "DEBUG") if Harrison.const_defined?("DEBUG")
+        Harrison.const_set("DEBUG", true)
+      end
+
+      after(:each) do
+        Harrison.send(:remove_const, "DEBUG") if Harrison.const_defined?("DEBUG")
+        Harrison.const_set("DEBUG", false)
+      end
+
+      it 'should output what is being uploaded and to where' do
+        expect(@mock_scp).to receive(:upload!).with('local', 'remote')
+
+        output = capture(:stdout) do
+          instance.upload('local', 'remote')
+        end
+
+        expect(output).to include('scp-up', 'local', 'remote')
+      end
+    end
+  end
+
+  describe '#close' do
+    it 'should delegate to net-ssh' do
+      expect(@mock_ssh_conn).to receive(:close)
+
+      instance.close
+    end
+
+    context 'when using a proxy command' do
+      before(:each) do
+        @proxy = double(:ssh_proxy)
+        instance.instance_variable_set(:@proxy, @proxy)
+      end
+
+      it 'should send TERM to the proxy command' do
+        allow(@mock_ssh_conn).to receive(:transport).and_return(double(:transport, socket: double(:socket, pid: 100000)))
+
+        expect(Process).to receive(:kill).with("TERM", 100000)
+        expect(@mock_ssh_conn).to receive(:close)
+
+        instance.close
+      end
+    end
+  end
+
+  describe '#closed?' do
+    it 'should delegate to net-ssh' do
+      expect(@mock_ssh_conn).to receive(:closed?)
+
+      instance.closed?
+    end
+  end
+
+  describe '#desc' do
+    it 'should include the host connected to' do
+      expect(instance.desc).to include('test.example.com')
+    end
+
+    context 'when using a proxy host' do
+      before(:each) do
+        @proxy = double(:ssh_proxy, command_line: "ssh proxy.example.com arg1 arg2")
+        instance.instance_variable_set(:@proxy, @proxy)
+      end
+
+      it 'should include the proxy host' do
+        expect(instance.desc).to include('proxy.example.com')
+      end
+    end
+  end
 end

data/spec/unit/harrison_spec.rb

@@ -16,38 +16,38 @@ describe Harrison do
   describe '.invoke' do
     it 'should exit when no args are passed' do
       output = capture(:stderr) do
-        lambda { Harrison.invoke([]) }.should exit_with_code(1)
+        expect(lambda { Harrison.invoke([]) }).to exit_with_code(1)
       end
 
-      output.should include('no', 'command', 'given')
+      expect(output).to include('no', 'command', 'given')
     end
 
     it 'should output base help when first arg is --help' do
       output = capture(:stdout) do
-        lambda { Harrison.invoke(['--help']) }.should exit_with_code(0)
+        expect(lambda { Harrison.invoke(['--help']) }).to exit_with_code(0)
       end
 
-      output.should include('options', 'debug', 'help')
+      expect(output).to include('options', 'debug', 'help')
     end
 
     it 'should look for a Harrisonfile' do
       expect(Harrison).to receive(:find_harrisonfile).and_return(harrisonfile_fixture_path)
 
       output = capture(:stderr) do
-        lambda { Harrison.invoke(['test']) }.should exit_with_code(1)
+        expect(lambda { Harrison.invoke(['test']) }).to exit_with_code(1)
       end
 
-      output.should include('unrecognized', 'command', 'test')
+      expect(output).to include('unrecognized', 'command', 'test')
     end
 
     it 'should complain if unable to find a Harrisonfile' do
       expect(Harrison).to receive(:find_harrisonfile).and_return(nil)
 
       output = capture(:stderr) do
-        lambda { Harrison.invoke(['test']) }.should exit_with_code(1)
+        expect(lambda { Harrison.invoke(['test']) }).to exit_with_code(1)
       end
 
-      output.should include('could', 'not', 'find', 'harrisonfile')
+      expect(output).to include('could', 'not', 'find', 'harrisonfile')
     end
   end
 
@@ -56,7 +56,7 @@ describe Harrison do
       mock_config = double(:config)
       expect(Harrison::Config).to receive(:new).and_return(mock_config)
 
-      Harrison.config.should == mock_config
+      expect(Harrison.config).to be mock_config
     end
 
     it 'should return existing Harrison::Config if defined' do
@@ -64,7 +64,7 @@ describe Harrison do
       Harrison.class_variable_set(:@@config, mock_config)
       expect(Harrison::Config).to_not receive(:new)
 
-      Harrison.config.should == mock_config
+      expect(Harrison.config).to be mock_config
     end
 
     it 'should yield config if given a block' do
@@ -124,13 +124,13 @@ describe Harrison do
       it 'should find a Harrisonfile if it exists in pwd' do
         expect(Dir).to receive(:pwd).and_return(fixture_path)
 
-        Harrison.send(:find_harrisonfile).should == harrisonfile_fixture_path
+        expect(Harrison.send(:find_harrisonfile)).to eq(harrisonfile_fixture_path)
       end
 
       it 'should find a Harrisonfile if it exists in parent of pwd' do
         expect(Dir).to receive(:pwd).and_return(fixture_path + '/nested')
 
-        Harrison.send(:find_harrisonfile).should == harrisonfile_fixture_path
+        expect(Harrison.send(:find_harrisonfile)).to eq(harrisonfile_fixture_path)
       end
 
       it 'should return nil if there is no Harrisonfile in tree' do
@@ -140,7 +140,7 @@ describe Harrison do
         allow(File).to receive(:expand_path).and_call_original
         allow(File).to receive(:expand_path).with("..", File.dirname(__FILE__)).and_return(File.dirname(__FILE__))
 
-        Harrison.send(:find_harrisonfile).should be_nil
+        expect(Harrison.send(:find_harrisonfile)).to be_nil
       end
     end
 
@@ -150,7 +150,7 @@ describe Harrison do
           Harrison.send(:eval_script, fixture_path + '/eval_script.rb')
         end
 
-        output.should == "this file was eval-led\n"
+        expect(output).to eq("this file was eval-led\n")
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: harrison
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-21 00:00:00.000000000 Z
+date: 2014-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trollop
@@ -96,17 +96,17 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: debugger
   requirement: !ruby/object:Gem::Requirement
@@ -149,11 +149,13 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
+- CHANGELOG
 - Gemfile
+- IDEAS
 - LICENSE.txt
 - README.md
 - Rakefile
-- TODO
 - bin/harrison
 - harrison.gemspec
 - lib/harrison.rb
@@ -193,7 +195,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1981909616735500300
+      hash: -1749031995180641465
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.29

data/TODO

@@ -1,26 +0,0 @@
-Bugs:
------
-[ ] Test that artifact exists before doing anything for deploy task.
-
-In Progress:
-------------
-[ ] Unit Testing
-
-Definitely:
------------
-[ ] Rollback action.
-[ ] Error handling (with automatic rollback/undo)
-[ ] Further de-compose actions so that specific parts can be easily overridden.
-[ ] When deploying via a proxy, cache artifact on proxy before deploying to hosts.
-[ ] Banner text in --help output.
-[ ] Improve unit testing, try to minimize coupling to implementation details.
-[ ] Include branch name in artifact file name.
-
-Maybe:
-------
-[ ] Allow more elaborate hosts config, e.g.: h.hosts = [ { host: '10.16.18.207', tags: %w(util migrate) } ]
-[ ] Some kind of --dry-run option.
-[ ] Allow deploy_via to include alternate user/connection options.
-[ ] Rename "releases" => "builds" (and "deploys" => "releases"?)
-[ ] Upload artifact to all hosts before the rest of the deployment process begins.
-[ ] --force option for deploy task to overwrite an existing release