chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/lib/chef/config.rb

@@ -203,6 +203,10 @@ class Chef
     # Does not apply to Enterprise Chef commands.
     default(:user_path) { derive_path_from_chef_repo_path('users') }
 
+    # Location of policies on disk. String or array of strings.
+    # Defaults to <chef_repo_path>/policies.
+    default(:policy_path) { derive_path_from_chef_repo_path('policies') }
+
     # Turn on "path sanity" by default. See also: http://wiki.opscode.com/display/chef/User+Environment+PATH+Sanity
     default :enforce_path_sanity, true
 
@@ -271,7 +275,7 @@ class Chef
     # * :fatal
     # These work as you'd expect. There is also a special `:auto` setting.
     # When set to :auto, Chef will auto adjust the log verbosity based on
-    # context. When a tty is available (usually becase the user is running chef
+    # context. When a tty is available (usually because the user is running chef
     # in a console), the log level is set to :warn, and output formatters are
     # used as the primary mode of output. When a tty is not available, the
     # logger is the primary mode of output, and the log level is set to :info
@@ -317,8 +321,17 @@ class Chef
     default :why_run, false
     default :color, false
     default :client_fork, true
+    default :ez, false
     default :enable_reporting, true
     default :enable_reporting_url_fatals, false
+    # Possible values for :audit_mode
+    # :enabled, :disabled, :audit_only,
+    #
+    # TODO: 11 Dec 2014: Currently audit-mode is an experimental feature
+    # and is disabled by default. When users choose to enable audit-mode,
+    # a warning is issued in application/client#reconfigure.
+    # This can be removed when audit-mode is enabled by default.
+    default :audit_mode, :disabled
 
     # Policyfile is an experimental feature where a node gets its run list and
     # cookbook version set from a single document on the server instead of
@@ -486,8 +499,20 @@ class Chef
     # Deprecated:
     default(:cache_options) { { :path => PathHelper.join(file_cache_path, "checksums") } }
 
-    # Set to false to silence Chef 11 deprecation warnings:
-    default :chef11_deprecation_warnings, true
+    # Whether errors should be raised for deprecation warnings. When set to
+    # `false` (the default setting), a warning is emitted but code using
+    # deprecated methods/features/etc. should work normally otherwise. When set
+    # to `true`, usage of deprecated methods/features will raise a
+    # `DeprecatedFeatureError`. This is used by Chef's tests to ensure that
+    # deprecated functionality is not used internally by Chef.  End users
+    # should generally leave this at the default setting (especially in
+    # production), but it may be useful when testing cookbooks or other code if
+    # the user wishes to aggressively address deprecations.
+    default(:treat_deprecation_warnings_as_errors) do
+      # Using an environment variable allows this setting to be inherited in
+      # tests that spawn new processes.
+      ENV.key?("CHEF_TREAT_DEPRECATION_WARNINGS_AS_ERRORS")
+    end
 
     # knife configuration data
     config_context :knife do
@@ -602,6 +627,13 @@ class Chef
     #
     default :no_lazy_load, true
 
+    # Default for the chef_gem compile_time attribute.  Nil is the same as false but will emit
+    # warnings on every use of chef_gem prompting the user to be explicit.  If the user sets this to
+    # true then the user will get backcompat behavior but with a single nag warning that cookbooks
+    # may break with this setting in the future.  The false setting is the recommended setting and
+    # will become the default.
+    default :chef_gem_compile_time, nil
+
     # A whitelisted array of attributes you want sent over the wire when node
     # data is saved.
     # The default setting is nil, which collects all data. Setting to [] will not

data/lib/chef/cookbook/metadata.rb

@@ -227,11 +227,11 @@ class Chef
         )
       end
 
-      # Sets the current cookbook version, or returns it.  Can be two or three digits, seperated
+      # Sets the current cookbook version, or returns it.  Can be two or three digits, separated
       # by dots.  ie: '2.1', '1.5.4' or '0.9'.
       #
       # === Parameters
-      # version<String>:: The curent version, as a string
+      # version<String>:: The current version, as a string
       #
       # === Returns
       # version<String>:: Returns the current version
@@ -246,7 +246,7 @@ class Chef
       # Sets the name of the cookbook, or returns it.
       #
       # === Parameters
-      # name<String>:: The curent cookbook name.
+      # name<String>:: The current cookbook name.
       #
       # === Returns
       # name<String>:: Returns the current cookbook name.

data/lib/chef/cookbook_manifest.rb

