minmb-capistrano 2.15.4

data/lib/capistrano/recipes/deploy/scm/perforce.rb

@@ -0,0 +1,152 @@
+require 'capistrano/recipes/deploy/scm/base'
+
+# Notes:
+#  no global verbose flag for scm_verbose
+#  sync, checkout and export are just sync in p4
+#
+module Capistrano
+  module Deploy
+    module SCM
+
+      # Implements the Capistrano SCM interface for the Perforce revision
+      # control system (http://www.perforce.com).
+      class Perforce < Base
+        # Sets the default command name for this SCM. Users may override this
+        # by setting the :scm_command variable.
+        default_command "p4"
+
+        # Perforce understands '#head' to refer to the latest revision in the
+        # depot.
+        def head
+          'head'
+        end
+
+        # Returns the command that will sync the given revision to the given
+        # destination directory. The perforce client has a fixed destination so
+        # the files must be copied from there to their intended resting place.
+        def checkout(revision, destination)
+          p4_sync(revision, destination, p4sync_flags)
+        end
+
+        # Returns the command that will sync the given revision to the given
+        # destination directory. The perforce client has a fixed destination so
+        # the files must be copied from there to their intended resting place.
+        def sync(revision, destination)
+          p4_sync(revision, destination, p4sync_flags)
+        end
+
+        # Returns the command that will sync the given revision to the given
+        # destination directory. The perforce client has a fixed destination so
+        # the files must be copied from there to their intended resting place.
+        def export(revision, destination)
+          p4_sync(revision, destination, p4sync_flags)
+        end
+
+        # Returns the command that will do an "p4 diff2" for the two revisions.
+        def diff(from, to=head)
+          scm authentication, :diff2, "-u -db", "//#{p4client}/...#{rev_no(from)}", "//#{p4client}/...#{rev_no(to)}"
+        end
+
+        # Returns a "p4 changes" command for the two revisions.
+        def log(from=1, to=head)
+          scm authentication, :changes, "-s submitted", "//#{p4client}/...#{rev_no(from)},#{rev_no(to)}"
+        end
+
+        def query_revision(revision)
+          return revision if revision.to_s =~ /^\d+$/
+          command = scm(authentication, :changes, "-s submitted", "-m 1", "//#{p4client}/...#{rev_no(revision)}")
+          yield(command)[/Change (\d+) on/, 1]
+        end
+
+        # Increments the given revision number and returns it.
+        def next_revision(revision)
+          revision.to_i + 1
+        end
+
+        # Determines what the response should be for a particular bit of text
+        # from the SCM. Password prompts, connection requests, passphrases,
+        # etc. are handled here.
+        def handle_data(state, stream, text)
+          case text
+          when /\(P4PASSWD\) invalid or unset\./i
+            raise Capistrano::Error, "scm_password (or p4passwd) is incorrect or unset"
+          when /Can.t create a new user.*/i
+            raise Capistrano::Error, "scm_username (or p4user) is incorrect or unset"
+          when /Perforce client error\:/i
+            raise Capistrano::Error, "p4port is incorrect or unset"
+          when /Client \'[\w\-\_\.]+\' unknown.*/i
+            raise Capistrano::Error, "p4client is incorrect or unset"
+          end
+        end
+
+        private
+
+          # Builds the set of authentication switches that perforce understands.
+          def authentication
+            [ p4port    && "-p #{p4port}",
+              p4user    && "-u #{p4user}",
+              p4passwd  && "-P #{p4passwd}",
+              p4client  && "-c #{p4client}",
+              p4charset && "-C #{p4charset}" ].compact.join(" ")
+          end
+
+          # Returns the command that will sync the given revision to the given
+          # destination directory with specific options. The perforce client has
+          # a fixed destination so the files must be copied from there to their
+          # intended resting place.
+          def p4_sync(revision, destination, options="")
+            scm authentication, :sync, options, "#{rev_no(revision)}", "&& cp -rf #{p4client_root} #{destination}"
+          end
+
+          def p4client
+            variable(:p4client)
+          end
+
+          def p4port
+            variable(:p4port)
+          end
+
+          def p4user
+            variable(:p4user) || variable(:scm_username)
+          end
+
+          def p4passwd
+            variable(:p4passwd) || variable(:scm_password)
+          end
+
+          def p4charset
+            variable(:p4charset)
+          end
+
+          def p4sync_flags
+            variable(:p4sync_flags) || "-f"
+          end
+
+          def p4client_root
+            variable(:p4client_root) || "`#{command} #{authentication} client -o | grep ^Root | cut -f2`"
+          end
+
+          def rev_no(revision)
+            if variable(:p4_label)
+              p4_label = if variable(:p4_label) =~ /\A@/
+                variable(:p4_label)
+              else
+                "@#{variable(:p4_label)}"
+              end
+              return p4_label
+            end
+
+            case revision.to_s
+            when "head"
+              "#head"
+            when /^\d+/
+              "@#{revision}"
+            else
+              revision
+            end
+          end
+      end
+
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/scm/subversion.rb

