chef 11.6.2-x86-mingw32 → 11.8.0.rc.1-x86-mingw32

data/lib/chef/http/json_input.rb

@@ -0,0 +1,53 @@
+#--
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2013 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 'chef/json_compat'
+
+class Chef
+  class HTTP
+
+    # Middleware that takes json input and turns it into raw text
+    class JSONInput
+
+      def initialize(opts={})
+      end
+
+      def handle_request(method, url, headers={}, data=false)
+        if data
+          headers["Content-Type"] = 'application/json'
+          data = Chef::JSONCompat.to_json(data)
+          # Force encoding to binary to fix SSL related EOFErrors
+          # cf. http://tickets.opscode.com/browse/CHEF-2363
+          # http://redmine.ruby-lang.org/issues/5233
+          data.force_encoding(Encoding::BINARY) if data.respond_to?(:force_encoding)
+        end
+        [method, url, headers, data]
+      end
+
+      def handle_response(http_response, rest_request, return_value)
+        [http_response, rest_request, return_value]
+      end
+
+      def stream_response_handler(response)
+        nil
+      end
+
+    end
+  end
+end

data/lib/chef/http/json_output.rb

@@ -0,0 +1,69 @@
+#--
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2013 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 'chef/json_compat'
+require 'chef/log'
+
+class Chef
+  class HTTP
+
+    # Middleware that takes an HTTP response, parses it as JSON if possible.
+    class JSONOutput
+
+      def initialize(opts={})
+        @raw_output = opts[:raw_output]
+        @inflate_json_class = opts[:inflate_json_class]
+      end
+
+      def handle_request(method, url, headers={}, data=false)
+        # Ideally this should always set Accept to application/json, but
+        # Chef::REST is sometimes used to make non-JSON requests, so it sets
+        # Accept to the desired value before middlewares get called.
+        headers['Accept'] ||= 'application/json'
+        [method, url, headers, data]
+      end
+
+      def handle_response(http_response, rest_request, return_value)
+        # temporary hack, skip processing if return_value is false
+        # needed to keep conditional get stuff working correctly.
+        return [http_response, rest_request, return_value] if return_value == false
+        if http_response['content-type'] =~ /json/
+          if @raw_output
+            return_value = http_response.body.to_s
+          else
+            if @inflate_json_class
+              return_value = Chef::JSONCompat.from_json(http_response.body.chomp)
+            else
+              return_value = Chef::JSONCompat.from_json(http_response.body.chomp, :create_additions => false)
+            end
+          end
+          [http_response, rest_request, return_value]
+        else
+          Chef::Log.warn("Expected JSON response, but got content-type '#{http_response['content-type']}'")
+          return [http_response, rest_request, http_response.body.to_s]
+        end
+      end
+
+      def stream_response_handler(response)
+        nil
+      end
+
+    end
+  end
+end

data/lib/chef/http/json_to_model_output.rb

@@ -0,0 +1,34 @@
+#--
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2013 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 'chef/http/json_output'
+
+class Chef
+  class HTTP
+
+    # A Middleware-ish thing that takes an HTTP response, parses it as JSON if
+    # possible, and converts it into an appropriate model object if it contains
+    # a `json_class` key.
+    class JSONToModelOutput < JSONOutput
+      def initialize(opts={})
+        opts[:inflate_json_class] = true if !opts.has_key?(:inflate_json_class)
+        super
+      end
+    end
+  end
+end

data/lib/chef/http/simple.rb

@@ -0,0 +1,16 @@
+require 'chef/http'
+require 'chef/http/authenticator'
+require 'chef/http/decompressor'
+
+
+class Chef
+  class HTTP
+
+    class Simple < HTTP
+
+      use Decompressor
+      use CookieManager
+
+    end
+  end
+end

data/lib/chef/http/ssl_policies.rb

