chef 12.2.1 → 12.3.0.rc.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 91f1920d1c2e0863500a9e71845388856c621dc3
-  data.tar.gz: 1ded9282d859bca75cffd03654cfeec71a676b4e
+  metadata.gz: dab060d316f7e7df4ab46305e971695d6f8d7c99
+  data.tar.gz: f09a8ffb3137bdb1ba5bfcf5bff8969537c5e502
 SHA512:
-  metadata.gz: f4f3f95775aba6c9a129db77b7ae7a1b708db9c16a553673a4c6275f02bba0fabae76dc5b259c1ee71085da2f842f0cd4dedcf6e45439e20334cac06e540715f
-  data.tar.gz: ec7d0ad336743697fcb95f0d139ec8d8f7c364f324cf191311abece9ea1efada824504d3513117fa328d0671e6a5463bc217a097e153ad89ea264deedbcc8008
+  metadata.gz: 244c89673e62ec837b467ca6be7b8846012d17b8231b29f11365ba6044e044f281c34edd9ed4e71173350a0e7472d05e111145dda831198c5921234dab6da9fe
+  data.tar.gz: e79a4ef02c7e5bf2484f06a9bba694a1c5ea4001faa5c50de3702be3b65947a59746b665a685150cc6902ab8cbcc599b3d9ae164ade2ed5b3df81689c2f98273

data/lib/chef.rb

@@ -32,3 +32,4 @@ require 'chef/run_status'
 require 'chef/handler'
 require 'chef/handler/json_file'
 
+require 'chef/chef_class'

data/lib/chef/application/apply.rb

@@ -85,6 +85,11 @@ class Chef::Application::Apply < Chef::Application
     :default      => !Chef::Platform.windows?,
     :description  => "Use colored output, defaults to enabled"
 
+  option :minimal_ohai,
+    :long           => "--minimal-ohai",
+    :description    => "Only run the bare minimum ohai plugins chef needs to function",
+    :boolean        => true
+
   attr_reader :json_attribs
 
   def initialize

data/lib/chef/application/client.rb

@@ -253,6 +253,16 @@ class Chef::Application::Client < Chef::Application
     :description    => "Enable audit-mode with `enabled`. Disable audit-mode with `disabled`. Skip converge and only perform audits with `audit-only`",
     :proc           => lambda { |mo| mo.gsub("-", "_").to_sym }
 
+  option :minimal_ohai,
+    :long           => "--minimal-ohai",
+    :description    => "Only run the bare minimum ohai plugins chef needs to function",
+    :boolean        => true
+
+  option :listen,
+    :long           => "--[no-]listen",
+    :description    => "Whether a local mode (-z) server binds to a port",
+    :boolean        => true
+
   IMMEDIATE_RUN_SIGNAL = "1".freeze
 
   attr_reader :chef_client_json

data/lib/chef/application/knife.rb

@@ -121,6 +121,11 @@ class Chef::Application::Knife < Chef::Application
     :long         => "--chef-zero-port PORT",
     :description  => "Port (or port range) to start chef-zero on.  Port ranges like 1000,1010 or 8889-9999 will try all given ports until one works."
 
+  option :listen,
+    :long           => "--[no-]listen",
+    :description    => "Whether a local mode (-z) server binds to a port",
+    :boolean        => true
+
   option :version,
     :short        => "-v",
     :long         => "--version",
@@ -129,7 +134,6 @@ class Chef::Application::Knife < Chef::Application
     :proc         => lambda {|v| puts "Chef: #{::Chef::VERSION}"},
     :exit         => 0
 
-
   # Run knife
   def run
     Mixlib::Log::Formatter.show_time = false

data/lib/chef/application/solo.rb

@@ -180,6 +180,11 @@ class Chef::Application::Solo < Chef::Application
     :description  => "Set maximum duration to wait for another client run to finish, default is indefinitely.",
     :proc         => lambda { |s| s.to_i }
 
+  option :minimal_ohai,
+    :long           => "--minimal-ohai",
+    :description    => "Only run the bare minimum ohai plugins chef needs to function",
+    :boolean        => true
+
   attr_reader :chef_client_json
 
   def initialize

data/lib/chef/chef_class.rb

