Class: Chef::CookbookVersion

Inherits:
Object
  • Object
show all
Includes:
IndexQueue::Indexable, 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. – TODO: timh/cw: 5-24-2010: mutators for files (e.g., recipe_filenames=, recipe_filenames.insert) should dirty the manifest so it gets regenerated.

Constant Summary collapse

COOKBOOK_SEGMENTS =
[ :resources, :providers, :recipes, :definitions, :libraries, :attributes, :files, :templates, :root_files ]
DESIGN_DOCUMENT =
{
  "version" => 8,
  "language" => "javascript",
  "views" => {
    "all" => {
      "map" => <<-EOJS
      function(doc) {
        if (doc.chef_type == "cookbook_version") {
          emit(doc.name, doc);
        }
      }
      EOJS
    },
    "all_id" => {
      "map" => <<-EOJS
      function(doc) {
        if (doc.chef_type == "cookbook_version") {
          emit(doc.name, doc.name);
        }
      }
      EOJS
    },
    "all_with_version" => {
      "map" => <<-EOJS
      function(doc) {
        if (doc.chef_type == "cookbook_version") {
          emit(doc.cookbook_name, doc.version);
        }
      }
      EOJS
    },
    "all_with_version_and_deps" => {
      "map" => <<-JS
      function(doc) {
        if (doc.chef_type == "cookbook_version") {
          emit(doc.cookbook_name, {version: doc.version, deps: doc.metadata.dependencies});
        }
      }
      JS
    },
    "all_latest_version" => {
      "map" => %q@
      function(doc) {
        if (doc.chef_type == "cookbook_version") {
          emit(doc.cookbook_name, doc.version);
        }
      }
      @,
      "reduce" => %q@
      function(keys, values, rereduce) {
        var result = null;

        for (var idx in values) {
          var value = values[idx];

          if (idx == 0) {
            result = value;
            continue;
          }

          var valueParts = value.split('.').map(function(v) { return parseInt(v); });
          var resultParts = result.split('.').map(function(v) { return parseInt(v); });

          if (valueParts[0] != resultParts[0]) {
            if (valueParts[0] > resultParts[0]) {
              result = value;
            }
          }
          else if (valueParts[1] != resultParts[1]) {
            if (valueParts[1] > resultParts[1]) {
              result = value;
            }
          }
          else if (valueParts[2] != resultParts[2]) {
            if (valueParts[2] > resultParts[2]) {
              result = value;
            }
          }
        }
        return result;
      }
      @
    },
    "all_latest_version_by_id" => {
      "map" => %q@
      function(doc) {
        if (doc.chef_type == "cookbook_version") {
          emit(doc.cookbook_name, {version: doc.version, id:doc._id});
        }
      }
      @,
      "reduce" => %q@
      function(keys, values, rereduce) {
        var result = null;

        for (var idx in values) {
          var value = values[idx];

          if (idx == 0) {
            result = value;
            continue;
          }

          var valueParts = value.version.split('.').map(function(v) { return parseInt(v); });
          var resultParts = result.version.split('.').map(function(v) { return parseInt(v); });

          if (valueParts[0] != resultParts[0]) {
            if (valueParts[0] > resultParts[0]) {
              result = value;
            }
          }
          else if (valueParts[1] != resultParts[1]) {
            if (valueParts[1] > resultParts[1]) {
              result = value;
            }
          }
          else if (valueParts[2] != resultParts[2]) {
            if (valueParts[2] > resultParts[2]) {
              result = value;
            }
          }
        }
        return result;
      }
      @
    },
  }
}

Instance Attribute Summary collapse

Attributes included from IndexQueue::Indexable

#index_id

Class Method Summary collapse

Instance Method Summary collapse

Methods included from IndexQueue::Indexable

#add_to_index, #delete_from_index, included, #index_object_type, #with_indexer_metadata

Constructor Details

#initialize(name, couchdb = nil) ⇒ CookbookVersion

Creates a new Chef::CookbookVersion object.

Returns

object<Chef::CookbookVersion>

Duh. :)



424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
# File 'lib/chef/cookbook_version.rb', line 424

