dynport-capistrano_rsync_with_remote_cache 2.4.1

data/README.rdoc

@@ -0,0 +1,96 @@
+= Capistrano rsync_with_remote_cache Deployment Strategy
+
+== Description
+
+This gem provides a deployment strategy for Capistrano which combines the
+<tt>rsync</tt> command with a remote cache, allowing fast deployments from SCM
+repositories behind firewalls.
+
+== Requirements
+
+This gem supports Subversion, Git, Mercurial and Bazaar. Only Subversion and
+Git have been extensively tested. This gem is unlikely to be supported for
+other SCM systems.
+
+This gem requires the <tt>rsync</tt> command-line utilities on the local and
+remote hosts. It also requires either <tt>svn</tt>, <tt>git</tt>, <tt>hg</tt>
+or <tt>bzr</tt> on the local host, but not the remote host.
+
+This gem is tested on Mac OS X and Linux. Windows is neither tested nor supported.
+
+== Installation
+
+    gem install capistrano_rsync_with_remote_cache
+
+== Usage
+
+To use this deployment strategy, add this line to your <tt>deploy.rb</tt> file:
+
+    set :deploy_via, :rsync_with_remote_cache
+
+== Under the Hood
+
+This strategy maintains two cache directories:
+
+* The local cache directory is a checkout from the SCM repository. The local
+  cache directory is specified with the <tt>:local_cache</tt> variable in the
+  configuration. If not specified, it will default to <tt>.rsync_cache</tt>
+  in the same directory as the Capfile.
+
+* The remote cache directory is an <tt>rsync</tt> copy of the local cache directory.
+  The remote cache directory is specified with the <tt>:repository_cache</tt> variable
+  in the configuration (this name comes from the <tt>:remote_cache</tt> strategy that
+  ships with Capistrano, and has been maintained for compatibility.) If not
+  specified, it will default to <tt>shared/cached-copy</tt> (again, for compatibility
+  with remote_cache.)
+
+Deployment happens in three major steps. First, the local cache directory is
+processed. There are three possibilities:
+
+* If the local cache does not exist, it is created with a checkout of the
+  revision to be deployed.
+* If the local cache exists and matches the <tt>:repository</tt> variable, it is
+  updated to the revision to be deployed.
+* If the local cache exists and does not match the <p>:repository</p> variable,
+  the local cache is purged and recreated with a checkout of the revision
+  to be deployed.
+* If the local cache exists but is not a directory, an exception is raised
+
+Second, <tt>rsync</tt> runs on the local side to sync the remote cache to the local
+cache. When the <tt>rsync</tt> is complete, the remote cache should be an exact
+replica of the local cache.
+
+Finally, a copy of the remote cache is made in the appropriate release
+directory. The end result is the same as if the code had been checked out
+directly on the remote server, as in the default strategy.
+
+== Contributors
+
+Thanks to the people who submitted patches:
+
+* {S. Brent Faulkner}[http://github.com/sbfaulkner]
+
+== License
+
+Copyright (c) 2007 - 2010 Patrick Reagan (patrick.reagan@viget.com) & Mark Cornick
+
+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/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+spec = eval(File.read(File.expand_path("../capistrano_rsync_with_remote_cache.gemspec", __FILE__)))
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+task :default => :test

data/lib/capistrano/recipes/deploy/strategy/rsync_with_remote_cache.rb

@@ -0,0 +1,121 @@
+require 'capistrano/recipes/deploy/strategy/remote'
+require 'fileutils'
+
+module Capistrano
+  module Deploy
+    module Strategy
+      class RsyncWithRemoteCache < Remote
+        
+        class InvalidCacheError < Exception; end
+
+        def self.default_attribute(attribute, default_value)
+          define_method(attribute) { configuration[attribute] || default_value }
+        end
+
+        INFO_COMMANDS = {
+          :subversion => "svn info . | sed -n \'s/URL: //p\'",
+          :git        => "git config remote.origin.url",
+          :mercurial  => "hg showconfig paths.default",
+          :bzr        => "bzr info | grep parent | sed \'s/^.*parent branch: //\'"
+        }
+        
+        default_attribute :rsync_options, '-az --delete'
+        default_attribute :local_cache, '.rsync_cache'
+        default_attribute :repository_cache, 'cached-copy'
+
+        def deploy!
+          update_local_cache
+          update_remote_cache
+          copy_remote_cache
+        end
+        
+        def update_local_cache
+          system(command) or raise "Dynport fixed it!"
+          mark_local_cache
+        end
+        
+        def update_remote_cache
+          finder_options = {:except => { :no_release => true }}
+          find_servers(finder_options).each {|s| system(rsync_command_for(s)) }
+        end
+        
+        def copy_remote_cache
+          run("rsync -a --delete #{repository_cache_path}/ #{configuration[:release_path]}/")
+        end
+        
+        def rsync_command_for(server)
+          "rsync #{rsync_options} --rsh='ssh -p #{ssh_port(server)}' #{local_cache_path}/ #{rsync_host(server)}:#{repository_cache_path}/"
+        end
+        
+        def mark_local_cache
+          File.open(File.join(local_cache_path, 'REVISION'), 'w') {|f| f << revision }
+        end
+        
+        def ssh_port(server)
+          server.port || ssh_options[:port] || 22
+        end
+        
+        def local_cache_path
+          File.expand_path(local_cache)
+        end
+        
+        def repository_cache_path
+          File.join(shared_path, repository_cache)
+        end
+        
+        def repository_url
+          `cd #{local_cache_path} && #{INFO_COMMANDS[configuration[:scm]]}`.strip
+        end
+        
+        def repository_url_changed?
+          repository_url != configuration[:repository]
+        end
+        
+        def remove_local_cache
+          logger.trace "repository has changed; removing old local cache from #{local_cache_path}"
+          FileUtils.rm_rf(local_cache_path)
+        end
+
+        def remove_cache_if_repository_url_changed
+          remove_local_cache if repository_url_changed?
+        end
+        
+        def rsync_host(server)
+          configuration[:user] ? "#{configuration[:user]}@#{server.host}" : server.host
+        end
+        
+        def local_cache_exists?
+          File.exist?(local_cache_path)
+        end
+        
+        def local_cache_valid?
+          local_cache_exists? && File.directory?(local_cache_path)
+        end
+
+        # Defines commands that should be checked for by deploy:check. These include the SCM command
+        # on the local end, and rsync on both ends. Note that the SCM command is not needed on the
+        # remote end.
+        def check!
+          super.check do |check|
+            check.local.command(source.command)
+            check.local.command('rsync')
+            check.remote.command('rsync')
+          end
+        end
+
+        private
+
+        def command
+          if local_cache_valid?
+            source.sync(revision, local_cache_path)
+          elsif !local_cache_exists?
+            "mkdir -p #{local_cache_path} && #{source.checkout(revision, local_cache_path)}"
+          else
+            raise InvalidCacheError, "The local cache exists but is not valid (#{local_cache_path})"
+          end
+        end
+      end
+      
+    end
+  end
+end

data/test/capistrano_rsync_with_remote_cache_test.rb

@@ -0,0 +1,299 @@
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+require 'shoulda'
+require 'matchy'
+require 'tmpdir'
+
+require 'capistrano/recipes/deploy/strategy/rsync_with_remote_cache'
+
+class CapistranoRsyncWithRemoteCacheTest < Test::Unit::TestCase
+  
+  context "An instance of the CapistranoRsyncWithRemoteCache class" do
+    setup { @strategy = Capistrano::Deploy::Strategy::RsyncWithRemoteCache.new }
+
+    should "know the default rsync options" do
+      @strategy.rsync_options.should == '-az --delete'
+    end
+    
+    should "allow overriding of the rsync options" do
+      @strategy.stubs(:configuration).with().returns(:rsync_options => 'new_opts')
+      @strategy.rsync_options.should == 'new_opts'
+    end
+
+    should "know the default local cache name" do
+      @strategy.local_cache.should == '.rsync_cache'
+    end
+    
+    should "know the local cache name if it has been configured" do
+      @strategy.stubs(:configuration).with().returns(:local_cache => 'cache')
+      @strategy.local_cache.should == 'cache'
+    end
+    
+    should "know the cache path" do
+      @strategy.stubs(:local_cache).with().returns('cache_dir')
+      File.expects(:expand_path).with('cache_dir').returns('local_cache_path')
+      
+      @strategy.local_cache_path.should == 'local_cache_path'
+    end
+    
+    should "know the repository URL for a subversion repository" do
+      @strategy.stubs(:local_cache_path).with().returns('cache_path')
+      @strategy.stubs(:configuration).with().returns(:scm => :subversion)
+      @strategy.expects(:`).with("cd cache_path && svn info . | sed -n \'s/URL: //p\'").returns("svn_url\n")
+      @strategy.repository_url.should == 'svn_url'
+    end
+    
+    should "know the repository URL for a git repository" do
+      @strategy.stubs(:local_cache_path).with().returns('cache_path')
+      @strategy.stubs(:configuration).with().returns(:scm => :git)
+      @strategy.expects(:`).with("cd cache_path && git config remote.origin.url").returns("git_url\n")
+      @strategy.repository_url.should == 'git_url'
+    end
+    
+    should "know the repository URL for a mercurial repository" do
+      @strategy.stubs(:local_cache_path).with().returns('cache_path')
+      @strategy.stubs(:configuration).with().returns(:scm => :mercurial)
+      @strategy.expects(:`).with("cd cache_path && hg showconfig paths.default").returns("hg_url\n")
+      @strategy.repository_url.should == 'hg_url'
+    end
+    
+    should "know the repository URL for a bzr repository" do
+      @strategy.stubs(:local_cache_path).with().returns('cache_path')
+      @strategy.stubs(:configuration).with().returns(:scm => :bzr)
+      @strategy.expects(:`).with("cd cache_path && bzr info | grep parent | sed \'s/^.*parent branch: //\'").returns("bzr_url\n")
+      @strategy.repository_url.should == 'bzr_url'
+    end
+    
+    should "know that the repository URL has not changed" do
+      @strategy.stubs(:repository_url).with().returns('repo_url')
+      @strategy.stubs(:configuration).with().returns(:repository => 'repo_url')
+      
+      @strategy.repository_url_changed?.should be(false)
+    end
+    
+    should "know that the repository URL has changed" do
+      @strategy.stubs(:repository_url).with().returns('new_repo_url')
+      @strategy.stubs(:configuration).with().returns(:repository => 'old_repo_url')
+      
+      @strategy.repository_url_changed?.should be(true)
+    end
+    
+    should "be able to remove the local cache" do
+      @strategy.stubs(:logger).with().returns(stub(:trace))
+      @strategy.stubs(:local_cache_path).with().returns('local_cache_path')
+      FileUtils.expects(:rm_rf).with('local_cache_path')
+      
+      @strategy.remove_local_cache
+    end
+    
+    should "remove the local cache if the repository URL has changed" do
+      @strategy.stubs(:repository_url_changed?).with().returns(true)
+      @strategy.expects(:remove_local_cache).with()
+      
+      @strategy.remove_cache_if_repository_url_changed
+    end
+    
+    should "not remove the local cache if the repository URL has not changed" do
+      @strategy.stubs(:repository_url_changed?).with().returns(false)
+      @strategy.expects(:remove_local_cache).with().never
+      
+      @strategy.remove_cache_if_repository_url_changed
+    end
+    
+    should "know the default SSH port" do
+      @strategy.stubs(:ssh_options).with().returns({})
+      server = stub(:port => nil)
+      @strategy.ssh_port(server).should == 22
+    end
+    
+    should "be able to override the default SSH port" do
+      @strategy.stubs(:ssh_options).with().returns({:port => 95})
+      server = stub(:port => nil)
+      @strategy.ssh_port(server).should == 95
+    end
+
+    should "be able to override the default SSH port for each server" do
+      @strategy.stubs(:ssh_options).with().returns({:port => 95})
+      server = stub(:port => 123)
+      @strategy.ssh_port(server).should == 123
+    end
+
+    should "know the default repository cache" do
+      @strategy.repository_cache.should == 'cached-copy'
+    end
+    
+    should "be able to override the default repository cache" do
+      @strategy.stubs(:configuration).with().returns(:repository_cache => 'other_cache')
+      @strategy.repository_cache.should == 'other_cache'
+    end
+    
+    should "know the repository cache path" do
+      @strategy.stubs(:shared_path).with().returns('shared_path')
+      @strategy.stubs(:repository_cache).with().returns('cache_path')
+      
+      File.expects(:join).with('shared_path', 'cache_path').returns('path')
+      @strategy.repository_cache_path.should == 'path'
+    end
+    
+    should "be able to determine the hostname for the rsync command" do
+      server = stub(:host => 'host.com')
+      @strategy.rsync_host(server).should == 'host.com'
+    end
+    
+    should "be able to determine the hostname for the rsync command when a user is configured" do
+      @strategy.stubs(:configuration).with().returns(:user => 'foobar')
+      server = stub(:host => 'host.com')
+      
+      @strategy.rsync_host(server).should == 'foobar@host.com'
+    end
+    
+    should "know that the local cache exists" do
+      @strategy.stubs(:local_cache_path).with().returns('path')
+      File.stubs(:exist?).with('path').returns(true)
+      
+      @strategy.local_cache_exists?.should be(true)
+    end
+    
+    should "know that the local cache does not exist" do
+      @strategy.stubs(:local_cache_path).with().returns('path')
+      File.stubs(:exist?).with('path').returns(false)
+      
+      @strategy.local_cache_exists?.should be(false)
+    end
+    
+    should "know that the local cache is not valid if it does not exist" do
+      @strategy.stubs(:local_cache_exists?).with().returns(false)
+      @strategy.local_cache_valid?.should be(false)
+    end
+    
+    should "know that the local cache is not valid if it's not a directory" do
+      @strategy.stubs(:local_cache_path).with().returns('path')
+      @strategy.stubs(:local_cache_exists?).with().returns(true)
+      
+      File.stubs(:directory?).with('path').returns(false)
+      @strategy.local_cache_valid?.should be(false)
+    end
+    
+    should "know that the local cache is valid" do
+      @strategy.stubs(:local_cache_path).with().returns('path')
+      @strategy.stubs(:local_cache_exists?).with().returns(true)
+      
+      File.stubs(:directory?).with('path').returns(true)
+      @strategy.local_cache_valid?.should be(true)
+    end
+    
+    should "know the SCM command when the local cache is valid" do
+      source = mock() {|s| s.expects(:sync).with('revision', 'path').returns('scm_command') }
+      
+      @strategy.stubs(:local_cache_valid?).with().returns(true)
+      @strategy.stubs(:local_cache_path).with().returns('path')
+      @strategy.stubs(:revision).with().returns('revision')
+      @strategy.stubs(:source).with().returns(source)
+      
+      @strategy.send(:command).should == 'scm_command'
+    end
+    
+    should "know the SCM command when the local cache does not exist" do
+      source = mock() {|s| s.expects(:checkout).with('revision', 'path').returns('scm_command') }
+      
+      @strategy.stubs(:local_cache_valid?).with().returns(false)
+      @strategy.stubs(:local_cache_exists?).with().returns(false)
+      @strategy.stubs(:local_cache_path).with().returns('path')
+      @strategy.stubs(:revision).with().returns('revision')
+      @strategy.stubs(:source).with().returns(source)
+      
+      @strategy.send(:command).should == 'mkdir -p path && scm_command'
+    end
+    
+    should "raise an exception when the local cache is invalid" do
+      @strategy.stubs(:local_cache_valid?).with().returns(false)
+      @strategy.stubs(:local_cache_exists?).with().returns(true)
+  
+      lambda {
+        @strategy.send(:command) 
+      }.should raise_error(Capistrano::Deploy::Strategy::RsyncWithRemoteCache::InvalidCacheError)
+    end
+    
+    should "be able to tag the local cache" do
+      local_cache_path = Dir.tmpdir
+      @strategy.stubs(:revision).with().returns('1')
+      @strategy.stubs(:local_cache_path).with().returns(local_cache_path)
+      
+      @strategy.mark_local_cache
+      
+      File.read(File.join(local_cache_path, 'REVISION')).should == '1'
+    end
+    
+    should "be able to update the local cache" do
+      @strategy.stubs(:command).with().returns('scm_command')
+      @strategy.expects(:system).with('scm_command').returns true
+      @strategy.expects(:mark_local_cache).with()
+      
+      @strategy.update_local_cache
+    end
+    
+    [nil, false].each do |value|
+      should "raise an error when system returns nil" do
+        @strategy.stubs(:command).returns('failing_command')
+        @strategy.stubs(:system).with("failing_command").returns value
+        @strategy.stubs(:mark_local_cache).returns nil
+        lambda {
+          @strategy.update_local_cache
+        }.should raise_error
+      end
+    end
+    
+    should "be able to run the rsync command on a server" do
+      server = stub()
+      
+      @strategy.stubs(:rsync_host).with(server).returns('rsync_host')
+      
+      @strategy.stubs(
+        :rsync_options         => 'rsync_options', 
+        :ssh_port              => 'ssh_port',
+        :local_cache_path      => 'local_cache_path',
+        :repository_cache_path => 'repository_cache_path'
+      )
+      
+      expected = "rsync rsync_options --rsh='ssh -p ssh_port' local_cache_path/ rsync_host:repository_cache_path/"
+      
+      @strategy.rsync_command_for(server).should == expected
+    end
+    
+    should "be able to update the remote cache" do
+      server_1, server_2 = [stub(), stub()]
+      @strategy.stubs(:find_servers).with(:except => {:no_release => true}).returns([server_1, server_2])
+      
+      @strategy.stubs(:rsync_command_for).with(server_1).returns('server_1_rsync_command')
+      @strategy.stubs(:rsync_command_for).with(server_2).returns('server_2_rsync_command')
+      
+      @strategy.expects(:system).with('server_1_rsync_command')
+      @strategy.expects(:system).with('server_2_rsync_command')
+      
+      @strategy.update_remote_cache
+    end
+    
+    should "be able copy the remote cache into place" do
+      @strategy.stubs(
+        :repository_cache_path => 'repository_cache_path',
+        :configuration         => {:release_path => 'release_path'}
+      )
+      
+      command = "rsync -a --delete repository_cache_path/ release_path/"
+      @strategy.expects(:run).with(command)
+      
+      @strategy.copy_remote_cache
+    end
+    
+    should "be able to deploy" do
+      @strategy.expects(:update_local_cache).with()
+      @strategy.expects(:update_remote_cache).with()
+      @strategy.expects(:copy_remote_cache).with()
+      
+      @strategy.deploy!
+    end
+    
+  end
+  
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: dynport-capistrano_rsync_with_remote_cache
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 2.4.1
+platform: ruby
+authors: 
+- Patrick Reagan
+- Mark Cornick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-15 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: capistrano
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.0
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: patrick.reagan@viget.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- lib/capistrano/recipes/deploy/strategy/rsync_with_remote_cache.rb
+- test/capistrano_rsync_with_remote_cache_test.rb
+homepage: http://www.viget.com/extend/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: A deployment strategy for Capistrano 2.0 which combines rsync with a remote cache, allowing fast deployments from SCM servers behind firewalls.
+test_files: []
+