le1t0-capistrano 2.5.18.001

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

@@ -0,0 +1,79 @@
+require 'capistrano/recipes/deploy/dependencies'
+
+module Capistrano
+  module Deploy
+    module Strategy
+
+      # This class defines the abstract interface for all Capistrano
+      # deployment strategies. Subclasses must implement at least the
+      # #deploy! method.
+      class Base
+        attr_reader :configuration
+
+        # Instantiates a strategy with a reference to the given configuration.
+        def initialize(config={})
+          @configuration = config
+        end
+
+        # Executes the necessary commands to deploy the revision of the source
+        # code identified by the +revision+ variable. Additionally, this
+        # should write the value of the +revision+ variable to a file called
+        # REVISION, in the base of the deployed revision. This file is used by
+        # other tasks, to perform diffs and such.
+        def deploy!
+          raise NotImplementedError, "`deploy!' is not implemented by #{self.class.name}"
+        end
+
+        # Performs a check on the remote hosts to determine whether everything
+        # is setup such that a deploy could succeed.
+        def check!
+          Dependencies.new(configuration) do |d|
+            d.remote.directory(configuration[:releases_path]).or("`#{configuration[:releases_path]}' does not exist. Please run `cap deploy:setup'.")
+            d.remote.writable(configuration[:deploy_to]).or("You do not have permissions to write to `#{configuration[:deploy_to]}'.")
+            d.remote.writable(configuration[:releases_path]).or("You do not have permissions to write to `#{configuration[:releases_path]}'.")
+          end
+        end
+          
+        protected
+
+          # This is to allow helper methods like "run" and "put" to be more
+          # easily accessible to strategy implementations.
+          def method_missing(sym, *args, &block)
+            if configuration.respond_to?(sym)
+              configuration.send(sym, *args, &block)
+            else
+              super
+            end
+          end
+
+          # A wrapper for Kernel#system that logs the command being executed.
+          def system(*args)
+            cmd = args.join(' ')
+            if RUBY_PLATFORM =~ /win32/
+							cmd = cmd.split(/\s+/).collect {|w| w.match(/^[\w+]+:\/\//) ? w : w.gsub('/', '\\') }.join(' ') # Split command by spaces, change / by \\ unless element is a some+thing:// 
+              cmd.gsub!(/^cd /,'cd /D ') # Replace cd with cd /D
+              cmd.gsub!(/&& cd /,'&& cd /D ') # Replace cd with cd /D
+              logger.trace "executing locally: #{cmd}"
+              super(cmd)
+            else
+              logger.trace "executing locally: #{cmd}"
+              super
+            end
+          end
+
+        private
+
+          def logger
+            @logger ||= configuration[:logger] || Capistrano::Logger.new(:output => STDOUT)
+          end
+
+          # The revision to deploy. Must return a real revision identifier,
+          # and not a pseudo-id.
+          def revision
+            configuration[:real_revision]
+          end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'capistrano/recipes/deploy/strategy/remote'
+
+module Capistrano
+  module Deploy
+    module Strategy
+
+      # Implements the deployment strategy which does an SCM checkout on each
+      # target host. This is the default deployment strategy for Capistrano.
+      class Checkout < Remote
+        protected
+
+          # Returns the SCM's checkout command for the revision to deploy.
+          def command
+            @command ||= source.checkout(revision, configuration[:release_path])
+          end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,218 @@
+require 'capistrano/recipes/deploy/strategy/base'
+require 'fileutils'
+require 'tempfile'  # Dir.tmpdir
+
+module Capistrano
+  module Deploy
+    module Strategy
+
+      # This class implements the strategy for deployments which work
+      # by preparing the source code locally, compressing it, copying the
+      # file to each target host, and uncompressing it to the deployment
+      # directory.
+      #
+      # By default, the SCM checkout command is used to obtain the local copy
+      # of the source code. If you would rather use the export operation,
+      # you can set the :copy_strategy variable to :export.
+      #
+      #   set :copy_strategy, :export
+      #
+      # For even faster deployments, you can set the :copy_cache variable to
+      # true. This will cause deployments to do a new checkout of your
+      # repository to a new directory, and then copy that checkout. Subsequent
+      # deploys will just resync that copy, rather than doing an entirely new
+      # checkout. Additionally, you can specify file patterns to exclude from
+      # the copy when using :copy_cache; just set the :copy_exclude variable
+      # to a file glob (or an array of globs).
+      #
+      #   set :copy_cache, true
+      #   set :copy_exclude, ".git/*"
+      #
+      # Note that :copy_strategy is ignored when :copy_cache is set. Also, if
+      # you want the copy cache put somewhere specific, you can set the variable
+      # to the path you want, instead of merely 'true':
+      #
+      #   set :copy_cache, "/tmp/caches/myapp"
+      #
+      # This deployment strategy also supports a special variable,
+      # :copy_compression, which must be one of :gzip, :bz2, or
+      # :zip, and which specifies how the source should be compressed for
+      # transmission to each host.
+      class Copy < Base
+        # Obtains a copy of the source code locally (via the #command method),
+        # compresses it to a single file, copies that file to all target
+        # servers, and uncompresses it on each of them into the deployment
+        # directory.
+        def deploy!
+          if copy_cache
+            if File.exists?(copy_cache)
+              logger.debug "refreshing local cache to revision #{revision} at #{copy_cache}"
+              system(source.sync(revision, copy_cache))
+            else
+              logger.debug "preparing local cache at #{copy_cache}"
+              system(source.checkout(revision, copy_cache))
+            end
+
+            # Check the return code of last system command and rollback if not 0
+            unless $? == 0
+              raise Capistrano::Error, "shell command failed with return code #{$?}"
+            end
+
+            logger.debug "copying cache to deployment staging area #{destination}"
+            Dir.chdir(copy_cache) do
+              FileUtils.mkdir_p(destination)
+              queue = Dir.glob("*", File::FNM_DOTMATCH)
+              while queue.any?
+                item = queue.shift
+                name = File.basename(item)
+
+                next if name == "." || name == ".."
+                next if copy_exclude.any? { |pattern| File.fnmatch(pattern, item) }
+
+                if File.symlink?(item)
+                  FileUtils.ln_s(File.readlink(File.join(copy_cache, item)), File.join(destination, item))
+                elsif File.directory?(item)
+                  queue += Dir.glob("#{item}/*", File::FNM_DOTMATCH)
+                  FileUtils.mkdir(File.join(destination, item))
+                else
+                  FileUtils.ln(File.join(copy_cache, item), File.join(destination, item))
+                end
+              end
+            end
+          else
+            logger.debug "getting (via #{copy_strategy}) revision #{revision} to #{destination}"
+            system(command)
+
+            if copy_exclude.any?
+              logger.debug "processing exclusions..."
+              if copy_exclude.any?
+                copy_exclude.each do |pattern| 
+                  delete_list = Dir.glob(File.join(destination, pattern), File::FNM_DOTMATCH)
+                  # avoid the /.. trap that deletes the parent directories
+                  delete_list.delete_if { |dir| dir =~ /\/\.\.$/ }
+                  FileUtils.rm_rf(delete_list.compact)
+                end
+              end
+            end
+          end
+
+          File.open(File.join(destination, "REVISION"), "w") { |f| f.puts(revision) }
+
+          logger.trace "compressing #{destination} to #{filename}"
+          Dir.chdir(tmpdir) { system(compress(File.basename(destination), File.basename(filename)).join(" ")) }
+
+          upload(filename, remote_filename)
+          run "cd #{configuration[:releases_path]} && #{decompress(remote_filename).join(" ")} && rm #{remote_filename}"
+        ensure
+          FileUtils.rm filename rescue nil
+          FileUtils.rm_rf destination rescue nil
+        end
+
+        def check!
+          super.check do |d|
+            d.local.command(source.local.command) if source.local.command
+            d.local.command(compress(nil, nil).first)
+            d.remote.command(decompress(nil).first)
+          end
+        end
+
+        # Returns the location of the local copy cache, if the strategy should
+        # use a local cache + copy instead of a new checkout/export every
+        # time. Returns +nil+ unless :copy_cache has been set. If :copy_cache
+        # is +true+, a default cache location will be returned.
+        def copy_cache
+          @copy_cache ||= configuration[:copy_cache] == true ?
+            File.join(Dir.tmpdir, configuration[:application]) :
+            configuration[:copy_cache]
+        end
+
+        private
+
+          # Specify patterns to exclude from the copy. This is only valid
+          # when using a local cache.
+          def copy_exclude
+            @copy_exclude ||= Array(configuration.fetch(:copy_exclude, []))
+          end
+
+          # Returns the basename of the release_path, which will be used to
+          # name the local copy and archive file.
+          def destination
+            @destination ||= File.join(tmpdir, File.basename(configuration[:release_path]))
+          end
+
+          # Returns the value of the :copy_strategy variable, defaulting to
+          # :checkout if it has not been set.
+          def copy_strategy
+            @copy_strategy ||= configuration.fetch(:copy_strategy, :checkout)
+          end
+
+          # Should return the command(s) necessary to obtain the source code
+          # locally.
+          def command
+            @command ||= case copy_strategy
+            when :checkout
+              source.checkout(revision, destination)
+            when :export
+              source.export(revision, destination)
+            end
+          end
+
+          # Returns the name of the file that the source code will be
+          # compressed to.
+          def filename
+            @filename ||= File.join(tmpdir, "#{File.basename(destination)}.#{compression.extension}")
+          end
+
+          # The directory to which the copy should be checked out
+          def tmpdir
+            @tmpdir ||= configuration[:copy_dir] || Dir.tmpdir
+          end
+
+          # The directory on the remote server to which the archive should be
+          # copied
+          def remote_dir
+            @remote_dir ||= configuration[:copy_remote_dir] || "/tmp"
+          end
+
+          # The location on the remote server where the file should be
+          # temporarily stored.
+          def remote_filename
+            @remote_filename ||= File.join(remote_dir, File.basename(filename))
+          end
+
+          # A struct for representing the specifics of a compression type.
+          # Commands are arrays, where the first element is the utility to be
+          # used to perform the compression or decompression.
+          Compression = Struct.new(:extension, :compress_command, :decompress_command)
+          
+          # The compression method to use, defaults to :gzip.
+          def compression
+            remote_tar = configuration[:copy_remote_tar] || 'tar'
+            local_tar = configuration[:copy_local_tar] || 'tar'
+            
+            type = configuration[:copy_compression] || :gzip
+            case type
+            when :gzip, :gz   then Compression.new("tar.gz",  [local_tar, 'czf'], [remote_tar, 'xzf'])
+            when :bzip2, :bz2 then Compression.new("tar.bz2", [local_tar, 'cjf'], [remote_tar, 'xjf'])
+            when :zip         then Compression.new("zip",     %w(zip -qr), %w(unzip -q))
+            else raise ArgumentError, "invalid compression type #{type.inspect}"
+            end
+          end
+          
+          # Returns the command necessary to compress the given directory
+          # into the given file.
+          def compress(directory, file)
+            compression.compress_command + [file, directory]
+          end
+
+          # Returns the command necessary to decompress the given file,
+          # relative to the current working directory. It must also
+          # preserve the directory structure in the file.
+          def decompress(file)
+            compression.decompress_command + [file]
+          end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'capistrano/recipes/deploy/strategy/remote'
+
+module Capistrano
+  module Deploy
+    module Strategy
+
+      # Implements the deployment strategy which does an SCM export on each
+      # target host.
+      class Export < Remote
+        protected
+
+          # Returns the SCM's export command for the revision to deploy.
+          def command
+            @command ||= source.export(revision, configuration[:release_path])
+          end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'capistrano/recipes/deploy/strategy/base'
+
+module Capistrano
+  module Deploy
+    module Strategy
+
+      # An abstract superclass, which forms the base for all deployment
+      # strategies which work by grabbing the code from the repository directly
+      # from remote host. This includes deploying by checkout (the default),
+      # and deploying by export.
+      class Remote < Base
+        # Executes the SCM command for this strategy and writes the REVISION
+        # mark file to each host.
+        def deploy!
+          scm_run "#{command} && #{mark}"
+        end
+
+        def check!
+          super.check do |d|
+            d.remote.command(source.command)
+          end
+        end
+
+        protected
+
+          # Runs the given command, filtering output back through the
+          # #handle_data filter of the SCM implementation.
+          def scm_run(command)
+            run(command) do |ch,stream,text|
+              ch[:state] ||= { :channel => ch }
+              output = source.handle_data(ch[:state], stream, text)
+              ch.send_data(output) if output
+            end
+          end
+
+          # An abstract method which must be overridden in subclasses, to
+          # return the actual SCM command(s) which must be executed on each
+          # target host in order to perform the deployment.
+          def command
+            raise NotImplementedError, "`command' is not implemented by #{self.class.name}"
+          end
+
+          # Returns the command which will write the identifier of the
+          # revision being deployed to the REVISION file on each host.
+          def mark
+            "(echo #{revision} > #{configuration[:release_path]}/REVISION)"
+          end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'capistrano/recipes/deploy/strategy/remote'
+
+module Capistrano
+  module Deploy
+    module Strategy
+
+      # Implements the deployment strategy that keeps a cached checkout of
+      # the source code on each remote server. Each deploy simply updates the
+      # cached checkout, and then does a copy from the cached copy to the
+      # final deployment location.
+      class RemoteCache < Remote
+        # Executes the SCM command for this strategy and writes the REVISION
+        # mark file to each host.
+        def deploy!
+          update_repository_cache
+          copy_repository_cache
+        end
+
+        def check!
+          super.check do |d|
+            d.remote.writable(shared_path)
+          end
+        end
+
+        private
+
+          def repository_cache
+            File.join(shared_path, configuration[:repository_cache] || "cached-copy")
+          end
+
+          def update_repository_cache
+            logger.trace "updating the cached checkout on all servers"
+            command = "if [ -d #{repository_cache} ]; then " +
+              "#{source.sync(revision, repository_cache)}; " +
+              "else #{source.checkout(revision, repository_cache)}; fi"
+            scm_run(command)
+          end
+
+          def copy_repository_cache
+            logger.trace "copying the cached version to #{configuration[:release_path]}"
+            if copy_exclude.empty? 
+              run "cp -RPp #{repository_cache} #{configuration[:release_path]} && #{mark}"
+            else
+              exclusions = copy_exclude.map { |e| "--exclude=\"#{e}\"" }.join(' ')
+              run "rsync -lrpt #{exclusions} #{repository_cache}/* #{configuration[:release_path]} && #{mark}"
+            end
+          end
+          
+          def copy_exclude
+            @copy_exclude ||= Array(configuration.fetch(:copy_exclude, []))
+          end
+      end
+
+    end
+  end
+end