Class: Chef::Runner

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

Overview

Chef::Runner

This class is responsible for executing the steps in a Chef run.

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Mixin::ParamsValidate

#set_or_return, #validate

Constructor Details

#initialize(run_context) ⇒ Runner

Returns a new instance of Runner.



38
39
40
41
 
# File 'lib/chef/runner.rb', line 38

def initialize(run_context)
  @run_context      = run_context
  @delayed_actions  = []
end

Instance Attribute Details

#delayed_actions ⇒ Object (readonly)

Returns the value of attribute delayed_actions.



34
35
36
 
# File 'lib/chef/runner.rb', line 34

def delayed_actions
  @delayed_actions
end

#run_context ⇒ Object (readonly)

Returns the value of attribute run_context.



32
33
34
 
# File 'lib/chef/runner.rb', line 32

def run_context
  @run_context
end

Instance Method Details

#converge ⇒ Object

Iterates over the resource_collection in the run_context calling run_action for each resource in turn.



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/chef/runner.rb', line 74

def converge
  # Resolve all lazy/forward references in notifications
  run_context.resource_collection.each do |resource|
    resource.resolve_notification_references
  end

  # Execute each resource.
  run_context.resource_collection.execute_each_resource do |resource|
    Array(resource.action).each {|action| run_action(resource, action)}
  end

rescue Exception => e
  Chef::Log.info "Running queued delayed notifications before re-raising exception"
  run_delayed_notifications(e)
else
  run_delayed_notifications(nil)
  true
end

#events ⇒ Object 



43
44
45
 
# File 'lib/chef/runner.rb', line 43

def events
  @run_context.events
end

#run_action(resource, action, notification_type = nil, notifying_resource = nil) ⇒ Object

Determine the appropriate provider for the given resource, then execute it.



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/chef/runner.rb', line 49

def run_action(resource, action, notification_type=nil, notifying_resource=nil)
  resource.run_action(action, notification_type, notifying_resource)

  # Execute any immediate and queue up any delayed notifications
  # associated with the resource, but only if it was updated *this time*
  # we ran an action on it.
  if resource.updated_by_last_action?
    run_context.immediate_notifications(resource).each do |notification|
      Chef::Log.info("#{resource} sending #{notification.action} action to #{notification.resource} (immediate)")
      run_action(notification.resource, notification.action, :immediate, resource)
    end

    run_context.delayed_notifications(resource).each do |notification|
      if delayed_actions.any? { |existing_notification| existing_notification.duplicates?(notification) }
        Chef::Log.info( "#{resource} not queuing delayed action #{notification.action} on #{notification.resource}"\
                        " (delayed), as it's already been queued")
      else
        delayed_actions << notification
      end
    end
  end
end