@@ -0,0 +1,129 @@
+#--
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Thom May (<thom@clearairturbulence.org>)
+# Author:: Nuo Yan (<nuo@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2009, 2010, 2013 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 'openssl'
+
+class Chef
+  class HTTP
+
+    # == Chef::HTTP::DefaultSSLPolicy
+    # Configures SSL behavior on an HTTP object via visitor pattern.
+    class DefaultSSLPolicy
+
+      def self.apply_to(http_client)
+        new(http_client).apply
+        http_client
+      end
+
+      attr_reader :http_client
+
+      def initialize(http_client)
+        @http_client = http_client
+      end
+
+      def apply
+        set_verify_mode
+        set_ca_store
+        set_custom_certs
+        set_client_credentials
+      end
+
+      def set_verify_mode
+        if config[:ssl_verify_mode] == :verify_none
+          http_client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        elsif config[:ssl_verify_mode] == :verify_peer
+          http_client.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+      end
+
+      def set_ca_store
+        if config[:ssl_ca_path]
+          unless ::File.exist?(config[:ssl_ca_path])
+            raise Chef::Exceptions::ConfigurationError, "The configured ssl_ca_path #{config[:ssl_ca_path]} does not exist"
+          end
+          http_client.ca_path = config[:ssl_ca_path]
+        elsif config[:ssl_ca_file]
+          unless ::File.exist?(config[:ssl_ca_file])
+            raise Chef::Exceptions::ConfigurationError, "The configured ssl_ca_file #{config[:ssl_ca_file]} does not exist"
+          end
+          http_client.ca_file = config[:ssl_ca_file]
+        end
+      end
+
+      def set_custom_certs
+        unless http_client.cert_store
+          http_client.cert_store = OpenSSL::X509::Store.new
+          http_client.cert_store.set_default_paths
+        end
+        if config.trusted_certs_dir
+          certs = Dir.glob(File.join(config.trusted_certs_dir, "*.{crt,pem}"))
+          certs.each do |cert_file|
+            cert = OpenSSL::X509::Certificate.new(File.read(cert_file))
+            add_trusted_cert(cert)
+          end
+        end
+      end
+
+      def set_client_credentials
+        if (config[:ssl_client_cert] || config[:ssl_client_key])
+          unless (config[:ssl_client_cert] && config[:ssl_client_key])
+            raise Chef::Exceptions::ConfigurationError, "You must configure ssl_client_cert and ssl_client_key together"
+          end
+          unless ::File.exists?(config[:ssl_client_cert])
+            raise Chef::Exceptions::ConfigurationError, "The configured ssl_client_cert #{config[:ssl_client_cert]} does not exist"
+          end
+          unless ::File.exists?(config[:ssl_client_key])
+            raise Chef::Exceptions::ConfigurationError, "The configured ssl_client_key #{config[:ssl_client_key]} does not exist"
+          end
+          http_client.cert = OpenSSL::X509::Certificate.new(::File.read(config[:ssl_client_cert]))
+          http_client.key = OpenSSL::PKey::RSA.new(::File.read(config[:ssl_client_key]))
+        end
+      end
+
+      def config
+        Chef::Config
+      end
+
+      private
+
+      def add_trusted_cert(cert)
+        http_client.cert_store.add_cert(cert)
+      rescue OpenSSL::X509::StoreError => e
+        raise e unless e.message == 'cert already in hash table'
+      end
+
+    end
+
+    class APISSLPolicy < DefaultSSLPolicy
+
+      def set_verify_mode
+        if config[:ssl_verify_mode] == :verify_peer or config[:verify_api_cert]
+          http_client.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        elsif config[:ssl_verify_mode] == :verify_none
+          http_client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+      end
+    end
+
+  end
+end

data/lib/chef/knife.rb

@@ -20,6 +20,7 @@
 require 'forwardable'
 require 'chef/version'
 require 'mixlib/cli'
