capistrano_rsync_with_remote_cache 2.3.7 → 2.3.8

data/README.rdoc

@@ -0,0 +1,90 @@
+= 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.
+
+== 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

@@ -1,86 +1,30 @@
 require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "capistrano_rsync_with_remote_cache"
-    gem.summary = "rsync_with_remote_cache strategy for Capistrano"
-    gem.description = 'A deployment strategy for Capistrano 2.0 which combines rsync with a remote cache, allowing fast deployments from SCM servers behind firewalls.'
-    gem.email = "mark@viget.com"
-    gem.homepage = "http://github.com/vigetlabs/capistrano_rsync_with_remote_cache"
-    gem.authors = ["Mark Cornick"]
-    gem.rubyforge_project = "viget"
-    gem.add_dependency 'capistrano', '>= 2.0'
-    gem.add_development_dependency "thoughtbot-shoulda"
-    gem.add_development_dependency "yard"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-  Jeweler::RubyforgeTasks.new do |rubyforge|
-    rubyforge.doc_task = "yardoc"
-  end
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
-
+require 'rake/gempackagetask'
 require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/*_test.rb'
-  test.verbose = true
-end
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/*_test.rb'
-    test.verbose = true
-    test.rcov_opts << '-x gems'
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install relevance-rcov"
-  end
+spec = Gem::Specification.new do |s|
+  s.name             = 'capistrano_rsync_with_remote_cache'
+  s.version          = '2.3.8'
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w(README.rdoc)
+  s.rdoc_options     = %w(--main README.rdoc)
+  s.summary          = "A deployment strategy for Capistrano 2.0 which combines rsync with a remote cache, allowing fast deployments from SCM servers behind firewalls."
+  s.authors          = ['Patrick Reagan', 'Mark Cornick']
+  s.email            = 'patrick.reagan@viget.com'
+  s.homepage         = 'http://www.viget.com/extend/'
+  s.files            = %w(README.rdoc Rakefile) + Dir.glob("{lib,test}/**/*")
+  
+  s.add_dependency('capistrano', '>=2.1.0')
 end
 
-task :test => :check_dependencies
-
-begin
-  require 'reek/rake_task'
-  Reek::RakeTask.new do |t|
-    t.fail_on_error = true
-    t.verbose = false
-    t.source_files = 'lib/**/*.rb'
-  end
-rescue LoadError
-  task :reek do
-    abort "Reek is not available. In order to run reek, you must: sudo gem install reek"
-  end
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
 end
 
-begin
-  require 'roodi'
-  require 'roodi_task'
-  RoodiTask.new do |t|
-    t.verbose = false
-  end
-rescue LoadError
-  task :roodi do
-    abort "Roodi is not available. In order to run roodi, you must: sudo gem install roodi"
-  end
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
 end
 
-task :default => :test
-
-begin
-  require 'yard'
-  YARD::Rake::YardocTask.new do |t|
-    t.options = ['--private']
-  end
-rescue LoadError
-  task :yardoc do
-    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
-  end
-end
+task :default => :test

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

@@ -5,6 +5,12 @@ 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\'",
@@ -12,23 +18,78 @@ module Capistrano
           :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'
 
-        # The deployment method itself, in three major steps: update the local cache, update the remote
-        # cache, and copy the remote cache into place.
         def deploy!
-
-          # Step 1: Update the local cache.
+          update_local_cache
+          update_remote_cache
+          copy_remote_cache
+        end
+        
+        def update_local_cache
           system(command)
-          File.open(File.join(local_cache, "REVISION"), "w") { |file| file.puts(revision) }
-
-          # Step 2: Update the remote cache.
-          logger.trace "copying local cache to remote"
-          find_servers(:except => { :no_release => true }).each do |server|
-            system("rsync #{rsync_options} --rsh='ssh -p #{ssh_port}' #{local_cache}/ #{rsync_host(server)}:#{repository_cache}/")
-          end
+          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}' #{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
+          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
 
-          # Step 3: Copy the remote cache into place.
-          run("rsync -a --delete #{repository_cache}/ #{configuration[:release_path]}/ && #{mark}")
+        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
@@ -44,75 +105,17 @@ module Capistrano
 
         private
 
