harrison 0.0.1

data/.gitignore

@@ -0,0 +1,24 @@
+.DS_Store
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/Harrisonfile

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in harrison.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jesse Scott
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,137 @@
+# Harrison
+
+Simple artifact-based deployment for web applications.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'harrison'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install harrison
+
+## Usage
+
+First, create a Harrisonfile in the root of your project. Here's an example:
+
+```ruby
+# 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 = 'build-server.example.com'
+  h.user = 'jesse'
+
+  # Things we don't want to package.
+  h.exclude = %w(.git ./config ./coverage ./examples ./log ./pkg ./tmp ./spec)
+
+  # Define the build process here.
+  h.run do |h|
+    # Bundle Install
+    h.remote_exec("cd #{h.commit} && bash -l -c \"bundle install --path=vendor --without=\\\"development packaging test doc\\\"\"")
+  end
+end
+
+Harrison.deploy do |h|
+  h.hosts = [ 'util-server-01.example.com', 'app-server-01.example.com', 'app-server-02.example.com' ]
+  h.user = 'jesse'
+  h.base_dir = '/opt'
+
+  # Run block will be invoked once for each host after new code is in place.
+  h.run do |h|
+    # You can interrogate h.host to see what host you are currently running on.
+    if h.host =~ /util/
+      # Do something on the util box.
+    else
+      puts "Reloading Unicorn on #{h.host}..."
+      h.remote_exec("sudo -- /etc/init.d/unicorn_#{h.project} reload")
+    end
+  end
+end
+```
+
+Next, ensure that your SSH key is authorized to log in as the `user` you have specified in
+the Harrisonfile for each task. (Or be ready to type the password a lot. :weary:)
+
+### Building a Release
+
+Use the `harrison package` command:
+
+```
+$ harrison package
+```
+
+By default this will build and package `HEAD` of your current branch. You may specify another commit to
+build using the `--commit` option:
+
+```
+$ harrison package --commit mybranch
+```
+
+The `--commit` option understands anything that `git rev-parse` understands. *NOTE: The commit you
+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:
+
+```
+$ harrison package
+Packaging 5a547d8 for "harrison" on build-server.example.com...
+Sucessfully packaged 5a547d8 to pkg/20140711170226-5a547d8.tar.gz
+```
+
+There are some additional options available, run `harrison package --help` to see everything available.
+
+
+### Deploying a Release
+
+Use the `harrison deploy` command passing the artifact to be deployed as an argument:
+
+```
+$ harrison deploy pkg/20140711170226-5a547d8.tar.gz
+```
+
+By default, this will deploy to the list of hosts defined in your Harrisonfile.
+
+You can override the target hosts by passing a `--hosts` option:
+
+```
+$ harrison deploy pkg/20140711170226-5a547d8.tar.gz --hosts test-app-server-01.example.com test-app-server-02.example.com
+```
+
+You can also pass an `--env` option to deploy into multi-stage environments:
+
+```
+$ harrison deploy pkg/20140711170226-5a547d8.tar.gz --env prod
+```
+
+This value can then be tested to alter the default target hosts in your Harrisonfile:
+
+```ruby
+if h.env =~ /prod/
+  h.hosts = [ 'app-server-01.prod.example.com', 'app-server-02.prod.example.com' ]
+else
+  h.hosts = [ 'app-server-01.stage.example.com', 'app-server-02.stage.example.com' ]
+end
+```
+
+There are some additional options available, run `harrison deploy --help` to see everything available.
+
+
+## Contributing
+
+1. Fork it ( https://github.com/scotje/harrison/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new('spec')
+
+# If you want to make this the default task
+task :default => :spec

data/TODO

@@ -0,0 +1,26 @@
+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

data/bin/harrison

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+# Exit cleanly from an early interrupt
+Signal.trap("INT") { exit 1 }
+
+require 'harrison'
+Harrison.invoke(ARGV)

data/harrison.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'harrison/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "harrison"
+  spec.version       = Harrison::VERSION
+  spec.authors       = ["Jesse Scott"]
+  spec.email         = ["jesse@puppetlabs.com"]
+  spec.summary       = %q{Simple artifact-based deployment for web applications.}
+  spec.homepage      = "https://github.com/scotje/harrison"
+  spec.license       = "Apache 2.0"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = ["harrison"]
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 1.9.3'
+
+  spec.add_runtime_dependency "trollop"
+  spec.add_runtime_dependency "net-ssh"
+  spec.add_runtime_dependency "net-scp"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  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"
+end

data/lib/harrison/base.rb

@@ -0,0 +1,101 @@
+module Harrison
+  class Base
+    attr_reader :ssh
+    attr_accessor :options
+
+    def initialize(arg_opts=[], opts={})
+      # Config helpers for Harrisonfile.
+      self.class.option_helper(:user)
+
+      @arg_opts = arg_opts
+      @arg_opts << [ :debug, "Output debug messages.", :type => :boolean, :default => false ]
+
+      @options = opts
+    end
+
+    def self.option_helper(option)
+      send :define_method, option do
+        @options[option]
+      end
+
+      send :define_method, "#{option}=" do |val|
+        @options[option] = val
+      end
+    end
+
+    # Find config from Harrison.config if it's not on this class.
+    def method_missing(meth, *args, &block)
+      if Harrison.config.respond_to?(meth)
+        Harrison.config.send(meth, *args, &block)
+      else
+        super
+      end
+    end
+
+    def exec(cmd)
+      result = `#{cmd}`
+      abort("ERROR: Unable to execute local command: \"#{cmd}\"") if !$?.success? || result.nil?
+      result.strip
+    end
+
+    def remote_exec(cmd)
+      result = ssh.exec(cmd)
+      abort("ERROR: Unable to execute remote command: \"#{cmd}\"") if result.nil?
+      result.strip
+    end
+
+    def parse(args)
+      opt_parser = Trollop::Parser.new
+
+      @arg_opts.each do |arg_opt|
+        opt_parser.opt(*arg_opt)
+      end
+
+      @options.merge!(Trollop::with_standard_exception_handling(opt_parser) do
+        opt_parser.parse(args)
+      end)
+
+      Harrison.send(:remove_const, "DEBUG") if Harrison.const_defined?("DEBUG")
+      Harrison.const_set("DEBUG", @options[:debug])
+    end
+
+    def run(&block)
+      if block_given?
+        # If called with a block, convert it to a proc and store.
+        @run_block = block
+      else
+        # Otherwise, invoke the previously stored block with self.
+        @run_block && @run_block.call(self)
+      end
+    end
+
+    def download(remote_path, local_path)
+      ssh.download(remote_path, local_path)
+    end
+
+    def upload(local_path, remote_path)
+      ssh.upload(local_path, remote_path)
+    end
+
+    def close
+      ssh.close if @ssh
+    end
+
+    protected
+
+    def ssh
+      @ssh ||= Harrison::SSH.new(host: @options[:host], user: @options[:user])
+    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)
+      @_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}\".")
+    end
+  end
+end