@@ -0,0 +1,121 @@
+require 'capistrano/recipes/deploy/scm/base'
+require 'yaml'
+
+module Capistrano
+  module Deploy
+    module SCM
+
+      # Implements the Capistrano SCM interface for the Subversion revision
+      # control system (http://subversion.tigris.org).
+      class Subversion < Base
+        # Sets the default command name for this SCM. Users may override this
+        # by setting the :scm_command variable.
+        default_command "svn"
+
+        # Subversion understands 'HEAD' to refer to the latest revision in the
+        # repository.
+        def head
+          "HEAD"
+        end
+
+        # Returns the command that will check out the given revision to the
+        # given destination.
+        def checkout(revision, destination)
+          scm :checkout, arguments, arguments(:checkout), verbose, authentication, "-r#{revision}", repository, destination
+        end
+
+        # Returns the command that will do an "svn update" to the given
+        # revision, for the working copy at the given destination.
+        def sync(revision, destination)
+          scm :switch, arguments, verbose, authentication, "-r#{revision}", repository, destination
+        end
+
+        # Returns the command that will do an "svn export" of the given revision
+        # to the given destination.
+        def export(revision, destination)
+          scm :export, arguments, arguments(:export), verbose, authentication, "-r#{revision}", repository, destination
+        end
+
+        # Returns the command that will do an "svn diff" for the two revisions.
+        def diff(from, to=nil)
+          scm :diff, repository, arguments(:diff), authentication, "-r#{from}:#{to || head}"
+        end
+
+        # Returns an "svn log" command for the two revisions.
+        def log(from, to=nil)
+          scm :log, repository, arguments(:log), authentication, "-r#{from}:#{to || head}"
+        end
+
+        # Attempts to translate the given revision identifier to a "real"
+        # revision. If the identifier is an integer, it will simply be returned.
+        # Otherwise, this will yield a string of the commands it needs to be
+        # executed (svn info), and will extract the revision from the response.
+        def query_revision(revision)
+          return revision if revision =~ /^\d+$/
+          command = scm(:info, arguments, arguments(:info), repository, authentication, "-r#{revision}")
+          result = yield(command)
+          yaml = YAML.load(result)
+          raise "tried to run `#{command}' and got unexpected result #{result.inspect}" unless Hash === yaml
+          [ (yaml['Last Changed Rev'] || 0).to_i, (yaml['Revision'] || 0).to_i ].max
+        end
+
+        # Increments the given revision number and returns it.
+        def next_revision(revision)
+          revision.to_i + 1
+        end
+
+        # Determines what the response should be for a particular bit of text
+        # from the SCM. Password prompts, connection requests, passphrases,
+        # etc. are handled here.
+        def handle_data(state, stream, text)
+          host = state[:channel][:host]
+          logger.info "[#{host} :: #{stream}] #{text}"
+          case text
+          when /\bpassword.*:/i
+            # subversion is prompting for a password
+            "#{scm_password_prompt}\n"
+          when %r{\(yes/no\)}
+            # subversion is asking whether or not to connect
+            "yes\n"
+          when /passphrase/i
+            # subversion is asking for the passphrase for the user's key
+            "#{variable(:scm_passphrase)}\n"
+          when /The entry \'(.+?)\' is no longer a directory/
+            raise Capistrano::Error, "subversion can't update because directory '#{$1}' was replaced. Please add it to svn:ignore."
+          when /accept \(t\)emporarily/
+            # subversion is asking whether to accept the certificate
+            "t\n"
+          end
+        end
+
+        private
+
+          # If a username is configured for the SCM, return the command-line
+          # switches for that. Note that we don't need to return the password
+          # switch, since Capistrano will check for that prompt in the output
+          # and will respond appropriately.
+          def authentication
+            username = variable(:scm_username)
+            return "" unless username
+            result = "--username #{variable(:scm_username)} "
+            result << "--password #{variable(:scm_password)} " unless variable(:scm_auth_cache) || variable(:scm_prefer_prompt)
+            result << "--no-auth-cache " unless variable(:scm_auth_cache)
+            result
+          end
+
+          # If verbose output is requested, return nil, otherwise return the
+          # command-line switch for "quiet" ("-q").
+          def verbose
+            variable(:scm_verbose) ? nil : "-q"
+          end
+
+          def scm_password_prompt
+            @scm_password_prompt ||= variable(:scm_password) ||
+              variable(:password) ||
+              Capistrano::CLI.password_prompt("Subversion password: ")
+          end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Capistrano
+  module Deploy
+    module Strategy
+      def self.new(strategy, config={})
+        strategy_file = "capistrano/recipes/deploy/strategy/#{strategy}"
+        require(strategy_file)
+
+        strategy_const = strategy.to_s.capitalize.gsub(/_(.)/) { $1.upcase }
+        if const_defined?(strategy_const)
+          const_get(strategy_const).new(config)
+        else
+          raise Capistrano::Error, "could not find `#{name}::#{strategy_const}' in `#{strategy_file}'"
+        end
+      rescue LoadError
+        raise Capistrano::Error, "could not find any strategy named `#{strategy}'"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+require 'benchmark'
+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|
+            if exists?(:stage)
+              d.remote.directory(configuration[:releases_path]).or("`#{configuration[:releases_path]}' does not exist. Please run `cap #{configuration[:stage]} deploy:setup'.")
+            else
+              d.remote.directory(configuration[:releases_path]).or("`#{configuration[:releases_path]}' does not exist. Please run `cap deploy:setup'.")
+            end
+            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(' ')
+            result = nil
+            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}"
+              elapsed = Benchmark.realtime do
+                result = super(cmd)
+              end
+            else
+              logger.trace "executing locally: #{cmd}"
+              elapsed = Benchmark.realtime do
+                result = super
+              end
+            end
+
+            logger.trace "command finished in #{(elapsed * 1000).round}ms"
+            result
+          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,338 @@
+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.
+      #
+      # By default, files will be transferred across to the remote machines via 'sftp'. If you prefer
+      # to use 'scp' you can set the :copy_via variable to :scp.
+      #
+      #   set :copy_via, :scp
+      #
+      # There is a possibility to pass a build command that will get
+      # executed if your code needs to be compiled or something needs to be
+      # done before the code is ready to run.
+      #
+      #   set :build_script, "make all"
+      #
+      # Note that if you use :copy_cache, the :build_script is used on the
+      # cache and thus you get faster compilation if your script does not
+      # recompile everything.
+      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!
+          copy_cache ? run_copy_cache_strategy : run_copy_strategy
+
+          create_revision_file
+          compress_repository
+          distribute!
+        ensure
+          rollback_changes
+        end
+
+        def build directory
+          execute "running build script on #{directory}" do
+            Dir.chdir(directory) { system(build_script) }
+          end if build_script
+        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.expand_path(configuration[:application], Dir.tmpdir) :
+            File.expand_path(configuration[:copy_cache], Dir.pwd) rescue nil
+        end
+
+        private
+
+          def run_copy_cache_strategy
+            copy_repository_to_local_cache
+            build copy_cache
+            copy_cache_to_staging_area
+          end
+
+          def run_copy_strategy
+            copy_repository_to_server
+            build destination
+            remove_excluded_files if copy_exclude.any?
+          end
+
+          def execute description, &block
+            logger.debug description
+            handle_system_errors &block
+          end
+
+          def handle_system_errors &block
+            block.call
+            raise_command_failed if last_command_failed?
+          end
+
+          def refresh_local_cache
+            execute "refreshing local cache to revision #{revision} at #{copy_cache}" do
+              system(source.sync(revision, copy_cache))
+            end
+          end
+
+          def create_local_cache
+            execute "preparing local cache at #{copy_cache}" do
+              system(source.checkout(revision, copy_cache))
+            end
+          end
+
+          def raise_command_failed
+            raise Capistrano::Error, "shell command failed with return code #{$?}"
+          end
+
+          def last_command_failed?
+            $? != 0
+          end
+
+          def copy_cache_to_staging_area
+            execute "copying cache to deployment staging area #{destination}" do
+              create_destination
+              Dir.chdir(copy_cache) { copy_files(queue_files) }
+            end
+          end
+
+          def create_destination
+            FileUtils.mkdir_p(destination)
+          end
+
+          def copy_files files
+            files.each { |name| process_file(name) }
+          end
+
+          def process_file name
+            send "copy_#{filetype(name)}", name
+          end
+
+          def filetype name
+            filetype = File.ftype name
+            filetype = "file" unless ["link", "directory"].include? filetype
+            filetype
+          end
+
+          def copy_link name
+            FileUtils.ln_s(File.readlink(name), File.join(destination, name))
+          end
+
+          def copy_directory name
+            FileUtils.mkdir(File.join(destination, name))
+            copy_files(queue_files(name))
+          end
+
+          def copy_file name
+            FileUtils.ln(name, File.join(destination, name))
+          end
+
+          def queue_files directory=nil
+            Dir.glob(pattern_for(directory), File::FNM_DOTMATCH).reject! { |file| excluded_files_contain? file }
+          end
+
+          def pattern_for directory
+            !directory.nil? ? "#{escape_globs(directory)}/*" : "*"
+          end
+
+          def escape_globs path
+            path.gsub(/[*?{}\[\]]/, '\\\\\\&')
+          end
+
+          def excluded_files_contain? file
+            copy_exclude.any? { |p| File.fnmatch(p, file) } or [ ".", ".."].include? File.basename(file)
+          end
+
+          def copy_repository_to_server
+            execute "getting (via #{copy_strategy}) revision #{revision} to #{destination}" do
+              copy_repository_via_strategy
+            end
+          end
+
+          def copy_repository_via_strategy
+              system(command)
+          end
+
+          def remove_excluded_files
+            logger.debug "processing exclusions..."
+
+            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
+
+          def create_revision_file
+            File.open(File.join(destination, "REVISION"), "w") { |f| f.puts(revision) }
+          end
+
+          def compress_repository
+            execute "Compressing #{destination} to #{filename}" do
+              Dir.chdir(copy_dir) { system(compress(File.basename(destination), File.basename(filename)).join(" ")) }
+            end
+          end
+
+          def rollback_changes
+            FileUtils.rm filename rescue nil
+            FileUtils.rm_rf destination rescue nil
+          end
+
+          def copy_repository_to_local_cache
+            return refresh_local_cache if File.exists?(copy_cache)
+            create_local_cache
+          end
+
+          def build_script
+            configuration[:build_script]
+          end
+
+          # 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(copy_dir, 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(copy_dir, "#{File.basename(destination)}.#{compression.extension}")
+          end
+
+          # The directory to which the copy should be checked out
+          def copy_dir
+            @copy_dir ||= File.expand_path(configuration[:copy_dir] || Dir.tmpdir, Dir.pwd)
+          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 -qyr), %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
+
+          def decompress_remote_file
+            run "cd #{configuration[:releases_path]} && #{decompress(remote_filename).join(" ")} && rm #{remote_filename}"
+          end
+
+          # Distributes the file to the remote servers
+          def distribute!
+            args = [filename, remote_filename]
+            args << { :via => configuration[:copy_via] } if configuration[:copy_via]
+
+            upload(*args)
+            decompress_remote_file
+          end
+      end
+
+    end
+  end
+end