def initialize(name, couchdb=nil)
  @name = name
  @frozen = false
  @attribute_filenames = Array.new
  @definition_filenames = Array.new
  @template_filenames = Array.new
  @file_filenames = Array.new
  @recipe_filenames = Array.new
  @recipe_filenames_by_name = Hash.new
  @library_filenames = Array.new
  @resource_filenames = Array.new
  @provider_filenames = Array.new
  @metadata_filenames = Array.new
  @root_dir = nil
  @root_filenames = Array.new
  @couchdb_id = nil
  @couchdb = couchdb || Chef::CouchDB.new
  @couchdb_rev = nil
  @status = :ready
  @manifest = nil
  @file_vendor = nil
  @metadata = Chef::Cookbook::Metadata.new
end

Instance Attribute Details

#attribute_filenamesObject Also known as: attribute_files

attribute_filenames also has a setter that has non-default functionality.



269
270
271
# File 'lib/chef/cookbook_version.rb', line 269

def attribute_filenames
  @attribute_filenames
end

#attribute_filenames_by_short_filenameObject (readonly)

Returns the value of attribute attribute_filenames_by_short_filename



276
277
278
# File 'lib/chef/cookbook_version.rb', line 276

def attribute_filenames_by_short_filename
  @attribute_filenames_by_short_filename
end

#couchdbObject

Returns the value of attribute couchdb



263
264
265
# File 'lib/chef/cookbook_version.rb', line 263

def couchdb
  @couchdb
end

#couchdb_idObject

Returns the value of attribute couchdb_id



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

def couchdb_id
  @couchdb_id
end

#couchdb_revObject

Returns the value of attribute couchdb_rev



262
263
264
# File 'lib/chef/cookbook_version.rb', line 262

def couchdb_rev
  @couchdb_rev
end

#definition_filenamesObject

Returns the value of attribute definition_filenames



251
252
253
# File 'lib/chef/cookbook_version.rb', line 251

def definition_filenames
  @definition_filenames
end

#file_filenamesObject

Returns the value of attribute file_filenames



253
254
255
# File 'lib/chef/cookbook_version.rb', line 253

def file_filenames
  @file_filenames
end

#library_filenamesObject

Returns the value of attribute library_filenames



254
255
256
# File 'lib/chef/cookbook_version.rb', line 254

def library_filenames
  @library_filenames
end

#metadataObject

Returns the value of attribute metadata



259
260
261
# File 'lib/chef/cookbook_version.rb', line 259

def 
  @metadata
end

#metadata_filenamesObject

Returns the value of attribute metadata_filenames



260
261
262
# File 'lib/chef/cookbook_version.rb', line 260

def 
  @metadata_filenames
end

#nameObject

Returns the value of attribute name



258
259
260
# File 'lib/chef/cookbook_version.rb', line 258

def name
  @name
end

#provider_filenamesObject

Returns the value of attribute provider_filenames



256
257
258
# File 'lib/chef/cookbook_version.rb', line 256

def provider_filenames
  @provider_filenames
end

#recipe_filenamesObject Also known as: recipe_files

recipe_filenames also has a setter that has non-default functionality.



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

def recipe_filenames
  @recipe_filenames
end

#recipe_filenames_by_nameObject (readonly)

Returns the value of attribute recipe_filenames_by_name



275
276
277
# File 'lib/chef/cookbook_version.rb', line 275

def recipe_filenames_by_name
  @recipe_filenames_by_name
end

#resource_filenamesObject

Returns the value of attribute resource_filenames



255
256
257
# File 'lib/chef/cookbook_version.rb', line 255

def resource_filenames
  @resource_filenames
end

#root_dirObject

Returns the value of attribute root_dir



250
251
252
# File 'lib/chef/cookbook_version.rb', line 250

def root_dir
  @root_dir
end

#root_filenamesObject

Returns the value of attribute root_filenames



257
258
259
# File 'lib/chef/cookbook_version.rb', line 257

def root_filenames
  @root_filenames
end

#statusObject

Returns the value of attribute status



261
262
263
# File 'lib/chef/cookbook_version.rb', line 261

def status
  @status
