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. :)



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/chef/run_context.rb', line 69

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

  @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

#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

#delayed_notifications(resource) ⇒ Object 



123
124
125
126
127
128
129
 
# File 'lib/chef/run_context.rb', line 123

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) 


241
242
243
244
 
# File 'lib/chef/run_context.rb', line 241

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) 


236
237
238
239
 
# File 'lib/chef/run_context.rb', line 236

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 



115
116
117
118
119
120
121
 
# File 'lib/chef/run_context.rb', line 115

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



132
133
134
135
136
137
138
139
140
 
# File 'lib/chef/run_context.rb', line 132

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



87
88
89
90
 
# File 'lib/chef/run_context.rb', line 87

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



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

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 



170
171
172
173
174
175
176
177
178
179
 
# File 'lib/chef/run_context.rb', line 170

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 



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

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”.



209
210
211
 
# File 'lib/chef/run_context.rb', line 209

def loaded_attributes
  @loaded_attributes.keys
end

#loaded_fully_qualified_attribute?(cookbook, attribute_file) ⇒ Boolean

Returns:

  • (Boolean) 


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

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) 


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

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) 


220
221
222
223
 
# File 'lib/chef/run_context.rb', line 220

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?



200
201
202
 
# File 'lib/chef/run_context.rb', line 200

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.



106
107
108
109
110
111
112
113
 
# File 'lib/chef/run_context.rb', line 106

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.



95
96
97
98
99
100
101
102
 
# File 'lib/chef/run_context.rb', line 95

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.



261
262
263
264
265
266
267
268
269
270
271
272
 
# File 'lib/chef/run_context.rb', line 261

def open_stream(options = {})
  stream = EventDispatch::EventsOutputStream.new(events, options)
  if block_given?
    begin
      yield stream
    ensure
      stream.close
    end
  else
    stream
  end
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:



183
184
185
186
187
188
189
190
191
 
# File 'lib/chef/run_context.rb', line 183

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) 


249
250
251
 
# File 'lib/chef/run_context.rb', line 249

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