data/lib/harrison/config.rb

@@ -0,0 +1,9 @@
+module Harrison
+  class Config
+    attr_accessor :project
+    attr_accessor :git_src
+
+    def initialize(opts={})
+    end
+  end
+end

data/lib/harrison/deploy.rb

@@ -0,0 +1,110 @@
+module Harrison
+  class Deploy < Base
+    attr_accessor :artifact
+    attr_accessor :host # The specific host among --hosts that we are currently working on.
+    attr_accessor :release_dir
+    attr_accessor :deploy_link
+
+    def initialize(opts={})
+      # Config helpers for Harrisonfile.
+      self.class.option_helper(:hosts)
+      self.class.option_helper(:env)
+      self.class.option_helper(:base_dir)
+      self.class.option_helper(:deploy_via)
+
+      # Command line opts for this action. Will be merged with common opts.
+      arg_opts = [
+        [ :hosts, "List of remote hosts to deploy to. Can also be specified in Harrisonfile.", :type => :strings ],
+        [ :env, "Environment to deploy to. This can be examined in your Harrisonfile to calculate target hosts.", :type => :string ],
+      ]
+
+      super(arg_opts, opts)
+    end
+
+    def parse(args)
+      super
+
+      # Preserve argv hosts if it's been passed.
+      @_argv_hosts = self.hosts.dup if self.hosts
+
+      # Make sure they passed an artifact.
+      self.artifact = args[1] || abort("ERROR: You must specify the artifact to be deployed as an argument to this command.")
+    end
+
+    def remote_exec(cmd)
+      super("cd #{remote_project_dir} && #{cmd}")
+    end
+
+    def run(&block)
+      return super if block_given?
+
+      # Override Harrisonfile hosts if it was passed on argv.
+      self.hosts = @_argv_hosts if @_argv_hosts
+
+      if !self.hosts || self.hosts.empty?
+        abort("ERROR: You must specify one or more hosts to deploy to, either in your Harrisonfile or via --hosts.")
+      end
+
+      # Default base_dir.
+      self.base_dir ||= '/opt'
+
+      puts "Deploying #{artifact} for \"#{project}\" onto #{hosts.size} hosts..."
+
+      self.release_dir = "#{remote_project_dir}/releases/" + File.basename(artifact, '.tar.gz')
+      self.deploy_link = "#{remote_project_dir}/deploys/" + Time.new.utc.strftime('%Y-%m-%d_%H%M%S')
+
+      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")
+
+        # 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/")
+
+        # Unpack.
+        remote_exec("cd #{release_dir} && tar -xzf ../#{File.basename(artifact)}")
+
+        # Clean up artifact.
+        remote_exec("rm -f #{remote_project_dir}/releases/#{File.basename(artifact)}")
+
+        # Symlink a new deploy to this release.
+        remote_exec("ln -s #{release_dir} #{deploy_link}")
+
+        # Symlink current to new deploy.
+        remote_exec("ln -sfn #{deploy_link} #{remote_project_dir}/current")
+
+        # Run user supplied deploy code to restart server or whatever.
+        super
+
+        close(self.host)
+      end
+
+      puts "Sucessfully deployed #{artifact} to #{hosts.join(', ')}."
+    end
+
+    def close(host=nil)
+      if host
+        @_conns[host].close if @_conns && @_conns[host]
+      elsif @_conns
+        @_conns.keys.each do |host|
+          @_conns[host].close unless @_conns[host].closed?
+        end
+      end
+    end
+
+    protected
+
+    def ssh
+      @_conns ||= {}
+      @_conns[self.host] ||= Harrison::SSH.new(host: self.host, user: @options[:user], proxy: self.deploy_via)
+    end
+
+    def remote_project_dir
+      "#{base_dir}/#{project}"
+    end
+  end
+end

