chef 14.15.6-universal-mingw32 → 15.0.293-universal-mingw32

data/lib/chef/cookbook_loader.rb

@@ -1,208 +1,185 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Christopher Walters (<cw@chef.io>)
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright 2008-2018, Chef Software Inc.
-# Copyright:: Copyright 2009-2016, Daniel DeLeo
-# 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/config"
-require "chef/exceptions"
-require "chef/cookbook/cookbook_version_loader"
-require "chef/cookbook_version"
-require "chef/cookbook/chefignore"
-require "chef/cookbook/metadata"
-
-#
-# CookbookLoader class loads the cookbooks lazily as read
-#
-class Chef
-  class CookbookLoader
-
-    attr_reader :cookbooks_by_name
-    attr_reader :merged_cookbooks
-    attr_reader :cookbook_paths
-    attr_reader :metadata
-
-    include Enumerable
-
-    def initialize(*repo_paths)
-      repo_paths = repo_paths.flatten
-      raise ArgumentError, "You must specify at least one cookbook repo path" if repo_paths.empty?
-      @cookbooks_by_name = Mash.new
-      @loaded_cookbooks = {}
-      @metadata = Mash.new
-      @cookbooks_paths = Hash.new { |h, k| h[k] = [] } # for deprecation warnings
-      @chefignores = {}
-      @repo_paths = repo_paths.map do |repo_path|
-        File.expand_path(repo_path)
-      end
-
-      @preloaded_cookbooks = false
-      @loaders_by_name = {}
-
-      # Used to track which cookbooks appear in multiple places in the cookbook repos
-      # and are merged in to a single cookbook by file shadowing. This behavior is
-      # deprecated, so users of this class may issue warnings to the user by checking
-      # this variable
-      @merged_cookbooks = []
-    end
-
-    def merged_cookbook_paths # for deprecation warnings
-      merged_cookbook_paths = {}
-      @merged_cookbooks.each { |c| merged_cookbook_paths[c] = @cookbooks_paths[c] }
-      merged_cookbook_paths
-    end
-
-    def warn_about_cookbook_shadowing
-      unless merged_cookbooks.empty?
-        Chef.deprecated(:cookbook_shadowing, "The cookbook(s): #{merged_cookbooks.join(', ')} exist in multiple places in your cookbook_path. " +
-          "A composite version has been compiled. This has been deprecated since 0.10.4, in Chef 15 this behavior will be REMOVED.")
-      end
-    end
-
-    # Will be removed when cookbook shadowing is removed, do NOT create new consumers of this API.
-    #
-    # @api private
-    def load_cookbooks_without_shadow_warning
-      preload_cookbooks
-      @loaders_by_name.each_key do |cookbook_name|
-        load_cookbook(cookbook_name)
-      end
-      @cookbooks_by_name
-    end
-
-    def load_cookbooks
-      ret = load_cookbooks_without_shadow_warning
-      warn_about_cookbook_shadowing
-      ret
-    end
-
-    def load_cookbook(cookbook_name)
-      preload_cookbooks
-
-      return @cookbooks_by_name[cookbook_name] if @cookbooks_by_name.key?(cookbook_name)
-
-      return nil unless @loaders_by_name.key?(cookbook_name.to_s)
-
-      cookbook_loaders_for(cookbook_name).each do |loader|
-        loader.load
-
-        next if loader.empty?
-
-        @cookbooks_paths[cookbook_name] << loader.cookbook_path # for deprecation warnings
-
-        if @loaded_cookbooks.key?(cookbook_name)
-          @merged_cookbooks << cookbook_name # for deprecation warnings
-          @loaded_cookbooks[cookbook_name].merge!(loader)
-        else
-          @loaded_cookbooks[cookbook_name] = loader
-        end
-      end
-
-      if @loaded_cookbooks.key?(cookbook_name)
-        cookbook_version = @loaded_cookbooks[cookbook_name].cookbook_version
-        @cookbooks_by_name[cookbook_name] = cookbook_version
-        @metadata[cookbook_name] = cookbook_version.metadata
-      end
-      @cookbooks_by_name[cookbook_name]
-    end
-
-    def [](cookbook)
-      if @cookbooks_by_name.key?(cookbook.to_sym) || load_cookbook(cookbook.to_sym)
-        @cookbooks_by_name[cookbook.to_sym]
-      else
-        raise Exceptions::CookbookNotFoundInRepo, "Cannot find a cookbook named #{cookbook}; did you forget to add metadata to a cookbook? (https://docs.chef.io/config_rb_metadata.html)"
-      end
-    end
-
-    alias :fetch :[]
-
-    def has_key?(cookbook_name)
-      not self[cookbook_name.to_sym].nil?
-    end
-    alias :cookbook_exists? :has_key?
-    alias :key? :has_key?
-
-    def each
-      @cookbooks_by_name.keys.sort_by(&:to_s).each do |cname|
-        yield(cname, @cookbooks_by_name[cname])
-      end
-    end
-
-    def each_key(&block)
-      cookbook_names.each(&block)
-    end
-
-    def each_value(&block)
-      values.each(&block)
-    end
-
-    def cookbook_names
-      @cookbooks_by_name.keys.sort
-    end
-
-    def values
-      @cookbooks_by_name.values
-    end
-    alias :cookbooks :values
-
-    private
-
-    def preload_cookbooks
-      return false if @preloaded_cookbooks
-
-      all_directories_in_repo_paths.each do |cookbook_path|
-        preload_cookbook(cookbook_path)
-      end
-      @preloaded_cookbooks = true
-      true
-    end
-
-    def preload_cookbook(cookbook_path)
-      repo_path = File.dirname(cookbook_path)
-      @chefignores[repo_path] ||= Cookbook::Chefignore.new(repo_path)
-      loader = Cookbook::CookbookVersionLoader.new(cookbook_path, @chefignores[repo_path])
-      add_cookbook_loader(loader)
-    end
-
-    def all_directories_in_repo_paths
-      @all_directories_in_repo_paths ||=
-        all_files_in_repo_paths.select { |path| File.directory?(path) }
-    end
-
-    def all_files_in_repo_paths
-      @all_files_in_repo_paths ||=
-        begin
-          @repo_paths.inject([]) do |all_children, repo_path|
-            all_children + Dir[File.join(Chef::Util::PathHelper.escape_glob_dir(repo_path), "*")]
-          end
-        end
-    end
-
-    def add_cookbook_loader(loader)
-      cookbook_name = loader.cookbook_name
-
-      @loaders_by_name[cookbook_name.to_s] ||= []
-      @loaders_by_name[cookbook_name.to_s] << loader
-      loader
-    end
-
-    def cookbook_loaders_for(cookbook_name)
-      @loaders_by_name[cookbook_name.to_s]
-    end
-
-  end
-end
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Christopher Walters (<cw@chef.io>)
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
+# Copyright:: Copyright 2009-2016, Daniel DeLeo
+# 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_relative "config"
+require_relative "exceptions"
+require_relative "cookbook/cookbook_version_loader"
+require_relative "cookbook_version"
+require_relative "cookbook/chefignore"
+require_relative "cookbook/metadata"
+
+class Chef
+  # This class is used by knife, cheffs and legacy chef-solo modes.  It is not used by the server mode
+  # of chef-client or zolo/zero modes.
+  #
+  # This class implements orchestration around producing a single cookbook_version for a cookbook or
+  # loading a Mash of all cookbook_versions, using the cookbook_version_loader class, and doing
+  # lazy-access and memoization to only load each cookbook once on demand.
+  #
+  # This implements a key-value style each which makes it appear to be a Hash of String => CookbookVersion
+  # pairs where the String is the cookbook name.  The use of Enumerable combined with the Hash-style
+  # each is likely not entirely sane.
+  #
+  # This object is also passed and injected into the CookbookCollection object where it is converted
+  # to a Mash that looks almost exactly like the cookbook_by_name Mash in this object.
+  #
+  class CookbookLoader
+    # @return [Array<String>] the array of repo paths containing cookbook dirs
+    attr_reader :repo_paths
+
+    # XXX: this is highly questionable combined with the Hash-style each method
+    include Enumerable
+
+    # @param repo_paths [Array<String>] the array of repo paths containing cookbook dirs
+    def initialize(*repo_paths)
+      @repo_paths = repo_paths.flatten.map { |p| File.expand_path(p) }
+      raise ArgumentError, "You must specify at least one cookbook repo path" if repo_paths.empty?
+    end
+
+    # The primary function of this class is to build this Mash mapping cookbook names as a string to
+    # the CookbookVersion objects for them.  Callers must call "load_cookbooks" first.
+    #
+    # @return [Mash<String, Chef::CookbookVersion>]
+    def cookbooks_by_name
+      @cookbooks_by_name ||= Mash.new
+    end
+
+    # This class also builds a mapping of cookbook names to their Metadata objects.  Callers must call
+    # "load_cookbooks" first.
+    #
+    # @return [Mash<String, Chef::Cookbook::Metadata>]
+    def metadata
+      @metadata ||= Mash.new
+    end
+
+    # Loads all cookbooks across all repo_paths
+    #
+    # @return [Mash<String, Chef::CookbookVersion>] the cookbooks_by_name Mash
+    def load_cookbooks
+      cookbook_version_loaders.each_key do |cookbook_name|
+        load_cookbook(cookbook_name)
+      end
+      cookbooks_by_name
+    end
+
+    # Loads a single cookbook by its name.
+    #
+    # @param [String]
+    # @return [Chef::CookbookVersion]
+    def load_cookbook(cookbook_name)
+      unless cookbook_version_loaders.key?(cookbook_name)
+        raise Exceptions::CookbookNotFoundInRepo, "Cannot find a cookbook named #{cookbook_name}; did you forget to add metadata to a cookbook? (https://docs.chef.io/config_rb_metadata.html)"
+      end
+
+      return cookbooks_by_name[cookbook_name] if cookbooks_by_name.key?(cookbook_name)
+
+      loader = cookbook_version_loaders[cookbook_name]
+
+      loader.load
+
+      cookbook_version = loader.cookbook_version
+      cookbooks_by_name[cookbook_name] = cookbook_version
+      metadata[cookbook_name] = cookbook_version.metadata
+      cookbook_version
+    end
+
+    def [](cookbook)
+      load_cookbook(cookbook)
+    end
+
+    alias :fetch :[]
+
+    def has_key?(cookbook_name)
+      not self[cookbook_name.to_sym].nil?
+    end
+
+    alias :cookbook_exists? :has_key?
+    alias :key? :has_key?
+
+    def each
+      cookbooks_by_name.keys.sort_by(&:to_s).each do |cname|
+        yield(cname, cookbooks_by_name[cname])
+      end
+    end
+
+    def each_key(&block)
+      cookbook_names.each(&block)
+    end
+
+    def each_value(&block)
+      values.each(&block)
+    end
+
+    def cookbook_names
+      cookbooks_by_name.keys.sort
+    end
+
+    def values
+      cookbooks_by_name.values
+    end
+
+    alias :cookbooks :values
+
+    private
+
+    # Helper method to lazily create and remember the chefignore object
+    # for a given repo_path.
+    #
+    # @param [String] repo_path the full path to the cookbook directory of the repo
+    # @return [Chef::Cookbook::Chefignore] the chefignore object for the repo_path
+    def chefignore(repo_path)
+      @chefignores ||= {}
+      @chefignores[repo_path] ||= Cookbook::Chefignore.new(repo_path)
+    end
+
+    def all_directories_in_repo_paths
+      @all_directories_in_repo_paths ||=
+        all_files_in_repo_paths.select { |path| File.directory?(path) }
+    end
+
+    def all_files_in_repo_paths
+      @all_files_in_repo_paths ||=
+        begin
+          repo_paths.inject([]) do |all_children, repo_path|
+            all_children + Dir[File.join(Chef::Util::PathHelper.escape_glob_dir(repo_path), "*")]
+          end
+        end
+    end
+
+    # This method creates a Mash of the CookbookVersionLoaders for each cookbook.
+    #
+    # @return [Mash<String, Cookbook::CookbookVersionLoader>]
+    def cookbook_version_loaders
+      @cookbook_version_loaders ||=
+        begin
+          mash = Mash.new
+          all_directories_in_repo_paths.each do |cookbook_path|
+            loader = Cookbook::CookbookVersionLoader.new(cookbook_path, chefignore(File.dirname(cookbook_path)))
+            cookbook_name = loader.cookbook_name
+            if mash.key?(cookbook_name)
+              raise Chef::Exceptions::CookbookMergingError, "Cookbook merging is no longer supported, the cookbook named #{cookbook_name} can only appear once in the cookbook_path"
+            end
+            mash[cookbook_name] = loader
+          end
+          mash
+        end
+    end
+  end
+end

