Class: Chef::Runner

Inherits:
Object show all
Includes:
Mixin::ParamsValidate
Defined in:
lib/chef/runner.rb

Instance Method Summary collapse

Methods included from Mixin::ParamsValidate

#set_or_return, #validate

Constructor Details

#initialize(node, collection, definitions = {}, cookbook_loader = nil) ⇒ Runner

Returns a new instance of Runner.



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/chef/runner.rb', line 29

def initialize(node, collection, definitions={}, cookbook_loader=nil)
  validate(
    {
      :node => node,
      :collection => collection,
    },
    {
      :node => {
        :kind_of => Chef::Node,
      },
      :collection => {
        :kind_of => Chef::ResourceCollection,
      },
    }
  )
  @node = node
  @collection = collection
  @definitions = definitions
  @cookbook_loader = cookbook_loader
end

Instance Method Details

#build_provider(resource) ⇒ Object 



50
51
52
53
54
55
56
57
 
# File 'lib/chef/runner.rb', line 50

def build_provider(resource)
  provider_klass = resource.provider
  provider_klass ||= Chef::Platform.find_provider_for_node(@node, resource)
  Chef::Log.debug("#{resource} using #{provider_klass.to_s}")
  provider = provider_klass.new(@node, resource, @collection, @definitions, @cookbook_loader)
  provider.load_current_resource
  provider
end

#converge ⇒ Object 



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/chef/runner.rb', line 84

def converge

  @delayed_actions = Hash.new
  
  @collection.execute_each_resource do |resource|
    begin
      Chef::Log.debug("Processing #{resource}")
      
      # Check if this resource has an only_if block - if it does, skip it.
      if resource.only_if
        unless Chef::Mixin::Command.only_if(resource.only_if)
          Chef::Log.debug("Skipping #{resource} due to only_if")
          next
        end
      end
      
      # Check if this resource has a not_if block - if it does, skip it.
      if resource.not_if
        unless Chef::Mixin::Command.not_if(resource.not_if)
          Chef::Log.debug("Skipping #{resource} due to not_if")
          next
        end
      end
      
      # Walk the actions for this resource, building the provider and running each.
      action_list = resource.action.kind_of?(Array) ? resource.action : [ resource.action ]
      action_list.each do |ra|
        run_action(resource, ra)
      end
    rescue => e
      Chef::Log.error("#{resource} (#{resource.source_line}) had an error:\n#{e}\n#{e.backtrace.join("\n")}")
      raise e unless resource.ignore_failure
    end
  end
  
  # Run all our :delayed actions
  @delayed_actions.each do |resource, action_hash| 
    action_hash.each do |action, log_array|
      log_array.each { |l| l.call } # Call each log message
      run_action(resource, action)
    end
  end

  true
end

#run_action(resource, ra) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/chef/runner.rb', line 59

def run_action(resource, ra)
  provider = build_provider(resource)
  provider.send("action_#{ra}")

  if resource.updated
    resource.actions.each_key do |action|
      if resource.actions[action].has_key?(:immediate)
        resource.actions[action][:immediate].each do |r|
          Chef::Log.info("#{resource} sending #{action} action to #{r} (immediate)")
          run_action(r, action)
        end
      end
      if resource.actions[action].has_key?(:delayed)
        resource.actions[action][:delayed].each do |r|
          @delayed_actions[r] = Hash.new unless @delayed_actions.has_key?(r)
          @delayed_actions[r][action] = Array.new unless @delayed_actions[r].has_key?(action)
          @delayed_actions[r][action] << lambda {
            Chef::Log.info("#{resource} sending #{action} action to #{r} (delayed)")
          } 
        end
      end
    end
  end
end