mbailey-capistrano 2.5.5

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

@@ -0,0 +1,271 @@
+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
+          configuration[:branch] || 'HEAD'
+        end
+
+        def origin
+          configuration[: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 = []
+          args << "-o #{remote}" unless remote == 'origin'
+          if depth = configuration[:git_shallow_clone]
+            args << "--depth #{depth}"
+          end
+
+          execute = []
+          if args.empty?
+            execute << "#{git} clone #{verbose} #{configuration[:repository]} #{destination}"
+          else
+            execute << "#{git} clone #{verbose} #{args.join(' ')} #{configuration[:repository]} #{destination}"
+          end
+
+          # checkout into a local branch rather than a detached HEAD
+          execute << "cd #{destination} && #{git} checkout #{verbose} -b deploy #{revision}"
+          
+          if configuration[:git_enable_submodules]
+            execute << "#{git} submodule #{verbose} init"
+            execute << "#{git} submodule #{verbose} update"
+          end
+
+          execute.join(" && ")
+        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 #{configuration[: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} reset #{verbose} --hard #{revision}"
+
+          if configuration[:git_enable_submodules]
+            execute << "#{git} submodule #{verbose} init"
+            execute << "#{git} submodule #{verbose} update"
+          end
+
+          execute.join(" && ")
+        end
+
+        # Returns a string of diffs between two revisions
+        def diff(from, to=nil)
+          from << "..#{to}" if to
+          scm :diff, from
+        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
+              newrev = rev
+              break
+            end
+          end
+          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
+          configuration[: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 = configuration[: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 = configuration[: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

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

@@ -0,0 +1,137 @@
+# Copyright 2007 Matthew Elder <sseses@gmail.com>
+# based on work by Tobias Luetke
+
+require 'capistrano/recipes/deploy/scm/base'
+
+module Capistrano
+  module Deploy
+    module SCM
+
+      # Implements the Capistrano SCM interface for the Mercurial revision
+      # control system (http://www.selenic.com/mercurial/).
+      # Latest updates at http://tackletechnology.org/oss/cap2-mercurial
+      class Mercurial < Base
+        # Sets the default command name for this SCM. Users may override this
+        # by setting the :scm_command variable.
+        default_command "hg"
+
+        # For mercurial HEAD == tip except that it bases this assumption on what
+        # tip is in the current repository (so push before you deploy)
+        def head
+          "tip"
+        end
+
+        # Clone the repository and update to the specified changeset.
+        def checkout(changeset, destination)
+          clone(destination) + " && " + update(changeset, destination)
+        end
+
+        # Pull from the repository and update to the specified changeset.
+        def sync(changeset, destination)
+          pull(destination) + " && " + update(changeset, destination)
+        end
+
+        # One day we will have hg archive, although i think its not needed
+        def export(revision, destination)
+          raise NotImplementedError, "`diff' is not implemented by #{self.class.name}" +
+          "use checkout strategy"
+        end
+
+        # Compute the difference between the two changesets +from+ and +to+
+        # as a unified diff.
+        def diff(from, to=nil)
+          scm :diff,
+              "--rev #{from}",
+              (to ? "--rev #{to}" : nil)
+        end
+
+        # Return a log of all changes between the two specified changesets,
+        # +from+ and +to+, inclusive or the log for +from+ if +to+ is omitted.
+        def log(from, to=nil)
+          scm :log,
+              verbose,
+              "--rev #{from}" +
+              (to ? ":#{to}" : "")
+        end
+
+        # Translates a tag to a changeset if needed or just returns changeset.
+        def query_revision(changeset)
+          cmd = scm :log,
+                    verbose,
+                    "-r #{changeset}",
+                    "--template '{node|short}'"
+                    yield cmd
+        end
+
+        # Determine response for SCM prompts
+        # user/pass can come from ssh and http distribution methods
+        # yes/no is for when ssh asks you about fingerprints
+        def handle_data(state, stream, text)
+          host = state[:channel][:host]
+          logger.info "[#{host} :: #{stream}] #{text}"
+          case text
+          when /^user:/mi
+            # support :scm_user for backwards compatibility of this module
+            if user = variable(:scm_username) || variable(:scm_user)
+              "#{user}\n"
+            else
+              raise "No variable :scm_username specified and Mercurial asked!\n" +
+                "Prompt was: #{text}"
+            end
+          when /\bpassword:/mi
+            unless pass = scm_password_or_prompt
+              # fall back on old behavior of erroring out with msg
+              raise "No variable :scm_password specified and Mercurial asked!\n" +
+                "Prompt was: #{text}"
+            end
+            "#{pass}\n"
+          when /yes\/no/i
+            "yes\n"
+          end
+        end
+        
+        private
+
+        # Fine grained mercurial commands
+        def clone(destination) 
+          scm :clone,
+              verbose,
+              "--noupdate", # do not update to tip when cloning is done
+              repository,   # clone which repository?
+              destination   # and put the clone where?
+        end
+
+        def pull(destination)
+          scm :pull,
+              verbose,
+              "--repository #{destination}", # pull changes into what?
+              repository                     # and pull the changes from?
+        end
+
+        def update(changeset, destination)
+          scm :update,
+              verbose,
+              "--repository #{destination}", # update what?
+              "--clean",                     # ignore untracked changes
+              changeset                      # update to this changeset
+        end
+
+        # verbosity configuration grokking :)
+        def verbose
+          case variable(:scm_verbose)
+            when nil   then nil
+            when false then "--quiet"
+            else            "--verbose"
+          end
+        end
+        
+        # honor Cap 2.1+'s :scm_prefer_prompt if present
+        def scm_password_or_prompt
+          @scm_password_or_prompt ||= variable(:scm_password) ||
+            (Capistrano::CLI.password_prompt("hg password: ") if variable(:scm_prefer_prompt))
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'capistrano/recipes/deploy/scm/base'
+
+module Capistrano
+  module Deploy
+    module SCM
+
+      # A trivial SCM wrapper for representing the current working directory
+      # as a repository. Obviously, not all operations are available for this
+      # SCM, but it works sufficiently for use with the "copy" deployment
+      # strategy.
+      #
+      # Use of this module is _not_ recommended; in general, it is good
+      # practice to use some kind of source code management even for anything
+      # you are wanting to deploy. However, this module is provided in
+      # acknowledgement of the cases where trivial deployment of your current
+      # working directory is desired.
+      #
+      #   set :repository, "."
+      #   set :scm, :none
+      #   set :deploy_via, :copy
+      class None < Base
+        # No versioning, thus, no head. Returns the empty string.
+        def head
+          ""
+        end
+
+        # Simply does a copy from the :repository directory to the
+        # :destination directory.
+        def checkout(revision, destination)
+          !Capistrano::Deploy::LocalDependency.on_windows? ? "cp -R #{repository} #{destination}" : "xcopy #{repository} \"#{destination}\" /S/I/Y/Q/E"
+        end
+
+        alias_method :export, :checkout
+
+        # No versioning, so this just returns the argument, with no
+        # modification.
+        def query_revision(revision)
+          revision
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+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
+
+        # 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}" ].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 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)                     
+            case revision.to_s
+            when "head"
+              "#head"
+            when /^\d+/  
+              "@#{revision}"
+            else
+              revision
+            end          
+          end
+      end
+
+    end
+  end
+end