Class: Chef::RunContext

Inherits:
Object show all
Defined in:
lib/chef/run_context.rb,
lib/chef/run_context/cookbook_compiler.rb

Overview

Chef::RunContext

Value object that loads and tracks the context of a Chef run

Defined Under Namespace

Classes: CookbookCompiler

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(node, cookbook_collection, events) ⇒ RunContext

Creates a new Chef::RunContext object and populates its fields. This object gets used by the Chef Server to generate a fully compiled recipe list for a node.

Returns

object<Chef::RunContext>

Duh. :)



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/chef/run_context.rb', line 72

def initialize(node, cookbook_collection, events)
  @node = node
  @cookbook_collection = cookbook_collection
  @resource_collection = Chef::ResourceCollection.new
  @immediate_notification_collection = Hash.new {|h,k| h[k] = []}
  @delayed_notification_collection = Hash.new {|h,k| h[k] = []}
  @definitions = Hash.new
  @loaded_recipes = {}
  @loaded_attributes = {}
  @events = events
  @reboot_info = {}

  @node.run_context = self
  @cookbook_compiler = nil
end

Instance Attribute Details

#cookbook_collection ⇒ Object (readonly)

Chef::CookbookCollection for this run



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

def cookbook_collection
  @cookbook_collection
end

#definitions ⇒ Object (readonly)

