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

Class | Capistrano::Deploy::SCM::Git
In: | lib/capistrano/recipes/deploy/scm/git.rb
Parent: | Base

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

### Methods

checkout command diff export handle_data head log origin query_revision sync

### Public Instance methods

checkout(revision, destination)

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

command()
diff(from, to=nil)

Returns a string of diffs between two revisions

export(revision, destination)

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

handle_data(state, stream, text)

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

head()

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

log(from, to=nil)

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

origin()
query_revision(revision) {|command| ...}

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

sync(revision, destination)

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

[Validate]