+require 'chef/config_fetcher'
 require 'chef/mixin/convert_to_class_name'
 require 'chef/mixin/path_sanity'
 require 'chef/knife/core/subcommand_loader'
@@ -314,7 +315,11 @@ class Chef
       config_file_settings
     end
 
-    def locate_config_file
+    def self.config_fetcher(candidate_config)
+      Chef::ConfigFetcher.new(candidate_config, Chef::Config.config_file_jail)
+    end
+
+    def self.locate_config_file
       candidate_configs = []
 
       # Look for $KNIFE_HOME/knife.rb (allow multiple knives config on same machine)
@@ -326,8 +331,8 @@ class Chef
         candidate_configs << File.join(Dir.pwd, 'knife.rb')
       end
       # Look for $UPWARD/.chef/knife.rb
-      if self.class.chef_config_dir
-        candidate_configs << File.join(self.class.chef_config_dir, 'knife.rb')
+      if chef_config_dir
+        candidate_configs << File.join(chef_config_dir, 'knife.rb')
       end
       # Look for $HOME/.chef/knife.rb
       if ENV['HOME']
@@ -335,12 +340,12 @@ class Chef
       end
 
       candidate_configs.each do | candidate_config |
-        candidate_config = File.expand_path(candidate_config)
-        if File.exist?(candidate_config)
-          config[:config_file] = candidate_config
-          break
+        fetcher = config_fetcher(candidate_config)
+        if !fetcher.config_missing?
+          return candidate_config
         end
       end
+      return nil
     end
 
     # Apply Config in this order:
@@ -379,6 +384,12 @@ class Chef
       Chef::Config[:chef_server_url]   = config[:chef_server_url] if config[:chef_server_url]
       Chef::Config[:environment]       = config[:environment]     if config[:environment]
 
+      Chef::Config.local_mode = config[:local_mode] if config.has_key?(:local_mode)
+      if Chef::Config.local_mode && !Chef::Config.has_key?(:cookbook_path) && !Chef::Config.has_key?(:chef_repo_path)
+        Chef::Config.chef_repo_path = Chef::Config.find_chef_repo_path(Dir.pwd)
+      end
+      Chef::Config.chef_zero.port = config[:chef_zero_port] if config[:chef_zero_port]
+
       # Expand a relative path from the config directory. Config from command
       # line should already be expanded, and absolute paths will be unchanged.
       if Chef::Config[:client_key] && config[:config_file]
@@ -397,14 +408,20 @@ class Chef
     end
 
     def configure_chef
-      unless config[:config_file]
-        locate_config_file
+      if !config[:config_file]
+        located_config_file = self.class.locate_config_file
+        config[:config_file] = located_config_file if located_config_file
       end
 
-      # Don't try to load a knife.rb if it doesn't exist.
+      # Don't try to load a knife.rb if it wasn't specified.
       if config[:config_file]
