# class Chef::Runner

## Chef::Runner¶ ↑

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

### Attributes

delayed_actions[R]
run_context[R]

### Public Class Methods

new(run_context) click to toggle source

    # File lib/chef/runner.rb, line 37
    def initialize(run_context)
      @run_context      = run_context
      @delayed_actions  = []
    end

### Public Instance Methods

converge() click to toggle source

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

    # File lib/chef/runner.rb, line 73
    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() click to toggle source

    # File lib/chef/runner.rb, line 42
    def events
      @run_context.events
    end

run_action(resource, action, notification_type=nil, notifying_resource=nil) click to toggle source

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

    # File lib/chef/runner.rb, line 48
    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