robot-army-git-deploy 0.0.4

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2007 Wesabe, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.markdown

@@ -0,0 +1,4 @@
+Robot Army Git Deploy
+=====================
+
+Deployment for Robot Army for projects using a git repository.

data/Rakefile

@@ -0,0 +1,9 @@
+begin
+  require 'rubygems'
+  require 'thor'
+  
+  $stderr.puts "Robot Army uses thor, not rake. Here are the available tasks:"
+  exec "thor -T"
+rescue LoadError
+  $stderr.puts "Robot Army uses thor, not rake. Please install thor."
+end

data/lib/robot-army-git-deploy.rb

@@ -0,0 +1,12 @@
+$:.unshift(File.dirname(__FILE__))
+
+# external libraries
+require 'rubygems'
+require 'grit'
+require 'robot-army'
+require 'fileutils'
+require 'highline'
+
+# internal files
+require 'robot-army-git-deploy/git_deployer'
+require 'robot-army-git-deploy/grit_ext'

data/lib/robot-army-git-deploy/git_deployer.rb

@@ -0,0 +1,251 @@
+module RobotArmy::GitDeployer
+  def self.included(base)
+    base.const_set(:DEPLOY_COUNT, 5)
+
+    base.class_eval do
+      method_options :target_revision => :string
+
+      desc "check", "Checks the deploy status"
+      def check(opts={})
+        update_server_refs
+
+        run_pager
+
+        say "Deployed Revisions"
+
+        deployed_revisions.each do |host, revision|
+          if revision
+            commit = commit_from_revision_or_abort(revision)
+            puts "%s: %s %s [%s]" % [
+              host,
+              color(commit.id_abbrev, :yellow),
+              commit.message.to_a.first.chomp,
+              commit.author.name]
+          else
+            puts "%s: %s %s" % [
+              host,
+              color('0000000', :yellow),
+              "(no deployed revision)"]
+          end
+        end
+
+        puts
+
+        say "On Deck"
+
+        if oldest_deployed_revision == target_revision
+          puts "Deployed revision is up to date"
+        elsif oldest_deployed_revision
+          shortlog "#{oldest_deployed_revision}..#{target_revision}"
+          diff "#{oldest_deployed_revision}..#{target_revision}"
+        else
+          shortlog target_revision, :root => true
+          diff target_revision, :root => true
+        end
+      end
+
+      desc "archive", "Write HEAD to a tgz file"
+      def archive
+        say "Archiving to #{archive_path}"
+        %x{git archive --format=tar #{target_revision} | gzip >#{archive_path}}
+      end
+
+      desc "stage", "Stages the locally-generated archive on each host"
+      def stage
+        revision = repo.commits.first.id
+
+        # create the destination directory
+        sudo do
+          FileUtils.mkdir_p(deploy_path)
+          FileUtils.chown(user, group, deploy_path)
+        end
+
+        say "Staging #{app} into #{deploy_path}"
+        cptemp(archive_path, :user => user) do |path|
+          %x{tar -xvz -f #{path} -C #{deploy_path}}
+          File.open(File.join(deploy_path, 'REVISION'), 'w') {|f| f << revision}
+          path # just so that we don't try to return a File and generate a warning
+        end
+      end
+
+    no_tasks do
+
+      def install
+        say "Installing #{app} into #{current_link}"
+        sudo do
+          FileUtils.rm_f(current_link)
+          FileUtils.ln_sf(deploy_path, current_link)
+        end
+        update_server_refs(true)
+      end
+
+      def cleanup
+        clean_temporary_files
+        clean_old_revisions
+      end
+
+      def clean_temporary_files
+        say "Cleaning up temporary files"
+        FileUtils.rm_f("#{app}-archive.tar.gz")
+      end
+
+      def clean_old_revisions
+        say "Cleaning up old revisions"
+        deploy_count = self.class.const_get(:DEPLOY_COUNT)
+
+        sudo do
+          deploy_paths = Dir.glob(File.join(deploy_root, '*')).sort
+          deploy_paths -= [current_link]
+          FileUtils.rm_rf(deploy_paths.first(deploy_paths.size - deploy_count)) if deploy_paths.size > deploy_count
+        end
+      end
+
+      desc "run", "Run a full deploy"
+      def run
+        archive
+        stage
+        install
+        cleanup
+      end
+
+    end
+    end
+  end
+
+  private
+
+  def repo
+    @repo ||= Grit::Repo.new(Dir.pwd)
+  end
+
+  def git
+    repo.git
+  end
+
+  def revfile
+    File.join(current_link, 'REVISION')
+  end
+
+  def deployed_revisions
+    @deployed_revisions ||= hosts.zip(Array(remote { File.read(revfile).chomp if File.exist?(revfile) }))
+  end
+
+  def clear_deployed_revisions_cache
+    @deployed_revisions = nil
+  end
+
+  def deployed_revisions_equal?
+    deployed_revisions.map{|host, revision| revision}.uniq.size == 1
+  end
+
+  def target_revision
+    options[:target_revision] || repo.head.commit
+  end
+
+  def oldest_deployed_revision
+    oldest_commit = deployed_revisions.
+                  map {|host, revision| repo.commit(revision) if revision}.
+                  compact.
+                  sort.
+                  first
+    return oldest_commit.id if oldest_commit
+  end
+
+  def update_server_refs(refresh=false)
+    clear_deployed_revisions_cache if refresh
+
+    deployed_revisions.each do |host, revision|
+      # thanks to doener in #git for this idea
+      git.update_ref({}, "refs/servers/#{host}", revision) if revision
+    end
+  end
+
+  def clear_deployed_refs
+    pairs = git.for_each_ref({:format => "%(objectname) %(refname)"}, 'refs/servers').to_a
+    pairs.map!{|line| line.chomp.split(' ')}
+    pairs.each do |objectname, refname|
+      git.update_ref({:d => true}, refname, objectname)
+    end
+  end
+
+  def archive_path
+    "#{app}-archive.tar.gz"
+  end
+
+  def deploy_root
+    File.expand_path(File.join(root, app))
+  end
+
+  def deploy_path
+    File.join(deploy_root, timestamp)
+  end
+
+  def current_link
+    File.join(deploy_root, 'current')
+  end
+
+  def color(*args)
+    (@highline ||= HighLine.new).color(*args)
+  end
+
+  def log(what, options={})
+    puts git.log({:pretty=>'oneline', :'abbrev-commit'=>true, :color=>true}.merge(options), what)
+  end
+
+  def shortlog(what, options={})
+    puts git.shortlog({:color=>true}.merge(options), what)
+  end
+
+  def diff(what, options={})
+    # dumb, dumb, dumb
+    puts git.send(:method_missing, :diff, {:stat => true, :color => true}.merge(options), what)
+  end
+
+  def deployed_revision
+    deployed_revisions.find{|host, revision| revision}.last
+  end
+
+  def commit_from_revision_or_abort(revision)
+    if commit = repo.commits(revision, 1).first
+      return commit
+    else
+      $stderr.puts "#{color('ERROR', :red)}: The deployed revision (#{color(revision, :yellow)}) was not found in your local repository. Perhaps you need to update first?"
+      exit(1)
+    end
+  end
+
+  def revfile
+    File.join(current_link, 'REVISION')
+  end
+
+  def timestamp
+    @timestamp ||= Time.now.utc.strftime("%Y-%m-%d-%H-%M-%S")
+  end
+
+
+  def run_pager
+    return if PLATFORM =~ /win32/
+    return unless STDOUT.tty?
+
+    read, write = IO.pipe
+
+    unless Kernel.fork # Child process
+      STDOUT.reopen(write)
+      STDERR.reopen(write) if STDERR.tty?
+      read.close
+      write.close
+      return
+    end
+
+    # Parent process, become pager
+    STDIN.reopen(read)
+    read.close
+    write.close
+
+    ENV['LESS'] = 'FSRX' # Don't page if the input is short enough
+
+    Kernel.select [STDIN] # Wait until we have input before we start the pager
+    pager = ENV['PAGER'] || 'less'
+    exec pager rescue exec "/bin/sh", "-c", pager
+  end
+end

data/lib/robot-army-git-deploy/grit_ext.rb

@@ -0,0 +1,18 @@
+class Grit::Commit
+  include Comparable
+  
+  def <=>(other)
+    raise ArgumentError unless other.is_a?(Grit::Commit)
+    
+    if id == other.id
+      return 0
+    elsif not @repo.commits("#{id}..#{other.id}").empty?
+      return -1
+    elsif not @repo.commits("#{other.id}..#{id}").empty?
+      return 1
+    else
+      raise ArgumentError, 
+        "#{other.inspect} is not an ancestor of #{self.inspect} or vice-versa, and are therefor not comparable"
+    end
+  end
+end

data/spec/git_deployer_spec.rb

@@ -0,0 +1,230 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class Deploy < RobotArmy::TaskMaster
+  include RobotArmy::GitDeployer
+
+  hosts %w[test1 test2 test3]
+
+  def remote(hosts=self.class.hosts)
+    hosts.size == 1 ? yield : hosts.map { yield }
+  end
+
+  alias_method :sudo, :remote
+
+  def root
+    "/opt"
+  end
+
+  def app
+    "test"
+  end
+
+  def user
+    "nobody"
+  end
+
+  def group
+    "nobody"
+  end
+
+  def color(str, color)
+    str
+  end
+
+  # make all methods public so we can test 'em easily
+  private_instance_methods.each { |m| public m }
+end
+
+class FakeCommit
+  attr_reader :id
+  include Comparable
+
+  def initialize(id)
+    @id = id
+  end
+
+  def <=>(other)
+    id <=> other.id
+  end
+end
+
+describe RobotArmy::GitDeployer do
+  before do
+    @deploy = Deploy.new
+    @deploy.options = (@options = {})
+  end
+
+  describe "tasks" do
+    it "defines a 'check' task" do
+      Deploy.tasks['check'].must be_an_instance_of(Thor::Task)
+    end
+
+    it "defines a 'run' task" do
+      Deploy.tasks['run'].must be_an_instance_of(Thor::Task)
+    end
+
+    it "defines a 'cleanup' task" do
+      Deploy.tasks['cleanup'].must be_an_instance_of(Thor::Task)
+    end
+
+    it "defines a 'install' task" do
+      Deploy.tasks['install'].must be_an_instance_of(Thor::Task)
+    end
+
+    it "defines a 'archive' task" do
+      Deploy.tasks['archive'].must be_an_instance_of(Thor::Task)
+    end
+
+    it "defines a 'stage' task" do
+      Deploy.tasks['stage'].must be_an_instance_of(Thor::Task)
+    end
+  end
+
+  describe "plumbing" do
+    describe "when the revfile exists on all hosts" do
+      before do
+        File.stub!(:exist?).with(@deploy.revfile).any_number_of_times.and_return(true)
+        File.stub!(:read).with(@deploy.revfile).any_number_of_times.and_return("abcde\n")
+      end
+
+      it "can get the list of deployed revisions" do
+        @deploy.deployed_revisions.must == [%w[test1 abcde], %w[test2 abcde], %w[test3 abcde]]
+      end
+    end
+  end
+
+  describe "when the revfile doesn't exist on a host" do
+    before do
+      File.stub!(:exist?).with(@deploy.revfile).and_return(true, true, false)
+      File.stub!(:read).with(@deploy.revfile).twice.and_return("abcde\n")
+    end
+
+    it "returns nil for that host's revision" do
+      @deploy.deployed_revisions.must == [%w[test1 abcde], %w[test2 abcde], ['test3', nil]]
+    end
+  end
+
+  describe "oldest_deployed_revision" do
+    describe "when all revisions are equal" do
+      before do
+        @deploy.stub!(:repo).and_return(stub(:repo, :commit => FakeCommit.new('abcde')))
+      end
+
+      it "sorts commits and returns the first (oldest) one" do
+        @deploy.
+          stub!(:deployed_revisions).
+          and_return([%w[test1 abcde], %w[test2 abcde], %w[test3 abcde]])
+
+        @deploy.oldest_deployed_revision.must == 'abcde'
+      end
+    end
+
+    describe "when not all revisions are equal" do
+      before do
+        @repo = stub(:repo)
+        @repo.
+          stub!(:commit).
+          and_return(FakeCommit.new('cdeab'), FakeCommit.new('abcde'), FakeCommit.new('deabc'))
+
+        @deploy.
+          stub!(:repo).
+          and_return(@repo)
+      end
+
+      it "sorts commits and returns the first (oldest) one" do
+        @deploy.
+          stub!(:deployed_revisions).
+          and_return([%w[test1 cdeab], %w[test2 abcde], %w[test3 deabc]])
+
+        @deploy.oldest_deployed_revision.must == 'abcde'
+      end
+    end
+  end
+
+  describe "target_revision" do
+    it "defaults to the current HEAD" do
+      @deploy.stub!(:repo).and_return(stub(:repo, :commits => [FakeCommit.new('abcde')]))
+      @deploy.target_revision.must == 'abcde'
+    end
+
+    it "can be set as an option" do
+      @options[:target_revision] = 'production'
+      @deploy.target_revision.must == 'production'
+    end
+  end
+
+  describe "commit_from_revision_or_abort" do
+    describe "given a revision in the repository" do
+      before do
+        @commit = FakeCommit.new('abcde')
+        @deploy.stub!(:repo).and_return(stub(:repo, :commits => [@commit]))
+      end
+
+      it "returns the commit for that revision" do
+        @deploy.commit_from_revision_or_abort('abcde').must == @commit
+      end
+    end
+
+    describe "given a revision not in the repository" do
+      before do
+        @deploy.stub!(:repo).and_return(stub(:repo, :commits => []))
+      end
+
+      it "warns about the missing commit and exits" do
+        @deploy.should_receive(:exit).with(1)
+        capture(:stderr) { @deploy.commit_from_revision_or_abort('abcde') }.
+          must == "ERROR: The deployed revision (abcde) was not found in your local repository. Perhaps you need to update first?\n"
+      end
+    end
+  end
+
+  describe "clean_old_revisions" do
+    def deployed_revision_paths_for_range(range, include_current=true)
+      (include_current ? [@deploy.current_link] : []) + range.map {|i| File.join(@deploy.deploy_root, "deploy-#{i}")}
+    end
+
+    describe "when there are no deployed revisions" do
+      before do
+        Dir.stub!(:glob).with(File.join(@deploy.deploy_root, '*')).and_return(deployed_revision_paths_for_range(1...1))
+      end
+
+      it "does not remove anything" do
+        FileUtils.should_not_receive(:rm_rf)
+        silence(:stdout) { @deploy.clean_old_revisions }
+      end
+    end
+
+    describe "when there are less than DEPLOY_COUNT deployed revisions" do
+      before do
+        Dir.stub!(:glob).with(File.join(@deploy.deploy_root, '*')).and_return(deployed_revision_paths_for_range(1...Deploy::DEPLOY_COUNT))
+      end
+
+      it "does not remove anything" do
+        FileUtils.should_not_receive(:rm_rf)
+        silence(:stdout) { @deploy.clean_old_revisions }
+      end
+    end
+
+    describe "when there are exactly DEPLOY_COUNT deployed revisions" do
+      before do
+        Dir.stub!(:glob).with(File.join(@deploy.deploy_root, '*')).and_return(deployed_revision_paths_for_range(1..Deploy::DEPLOY_COUNT))
+      end
+
+      it "does not remove anything" do
+        FileUtils.should_not_receive(:rm_rf)
+        silence(:stdout) { @deploy.clean_old_revisions }
+      end
+    end
+
+    describe "when there are more than DEPLOY_COUNT deployed revisions" do
+      before do
+        Dir.stub!(:glob).with(File.join(@deploy.deploy_root, '*')).and_return(deployed_revision_paths_for_range(1..(Deploy::DEPLOY_COUNT+2)))
+      end
+
+      it "removes enough of the oldest deployed revisions to get the count down to DEPLOY_COUNT" do
+        FileUtils.should_receive(:rm_rf).with(deployed_revision_paths_for_range(1..2, false)).exactly(@deploy.hosts.size).times
+        silence(:stdout) { @deploy.clean_old_revisions }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+$TESTING=true
+load File.join(File.dirname(__FILE__), '..', 'lib', 'robot-army-git-deploy.rb')
+
+module Spec::Expectations::ObjectExpectations
+  alias_method :must, :should
+  alias_method :must_not, :should_not
+  undef_method :should
+  undef_method :should_not
+end
+
+Spec::Runner.configure do |config|
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure 
+      eval("$#{stream} = #{stream.upcase}")
+    end
+
+    result
+  end
+  
+  alias silence capture
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification 
+name: robot-army-git-deploy
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- Brian Donovan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-23 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: robot-army
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 7
+        version: 0.1.7
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 11
+        - 3
+        version: 0.11.3
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: grit
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 0
+        version: 0.0.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: highline
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 0
+        version: 0.0.0
+  type: :runtime
+  version_requirements: *id004
+description: Robot Army deployment with git repositories
+email: brian@wesabe.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- lib/robot-army-git-deploy.rb
+- lib/robot-army-git-deploy/git_deployer.rb
+- lib/robot-army-git-deploy/grit_ext.rb
+has_rdoc: true
+homepage: http://github.com/wesabe/robot-army-git-deploy
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: robot-army-git-deploy
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Robot Army deployment with git repositories
+test_files: 
+- spec/git_deployer_spec.rb
+- spec/spec_helper.rb