-        # Path to the remote cache. We use a variable name and default that are compatible with
-        # the stock remote_cache strategy, for easy migration.
-        # @return [String] the path to the remote cache
-        def repository_cache
-          File.join(shared_path, configuration[:repository_cache] || "cached-copy")
-        end
-
-        # Path to the local cache. If not specified in the Capfile, we use an arbitrary default.
-        # @return [String] the path to the local cache
-        def local_cache
-          configuration[:local_cache] || ".rsync_cache"
-        end
-
-        # Options to use for rsync in step 2. If not specified in the Capfile, we use the default
-        # from prior versions.
-        # @return [String] the options to be passed to rsync
-        def rsync_options
-          configuration[:rsync_options] || "-az --delete"
-        end
-
-        # Port to use for rsync in step 2. If not specified with (ssh_options) in the Capfile, we
-        # use the default well-known port 22.
-        # @return [Fixnum] the port to connect to with rsync
-        def ssh_port
-          ssh_options[:port] || 22
-        end
-
-        # Get a hostname to be used in the rsync command.
-        # @param [Capistrano::ServerDefinition, #host] the host which rsync will connect to
-        # @return [String] the hostname, prefixed with user@ if necessary
-        def rsync_host(server)
-          if configuration[:user]
-            "#{configuration[:user]}@#{server.host}"
-          else
-            server.host
-          end
-        end
-
-        # Remove the local cache (so it can be recreated) if the repository URL has changed
-        # since the last deployment.
-        # TODO: punt in some sensible way if local_cache exists but is a regular file.
-        def remove_cache_if_repo_changed
-          if INFO_COMMANDS[configuration[:scm]] && File.directory?(local_cache)
-            info_command = "cd #{File.expand_path(local_cache)} && #{INFO_COMMANDS[configuration[:scm]]}"
-            cached_repo_url = IO.popen(info_command){|pipe| pipe.readline}.chomp
-            if cached_repo_url != configuration[:repository]
-              logger.trace "repository has changed; removing old local cache"
-              FileUtils.rm_rf(local_cache)
-            end
-          end
-        end
-
-        # Command to get source from SCM on the local side. The local cache is either created,
-        # updated, or destroyed and recreated depending on whether it exists and is a cache of
-        # the right repository.
-        # @return [String] command to either checkout or update the local cache
         def command
-          remove_cache_if_repo_changed
-          if File.exists?(local_cache) && File.directory?(local_cache)
-            logger.trace "updating local cache to revision #{revision}"
-            return source.sync(revision, local_cache)
+          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
-            logger.trace "creating local cache with revision #{revision}"
-            File.delete(local_cache) if File.exists?(local_cache)
-            Dir.mkdir(File.dirname(local_cache)) unless File.directory?(File.dirname(local_cache))
-            return source.checkout(revision, local_cache)
+            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

@@ -1,174 +1,280 @@
-# This test suite was written way after the code, back when the author didn't do TDD consistently.
-# Also, the code does a lot of things with external servers and services, so there's a lot of mocking.
-# Therefore, this suite is nearly impossible to follow in places. Sorry.
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+require 'shoulda'
+require 'matchy'
+require 'tmpdir'
 
-require 'test_helper'
+require 'capistrano/recipes/deploy/strategy/rsync_with_remote_cache'
 
 class CapistranoRsyncWithRemoteCacheTest < Test::Unit::TestCase
-  def stub_configuration(hash)
-    @rwrc.expects(:configuration).at_least_once.returns(hash)
-  end
-
-  def stub_ssh_options(hash)
-    @rwrc.expects(:ssh_options).at_least_once.returns(hash)
-  end
+  
+  context "An instance of the CapistranoRsyncWithRemoteCache class" do
+    setup { @strategy = Capistrano::Deploy::Strategy::RsyncWithRemoteCache.new }
 
-  context 'RsyncWithRemoteCache' do
-    setup do
-      @rwrc = Capistrano::Deploy::Strategy::RsyncWithRemoteCache.new
-      logger_stub = stub()
-      logger_stub.stubs(:trace)
-      @rwrc.stubs(:logger).returns(logger_stub)
+    should "know the default rsync options" do
+      @strategy.rsync_options.should == '-az --delete'
     end