data/lib/harrison/package.rb

@@ -0,0 +1,87 @@
+module Harrison
+  class Package < Base
+    def initialize(opts={})
+      # Config helpers for Harrisonfile.
+      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(:remote_dir)
+      self.class.option_helper(:exclude)
+
+      # Command line opts for this action. Will be merged with common opts.
+      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" ],
+        [ :remote_dir, "Remote working folder.", :type => :string, :default => "~/.harrison" ],
+      ]
+
+      super(arg_opts, opts)
+    end
+
+    def remote_exec(cmd)
+      ensure_remote_dir(self.host, "#{remote_project_dir}/package")
+
+      super("cd #{remote_project_dir}/package && #{cmd}")
+    end
+
+    def run(&block)
+      return super if block_given?
+
+      # Resolve commit ref to an actual short SHA.
+      resolve_commit!
+
+      puts "Packaging #{commit} for \"#{project}\" on #{host}..."
+
+      # Make sure the folder to save the artifact to locally exists.
+      ensure_local_dir(pkg_dir)
+
+      # 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")
+
+      # Check out target commit.
+      remote_exec("cd cached && git reset --hard #{commit} && git clean -f -d")
+
+      # Make a build folder of the target commit.
+      remote_exec("rm -rf #{commit} && cp -a cached #{commit}")
+
+      # Run user supplied build code.
+      # TODO: alter remote_exec to set directory context to commit dir?
+      super
+
+      # 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 purge
+        remote_exec("cd .. && rm -rf package")
+      end
+
+      puts "Sucessfully packaged #{commit} to #{pkg_dir}/#{artifact_name(commit)}.tar.gz"
+    end
+
+    protected
+
+    def remote_project_dir
+      "#{remote_dir}/#{project}"
+    end
+
+    def resolve_commit!
+      self.commit = exec("git rev-parse --short #{self.commit} 2>/dev/null")
+    end
+
+    def excludes_for_tar
+      return '' if !exclude || exclude.empty?
+
+      "--exclude \"#{exclude.join('" --exclude "')}\""
+    end
+
+    def artifact_name(commit)
+      @_timestamp ||= Time.new.utc.strftime('%Y%m%d%H%M%S')
+      "#{@_timestamp}-#{commit}"
+    end
+  end
+end

data/lib/harrison/ssh.rb

@@ -0,0 +1,80 @@
+require 'net/ssh'
+require 'net/ssh/proxy/command'
+require 'net/scp'
+
+module Harrison
+  class SSH
+    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)
+      else
+        @conn = Net::SSH.start(opts[:host], opts[:user], forward_agent: true)
+      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
+
+          channel.on_request("exit-status") do |ch,data|
+            exit_code = data.read_long
+          end
+        end
+      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
+    end
+
+    def download(remote_path, local_path)
+      puts "INFO (scp-down #{desc}): #{local_path} <<< #{remote_path}" if Harrison::DEBUG
+      @conn.scp.download!(remote_path, local_path)
+    end
+
+    def upload(local_path, remote_path)
+      puts "INFO (scp-up #{desc}): #{local_path} >>> #{remote_path}" if Harrison::DEBUG
+      @conn.scp.upload!(local_path, remote_path)
+    end
+
+    def close
+      # net-ssh doesn't seem to know how to close proxy::command connections
+      Process.kill("TERM", @conn.transport.socket.pid) if @proxy
+      @conn.close
+    end
+
+    def closed?
+      @conn.closed?
+    end
+
+    def desc
+      if @proxy
+        "#{@conn.host} (via #{@proxy.command_line.split(' ')[1]})"
+      else
+        @conn.host
+      end
+    end
+  end
+end

data/lib/harrison/version.rb

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