capistrano 2.0.0 → 2.15.2

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

@@ -0,0 +1,169 @@
+require 'capistrano/recipes/deploy/scm/base'
+require 'rexml/xpath'
+require 'rexml/document'
+
+module Capistrano
+  module Deploy
+    module SCM
+      # Accurev bridge for use by Capistrano. This implementation does not
+      # implement all features of a Capistrano SCM module. The ones that are
+      # left out are either exceedingly difficult to implement with Accurev
+      # or are considered bad form.
+      #
+      # When using this module in a project, the following variables are used:
+      #  * :repository - This should match the depot that code lives in. If your code
+      #                  exists in a subdirectory, you can append the path depot.
+      #                  eg. foo-depot/bar_dir
+      #  * :stream - The stream in the depot that code should be pulled from. If
+      #              left blank, the depot stream will be used
+      #  * :revision - Should be in the form 'stream/transaction'.
+      class Accurev < Base
+        include REXML
+        default_command 'accurev'
+
+        # Defines pseudo-revision value for the most recent changes to be deployed.
+        def head
+          "#{stream}/highest"
+        end
+
+        # Given an Accurev revision identifier, this method returns an identifier that
+        # can be used for later SCM calls. This returned identifier will not
+        # change as a result of further SCM activity.
+        def query_revision(revision)
+          internal_revision = InternalRevision.parse(revision)
+          return revision unless internal_revision.psuedo_revision?
+
+          logger.debug("Querying for real revision for #{internal_revision}")
+          rev_stream = internal_revision.stream
+
+          logger.debug("Determining what type of stream #{rev_stream} is...")
+          stream_xml = yield show_streams_for(rev_stream)
+          stream_doc = Document.new(stream_xml)
+          type = XPath.first(stream_doc, '//streams/stream/@type').value
+
+          case type
+          when 'snapshot'
+            InternalRevision.new(rev_stream, 'highest').to_s
+          else
+            logger.debug("Getting latest transaction id in #{rev_stream}")
+            # Doing another yield for a second Accurev call. Hopefully this is ok.
+            hist_xml = yield scm(:hist, '-ftx', '-s', rev_stream, '-t', 'now.1')
+            hist_doc = Document.new(hist_xml)
+            transaction_id = XPath.first(hist_doc, '//AcResponse/transaction/@id').value
+            InternalRevision.new(stream, transaction_id).to_s
+          end
+        end
+
+        # Pops a copy of the code for the specified Accurev revision identifier.
+        # The revision identifier is represented as a stream & transaction ID combo.
+        # Accurev can only pop a particular transaction if a stream is created on the server
+        # with a time basis of that transaction id. Therefore, we will create a stream with
+        # the required criteria and pop that.
+        def export(revision_id, destination)
+          revision = InternalRevision.parse(revision_id)
+          logger.debug("Exporting #{revision.stream}/#{revision.transaction_id} to #{destination}")
+
+          commands = [
+            change_or_create_stream("#{revision.stream}-capistrano-deploy", revision),
+            "mkdir -p #{destination}",
+            scm_quiet(:pop, "-Rv #{stream}", "-L #{destination}", "'/./#{subdir}'")
+          ]
+          if subdir
+            commands.push(
+              "mv #{destination}/#{subdir}/* #{destination}",
+              "rm -rf #{File.join(destination, subdir)}"
+            )
+          end
+          commands.join(' && ')
+        end
+
+        # Returns the command needed to show the changes that exist between the two revisions.
+        def log(from, to=head)
+          logger.info("Getting transactions between #{from} and #{to}")
+          from_rev = InternalRevision.parse(from)
+          to_rev = InternalRevision.parse(to)
+
+          [
+            scm(:hist, '-s', from_rev.stream, '-t', "#{to_rev.transaction_id}-#{from_rev.transaction_id}"),
+            "sed -e '/transaction #{from_rev.transaction_id}/ { Q }'"
+          ].join(' | ')
+        end
+
+        # Returns the command needed to show the diff between what is deployed and what is
+        # pending. Because Accurev can not do this task without creating some streams,
+        # two time basis streams will be created for the purposes of doing the diff.
+        def diff(from, to=head)
+          from = InternalRevision.parse(from)
+          to = InternalRevision.parse(to)
+
+          from_stream = "#{from.stream}-capistrano-diff-from"
+          to_stream = "#{to.stream}-capistrano-diff-to"
+
+          [
+            change_or_create_stream(from_stream, from),
+            change_or_create_stream(to_stream, to),
+            scm(:diff, '-v', from_stream, '-V', to_stream, '-a')
+          ].join(' && ')
+        end
+
+        private
+        def depot
+          repository.split('/')[0]
+        end
+
+        def stream
+          variable(:stream) || depot
+        end
+
+        def subdir
+          repository.split('/')[1..-1].join('/') unless repository.index('/').nil?
+        end
+
+        def change_or_create_stream(name, revision)
+          [
+            scm_quiet(:mkstream, '-b', revision.stream, '-s', name, '-t', revision.transaction_id),
+            scm_quiet(:chstream, '-b', revision.stream, '-s', name, '-t', revision.transaction_id)
+          ].join('; ')
+        end
+
+        def show_streams_for(stream)
+          scm :show, '-fx', '-s', stream, :streams
+        end
+
+        def scm_quiet(*args)
+          scm(*args) + (variable(:scm_verbose) ? '' : '&> /dev/null')
+        end
+
+        class InternalRevision
+          attr_reader :stream, :transaction_id
+
+          def self.parse(string)
+            match = /([^\/]+)(\/(.+)){0,1}/.match(string)
+            raise "Unrecognized revision identifier: #{string}" unless match
+
+            stream = match[1]
+            transaction_id = match[3] || 'highest'
+            InternalRevision.new(stream, transaction_id)
+          end
+
+          def initialize(stream, transaction_id)
+            @stream = stream
+            @transaction_id = transaction_id
+          end
+
+          def psuedo_revision?
+            @transaction_id == 'highest'
+          end
+
+          def to_s
+            "#{stream}/#{transaction_id}"
+          end
+
+          def ==(other)
+            (stream == other.stream) && (transaction_id == other.transaction_id)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -54,7 +54,7 @@ module Capistrano
         # and "local_scm_command" to be set, if the two differ.
         #
         # Alternatively, it may be called with a block, and for the duration of