Resource Definitions for this run. Populated when the files in definitions/ are evaluated (this is triggered by #load).



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

def definitions
  @definitions
end

#delayed_notification_collection ⇒ Object

A Hash containing the delayed (end of run) notifications triggered by resources during the converge phase of the chef run.



59
60
61
 
# File 'lib/chef/run_context.rb', line 59

def delayed_notification_collection
  @delayed_notification_collection
end

#events ⇒ Object (readonly)

Event dispatcher for this run.



62
63
64
 
# File 'lib/chef/run_context.rb', line 62

def events
  @events
end

#immediate_notification_collection ⇒ Object

A Hash containing the immediate notifications triggered by resources during the converge phase of the chef run.



55
56
57
 
# File 'lib/chef/run_context.rb', line 55

def immediate_notification_collection
  @immediate_notification_collection
end

#node ⇒ Object (readonly)

Chef::Node object for this run



36
37
38
 
# File 'lib/chef/run_context.rb', line 36

def node
  @node
end

#reboot_info ⇒ Object (readonly)

Hash of factoids for a reboot request.



65
66
67
 
# File 'lib/chef/run_context.rb', line 65

def reboot_info
  @reboot_info
end

#resource_collection ⇒ Object

The Chef::ResourceCollection for this run. Populated by evaluating recipes, which is triggered by #load. (See also: CookbookCompiler)



51
52
53
 
# File 'lib/chef/run_context.rb', line 51

def resource_collection
  @resource_collection
end

Instance Method Details

#cancel_reboot ⇒ Object 



289
290
291
292
 
# File 'lib/chef/run_context.rb', line 289

def cancel_reboot
  Chef::Log::info "Changing reboot status from #{@reboot_info.inspect} to {}"
  @reboot_info = {}
end

#delayed_notifications(resource) ⇒ Object 



126
127
128
129
130
131
132
 
# File 'lib/chef/run_context.rb', line 126

def delayed_notifications(resource)
  if resource.instance_of?(Chef::Resource)
    return @delayed_notification_collection[resource.name]
  else
    return @delayed_notification_collection[resource.to_s]
  end
end

#has_cookbook_file_in_cookbook?(cookbook, cb_file_name) ⇒ Boolean

Returns:

  • (Boolean) 


244
245
246
247
 
# File 'lib/chef/run_context.rb', line 244

def has_cookbook_file_in_cookbook?(cookbook, cb_file_name)
  cookbook = cookbook_collection[cookbook]
  cookbook.has_cookbook_file_for_node?(node, cb_file_name)
end

#has_template_in_cookbook?(cookbook, template_name) ⇒ Boolean

Cookbook File Introspection

Returns:

  • (Boolean) 


239
240
241
242
 
# File 'lib/chef/run_context.rb', line 239

def has_template_in_cookbook?(cookbook, template_name)
  cookbook = cookbook_collection[cookbook]
  cookbook.has_template_for_node?(node, template_name)
end

#immediate_notifications(resource) ⇒ Object 



118
119
120
121
122
123
124
 
# File 'lib/chef/run_context.rb', line 118

def immediate_notifications(resource)
  if resource.instance_of?(Chef::Resource)
    return @immediate_notification_collection[resource.name]
  else
    return @immediate_notification_collection[resource.to_s]
  end
end

#include_recipe(*recipe_names) ⇒ Object

Evaluates the recipes recipe_names. Used by DSL::IncludeRecipe



135
136
137
138
139
140
141
142
143
 
# File 'lib/chef/run_context.rb', line 135

def include_recipe(*recipe_names)
  result_recipes = Array.new
  recipe_names.flatten.each do |recipe_name|
    if result = load_recipe(recipe_name)
      result_recipes << result
    end
  end
  result_recipes
end

#load(run_list_expansion) ⇒ Object

Triggers the compile phase of the chef run. Implemented by Chef::RunContext::CookbookCompiler



90
91
92
93
 
# File 'lib/chef/run_context.rb', line 90

def load(run_list_expansion)
  @cookbook_compiler = CookbookCompiler.new(self, run_list_expansion, events)
  @cookbook_compiler.compile
end

#load_recipe(recipe_name) ⇒ Object

Evaluates the recipe recipe_name. Used by DSL::IncludeRecipe



146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
 
# File 'lib/chef/run_context.rb', line 146

def load_recipe(recipe_name)
  Chef::Log.debug("Loading Recipe #{recipe_name} via include_recipe")

  cookbook_name, recipe_short_name = Chef::Recipe.parse_recipe_name(recipe_name)

  if unreachable_cookbook?(cookbook_name) # CHEF-4367
    Chef::Log.warn(<<-ERROR_MESSAGE)
MissingCookbookDependency:
Recipe `#{recipe_name}` is not in the run_list, and cookbook '#{cookbook_name}'
is not a dependency of any cookbook in the run_list.  To load this recipe,
first add a dependency on cookbook '#{cookbook_name}' in the cookbook you're
including it from in that cookbook's metadata.
ERROR_MESSAGE
  end


  if loaded_fully_qualified_recipe?(cookbook_name, recipe_short_name)
    Chef::Log.debug("I am not loading #{recipe_name}, because I have already seen it.")
    false
  else
    loaded_recipe(cookbook_name, recipe_short_name)
    node.loaded_recipe(cookbook_name, recipe_short_name)
    cookbook = cookbook_collection[cookbook_name]
    cookbook.load_recipe(recipe_short_name, self)
  end
end

#load_recipe_file(recipe_file) ⇒ Object 



173
174
175
176
177
178
179
180
181
182
 
# File 'lib/chef/run_context.rb', line 173

def load_recipe_file(recipe_file)
  if !File.exist?(recipe_file)
    raise Chef::Exceptions::RecipeNotFound, "could not find recipe file #{recipe_file}"
  end

  Chef::Log.debug("Loading Recipe File #{recipe_file}")
  recipe = Chef::Recipe.new('@recipe_files', recipe_file, self)
  recipe.from_file(recipe_file)
  recipe
end

#loaded_attribute(cookbook, attribute_file) ⇒ Object 



232
233
234
 
# File 'lib/chef/run_context.rb', line 232

def loaded_attribute(cookbook, attribute_file)
  @loaded_attributes["#{cookbook}::#{attribute_file}"] = true
end

#loaded_attributes ⇒ Object

An Array of all attributes files that have been loaded. Stored internally using a Hash, so order is not preserved on ruby 1.8.

Attribute file names are given in fully qualified form, e.g., “nginx::default” instead of “nginx”.



212
213
214
 
# File 'lib/chef/run_context.rb', line 212

def loaded_attributes
  @loaded_attributes.keys
end

#loaded_fully_qualified_attribute?(cookbook, attribute_file) ⇒ Boolean

Returns:

  • (Boolean) 


228
229
230
 
# File 'lib/chef/run_context.rb', line 228

def loaded_fully_qualified_attribute?(cookbook, attribute_file)
  @loaded_attributes.has_key?("#{cookbook}::#{attribute_file}")
end

#loaded_fully_qualified_recipe?(cookbook, recipe) ⇒ Boolean

Returns:

  • (Boolean) 


216
217
218
 
# File 'lib/chef/run_context.rb', line 216

def loaded_fully_qualified_recipe?(cookbook, recipe)
  @loaded_recipes.has_key?("#{cookbook}::#{recipe}")
end

#loaded_recipe?(recipe) ⇒ Boolean

Returns true if recipe has been loaded, false otherwise. Default recipe names are expanded, so ‘loaded_recipe?(“nginx”)` and `loaded_recipe?(“nginx::default”)` are valid and give identical results.

Returns:

  • (Boolean) 


223
224
225
226
 
# File 'lib/chef/run_context.rb', line 223

def loaded_recipe?(recipe)
  cookbook, recipe_name = Chef::Recipe.parse_recipe_name(recipe)
  loaded_fully_qualified_recipe?(cookbook, recipe_name)
end

#loaded_recipes ⇒ Object

An Array of all recipes that have been loaded. This is stored internally as a Hash, so ordering is not preserved when using ruby 1.8.

Recipe names are given in fully qualified form, e.g., the recipe “nginx” will be given as “nginx::default”

To determine if a particular recipe has been loaded, use #loaded_recipe?



203
204
205
 
# File 'lib/chef/run_context.rb', line 203

def loaded_recipes
  @loaded_recipes.keys
end

#notifies_delayed(notification) ⇒ Object

Adds a delayed notification to the delayed_notification_collection. The notification should be a Chef::Resource::Notification or duck type.



109
110
111
112
113
114
115
116
 
# File 'lib/chef/run_context.rb', line 109

def notifies_delayed(notification)
  nr = notification.notifying_resource
  if nr.instance_of?(Chef::Resource)
    @delayed_notification_collection[nr.name] << notification
  else
    @delayed_notification_collection[nr.to_s] << notification
  end
end

#notifies_immediately(notification) ⇒ Object

Adds an immediate notification to the immediate_notification_collection. The notification should be a Chef::Resource::Notification or duck type.



98
99
100
101
102
103
104
105
 
# File 'lib/chef/run_context.rb', line 98

def notifies_immediately(notification)
  nr = notification.notifying_resource
  if nr.instance_of?(Chef::Resource)
    @immediate_notification_collection[nr.name] << notification
  else
    @immediate_notification_collection[nr.to_s] << notification
  end
end

#open_stream(options = {}) ⇒ Object

Open a stream object that can be printed into and will dispatch to events

Arguments

options is a hash with these possible options:

  • name: a string that identifies the stream to the user. Preferably short.

Pass a block and the stream will be yielded to it, and close on its own at the end of the block.



264
265
266
267
268
269
270
271
272
273
274
275
 
# File 'lib/chef/run_context.rb', line 264

def open_stream(options = {})
  stream = EventDispatch::EventsOutputStream.new(events, options)
  if block_given?
    begin
      yield stream
    ensure
      stream.close
    end
  else
    stream
  end
end

#reboot_requested? ⇒ Boolean

Returns:

  • (Boolean) 


294
295
296
 
# File 'lib/chef/run_context.rb', line 294

def reboot_requested?
  @reboot_info.size > 0
end

#request_reboot(reboot_info) ⇒ Object

there are options for how to handle multiple calls to these functions:

  1. first call always wins (never change @reboot_info once set).

  2. last call always wins (happily change @reboot_info whenever).

  3. raise an exception on the first conflict.

  4. disable reboot after this run if anyone ever calls :cancel.

  5. raise an exception on any second call.

  6. ?



284
285
286
287
 
# File 'lib/chef/run_context.rb', line 284

def request_reboot(reboot_info)
  Chef::Log::info "Changing reboot status from #{@reboot_info.inspect} to #{reboot_info.inspect}"
  @reboot_info = reboot_info
end

#resolve_attribute(cookbook_name, attr_file_name) ⇒ Object

Looks up an attribute file given the cookbook_name and attr_file_name. Used by DSL::IncludeAttribute

Raises:



186
187
188
189
190
191
192
193
194
 
# File 'lib/chef/run_context.rb', line 186

def resolve_attribute(cookbook_name, attr_file_name)
  cookbook = cookbook_collection[cookbook_name]
  raise Chef::Exceptions::CookbookNotFound, "could not find cookbook #{cookbook_name} while loading attribute #{name}" unless cookbook

  attribute_filename = cookbook.attribute_filenames_by_short_filename[attr_file_name]
  raise Chef::Exceptions::AttributeNotFound, "could not find filename for attribute #{attr_file_name} in cookbook #{cookbook_name}" unless attribute_filename

  attribute_filename
end

#unreachable_cookbook?(cookbook_name) ⇒ Boolean

Delegates to CookbookCompiler#unreachable_cookbook? Used to raise an error when attempting to load a recipe belonging to a cookbook that is not in the dependency graph. See also: CHEF-4367

Returns:

  • (Boolean) 


252
253
254
 
# File 'lib/chef/run_context.rb', line 252

def unreachable_cookbook?(cookbook_name)
  @cookbook_compiler.unreachable_cookbook?(cookbook_name)
end