Class: Chef::CookbookVersion

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Includes:
Comparable
Defined in:
lib/chef/cookbook_version.rb

Overview

Chef::CookbookVersion

CookbookVersion is a model object encapsulating the data about a Chef cookbook. Chef supports maintaining multiple versions of a cookbook on a single server; each version is represented by a distinct instance of this class.

Constant Summary collapse

COOKBOOK_SEGMENTS = 
%i{resources providers recipes definitions libraries attributes files templates root_files}.freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name, *root_paths, chef_server_rest: nil) ⇒ CookbookVersion

Creates a new Chef::CookbookVersion object.

Returns

object<Chef::CookbookVersion>

Duh. :)



94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/chef/cookbook_version.rb', line 94

def initialize(name, *root_paths, chef_server_rest: nil)
  @name = name
  @root_paths = root_paths
  @frozen = false

  @all_files = []

  @file_vendor = nil
  @cookbook_manifest = Chef::CookbookManifest.new(self)
  @metadata = Chef::Cookbook::Metadata.new
  @chef_server_rest = chef_server_rest
end

Instance Attribute Details

#all_files ⇒ Object

Returns the value of attribute all_files.



47
48
49
 
# File 'lib/chef/cookbook_version.rb', line 47

def all_files
  @all_files
end

#identifier ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