@@ -0,0 +1,130 @@
+#
+# Author:: Lamont Granquist (<lamont@chef.io>)
+# Copyright:: Copyright (c) 2015 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.
+
+# NOTE: This class is not intended for internal use by the chef-client code.  Classes in
+# chef-client should still have objects like the node and run_context injected into them
+# via their initializers.  This class is still global state and will complicate writing
+# unit tests for internal Chef objects.  It is intended to be used only by recipe code.
+
+# NOTE: When adding require lines here you are creating tight coupling on a global that may be
+# included in many different situations and ultimately that ends in tears with circular requires.
+# Note the way that the run_context, provider_priority_map and resource_priority_map are "dependency
+# injected" into this class by other objects and do not reference the class symbols in those files
+# directly and we do not need to require those files here.
+
+class Chef
+  class << self
+
+    #
+    # Public API
+    #
+
+    # Get the node object
+    #
+    # @return [Chef::Node] node object of the chef-client run
+    attr_reader :node
+
+    # Get the run context
+    #
+    # @return [Chef::RunContext] run_context of the chef-client run
+    attr_reader :run_context
+
+    # Get the array of providers associated with a resource_name for the current node
+    #
+    # @param resource_name [Symbol] name of the resource as a symbol
+    # @return [Array<Class>] Priority Array of Provider Classes to use for the resource_name on the node
+    def get_provider_priority_array(resource_name)
+      @provider_priority_map.get_priority_array(node, resource_name).dup
+    end
+
+    # Get the array of resources associated with a resource_name for the current node
+    #
+    # @param resource_name [Symbol] name of the resource as a symbol
+    # @return [Array<Class>] Priority Array of Resource Classes to use for the resource_name on the node
+    def get_resource_priority_array(resource_name)
+      @resource_priority_map.get_priority_array(node, resource_name).dup
+    end
+
+    # Set the array of providers associated with a resource_name for the current node
+    #
+    # @param resource_name [Symbol] name of the resource as a symbol
+    # @param priority_array [Array<Class>] Array of Classes to set as the priority for resource_name on the node
+    # @param filter [Hash] Chef::Nodearray-style filter
+    # @return [Array<Class>] Modified Priority Array of Provider Classes to use for the resource_name on the node
+    def set_provider_priority_array(resource_name, priority_array, *filter)
+      @provider_priority_map.set_priority_array(resource_name, priority_array, *filter).dup
+    end
+
+    # Get the array of resources associated with a resource_name for the current node
+    #
+    # @param resource_name [Symbol] name of the resource as a symbol
+    # @param priority_array [Array<Class>] Array of Classes to set as the priority for resource_name on the node
+    # @param filter [Hash] Chef::Nodearray-style filter
+    # @return [Array<Class>] Modified Priority Array of Resource Classes to use for the resource_name on the node
+    def set_resource_priority_array(resource_name, priority_array, *filter)
+      @resource_priority_map.set_priority_array(resource_name, priority_array, *filter).dup
+    end
+
+    #
+    # Dependency Injection API (Private not Public)
+    # [ in the ruby sense these have to be public methods, but they are
+    #   *NOT* for public consumption ]
+    #
+
+    # Sets the resource_priority_map
+    #
+    # @api private
+    # @param resource_priority_map [Chef::Platform::ResourcePriorityMap]
+    def set_resource_priority_map(resource_priority_map)
+      @resource_priority_map = resource_priority_map
+    end
+
+    # Sets the provider_priority_map
+    #
+    # @api private
+    # @param provider_priority_map [Chef::Platform::providerPriorityMap]
+    def set_provider_priority_map(provider_priority_map)
+      @provider_priority_map = provider_priority_map
+    end
+
+    # Sets the node object
+    #
+    # @api private
+    # @param node [Chef::Node]
+    def set_node(node)
+      @node = node
+    end
+
+    # Sets the run_context object
+    #
+    # @api private
+    # @param run_context [Chef::RunContext]
+    def set_run_context(run_context)
+      @run_context = run_context
+    end
+
+    # Resets the internal state
+    #
+    # @api private
+    def reset!
+      @run_context = nil
+      @node = nil
+      @provider_priority_map = nil
+      @resource_priority_map = nil
+    end
+  end
+end

data/lib/chef/client.rb

@@ -166,6 +166,13 @@ class Chef
       if new_runlist = args.delete(:runlist)
         @json_attribs["run_list"] = new_runlist
       end
+
+      # these slurp in the resource+provider world, so be exceedingly lazy about requiring them
+      require 'chef/platform/provider_priority_map' unless defined? Chef::Platform::ProviderPriorityMap
+      require 'chef/platform/resource_priority_map' unless defined? Chef::Platform::ResourcePriorityMap
+
+      Chef.set_provider_priority_map(Chef::Platform::ProviderPriorityMap.instance)
+      Chef.set_resource_priority_map(Chef::Platform::ResourcePriorityMap.instance)
     end
 
     def configure_formatters
