chef 13.7.16-universal-mingw32 → 13.8.0-universal-mingw32

data/lib/chef/cookbook_uploader.rb

@@ -1,157 +1,157 @@
-
-require "set"
-require "chef/exceptions"
-require "chef/knife/cookbook_metadata"
-require "chef/digester"
-require "chef/cookbook_manifest"
-require "chef/cookbook_version"
-require "chef/cookbook/syntax_check"
-require "chef/cookbook/file_system_file_vendor"
-require "chef/util/threaded_job_queue"
-require "chef/sandbox"
-require "chef/server_api"
-
-class Chef
-  class CookbookUploader
-
-    attr_reader :cookbooks
-    attr_reader :path
-    attr_reader :opts
-    attr_reader :rest
-    attr_reader :concurrency
-
-    # Creates a new CookbookUploader.
-    # ===Arguments:
-    # * cookbooks::: A Chef::CookbookVersion or array of them describing the
-    #                cookbook(s) to be uploaded
-    # * path::: A String or Array of Strings representing the base paths to the
-    #           cookbook repositories.
-    # * opts::: (optional) An options Hash
-    # ===Options:
-    # * :force  indicates that the uploader should set the force option when
-    #           uploading the cookbook. This allows frozen CookbookVersion
-    #           documents on the server to be overwritten (otherwise a 409 is
-    #           returned by the server)
-    # * :rest   A Chef::ServerAPI object that you have configured the way you like it.
-    #           If you don't provide this, one will be created using the values
-    #           in Chef::Config.
-    # * :concurrency   An integer that decided how many threads will be used to
-    #           perform concurrent uploads
-    def initialize(cookbooks, opts = {})
-      @opts = opts
-      @cookbooks = Array(cookbooks)
-      @rest = opts[:rest] || Chef::ServerAPI.new(Chef::Config[:chef_server_url], version_class: Chef::CookbookManifestVersions)
-      @concurrency = opts[:concurrency] || 10
-      @policy_mode = opts[:policy_mode] || false
-    end
-
-    def upload_cookbooks
-      # Syntax Check
-      validate_cookbooks
-      # generate checksums of cookbook files and create a sandbox
-      checksum_files = {}
-      cookbooks.each do |cb|
-        Chef::Log.info("Saving #{cb.name}")
-        checksum_files.merge!(cb.checksums)
-      end
-
-      checksums = checksum_files.inject({}) { |memo, elt| memo[elt.first] = nil; memo }
-      new_sandbox = rest.post("sandboxes", { :checksums => checksums })
-
-      Chef::Log.info("Uploading files")
-
-      queue = Chef::Util::ThreadedJobQueue.new
-
-      checksums_to_upload = Set.new
-
-      # upload the new checksums and commit the sandbox
-      new_sandbox["checksums"].each do |checksum, info|
-        if info["needs_upload"] == true
-          checksums_to_upload << checksum
-          Chef::Log.info("Uploading #{checksum_files[checksum]} (checksum hex = #{checksum}) to #{info['url']}")
-          queue << uploader_function_for(checksum_files[checksum], checksum, info["url"], checksums_to_upload)
-        else
-          Chef::Log.debug("#{checksum_files[checksum]} has not changed")
-        end
-      end
-
-      queue.process(@concurrency)
-
-      sandbox_url = new_sandbox["uri"]
-      Chef::Log.debug("Committing sandbox")
-      # Retry if S3 is claims a checksum doesn't exist (the eventual
-      # in eventual consistency)
-      retries = 0
-      begin
-        rest.put(sandbox_url, { :is_completed => true })
-      rescue Net::HTTPServerException => e
-        if e.message =~ /^400/ && (retries += 1) <= 5
-          sleep 2
-          retry
-        else
-          raise
-        end
-      end
-
-      # files are uploaded, so save the manifest
-      cookbooks.each do |cb|
-
-        manifest = Chef::CookbookManifest.new(cb, policy_mode: policy_mode?)
-
-        save_url = opts[:force] ? manifest.force_save_url : manifest.save_url
-        begin
-          rest.put(save_url, manifest)
-        rescue Net::HTTPServerException => e
-          case e.response.code
-          when "409"
-            raise Chef::Exceptions::CookbookFrozen, "Version #{cb.version} of cookbook #{cb.name} is frozen. Use --force to override."
-          else
-            raise
-          end
-        end
-      end
-
-      Chef::Log.info("Upload complete!")
-    end
-
-    def uploader_function_for(file, checksum, url, checksums_to_upload)
-      lambda do
-        # Checksum is the hexadecimal representation of the md5,
-        # but we need the base64 encoding for the content-md5
-        # header
-        checksum64 = Base64.encode64([checksum].pack("H*")).strip
-        file_contents = File.open(file, "rb") { |f| f.read }
-
-        # Custom headers. 'content-type' disables JSON serialization of the request body.
-        headers = { "content-type" => "application/x-binary", "content-md5" => checksum64, "accept" => "application/json" }
-
-        begin
-          rest.put(url, file_contents, headers)
-          checksums_to_upload.delete(checksum)
-        rescue Net::HTTPServerException, Net::HTTPFatalError, Errno::ECONNREFUSED, Timeout::Error, Errno::ETIMEDOUT, SocketError => e
-          error_message = "Failed to upload #{file} (#{checksum}) to #{url} : #{e.message}"
-          error_message << "\n#{e.response.body}" if e.respond_to?(:response)
-          Chef::Knife.ui.error(error_message)
-          raise
-        end
-      end
-    end
-
-    def validate_cookbooks
-      cookbooks.each do |cb|
-        syntax_checker = Chef::Cookbook::SyntaxCheck.for_cookbook(cb.name)
-        Chef::Log.info("Validating ruby files")
-        exit(1) unless syntax_checker.validate_ruby_files
-        Chef::Log.info("Validating templates")
-        exit(1) unless syntax_checker.validate_templates
-        Chef::Log.info("Syntax OK")
-        true
-      end
-    end
-
-    def policy_mode?
-      @policy_mode
-    end
-
-  end
-end
+
+require "set"
+require "chef/exceptions"
+require "chef/knife/cookbook_metadata"
+require "chef/digester"
+require "chef/cookbook_manifest"
+require "chef/cookbook_version"
+require "chef/cookbook/syntax_check"
+require "chef/cookbook/file_system_file_vendor"
+require "chef/util/threaded_job_queue"
+require "chef/sandbox"
+require "chef/server_api"
+
+class Chef
+  class CookbookUploader
+
+    attr_reader :cookbooks
+    attr_reader :path
+    attr_reader :opts
+    attr_reader :rest
+    attr_reader :concurrency
+
+    # Creates a new CookbookUploader.
+    # ===Arguments:
+    # * cookbooks::: A Chef::CookbookVersion or array of them describing the
+    #                cookbook(s) to be uploaded
+    # * path::: A String or Array of Strings representing the base paths to the
+    #           cookbook repositories.
+    # * opts::: (optional) An options Hash
+    # ===Options:
+    # * :force  indicates that the uploader should set the force option when
+    #           uploading the cookbook. This allows frozen CookbookVersion
+    #           documents on the server to be overwritten (otherwise a 409 is
+    #           returned by the server)
+    # * :rest   A Chef::ServerAPI object that you have configured the way you like it.
+    #           If you don't provide this, one will be created using the values
+    #           in Chef::Config.
+    # * :concurrency   An integer that decided how many threads will be used to
+    #           perform concurrent uploads
+    def initialize(cookbooks, opts = {})
+      @opts = opts
+      @cookbooks = Array(cookbooks)
+      @rest = opts[:rest] || Chef::ServerAPI.new(Chef::Config[:chef_server_url], version_class: Chef::CookbookManifestVersions)
+      @concurrency = opts[:concurrency] || 10
+      @policy_mode = opts[:policy_mode] || false
+    end
+
+    def upload_cookbooks
+      # Syntax Check
+      validate_cookbooks
+      # generate checksums of cookbook files and create a sandbox
+      checksum_files = {}
+      cookbooks.each do |cb|
+        Chef::Log.info("Saving #{cb.name}")
+        checksum_files.merge!(cb.checksums)
+      end
+
+      checksums = checksum_files.inject({}) { |memo, elt| memo[elt.first] = nil; memo }
+      new_sandbox = rest.post("sandboxes", { :checksums => checksums })
+
+      Chef::Log.info("Uploading files")
+
+      queue = Chef::Util::ThreadedJobQueue.new
+
+      checksums_to_upload = Set.new
+
+      # upload the new checksums and commit the sandbox
+      new_sandbox["checksums"].each do |checksum, info|
+        if info["needs_upload"] == true
+          checksums_to_upload << checksum
+          Chef::Log.info("Uploading #{checksum_files[checksum]} (checksum hex = #{checksum}) to #{info['url']}")
+          queue << uploader_function_for(checksum_files[checksum], checksum, info["url"], checksums_to_upload)
+        else
+          Chef::Log.debug("#{checksum_files[checksum]} has not changed")
+        end
+      end
+
+      queue.process(@concurrency)
+
+      sandbox_url = new_sandbox["uri"]
+      Chef::Log.debug("Committing sandbox")
+      # Retry if S3 is claims a checksum doesn't exist (the eventual
+      # in eventual consistency)
+      retries = 0
+      begin
+        rest.put(sandbox_url, { :is_completed => true })
+      rescue Net::HTTPServerException => e
+        if e.message =~ /^400/ && (retries += 1) <= 5
+          sleep 2
+          retry
+        else
+          raise
+        end
+      end
+
+      # files are uploaded, so save the manifest
+      cookbooks.each do |cb|
+
+        manifest = Chef::CookbookManifest.new(cb, policy_mode: policy_mode?)
+
+        save_url = opts[:force] ? manifest.force_save_url : manifest.save_url
+        begin
+          rest.put(save_url, manifest)
+        rescue Net::HTTPServerException => e
+          case e.response.code
+          when "409"
+            raise Chef::Exceptions::CookbookFrozen, "Version #{cb.version} of cookbook #{cb.name} is frozen. Use --force to override."
+          else
+            raise
+          end
+        end
+      end
+
+      Chef::Log.info("Upload complete!")
+    end
+
+    def uploader_function_for(file, checksum, url, checksums_to_upload)
+      lambda do
+        # Checksum is the hexadecimal representation of the md5,
+        # but we need the base64 encoding for the content-md5
+        # header
+        checksum64 = Base64.encode64([checksum].pack("H*")).strip
+        file_contents = File.open(file, "rb") { |f| f.read }
+
+        # Custom headers. 'content-type' disables JSON serialization of the request body.
+        headers = { "content-type" => "application/x-binary", "content-md5" => checksum64, "accept" => "application/json" }
+
+        begin
+          rest.put(url, file_contents, headers)
+          checksums_to_upload.delete(checksum)
+        rescue Net::HTTPServerException, Net::HTTPFatalError, Errno::ECONNREFUSED, Timeout::Error, Errno::ETIMEDOUT, SocketError => e
+          error_message = "Failed to upload #{file} (#{checksum}) to #{url} : #{e.message}"
+          error_message << "\n#{e.response.body}" if e.respond_to?(:response)
+          Chef::Knife.ui.error(error_message)
+          raise
+        end
+      end
+    end
+
+    def validate_cookbooks
+      cookbooks.each do |cb|
+        syntax_checker = Chef::Cookbook::SyntaxCheck.for_cookbook(cb.name)
+        Chef::Log.info("Validating ruby files")
+        exit(1) unless syntax_checker.validate_ruby_files
+        Chef::Log.info("Validating templates")
+        exit(1) unless syntax_checker.validate_templates
+        Chef::Log.info("Syntax OK")
+        true
+      end
+    end
+
+    def policy_mode?
+      @policy_mode
+    end
+
+  end
+end