end

#template_filenamesObject

Returns the value of attribute template_filenames



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

def template_filenames
  @template_filenames
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.



888
889
890
891
892
893
894
895
896
897
898
899
# File 'lib/chef/cookbook_version.rb', line 888

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

.cacheObject



299
300
301
# File 'lib/chef/cookbook_version.rb', line 299

def self.cache
  Chef::FileCache
end

.cdb_by_name(cookbook_name, couchdb = nil) ⇒ Object

Couchdb



910
911
912
913
914
915
# File 'lib/chef/cookbook_version.rb', line 910

def self.cdb_by_name(cookbook_name, couchdb=nil)
  cdb = (couchdb || Chef::CouchDB.new)
  options = { :startkey => cookbook_name, :endkey => cookbook_name }
  rs = cdb.get_view("cookbooks", "all_with_version", options)
  rs["rows"].inject({}) { |memo, row| memo.has_key?(row["key"]) ? memo[row["key"]] << row["value"] : memo[row["key"]] = [ row["value"] ]; memo }
end

.cdb_list(inflate = false, couchdb = nil) ⇒ Object



938
939
940
941
942
943
944
945
946
# File 'lib/chef/cookbook_version.rb', line 938

def self.cdb_list(inflate=false, couchdb=nil)
  couchdb ||= Chef::CouchDB.new
  if inflate
    couchdb.list("cookbooks", true)["rows"].collect{|r| r["value"]}
  else
    # If you modify this, please make sure the desc sorted order on the versions doesn't get broken.
    couchdb.get_view("cookbooks", "all_with_version")["rows"].inject({}) { |mapped, row| mapped[row["key"]]||=Array.new; mapped[row["key"]].push(Chef::Version.new(row["value"])); mapped[row["key"]].sort!.reverse!; mapped}
  end
end

.cdb_list_latest(inflate = false, couchdb = nil) ⇒ Object



921
922
923
924
925
926
927
928
929
930
# File 'lib/chef/cookbook_version.rb', line 921

def self.cdb_list_latest(inflate=false, couchdb=nil)
  couchdb ||= Chef::CouchDB.new
  if inflate
    doc_ids = cdb_list_latest_ids.map {|i|i["id"]}
    couchdb.bulk_get(doc_ids)
  else
    results = couchdb.get_view("cookbooks", "all_latest_version", :group=>true)["rows"]
    results.inject({}) { |mapped, row| mapped[row["key"]] = row["value"]; mapped}
  end
end

.cdb_list_latest_ids(inflate = false, couchdb = nil) ⇒ Object



932
933
934
935
936
# File 'lib/chef/cookbook_version.rb', line 932

def self.cdb_list_latest_ids(inflate=false, couchdb=nil)
  couchdb ||= Chef::CouchDB.new
  results = couchdb.get_view("cookbooks", "all_latest_version_by_id", :group=>true)["rows"]
  results.map { |name_and_id| name_and_id["value"]}
end

.cdb_load(name, version = 'latest', couchdb = nil) ⇒ Object



948
949
950
951
952
953
954
955
956
# File 'lib/chef/cookbook_version.rb', line 948

def self.cdb_load(name, version='latest', couchdb=nil)
  cdb = couchdb || Chef::CouchDB.new
  if version == "latest" || version == "_latest"
    rs = cdb.get_view("cookbooks", "all_latest_version", :key => name, :descending => true, :group => true, :reduce => true)["rows"].first
    cdb.load("cookbook_version", "#{rs["key"]}-#{rs["value"]}")
  else
    cdb.load("cookbook_version", "#{name}-#{version}")
  end
end

.checksum_cookbook_file(filepath) ⇒ Object

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



280
281
282
283
284
285
# File 'lib/chef/cookbook_version.rb', line 280

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

.chef_server_restObject

REST API



846
847
848
# File 'lib/chef/cookbook_version.rb', line 846

def self.chef_server_rest
  Chef::REST.new(Chef::Config[:chef_server_url])
end

.cleanup_file_cacheObject



402
403
404
405
406
407
408
409
410
411
412
413
# File 'lib/chef/cookbook_version.rb', line 402