-        # the block, all requests on this configuration object will be 
+        # the block, all requests on this configuration object will be
         # considered local.
         def local
           if block_given?
@@ -114,6 +114,18 @@ module Capistrano
           raise NotImplementedError, "`query_revision' is not implemented by #{self.class.name}"
         end
 
+        # Returns the revision number immediately following revision, if at
+        # all possible. A block should always be passed to this method, which
+        # accepts a command to invoke and returns the result, although a
+        # particular SCM's implementation is not required to invoke the block.
+        #
+        # By default, this method simply returns the revision itself. If a
+        # particular SCM is able to determine a subsequent revision given a
+        # revision identifier, it should override this method.
+        def next_revision(revision)
+          revision
+        end
+
         # Should analyze the given text and determine whether or not a
         # response is expected, and if so, return the appropriate response.
         # If no response is expected, return nil. The +state+ parameter is a
@@ -138,15 +150,22 @@ module Capistrano
           command || default_command
         end
 
+        # A helper method that can be used to define SCM commands naturally.
+        # It returns a single string with all arguments joined by spaces,
+        # with the scm command prefixed onto it.
+        def scm(*args)
+          [command, *args].compact.join(" ")
+        end
+
         private
 
           # A helper for accessing variable values, which takes into
           # consideration the current mode ("normal" vs. "local").
-          def variable(name)
+          def variable(name, default = nil)
             if local? && configuration.exists?("local_#{name}".to_sym)
-              return configuration["local_#{name}".to_sym]
+              return configuration["local_#{name}".to_sym].nil? ? default : configuration["local_#{name}".to_sym]
             else