data/lib/chef/cookbook_version.rb

@@ -1,549 +1,549 @@
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Nuo Yan (<nuo@chef.io>)
-# Author:: Christopher Walters (<cw@chef.io>)
-# Author:: Tim Hinderliter (<tim@chef.io>)
-# Author:: Seth Falcon (<seth@chef.io>)
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require "chef/log"
-require "chef/cookbook/file_vendor"
-require "chef/cookbook/metadata"
-require "chef/version_class"
-require "chef/digester"
-require "chef/cookbook_manifest"
-require "chef/server_api"
-
-class Chef
-
-  # == 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.
-  class CookbookVersion
-
-    include Comparable
-    extend Forwardable
-
-    def_delegator :@cookbook_manifest, :files_for
-    def_delegator :@cookbook_manifest, :each_file
-
-    COOKBOOK_SEGMENTS = [ :resources, :providers, :recipes, :definitions, :libraries, :attributes, :files, :templates, :root_files ]
-
-    attr_reader :all_files
-
-    attr_accessor :root_paths
-    attr_accessor :name
-
-    # A Chef::Cookbook::Metadata object. It has a setter that fixes up the
-    # metadata to add descriptions of the recipes contained in this
-    # CookbookVersion.
-    attr_reader :metadata
-
-    attr_reader :recipe_filenames_by_name
-    attr_reader :attribute_filenames_by_short_filename
-
-    attr_accessor :chef_server_rest
-
-    # 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.
-    # @api private
-    attr_accessor :identifier
-
-    # The first root path is the primary cookbook dir, from which metadata is loaded
-    def root_dir
-      root_paths[0]
-    end
-
-    def all_files=(files)
-      @all_files = Array(files)
-      cookbook_manifest.reset!
-    end
-
-    # This is the one and only method that knows how cookbook files'
-    # checksums are generated.
-    def self.checksum_cookbook_file(filepath)
-      Chef::Digester.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
-
-    def self.cache
-      Chef::FileCache
-    end
-
-    # Creates a new Chef::CookbookVersion object.
-    #
-    # === Returns
-    # object<Chef::CookbookVersion>:: Duh. :)
-    def initialize(name, *root_paths, chef_server_rest: nil)
-      @name = name
-      @root_paths = root_paths
-      @frozen = false
-
-      @all_files = Array.new
-
-      @file_vendor = nil
-      @cookbook_manifest = Chef::CookbookManifest.new(self)
-      @metadata = Chef::Cookbook::Metadata.new
-      @chef_server_rest = chef_server_rest
-    end
-
-    def version
-      metadata.version
-    end
-
-    # 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
-    def frozen_version?
-      @frozen
-    end
-
-    def freeze_version
-      @frozen = true
-    end
-
-    def version=(new_version)
-      cookbook_manifest.reset!
-      metadata.version(new_version)
-    end
-
-    def full_name
-      "#{name}-#{version}"
-    end
-
-    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] == "attributes.rb" }
-        name_map["default"] = root_alias[:full_path] if root_alias
-        name_map
-      end
-    end
-
-    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] == "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
-
-    def metadata=(metadata)
-      @metadata = metadata
-      @metadata.recipes_from_cookbook_version(self)
-      @metadata
-    end
-
-    def manifest
-      cookbook_manifest.manifest
-    end
-
-    def manifest=(new_manifest)
-      cookbook_manifest.update_from(new_manifest)
-    end
-
-    # Returns a hash of checksums to either nil or the on disk path (which is
-    # done by generate_manifest).
-    def checksums
-      cookbook_manifest.checksums
-    end
-
-    def manifest_records_by_path
-      cookbook_manifest.manifest_records_by_path
-    end
-
-    # Return recipe names in the form of cookbook_name::recipe_name
-    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
-
-    # called from DSL
-    def load_recipe(recipe_name, run_context)
-      unless recipe_filenames_by_name.has_key?(recipe_name)
-        raise Chef::Exceptions::RecipeNotFound, "could not find recipe #{recipe_name} for 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_name} files for cookbook #{name}"
-      end
-
-      recipe.from_file(recipe_filename)
-      recipe
-    end
-
-    def segment_filenames(segment)
-      files_for(segment).map { |f| f["full_path"] || File.join(root_dir, f["path"]) }
-    end
-
-    # Query whether a template file +template_filename+ is available. File
-    # specificity for the given +node+ is obeyed in the lookup.
-    def has_template_for_node?(node, template_filename)
-      !!find_preferred_manifest_record(node, :templates, template_filename)
-    end
-
-    # Query whether a cookbook_file file +cookbook_filename+ is available. File
-    # specificity for the given +node+ is obeyed in the lookup.
-    def has_cookbook_file_for_node?(node, cookbook_filename)
-      !!find_preferred_manifest_record(node, :files, cookbook_filename)
-    end
-
-    # 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"
-    # }
-    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 segment == :files || segment == :templates
-          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}/#{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
-
-    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
-
-    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 }
-
-      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 =~ /(#{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
-
-    # 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.
-    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 }
-
-      files_for(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
-
-    # Given a node, segment and path (filename or directory name),
-    # return the priority-ordered list of preference locations to
-    # look.
-    def preferences_for_path(node, segment, path)
-      # only files and templates can be platform-specific
-      if segment.to_sym == :files || segment.to_sym == :templates
-        relative_search_path = if path.is_a?(Array)
-                                 path
-                               else
-                                 begin
-                                   platform, version = Chef::Platform.find_platform_and_version(node)
-                                 rescue ArgumentError => e
-                                   # Skip platform/version if they were not found by find_platform_and_version
-                                   if e.message =~ /Cannot find a (?:platform|version)/
-                                     platform = "/unknown_platform/"
-                                     version = "/unknown_platform_version/"
-                                   else
-                                     raise
-                                   end
-                                 end
-
-                                 fqdn = node[:fqdn]
-
-                                 # Break version into components, eg: "5.7.1" => [ "5.7.1", "5.7", "5" ]
-                                 search_versions = []
-                                 parts = version.to_s.split(".")
-
-                                 parts.size.times do
-                                   search_versions << parts.join(".")
-                                   parts.pop
-                                 end
-
-                                 # Most specific to least specific places to find the path
-                                 search_path = [ File.join("host-#{fqdn}", path) ]
-                                 search_versions.each do |v|
-                                   search_path << File.join("#{platform}-#{v}", path)
-                                 end
-                                 search_path << File.join(platform.to_s, path)
-                                 search_path << File.join("default", path)
-                                 search_path << path
-
-                                 search_path
-                               end
-        relative_search_path.map { |relative_path| File.join(segment.to_s, relative_path) }
-      else
-        if segment.to_sym == :root_files
-          [path]
-        else
-          [File.join(segment, path)]
-        end
-      end
-    end
-    private :preferences_for_path
-
-    def display
-      output = Mash.new
-      output["cookbook_name"] = name
-      output["name"] = full_name
-      output["frozen?"] = frozen_version?
-      output["metadata"] = metadata.to_hash
-      output["version"] = version
-      output.merge(cookbook_manifest.by_parent_directory)
-    end
-
-    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
-
-    def self.from_cb_artifact_data(o)
-      from_hash(o)
-    end
-
-    def metadata_json_file
-      File.join(root_paths[0], "metadata.json")
-    end
-
-    def metadata_rb_file
-      File.join(root_paths[0], "metadata.rb")
-    end
-
-    def reload_metadata!
-      if File.exists?(metadata_json_file)
-        metadata.from_json(IO.read(metadata_json_file))
-      end
-    end
-
-    ##
-    # REST API
-    ##
-
-    def chef_server_rest
-      @chef_server_rest ||= chef_server_rest
-    end
-
-    def self.chef_server_rest
-      Chef::ServerAPI.new(Chef::Config[:chef_server_url], { version_class: Chef::CookbookManifestVersions })
-    end
-
-    def destroy
-      chef_server_rest.delete("cookbooks/#{name}/#{version}")
-      self
-    end
-
-    def self.load(name, version = "_latest")
-      version = "_latest" if version == "latest"
-      from_hash(chef_server_rest.get("cookbooks/#{name}/#{version}"))
-    end
-
-    # The API returns only a single version of each cookbook in the result from the cookbooks method
-    def self.list
-      chef_server_rest.get("cookbooks")
-    end
-
-    # Alias latest_cookbooks as list
-    class << self
-      alias :latest_cookbooks :list
-    end
-
-    def self.list_all_versions
-      chef_server_rest.get("cookbooks?num_versions=all")
-    end
-
-    ##
-    # 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.
-    def self.available_versions(cookbook_name)
-      chef_server_rest.get("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
-
-    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
-
-    def cookbook_manifest
-      @cookbook_manifest ||= CookbookManifest.new(self)
-    end
-
-    private
-
-    def find_preferred_manifest_record(node, segment, filename)
-      preferences = preferences_for_path(node, segment, filename)
-
-      # in order of prefernce, look for the filename in the manifest
-      preferences.find { |preferred_filename| manifest_records_by_path[preferred_filename] }
-    end
-
-    # For each manifest record, produce a mapping of base filename (i.e. recipe name
-    # or attribute file) to on disk location
-    def relative_paths_by_name(records)
-      records.select { |record| record[:name] =~ /\.rb$/ }.inject({}) { |memo, record| memo[File.basename(record[:name], ".rb")] = record[:path]; memo }
-    end
-
-    # For each manifest record, produce a mapping of base filename (i.e. recipe name
-    # or attribute file) to on disk location
-    def filenames_by_name(records)
-      records.select { |record| record[:name] =~ /\.rb$/ }.inject({}) { |memo, record| memo[File.basename(record[:name], ".rb")] = record[:full_path]; memo }
-    end
-
-    def file_vendor
-      unless @file_vendor
-        @file_vendor = Chef::Cookbook::FileVendor.create_from_manifest(cookbook_manifest)
-      end
-      @file_vendor
-    end
-
-  end
-end
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Nuo Yan (<nuo@chef.io>)
+# Author:: Christopher Walters (<cw@chef.io>)
+# Author:: Tim Hinderliter (<tim@chef.io>)
+# Author:: Seth Falcon (<seth@chef.io>)
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "chef/log"
+require "chef/cookbook/file_vendor"
+require "chef/cookbook/metadata"
+require "chef/version_class"
+require "chef/digester"
+require "chef/cookbook_manifest"
+require "chef/server_api"
+
+class Chef
+
+  # == 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.
+  class CookbookVersion
+
+    include Comparable
+    extend Forwardable
+
+    def_delegator :@cookbook_manifest, :files_for
+    def_delegator :@cookbook_manifest, :each_file
+
+    COOKBOOK_SEGMENTS = [ :resources, :providers, :recipes, :definitions, :libraries, :attributes, :files, :templates, :root_files ]
+
+    attr_reader :all_files
+
+    attr_accessor :root_paths
+    attr_accessor :name
+
+    # A Chef::Cookbook::Metadata object. It has a setter that fixes up the
+    # metadata to add descriptions of the recipes contained in this
+    # CookbookVersion.
+    attr_reader :metadata
+
+    attr_reader :recipe_filenames_by_name
+    attr_reader :attribute_filenames_by_short_filename
+
+    attr_accessor :chef_server_rest
+
+    # 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.
+    # @api private
+    attr_accessor :identifier
+
+    # The first root path is the primary cookbook dir, from which metadata is loaded
+    def root_dir
+      root_paths[0]
+    end
+
+    def all_files=(files)
+      @all_files = Array(files)
+      cookbook_manifest.reset!
+    end
+
+    # This is the one and only method that knows how cookbook files'
+    # checksums are generated.
+    def self.checksum_cookbook_file(filepath)
+      Chef::Digester.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
+
+    def self.cache
+      Chef::FileCache
+    end
+
+    # Creates a new Chef::CookbookVersion object.
+    #
+    # === Returns
+    # object<Chef::CookbookVersion>:: Duh. :)
+    def initialize(name, *root_paths, chef_server_rest: nil)
+      @name = name
+      @root_paths = root_paths
+      @frozen = false
+
+      @all_files = Array.new
+
+      @file_vendor = nil
+      @cookbook_manifest = Chef::CookbookManifest.new(self)
+      @metadata = Chef::Cookbook::Metadata.new
+      @chef_server_rest = chef_server_rest
+    end
+
+    def version
+      metadata.version
+    end
+
+    # 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
+    def frozen_version?
+      @frozen
+    end
+
+    def freeze_version
+      @frozen = true
+    end
+
+    def version=(new_version)
+      cookbook_manifest.reset!
+      metadata.version(new_version)
+    end
+
+    def full_name
+      "#{name}-#{version}"
+    end
+
+    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] == "attributes.rb" }
+        name_map["default"] = root_alias[:full_path] if root_alias
+        name_map
+      end
+    end
+
+    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] == "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
+
+    def metadata=(metadata)
+      @metadata = metadata
+      @metadata.recipes_from_cookbook_version(self)
+      @metadata
+    end
+
+    def manifest
+      cookbook_manifest.manifest
+    end
+
+    def manifest=(new_manifest)
+      cookbook_manifest.update_from(new_manifest)
+    end
+
+    # Returns a hash of checksums to either nil or the on disk path (which is
+    # done by generate_manifest).
+    def checksums
+      cookbook_manifest.checksums
+    end
+
+    def manifest_records_by_path
+      cookbook_manifest.manifest_records_by_path
+    end
+
+    # Return recipe names in the form of cookbook_name::recipe_name
+    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
+
+    # called from DSL
+    def load_recipe(recipe_name, run_context)
+      unless recipe_filenames_by_name.has_key?(recipe_name)
+        raise Chef::Exceptions::RecipeNotFound, "could not find recipe #{recipe_name} for 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_name} files for cookbook #{name}"
+      end
+
+      recipe.from_file(recipe_filename)
+      recipe
+    end
+
+    def segment_filenames(segment)
+      files_for(segment).map { |f| f["full_path"] || File.join(root_dir, f["path"]) }
+    end
+
+    # Query whether a template file +template_filename+ is available. File
+    # specificity for the given +node+ is obeyed in the lookup.
+    def has_template_for_node?(node, template_filename)
+      !!find_preferred_manifest_record(node, :templates, template_filename)
+    end
+
+    # Query whether a cookbook_file file +cookbook_filename+ is available. File
+    # specificity for the given +node+ is obeyed in the lookup.
+    def has_cookbook_file_for_node?(node, cookbook_filename)
+      !!find_preferred_manifest_record(node, :files, cookbook_filename)
+    end
+
+    # 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"
+    # }
+    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 segment == :files || segment == :templates
+          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}/#{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
+
+    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
+
+    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 }
+
+      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 =~ /(#{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
+
+    # 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.
+    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 }
+
+      files_for(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
+
+    # Given a node, segment and path (filename or directory name),
+    # return the priority-ordered list of preference locations to
+    # look.
+    def preferences_for_path(node, segment, path)
+      # only files and templates can be platform-specific
+      if segment.to_sym == :files || segment.to_sym == :templates
+        relative_search_path = if path.is_a?(Array)
+                                 path
+                               else
+                                 begin
+                                   platform, version = Chef::Platform.find_platform_and_version(node)
+                                 rescue ArgumentError => e
+                                   # Skip platform/version if they were not found by find_platform_and_version
+                                   if e.message =~ /Cannot find a (?:platform|version)/
+                                     platform = "/unknown_platform/"
+                                     version = "/unknown_platform_version/"
+                                   else
+                                     raise
+                                   end
+                                 end
+
+                                 fqdn = node[:fqdn]
+
+                                 # Break version into components, eg: "5.7.1" => [ "5.7.1", "5.7", "5" ]
+                                 search_versions = []
+                                 parts = version.to_s.split(".")
+
+                                 parts.size.times do
+                                   search_versions << parts.join(".")
+                                   parts.pop
+                                 end
+
+                                 # Most specific to least specific places to find the path
+                                 search_path = [ File.join("host-#{fqdn}", path) ]
+                                 search_versions.each do |v|
+                                   search_path << File.join("#{platform}-#{v}", path)
+                                 end
+                                 search_path << File.join(platform.to_s, path)
+                                 search_path << File.join("default", path)
+                                 search_path << path
+
+                                 search_path
+                               end
+        relative_search_path.map { |relative_path| File.join(segment.to_s, relative_path) }
+      else
+        if segment.to_sym == :root_files
+          [path]
+        else
+          [File.join(segment, path)]
+        end
+      end
+    end
+    private :preferences_for_path
+
+    def display
+      output = Mash.new
+      output["cookbook_name"] = name
+      output["name"] = full_name
+      output["frozen?"] = frozen_version?
+      output["metadata"] = metadata.to_hash
+      output["version"] = version
+      output.merge(cookbook_manifest.by_parent_directory)
+    end
+
+    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
+
+    def self.from_cb_artifact_data(o)
+      from_hash(o)
+    end
+
+    def metadata_json_file
+      File.join(root_paths[0], "metadata.json")
+    end
+
+    def metadata_rb_file
+      File.join(root_paths[0], "metadata.rb")
+    end
+
+    def reload_metadata!
+      if File.exists?(metadata_json_file)
+        metadata.from_json(IO.read(metadata_json_file))
+      end
+    end
+
+    ##
+    # REST API
+    ##
+
+    def chef_server_rest
+      @chef_server_rest ||= chef_server_rest
+    end
+
+    def self.chef_server_rest
+      Chef::ServerAPI.new(Chef::Config[:chef_server_url], { version_class: Chef::CookbookManifestVersions })
+    end
+
+    def destroy
+      chef_server_rest.delete("cookbooks/#{name}/#{version}")
+      self
+    end
+
+    def self.load(name, version = "_latest")
+      version = "_latest" if version == "latest"
+      from_hash(chef_server_rest.get("cookbooks/#{name}/#{version}"))
+    end
+
+    # The API returns only a single version of each cookbook in the result from the cookbooks method
+    def self.list
+      chef_server_rest.get("cookbooks")
+    end
+
+    # Alias latest_cookbooks as list
+    class << self
+      alias :latest_cookbooks :list
+    end
+
+    def self.list_all_versions
+      chef_server_rest.get("cookbooks?num_versions=all")
+    end
+
+    ##
+    # 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.
+    def self.available_versions(cookbook_name)
+      chef_server_rest.get("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
+
+    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
+
+    def cookbook_manifest
+      @cookbook_manifest ||= CookbookManifest.new(self)
+    end
+
+    private
+
+    def find_preferred_manifest_record(node, segment, filename)
+      preferences = preferences_for_path(node, segment, filename)
+
+      # in order of prefernce, look for the filename in the manifest
+      preferences.find { |preferred_filename| manifest_records_by_path[preferred_filename] }
+    end
+
+    # For each manifest record, produce a mapping of base filename (i.e. recipe name
+    # or attribute file) to on disk location
+    def relative_paths_by_name(records)
+      records.select { |record| record[:name] =~ /\.rb$/ }.inject({}) { |memo, record| memo[File.basename(record[:name], ".rb")] = record[:path]; memo }
+    end
+
+    # For each manifest record, produce a mapping of base filename (i.e. recipe name
+    # or attribute file) to on disk location
+    def filenames_by_name(records)
+      records.select { |record| record[:name] =~ /\.rb$/ }.inject({}) { |memo, record| memo[File.basename(record[:name], ".rb")] = record[:full_path]; memo }
+    end
+
+    def file_vendor
+      unless @file_vendor
+        @file_vendor = Chef::Cookbook::FileVendor.create_from_manifest(cookbook_manifest)
+      end
+      @file_vendor
+    end
+
+  end
+end