@@ -224,21 +231,21 @@ class Chef
     end
 
     # Instantiates a Chef::Node object, possibly loading the node's prior state
-    # when using chef-client. Delegates to policy_builder
-    #
+    # when using chef-client. Delegates to policy_builder.  Injects the built node
+    # into the Chef class.
     #
-    # === Returns
-    # Chef::Node:: The node object for this chef run
+    # @return [Chef::Node] The node object for this Chef run
     def load_node
       policy_builder.load_node
       @node = policy_builder.node
+      Chef.set_node(@node)
+      node
     end
 
     # Mutates the `node` object to prepare it for the chef run. Delegates to
     # policy_builder
     #
-    # === Returns
-    # Chef::Node:: The updated node object
+    # @return [Chef::Node] The updated node object
     def build_node
       policy_builder.build_node
       @run_status = Chef::RunStatus.new(node, events)
@@ -272,7 +279,8 @@ class Chef
     end
 
     def run_ohai
-      ohai.all_plugins
+      filter = Chef::Config[:minimal_ohai] ? %w[fqdn machinename hostname platform platform_version os os_version] : nil
+      ohai.all_plugins(filter)
       @events.ohai_completed(node)
     end
 

data/lib/chef/config.rb

@@ -305,6 +305,14 @@ class Chef
 
     default :pid_file, nil
 
+    # Whether Chef Zero local mode should bind to a port. All internal requests
+    # will go through the socketless code path regardless, so the socket is
+    # only needed if other processes will connect to the local mode server.
+    #
+    # For compatibility this is set to true but it will be changed to false in
+    # the future.
+    default :listen, true
+
     config_context :chef_zero do
       config_strict_mode true
       default(:enabled) { Chef::Config.local_mode }
@@ -333,6 +341,11 @@ class Chef
     # This can be removed when audit-mode is enabled by default.
     default :audit_mode, :disabled
 
+    # Chef only needs ohai to run the hostname plugin for the most basic
+    # functionality. If the rest of the ohai plugins are not needed (like in
+    # most of our testing scenarios)
+    default :minimal_ohai, false
+
     # 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
     # expanding the run list and having the server compute the cookbook version

data/lib/chef/event_loggers/windows_eventlog.rb

@@ -88,15 +88,21 @@ class Chef
       #Exception message: %4
       #Exception backtrace: %5
       def run_failed(e)
+        data =
+          if @run_status
+            [@run_status.run_id,
+             @run_status.elapsed_time.to_s]
+          else
+            ["UNKNOWN", "UNKNOWN"]
+          end
+
         @eventlog.report_event(
           :event_type => ::Win32::EventLog::ERROR_TYPE,
           :source => SOURCE,
           :event_id => RUN_FAILED_EVENT_ID,
-          :data => [@run_status.run_id,
-                    @run_status.elapsed_time.to_s,
-                    e.class.name,
-                    e.message,
-                    e.backtrace.join("\n")]
+          :data => data + [e.class.name,
+                           e.message,
+                           e.backtrace.join("\n")]
         )
       end
 

data/lib/chef/http.rb

@@ -25,6 +25,7 @@ require 'tempfile'
 require 'net/https'
 require 'uri'
 require 'chef/http/basic_client'
+require 'chef/http/socketless_chef_zero_client'
 require 'chef/monkey_patches/net_http'
 require 'chef/config'
 require 'chef/platform/query_helpers'
@@ -196,14 +197,18 @@ class Chef
 
     def http_client(base_url=nil)
       base_url ||= url
-      BasicClient.new(base_url)
+      if chef_zero_uri?(base_url)
+        SocketlessChefZeroClient.new(base_url)
+      else
+        BasicClient.new(base_url, :ssl_policy => Chef::HTTP::APISSLPolicy)
+      end
     end
 
     protected
 
     def create_url(path)
       return path if path.is_a?(URI)
-      if path =~ /^(http|https):\/\//i
+      if path =~ /^(http|https|chefzero):\/\//i
         URI.parse(path)
       elsif path.nil? or path.empty?
         URI.parse(@url)
@@ -292,7 +297,7 @@ class Chef
           http_attempts += 1
           response, request, return_value = yield
           # handle HTTP 50X Error