def self.cleanup_file_cache
  unless Chef::Config[:solo]
    # Delete each file in the cache that we didn't encounter in the
    # manifest.
    cache.find(File.join(%w{cookbooks ** *})).each do |cache_filename|
      unless valid_cache_entries[cache_filename]
        Chef::Log.info("Removing #{cache_filename} from the cache; it is no longer needed by chef-client.")
        cache.delete(cache_filename)
      end
    end
  end
end

.clear_obsoleted_cookbooks(cookbook_hash) ⇒ Object

Iterates over cached cookbooks' files, removing files belonging to cookbooks that don't appear in cookbook_hash



330
331
332
333
334
335
336
337
338
339
# File 'lib/chef/cookbook_version.rb', line 330

def self.clear_obsoleted_cookbooks(cookbook_hash)
  # Remove all cookbooks no longer relevant to this node
  cache.find(File.join(%w{cookbooks ** *})).each do |cache_file|
    cache_file =~ /^cookbooks\/([^\/]+)\//
    unless cookbook_hash.has_key?($1)
      Chef::Log.info("Removing #{cache_file} from the cache; its cookbook is no longer needed on this client.")
      cache.delete(cache_file)
    end
  end
end

.create_design_document(couchdb = nil) ⇒ Object



917
918
919
# File 'lib/chef/cookbook_version.rb', line 917

def self.create_design_document(couchdb=nil)
  (couchdb || Chef::CouchDB.new).create_design_document("cookbooks", DESIGN_DOCUMENT)
end

.json_create(o) ⇒ Object



794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
# File 'lib/chef/cookbook_version.rb', line 794

def self.json_create(o)
  cookbook_version = new(o["cookbook_name"])
  if o.has_key?('_rev')
    cookbook_version.couchdb_rev = o["_rev"] if o.has_key?("_rev")
    o.delete("_rev")
  end
  if o.has_key?("_id")
    cookbook_version.couchdb_id = o["_id"] if o.has_key?("_id")
    cookbook_version.index_id = cookbook_version.couchdb_id
    o.delete("_id")
  end
  # We want the Chef::Cookbook::Metadata object to always be inflated
  cookbook_version. = Chef::Cookbook::Metadata.from_hash(o["metadata"])
  cookbook_version.manifest = o

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

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

.latest_cookbooksObject

Get the newest version of all cookbooks



902
903
904
# File 'lib/chef/cookbook_version.rb', line 902

def self.latest_cookbooks
  chef_server_rest.get_rest('cookbooks/_latest')
end

.listObject



878
879
880
# File 'lib/chef/cookbook_version.rb', line 878

def self.list
  chef_server_rest.get_rest('cookbooks')
end

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



873
874
875
876
# File 'lib/chef/cookbook_version.rb', line 873

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

.reset_cache_validityObject



295
296
297
# File 'lib/chef/cookbook_version.rb', line 295

def self.reset_cache_validity
  @valid_cache_entries = nil
end

.sync_cookbook_file_cache(cookbook) ⇒ Object

Update the file caches for a given cache segment. Takes a segment name and a hash that matches one of the cookbooks/_attribute_files style remote file listings.

Parameters

cookbook<Chef::Cookbook>

The cookbook to update

valid_cache_entries<Hash>

Out-param; Added to this hash are the files that

were referred to by this cookbook



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
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
# File 'lib/chef/cookbook_version.rb', line 349