@@ -0,0 +1,275 @@
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2015 Opscode, 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/util/path_helper'
+require 'chef/log'
+
+class Chef
+
+  # Handles the details of representing a cookbook in JSON form for uploading
+  # to a Chef Server.
+  class CookbookManifest
+
+    # Duplicates the same constant in CookbookVersion. We cannot remove it
+    # there because it is treated by other code as part of CookbookVersion's
+    # public API (also used in some deprecated methods).
+    COOKBOOK_SEGMENTS = [ :resources, :providers, :recipes, :definitions, :libraries, :attributes, :files, :templates, :root_files ].freeze
+
+    extend Forwardable
+
+    attr_reader :cookbook_version
+
+    def_delegator :@cookbook_version, :root_paths
+    def_delegator :@cookbook_version, :segment_filenames
+    def_delegator :@cookbook_version, :name
+    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_hash 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. This endpoint is currently under active
+    #   development and the format is expected to change frequently, therefore
+    #   the result of #manifest, #to_hash, and #to_json will not be stable when
+    #   `policy_mode` is enabled.
+    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_hash
+      result = manifest.dup
+      result['frozen?'] = frozen_version?
+      result['chef_type'] = 'cookbook_version'
+      result.to_hash
+    end
+
+    def to_json(*a)
+      result = to_hash
+      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
+      "#{cookbook_url_path}/#{name}/#{version}"
+    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 = 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']}
+
+        cookbook_version.replace_segment_filenames(segment, filenames)
+      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({
+        :recipes => Array.new,
+        :definitions => Array.new,
+        :libraries => Array.new,
+        :attributes => Array.new,
+        :files => Array.new,
+        :templates => Array.new,
+        :resources => Array.new,
+        :providers => Array.new,
+        :root_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_SEGMENTS.each do |segment|
+        segment_filenames(segment).each do |segment_file|
+          next if File.directory?(segment_file)
+
+          path, specificity = parse_segment_file_from_root_paths(segment, segment_file)
+          file_name = File.basename(path)
+
+          csum = checksum_cookbook_file(segment_file)
+          @checksums[csum] = segment_file
+          rs = Mash.new({
+            :name => file_name,
+            :path => path,
+            :checksum => csum,
+            :specificity => specificity
+          })
+
+          manifest[segment] << rs
+        end
+      end
+
+      manifest[:cookbook_name] = name.to_s
+      manifest[:metadata] = metadata
+      manifest[:version] = metadata.version
+      manifest[:name] = full_name
+
+      @manifest_records_by_path = extract_manifest_records_by_path(manifest)
+      @manifest = manifest
+    end
+
+    def parse_segment_file_from_root_paths(segment, segment_file)
+      root_paths.each do |root_path|
+        pathname = Chef::Util::PathHelper.relative_path_from(root_path, segment_file)
+
+        parts = pathname.each_filename.take(2)
+        # Check if path is actually under root_path
+        next if parts[0] == '..'
+        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 [ pathname.to_s, 'root_default' ]
+          else
+            return [ pathname.to_s, parts[1] ]
+          end
+        else
+          return [ pathname.to_s, 'default' ]
+        end
+      end
+      Chef::Log.error("Cookbook file #{segment_file} not under cookbook root paths #{root_paths.inspect}.")
+      raise "Cookbook file #{segment_file} not under cookbook root paths #{root_paths.inspect}."
+    end
+
+    def extract_checksums_from_manifest(manifest)
+      checksums = {}
+      COOKBOOK_SEGMENTS.each do |segment|
+        next unless manifest.has_key?(segment)
+        manifest[segment].each do |manifest_record|
+          checksums[manifest_record[:checksum]] = nil
+        end
+      end
+      checksums
+    end
+
+    def checksum_cookbook_file(filepath)
+      CookbookVersion.checksum_cookbook_file(filepath)
+    end
+
+    def extract_manifest_records_by_path(manifest)
+      manifest_records_by_path = {}
+      COOKBOOK_SEGMENTS.each do |segment|
+        next unless manifest.has_key?(segment)
+        manifest[segment].each do |manifest_record|
+          manifest_records_by_path[manifest_record[:path]] = manifest_record
+        end
+      end
+      manifest_records_by_path
+    end
+  end
+end

data/lib/chef/cookbook_site_streaming_uploader.rb

@@ -18,6 +18,7 @@
 # limitations under the License.
 #
 
+require 'uri'
 require 'net/http'
 require 'mixlib/authentication/signedheaderauth'
 require 'openssl'
@@ -34,22 +35,22 @@ class Chef
 
     class << self
 
-       def create_build_dir(cookbook)
-         tmp_cookbook_path = Tempfile.new("chef-#{cookbook.name}-build")
-         tmp_cookbook_path.close
-         tmp_cookbook_dir = tmp_cookbook_path.path
-         File.unlink(tmp_cookbook_dir)
-         FileUtils.mkdir_p(tmp_cookbook_dir)
-         Chef::Log.debug("Staging at #{tmp_cookbook_dir}")
-         checksums_to_on_disk_paths = cookbook.checksums
-         Chef::CookbookVersion::COOKBOOK_SEGMENTS.each do |segment|
-           cookbook.manifest[segment].each do |manifest_record|
-             path_in_cookbook = manifest_record[:path]
-             on_disk_path = checksums_to_on_disk_paths[manifest_record[:checksum]]
-             dest = File.join(tmp_cookbook_dir, cookbook.name.to_s, path_in_cookbook)
-             FileUtils.mkdir_p(File.dirname(dest))
-             Chef::Log.debug("Staging #{on_disk_path} to #{dest}")
-             FileUtils.cp(on_disk_path, dest)
+      def create_build_dir(cookbook)
+        tmp_cookbook_path = Tempfile.new("chef-#{cookbook.name}-build")
+        tmp_cookbook_path.close
+        tmp_cookbook_dir = tmp_cookbook_path.path
+        File.unlink(tmp_cookbook_dir)
+        FileUtils.mkdir_p(tmp_cookbook_dir)
+        Chef::Log.debug("Staging at #{tmp_cookbook_dir}")
+        checksums_to_on_disk_paths = cookbook.checksums
+        Chef::CookbookVersion::COOKBOOK_SEGMENTS.each do |segment|
+          cookbook.manifest[segment].each do |manifest_record|
+            path_in_cookbook = manifest_record[:path]
+            on_disk_path = checksums_to_on_disk_paths[manifest_record[:checksum]]
+            dest = File.join(tmp_cookbook_dir, cookbook.name.to_s, path_in_cookbook)
+            FileUtils.mkdir_p(File.dirname(dest))
+            Chef::Log.debug("Staging #{on_disk_path} to #{dest}")
+            FileUtils.cp(on_disk_path, dest)
           end
         end
 
@@ -86,13 +87,13 @@ class Chef
               filepath = value.path
               filename = File.basename(filepath)
               parts << StringPart.new( "--" + boundary + "\r\n" +
-                                       "Content-Disposition: form-data; name=\"" + key.to_s + "\"; filename=\"" + filename + "\"\r\n" +
-                                       "Content-Type: application/octet-stream\r\n\r\n")
+                                      "Content-Disposition: form-data; name=\"" + key.to_s + "\"; filename=\"" + filename + "\"\r\n" +
+                                      "Content-Type: application/octet-stream\r\n\r\n")
               parts << StreamPart.new(value, File.size(filepath))
               parts << StringPart.new("\r\n")
             else
               parts << StringPart.new( "--" + boundary + "\r\n" +
-                                       "Content-Disposition: form-data; name=\"" + key.to_s + "\"\r\n\r\n")
+                                      "Content-Disposition: form-data; name=\"" + key.to_s + "\"\r\n\r\n")
               parts << StringPart.new(value.to_s + "\r\n")
             end
           end
@@ -243,10 +244,10 @@ class Chef
           @part_offset = 0
           next_part = read(how_much_next_part)
           result = current_part + if next_part
-                           next_part
-                         else
-                           ''
-                         end
+                                    next_part
+          else
+            ''
+          end
         else
           @part_offset += how_much_current_part
           result = current_part

data/lib/chef/cookbook_uploader.rb

@@ -3,6 +3,7 @@ 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'
@@ -40,6 +41,7 @@ class Chef
       @cookbooks = Array(cookbooks)
       @rest = opts[:rest] || Chef::REST.new(Chef::Config[:chef_server_url])
       @concurrency = opts[:concurrency] || 10
+      @policy_mode = opts[:policy_mode] || false
     end
 
     def upload_cookbooks
@@ -92,9 +94,12 @@ class Chef
 
       # files are uploaded, so save the manifest
       cookbooks.each do |cb|
-        save_url = opts[:force] ? cb.force_save_url : cb.save_url
+
+        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, cb)
+          rest.put(save_url, manifest)
         rescue Net::HTTPServerException => e
           case e.response.code
           when "409"
@@ -143,5 +148,9 @@ class Chef
       end
     end
 
+    def policy_mode?
+      @policy_mode
+    end
+
   end
 end