-          if response.kind_of?(Net::HTTPServerError)
+          if response.kind_of?(Net::HTTPServerError) && !Chef::Config.local_mode
             if http_retry_count - http_attempts + 1 > 0
               sleep_time = 1 + (2 ** http_attempts) + rand(2 ** http_attempts)
               Chef::Log.error("Server returned error #{response.code} for #{url}, retrying #{http_attempts}/#{http_retry_count} in #{sleep_time}s")
@@ -351,6 +356,11 @@ class Chef
 
     private
 
+    def chef_zero_uri?(uri)
+      uri = URI.parse(uri) unless uri.respond_to?(:scheme)
+      uri.scheme == "chefzero"
+    end
+
     def redirected_to(response)
       return nil  unless response.kind_of?(Net::HTTPRedirection)
       # Net::HTTPNotModified is undesired subclass of Net::HTTPRedirection so test for this

data/lib/chef/http/basic_client.rb

@@ -97,7 +97,9 @@ class Chef
 
       #adapted from buildr/lib/buildr/core/transports.rb
       def proxy_uri
-        proxy = Chef::Config["#{url.scheme}_proxy"]
+        proxy = Chef::Config["#{url.scheme}_proxy"] ||
+                env["#{url.scheme.upcase}_PROXY"] || env["#{url.scheme}_proxy"]
+
         # Check if the proxy string contains a scheme. If not, add the url's scheme to the
         # proxy before parsing. The regex /^.*:\/\// matches, for example, http://.
         proxy = if proxy.match(/^.*:\/\//)
@@ -105,7 +107,8 @@ class Chef
         else
           URI.parse("#{url.scheme}://#{proxy}")
         end if String === proxy
-        excludes = Chef::Config[:no_proxy].to_s.split(/\s*,\s*/).compact
+        no_proxy = Chef::Config[:no_proxy] || env['NO_PROXY'] || env['no_proxy']
+        excludes = no_proxy.to_s.split(/\s*,\s*/).compact
         excludes = excludes.map { |exclude| exclude =~ /:\d+$/ ? exclude : "#{exclude}:*" }
         return proxy unless excludes.any? { |exclude| File.fnmatch(exclude, "#{host}:#{port}") }
       end
@@ -126,18 +129,32 @@ class Chef
         Chef::Config
       end
 
+      def env
+        ENV
+      end
+
       def http_client_builder
         http_proxy = proxy_uri
         if http_proxy.nil?
           Net::HTTP
         else
           Chef::Log.debug("Using #{http_proxy.host}:#{http_proxy.port} for proxy")
-          user = Chef::Config["#{url.scheme}_proxy_user"]
-          pass = Chef::Config["#{url.scheme}_proxy_pass"]
+          user = http_proxy_user(http_proxy)
+          pass = http_proxy_pass(http_proxy)
           Net::HTTP.Proxy(http_proxy.host, http_proxy.port, user, pass)
         end
       end
 
+      def http_proxy_user(http_proxy)
+        http_proxy.user || Chef::Config["#{url.scheme}_proxy_user"] ||
+        env["#{url.scheme.upcase}_PROXY_USER"] || env["#{url.scheme}_proxy_user"]
+      end
+
+      def http_proxy_pass(http_proxy)
+        http_proxy.password || Chef::Config["#{url.scheme}_proxy_pass"] ||
+        env["#{url.scheme.upcase}_PROXY_PASS"] || env["#{url.scheme}_proxy_pass"]
+      end
+
       def configure_ssl(http_client)
         http_client.use_ssl = true
         ssl_policy.apply_to(http_client)

data/lib/chef/http/socketless_chef_zero_client.rb

@@ -0,0 +1,207 @@
+#--
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright (c) 2015 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.
+#
+# ---
+# Some portions of the code in this file are verbatim copies of code from the
+# fakeweb project: https://github.com/chrisk/fakeweb
+#
+# fakeweb is distributed under the MIT license, which is copied below:
+# ---
+#
+# Copyright 2006-2010 Blaine Cook, Chris Kampmeier, and other contributors
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'chef_zero/server'
+
+class Chef
+  class HTTP
+
+    # HTTP Client class that talks directly to Zero via the Rack interface.
+    class SocketlessChefZeroClient
+
+      # This module is extended into Net::HTTP Response objects created from
+      # Socketless Chef Zero responses.
+      module ResponseExts
+
+        # Net::HTTP raises an error if #read_body is called with a block or
+        # file argument after the body has already been read from the network.
+        #
+        # Since we always set the body to the string response from Chef Zero
+        # and set the `@read` indicator variable, we have to patch this method
+        # or else streaming-style responses won't work.
+        def read_body(dest = nil, &block)
+          if dest
+            raise "responses from socketless chef zero can't be written to specific destination"
+          end
+
+          if block_given?
+            block.call(@body)
+          else
+            super
+          end
+        end
+
+      end
+
+      attr_reader :url
+
+      # copied verbatim from webrick (2-clause BSD License)
+      #
+      # HTTP status codes and descriptions
+      STATUS_MESSAGE = {
+        100 => 'Continue',
+        101 => 'Switching Protocols',
+        200 => 'OK',
+        201 => 'Created',
+        202 => 'Accepted',
+        203 => 'Non-Authoritative Information',
+        204 => 'No Content',
+        205 => 'Reset Content',
+        206 => 'Partial Content',
+        207 => 'Multi-Status',
+        300 => 'Multiple Choices',
+        301 => 'Moved Permanently',
+        302 => 'Found',
+        303 => 'See Other',
+        304 => 'Not Modified',
+        305 => 'Use Proxy',
+        307 => 'Temporary Redirect',
+        400 => 'Bad Request',
+        401 => 'Unauthorized',
+        402 => 'Payment Required',
+        403 => 'Forbidden',
+        404 => 'Not Found',
+        405 => 'Method Not Allowed',
+        406 => 'Not Acceptable',
+        407 => 'Proxy Authentication Required',
+        408 => 'Request Timeout',
+        409 => 'Conflict',
+        410 => 'Gone',
+        411 => 'Length Required',
+        412 => 'Precondition Failed',
+        413 => 'Request Entity Too Large',
+        414 => 'Request-URI Too Large',
+        415 => 'Unsupported Media Type',
+        416 => 'Request Range Not Satisfiable',
+        417 => 'Expectation Failed',
+        422 => 'Unprocessable Entity',
+        423 => 'Locked',
+        424 => 'Failed Dependency',
+        426 => 'Upgrade Required',
+        428 => 'Precondition Required',
+        429 => 'Too Many Requests',
+        431 => 'Request Header Fields Too Large',
+        500 => 'Internal Server Error',
+        501 => 'Not Implemented',
+        502 => 'Bad Gateway',
+        503 => 'Service Unavailable',
+        504 => 'Gateway Timeout',
+        505 => 'HTTP Version Not Supported',
+        507 => 'Insufficient Storage',
+        511 => 'Network Authentication Required',
+      }
+
+      STATUS_MESSAGE.values.each {|v| v.freeze }
+      STATUS_MESSAGE.freeze
+
+      def initialize(base_url)
+        @url = base_url
+      end
+
+      def host
+        @url.hostname
+      end
+
+      def port
+        @url.port
+      end
+
+      def request(method, url, body, headers, &handler_block)
+        request = req_to_rack(method, url, body, headers)
+        res = ChefZero::SocketlessServerMap.request(port, request)
+
+        net_http_response = to_net_http(res[0], res[1], res[2])
+
+        yield net_http_response if block_given?
+
+        [self, net_http_response]
+      end
+
+      def req_to_rack(method, url, body, headers)
+        body_str = body || ""
+        {
+          "SCRIPT_NAME"     => "",
+          "SERVER_NAME"     => "localhost",
+          "REQUEST_METHOD"  => method.to_s.upcase,
+          "PATH_INFO"       => url.path,
+          "QUERY_STRING"    => url.query,
+          "SERVER_PORT"     => url.port,
+          "HTTP_HOST"       => "localhost:#{url.port}",
+          "rack.url_scheme" => "chefzero",
+          "rack.input"      => StringIO.new(body_str),
+        }
+      end
+
+      def to_net_http(code, headers, chunked_body)
+        body = chunked_body.join('')
+        msg = STATUS_MESSAGE[code] or raise "Cannot determine HTTP status message for code #{code}"
+        response = Net::HTTPResponse.send(:response_class, code.to_s).new("1.0", code.to_s, msg)
+        response.instance_variable_set(:@body, body)
+        headers.each do |name, value|
+          if value.respond_to?(:each)
+            value.each { |v| response.add_field(name, v) }
+          else
+            response[name] = value
+          end
+        end
+
+        response.instance_variable_set(:@read, true)
+        response.extend(ResponseExts)
+        response
+      end
+
+      private
+
+      def headers_extracted_from_options
+        options.reject {|name, _| KNOWN_OPTIONS.include?(name) }.map { |name, value|
+          [name.to_s.split("_").map { |segment| segment.capitalize }.join("-"), value]
+        }
+      end
+
+
+    end
+
+  end
+end