def self.sync_cookbook_file_cache(cookbook)
  Chef::Log.debug("Synchronizing cookbook #{cookbook.name}")

  # files and templates are lazily loaded, and will be done later.
  eager_segments = COOKBOOK_SEGMENTS.dup
  eager_segments.delete(:files)
  eager_segments.delete(:templates)

  eager_segments.each do |segment|
    segment_filenames = Array.new
    cookbook.manifest[segment].each do |manifest_record|
      # segment = cookbook segment
      # remote_list = list of file hashes
      #
      # We need the list of known good attribute files, so we can delete any that are
      # just laying about.

      cache_filename = File.join("cookbooks", cookbook.name, manifest_record['path'])
      valid_cache_entries[cache_filename] = true

      current_checksum = nil
      if cache.has_key?(cache_filename)
        current_checksum = checksum_cookbook_file(cache.load(cache_filename, false))
      end

      # If the checksums are different between on-disk (current) and on-server
      # (remote, per manifest), do the update. This will also execute if there
      # is no current checksum.
      if current_checksum != manifest_record['checksum']
        raw_file = chef_server_rest.get_rest(manifest_record[:url], true)

        Chef::Log.info("Storing updated #{cache_filename} in the cache.")
        cache.move_to(raw_file.path, cache_filename)
      else
        Chef::Log.debug("Not storing #{cache_filename}, as the cache is up to date.")
      end

      # make the segment filenames a full path.
      full_path_cache_filename = cache.load(cache_filename, false)
      segment_filenames << full_path_cache_filename
    end

    # replace segment filenames with a full-path one.
    if segment.to_sym == :recipes
      cookbook.recipe_filenames = segment_filenames
    elsif segment.to_sym == :attributes
      cookbook.attribute_filenames = segment_filenames
    else
      cookbook.segment_filenames(segment).replace(segment_filenames)
    end
  end
end

.sync_cookbooks(cookbook_hash) ⇒ Object

Synchronizes all the cookbooks from the chef-server.

Returns

true

Always returns true



313
314
315
316
317
318
319
320
321
322
323
324
325
326
# File 'lib/chef/cookbook_version.rb', line 313

def self.sync_cookbooks(cookbook_hash)
  Chef::Log.info("Loading cookbooks [#{cookbook_hash.keys.sort.join(', ')}]")
  Chef::Log.debug("Cookbooks detail: #{cookbook_hash.inspect}")

  clear_obsoleted_cookbooks(cookbook_hash)

  # Synchronize each of the node's cookbooks, and add to the
  # valid_cache_entries hash.
  cookbook_hash.values.each do |cookbook|
    sync_cookbook_file_cache(cookbook)
  end

  true
end

.valid_cache_entriesObject

Keep track of the filenames that we use in both eager cookbook downloading (during sync_cookbooks) and lazy (during the run itself, through FileVendor). After the run is over, clean up the cache.



291
292
293
# File 'lib/chef/cookbook_version.rb', line 291

def self.valid_cache_entries
  @valid_cache_entries ||= {}
end

Instance Method Details

#<=>(o) ⇒ Object



983
984
985
986
987
988
989
# File 'lib/chef/cookbook_version.rb', line 983

def <=>(o)
  raise Chef::Exceptions::CookbookVersionNameMismatch if self.name != o.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(self.version) <=> Chef::Version.new(o.version)
end

#cdb_destroyObject



958
959
960
# File 'lib/chef/cookbook_version.rb', line 958

def cdb_destroy
  (couchdb || Chef::CouchDB.new).delete("cookbook_version", full_name, couchdb_rev)
end

#cdb_saveObject



974
975
976
# File 'lib/chef/cookbook_version.rb', line 974

def cdb_save
  @couchdb_rev = couchdb.store("cookbook_version", full_name, self)["rev"]
end

#checksumsObject

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



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

def checksums
  unless @checksums
    generate_manifest
  end
  @checksums
end

#chef_server_restObject



850
851
852
# File 'lib/chef/cookbook_version.rb', line 850

def chef_server_rest
  self.class.chef_server_rest
end

#destroyObject



868
869
870
871
# File 'lib/chef/cookbook_version.rb', line 868

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

#force_save_urlObject