+        fetcher = Chef::ConfigFetcher.new(config[:config_file], Chef::Config.config_file_jail)
+        if fetcher.config_missing?
+          ui.error("Specified config file #{config[:config_file]} does not exist#{Chef::Config.config_file_jail ? " or is not under config file jail #{Chef::Config.config_file_jail}" : ""}!")
+          exit 1
+        end
         Chef::Log.debug("Using configuration from #{config[:config_file]}")
-        read_config_file(config[:config_file])
+        read_config(fetcher.read_config, config[:config_file])
       else
         # ...but do log a message if no config was found.
         Chef::Config[:color] = config[:color]
@@ -415,24 +432,24 @@ class Chef
       apply_computed_config
     end
 
-    def read_config_file(file)
-      Chef::Config.from_file(file)
+    def read_config(config_content, config_file_path)
+      Chef::Config.from_string(config_content, config_file_path)
     rescue SyntaxError => e
-      ui.error "You have invalid ruby syntax in your config file #{file}"
+      ui.error "You have invalid ruby syntax in your config file #{config_file_path}"
       ui.info(ui.color(e.message, :red))
-      if file_line = e.message[/#{Regexp.escape(file)}:[\d]+/]
+      if file_line = e.message[/#{Regexp.escape(config_file_path)}:[\d]+/]
         line = file_line[/:([\d]+)$/, 1].to_i
-        highlight_config_error(file, line)
+        highlight_config_error(config_file_path, line)
       end
       exit 1
     rescue Exception => e
-      ui.error "You have an error in your config file #{file}"
+      ui.error "You have an error in your config file #{config_file_path}"
       ui.info "#{e.class.name}: #{e.message}"
-      filtered_trace = e.backtrace.grep(/#{Regexp.escape(file)}/)
+      filtered_trace = e.backtrace.grep(/#{Regexp.escape(config_file_path)}/)
       filtered_trace.each {|line| ui.msg("  " + ui.color(line, :red))}
       if !filtered_trace.empty?
-        line_nr = filtered_trace.first[/#{Regexp.escape(file)}:([\d]+)/, 1]
-        highlight_config_error(file, line_nr.to_i)
+        line_nr = filtered_trace.first[/#{Regexp.escape(config_file_path)}:([\d]+)/, 1]
+        highlight_config_error(config_file_path, line_nr.to_i)
       end
 
       exit 1
@@ -458,14 +475,19 @@ class Chef
       stdout.puts("USAGE: " + self.opt_parser.to_s)
     end
 
-    def run_with_pretty_exceptions
+    def run_with_pretty_exceptions(raise_exception = false)
       unless self.respond_to?(:run)
         ui.error "You need to add a #run method to your knife command before you can use it"
       end
       enforce_path_sanity
-      run
+      Chef::Application.setup_server_connectivity
+      begin
+        run
+      ensure
+        Chef::Application.destroy_server_connectivity
+      end
     rescue Exception => e
-      raise if Chef::Config[:verbosity] == 2
+      raise if raise_exception || Chef::Config[:verbosity] == 2
       humanize_exception(e)
       exit 100
     end

data/lib/chef/knife/bootstrap.rb

@@ -89,6 +89,11 @@ class Chef
         :description => "The proxy server for the node being bootstrapped",
         :proc => Proc.new { |p| Chef::Config[:knife][:bootstrap_proxy] = p }
 
+      option :bootstrap_no_proxy,
+        :long => "--bootstrap-no-proxy [NO_PROXY_URL|NO_PROXY_IP]",
+        :description => "Do not proxy locations for the node being bootstrapped",
+        :proc => Proc.new { |np| Chef::Config[:knife][:bootstrap_no_proxy] = np }
+
       option :distro,
         :short => "-d DISTRO",
         :long => "--distro DISTRO",
@@ -141,11 +146,13 @@ class Chef
       option :secret,
         :short => "-s SECRET",
         :long  => "--secret ",
-        :description => "The secret key to use to encrypt data bag item values"
+        :description => "The secret key to use to encrypt data bag item values",
+        :proc => Proc.new { |s| Chef::Config[:knife][:secret] = s }
 
       option :secret_file,
         :long => "--secret-file SECRET_FILE",
-        :description => "A file containing the secret key to use to encrypt data bag item values"
+        :description => "A file containing the secret key to use to encrypt data bag item values",
+        :proc => Proc.new { |sf| Chef::Config[:knife][:secret_file] = sf }
 
       def find_template(template=nil)
         # Are we bootstrapping using an already shipped template?
@@ -244,7 +251,7 @@ class Chef
         command = render_template(read_template)
 
         if config[:use_sudo]
-          command = config[:use_sudo_password] ? "echo #{config[:ssh_password]} | sudo -S #{command}" : "sudo #{command}"
+          command = config[:use_sudo_password] ? "echo '#{config[:ssh_password]}' | sudo -S #{command}" : "sudo #{command}"
         end
 
         command