-
-    should 'deploy!' do
-      stub_configuration(:deploy_to => 'deploy_to', :release_path => 'release_path', :scm => :subversion)
-      stub_ssh_options(:port => nil)
-      @rwrc.stubs(:shared_path).returns('shared')
-
-      # Step 1: Update the local cache.
-      @rwrc.expects(:command).returns('command')
-      @rwrc.expects(:system).with('command')
-      revision_file_stub = stub()
-      revision_file_stub.expects(:puts)
-      File.expects(:open).with(File.join('.rsync_cache', 'REVISION'), 'w').yields(revision_file_stub)
-
-      # Step 2: Update the remote cache.
-      server_stub = stub(:host => 'host')
-      @rwrc.expects(:system).with("rsync -az --delete --rsh='ssh -p 22' .rsync_cache/ host:shared/cached-copy/")
-      @rwrc.expects(:find_servers).returns([server_stub])
-
-      # Step 3: Copy the remote cache into place.
-      @rwrc.expects(:mark).returns('mark')
-      @rwrc.expects(:run).with("rsync -a --delete shared/cached-copy/ release_path/ && mark")
-
-      @rwrc.deploy!
+    
+    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 'check!' do
-      configuration = {:releases_path => 'releases_path', :deploy_to => 'deploy_to'}
-      configuration.stubs(:invoke_command)
-      @rwrc.expects(:configuration).at_least_once.returns(configuration)
-
-      source_stub = stub(:command => 'command')
-      @rwrc.stubs(:source).returns(source_stub)
-
-      @rwrc.check!
+    should "know the default local cache name" do
+      @strategy.local_cache.should == '.rsync_cache'
     end
