Page MenuHomeSoftware Heritage
Files F9338101

No OneTemporary
Actions

View Options

diff --git a/README.markdown b/README.markdown
index e878891..ffc2d7e 100644
--- a/README.markdown
+++ b/README.markdown
@@ -1,748 +1,758 @@
#vcsrepo
####Table of Contents
1. [Overview](#overview)
2. [Module Description - What the module does and why it is useful](#module-description)
3. [Setup - The basics of getting started with vcsrepo](#setup)
* [Setup requirements](#setup-requirements)
* [Beginning with vcsrepo](#beginning-with-vcsrepo)
4. [Usage - Configuration options and additional functionality](#usage)
* [Git](#git)
* [Bazaar](#bazaar)
* [CVS](#cvs)
* [Mercurial](#mercurial)
* [Perforce](#perforce)
* [Subversion](#subversion)
5. [Reference - An under-the-hood peek at what the module is doing and how](#reference)
* [Type: vcsrepo](#type-vcsrepo)
* [Providers](#providers)
* [Features](#features)
* [Parameters](#parameters)
5. [Limitations - OS compatibility, etc.](#limitations)
6. [Development - Guide for contributing to the module](#development)
##Overview
The vcsrepo module lets you use Puppet to easily deploy content from your version control system (VCS).
##Module Description
The vcsrepo module provides a single type with providers to support the following version control systems:
* [Git](#git)
* [Bazaar](#bazaar)
* [CVS](#cvs)
* [Mercurial](#mercurial)
* [Perforce](#perforce)
* [Subversion](#subversion)
**Note:** `git` is the only vcs provider officially [supported by Puppet Labs](https://forge.puppetlabs.com/supported).
##Setup
###Setup Requirements
The `vcsrepo` module does not install any VCS software for you. You must install a VCS before you can use this module.
Like Puppet in general, the `vcsrepo` module does not automatically create parent directories for the files it manages. Make sure to set up any needed directory structures before you get started.
###Beginning with vcsrepo
To create and manage a blank repository, define the type `vcsrepo` with a path to your repository and supply the `provider` parameter based on the [VCS you're using](#usage).
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => git,
}
~~~
##Usage
**Note:** `git` is the only vcsrepo provider officially [supported by Puppet Labs](https://forge.puppetlabs.com/supported).
###Git
####Create a blank repository
To create a blank repository, suitable for use as a central repository, define `vcsrepo` without `source` or `revision`:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => git,
}
~~~
If you're managing a central or official repository, you might want to make it a bare repository. To do this, set `ensure` to 'bare':
~~~
vcsrepo { '/path/to/repo':
ensure => bare,
provider => git,
}
~~~
####Clone/pull a repository
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => git,
source => 'git://example.com/repo.git',
}
~~~
+If you want to clone your repository as bare or mirror, you can set `ensure` to 'bare' or 'mirror':
+
+~~~
+vcsrepo { '/path/to/repo':
+ ensure => mirror,
+ provider => git,
+ source => 'git://example.com/repo.git',
+}
+~~~
+
By default, `vcsrepo` will use the HEAD of the source repository's master branch. To use another branch or a specific commit, set `revision` to either a branch name or a commit SHA or tag.
Branch name:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => git,
source => 'git://example.com/repo.git',
revision => 'development',
}
~~~
SHA:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => git,
source => 'git://example.com/repo.git',
revision => '0c466b8a5a45f6cd7de82c08df2fb4ce1e920a31',
}
~~~
Tag:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => git,
source => 'git://example.com/repo.git',
revision => '1.1.2rc1',
}
~~~
To check out a branch as a specific user, supply the `user` parameter:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => git,
source => 'git://example.com/repo.git',
revision => '0c466b8a5a45f6cd7de82c08df2fb4ce1e920a31',
user => 'someUser',
}
~~~
To keep the repository at the latest revision, set `ensure` to 'latest'.
**WARNING:** this overwrites any local changes to the repository:
~~~
vcsrepo { '/path/to/repo':
ensure => latest,
provider => git,
source => 'git://example.com/repo.git',
revision => 'master',
}
~~~
To clone the repository but skip initializing submodules, set `submodules` to 'false':
~~~
vcsrepo { '/path/to/repo':
ensure => latest,
provider => git,
source => 'git://example.com/repo.git',
submodules => false,
}
~~~
####Use multiple remotes with a repository
In place of a single string, you can set `source` to a hash of one or more name => URL pairs:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => git,
remote => 'origin'
source => {
'origin' => 'https://github.com/puppetlabs/puppetlabs-vcsrepo.git',
'other_remote' => 'https://github.com/other_user/puppetlabs-vcsrepo.git'
},
}
~~~
**Note:** if you set `source` to a hash, one of the names you specify must match the value of the `remote` parameter. That remote serves as the upstream of your managed repository.
####Connect via SSH
To connect to your source repository via SSH (e.g., 'username@server:…'), we recommend managing your SSH keys with Puppet and using the [`require`](http://docs.puppetlabs.com/references/stable/metaparameter.html#require) metaparameter to make sure they are present before the `vcsrepo` resource is applied.
To use SSH keys associated with a user, specify the username in the `user` parameter:
~~~
vcsrepo { '/path/to/repo':
ensure => latest,
provider => git,
source => 'git://username@example.com/repo.git',
user => 'toto', #uses toto's $HOME/.ssh setup
require => File['/home/toto/.ssh/id_rsa'],
}
~~~
###Bazaar
####Create a blank repository
To create a blank repository, suitable for use as a central repository, define `vcsrepo` without `source` or `revision`:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => bzr,
}
~~~
####Branch from an existing repository
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => bzr,
source => '/some/path',
}
~~~
To branch from a specific revision, set `revision` to a valid [Bazaar revision spec](http://wiki.bazaar.canonical.com/BzrRevisionSpec):
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => bzr,
source => '/some/path',
revision => 'menesis@pov.lt-20100309191856-4wmfqzc803fj300x',
}
~~~
####Connect via SSH
To connect to your source repository via SSH (e.g., `'bzr+ssh://...'` or `'sftp://...,'`), we recommend using the [`require`](http://docs.puppetlabs.com/references/stable/metaparameter.html#require) metaparameter to make sure your SSH keys are present before the `vcsrepo` resource is applied:
~~~
vcsrepo { '/path/to/repo':
ensure => latest,
provider => bzr,
source => 'bzr+ssh://bzr.example.com/some/path',
user => 'toto', #uses toto's $HOME/.ssh setup
require => File['/home/toto/.ssh/id_rsa'],
}
~~~
###CVS
####Create a blank repository
To create a blank repository, suitable for use as a central repository, define `vcsrepo` without `source` or `revision`:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => cvs,
}
~~~
####Checkout/update from a repository
~~~
vcsrepo { '/path/to/workspace':
ensure => present,
provider => cvs,
source => ':pserver:anonymous@example.com:/sources/myproj',
}
~~~
To get a specific module on the current mainline, supply the `module` parameter:
~~~
vcsrepo {'/vagrant/lockss-daemon-source':
ensure => present,
provider => cvs,
source => ':pserver:anonymous@lockss.cvs.sourceforge.net:/cvsroot/lockss',
module => 'lockss-daemon',
}
~~~
To set the GZIP compression levels for your repository history, use the `compression` parameter:
~~~
vcsrepo { '/path/to/workspace':
ensure => present,
provider => cvs,
compression => 3,
source => ':pserver:anonymous@example.com:/sources/myproj',
}
~~~
To get a specific revision, set `revision` to the revision number.
~~~
vcsrepo { '/path/to/workspace':
ensure => present,
provider => cvs,
compression => 3,
source => ':pserver:anonymous@example.com:/sources/myproj',
revision => '1.2',
}
~~~
You can also set `revision` to a tag:
~~~
vcsrepo { '/path/to/workspace':
ensure => present,
provider => cvs,
compression => 3,
source => ':pserver:anonymous@example.com:/sources/myproj',
revision => 'SOMETAG',
}
~~~
####Connect via SSH
To connect to your source repository via SSH, we recommend using the [`require`](http://docs.puppetlabs.com/references/stable/metaparameter.html#require) metaparameter to make sure your SSH keys are present before the `vcsrepo` resource is applied:
~~~
vcsrepo { '/path/to/repo':
ensure => latest,
provider => cvs,
source => ':pserver:anonymous@example.com:/sources/myproj',
user => 'toto', #uses toto's $HOME/.ssh setup
require => File['/home/toto/.ssh/id_rsa'],
}
~~~
###Mercurial
####Create a blank repository
To create a blank repository, suitable for use as a central repository, define `vcsrepo` without `source` or `revision`:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => hg,
}
~~~
####Clone/pull & update a repository
To get the default branch tip:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => hg,
source => 'http://hg.example.com/myrepo',
}
~~~
For a specific changeset, use `revision`:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => hg,
source => 'http://hg.example.com/myrepo',
revision => '21ea4598c962',
}
~~~
You can also set `revision` to a tag:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => hg,
source => 'http://hg.example.com/myrepo',
revision => '1.1.2',
}
~~~
To check out as a specific user:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => hg,
source => 'http://hg.example.com/myrepo',
user => 'user',
}
~~~
To specify an SSH identity key:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => hg,
source => 'ssh://hg@hg.example.com/myrepo',
identity => '/home/user/.ssh/id_dsa1,
}
~~~
To specify a username and password for HTTP Basic authentication:
~~~
vcsrepo { '/path/to/repo':
ensure => latest,
provider => hg,
source => 'http://hg.example.com/myrepo',
basic_auth_username => 'hgusername',
basic_auth_password => 'hgpassword',
}
~~~
####Connect via SSH
To connect to your source repository via SSH (e.g., `'ssh://...'`), we recommend using the [`require` metaparameter](http://docs.puppetlabs.com/references/stable/metaparameter.html#require) to make sure your SSH keys are present before the `vcsrepo` resource is applied:
~~~
vcsrepo { '/path/to/repo':
ensure => latest,
provider => hg,
source => 'ssh://hg.example.com//path/to/myrepo',
user => 'toto', #uses toto's $HOME/.ssh setup
require => File['/home/toto/.ssh/id_rsa'],
}
~~~
###Perforce
####Create an empty workspace
To set up the connection to your Perforce service, set `p4config` to the location of a valid Perforce [config file](http://www.perforce.com/perforce/doc.current/manuals/p4guide/chapter.configuration.html#configuration.settings.configfiles) stored on the node:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => p4,
p4config => '/root/.p4config'
}
~~~
**Note:** If you don't include the `P4CLIENT` setting in your config file, the provider generates a workspace name based on the digest of `path` and the node's hostname (e.g., `puppet-91bc00640c4e5a17787286acbe2c021c`):
####Create/update and sync a Perforce workspace
To sync a depot path to head, set `ensure` to 'latest':
~~~
vcsrepo { '/path/to/repo':
ensure => latest,
provider => p4,
source => '//depot/branch/...'
}
~~~
To sync to a specific changelist, specify its revision number with the `revision` parameter:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => p4,
source => '//depot/branch/...',
revision => '2341'
}
~~~
You can also set `revision` to a label:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => p4,
source => '//depot/branch/...',
revision => 'my_label'
}
~~~
###Subversion
####Create a blank repository
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => svn,
}
~~~
####Check out from an existing repository
Provide a `source` pointing to the branch or tag you want to check out:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => svn,
source => 'svn://svnrepo/hello/branches/foo',
}
~~~
You can also designate a specific revision:
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => svn,
source => 'svn://svnrepo/hello/branches/foo',
revision => '1234',
}
~~~
####Use a specific Subversion configuration directory
Use the `configuration` parameter to designate the directory that contains your Subversion configuration files (typically, '/path/to/.subversion'):
~~~
vcsrepo { '/path/to/repo':
ensure => present,
provider => svn,
source => 'svn://svnrepo/hello/branches/foo',
configuration => '/path/to/.subversion',
}
~~~
####Connect via SSH
To connect to your source repository via SSH (e.g., `'svn+ssh://...'`), we recommend using the [`require` metaparameter](http://docs.puppetlabs.com/references/stable/metaparameter.html#require) to make sure your SSH keys are present before the `vcsrepo` resource is applied:
~~~
vcsrepo { '/path/to/repo':
ensure => latest,
provider => svn,
source => 'svn+ssh://svnrepo/hello/branches/foo',
user => 'toto', #uses toto's $HOME/.ssh setup
require => File['/home/toto/.ssh/id_rsa'],
}
~~~
##Reference
###Type: vcsrepo
The vcsrepo module adds only one type with several providers. Each provider abstracts a different VCS, and each provider includes a set of features according to its needs.
####Providers
**Note:** Not all features are available with all providers.
#####`git` - Supports the Git VCS.
Features: `bare_repositories`, `depth`, `multiple_remotes`, `reference_tracking`, `ssh_identity`, `submodules`, `user`
Parameters: `depth`, `ensure`, `excludes`, `force`, `group`, `identity`, `owner`, `path`, `provider`, `remote`, `revision`, `source`, `user`
#####`bzr` - Supports the Bazaar VCS.
Features: `reference_tracking`
Parameters: `ensure`, `excludes`, `force`, `group`, `owner`, `path`, `provider`, `revision`, `source`
#####`cvs` - Supports the CVS VCS.
Features: `cvs_rsh`, `gzip_compression`, `modules`, `reference_tracking`, `user`
Parameters: `compression`, `cvs_rsh`, `ensure`, `excludes`, `force`, `group`, `module`, `owner`, `path`, `provider`
#####`hg` - Supports the Mercurial VCS.
Features: `reference_tracking`, `ssh_identity`, `user`
Parameters: `ensure`, `excludes`, `force`, `group`, `identity`, `owner`, `path`, `provider`, `revision`, `source`, `user`
#####`p4` - Supports the Perforce VCS.
Features: `p4config`, `reference_tracking`
Parameters: `ensure`, `excludes`, `force`, `group`, `owner`, `p4config`, `path`, `provider`, `revision`, `source`
#####`svn` - Supports the Subversion VCS.
Features: `basic_auth`, `configuration`, `conflict`, `depth`, `filesystem_types`, `reference_tracking`
Parameters: `basic_auth_password`, `basic_auth_username`, `configuration`, `conflict`, `ensure`, `excludes`, `force`, `fstype`, `group`, `owner`, `path`, `provider`, `revision`, `source`, `trust_server_cert`
####Features
**Note:** Not all features are available with all providers.
* `bare_repositories` - Differentiates between bare repositories and those with working copies. (Available with `git`.)
* `basic_auth` - Supports HTTP Basic authentication. (Available with `svn`.)
* `conflict` - Lets you decide how to resolve any conflicts between the source repository and your working copy. (Available with `svn`.)
* `configuration` - Lets you specify the location of your configuration files. (Available with `svn`.)
* `cvs_rsh` - Understands the `CVS_RSH` environment variable. (Available with `cvs`.)
* `depth` - Supports shallow clones in `git` or sets scope limit in `svn`. (Available with `git` and `svn`.)
* `filesystem_types` - Supports multiple types of filesystem. (Available with `svn`.)
* `gzip_compression` - Supports explicit GZip compression levels. (Available with `cvs`.)
* `modules` - Lets you choose a specific repository module. (Available with `cvs`.)
* `multiple_remotes` - Tracks multiple remote repositories. (Available with `git`.)
* `reference_tracking` - Lets you track revision references that can change over time (e.g., some VCS tags and branch names). (Available with all providers)
* `ssh_identity` - Lets you specify an SSH identity file. (Available with `git` and `hg`.)
* `user` - Can run as a different user. (Available with `git`, `hg` and `cvs`.)
* `p4config` - Supports setting the `P4CONFIG` environment. (Available with `p4`.)
* `submodules` - Supports repository submodules which can be optionally initialized. (Available with `git`.)
####Parameters
All parameters are optional, except where specified otherwise.
##### `basic_auth_password`
Specifies the password for HTTP Basic authentication. (Requires the `basic_auth` feature.) Valid options: a string. Default: none.
##### `basic_auth_username`
Specifies the username for HTTP Basic authentication. (Requires the `basic_auth` feature.) Valid options: a string. Default: none.
##### `compression`
Sets the GZIP compression level for the repository history. (Requires the `gzip_compression` feature.) Valid options: an integer between 0 and 6. Default: none.
##### `configuration`
Sets the configuration directory to use. (Requires the `configuration` feature.) Valid options: a string containing an absolute path. Default: none.
##### `conflict`
Tells Subversion how to resolve any conflicts between the source repository and your working copy. (Requires the `conflict` feature.) Valid options: 'base', 'mine-full', 'theirs-full', and 'working'. Default: none.
##### `cvs_rsh`
Provides a value for the `CVS_RSH` environment variable. (Requires the `cvs_rsh` feature.) Valid options: a string. Default: none.
##### `depth`
In `git` sets the number of commits to include when creating a shallow clone. (Requires the `depth` feature.) Valid options: an integer. Default: none.
In `svn` instructs Subversion to limit the scope of an operation to a particular tree depth. (Requires the `depth` feature.) Valid options: 'empty', 'files', 'immediates', 'infinity'. Default: none.
##### `ensure`
Specifies whether the repository should exist. Valid options: 'present', 'bare', 'absent', and 'latest'. Default: 'present'.
##### `excludes`
Lists any files the repository shouldn't track (similar to .gitignore). Valid options: a string (separate multiple values with the newline character). Default: none.
##### `force`
Specifies whether to delete any existing files in the repository path if creating a new repository. **Use with care.** Valid options: 'true' and 'false'. Default: 'false'.
##### `fstype`
Sets the filesystem type. (Requires the `filesystem_types` feature.) Valid options: 'fsfs' or 'bdb'. Default: none.
##### `group`
Specifies a group to own the repository files. Valid options: a string containing a group name or GID. Default: none.
##### `identity`
Specifies an identity file to use for SSH authentication. (Requires the `ssh_identity` feature.) Valid options: a string containing an absolute path. Default: none.
##### `module`
Specifies the repository module to manage. (Requires the `modules` feature.) Valid options: a string containing the name of a CVS module. Default: none.
##### `owner`
Specifies a user to own the repository files. Valid options: a string containing a username or UID. Default: none.
##### `p4config`
Specifies a config file that contains settings for connecting to the Perforce service. (Requires the `p4config` feature.) Valid options: a string containing the absolute path to a valid [Perforce config file](http://www.perforce.com/perforce/doc.current/manuals/p4guide/chapter.configuration.html#configuration.settings.configfiles). Default: none.
##### `path`
Specifies a location for the managed repository. Valid options: a string containing an absolute path. Default: the title of your declared resource.
##### `provider`
*Required.* Specifies the backend to use for this vcsrepo resource. Valid options: 'bzr', 'cvs', 'git', 'hg', 'p4', and 'svn'.
##### `remote`
Specifies the remote repository to track. (Requires the `multiple_remotes` feature.) Valid options: a string containing one of the remote names specified in `source`. Default: 'origin'.
##### `revision`
Sets the revision of the repository. Valid options vary by provider:
* `git` - a string containing a Git branch name, or a commit SHA or tag
* `bzr` - a string containing a Bazaar [revision spec](http://wiki.bazaar.canonical.com/BzrRevisionSpec)
* `cvs` - a string containing a CVS [tag or revision number](http://www.thathost.com/wincvs-howto/cvsdoc/cvs_4.html)
* `hg` - a string containing a Mercurial [changeset ID](http://mercurial.selenic.com/wiki/ChangeSetID) or [tag](http://mercurial.selenic.com/wiki/Tag)
* `p4` - a string containing a Perforce [change number, label name, client name, or date spec](http://www.perforce.com/perforce/r12.1/manuals/cmdref/o.fspecs.html)
* `svn` - a string containing a Subversion [revision number](http://svnbook.red-bean.com/en/1.7/svn.basic.in-action.html#svn.basic.in-action.revs), [revision keyword, or revision date](http://svnbook.red-bean.com/en/1.7/svn.tour.revs.specifiers.html)
Default: none.
##### `source`
Specifies a source repository to serve as the upstream for your managed repository. Default: none. Valid options vary by provider:
* `git` - a string containing a [Git repository URL](https://www.kernel.org/pub/software/scm/git/docs/git-clone.html#_git_urls_a_id_urls_a) or a hash of name => URL mappings. See also [`remote`](#remote).
* `bzr` - a string containing a Bazaar branch location
* `cvs` - a string containing a CVS root
* `hg` - a string containing the local path or URL of a Mercurial repository
* `p4` - a string containing a Perforce depot path
* `svn` - a string containing a Subversion repository URL
Default: none.
##### `submodules`
Specifies whether to initialize and update each submodule in the repository. (Requires the `submodules` feature.) Valid options: 'true' and 'false'. Default: 'true'.
##### `trust_server_cert`
Instructs Subversion to accept SSL server certificates issued by unknown certificate authorities. Valid options: 'true' and 'false'. Default: 'false'.
##### `user`
Specifies the user to run as for repository operations. (Requires the `user` feature.) Valid options: a string containing a username or UID. Default: none.
##Limitations
Git is the only VCS provider officially [supported](https://forge.puppetlabs.com/supported) by Puppet Labs.
This module has been tested with Puppet 2.7 and higher.
The module has been tested on:
* CentOS 5/6/7
* Debian 6/7
* Oracle 5/6/7
* Red Hat Enterprise Linux 5/6/7
* Scientific Linux 5/6/7
* SLES 10/11/12
* Ubuntu 10.04/12.04/14.04
Testing on other platforms has been light and cannot be guaranteed.
##Development
Puppet Labs modules on the Puppet Forge are open projects, and community contributions are essential for keeping them great. We can't access the huge number of platforms and myriad of hardware, software, and deployment configurations that Puppet is intended to serve.
We want to keep it as easy as possible to contribute changes so that our modules work in your environment. There are a few guidelines that we need contributors to follow so that we can have a chance of keeping on top of things.
You can read the complete module contribution guide [on the Puppet Labs wiki.](http://projects.puppetlabs.com/projects/module-site/wiki/Module_contributing)
diff --git a/lib/puppet/provider/vcsrepo/git.rb b/lib/puppet/provider/vcsrepo/git.rb
index 0249a3c..63986ab 100644
--- a/lib/puppet/provider/vcsrepo/git.rb
+++ b/lib/puppet/provider/vcsrepo/git.rb
@@ -1,469 +1,480 @@
require File.join(File.dirname(__FILE__), '..', 'vcsrepo')
Puppet::Type.type(:vcsrepo).provide(:git, :parent => Puppet::Provider::Vcsrepo) do
desc "Supports Git repositories"
has_command(:git, 'git') do
environment({ 'HOME' => ENV['HOME'] })
end
has_features :bare_repositories, :reference_tracking, :ssh_identity, :multiple_remotes, :user, :depth, :branch, :submodules
def create
- if @resource.value(:revision) and @resource.value(:ensure) == :bare
+ if @resource.value(:revision) and ensure_bare_or_mirror?
fail("Cannot set a revision (#{@resource.value(:revision)}) on a bare repository")
end
if !@resource.value(:source)
+ if @resource.value(:ensure) == :mirror
+ fail("Cannot init repository with mirror option, try bare instead")
+ end
+
init_repository(@resource.value(:path))
else
clone_repository(default_url, @resource.value(:path))
update_remotes
if @resource.value(:revision)
checkout
end
- if @resource.value(:ensure) != :bare && @resource.value(:submodules) == :true
+ if !ensure_bare_or_mirror? && @resource.value(:submodules) == :true
update_submodules
end
end
update_owner_and_excludes
end
def destroy
FileUtils.rm_rf(@resource.value(:path))
end
# Checks to see if the current revision is equal to the revision on the
# remote (whether on a branch, tag, or reference)
#
# @return [Boolean] Returns true if the repo is on the latest revision
def latest?
return revision == latest_revision
end
# Just gives the `should` value that we should be setting the repo to if
# latest? returns false
#
# @return [String] Returns the target sha/tag/branch
def latest
if not @resource.value(:revision) and branch = on_branch?
return branch
else
return @resource.value(:revision)
end
end
# Get the current revision of the repo (tag/branch/sha)
#
# @return [String] Returns the branch/tag if the current sha matches the
# remote; otherwise returns the current sha.
def revision
#HEAD is the default, but lets just be explicit here.
get_revision('HEAD')
end
# Is passed the desired reference, whether a tag, rev, or branch. Should
# handle transitions from a rev/branch/tag to a rev/branch/tag. Detached
# heads should be treated like bare revisions.
#
# @param [String] desired The desired revision to which the repo should be
# set.
def revision=(desired)
#just checkout tags and shas; fetch has already happened so they should be updated.
checkout(desired)
#branches require more work.
if local_branch_revision?(desired)
#reset instead of pull to avoid merge conflicts. assuming remote is
#updated and authoritative.
#TODO might be worthwhile to have an allow_local_changes param to decide
#whether to reset or pull when we're ensuring latest.
if @resource.value(:source)
at_path { git_with_identity('reset', '--hard', "#{@resource.value(:remote)}/#{desired}") }
else
at_path { git_with_identity('reset', '--hard', "#{desired}") }
end
end
#TODO Would this ever reach here if it is bare?
- if @resource.value(:ensure) != :bare && @resource.value(:submodules) == :true
+ if !ensure_bare_or_mirror? && @resource.value(:submodules) == :true
update_submodules
end
update_owner_and_excludes
end
def bare_exists?
bare_git_config_exists? && !working_copy_exists?
end
+ def ensure_bare_or_mirror?
+ [:bare, :mirror].include? @resource.value(:ensure)
+ end
+
# If :source is set to a hash (for supporting multiple remotes),
# we search for the URL for :remote. If it doesn't exist,
# we throw an error. If :source is just a string, we use that
# value for the default URL.
def default_url
if @resource.value(:source).is_a?(Hash)
if @resource.value(:source).has_key?(@resource.value(:remote))
@resource.value(:source)[@resource.value(:remote)]
else
fail("You must specify the URL for #{@resource.value(:remote)} in the :source hash")
end
else
@resource.value(:source)
end
end
def working_copy_exists?
if @resource.value(:source) and File.exists?(File.join(@resource.value(:path), '.git', 'config'))
File.readlines(File.join(@resource.value(:path), '.git', 'config')).grep(/#{Regexp.escape(default_url)}/).any?
else
File.directory?(File.join(@resource.value(:path), '.git'))
end
end
def exists?
working_copy_exists? || bare_exists?
end
def update_remote_url(remote_name, remote_url)
do_update = false
current = git_with_identity('config', '-l')
unless remote_url.nil?
# Check if remote exists at all, regardless of URL.
# If remote doesn't exist, add it
if not current.include? "remote.#{remote_name}.url"
git_with_identity('remote','add', remote_name, remote_url)
return true
# If remote exists, but URL doesn't match, update URL
elsif not current.include? "remote.#{remote_name}.url=#{remote_url}"
git_with_identity('remote','set-url', remote_name, remote_url)
return true
else
return false
end
end
end
def update_remotes
do_update = false
# If supplied source is a hash of remote name and remote url pairs, then
# we loop around the hash. Otherwise, we assume single url specified
# in source property
if @resource.value(:source).is_a?(Hash)
@resource.value(:source).keys.sort.each do |remote_name|
remote_url = @resource.value(:source)[remote_name]
at_path { do_update |= update_remote_url(remote_name, remote_url) }
end
else
at_path { do_update |= update_remote_url(@resource.value(:remote), @resource.value(:source)) }
end
# If at least one remote was added or updated, then we must
# call the 'git remote update' command
if do_update == true
at_path { git_with_identity('remote','update') }
end
end
def update_references
at_path do
update_remotes
git_with_identity('fetch', @resource.value(:remote))
git_with_identity('fetch', '--tags', @resource.value(:remote))
update_owner_and_excludes
end
end
private
# @!visibility private
def bare_git_config_exists?
File.exist?(File.join(@resource.value(:path), 'config'))
end
# @!visibility private
def clone_repository(source, path)
check_force
args = ['clone']
if @resource.value(:depth) and @resource.value(:depth).to_i > 0
args.push('--depth', @resource.value(:depth).to_s)
if @resource.value(:revision)
args.push('--branch', @resource.value(:revision).to_s)
end
end
if @resource.value(:branch)
args.push('--branch', @resource.value(:branch).to_s)
end
- if @resource.value(:ensure) == :bare
- args << '--bare'
+
+ case @resource.value(:ensure)
+ when :bare then args << '--bare'
+ when :mirror then args << '--mirror'
end
+
if @resource.value(:remote) != 'origin'
args.push('--origin', @resource.value(:remote))
end
if !working_copy_exists?
args.push(source, path)
Dir.chdir("/") do
git_with_identity(*args)
end
else
notice "Repo has already been cloned"
end
end
# @!visibility private
def check_force
if path_exists? and not path_empty?
if @resource.value(:force)
notice "Removing %s to replace with vcsrepo." % @resource.value(:path)
destroy
else
raise Puppet::Error, "Could not create repository (non-repository at path)"
end
end
end
# @!visibility private
def init_repository(path)
check_force
if @resource.value(:ensure) == :bare && working_copy_exists?
convert_working_copy_to_bare
elsif @resource.value(:ensure) == :present && bare_exists?
convert_bare_to_working_copy
else
# normal init
FileUtils.mkdir(@resource.value(:path))
FileUtils.chown(@resource.value(:user), nil, @resource.value(:path)) if @resource.value(:user)
args = ['init']
if @resource.value(:ensure) == :bare
args << '--bare'
end
at_path do
git_with_identity(*args)
end
end
end
# Convert working copy to bare
#
# Moves:
# <path>/.git
# to:
# <path>/
# @!visibility private
def convert_working_copy_to_bare
notice "Converting working copy repository to bare repository"
FileUtils.mv(File.join(@resource.value(:path), '.git'), tempdir)
FileUtils.rm_rf(@resource.value(:path))
FileUtils.mv(tempdir, @resource.value(:path))
end
# Convert bare to working copy
#
# Moves:
# <path>/
# to:
# <path>/.git
# @!visibility private
def convert_bare_to_working_copy
notice "Converting bare repository to working copy repository"
FileUtils.mv(@resource.value(:path), tempdir)
FileUtils.mkdir(@resource.value(:path))
FileUtils.mv(tempdir, File.join(@resource.value(:path), '.git'))
if commits_in?(File.join(@resource.value(:path), '.git'))
reset('HEAD')
git_with_identity('checkout', '--force')
update_owner_and_excludes
end
end
# @!visibility private
def commits_in?(dot_git)
Dir.glob(File.join(dot_git, 'objects/info/*'), File::FNM_DOTMATCH) do |e|
return true unless %w(. ..).include?(File::basename(e))
end
false
end
# Will checkout a rev/branch/tag using the locally cached versions. Does not
# handle upstream branch changes
# @!visibility private
def checkout(revision = @resource.value(:revision))
if !local_branch_revision?(revision) && remote_branch_revision?(revision)
#non-locally existant branches (perhaps switching to a branch that has never been checked out)
at_path { git_with_identity('checkout', '--force', '-b', revision, '--track', "#{@resource.value(:remote)}/#{revision}") }
else
#tags, locally existant branches (perhaps outdated), and shas
at_path { git_with_identity('checkout', '--force', revision) }
end
end
# @!visibility private
def reset(desired)
at_path do
git_with_identity('reset', '--hard', desired)
end
end
# @!visibility private
def update_submodules
at_path do
git_with_identity('submodule', 'update', '--init', '--recursive')
end
end
# Determins if the branch exists at the upstream but has not yet been locally committed
# @!visibility private
def remote_branch_revision?(revision = @resource.value(:revision))
# git < 1.6 returns '#{@resource.value(:remote)}/#{revision}'
# git 1.6+ returns 'remotes/#{@resource.value(:remote)}/#{revision}'
branch = at_path { branches.grep /(remotes\/)?#{@resource.value(:remote)}\/#{revision}$/ }
branch unless branch.empty?
end
# Determins if the branch is already cached locally
# @!visibility private
def local_branch_revision?(revision = @resource.value(:revision))
at_path { branches.include?(revision) }
end
# @!visibility private
def tag_revision?(revision = @resource.value(:revision))
at_path { tags.include?(revision) }
end
# @!visibility private
def branches
at_path { git_with_identity('branch', '-a') }.gsub('*', ' ').split(/\n/).map { |line| line.strip }
end
# git < 2.4 returns 'detached from'
# git 2.4+ returns 'HEAD detached at'
# @!visibility private
def on_branch?
at_path {
matches = git_with_identity('branch', '-a').match /\*\s+(.*)/
matches[1] unless matches[1].match /(\(detached from|\(HEAD detached at|\(no branch)/
}
end
# @!visibility private
def tags
at_path { git_with_identity('tag', '-l') }.split(/\n/).map { |line| line.strip }
end
# @!visibility private
def set_excludes
# Excludes may be an Array or a String.
at_path do
open('.git/info/exclude', 'w') do |f|
if @resource.value(:excludes).respond_to?(:each)
@resource.value(:excludes).each { |ex| f.puts ex }
else
f.puts @resource.value(:excludes)
end
end
end
end
# Finds the latest revision or sha of the current branch if on a branch, or
# of HEAD otherwise.
# @note Calls create which can forcibly destroy and re-clone the repo if
# force => true
# @see get_revision
#
# @!visibility private
# @return [String] Returns the output of get_revision
def latest_revision
#TODO Why is create called here anyway?
create if @resource.value(:force) && working_copy_exists?
create if !working_copy_exists?
if branch = on_branch?
return get_revision("#{@resource.value(:remote)}/#{branch}")
else
return get_revision
end
end
# Returns the current revision given if the revision is a tag or branch and
# matches the current sha. If the current sha does not match the sha of a tag
# or branch, then it will just return the sha (ie, is not in sync)
#
# @!visibility private
#
# @param [String] rev The revision of which to check if it is current
# @return [String] Returns the tag/branch of the current repo if it's up to
# date; otherwise returns the sha of the requested revision.
def get_revision(rev = 'HEAD')
if @resource.value(:source)
update_references
else
status = at_path { git_with_identity('status')}
is_it_new = status =~ /Initial commit/
if is_it_new
status =~ /On branch (.*)/
branch = $1
return branch
end
end
current = at_path { git_with_identity('rev-parse', rev).strip }
if @resource.value(:revision)
if tag_revision?
# git-rev-parse will give you the hash of the tag object itself rather
# than the commit it points to by default. Using tag^0 will return the
# actual commit.
canonical = at_path { git_with_identity('rev-parse', "#{@resource.value(:revision)}^0").strip }
elsif local_branch_revision?
canonical = at_path { git_with_identity('rev-parse', @resource.value(:revision)).strip }
elsif remote_branch_revision?
canonical = at_path { git_with_identity('rev-parse', "#{@resource.value(:remote)}/#{@resource.value(:revision)}").strip }
else
#look for a sha (could match invalid shas)
canonical = at_path { git_with_identity('rev-parse', '--revs-only', @resource.value(:revision)).strip }
end
fail("#{@resource.value(:revision)} is not a local or remote ref") if canonical.nil? or canonical.empty?
current = @resource.value(:revision) if current == canonical
end
return current
end
# @!visibility private
def update_owner_and_excludes
if @resource.value(:owner) or @resource.value(:group)
set_ownership
end
if @resource.value(:excludes)
set_excludes
end
end
# @!visibility private
def git_with_identity(*args)
if @resource.value(:identity)
Tempfile.open('git-helper', Puppet[:statedir]) do |f|
f.puts '#!/bin/sh'
f.puts 'export SSH_AUTH_SOCKET='
f.puts "exec ssh -oStrictHostKeyChecking=no -oPasswordAuthentication=no -oKbdInteractiveAuthentication=no -oChallengeResponseAuthentication=no -oConnectTimeout=120 -i #{@resource.value(:identity)} $*"
f.close
FileUtils.chmod(0755, f.path)
env_save = ENV['GIT_SSH']
ENV['GIT_SSH'] = f.path
ret = git(*args)
ENV['GIT_SSH'] = env_save
return ret
end
elsif @resource.value(:user) and @resource.value(:user) != Facter['id'].value
env = Etc.getpwnam(@resource.value(:user))
Puppet::Util::Execution.execute("git #{args.join(' ')}", :uid => @resource.value(:user), :failonfail => true, :custom_environment => {'HOME' => env['dir']})
else
git(*args)
end
end
end
diff --git a/lib/puppet/type/vcsrepo.rb b/lib/puppet/type/vcsrepo.rb
index 290bdad..e2ef0b7 100644
--- a/lib/puppet/type/vcsrepo.rb
+++ b/lib/puppet/type/vcsrepo.rb
@@ -1,240 +1,248 @@
require 'pathname'
Puppet::Type.newtype(:vcsrepo) do
desc "A local version control repository"
feature :gzip_compression,
"The provider supports explicit GZip compression levels"
feature :basic_auth,
"The provider supports HTTP Basic Authentication"
feature :bare_repositories,
"The provider differentiates between bare repositories
and those with working copies",
:methods => [:bare_exists?, :working_copy_exists?]
feature :filesystem_types,
"The provider supports different filesystem types"
feature :reference_tracking,
"The provider supports tracking revision references that can change
over time (eg, some VCS tags and branch names)"
feature :ssh_identity,
"The provider supports a configurable SSH identity file"
feature :user,
"The provider can run as a different user"
feature :modules,
"The repository contains modules that can be chosen of"
feature :multiple_remotes,
"The repository tracks multiple remote repositories"
feature :configuration,
"The configuration directory to use"
feature :cvs_rsh,
"The provider understands the CVS_RSH environment variable"
feature :depth,
"The provider can do shallow clones or set scope limit"
feature :branch,
"The name of the branch"
feature :p4config,
"The provider understands Perforce Configuration"
feature :submodules,
"The repository contains submodules which can be optionally initialized"
feature :conflict,
"The provider supports automatic conflict resolution"
ensurable do
attr_accessor :latest
def insync?(is)
@should ||= []
case should
when :present
return true unless [:absent, :purged, :held].include?(is)
when :latest
if is == :latest
return true
else
return false
end
when :bare
return is == :bare
+ when :mirror
+ return is == :mirror
end
end
newvalue :present do
notice "Creating repository from present"
provider.create
end
newvalue :bare, :required_features => [:bare_repositories] do
if !provider.exists?
provider.create
end
end
+ newvalue :mirror, :required_features => [:bare_repositories] do
+ if !provider.exists?
+ provider.create
+ end
+ end
+
newvalue :absent do
provider.destroy
end
newvalue :latest, :required_features => [:reference_tracking] do
if provider.exists? && !@resource.value(:force)
if provider.respond_to?(:update_references)
provider.update_references
end
if provider.respond_to?(:latest?)
reference = provider.latest || provider.revision
else
reference = resource.value(:revision) || provider.revision
end
notice "Updating to latest '#{reference}' revision"
provider.revision = reference
else
notice "Creating repository from latest"
provider.create
end
end
def retrieve
prov = @resource.provider
if prov
if prov.working_copy_exists?
(@should.include?(:latest) && prov.latest?) ? :latest : :present
elsif prov.class.feature?(:bare_repositories) and prov.bare_exists?
:bare
else
:absent
end
else
raise Puppet::Error, "Could not find provider"
end
end
end
newparam :path do
desc "Absolute path to repository"
isnamevar
validate do |value|
path = Pathname.new(value)
unless path.absolute?
raise ArgumentError, "Path must be absolute: #{path}"
end
end
end
newparam :source do
desc "The source URI for the repository"
end
newparam :fstype, :required_features => [:filesystem_types] do
desc "Filesystem type"
end
newproperty :revision do
desc "The revision of the repository"
newvalue(/^\S+$/)
end
newparam :owner do
desc "The user/uid that owns the repository files"
end
newparam :group do
desc "The group/gid that owns the repository files"
end
newparam :user do
desc "The user to run for repository operations"
end
newparam :excludes do
desc "Files to be excluded from the repository"
end
newparam :force do
desc "Force repository creation, destroying any files on the path in the process."
newvalues(:true, :false)
defaultto false
end
newparam :compression, :required_features => [:gzip_compression] do
desc "Compression level"
validate do |amount|
unless Integer(amount).between?(0, 6)
raise ArgumentError, "Unsupported compression level: #{amount} (expected 0-6)"
end
end
end
newparam :basic_auth_username, :required_features => [:basic_auth] do
desc "HTTP Basic Auth username"
end
newparam :basic_auth_password, :required_features => [:basic_auth] do
desc "HTTP Basic Auth password"
end
newparam :identity, :required_features => [:ssh_identity] do
desc "SSH identity file"
end
newparam :module, :required_features => [:modules] do
desc "The repository module to manage"
end
newparam :remote, :required_features => [:multiple_remotes] do
desc "The remote repository to track"
defaultto "origin"
end
newparam :configuration, :required_features => [:configuration] do
desc "The configuration directory to use"
end
newparam :cvs_rsh, :required_features => [:cvs_rsh] do
desc "The value to be used for the CVS_RSH environment variable."
end
newparam :depth, :required_features => [:depth] do
desc "The value to be used to do a shallow clone."
end
newparam :branch, :required_features => [:branch] do
desc "The name of the branch to clone."
end
newparam :p4config, :required_features => [:p4config] do
desc "The Perforce P4CONFIG environment."
end
newparam :submodules, :required_features => [:submodules] do
desc "Initialize and update each submodule in the repository."
newvalues(:true, :false)
defaultto true
end
newparam :conflict do
desc "The action to take if conflicts exist between repository and working copy"
end
-
+
newparam :trust_server_cert do
desc "Trust server certificate"
newvalues(:true, :false)
defaultto :false
end
autorequire(:package) do
['git', 'git-core', 'mercurial']
end
end
diff --git a/spec/unit/puppet/provider/vcsrepo/git_spec.rb b/spec/unit/puppet/provider/vcsrepo/git_spec.rb
index 87113fa..6a8f58f 100644
--- a/spec/unit/puppet/provider/vcsrepo/git_spec.rb
+++ b/spec/unit/puppet/provider/vcsrepo/git_spec.rb
@@ -1,375 +1,401 @@
require 'spec_helper'
describe Puppet::Type.type(:vcsrepo).provider(:git_provider) do
def branch_a_list(include_branch = nil?)
<<branches
end
#{"* master" unless include_branch.nil?}
#{"* " + include_branch unless !include_branch}
remote/origin/master
remote/origin/foo
branches
- end
+ end
let(:resource) { Puppet::Type.type(:vcsrepo).new({
:name => 'test',
:ensure => :present,
:provider => :git,
:revision => '2634',
:source => 'git@repo',
:path => '/tmp/test',
:force => false
})}
let(:provider) { resource.provider }
before :each do
Puppet::Util.stubs(:which).with('git').returns('/usr/bin/git')
end
context 'creating' do
context "with a revision that is a remote branch" do
it "should execute 'git clone' and 'git checkout -b'" do
resource[:revision] = 'only/remote'
Dir.expects(:chdir).with('/').at_least_once.yields
Dir.expects(:chdir).with('/tmp/test').at_least_once.yields
provider.expects(:git).with('clone', resource.value(:source), resource.value(:path))
provider.expects(:update_submodules)
provider.expects(:update_remote_url).with("origin", resource.value(:source)).returns false
provider.expects(:git).with('branch', '-a').returns(branch_a_list(resource.value(:revision)))
provider.expects(:git).with('checkout', '--force', resource.value(:revision))
provider.create
end
end
context "with a remote not named 'origin'" do
it "should execute 'git clone --origin not_origin" do
resource[:remote] = 'not_origin'
Dir.expects(:chdir).with('/').at_least_once.yields
Dir.expects(:chdir).with('/tmp/test').at_least_once.yields
provider.expects(:git).with('clone', '--origin', 'not_origin', resource.value(:source), resource.value(:path))
provider.expects(:update_submodules)
provider.expects(:update_remote_url).with("not_origin", resource.value(:source)).returns false
provider.expects(:git).with('branch', '-a').returns(branch_a_list(resource.value(:revision)))
provider.expects(:git).with('checkout', '--force', resource.value(:revision))
provider.create
end
end
context "with shallow clone enable" do
it "should execute 'git clone --depth 1'" do
resource[:revision] = 'only/remote'
resource[:depth] = 1
Dir.expects(:chdir).with('/').at_least_once.yields
Dir.expects(:chdir).with('/tmp/test').at_least_once.yields
provider.expects(:git).with('clone', '--depth', '1', '--branch', resource.value(:revision),resource.value(:source), resource.value(:path))
provider.expects(:update_submodules)
provider.expects(:update_remote_url).with("origin", resource.value(:source)).returns false
provider.expects(:git).with('branch', '-a').returns(branch_a_list(resource.value(:revision)))
provider.expects(:git).with('checkout', '--force', resource.value(:revision))
provider.create
end
end
context "with a revision that is not a remote branch" do
it "should execute 'git clone' and 'git reset --hard'" do
resource[:revision] = 'a-commit-or-tag'
Dir.expects(:chdir).with('/').at_least_once.yields
Dir.expects(:chdir).with('/tmp/test').at_least_once.yields
provider.expects(:git).with('clone', resource.value(:source), resource.value(:path))
provider.expects(:update_submodules)
provider.expects(:update_remote_url).with("origin", resource.value(:source)).returns false
provider.expects(:git).with('branch', '-a').returns(branch_a_list(resource.value(:revision)))
provider.expects(:git).with('checkout', '--force', resource.value(:revision))
provider.create
end
it "should execute 'git clone' and submodule commands" do
resource.delete(:revision)
provider.expects(:git).with('clone', resource.value(:source), resource.value(:path))
provider.expects(:update_submodules)
provider.expects(:update_remotes)
provider.create
end
end
context "with an ensure of bare" do
context "with revision" do
it "should raise an error" do
resource[:ensure] = :bare
expect { provider.create }.to raise_error Puppet::Error, /cannot set a revision.+bare/i
end
end
context "without revision" do
it "should just execute 'git clone --bare'" do
resource[:ensure] = :bare
resource.delete(:revision)
provider.expects(:git).with('clone', '--bare', resource.value(:source), resource.value(:path))
provider.expects(:update_remotes)
provider.create
end
end
end
+ context "with an ensure of mirror" do
+ context "with revision" do
+ it "should raise an error" do
+ resource[:ensure] = :mirror
+ expect { provider.create }.to raise_error Puppet::Error, /cannot set a revision.+bare/i
+ end
+ end
+ context "without revision" do
+ it "should just execute 'git clone --mirror'" do
+ resource[:ensure] = :mirror
+ resource.delete(:revision)
+ provider.expects(:git).with('clone', '--mirror', resource.value(:source), resource.value(:path))
+ provider.expects(:update_remotes)
+ provider.create
+ end
+ end
+ end
+
context "when a source is not given" do
context "when the path does not exist" do
it "should execute 'git init'" do
resource[:ensure] = :present
resource.delete(:source)
expects_mkdir
expects_chdir
expects_directory?(false)
provider.expects(:bare_exists?).returns(false)
provider.expects(:git).with('init')
provider.create
end
end
context "when the path is a bare repository" do
it "should convert it to a working copy" do
resource[:ensure] = :present
resource.delete(:source)
provider.expects(:bare_exists?).returns(true)
provider.expects(:convert_bare_to_working_copy)
provider.create
end
end
context "when the path is not empty and not a repository" do
it "should raise an exception" do
provider.expects(:path_exists?).returns(true)
provider.expects(:path_empty?).returns(false)
expect { provider.create }.to raise_error(Puppet::Error)
end
end
end
context "when the path does not exist" do
it "should execute 'git init --bare'" do
resource[:ensure] = :bare
resource.delete(:source)
resource.delete(:revision)
expects_chdir
expects_mkdir
expects_directory?(false)
provider.expects(:working_copy_exists?).returns(false)
provider.expects(:git).with('init', '--bare')
provider.create
end
+
+ it "should raise an exeption" do
+ resource[:ensure] = :mirror
+ resource.delete(:source)
+ resource.delete(:revision)
+
+ expect { provider.create }.to raise_error Puppet::Error, /cannot init repository with mirror.+try bare/i
+ end
end
context "when the path is a working copy repository" do
it "should convert it to a bare repository" do
resource[:ensure] = :bare
resource.delete(:source)
resource.delete(:revision)
provider.expects(:working_copy_exists?).returns(true)
provider.expects(:convert_working_copy_to_bare)
provider.create
end
it "should clone overtop it using force" do
resource[:force] = true
Dir.expects(:chdir).with('/').at_least_once.yields
Dir.expects(:chdir).with('/tmp/test').at_least_once.yields
provider.expects(:path_exists?).returns(true)
provider.expects(:path_empty?).returns(false)
provider.destroy
provider.expects(:git).with('clone',resource.value(:source), resource.value(:path))
provider.expects(:update_submodules)
provider.expects(:update_remote_url).with("origin", resource.value(:source)).returns false
provider.expects(:git).with('branch', '-a').returns(branch_a_list(resource.value(:revision)))
provider.expects(:git).with('checkout', '--force', resource.value(:revision))
provider.create
end
end
context "when the path is not empty and not a repository" do
it "should raise an exception" do
provider.expects(:path_exists?).returns(true)
provider.expects(:path_empty?).returns(false)
provider.expects(:working_copy_exists?).returns(false)
expect { provider.create }.to raise_error(Puppet::Error)
end
end
end
context 'destroying' do
it "it should remove the directory" do
#expects_rm_rf
provider.destroy
end
end
context "checking the revision property" do
before do
expects_chdir('/tmp/test')
resource[:revision] = 'currentsha'
resource[:source] = 'http://example.com'
provider.stubs(:git).with('config', 'remote.origin.url').returns('')
provider.stubs(:git).with('fetch', 'origin') # FIXME
provider.stubs(:git).with('fetch', '--tags', 'origin')
provider.stubs(:git).with('rev-parse', 'HEAD').returns('currentsha')
provider.stubs(:git).with('branch', '-a').returns(branch_a_list(resource.value(:revision)))
provider.stubs(:git).with('tag', '-l').returns("Hello")
end
context "when its SHA is not different than the current SHA" do
it "should return the ref" do
provider.expects(:git).with('rev-parse', resource.value(:revision)).returns('currentsha')
provider.expects(:update_remotes)
expect(provider.revision).to eq(resource.value(:revision))
end
end
context "when its SHA is different than the current SHA" do
it "should return the current SHA" do
provider.expects(:git).with('rev-parse', resource.value(:revision)).returns('othersha')
provider.expects(:update_remotes)
expect(provider.revision).to eq(resource.value(:revision))
end
end
context "when its a ref to a remote head" do
it "should return the revision" do
provider.stubs(:git).with('branch', '-a').returns(" remotes/origin/#{resource.value(:revision)}")
provider.expects(:git).with('rev-parse', "origin/#{resource.value(:revision)}").returns("newsha")
provider.expects(:update_remotes)
expect(provider.revision).to eq(resource.value(:revision))
end
end
context "when its a ref to non existant remote head" do
it "should fail" do
provider.expects(:git).with('branch', '-a').returns(branch_a_list)
provider.expects(:git).with('rev-parse', '--revs-only', resource.value(:revision)).returns('')
provider.expects(:update_remotes)
expect { provider.revision }.to raise_error(Puppet::Error, /not a local or remote ref$/)
end
end
context "when the source is modified" do
it "should update the origin url" do
resource[:source] = 'git://git@foo.com/bar.git'
provider.expects(:git).with('config', '-l').returns("remote.origin.url=git://git@foo.com/foo.git\n")
provider.expects(:git).with('remote', 'set-url', 'origin', 'git://git@foo.com/bar.git')
provider.expects(:git).with('remote','update')
provider.expects(:git).with('rev-parse', resource.value(:revision)).returns('currentsha')
expect(provider.revision).to eq(resource.value(:revision))
end
end
context "when multiple sources are modified" do
it "should update the urls" do
resource[:source] = {"origin" => "git://git@foo.com/bar.git", "new_remote" => "git://git@foo.com/baz.git"}
provider.expects(:git).at_least_once.with('config', '-l').returns("remote.origin.url=git://git@foo.com/bar.git\n", "remote.origin.url=git://git@foo.com/foo.git\n")
provider.expects(:git).with('remote', 'set-url', 'origin', 'git://git@foo.com/bar.git')
provider.expects(:git).with('remote', 'add', 'new_remote', 'git://git@foo.com/baz.git')
provider.expects(:git).with('remote','update')
provider.expects(:git).with('rev-parse', resource.value(:revision)).returns('currentsha')
expect(provider.revision).to eq(resource.value(:revision))
end
end
context "when there's no source" do
it 'should return the revision' do
resource.delete(:source)
provider.expects(:git).with('status')
provider.expects(:git).with('rev-parse', resource.value(:revision)).returns('currentsha')
expect(provider.revision).to eq(resource.value(:revision))
end
end
end
context "setting the revision property" do
before do
expects_chdir
end
context "when it's an existing local branch" do
it "should use 'git fetch' and 'git reset'" do
resource[:revision] = 'feature/foo'
provider.expects(:update_submodules)
provider.expects(:git).with('branch', '-a').at_least_once.returns(branch_a_list(resource.value(:revision)))
provider.expects(:git).with('checkout', '--force', resource.value(:revision))
provider.expects(:git).with('reset', '--hard', "origin/#{resource.value(:revision)}")
provider.revision = resource.value(:revision)
end
end
context "when it's a remote branch" do
it "should use 'git fetch' and 'git reset'" do
resource[:revision] = 'only/remote'
provider.expects(:update_submodules)
provider.expects(:git).with('branch', '-a').at_least_once.returns(resource.value(:revision))
provider.expects(:git).with('checkout', '--force', resource.value(:revision))
provider.expects(:git).with('reset', '--hard', "origin/#{resource.value(:revision)}")
provider.revision = resource.value(:revision)
end
end
context "when it's a commit or tag" do
it "should use 'git fetch' and 'git reset'" do
resource[:revision] = 'a-commit-or-tag'
provider.expects(:git).with('branch', '-a').at_least_once.returns(fixture(:git_branch_a))
provider.expects(:git).with('checkout', '--force', resource.value(:revision))
provider.expects(:git).with('branch', '-a').returns(fixture(:git_branch_a))
provider.expects(:git).with('branch', '-a').returns(fixture(:git_branch_a))
provider.expects(:git).with('submodule', 'update', '--init', '--recursive')
provider.revision = resource.value(:revision)
end
end
end
context "updating references" do
it "should use 'git fetch --tags'" do
resource.delete(:source)
expects_chdir
provider.expects(:git).with('config', '-l').returns("remote.origin.url=git://git@foo.com/foo.git\n")
provider.expects(:git).with('fetch', 'origin')
provider.expects(:git).with('fetch', '--tags', 'origin')
provider.update_references
end
end
describe 'latest?' do
context 'when true' do
it do
provider.expects(:revision).returns('testrev')
provider.expects(:latest_revision).returns('testrev')
expect(provider.latest?).to be_truthy
end
end
context 'when false' do
it do
provider.expects(:revision).returns('master')
provider.expects(:latest_revision).returns('testrev')
expect(provider.latest?).to be_falsey
end
end
end
describe 'convert_working_copy_to_bare' do
it do
FileUtils.expects(:mv).returns(true)
FileUtils.expects(:rm_rf).returns(true)
FileUtils.expects(:mv).returns(true)
provider.instance_eval { convert_working_copy_to_bare }
end
end
describe 'convert_bare_to_working_copy' do
it do
FileUtils.expects(:mv).returns(true)
FileUtils.expects(:mkdir).returns(true)
FileUtils.expects(:mv).returns(true)
provider.expects(:commits_in?).returns(true)
# If you forget to stub these out you lose 3 hours of rspec work.
provider.expects(:reset).with('HEAD').returns(true)
provider.expects(:git_with_identity).returns(true)
provider.expects(:update_owner_and_excludes).returns(true)
provider.instance_eval { convert_bare_to_working_copy }
end
end
end

File Metadata

Mime Type
text/x-diff
Expires
Jul 4 2025, 8:32 AM (7 w, 5 d ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
3292176

Event Timeline

About · Developer information · Legal