Chef

Table Of Contents

git

A resource defines the desired state for a single configuration item present on a node that is under management by Chef. A resource collection—one (or more) individual resources—defines the desired state for the entire node. During a chef-client run, the current state of each resource is tested, after which the chef-client will take any steps that are necessary to repair the node and bring it back into the desired state.

Use the git resource to manage source control resources that exist in a git repository. git version 1.6.5 (or higher) is required to use all of the functionality in the git resource.

Note

This resource is often used in conjunction with the deploy resource.

Syntax

A git resource block manages source control resources that exist in a git repository:

git '#{Chef::Config[:file_cache_path]}/app_name' do
  repository 'node[:app_name][:git_repository]'
  revision 'node[:app_name][:git_revision]'
  action :sync
end

The full syntax for all of the attributes that are available to the git resource is:

git 'name' do
  additional_remotes         Hash
  checkout_branch            String
  depth                      Integer
  destination                String # defaults to 'name' if not specified
  enable_checkout            TrueClass, FalseClass
  enable_submodules          TrueClass, FalseClass
  environment                Hash
  group                      String, Integer
  notifies                   # see description
  provider                   Chef::Provider::Scm::Git
  reference                  String
  remote                     String
  repository                 String
  revision                   String
  ssh_wrapper                String
  subscribes                 # see description
  timeout                    Integer
  user                       String, Integer
  action                     Symbol # defaults to :sync if not specified
end

where

  • git is the resource
  • name is the name of the resource block and also (when destination is not specified) the location in which the source files will be placed and/or synchronized with the files under source control management
  • :action identifies the steps the chef-client will take to bring the node into the desired state
  • additional_remotes, checkout_branch, depth, destination, enable_checkout, enable_submodules, environment, group, provider, reference, remote, repository, revision, ssh_wrapper, timeout, and user are attributes of this resource, with the Ruby type shown. (See “Attributes” section below for more information about all of the attributes that may be used with this resource.)

Actions

This resource has the following actions:

Action Description
:checkout Use to clone or check out the source. When a checkout is available, this provider does nothing.
:export Use to export the source, excluding or removing any version control artifacts.
:nothing Use to define a resource block that does nothing until it is notified by another resource to take action. When notified, this resource block is either run immediately or it is queued up to be run at the end of the chef-client run.
:sync Default. Use to update the source to the specified version, or to get a new clone or checkout.

Attributes

This resource has the following attributes:

Attribute Description
additional_remotes

Ruby Type: Hash

An array of additional remotes that are added to the git repository configuration.

checkout_branch

Ruby Type: String

Do a one-time checkout from git or use when a branch in the upstream repository is named deploy. To prevent the git resource from attempting to check out master from master, set enable_checkout to false when using the checkout_branch attribute. See revision. Default value: deploy.

depth

Ruby Type: Integer

The number of past revisions to be included in the git shallow clone. The default behavior will do a full clone.

destination

Ruby Type: String

The path to the location to which the source will be cloned, checked out, or exported. Default value: the name of the resource block. (See “Syntax” section above for more information.)

enable_checkout

Ruby Types: TrueClass, FalseClass

Use to check out a repo from master. Set to false when using the checkout_branch attribute to prevent the git resource from attempting to check out master from master. Default value: true.

enable_submodules

Ruby Types: TrueClass, FalseClass

Use to perform a sub-module initialization and update. Default value: false.

environment

Ruby Type: Hash

A Hash of environment variables in the form of {"ENV_VARIABLE" => "VALUE"}. (These variables must exist for a command to be run successfully.)

Note

The git provider automatically sets the ENV['HOME'] and ENV['GIT_SSH'] environment variables. To override this behavior and provide different values, add ENV['HOME'] and/or ENV['GIT_SSH'] to the environment Hash.

group

Ruby Types: String, Integer

The system group that is responsible for the checked-out code.

ignore_failure

Ruby Types: TrueClass, FalseClass

Use to continue running a recipe if a resource fails for any reason. Default value: false.

notifies

Ruby Type: Symbol, ‘Chef::Resource[String]’, Symbol

Use to specify which resource will take action when this resource’s state changes. A resource may notify more than one resource; use a notifies statement for each resource to be notified.

Specify the :action, 'resource[name]', and timer (:delayed or :immediately). Use multiple notifies statements to notify more than one resource.

resource 'name' do
  ...
  notifies :action, 'resource[name]', :timer
end

Use the following timers to specify when a notification is triggered:

Timer Description
:delayed Use to specify that a notification should be queued up, and then executed at the very end of a chef-client run.
:immediately Use to specify that a notification should be run immediately, per resource notified.
provider

Ruby Type: Chef Class

Optional. Use to explicitly specify a provider.