-
-    context 'repository_cache' do
-      setup do
-        @rwrc.expects(:shared_path).returns('shared')
-      end
-
-      should 'return specified cache if present in configuration' do
-        stub_configuration(:repository_cache => 'cache')
-        assert_equal 'shared/cache', @rwrc.send(:repository_cache)
-      end
-
-      should 'return default cache if not present in configuration' do
-        stub_configuration(:repository_cache => nil)
-        assert_equal 'shared/cached-copy', @rwrc.send(:repository_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
-
-    context 'local_cache' do
-      should 'return specified cache if present in configuration' do
-        stub_configuration(:local_cache => 'cache')
-        assert_equal 'cache', @rwrc.send(:local_cache)
-      end
-
-      should 'return default cache if not present in configuration' do
-        stub_configuration(:local_cache => nil)
-        assert_equal '.rsync_cache', @rwrc.send(:local_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
-
-    context 'rsync_options' do
-      should 'return specified options if present in configuration' do
-        stub_configuration(:rsync_options => 'options')
-        assert_equal 'options', @rwrc.send(:rsync_options)
-      end
-
-      should 'return default options if not present in configuration' do
-        stub_configuration(:rsync_options => nil)
-        assert_equal '-az --delete', @rwrc.send(:rsync_options)
-      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
-
-    context 'ssh_port' do
-      should 'return specified port if present in configuration' do
-        stub_ssh_options(:port => 2222)
-        assert_equal 2222, @rwrc.send(:ssh_port)
-      end
-
-      should 'return default port if not present in configuration' do
-        stub_ssh_options(:port => nil)
-        assert_equal 22, @rwrc.send(:ssh_port)
-      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
-
-    context 'rsync_host' do
-      setup do
-        @server_stub = stub(:host => 'host')
-      end
-
-      should 'prefix user if present in configuration' do
-        stub_configuration(:user => 'user')
-        assert_equal 'user@host', @rwrc.send(:rsync_host, @server_stub)
-      end
-
-      should 'not prefix user if not present in configuration' do
-        stub_configuration(:user => nil)
-        assert_equal 'host', @rwrc.send(:rsync_host, @server_stub)
-      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
-
-    context 'remove_cache_if_repo_changed' do
-      [:subversion, :git, :mercurial, :bzr].each do |scm|
-        should "purge local cache if it detects #{scm} info has changed" do
-          stub_configuration(:scm => scm, :repository => 'repository')
-          info_command = Capistrano::Deploy::Strategy::RsyncWithRemoteCache::INFO_COMMANDS[scm]
-          File.expects(:directory?).with('.rsync_cache').returns(true)
-          IO.expects(:popen).with("cd .rsync_cache && #{info_command}").returns('abc')
-          FileUtils.expects(:rm_rf).with('.rsync_cache')
-          @rwrc.send(:remove_cache_if_repo_changed)
-        end
-      end
-
-      should 'not attempt to purge local cache if it does not exist' do
-        stub_configuration(:scm => :subversion, :repository => 'repository')
-        File.expects(:directory?).with('.rsync_cache').returns(false)
-        FileUtils.expects(:rm_rf).with('.rsync_cache').never
-        @rwrc.send(:remove_cache_if_repo_changed)
-      end
-
-      should 'not attempt to purge local cache if the scm is not supported by this gem' do
-        stub_configuration(:scm => :cvs, :repository => 'repository')
-        FileUtils.expects(:rm_rf).with('.rsync_cache').never
-        @rwrc.send(:remove_cache_if_repo_changed)
-      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({})
+      @strategy.ssh_port.should == 22
+    end
+    
+    should "be able to override the default SSH port" do
+      @strategy.stubs(:ssh_options).with().returns({:port => 95})
+      @strategy.ssh_port.should == 95
     end
 
-    context 'command' do
-      should 'update local cache if it exists' do
-        File.expects(:exists?).with('.rsync_cache').returns(true)
-        File.expects(:directory?).with('.rsync_cache').returns(true)
-        source_stub = stub()
-        source_stub.expects(:sync)
-        @rwrc.expects(:source).returns(source_stub)
-        @rwrc.send(:command)
-      end
-
-      should 'create local cache if it does not exist' do
-        File.expects(:exists?).with('.rsync_cache').times(2).returns(false)
-        File.expects(:directory?).with(File.dirname('.rsync_cache')).returns(false)
-        Dir.expects(:mkdir).with(File.dirname('.rsync_cache'))
-        source_stub = stub()
-        source_stub.expects(:checkout)
-        @rwrc.expects(:source).returns(source_stub)
-        @rwrc.send(:command)
-      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')
+      @strategy.expects(:mark_local_cache).with()
+      
+      @strategy.update_local_cache
+    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

@@ -5,16 +5,17 @@ version: !ruby/object:Gem::Version
   segments: 
   - 2
   - 3
-  - 7
-  version: 2.3.7
+  - 8
+  version: 2.3.8
 platform: ruby
 authors: 
+- Patrick Reagan
 - Mark Cornick
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-03-12 00:00:00 -05:00
+date: 2010-04-08 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,62 +27,32 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 2
+        - 1
         - 0
-        version: "2.0"
+        version: 2.1.0
   type: :runtime
   version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: thoughtbot-shoulda
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: yard
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id003
-description: A deployment strategy for Capistrano 2.0 which combines rsync with a remote cache, allowing fast deployments from SCM servers behind firewalls.
-email: mark@viget.com
+description: 
+email: patrick.reagan@viget.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-- LICENSE
-- README.md
+- README.rdoc
 files: 
-- .document
-- .gitignore
-- LICENSE
-- README.md
+- README.rdoc
 - Rakefile
-- VERSION
-- capistrano_rsync_with_remote_cache.gemspec
-- lib/capistrano/recipes/deploy/strategy/exceptions.reek
 - lib/capistrano/recipes/deploy/strategy/rsync_with_remote_cache.rb
 - test/capistrano_rsync_with_remote_cache_test.rb
-- test/test_helper.rb
 has_rdoc: true
-homepage: http://github.com/vigetlabs/capistrano_rsync_with_remote_cache
+homepage: http://www.viget.com/extend/
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-- --charset=UTF-8
+- --main
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -100,11 +71,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: "0"
 requirements: []
 
-rubyforge_project: viget
+rubyforge_project: 
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: rsync_with_remote_cache strategy for Capistrano
-test_files: 
-- test/capistrano_rsync_with_remote_cache_test.rb
-- test/test_helper.rb
+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: []
+

data/.document

@@ -1,5 +0,0 @@
-README.md
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE

data/.gitignore

@@ -1,5 +0,0 @@
-/pkg/
-/doc/
-/coverage/
-*.gem
-.yardoc

data/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2007, 2008 Mark Cornick of Viget Labs (http://www.viget.com/)
-
-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

@@ -1,36 +0,0 @@
-# Capistrano rsync_with_remote_cache
-
-This gem provides a deployment strategy for Capistrano which combines `rsync` with a remote cache, allowing fast deployments from Subversion repositories behind firewalls.
-
-## Requirements
-
-This gem requires Capistrano 2.0.0 or higher. Git support requires Capistrano 2.1.0 or higher.
-
-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 `rsync` command line utilities on the local and remote hosts. It also requires either `svn`, `git`, `hg` or `bzr` on the local host, but not the remote host.
-
-This gem is tested on Mac OS X and Linux. Windows is not tested or supported.
-
-## Using the strategy
-
-To use this deployment strategy, add this line to your `deploy.rb` file:
-
-    set :deploy_via, :rsync_with_remote_cache
-
-## How it works
-
-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 `local_cache` variable in the configuration. If not specified, it will default to `.rsync_cache` in the same directory as the Capfile.
-* The remote cache directory is an `rsync` copy of the local cache directory. The remote cache directory is specified with the `repository_cache` variable in the configuration (this name comes from the `remote_cache` strategy that ships with Capistrano, and has been maintained for compatibility.) If not specified, it will default to `shared/cached-copy` (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 `:repository` variable, it is updated to the revision to be deployed.
-* If the local cache exists and does not match the `:repository` variable, the local cache is purged and recreated with a checkout of the revision to be deployed.
-
-Second, `rsync` runs on the local side to sync the remote cache to the local cache. When the `rsync` 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.

data/VERSION

@@ -1 +0,0 @@
-2.3.7

data/capistrano_rsync_with_remote_cache.gemspec

@@ -1,62 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{capistrano_rsync_with_remote_cache}
-  s.version = "2.3.7"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Mark Cornick"]
-  s.date = %q{2010-03-12}
-  s.description = %q{A deployment strategy for Capistrano 2.0 which combines rsync with a remote cache, allowing fast deployments from SCM servers behind firewalls.}
-  s.email = %q{mark@viget.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.md"
-  ]
-  s.files = [
-    ".document",
-     ".gitignore",
-     "LICENSE",
-     "README.md",
-     "Rakefile",
-     "VERSION",
-     "capistrano_rsync_with_remote_cache.gemspec",
-     "lib/capistrano/recipes/deploy/strategy/exceptions.reek",
-     "lib/capistrano/recipes/deploy/strategy/rsync_with_remote_cache.rb",
-     "test/capistrano_rsync_with_remote_cache_test.rb",
-     "test/test_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/vigetlabs/capistrano_rsync_with_remote_cache}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{viget}
-  s.rubygems_version = %q{1.3.6}
-  s.summary = %q{rsync_with_remote_cache strategy for Capistrano}
-  s.test_files = [
-    "test/capistrano_rsync_with_remote_cache_test.rb",
-     "test/test_helper.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<capistrano>, [">= 2.0"])
-      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-      s.add_development_dependency(%q<yard>, [">= 0"])
-    else
-      s.add_dependency(%q<capistrano>, [">= 2.0"])
-      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-      s.add_dependency(%q<yard>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<capistrano>, [">= 2.0"])
-    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-    s.add_dependency(%q<yard>, [">= 0"])
-  end
-end
-

data/lib/capistrano/recipes/deploy/strategy/exceptions.reek

@@ -1,15 +0,0 @@
----
-Duplication:
-  exclude:
-  - check!
-  - command
-  - deploy!
-  - rsync_host
-  - remove_cache_if_repo_changed
-
-FeatureEnvy:
-  exclude:
-  - check!
-
-LongMethod: 
-  max_statements: 10

data/test/test_helper.rb

@@ -1,11 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'mocha'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'capistrano/recipes/deploy/strategy/rsync_with_remote_cache'
-
-class Test::Unit::TestCase
-end