Class: Capistrano::Deploy::SCM::Git

### Home Classes Methods

### In Files

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

### Parent

Capistrano::Deploy::SCM::Base

### Methods

- #checkout
- #command
- #diff
- #export
- #handle_data
- #head
- #log
- #origin
- #query_revision
- #sync

### Files

- help.txt

### Class/Module Index

Quicksearch

- Capistrano
- Capistrano::CLI
- Capistrano::CLI::Execute
- Capistrano::CLI::Execute::ClassMethods
- Capistrano::CLI::Help
- Capistrano::CLI::Options
- Capistrano::CLI::Options::ClassMethods
- Capistrano::CLI::UI
- Capistrano::CLI::UI::ClassMethods
- Capistrano::Callback
- Capistrano::Command
- Capistrano::Command::Tree
- Capistrano::Command::Tree::Branch
- Capistrano::Command::Tree::ConditionBranch
- Capistrano::Command::Tree::ConditionBranch::Evaluator
- Capistrano::Command::Tree::ElseBranch
- Capistrano::Configuration
- Capistrano::Configuration::Actions
- Capistrano::Configuration::Actions::FileTransfer
- Capistrano::Configuration::Actions::Inspect
- Capistrano::Configuration::Actions::Invocation
- Capistrano::Configuration::Actions::Invocation::ClassMethods
- Capistrano::Configuration::AliasTask
- Capistrano::Configuration::Callbacks
- Capistrano::Configuration::Connections
- Capistrano::Configuration::Execution
- Capistrano::Configuration::Loading
- Capistrano::Configuration::Loading::ClassMethods
- Capistrano::Configuration::LogFormatters
- Capistrano::Configuration::Namespaces
- Capistrano::Configuration::Namespaces::Namespace
- Capistrano::Configuration::Roles
- Capistrano::Configuration::Servers
- Capistrano::Configuration::Variables
- Capistrano::Deploy
- Capistrano::Deploy::Dependencies
- Capistrano::Deploy::LocalDependency
- Capistrano::Deploy::RemoteDependency
- Capistrano::Deploy::SCM
- Capistrano::Deploy::SCM::Accurev
- Capistrano::Deploy::SCM::Accurev::InternalRevision
- Capistrano::Deploy::SCM::Base
- Capistrano::Deploy::SCM::Base::LocalProxy
- Capistrano::Deploy::SCM::Bzr
- Capistrano::Deploy::SCM::Cvs
- Capistrano::Deploy::SCM::Darcs
- Capistrano::Deploy::SCM::Git
- Capistrano::Deploy::SCM::Mercurial
- Capistrano::Deploy::SCM::None
- Capistrano::Deploy::SCM::Perforce
- Capistrano::Deploy::SCM::Subversion
- Capistrano::Deploy::Strategy
- Capistrano::Deploy::Strategy::Base
- Capistrano::Deploy::Strategy::Checkout
- Capistrano::Deploy::Strategy::Copy
- Capistrano::Deploy::Strategy::Export
- Capistrano::Deploy::Strategy::Remote
- Capistrano::Deploy::Strategy::RemoteCache
- Capistrano::Deploy::Strategy::UnsharedRemoteCache
- Capistrano::ProcCallback
- Capistrano::Processable
- Capistrano::Processable::SessionAssociation
- Capistrano::RemoteError
- Capistrano::Role
- Capistrano::Role::DynamicServerList
- Capistrano::SSH
- Capistrano::ServerDefinition
- Capistrano::Shell
- Capistrano::TaskCallback
- Capistrano::TaskDefinition
- Capistrano::Transfer
- Capistrano::Transfer::SFTPTransferWrapper
- Capistrano::Version
- Kernel
- Object
- String

No matching classes.

# Capistrano::Deploy::SCM::Git

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 `:repository` 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 `:branch`, 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 `:remote`, which will be used as a name for remote tracking of repositories. This option is intended for use with the `:remote_cache` strategy in a distributed git environment.

For example in the projects `config/deploy.rb`:

    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 `~/.caprc` 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 `:scm_command` 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, `:git` is still recognized as an alias for :scm_command.

Set `:scm_password` 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.

`:scm_passphrase` 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 scie.nti.st Contributions by Geoffrey Grosenbach topfunky.com

    Scott Chacon http://jointheconversation.org
                Alex Arnell http://twologic.com
                         and Phillip Goldenburg

### Public Instance Methods

checkout(revision, destination) click to toggle source

Performs a clone on the remote machine, then checkout on the branch you want to deploy.

    # File lib/capistrano/recipes/deploy/scm/git.rb, line 132
    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? || variable(:branch) == revision
      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 << %(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

command() click to toggle source

    # File lib/capistrano/recipes/deploy/scm/git.rb, line 249
    def command
      # For backwards compatibility with 1.x version of this module
      variable(:git) || super
    end

diff(from, to=nil) click to toggle source

Returns a string of diffs between two revisions

    # File lib/capistrano/recipes/deploy/scm/git.rb, line 213
    def diff(from, to=nil)
      return scm :diff, from unless to
      scm :diff, "#{from}..#{to}"
    end

export(revision, destination) click to toggle source

An expensive export. Performs a checkout as above, then removes the repo.

    # File lib/capistrano/recipes/deploy/scm/git.rb, line 167
    def export(revision, destination)
      checkout(revision, destination) << " && rm -Rf #{destination}/.git"
    end

handle_data(state, stream, text) click to toggle source

Determines what the response should be for a particular bit of text from the SCM. Password prompts, connection requests, passphrases, etc. are handled here.

    # File lib/capistrano/recipes/deploy/scm/git.rb, line 257
    def handle_data(state, stream, text)
      host = state[:channel][:host]
      logger.info "[#{host} :: #{stream}] #{text}"
      case text
      when /\bpassword.*:/
        # git is prompting for a password
        unless pass = variable(:scm_password)
          pass = Capistrano::CLI.password_prompt
        end
        %("#{pass}"\n)
      when %{\(yes/no\)}
        # git is asking whether or not to connect
        "yes\n"
      when /passphrase/
        # 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

head() click to toggle source

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").

    # File lib/capistrano/recipes/deploy/scm/git.rb, line 122
    def head
      variable(:branch) || 'HEAD'
    end

log(from, to=nil) click to toggle source

Returns a log of changes between the two revisions (inclusive).

    # File lib/capistrano/recipes/deploy/scm/git.rb, line 219
    def log(from, to=nil)
      scm :log, "#{from}..#{to}"
    end

origin() click to toggle source

    # File lib/capistrano/recipes/deploy/scm/git.rb, line 126
    def origin
      variable(:remote) || 'origin'
    end

query_revision(revision) click to toggle source

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

    # File lib/capistrano/recipes/deploy/scm/git.rb, line 225
    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

sync(revision, destination) click to toggle source

Merges the changes to 'head' since the last fetch, for remote_cache deployment strategy

    # File lib/capistrano/recipes/deploy/scm/git.rb, line 173
    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 << %(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

[Validate]

Generated with the Darkfish Rdoc Generator 2.