-              configuration[name]
+              configuration[name].nil? ? default : configuration[name]
             end
           end
 
@@ -162,17 +181,18 @@ module Capistrano
             self.class.default_command
           end
 
-          # A helper method that can be used to define SCM commands naturally.
-          # It returns a single string with all arguments joined by spaces,
-          # with the scm command prefixed onto it.
-          def scm(*args)
-            [command, *args].compact.join(" ")
-          end
-
           # A convenience method for accessing the declared repository value.
           def repository
             variable(:repository)
           end
+
+          def arguments(command = :all)
+            value = variable(:scm_arguments)
+            if value.is_a?(Hash)
+              value = value[command]
+            end
+            value
+          end
       end
 
     end

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

@@ -21,7 +21,7 @@ module Capistrano
         # Returns the command that will check out the given revision to the
         # given destination.
         def checkout(revision, destination)
-          scm :branch, revswitch(revision), repository, destination
+          scm :checkout, "--lightweight", revswitch(revision), repository, destination
         end
 
         # The bzr 'update' command does not support updating to a specific
@@ -33,13 +33,9 @@ module Capistrano
           commands.join(" && ")
         end
 
-        # The bzr 'export' command would work fine, except it doesn't let you
-        # specify the repository itself, so it only works if there is a working
-        # tree handy, locally. Since this needs to work even on a remote host
-        # where there is no working tree, we'll just do a checkout, followed
-        # by a deletion of the ".bzr" metadata directory.
+        # The bzr 'export' does an export similar to other SCM systems
         def export(revision, destination)
-          [checkout(revision, destination) && "rm -rf #{destination}/.bzr"].join(" && ")
+          scm :export, revswitch(revision), destination, repository
         end
 
         # The bzr "diff" command doesn't accept a repository argument, so it
@@ -63,20 +59,24 @@ module Capistrano
         # If the 'revision' argument, on the other hand, is not :head, it is
         # simply returned.
         def query_revision(revision)
-          if revision == head
-            yield(scm(:revno, repository)).chomp
-          else
-            revision
-          end
+          return revision unless :head == revision
+
+          command = scm('revno', repository)
+          result = yield(command)
+        end
+
+        # Increments the given revision number and returns it.
+        def next_revision(revision)
+          revision.to_i + 1
         end
 
         private
 
           def revswitch(revision)
-            if revision == :head
+            if revision == :head || revision.nil?
               nil
             else
-              "-r #{revision}"
+              "-r #{revision}".chomp
             end
           end
       end

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

@@ -63,15 +63,16 @@ module Capistrano
           scm cvs_root, :log, range_arg
         end
 
-        # Unfortunately, cvs doesn't support the concept of a revision number like 
+        # Unfortunately, cvs doesn't support the concept of a revision number like
         # subversion and other SCM's do.  For now, we'll rely on getting the timestamp
         # of the latest checkin under the revision that's passed to us.
         def query_revision(revision)
           return revision if revision_type(revision) == :date
           revision = yield(scm(cvs_root, :log, "-r#{revision}")).
-                       grep(/^date:/).
+                       split("\n").
+                       select { |line| line =~ /^date:/ }.
                        map { |line| line[/^date: (.*?);/, 1] }.
-                       sort.last
+                       sort.last + " UTC"
           return revision
         end
 
@@ -98,7 +99,7 @@ module Capistrano
             root << "-d #{repository} " if repository
             root
           end
-          
+
           # Constructs the destination dir command-line option
           def cvs_destination(destination)
             dest = ""
@@ -108,23 +109,24 @@ module Capistrano
             end
             dest
           end
-          
+
           # attempts to guess what type of revision we're working with
           def revision_type(rev)
+            return :date if rev =~ /^\d{4}\/\d{2}\/\d{2} \d{2}:\d{2}:\d{2} UTC$/ # i.e 2007-05-15 08:13:25 UTC
             return :date if rev =~ /^\d{4}\/\d{2}\/\d{2} \d{2}:\d{2}:\d{2}$/ # i.e 2007-05-15 08:13:25
             return :revision if rev =~ /^\d/ # i.e. 1.2.1
             return :tag # i.e. RELEASE_1_2
           end
