harrison 0.0.1

data/lib/harrison.rb

@@ -0,0 +1,91 @@
+require "trollop"
+require "harrison/version"
+require "harrison/ssh"
+require "harrison/config"
+require "harrison/base"
+require "harrison/package"
+require "harrison/deploy"
+
+module Harrison
+
+  def self.invoke(args)
+    @@args = args.freeze
+
+    abort("No command given. Run with --help for valid commands and options.") if @@args.empty?
+
+    # Catch root level --help
+    Harrison::Base.new.parse(@@args.dup) and exit(0) if @@args[0] == '--help'
+
+    # Find Harrisonfile.
+    hf = find_harrisonfile
+    abort("ERROR: Could not find a Harrisonfile in this directory or any ancestor.") if hf.nil?
+
+    # Find the class to handle command.
+    @@runner = find_runner(@@args[0])
+    abort("ERROR: Unrecognized command \"#{@@args[0]}\".") unless @@runner
+
+    # Eval the Harrisonfile.
+    eval_script(hf)
+
+    # Invoke command and cleanup afterwards.
+    begin
+      @@runner.call.run
+    ensure
+      @@runner.call.close
+    end
+  end
+
+  def self.config(opts={})
+    @@config ||= Harrison::Config.new(opts)
+
+    if block_given?
+      yield @@config
+    else
+      @@config
+    end
+  end
+
+  def self.package(opts={})
+    @@packager ||= Harrison::Package.new(opts)
+
+    # Parse options if this is the target command.
+    @@packager.parse(@@args.dup) if @@runner && @@runner.call == @@packager
+
+    yield @@packager
+  end
+
+  def self.deploy(opts={})
+    @@deployer ||= Harrison::Deploy.new(opts)
+
+    # Parse options if this is the target command.
+    @@deployer.parse(@@args.dup) if @@runner && @@runner.call == @@deployer
+
+    yield @@deployer
+  end
+
+
+  private
+
+  def self.find_harrisonfile
+    previous = nil
+    current  = File.expand_path(Dir.pwd)
+
+    until !File.directory?(current) || current == previous
+      filename = File.join(current, 'Harrisonfile')
+      return filename if File.file?(filename)
+      current, previous = File.expand_path("..", current), current
+    end
+  end
+
+  def self.eval_script(filename)
+    proc = Proc.new {}
+    eval(File.read(filename), proc.binding, filename)
+  end
+
+  def self.find_runner(command)
+    case command.downcase
+      when 'package' then lambda { @@packager if self.class_variable_defined?(:@@packager) }
+      when 'deploy' then lambda { @@deployer if self.class_variable_defined?(:@@deployer) }
+    end
+  end
+end

data/spec/fixtures/Harrisonfile

@@ -0,0 +1,34 @@
+# This is an valid fixture Harrisonfile used for testing.
+
+# Project-wide Config
+Harrison.config do |h|
+  h.project = 'harrison'
+  h.git_src = "git@github.com:scotje/harrison.git"
+end
+
+Harrison.package do |h|
+  # Where to build package.
+  h.host = 'localhost'
+  h.user = 'test'
+
+  # Things we don't want to package.
+  h.exclude = %w(.git config coverage examples log module_files pkg tmp spec)
+
+  # Define the build process here.
+  h.run do |h|
+    h.remote_exec("echo \"test-package\"")
+  end
+end
+
+Harrison.deploy do |h|
+  # Hosts to deploy to.
+  h.hosts = [ 'localhost' ]
+
+  h.user = 'test'
+  h.base_dir = '/tmp'
+
+  # Run block will be invoked once for each host after new code is in place.
+  h.run do |h|
+    h.remote_exec("echo \"test-deploy\"")
+  end
+end

data/spec/fixtures/eval_script.rb

@@ -0,0 +1 @@
+puts "this file was eval-led"

data/spec/spec_helper.rb

@@ -0,0 +1,83 @@
+require 'bundler/setup'
+Bundler.setup
+
+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
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+RSpec::Matchers.define :exit_with_code do |exp_code|
+  actual = nil
+
+  match do |block|
+    begin
+      block.call
+    rescue SystemExit => e
+      actual = e.status
+    end
+    actual and actual == exp_code
+  end
+
+  failure_message_for_should 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|
+    "expected block not to call exit(#{exp_code})"
+  end
+
+  description do
+    "expect block to call exit(#{exp_code})"
+  end
+end
+
+def capture(io_names = [ :stdout, :stderr ], &block)
+  original_ios = {}
+  fake_ios = {}
+
+  io_names = [ io_names ] unless io_names.respond_to?(:each)
+
+  io_names.each do |io_name|
+    original_ios[io_name] = eval("$#{io_name}")
+    fake_ios[io_name] = StringIO.new
+
+    eval("$#{io_name} = fake_ios[io_name]")
+  end
+
+  begin
+    yield
+  ensure
+    io_names.each do |io_name|
+      eval("$#{io_name} = original_ios[io_name]")
+    end
+  end
+
+  if io_names.size == 1
+    return fake_ios[io_names.first].string.downcase
+  else
+    return fake_ios.each { |io, output| fake_ios[io] = output.string.downcase }
+  end
+end
+
+def fixture_path
+  File.dirname(__FILE__) + "/fixtures"
+end
+
+def harrisonfile_fixture_path(type=nil)
+  if type
+    fixture_path + "/Harrisonfile.#{type}"
+  else
+    fixture_path + "/Harrisonfile"
+  end
+end