Adds the `force=true` parameter to the upload URL. This allows the user to overwrite a frozen cookbook (a PUT against the normal #save_url raises a 409 Conflict in this case).



864
865
866
# File 'lib/chef/cookbook_version.rb', line 864

def force_save_url
  "cookbooks/#{name}/#{version}?force=true"
end

#freeze_versionObject



459
460
461
# File 'lib/chef/cookbook_version.rb', line 459

def freeze_version
  @frozen = true
end

#frozen_version?Boolean

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

Returns:

  • (Boolean)


455
456
457
# File 'lib/chef/cookbook_version.rb', line 455

def frozen_version?
  @frozen
end

#full_nameObject



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

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

#fully_qualified_recipe_namesObject

Return recipe names in the form of cookbook_name::recipe_name



546
547
548
549
550
551
552
# File 'lib/chef/cookbook_version.rb', line 546

def fully_qualified_recipe_names
  results = Array.new
  recipe_filenames_by_name.each_key do |rname|
    results << "#{name}::#{rname}"
  end
  results
end

#generate_manifest_with_urls(&url_generator) ⇒ Object



816
817
818
819
820
821
822
823
824
825
826
827
# File 'lib/chef/cookbook_version.rb', line 816

def generate_manifest_with_urls(&url_generator)
  rendered_manifest = manifest.dup
  COOKBOOK_SEGMENTS.each do |segment|
    if rendered_manifest.has_key?(segment)
      rendered_manifest[segment].each do |manifest_record|
        url_options = { :cookbook_name => name.to_s, :cookbook_version => version, :checksum => manifest_record["checksum"] }
        manifest_record["url"] = url_generator.call(url_options)
      end
    end
  end
  rendered_manifest
end

#load_recipe(recipe_name, run_context) ⇒ Object

called from DSL



565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
# File 'lib/chef/cookbook_version.rb', line 565

def load_recipe(recipe_name, run_context)
  unless recipe_filenames_by_name.has_key?(recipe_name)
    raise ArgumentError, "Cannot find a recipe matching #{recipe_name} in cookbook #{name}"
  end

  Chef::Log.debug("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 #{recipe_name} for cookbook #{name}"
  end

  recipe.from_file(recipe_filename)
  recipe
end

#manifestObject

A manifest is a Mash that maps segment names to arrays of manifest records (see #preferred_manifest_record for format of manifest records), as well as describing cookbook metadata. The manifest follows a form like the following:

{
  :cookbook_name = "apache2",
  :version = "1.0",
  :name = "Apache 2"
  :metadata = ???TODO: timh/cw: 5-24-2010: describe this format,

  :files => [
    {
      :name => "afile.rb",
      :path => "files/ubuntu-9.10/afile.rb",
      :checksum => "2222",
      :specificity => "ubuntu-9.10"
    },
  ],
  :templates => [ manifest_record1, ... ],
  ...
}


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

def manifest
  unless @manifest
    generate_manifest
  end
  @manifest
end

#manifest=(new_manifest) ⇒ Object



497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
# File 'lib/chef/cookbook_version.rb', line 497

def manifest=(new_manifest)
  @manifest = Mash.new new_manifest
  @checksums = extract_checksums_from_manifest(@manifest)
  @manifest_records_by_path = extract_manifest_records_by_path(@manifest)

  COOKBOOK_SEGMENTS.each do |segment|
    next unless @manifest.has_key?(segment)
    filenames = @manifest[segment].map{|manifest_record| manifest_record['name']}

    if segment == :recipes
      self.recipe_filenames = filenames
    elsif segment == :attributes
      self.attribute_filenames = filenames
    else
      segment_filenames(segment).clear
      filenames.each { |filename| segment_filenames(segment) << filename }
    end
  end
end

#manifest_records_by_pathObject



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

def manifest_records_by_path
  @manifest_records_by_path || generate_manifest
  @manifest_records_by_path
end

#metadata_json_fileObject



829
830
831
# File 'lib/chef/cookbook_version.rb', line 829

def 
  File.join(root_dir, "metadata.json")
end

#metadata_rb_fileObject



833
834
835
# File 'lib/chef/cookbook_version.rb', line 833

def 
  File.join(root_dir, "metadata.rb")
end

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



654
655
656
657
658
659
660
661
# File 'lib/chef/cookbook_version.rb', line 654

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"



621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
# File 'lib/chef/cookbook_version.rb', line 621

def preferred_manifest_record(node, segment, filename)
  preferences = preferences_for_path(node, segment, filename)

  # ensure that we generate the manifest, which will also generate
  # @manifest_records_by_path
  manifest

  # in order of prefernce, look for the filename in the manifest
  found_pref = preferences.find {|preferred_filename| @manifest_records_by_path[preferred_filename] }
  if found_pref
    @manifest_records_by_path[found_pref]
  else
    if segment == :files || segment == :templates
      error_message = "Cookbook '#{name}' (#{version}) does not contain a file at any of these locations:\n"
      error_locations = [
        "  #{segment}/#{node[:platform]}-#{node[:platform_version]}/#{filename}",
        "  #{segment}/#{node[:platform]}/#{filename}",
        "  #{segment}/default/#{filename}",
      ]
      error_message << error_locations.join("\n")
      existing_files = segment_filenames(segment)
      # Show the files that the cookbook does have. If the user made a typo,
      # hopefully they'll see it here.
      unless existing_files.empty?
        error_message << "\n\nThis cookbook _does_ contain: ['#{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.



704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
# File 'lib/chef/cookbook_version.rb', line 704

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

  manifest[segment].each do |manifest_record|
    manifest_record_path = manifest_record[:path]

    # extract the preference part from the path.
    if manifest_record_path =~ /(#{Regexp.escape(segment.to_s)}\/[^\/]+\/#{Regexp.escape(dirname)})\/.+$/
      # Note the specificy_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

#purgeObject

Runs on Chef Server (API); deletes the cookbook from couchdb and also destroys associated checksum documents



964
965
966
967
968
969
970
971
972
# File 'lib/chef/cookbook_version.rb', line 964

def purge
  checksums.keys.each do |checksum|
    begin
      Chef::Checksum.cdb_load(checksum, couchdb).purge
    rescue Chef::Exceptions::CouchDBNotFound
    end
  end
  cdb_destroy
end

#relative_filenames_in_preferred_directory(node, segment, dirname) ⇒ Object



663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
# File 'lib/chef/cookbook_version.rb', line 663

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

  manifest[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 =~ /(#{Regexp.escape(segment.to_s)}\/[^\/]+\/#{Regexp.escape(dirname)})\/.+$/
      specificity_dirname = $1
      non_specific_path = manifest_record_path[/#{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



837
838
839
840
841
# File 'lib/chef/cookbook_version.rb', line 837

def reload_metadata!
  if File.exists?()
    .from_json(IO.read())
  end
end

#save_urlObject

Return the URL to save (PUT) this object to the server via the REST api. If there is an existing document on the server and it is marked frozen, a PUT will result in a 409 Conflict.



857
858
859
# File 'lib/chef/cookbook_version.rb', line 857

def save_url
  "cookbooks/#{name}/#{version}"
end

#segment_filenames(segment) ⇒ Object



582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
# File 'lib/chef/cookbook_version.rb', line 582

def segment_filenames(segment)
  unless COOKBOOK_SEGMENTS.include?(segment)
    raise ArgumentError, "invalid segment #{segment}: must be one of #{COOKBOOK_SEGMENTS.join(', ')}"
  end

  case segment.to_sym
  when :resources
    @resource_filenames
  when :providers
    @provider_filenames
  when :recipes
    @recipe_filenames
  when :libraries
    @library_filenames
  when :definitions
    @definition_filenames
  when :attributes
    @attribute_filenames
  when :files
    @file_filenames
  when :templates
    @template_filenames
  when :root_files
    @root_filenames
  end
end

#to_hashObject



780
781
782
783
784
785
786
# File 'lib/chef/cookbook_version.rb', line 780

def to_hash
  result = manifest.dup
  result['frozen?'] = frozen_version?
  result['chef_type'] = 'cookbook_version'
  result["_rev"] = couchdb_rev if couchdb_rev
  result.to_hash
end

#to_json(*a) ⇒ Object



788
789
790
791
792
# File 'lib/chef/cookbook_version.rb', line 788

def to_json(*a)
  result = self.to_hash
  result['json_class'] = self.class.name
  result.to_json(*a)
end

#versionObject



448
449
450
# File 'lib/chef/cookbook_version.rb', line 448

def version
  .version
end

#version=(new_version) ⇒ Object



463
464
465
466
# File 'lib/chef/cookbook_version.rb', line 463

def version=(new_version)
  manifest["version"] = new_version
  .version(new_version)
end