-          
+
           # constructs the appropriate command-line switch for specifying a
           # "revision" in CVS.  This could be a tag, branch, revision (i.e. 1.3)
           # or a date (to be used with -d)
           def cvs_revision(rev)
             revision = ""
             revision << case revision_type(rev)
-              when :date:
+              when :date
                 "-D \"#{rev}\"" if revision_type(rev) == :date
-              when :revision:
+              when :revision
                 "-r #{rev}"
               else
                 "-r #{head}"

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

@@ -18,11 +18,22 @@ module Capistrano
           :head
         end
 
+        def to_match(revision)
+          if revision.nil? || revision == self.head
+            nil
+          else
+            "--to-match='hash #{revision}'"
+          end
+        end
+
         # Returns the command that will check out the given revision to the
         # given destination. The 'revision' parameter must be the 'hash' value
         # for the revision in question, as given by 'darcs changes --xml-output'.
         def checkout(revision, destination)
-          scm :get, verbose, "--repo-name=#{destination}", "--to-match='hash #{revision}'", repository
+          scm :get, *[verbose,
+                      "--repo-name=#{destination}",
+                      to_match(revision),
+                      repository].compact
         end
 
         # Tries to update the destination repository in-place, to bring it up

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

@@ -0,0 +1,293 @@
+require 'capistrano/recipes/deploy/scm/base'
+
+module Capistrano
+  module Deploy
+    module SCM
+
+      # An SCM module for using Git as your source control tool with Capistrano
+      # 2.0.  If you are using Capistrano 1.x, use this plugin instead:
+      #
+      #   http://scie.nti.st/2007/3/16/capistrano-with-git-shared-repository
+      #
+      # Assumes you are using a shared Git repository.
+      #
+      # Parts of this plugin borrowed from Scott Chacon's version, which I
+      # found on the Capistrano mailing list but failed to be able to get
+      # working.
+      #
+      # FEATURES:
+      #
+      #   * Very simple, only requiring 2 lines in your deploy.rb.
+      #   * Can deploy different branches, tags, or any SHA1 easily.
+      #   * Supports prompting for password / passphrase upon checkout.
+      #     (I am amazed at how some plugins don't do this)
+      #   * Supports :scm_command, :scm_password, :scm_passphrase Capistrano
+      #     directives.
+      #
+      # CONFIGURATION
+      # -------------
+      #
+      # Use this plugin by adding the following line in your config/deploy.rb:
+      #
+      #   set :scm, :git
+      #
+      # Set <tt>:repository</tt> to the path of your Git repo:
+      #
+      #   set :repository, "someuser@somehost:/home/myproject"
+      #
+      # The above two options are required to be set, the ones below are
+      # optional.
+      #
+      # You may set <tt>:branch</tt>, which is the reference to the branch, tag,
+      # or any SHA1 you are deploying, for example:
+      #
+      #   set :branch, "master"
+      #
+      # Otherwise, HEAD is assumed.  I strongly suggest you set this.  HEAD is
+      # not always the best assumption.
+      #
+      # You may also set <tt>:remote</tt>, which will be used as a name for remote
+      # tracking of repositories. This option is intended for use with the
+      # <tt>:remote_cache</tt> strategy in a distributed git environment.
+      #
+      # For example in the projects <tt>config/deploy.rb</tt>:
+      #
+      #   set :repository, "#{scm_user}@somehost:~/projects/project.git"
+      #   set :remote, "#{scm_user}"
+      #
+      # Then each person with deploy priveledges can add the following to their
+      # local <tt>~/.caprc</tt> file:
+      #
+      #   set :scm_user, 'someuser'
+      #
+      # Now any time a person deploys the project, their repository will be
+      # setup as a remote git repository within the cached repository.
+      #
+      # The <tt>:scm_command</tt> configuration variable, if specified, will
+      # be used as the full path to the git executable on the *remote* machine:
+      #
+      #   set :scm_command, "/opt/local/bin/git"
+      #
+      # For compatibility with deploy scripts that may have used the 1.x
+      # version of this plugin before upgrading, <tt>:git</tt> is still
+      # recognized as an alias for :scm_command.
+      #
+      # Set <tt>:scm_password</tt> to the password needed to clone your repo
+      # if you don't have password-less (public key) entry:
+      #
+      #   set :scm_password, "my_secret'
+      #
+      # Otherwise, you will be prompted for a password.
+      #
+      # <tt>:scm_passphrase</tt> is also supported.
+      #
+      # The remote cache strategy is also supported.
+      #
+      #   set :repository_cache, "git_master"
+      #   set :deploy_via, :remote_cache
+      #
+      # For faster clone, you can also use shallow cloning.  This will set the
+      # '--depth' flag using the depth specified.  This *cannot* be used
+      # together with the :remote_cache strategy
+      #
+      #   set :git_shallow_clone, 1
+      #
+      # For those that don't like to leave your entire repository on
+      # your production server you can:
+      #
+      #   set :deploy_via, :export
+      #
+      # To deploy from a local repository:
+      #
+      #   set :repository, "file://."
+      #   set :deploy_via, :copy
+      #
+      # AUTHORS
+      # -------
+      #
+      # Garry Dolley http://scie.nti.st
+      # Contributions by Geoffrey Grosenbach http://topfunky.com
+      #              Scott Chacon http://jointheconversation.org
+      #                          Alex Arnell http://twologic.com
+      #                                   and Phillip Goldenburg
+
+      class Git < Base
+        # Sets the default command name for this SCM on your *local* machine.
+        # Users may override this by setting the :scm_command variable.
+        default_command "git"
+
+        # When referencing "head", use the branch we want to deploy or, by
+        # default, Git's reference of HEAD (the latest changeset in the default
+        # branch, usually called "master").
+        def head
+          variable(:branch) || 'HEAD'
+        end
+
+        def origin
+          variable(:remote) || 'origin'
+        end
+
+        # Performs a clone on the remote machine, then checkout on the branch
+        # you want to deploy.
+        def checkout(revision, destination)
+          git    = command
+          remote = origin
+
+          args = []
+
+          # Add an option for the branch name so :git_shallow_clone works with branches
+          args << "-b #{variable(:branch)}" unless variable(:branch).nil?
+          args << "-o #{remote}" unless remote == 'origin'
+          if depth = variable(:git_shallow_clone)
+            args << "--depth #{depth}"
+          end
+
+          execute = []
+          execute << "#{git} clone #{verbose} #{args.join(' ')} #{variable(:repository)} #{destination}"
+
+          # checkout into a local branch rather than a detached HEAD
+          execute << "cd #{destination} && #{git} checkout #{verbose} -b deploy #{revision}"
+
+          if variable(:git_enable_submodules)
+            execute << "#{git} submodule #{verbose} init"
+            execute << "#{git} submodule #{verbose} sync"
+            if false == variable(:git_submodules_recursive)
+              execute << "#{git} submodule #{verbose} update --init"
+            else
+              execute << %Q(export GIT_RECURSIVE=$([ ! "`#{git} --version`" \\< "git version 1.6.5" ] && echo --recursive))
+              execute << "#{git} submodule #{verbose} update --init $GIT_RECURSIVE"
+            end
+          end
+
+          execute.compact.join(" && ").gsub(/\s+/, ' ')
+        end
+
+        # An expensive export. Performs a checkout as above, then
+        # removes the repo.
+        def export(revision, destination)
+          checkout(revision, destination) << " && rm -Rf #{destination}/.git"
+        end
+
+        # Merges the changes to 'head' since the last fetch, for remote_cache
+        # deployment strategy
+        def sync(revision, destination)
+          git     = command
+          remote  = origin
+
+          execute = []
+          execute << "cd #{destination}"
+
+          # Use git-config to setup a remote tracking branches. Could use
+          # git-remote but it complains when a remote of the same name already
+          # exists, git-config will just silenty overwrite the setting every
+          # time. This could cause wierd-ness in the remote cache if the url
+          # changes between calls, but as long as the repositories are all
+          # based from each other it should still work fine.
+          if remote != 'origin'
+            execute << "#{git} config remote.#{remote}.url #{variable(:repository)}"
+            execute << "#{git} config remote.#{remote}.fetch +refs/heads/*:refs/remotes/#{remote}/*"
+          end
+
+          # since we're in a local branch already, just reset to specified revision rather than merge
+          execute << "#{git} fetch #{verbose} #{remote} && #{git} fetch --tags #{verbose} #{remote} && #{git} reset #{verbose} --hard #{revision}"
+
+          if variable(:git_enable_submodules)
+            execute << "#{git} submodule #{verbose} init"
+            execute << "#{git} submodule #{verbose} sync"
+            if false == variable(:git_submodules_recursive)
+              execute << "#{git} submodule #{verbose} update --init"
+            else
+              execute << %Q(export GIT_RECURSIVE=$([ ! "`#{git} --version`" \\< "git version 1.6.5" ] && echo --recursive))
+              execute << "#{git} submodule #{verbose} update --init $GIT_RECURSIVE"
+            end
+          end
+
+          # Make sure there's nothing else lying around in the repository (for
+          # example, a submodule that has subsequently been removed).
+          execute << "#{git} clean #{verbose} -d -x -f"
+
+          execute.join(" && ")
+        end
+
+        # Returns a string of diffs between two revisions
+        def diff(from, to=nil)
+          return scm :diff, from unless to
+          scm :diff, "#{from}..#{to}"
+        end
+
+        # Returns a log of changes between the two revisions (inclusive).
+        def log(from, to=nil)
+          scm :log, "#{from}..#{to}"
+        end
+
+        # Getting the actual commit id, in case we were passed a tag
+        # or partial sha or something - it will return the sha if you pass a sha, too
+        def query_revision(revision)
+          raise ArgumentError, "Deploying remote branches is no longer supported.  Specify the remote branch as a local branch for the git repository you're deploying from (ie: '#{revision.gsub('origin/', '')}' rather than '#{revision}')." if revision =~ /^origin\//
+          return revision if revision =~ /^[0-9a-f]{40}$/
+          command = scm('ls-remote', repository, revision)
+          result = yield(command)
+          revdata = result.split(/[\t\n]/)
+          newrev = nil
+          revdata.each_slice(2) do |refs|
+            rev, ref = *refs
+            if ref.sub(/refs\/.*?\//, '').strip == revision.to_s
+              newrev = rev
+              break
+            end
+          end
+          return newrev if newrev =~ /^[0-9a-f]{40}$/
+
+          # If sha is not found on remote, try expanding from local repository
+          command = scm('rev-parse --revs-only', revision)
+          newrev = yield(command).to_s.strip
+
+          raise "Unable to resolve revision for '#{revision}' on repository '#{repository}'." unless newrev =~ /^[0-9a-f]{40}$/
+          return newrev
+        end
+
+        def command
+          # For backwards compatibility with 1.x version of this module
+          variable(:git) || super
+        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
+            # git is prompting for a password
+            unless pass = variable(:scm_password)
+              pass = Capistrano::CLI.password_prompt
+            end
+            "#{pass}\n"
+          when %r{\(yes/no\)}
+            # git is asking whether or not to connect
+            "yes\n"
+          when /passphrase/i
+            # git is asking for the passphrase for the user's key
+            unless pass = variable(:scm_passphrase)
+              pass = Capistrano::CLI.password_prompt
+            end
+            "#{pass}\n"
+          when /accept \(t\)emporarily/
+            # git is asking whether to accept the certificate
+            "t\n"
+          end
+        end
+
+        private
+
+          # If verbose output is requested, return nil, otherwise return the
+          # command-line switch for "quiet" ("-q").
+          def verbose
+            variable(:scm_verbose) ? nil : "-q"
+          end
+      end
+    end
+  end
+end
+