data/spec/unit/harrison/base_spec.rb

@@ -0,0 +1,221 @@
+require 'spec_helper'
+
+describe Harrison::Base do
+  let(:instance) { Harrison::Base.new }
+
+  describe 'initialize' do
+    it 'should persist arg_opts' do
+      instance = Harrison::Base.new(['foo'])
+
+      instance.instance_variable_get('@arg_opts').should include('foo')
+    end
+
+    it 'should add debug to arg_opts' do
+      instance.instance_variable_get('@arg_opts').to_s.should include(':debug')
+    end
+
+    it 'should persist options' do
+      instance = Harrison::Base.new([], testopt: 'foo')
+
+      instance.instance_variable_get('@options').should include(testopt: 'foo')
+    end
+  end
+
+  describe 'class methods' do
+    describe '.option_helper' do
+      it 'should define a getter instance method for the option' do
+        Harrison::Base.option_helper('foo')
+
+        instance.methods.should include(:foo)
+      end
+
+      it 'should define a setter instance method for the option' do
+        Harrison::Base.option_helper('foo')
+
+        instance.methods.should include(:foo=)
+      end
+    end
+  end
+
+  describe 'instance methods' do
+    describe '#exec' do
+      it 'should execute a command locally and return the output' do
+        instance.exec('echo "foo"').should == '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)
+        end
+
+        output.should include('unable', 'execute', 'local', 'command')
+      end
+    end
+
+    describe '#remote_exec' do
+      before(:each) do
+        @mock_ssh = double(:ssh)
+        expect(instance).to receive(:ssh).and_return(@mock_ssh)
+      end
+
+      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'
+      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)
+        end
+
+        output.should include('unable', 'execute', 'remote', 'command')
+      end
+    end
+
+    describe '#parse' do
+      it 'should recognize options from the command line' do
+        instance = Harrison::Base.new([
+          [ :testopt, "Test option.", :type => :string ]
+        ])
+
+        instance.parse(%w(test --testopt foozle))
+
+        instance.options.should 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
+      end
+    end
+
+    describe '#run' do
+      context 'when given a block' do
+        it 'should store the block' do
+          test_block = Proc.new { |test| "block_output" }
+          instance.run(&test_block)
+
+          instance.instance_variable_get("@run_block").should == test_block
+        end
+      end
+
+      context 'when not given a block' do
+        it 'should return nil if no block stored' do
+          instance.run.should == 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"
+        end
+      end
+    end
+
+    describe '#download' do
+      before(:each) do
+        @mock_ssh = double(:ssh)
+        expect(instance).to receive(:ssh).and_return(@mock_ssh)
+      end
+
+      it 'should delegate downloads to the SSH class' do
+        expect(@mock_ssh).to receive(:download).with('remote', 'local').and_return(true)
+
+        instance.download('remote', 'local').should == true
+      end
+    end
+
+    describe '#upload' do
+      before(:each) do
+        @mock_ssh = double(:ssh)
+        expect(instance).to receive(:ssh).and_return(@mock_ssh)
+      end
+
+      it 'should delegate uploads to the SSH class' do
+        expect(@mock_ssh).to receive(:upload).with('local', 'remote').and_return(true)
+
+        instance.upload('local', 'remote').should == true
+      end
+    end
+
+    describe '#close' do
+      before(:each) do
+        @mock_ssh = double(:ssh)
+        instance.instance_variable_set('@ssh', @mock_ssh)
+        expect(instance).to receive(:ssh).and_return(@mock_ssh)
+      end
+
+      it 'should invoke close on ssh instance' do
+        expect(@mock_ssh).to receive(:close).and_return(true)
+
+        instance.close.should == true
+      end
+    end
+  end
+
+  describe 'protected methods' do
+    describe '#ssh' do
+      it 'should instantiate a new ssh instance if needed' do
+        mock_ssh = double(:ssh)
+        expect(Harrison::SSH).to receive(:new).and_return(mock_ssh)
+
+        instance.send(:ssh).should == mock_ssh
+      end
+
+      it 'should return previously instantiated ssh instance' do
+        mock_ssh = double(:ssh)
+        instance.instance_variable_set('@ssh', mock_ssh)
+        expect(Harrison::SSH).to_not receive(:new)
+
+        instance.send(:ssh).should == mock_ssh
+      end
+    end
+
+    describe '#ensure_local_dir' 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
+      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
+      end
+    end
+
+    describe '#ensure_remote_dir' do
+      before(:each) do
+        @mock_ssh = double(:ssh)
+        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
+      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)
+
+        instance.send(:ensure_remote_dir, 'test-host', 'remote_dir').should == true
+        instance.send(:ensure_remote_dir, 'another-host', 'remote_dir').should == true
+      end
+
+      it 'should only try to create a directory once for the same host' 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
+      end
+    end
+  end
+end