reference

Ruby Type: String

The alias for revision.

remote

Ruby Type: String

The remote repository to be used when synchronizing an existing clone.

repository

Ruby Type: String

The URI for the git repository.

retries

Ruby Type: Integer

Use to specify the number of times to catch exceptions and retry the resource. Default value: 0.

retry_delay

Ruby Type: Integer

Use to specify the retry delay (in seconds). Default value: 2.

revision

Ruby Type: String

Use to specify a branch, tag, or commit to be synchronized with git. This can be symbolic, like HEAD or it can be a source control management-specific revision identifier. See checkout_branch. Default value: HEAD.

The value of the revision attribute may change over time. From one branch to another, to a tag, to a specific SHA for a commit, and then back to a branch. The revision attribute may even be changed in a way where history gets rewritten.

Instead of tracking a specific branch or doing a headless checkout, the chef-client maintains its own branch (via the git resource) that does not exist in the upstream repository. The chef-client is then free to forcibly check out this branch to any commit without destroying the local history of an existing branch.

For example, to explicitly track an upstream repository’s master branch:

revision 'master'

Use the git rev-parse and git ls-remote commands to verify that the chef-client is synchronizing commits correctly. (The chef-client always runs git ls-remote on the upstream repository to verify the commit is made to the correct repository.)

ssh_wrapper

Ruby Type: String

The path to the wrapper script used when running SSH with git. The GIT_SSH environment variable is set to this.

subscribes

Ruby Type: Symbol, ‘Chef::Resource[String]’, Symbol

Use to specify that this resource will listen to another resource, and then take action when that resource’s state changes.

Specify the :action, 'resource[name]', and timer (:delayed or :immediately). Use multiple subscribes statements to listen to more than one resource.

resource 'name' do
  ...
  subscribes :action, 'resource[name]', :timer
end

The subscribes attribute uses the same timers as the notifies attribute.

timeout

Ruby Type: Integer

The amount of time (in seconds) to wait for a command to execute before timing out. When this attribute is specified using the deploy resource, the value of the timeout attribute is passed from the deploy resource to the git resource.

user

Ruby Types: String, Integer

The system user that is responsible for the checked-out code. Default value: the home directory of this user, as indicated by the HOME environment variable.

Examples

The following examples demonstrate various approaches for using resources in recipes. If you want to see examples of how Chef uses resources in recipes, take a closer look at the cookbooks that Chef authors and maintains: https://github.com/opscode-cookbooks.

Use the git mirror

git "/opt/mysources/couch" do
  repository "git://git.apache.org/couchdb.git"
  revision "master"
  action :sync
end

Use different branches

To use different branches, depending on the environment of the node:

if node.chef_environment == "QA"
   branch_name = "staging"
else
   branch_name = "master"
end

git "/home/user/deployment" do
   repository "git@github.com:gitsite/deployment.git"
   revision branch_name
   action :sync
   user "user"
   group "test"
end

where the branch_name variable is set to staging or master, depending on the environment of the node. Once this is determined, the branch_name variable is used to set the revision for the repository. If the git status command is used after running the example above, it will return the branch name as deploy, as this is the default value. Run the chef-client in debug mode to verify that the correct branches are being checked out:

$ sudo chef-client -l debug

Install an application from git using bash

The following example shows how Bash can be used to install a plug-in for rbenv named ruby-build, which is located in git version source control. First, the application is synchronized, and then Bash changes its working directory to the location in which ruby-build is located, and then runs a command.

 git "#{Chef::Config[:file_cache_path]}/ruby-build" do
   repository "git://github.com/sstephenson/ruby-build.git"
   reference "master"
   action :sync
 end

 bash "install_ruby_build" do
   cwd "#{Chef::Config[:file_cache_path]}/ruby-build"
   user "rbenv"
   group "rbenv"
   code <<-EOH
     ./install.sh
     EOH
   environment 'PREFIX' => "/usr/local"
end

To read more about ruby-build, see here: https://github.com/sstephenson/ruby-build.

Upgrade packages from git

The following example shows the scm resource using the git short name as part of a larger recipe that is used to upgrade packages:

#  the following code sample comes from the ``source`` recipe in the ``libvpx-cookbook`` cookbook: https://github.com/enmasse-entertainment/libvpx-cookbook

git "#{Chef::Config[:file_cache_path]}/libvpx" do
  repository node[:libvpx][:git_repository]
  revision node[:libvpx][:git_revision]
  action :sync
  notifies :run, "bash[compile_libvpx]", :immediately
end

Pass in environment variables

git "/opt/mysources/couch" do
  repository "git://git.apache.org/couchdb.git"
  revision "master"
  environment  { 'VAR' => 'whatever' }
  action :sync
end