Class: Chef::Provider::Git

Inherits:
Chef::Provider show all
Includes:
Mixin::Command
Defined in:
lib/chef/provider/git.rb

Instance Attribute Summary

Attributes inherited from Chef::Provider

#current_resource, #new_resource, #node

Instance Method Summary collapse

Methods included from Mixin::Command

handle_command_failures, not_if, only_if, output_of_command, popen4, run_command, run_command_with_systems_locale

Methods inherited from Chef::Provider

#action_nothing, build_from_file, #initialize

Methods included from Mixin::ConvertToClassName

#convert_to_class_name, #filename_to_qualified_string

Methods included from Mixin::RecipeDefinitionDSLCore

#method_missing

Constructor Details

This class inherits a constructor from Chef::Provider

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class Chef::Mixin::RecipeDefinitionDSLCore

Instance Method Details

#action_checkout ⇒ Object 



38
39
40
41
42
43
 
# File 'lib/chef/provider/git.rb', line 38

def action_checkout
  clone
  checkout
  enable_submodules
  @new_resource.updated = true
end

#action_export ⇒ Object 



45
46
47
48
49
 
# File 'lib/chef/provider/git.rb', line 45

def action_export
  action_checkout
  FileUtils.rm_rf(::File.join(@new_resource.destination,".git"))
  @new_resource.updated = true
end

#action_sync ⇒ Object 



51
52
53
54
55
56
57
58
59
60
 
# File 'lib/chef/provider/git.rb', line 51

def action_sync
  if !::File.exist?(@new_resource.destination) || Dir.entries(@new_resource.destination) == ['.','..']
    action_checkout
  else
    sync
    enable_submodules
  end

  @new_resource.updated = true
end

#checkout ⇒ Object 



87
88
89
90
91
92
 
# File 'lib/chef/provider/git.rb', line 87

def checkout
  sha_ref = revision_sha
  Chef::Log.info "Checking out branch: #{@new_resource.revision} reference: #{sha_ref}"
  # checkout into a local branch rather than a detached HEAD
  run_command(run_options(:command => "#{git} checkout -b deploy #{sha_ref}", :cwd => @new_resource.destination))
end

#clone ⇒ Object 



74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/chef/provider/git.rb', line 74

def clone
  remote = @new_resource.remote

  args = []
  args << "-o #{remote}" unless remote == 'origin'
  args << "--depth #{@new_resource.depth}" if @new_resource.depth
  
  Chef::Log.info "Cloning repo #{@new_resource.repository} to #{@new_resource.destination}"
  
  clone_cmd = "#{git} clone #{args.join(' ')} #{@new_resource.repository} #{@new_resource.destination}"
  run_command(run_options(:command => clone_cmd))
end

#enable_submodules ⇒ Object 



94
95
96
97
98
99
100
 
# File 'lib/chef/provider/git.rb', line 94

def enable_submodules
  if @new_resource.enable_submodules
    Chef::Log.info "Enabling git submodules"
    command = "#{git} submodule init && #{git} submodule update"
    run_command(run_options(:command => command, :cwd => @new_resource.destination))
  end
end

#find_current_revision ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/chef/provider/git.rb', line 62

def find_current_revision
  if ::File.exist?(::File.join(cwd, ".git"))
    status, result, error_message = output_of_command("git rev-parse HEAD", run_options(:cwd=>cwd))
    
    # 128 is returned when we're not in a git repo. this is fine
    unless [0,128].include?(status.exitstatus)
      handle_command_failures(status, "STDOUT: #{result}\nSTDERR: #{error_message}")
    end
  end
  sha_hash?(result) ? result : nil
end

#load_current_resource ⇒ Object 



31
32
33
34
35
36
 
# File 'lib/chef/provider/git.rb', line 31

def load_current_resource
  @current_resource = Chef::Resource::Git.new(@new_resource.name)
  if current_revision = find_current_revision
    @current_resource.revision current_revision
  end
end

#remote_resolve_reference ⇒ Object 



140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/chef/provider/git.rb', line 140

def remote_resolve_reference
  command = scm('ls-remote', @new_resource.repository, @new_resource.revision)
  Chef::Log.debug("Executing #{command}")
  begin
    status, result, error_message = output_of_command(command, run_options)
    handle_command_failures(status, "STDOUT: #{result}\nSTDERR: #{error_message}")
  rescue RuntimeError => e
    raise RuntimeError, e.message + "\n" + "Could not access the remote Git repository. "+
          "If this is a private repository, please verify that the deploy key for your application " +
          "has been added to your remote Git account."
  end
  result
end

#revision_sha ⇒ Object Also known as: revision_slug 



125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/chef/provider/git.rb', line 125

def revision_sha
  @revision_sha ||= begin
    assert_revision_not_remote
    
    if sha_hash?(@new_resource.revision)
      @revision_sha = @new_resource.revision 
    else
      resolved_reference = remote_resolve_reference
      @revision_sha = extract_revision(resolved_reference)
    end
  end
end

#sync ⇒ Object 



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/chef/provider/git.rb', line 102

def sync
  revision = revision_sha
  sync_command = []

  # 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 @new_resource.remote != 'origin'
    Chef::Log.info  "Configuring remote tracking branches for repository #{@new_resource.repository} "+
                    "at remote #{@new_resource.remote}"
    sync_command << "#{git} config remote.#{@new_resource.remote}.url #{@new_resource.repository}"
    sync_command << "#{git} config remote.#{@new_resource.remote}.fetch +refs/heads/*:refs/remotes/#{@new_resource.remote}/*"
  end

  # since we're in a local branch already, just reset to specified revision rather than merge
  sync_command << "#{git} fetch #{@new_resource.remote} && #{git} reset --hard #{revision}"
  Chef::Log.info "Fetching updates from #{new_resource.remote} and resetting to revison #{revision}"
  run_command(run_options(:command => sync_command.join(" && "), :cwd => @new_resource.destination))
end