capistrano_rsync_with_remote_cache 2.2

data/README

@@ -0,0 +1,36 @@
+= 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 and higher. Git support requires Capistrano 2.1.0 or higher.
+
+This gem has only been tested with Subversion and Git. It is unlikely to be supported for other SCM systems unless we adopt them at Viget Labs, or get outside help.
+
+This gem requires and <tt>rsync</tt> command line utilities on the local and remote hosts. It also requires either <tt>svn</tt> or <tt>git</tt> on the local host, but not the remote host.
+
+This gem is tested primarily on Mac OS X and Linux. It may work with a Windows local host, but is not tested or supported. Like Capistrano itself, it will not work with a Windows remote host.
+
+== Gem preliminaries
+
+To create the gem, run <tt>gem build capistrano_rsync_with_remote_cache.gemspec</tt> in this directory.
+
+To use this deployment strategy, add this line to your configuration:
+
+<tt>set :deploy_via, :rsync_with_remote_cache</tt>
+
+== 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 <tt>local_cache</tt> 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 <tt>repository_cache</tt> 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. If it does not exist, it is created with a checkout of the revision to be deployed. If it exists, it is updated to 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.
+
+Copyright (c) 2007, 2008 Mark Cornick of Viget Labs, released under the MIT license

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

@@ -0,0 +1,94 @@
+require 'capistrano/recipes/deploy/strategy/remote'
+
+module Capistrano
+  module Deploy
+    module Strategy
+      class RsyncWithRemoteCache < Remote
+
+        # The deployment method itself, in three major steps.
+        def deploy!
+
+          # Step 1: Update the local cache.
+          system(command)
+          File.open(File.join(local_cache, "REVISION"), "w") { |f| f.puts(revision) }
+
+          # Step 2: Update the remote cache.
+          logger.trace "copying local cache to remote"
+          find_servers(:roles => :app, :except => { :no_release => true }).each do |server|
+            system("rsync #{rsync_options} #{local_cache}/ #{rsync_host(server)}:#{repository_cache}/")
+          end
+
+          # Step 3: Copy the remote cache into place.
+          run("rsync -a --delete #{repository_cache}/ #{configuration[:release_path]}/ && #{mark}")
+        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 |d|
+            d.local.command(source.command)
+            d.local.command('rsync')
+            d.remote.command('rsync')
+          end
+        end
+
+        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.
+        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.
+        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.
+        def rsync_options
+          configuration[:rsync_options] || "-az --delete"
+        end
+
+        # Returns the host used in the rsync command, prefixed with user@ if user is specified in Capfile.
+        def rsync_host(server)
+          if configuration[:user]
+            "#{configuration[:user]}@#{server.host}"
+          else
+            server.host
+          end
+        end
+        
+        # Command to get source from SCM on the local side. If the local_cache directory exists,
+        # we check to see if it's an SCM checkout that matches the currently configured repository.
+        # If it matches, we update it. If it doesn't match (either it's for another repository or
+        # not a checkout at all), we remove the directory and recreate it with a fresh SCM checkout.
+        # If the directory doesn't exist, we create it with a fresh SCM checkout.
+        #
+        # FIXME: The above logic only takes place if the SCM is Subversion. At some point, similar logic
+        # will probably be necessary for Git and other SCMs we might use.
+        #
+        # TODO: punt in some sensible way if local_cache exists but is a regular file.
+        def command
+          if (configuration[:scm] == :subversion &&
+              `svn info #{local_cache} | sed -n 's/URL: //p'`.strip != configuration[:repository])
+            logger.trace "repository has changed; removing old local cache"
+            system("rm -rf #{local_cache}")
+          end
+          if File.exists?(local_cache) && File.directory?(local_cache)
+            logger.trace "updating local cache to revision #{revision}"
+            cmd = source.sync(revision, local_cache)
+          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))
+            cmd = source.checkout(revision, local_cache)
+          end
+          cmd
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: capistrano_rsync_with_remote_cache
+version: !ruby/object:Gem::Version 
+  version: "2.2"
+platform: ruby
+authors: 
+- Mark Cornick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-26 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: capistrano
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+    version: 
+description: 
+email: mark@viget.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/capistrano/recipes/deploy/strategy/rsync_with_remote_cache.rb
+- README
+has_rdoc: true
+homepage: http://github.com/vigetlabs/capistrano_rsync_with_remote_cache
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+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: []
+