data/spec/unit/harrison/deploy_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+describe Harrison::Deploy do
+  let(:instance) do
+    Harrison::Deploy.new.tap do |d|
+      d.hosts = [ 'hf_host' ]
+      d.base_dir = '/hf_basedir'
+    end
+  end
+
+  describe '.initialize' do
+    it 'should add --hosts to arg_opts' do
+      instance.instance_variable_get('@arg_opts').to_s.should include(':hosts')
+    end
+
+    it 'should add --env to arg_opts' do
+      instance.instance_variable_get('@arg_opts').to_s.should include(':env')
+    end
+
+    it 'should persist options' do
+      instance = Harrison::Deploy.new(testopt: 'foo')
+
+      instance.instance_variable_get('@options').should include(testopt: 'foo')
+    end
+  end
+
+  describe 'instance methods' 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)
+        end
+
+        output.should 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' })
+      end
+    end
+
+    describe '#remote_exec' do
+      before(:each) do
+        @mock_ssh = double(:ssh)
+        expect(instance).to receive(:ssh).and_return(@mock_ssh)
+      end
+
+      it 'should prepend project dir onto passed command' do
+        instance.base_dir = '/opt'
+        instance.project = 'test_project'
+
+        expect(@mock_ssh).to receive(:exec).with("cd /opt/test_project && test_command").and_return('')
+
+        instance.remote_exec("test_command")
+      end
+    end
+
+    describe '#run' do
+      before(:each) do
+        instance.artifact = 'test_artifact.tar.gz'
+        instance.project = 'test_project'
+      end
+
+      context 'when passed a block' do
+        it 'should store the block' do
+          test_block = Proc.new { |test| "block_output" }
+          instance.run(&test_block)
+
+          instance.instance_variable_get("@run_block").should == test_block
+        end
+      end
+
+      context 'when not passed a block' do
+        before(:each) do
+          @mock_ssh = double(:ssh, 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}" })
+        end
+
+        it 'should use hosts from --hosts if passed' do
+          instance.instance_variable_set(:@_argv_hosts, [ 'argv_host1', 'argv_host2' ])
+
+          output = capture(:stdout) do
+            instance.run
+          end
+
+          instance.hosts.should == [ 'argv_host1', 'argv_host2' ]
+          output.should include('argv_host1', 'argv_host2')
+          output.should_not include('hf_host')
+        end
+
+        it 'should use hosts from Harrisonfile if --hosts not passed' do
+          output = capture(:stdout) do
+            instance.run
+          end
+
+          instance.hosts.should == [ 'hf_host' ]
+          output.should 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)
+          end
+
+          output.should include('must', 'specify', 'hosts')
+        end
+
+        it 'should invoke the previously stored block once for each host' do
+          instance.hosts = [ 'host1', 'host2', 'host3' ]
+
+          output = capture(:stdout) do
+            expect { |b| instance.run(&b); instance.run }.to yield_control.exactly(3).times
+          end
+
+          output.should include('host1', 'host2', 'host3')
+        end
+      end
+    end
+
+    describe '#close' do
+      before(:each) do
+        @test_host1_ssh = double(:ssh, 'closed?' => false)
+        @test_host2_ssh = double(:ssh, 'closed?' => false)
+
+        instance.instance_variable_set(:@_conns, { test_host1: @test_host1_ssh, test_host2: @test_host2_ssh })
+      end
+
+      context 'when passed a specific host' do
+        it 'should close the connection to that host' do
+          expect(@test_host1_ssh).to receive(:close).and_return(true)
+
+          instance.close(:test_host1)
+        end
+      end
+
+      it 'should close every open ssh connection' do
+        expect(@test_host1_ssh).to receive(:close).and_return(true)
+        expect(@test_host2_ssh).to receive(:close).and_return(true)
+
+        instance.close
+      end
+    end
+  end
+
+  describe 'protected methods' do
+    describe '#ssh' do
+      it 'should open a new SSH connection to self.host' do
+        mock_ssh = double(:ssh)
+        expect(Harrison::SSH).to receive(:new).and_return(mock_ssh)
+
+        instance.host = 'test_host'
+
+        instance.send(:ssh).should == mock_ssh
+      end
+
+      it 'should reuse an existing connection to self.host' do
+        mock_ssh = double(:ssh)
+        instance.instance_variable_set(:@_conns, { test_host2: mock_ssh })
+
+        instance.host = :test_host2
+
+        instance.send(:ssh).should == mock_ssh
+      end
+    end
+
+    describe '#remote_project_dir' do
+      it 'should combine base_dir and project name' do
+        instance.base_dir = '/test_base_dir'
+        instance.project = 'test_project'
+
+        instance.send(:remote_project_dir).should include('/test_base_dir', 'test_project')
+      end
+    end
+  end
+end