data/lib/chef/cookbook_manifest.rb

@@ -1,328 +1,328 @@
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2015-2018, 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 "forwardable"
-require "chef/mixin/versioned_api"
-require "chef/util/path_helper"
-require "chef/cookbook/manifest_v0"
-require "chef/cookbook/manifest_v2"
-require "chef/log"
-
-class Chef
-
-  # Handles the details of representing a cookbook in JSON form for uploading
-  # to a Chef Server.
-  class CookbookManifest
-
-    extend Forwardable
-
-    attr_reader :cookbook_version
-
-    def_delegator :@cookbook_version, :root_paths
-    def_delegator :@cookbook_version, :name
-    def_delegator :@cookbook_version, :identifier
-    def_delegator :@cookbook_version, :metadata
-    def_delegator :@cookbook_version, :full_name
-    def_delegator :@cookbook_version, :version
-    def_delegator :@cookbook_version, :frozen_version?
-
-    # Create a new CookbookManifest object for the given `cookbook_version`.
-    # You can subsequently call #to_h to get a Hash representation of the
-    # cookbook_version in the "manifest" format, or #to_json to get a JSON
-    # representation of the cookbook_version.
-    #
-    # The inferface for this behavior is expected to change as we implement new
-    # manifest formats. The entire class should be considered a private API for
-    # now.
-    #
-    # @api private
-    # @param policy_mode [Boolean] whether to convert cookbooks to Hash/JSON in
-    #   the format used by the `cookbook_artifacts` endpoint (for policyfiles).
-    #   Setting this option also changes the behavior of #save_url and
-    #   #force_save_url such that CookbookVersions will be uploaded to the new
-    #   `cookbook_artifacts` API.
-    def initialize(cookbook_version, policy_mode: false)
-      @cookbook_version = cookbook_version
-      @policy_mode = !!policy_mode
-
-      reset!
-    end
-
-    # Resets all lazily computed values.
-    def reset!
-      @manifest = nil
-      @checksums = nil
-      @manifest_records_by_path = nil
-      true
-    end
-
-    # Returns a 'manifest' data structure that can be uploaded to a Chef
-    # Server.
-    #
-    # The format is as follows:
-    #
-    #     {
-    #       :cookbook_name  => name,            # String
-    #       :metadata       => metadata,        # Chef::Cookbook::Metadata
-    #       :version        => version,         # Chef::Version
-    #       :name           => full_name,       # String of "#{name}-#{version}"
-    #
-    #       :recipes        => Array<FileSpec>,
-    #       :definitions    => Array<FileSpec>,
-    #       :libraries      => Array<FileSpec>,
-    #       :attributes     => Array<FileSpec>,
-    #       :files          => Array<FileSpec>,
-    #       :templates      => Array<FileSpec>,
-    #       :resources      => Array<FileSpec>,
-    #       :providers      => Array<FileSpec>,
-    #       :root_files     => Array<FileSpec>
-    #     }
-    #
-    # Where a `FileSpec` is a Hash of the form:
-    #
-    #     {
-    #       :name         => file_name,
-    #       :path         => path,
-    #       :checksum     => csum,
-    #       :specificity  => specificity
-    #     }
-    #
-    def manifest
-      @manifest || generate_manifest
-      @manifest
-    end
-
-    def checksums
-      @manifest || generate_manifest
-      @checksums
-    end
-
-    def manifest_records_by_path
-      @manifest || generate_manifest
-      @manifest_records_by_path
-    end
-
-    def policy_mode?
-      @policy_mode
-    end
-
-    def to_h
-      CookbookManifestVersions.to_h(self)
-    end
-
-    alias_method :to_hash, :to_h
-
-    def to_json(*a)
-      result = to_h
-      result["json_class"] = "Chef::CookbookVersion"
-      Chef::JSONCompat.to_json(result, *a)
-    end
-
-    # 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.
-    def save_url
-      if policy_mode?
-        "#{named_cookbook_url}/#{identifier}"
-      else
-        "#{named_cookbook_url}/#{version}"
-      end
-    end
-
-    def named_cookbook_url
-      "#{cookbook_url_path}/#{name}"
-    end
-
-    # 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).
-    def force_save_url
-      "#{save_url}?force=true"
-    end
-
-    # Update this CookbookManifest from the contents of another manifest, and
-    # make the corresponding changes to the cookbook_version object. Required
-    # to provide backward compatibility with CookbookVersion#manifest= method.
-    def update_from(new_manifest)
-      @manifest = Chef::CookbookManifestVersions.from_hash(new_manifest)
-      @checksums = extract_checksums_from_manifest(@manifest)
-      @manifest_records_by_path = extract_manifest_records_by_path(@manifest)
-    end
-
-    # @api private
-    # takes a list of hashes
-    def add_files_to_manifest(files)
-      manifest[:all_files].concat(Array(files))
-      @checksums = extract_checksums_from_manifest(@manifest)
-      @manifest_records_by_path = extract_manifest_records_by_path(@manifest)
-    end
-
-    def files_for(part)
-      return root_files if part.to_s == "root_files"
-      manifest[:all_files].select do |file|
-        seg = file[:name].split("/")[0]
-        part.to_s == seg
-      end
-    end
-
-    def each_file(excluded_parts: [], &block)
-      excluded_parts = Array(excluded_parts).map { |p| p.to_s }
-
-      manifest[:all_files].each do |file|
-        seg = file[:name].split("/")[0]
-        next if excluded_parts.include?(seg)
-        yield file if block_given?
-      end
-    end
-
-    def by_parent_directory
-      @by_parent_directory ||=
-        manifest[:all_files].inject({}) do |memo, file|
-          parts = file[:name].split("/")
-          parent = if parts.length == 1
-                     "root_files"
-                   else
-                     parts[0]
-                   end
-
-          memo[parent] ||= []
-          memo[parent] << file
-          memo
-        end
-    end
-
-    def root_files
-      manifest[:all_files].select do |file|
-        segment, name = file[:name].split("/")
-        name.nil? || segment == "root_files"
-      end
-    end
-
-    private
-
-    def cookbook_url_path
-      policy_mode? ? "cookbook_artifacts" : "cookbooks"
-    end
-
-    # See #manifest for a description of the manifest return value.
-    # See #preferred_manifest_record for a description an individual manifest record.
-    def generate_manifest
-      manifest = Mash.new({
-        all_files: Array.new,
-      })
-      @checksums = {}
-
-      if !root_paths || root_paths.size == 0
-        Chef::Log.error("Cookbook #{name} does not have root_paths! Cannot generate manifest.")
-        raise "Cookbook #{name} does not have root_paths! Cannot generate manifest."
-      end
-
-      @cookbook_version.all_files.each do |file|
-        next if File.directory?(file)
-
-        name, path, specificity = parse_file_from_root_paths(file)
-
-        csum = checksum_cookbook_file(file)
-        @checksums[csum] = file
-        rs = Mash.new({
-          name: name,
-          path: path,
-          checksum: csum,
-          specificity: specificity,
-          # full_path is not a part of the normal manifest, but is very useful to keep around.
-          # uploaders should strip this out.
-          full_path: file,
-        })
-
-        manifest[:all_files] << rs
-      end
-
-      manifest[:metadata] = metadata
-      manifest[:version] = metadata.version
-
-      if policy_mode?
-        manifest[:name] = name.to_s
-        manifest[:identifier] = identifier
-      else
-        manifest[:name] = full_name
-        manifest[:cookbook_name] = name.to_s
-      end
-
-      @manifest_records_by_path = extract_manifest_records_by_path(manifest)
-      @manifest = manifest
-    end
-
-    def parse_file_from_root_paths(file)
-      root_paths.each do |root_path|
-        pathname = Chef::Util::PathHelper.relative_path_from(root_path, file)
-
-        parts = pathname.each_filename.take(2)
-        # Check if path is actually under root_path
-        next if parts[0] == ".."
-
-        # if we have a root_file, such as metadata.rb, the first part will be "."
-        return [ "root_files/#{pathname}", pathname.to_s, "default" ] if parts.length == 1
-
-        segment = parts[0]
-
-        name = File.join(segment, pathname.basename.to_s)
-
-        if segment == "templates" || segment == "files"
-          # Check if pathname looks like files/foo or templates/foo (unscoped)
-          if pathname.each_filename.to_a.length == 2
-            # Use root_default in case the same path exists at root_default and default
-            return [ name, pathname.to_s, "root_default" ]
-          else
-            return [ name, pathname.to_s, parts[1] ]
-          end
-        else
-          return [ name, pathname.to_s, "default" ]
-        end
-      end
-      Chef::Log.error("Cookbook file #{file} not under cookbook root paths #{root_paths.inspect}.")
-      raise "Cookbook file #{file} not under cookbook root paths #{root_paths.inspect}."
-    end
-
-    def extract_checksums_from_manifest(manifest)
-      manifest[:all_files].inject({}) do |memo, manifest_record|
-        memo[manifest_record[:checksum]] = nil
-        memo
-      end
-    end
-
-    def checksum_cookbook_file(filepath)
-      CookbookVersion.checksum_cookbook_file(filepath)
-    end
-
-    def extract_manifest_records_by_path(manifest)
-      manifest[:all_files].inject({}) do |memo, manifest_record|
-        memo[manifest_record[:path]] = manifest_record
-        memo
-      end
-    end
-
-  end
-  class CookbookManifestVersions
-
-    extend Chef::Mixin::VersionedAPIFactory
-    add_versioned_api_class Chef::Cookbook::ManifestV0
-    add_versioned_api_class Chef::Cookbook::ManifestV2
-
-    def_versioned_delegator :from_hash
-    def_versioned_delegator :to_hash
-    def_versioned_delegator :to_h
-  end
-end
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2015-2018, 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 "forwardable"
+require_relative "mixin/versioned_api"
+require_relative "util/path_helper"
+require_relative "cookbook/manifest_v0"
+require_relative "cookbook/manifest_v2"
+require_relative "log"
+
+class Chef
+
+  # Handles the details of representing a cookbook in JSON form for uploading
+  # to a Chef Server.
+  class CookbookManifest
+
+    extend Forwardable
+
+    attr_reader :cookbook_version
+
+    def_delegator :@cookbook_version, :root_paths
+    def_delegator :@cookbook_version, :name
+    def_delegator :@cookbook_version, :identifier
+    def_delegator :@cookbook_version, :metadata
+    def_delegator :@cookbook_version, :full_name
+    def_delegator :@cookbook_version, :version
+    def_delegator :@cookbook_version, :frozen_version?
+
+    # Create a new CookbookManifest object for the given `cookbook_version`.
+    # You can subsequently call #to_h to get a Hash representation of the
+    # cookbook_version in the "manifest" format, or #to_json to get a JSON
+    # representation of the cookbook_version.
+    #
+    # The inferface for this behavior is expected to change as we implement new
+    # manifest formats. The entire class should be considered a private API for
+    # now.
+    #
+    # @api private
+    # @param policy_mode [Boolean] whether to convert cookbooks to Hash/JSON in
+    #   the format used by the `cookbook_artifacts` endpoint (for policyfiles).
+    #   Setting this option also changes the behavior of #save_url and
+    #   #force_save_url such that CookbookVersions will be uploaded to the new
+    #   `cookbook_artifacts` API.
+    def initialize(cookbook_version, policy_mode: false)
+      @cookbook_version = cookbook_version
+      @policy_mode = !!policy_mode
+
+      reset!
+    end
+
+    # Resets all lazily computed values.
+    def reset!
+      @manifest = nil
+      @checksums = nil
+      @manifest_records_by_path = nil
+      true
+    end
+
+    # Returns a 'manifest' data structure that can be uploaded to a Chef
+    # Server.
+    #
+    # The format is as follows:
+    #
+    #     {
+    #       :cookbook_name  => name,            # String
+    #       :metadata       => metadata,        # Chef::Cookbook::Metadata
+    #       :version        => version,         # Chef::Version
+    #       :name           => full_name,       # String of "#{name}-#{version}"
+    #
+    #       :recipes        => Array<FileSpec>,
+    #       :definitions    => Array<FileSpec>,
+    #       :libraries      => Array<FileSpec>,
+    #       :attributes     => Array<FileSpec>,
+    #       :files          => Array<FileSpec>,
+    #       :templates      => Array<FileSpec>,
+    #       :resources      => Array<FileSpec>,
+    #       :providers      => Array<FileSpec>,
+    #       :root_files     => Array<FileSpec>
+    #     }
+    #
+    # Where a `FileSpec` is a Hash of the form:
+    #
+    #     {
+    #       :name         => file_name,
+    #       :path         => path,
+    #       :checksum     => csum,
+    #       :specificity  => specificity
+    #     }
+    #
+    def manifest
+      @manifest || generate_manifest
+      @manifest
+    end
+
+    def checksums
+      @manifest || generate_manifest
+      @checksums
+    end
+
+    def manifest_records_by_path
+      @manifest || generate_manifest
+      @manifest_records_by_path
+    end
+
+    def policy_mode?
+      @policy_mode
+    end
+
+    def to_h
+      CookbookManifestVersions.to_h(self)
+    end
+
+    alias_method :to_hash, :to_h
+
+    def to_json(*a)
+      result = to_h
+      result["json_class"] = "Chef::CookbookVersion"
+      Chef::JSONCompat.to_json(result, *a)
+    end
+
+    # 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.
+    def save_url
+      if policy_mode?
+        "#{named_cookbook_url}/#{identifier}"
+      else
+        "#{named_cookbook_url}/#{version}"
+      end
+    end
+
+    def named_cookbook_url
+      "#{cookbook_url_path}/#{name}"
+    end
+
+    # 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).
+    def force_save_url
+      "#{save_url}?force=true"
+    end
+
+    # Update this CookbookManifest from the contents of another manifest, and
+    # make the corresponding changes to the cookbook_version object. Required
+    # to provide backward compatibility with CookbookVersion#manifest= method.
+    def update_from(new_manifest)
+      @manifest = Chef::CookbookManifestVersions.from_hash(new_manifest)
+      @checksums = extract_checksums_from_manifest(@manifest)
+      @manifest_records_by_path = extract_manifest_records_by_path(@manifest)
+    end
+
+    # @api private
+    # takes a list of hashes
+    def add_files_to_manifest(files)
+      manifest[:all_files].concat(Array(files))
+      @checksums = extract_checksums_from_manifest(@manifest)
+      @manifest_records_by_path = extract_manifest_records_by_path(@manifest)
+    end
+
+    def files_for(part)
+      return root_files if part.to_s == "root_files"
+      manifest[:all_files].select do |file|
+        seg = file[:name].split("/")[0]
+        part.to_s == seg
+      end
+    end
+
+    def each_file(excluded_parts: [], &block)
+      excluded_parts = Array(excluded_parts).map { |p| p.to_s }
+
+      manifest[:all_files].each do |file|
+        seg = file[:name].split("/")[0]
+        next if excluded_parts.include?(seg)
+        yield file if block_given?
+      end
+    end
+
+    def by_parent_directory
+      @by_parent_directory ||=
+        manifest[:all_files].inject({}) do |memo, file|
+          parts = file[:name].split("/")
+          parent = if parts.length == 1
+                     "root_files"
+                   else
+                     parts[0]
+                   end
+
+          memo[parent] ||= []
+          memo[parent] << file
+          memo
+        end
+    end
+
+    def root_files
+      manifest[:all_files].select do |file|
+        segment, name = file[:name].split("/")
+        name.nil? || segment == "root_files"
+      end
+    end
+
+    private
+
+    def cookbook_url_path
+      policy_mode? ? "cookbook_artifacts" : "cookbooks"
+    end
+
+    # See #manifest for a description of the manifest return value.
+    # See #preferred_manifest_record for a description an individual manifest record.
+    def generate_manifest
+      manifest = Mash.new({
+        all_files: Array.new,
+      })
+      @checksums = {}
+
+      if !root_paths || root_paths.size == 0
+        Chef::Log.error("Cookbook #{name} does not have root_paths! Cannot generate manifest.")
+        raise "Cookbook #{name} does not have root_paths! Cannot generate manifest."
+      end
+
+      @cookbook_version.all_files.each do |file|
+        next if File.directory?(file)
+
+        name, path, specificity = parse_file_from_root_paths(file)
+
+        csum = checksum_cookbook_file(file)
+        @checksums[csum] = file
+        rs = Mash.new({
+          name: name,
+          path: path,
+          checksum: csum,
+          specificity: specificity,
+          # full_path is not a part of the normal manifest, but is very useful to keep around.
+          # uploaders should strip this out.
+          full_path: file,
+        })
+
+        manifest[:all_files] << rs
+      end
+
+      manifest[:metadata] = metadata
+      manifest[:version] = metadata.version
+
+      if policy_mode?
+        manifest[:name] = name.to_s
+        manifest[:identifier] = identifier
+      else
+        manifest[:name] = full_name
+        manifest[:cookbook_name] = name.to_s
+      end
+
+      @manifest_records_by_path = extract_manifest_records_by_path(manifest)
+      @manifest = manifest
+    end
+
+    def parse_file_from_root_paths(file)
+      root_paths.each do |root_path|
+        pathname = Chef::Util::PathHelper.relative_path_from(root_path, file)
+
+        parts = pathname.each_filename.take(2)
+        # Check if path is actually under root_path
+        next if parts[0] == ".."
+
+        # if we have a root_file, such as metadata.rb, the first part will be "."
+        return [ "root_files/#{pathname}", pathname.to_s, "default" ] if parts.length == 1
+
+        segment = parts[0]
+
+        name = File.join(segment, pathname.basename.to_s)
+
+        if segment == "templates" || segment == "files"
+          # Check if pathname looks like files/foo or templates/foo (unscoped)
+          if pathname.each_filename.to_a.length == 2
+            # Use root_default in case the same path exists at root_default and default
+            return [ name, pathname.to_s, "root_default" ]
+          else
+            return [ name, pathname.to_s, parts[1] ]
+          end
+        else
+          return [ name, pathname.to_s, "default" ]
+        end
+      end
+      Chef::Log.error("Cookbook file #{file} not under cookbook root paths #{root_paths.inspect}.")
+      raise "Cookbook file #{file} not under cookbook root paths #{root_paths.inspect}."
+    end
+
+    def extract_checksums_from_manifest(manifest)
+      manifest[:all_files].inject({}) do |memo, manifest_record|
+        memo[manifest_record[:checksum]] = nil
+        memo
+      end
+    end
+
+    def checksum_cookbook_file(filepath)
+      CookbookVersion.checksum_cookbook_file(filepath)
+    end
+
+    def extract_manifest_records_by_path(manifest)
+      manifest[:all_files].inject({}) do |memo, manifest_record|
+        memo[manifest_record[:path]] = manifest_record
+        memo
+      end
+    end
+
+  end
+  class CookbookManifestVersions
+
+    extend Chef::Mixin::VersionedAPIFactory
+    add_versioned_api_class Chef::Cookbook::ManifestV0
+    add_versioned_api_class Chef::Cookbook::ManifestV2
+
+    def_versioned_delegator :from_hash
+    def_versioned_delegator :to_hash
+    def_versioned_delegator :to_h
+  end
+end