The ‘identifier` field is used for cookbook_artifacts, which are organized on the chef server according to their content. If the policy_mode option to CookbookManifest is set to true it will include this field in the manifest Hash and in the upload URL.

This field may be removed or have different behavior in the future, don’t use it in 3rd party code.



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

def identifier
  @identifier
end

#metadata ⇒ Object

A Chef::Cookbook::Metadata object. It has a setter that fixes up the metadata to add descriptions of the recipes contained in this CookbookVersion.



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

def metadata
  @metadata
end

#name ⇒ Object

Returns the value of attribute name.



50
51
52
 
# File 'lib/chef/cookbook_version.rb', line 50

def name
  @name
end

#root_paths ⇒ Object

Returns the value of attribute root_paths.



49
50
51
 
# File 'lib/chef/cookbook_version.rb', line 49

def root_paths
  @root_paths
end

Class Method Details

.available_versions(cookbook_name) ⇒ Object

Given a cookbook_name, get a list of all versions that exist on the server.

Returns

[String]

Array of cookbook versions, which are strings like ‘x.y.z’

nil

if the cookbook doesn’t exist. an error will also be logged.



557
558
559
560
561
562
563
564
565
566
567
568
 
# File 'lib/chef/cookbook_version.rb', line 557

def self.available_versions(cookbook_name)
  chef_server_rest.get("cookbooks/#{cookbook_name}")[cookbook_name]["versions"].map do |cb|
    cb["version"]
  end
rescue Net::HTTPClientException => e
  if /^404/.match?(e.to_s)
    Chef::Log.error("Cannot find a cookbook named #{cookbook_name}")
    nil
  else
    raise
  end
end

.cache ⇒ Object 



86
87
88
 
# File 'lib/chef/cookbook_version.rb', line 86

def self.cache
  Chef::FileCache
end

.checksum_cookbook_file(filepath) ⇒ Object

This is the one and only method that knows how cookbook files’ checksums are generated.



79
80
81
82
83
84
 
# File 'lib/chef/cookbook_version.rb', line 79

def self.checksum_cookbook_file(filepath)
  Chef::Digester.generate_md5_checksum_for_file(filepath)
rescue Errno::ENOENT
  Chef::Log.trace("File #{filepath} does not exist, so there is no checksum to generate")
  nil
end

.chef_server_rest ⇒ Object 



523
524
525
 
# File 'lib/chef/cookbook_version.rb', line 523

def self.chef_server_rest
  Chef::ServerAPI.new(Chef::Config[:chef_server_url], { version_class: Chef::CookbookManifestVersions })
end

.from_cb_artifact_data(o) ⇒ Object 



493
494
495
 
# File 'lib/chef/cookbook_version.rb', line 493

def self.from_cb_artifact_data(o)
  from_hash(o)
end

.from_hash(o) ⇒ Object 



478
479
480
481
482
483
484
485
486
487
488
489
490
491
 
# File 'lib/chef/cookbook_version.rb', line 478

def self.from_hash(o)
  cookbook_version = new(o["cookbook_name"] || o["name"])

  # We want the Chef::Cookbook::Metadata object to always be inflated
  cookbook_version.manifest = o
  cookbook_version.metadata = Chef::Cookbook::Metadata.from_hash(o["metadata"])
  cookbook_version.identifier = o["identifier"] if o.key?("identifier")

  # We don't need the following step when we decide to stop supporting deprecated operators in the metadata (e.g. <<, >>)
  cookbook_version.manifest["metadata"] = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(cookbook_version.metadata))

  cookbook_version.freeze_version if o["frozen?"]
  cookbook_version
end

.list ⇒ Object Also known as: latest_cookbooks

The API returns only a single version of each cookbook in the result from the cookbooks method



538
539
540
 
# File 'lib/chef/cookbook_version.rb', line 538

def self.list
  chef_server_rest.get("cookbooks")
end

.list_all_versions ⇒ Object 



547
548
549
 
# File 'lib/chef/cookbook_version.rb', line 547

def self.list_all_versions
  chef_server_rest.get("cookbooks?num_versions=all")
end

.load(name, version = "_latest") ⇒ Object 



532
533
534
535
 
# File 'lib/chef/cookbook_version.rb', line 532

def self.load(name, version = "_latest")
  version = "_latest" if version == "latest"
  from_hash(chef_server_rest.get("cookbooks/#{name}/#{version}"))
end

Instance Method Details

#<=>(other) ⇒ Object

Raises:



570
571
572
573
574
575
576
577
 
# File 'lib/chef/cookbook_version.rb', line 570

def <=>(other)
  raise Chef::Exceptions::CookbookVersionNameMismatch if name != other.name

  # FIXME: can we change the interface to the Metadata class such
  # that metadata.version returns a Chef::Version instance instead
  # of a string?
  Chef::Version.new(version) <=> Chef::Version.new(other.version)
end

#attribute_filenames_by_short_filename ⇒ Object 



131
132
133
134
135
136
137
138
 
# File 'lib/chef/cookbook_version.rb', line 131

def attribute_filenames_by_short_filename
  @attribute_filenames_by_short_filename ||= begin
    name_map = filenames_by_name(files_for("attributes"))
    root_alias = cookbook_manifest.root_files.find { |record| record[:name] == "root_files/attributes.rb" }
    name_map["default"] = root_alias[:full_path] if root_alias
    name_map
  end
end

#checksums ⇒ Object

Returns a hash of checksums to either nil or the on disk path (which is done by generate_manifest).



196
197
198
 
# File 'lib/chef/cookbook_version.rb', line 196

def checksums
  cookbook_manifest.checksums
end

#chef_server_rest ⇒ Object

REST API



519
520
521
 
# File 'lib/chef/cookbook_version.rb', line 519

def chef_server_rest
  @chef_server_rest ||= chef_server_rest
end

#compile_metadata(path = root_dir) ⇒ Object 



583
584
585
586
587
588
589
590
591
592
593
594
 
# File 'lib/chef/cookbook_version.rb', line 583

def compile_metadata(path = root_dir)
  json_file = "#{path}/metadata.json"
  rb_file = "#{path}/metadata.rb"
  return nil if File.exist?(json_file)

  md = Chef::Cookbook::Metadata.new
  md.from_file(rb_file)
  f = File.open(json_file, "w")
  f.write(Chef::JSONCompat.to_json_pretty(md))
  f.close
  f.path
end

#cookbook_manifest ⇒ Object 



579
580
581
 
# File 'lib/chef/cookbook_version.rb', line 579

def cookbook_manifest
  @cookbook_manifest ||= CookbookManifest.new(self)
end

#destroy ⇒ Object 



527
528
529
530
 
# File 'lib/chef/cookbook_version.rb', line 527

def destroy
  chef_server_rest.delete("cookbooks/#{name}/#{version}")
  self
end

#display ⇒ Object 



468
469
470
471
472
473
474
475
476
 
# File 'lib/chef/cookbook_version.rb', line 468

def display
  output = Mash.new
  output["cookbook_name"] = name
  output["name"] = full_name
  output["frozen?"] = frozen_version?
  output["metadata"] = metadata.to_h
  output["version"] = version
  output.merge(cookbook_manifest.by_parent_directory)
end

#freeze_version ⇒ Object 



118
119
120
 
# File 'lib/chef/cookbook_version.rb', line 118

def freeze_version
  @frozen = true
end

#frozen_version? ⇒ Boolean

Indicates if this version is frozen or not. Freezing a cookbook version indicates that a new cookbook with the same name and version number should

Returns:

  • (Boolean) 


114
115
116
 
# File 'lib/chef/cookbook_version.rb', line 114

def frozen_version?
  @frozen
end

#full_name ⇒ Object 



127
128
129
 
# File 'lib/chef/cookbook_version.rb', line 127

def full_name
  "#{name}-#{version}"
end

#fully_qualified_recipe_names ⇒ Object

Return recipe names in the form of cookbook_name::recipe_name



205
206
207
208
209
210
211
212
 
# File 'lib/chef/cookbook_version.rb', line 205

def fully_qualified_recipe_names
  files_for("recipes").inject([]) do |memo, recipe|
    rname = recipe[:name].split("/")[1]
    rname = File.basename(rname, ".rb")
    memo << "#{name}::#{rname}"
    memo
  end
end

#has_cookbook_file_for_node?(node, cookbook_filename) ⇒ Boolean

Query whether a cookbook_file file cookbook_filename is available. File specificity for the given node is obeyed in the lookup.

Returns:

  • (Boolean) 


278
279
280
 
# File 'lib/chef/cookbook_version.rb', line 278

def has_cookbook_file_for_node?(node, cookbook_filename)
  !!find_preferred_manifest_record(node, :files, cookbook_filename)
end

#has_metadata_file? ⇒ Boolean

Returns:

  • (Boolean) 


511
512
513
 
# File 'lib/chef/cookbook_version.rb', line 511

def has_metadata_file?
  all_files.include?(metadata_json_file) || all_files.include?(metadata_rb_file)
end

#has_template_for_node?(node, template_filename) ⇒ Boolean

Query whether a template file template_filename is available. File specificity for the given node is obeyed in the lookup.

Returns:

  • (Boolean) 


272
273
274
 
# File 'lib/chef/cookbook_version.rb', line 272

def has_template_for_node?(node, template_filename)
  !!find_preferred_manifest_record(node, :templates, template_filename)
end

#load_json_recipe(recipe_name, run_context) ⇒ Object 



227
228
229
230
231
232
233
234
235
236
237
238
 
# File 'lib/chef/cookbook_version.rb', line 227

def load_json_recipe(recipe_name, run_context)
  Chef::Log.trace("Found recipe #{recipe_name} in cookbook #{name}")
  recipe = Chef::Recipe.new(name, recipe_name, run_context)
  recipe_filename = recipe_json_filenames_by_name[recipe_name]

  unless recipe_filename
    raise Chef::Exceptions::RecipeNotFound, "could not find #{recipe_name} files for cookbook #{name}"
  end

  recipe.from_json_file(recipe_filename)
  recipe
end

#load_recipe(recipe_name, run_context) ⇒ Object

called from DSL



215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/chef/cookbook_version.rb', line 215

def load_recipe(recipe_name, run_context)
  if recipe_filenames_by_name.key?(recipe_name)
    load_ruby_recipe(recipe_name, run_context)
  elsif recipe_yml_filenames_by_name.key?(recipe_name)
    load_yml_recipe(recipe_name, run_context)
  elsif recipe_json_filenames_by_name.key?(recipe_name)
    load_json_recipe(recipe_name, run_context)
  else
    raise Chef::Exceptions::RecipeNotFound, "could not find recipe #{recipe_name} for cookbook #{name}"
  end
end

#load_ruby_recipe(recipe_name, run_context) ⇒ Object 



253
254
255
256
257
258
259
260
261
262
263
264
 
# File 'lib/chef/cookbook_version.rb', line 253

def load_ruby_recipe(recipe_name, run_context)
  Chef::Log.trace("Found recipe #{recipe_name} in cookbook #{name}")
  recipe = Chef::Recipe.new(name, recipe_name, run_context)
  recipe_filename = recipe_filenames_by_name[recipe_name]

  unless recipe_filename
    raise Chef::Exceptions::RecipeNotFound, "could not find #{recipe_name} files for cookbook #{name}"
  end

  recipe.from_file(recipe_filename)
  recipe
end

#load_yml_recipe(recipe_name, run_context) ⇒ Object 



240
241
242
243
244
245
246
247
248
249
250
251
 
# File 'lib/chef/cookbook_version.rb', line 240

def load_yml_recipe(recipe_name, run_context)
  Chef::Log.trace("Found recipe #{recipe_name} in cookbook #{name}")
  recipe = Chef::Recipe.new(name, recipe_name, run_context)
  recipe_filename = recipe_yml_filenames_by_name[recipe_name]

  unless recipe_filename
    raise Chef::Exceptions::RecipeNotFound, "could not find #{recipe_name} files for cookbook #{name}"
  end

  recipe.from_yaml_file(recipe_filename)
  recipe
end

#manifest ⇒ Object 



186
187
188
 
# File 'lib/chef/cookbook_version.rb', line 186

def manifest
  cookbook_manifest.manifest
end

#manifest=(new_manifest) ⇒ Object 



190
191
192
 
# File 'lib/chef/cookbook_version.rb', line 190

def manifest=(new_manifest)
  cookbook_manifest.update_from(new_manifest)
end

#manifest_records_by_path ⇒ Object 



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

def manifest_records_by_path
  cookbook_manifest.manifest_records_by_path
end

#metadata_json_file ⇒ Object 



497
498
499
 
# File 'lib/chef/cookbook_version.rb', line 497

def metadata_json_file
  File.join(root_paths[0], "metadata.json")
end

#metadata_rb_file ⇒ Object 



501
502
503
 
# File 'lib/chef/cookbook_version.rb', line 501

def metadata_rb_file
  File.join(root_paths[0], "metadata.rb")
end

#preferred_filename_on_disk_location(node, segment, filename, current_filepath = nil) ⇒ Object 



334
335
336
337
338
339
340
341
 
# File 'lib/chef/cookbook_version.rb', line 334

def preferred_filename_on_disk_location(node, segment, filename, current_filepath = nil)
  manifest_record = preferred_manifest_record(node, segment, filename)
  if current_filepath && (manifest_record["checksum"] == self.class.checksum_cookbook_file(current_filepath))
    nil
  else
    file_vendor.get_filename(manifest_record["path"])
  end
end

#preferred_manifest_record(node, segment, filename) ⇒ Object

Determine the most specific manifest record for the given segment/filename, given information in the node. Throws FileNotFound if there is no such segment and filename in the manifest.

A manifest record is a Mash that follows the following form: 

:name => "example.rb",
:path => "files/default/example.rb",
:specificity => "default",
:checksum => "1234"




294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
 
# File 'lib/chef/cookbook_version.rb', line 294

def preferred_manifest_record(node, segment, filename)
  found_pref = find_preferred_manifest_record(node, segment, filename)
  if found_pref
    manifest_records_by_path[found_pref]
  else
    if %i{files templates}.include?(segment)
      error_message = "Cookbook '#{name}' (#{version}) does not contain a file at any of these locations:\n"
      error_locations = if filename.is_a?(Array)
                          filename.map { |name| "  #{File.join(segment.to_s, name)}" }
                        else
                          [
                            "  #{segment}/host-#{node[:fqdn]}/#{filename}",
                            "  #{segment}/#{node[:platform]}-#{node[:platform_version]}/#{filename}",
                            "  #{segment}/#{node[:platform]}/#{filename}",
                            "  #{segment}/default/#{filename}",
                            "  #{segment}/#{filename}",
                          ]
                        end
      error_message << error_locations.join("\n")
      existing_files = segment_filenames(segment)
      # Strip the root_dir prefix off all files for readability
      pretty_existing_files = existing_files.map do |path|
        if root_dir
          path[root_dir.length + 1..-1]
        else
          path
        end
      end
      # Show the files that the cookbook does have. If the user made a typo,
      # hopefully they'll see it here.
      unless pretty_existing_files.empty?
        error_message << "\n\nThis cookbook _does_ contain: ['#{pretty_existing_files.join("','")}']"
      end
      raise Chef::Exceptions::FileNotFound, error_message
    else
      raise Chef::Exceptions::FileNotFound, "cookbook #{name} does not contain file #{segment}/#{filename}"
    end
  end
end

#preferred_manifest_records_for_directory(node, segment, dirname) ⇒ Object

Determine the manifest records from the most specific directory for the given node. See #preferred_manifest_record for a description of entries of the returned Array.

Raises:



383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
 
# File 'lib/chef/cookbook_version.rb', line 383

def preferred_manifest_records_for_directory(node, segment, dirname)
  preferences = preferences_for_path(node, segment, dirname)
  records_by_pref = {}
  preferences.each { |pref| records_by_pref[pref] = [] }

  files_for(segment).each do |manifest_record|
    manifest_record_path = manifest_record[:path]

    # extract the preference part from the path.
    if manifest_record_path =~ %r{(#{Regexp.escape(segment.to_s)}/[^/]+/#{Regexp.escape(dirname)})/.+$}
      # Note the specificity_dirname includes the segment and
      # dirname argument as above, which is what
      # preferences_for_path returns. It could be
      # "files/ubuntu-9.10/dirname", for example.
      specificity_dirname = $1

      # Record the specificity_dirname only if it's in the list of
      # valid preferences
      if records_by_pref[specificity_dirname]
        records_by_pref[specificity_dirname] << manifest_record
      end
    end
  end

  best_pref = preferences.find { |pref| !records_by_pref[pref].empty? }

  raise Chef::Exceptions::FileNotFound, "cookbook #{name} (#{version}) has no directory #{segment}/default/#{dirname}" unless best_pref

  records_by_pref[best_pref]
end

#recipe_filenames_by_name ⇒ Object 



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

def recipe_filenames_by_name
  @recipe_filenames_by_name ||= begin
    name_map = filenames_by_name(files_for("recipes"))
    root_alias = cookbook_manifest.root_files.find { |record| record[:name] == "root_files/recipe.rb" }
    if root_alias
      Chef::Log.error("Cookbook #{name} contains both recipe.rb and and recipes/default.rb, ignoring recipes/default.rb") if name_map["default"]
      name_map["default"] = root_alias[:full_path]
    end
    name_map
  end
end

#recipe_json_filenames_by_name ⇒ Object 



155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/chef/cookbook_version.rb', line 155

def recipe_json_filenames_by_name
  @recipe_json_filenames_by_name ||= begin
    name_map = json_filenames_by_name(files_for("recipes"))
    root_alias = cookbook_manifest.root_files.find { |record|
      record[:name] == "root_files/recipe.json"
    }
    if root_alias
      Chef::Log.error("Cookbook #{name} contains both recipe.json and recipes/default.json, ignoring recipes/default.json") if name_map["default"]
      name_map["default"] = root_alias[:full_path]
    end
    name_map
  end
end

#recipe_yml_filenames_by_name ⇒ Object 



140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/chef/cookbook_version.rb', line 140

def recipe_yml_filenames_by_name
  @recipe_yml_filenames_by_name ||= begin
    name_map = yml_filenames_by_name(files_for("recipes"))
    root_alias = cookbook_manifest.root_files.find { |record|
      record[:name] == "root_files/recipe.yml" ||
        record[:name] == "root_files/recipe.yaml"
    }
    if root_alias
      Chef::Log.error("Cookbook #{name} contains both recipe.yml and recipes/default.yml, ignoring recipes/default.yml") if name_map["default"]
      name_map["default"] = root_alias[:full_path]
    end
    name_map
  end
end

#relative_filenames_in_preferred_directory(node, segment, dirname) ⇒ Object

Raises:



343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
 
# File 'lib/chef/cookbook_version.rb', line 343

def relative_filenames_in_preferred_directory(node, segment, dirname)
  preferences = preferences_for_path(node, segment, dirname)
  filenames_by_pref = {}
  preferences.each { |pref| filenames_by_pref[pref] = [] }

  files_for(segment).each do |manifest_record|
    manifest_record_path = manifest_record[:path]

    # find the NON SPECIFIC filenames, but prefer them by filespecificity.
    # For example, if we have a file:
    # 'files/default/somedir/somefile.conf' we only keep
    # 'somedir/somefile.conf'. If there is also
    # 'files/$hostspecific/somedir/otherfiles' that matches the requested
    # hostname specificity, that directory will win, as it is more specific.
    #
    # This is clearly ugly b/c the use case is for remote directory, where
    # we're just going to make cookbook_files out of these and make the
    # cookbook find them by filespecificity again. but it's the shortest
    # path to "success" for now.
    if manifest_record_path =~ %r{(#{Regexp.escape(segment.to_s)}/[^/]*/?#{Regexp.escape(dirname)})/.+$}
      specificity_dirname = $1
      non_specific_path = manifest_record_path[%r{#{Regexp.escape(segment.to_s)}/[^/]*/?#{Regexp.escape(dirname)}/(.+)$}, 1]
      # Record the specificity_dirname only if it's in the list of
      # valid preferences
      if filenames_by_pref[specificity_dirname]
        filenames_by_pref[specificity_dirname] << non_specific_path
      end
    end
  end

  best_pref = preferences.find { |pref| !filenames_by_pref[pref].empty? }

  raise Chef::Exceptions::FileNotFound, "cookbook #{name} has no directory #{segment}/default/#{dirname}" unless best_pref

  filenames_by_pref[best_pref]
end

#reload_metadata! ⇒ Object 



505
506
507
508
509
 
# File 'lib/chef/cookbook_version.rb', line 505

def reload_metadata!
  if File.exist?(metadata_json_file)
    metadata.from_json(IO.read(metadata_json_file))
  end
end

#root_dir ⇒ Object

The first root path is the primary cookbook dir, from which metadata is loaded



68
69
70
 
# File 'lib/chef/cookbook_version.rb', line 68

def root_dir
  root_paths[0]
end

#segment_filenames(segment) ⇒ Object 



266
267
268
 
# File 'lib/chef/cookbook_version.rb', line 266

def segment_filenames(segment)
  files_for(segment).map { |f| f["full_path"] || File.join(root_dir, f["path"]) }
end

#version ⇒ Object 



107
108
109
 
# File 'lib/chef/cookbook_version.rb', line 107

def version
  metadata.version
end

#version=(new_version) ⇒ Object 



122
123
124
125
 
# File 'lib/chef/cookbook_version.rb', line 122

def version=(new_version)
  cookbook_manifest.reset!
  metadata.version(new_version)
end