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

data/lib/chef/resource/windows_script.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -27,14 +27,14 @@ class Chef
 
       def initialize(name, run_context, resource_name, interpreter_command)
         super(name, run_context)
-        @interpreter = interpreter_command        
+        @interpreter = interpreter_command
         @resource_name = resource_name
       end
 
       include Chef::Mixin::WindowsArchitectureHelper
 
       public
-      
+
       def architecture(arg=nil)
         assert_architecture_compatible!(arg) if ! arg.nil?
         result = set_or_return(
@@ -43,7 +43,7 @@ class Chef
           :kind_of => Symbol
         )
       end
-      
+
       protected
 
       def assert_architecture_compatible!(desired_architecture)
@@ -56,7 +56,7 @@ class Chef
       def node
         run_context && run_context.node
       end
-      
+
     end
   end
 end

data/lib/chef/resource/yum_package.rb

@@ -6,9 +6,9 @@
 # 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.

data/lib/chef/resource_collection.rb

@@ -183,7 +183,7 @@ class Chef
           "The string `#{query_object}' is not valid for resource collection lookup. Correct syntax is `resource_type[resource_name]'"
       else
         raise Chef::Exceptions::InvalidResourceSpecification,
-          "The object `#{query_object.inspect}' is not valid for resource collection lookup. " + 
+          "The object `#{query_object.inspect}' is not valid for resource collection lookup. " +
           "Use a String like `resource_type[resource_name]' or a Chef::Resource object"
       end
     end

data/lib/chef/resource_collection/stepable_iterator.rb

@@ -5,9 +5,9 @@
 # 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.
@@ -18,94 +18,94 @@
 class Chef
   class ResourceCollection
     class StepableIterator
-      
+
       def self.for_collection(new_collection)
         instance = new(new_collection)
         instance
       end
-      
+
       attr_accessor :collection
       attr_reader :position
-      
+
       def initialize(collection=[])
         @position = 0
         @paused = false
         @collection = collection
       end
-      
+
       def size
         collection.size
       end
-      
+
       def each(&block)
         reset_iteration(block)
         @iterator_type = :element
         iterate
       end
-      
+
       def each_index(&block)
         reset_iteration(block)
         @iterator_type = :index
         iterate
       end
-      
+
       def each_with_index(&block)
         reset_iteration(block)
         @iterator_type = :element_with_index
         iterate
       end
-      
+
       def paused?
         @paused
       end
-      
+
       def pause
         @paused = true
       end
-      
+
       def resume
         @paused = false
         iterate
       end
-      
+
       def rewind
         @position = 0
       end
-      
+
       def skip_back(skips=1)
         @position -= skips
       end
-      
+
       def skip_forward(skips=1)
         @position += skips
       end
-      
+
       def step
         return nil if @position == size
         call_iterator_block
         @position += 1
       end
-      
+
       def iterate_on(iteration_type, &block)
         @iterator_type = iteration_type
         @iterator_block = block
       end
-      
+
       private
-      
+
       def reset_iteration(iterator_block)
         @iterator_block = iterator_block
         @position = 0
         @paused = false
       end
-      
+
       def iterate
         while @position < size && !paused?
           step
         end
         collection
       end
-      
+
       def call_iterator_block
         case @iterator_type
         when :element
@@ -118,7 +118,7 @@ class Chef
           raise "42error: someone forgot to set @iterator_type, wtf?"
         end
       end
-      
+
     end
   end
 end

data/lib/chef/resource_definition.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -21,19 +21,19 @@ require 'chef/mixin/params_validate'
 
 class Chef
   class ResourceDefinition
-    
+
     include Chef::Mixin::FromFile
     include Chef::Mixin::ParamsValidate
-    
+
     attr_accessor :name, :params, :recipe, :node
-    
+
     def initialize(node=nil)
       @name = nil
       @params = Hash.new
       @recipe = nil
       @node = node
     end
-    
+
     def define(resource_name, prototype_params=nil, &block)
       unless resource_name.kind_of?(Symbol)
         raise ArgumentError, "You must use a symbol when defining a new resource!"
@@ -52,14 +52,14 @@ class Chef
       end
       true
     end
-    
+
     # When we do the resource definition, we're really just setting new values for
     # the paramaters we prototyped at the top.  This method missing is as simple as
     # it gets.
     def method_missing(symbol, *args)
       @params[symbol] = args.length == 1 ? args[0] : args
     end
-    
+
     def to_s
       "#{name.to_s}"
     end

data/lib/chef/resource_definition_list.rb

@@ -6,9 +6,9 @@
 # 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.

data/lib/chef/resource_reporter.rb

@@ -52,8 +52,8 @@ class Chef
         as_hash["type"]   = new_resource.class.dsl_name
         as_hash["name"]   = new_resource.name
         as_hash["id"]     = new_resource.identity
-        as_hash["after"]  = new_resource.state
-        as_hash["before"] = current_resource ? current_resource.state : {}
+        as_hash["after"]  = state(new_resource)
+        as_hash["before"] = current_resource ? state(current_resource) : {}
         as_hash["duration"] = (elapsed_time * 1000).to_i.to_s
         as_hash["delta"]  = new_resource.diff if new_resource.respond_to?("diff")
         as_hash["delta"]  = "" if as_hash["delta"].nil?
@@ -80,6 +80,12 @@ class Chef
         !self.exception
       end
 
+      def state(r)
+        r.class.state_attrs.inject({}) do |state_attrs, attr_name|
+          state_attrs[attr_name] = r.send(attr_name)
+          state_attrs
+        end
+      end
     end # End class ResouceReport
 
     attr_reader :updated_resources

data/lib/chef/resources.rb

@@ -56,6 +56,7 @@ require 'chef/resource/registry_key'
 require 'chef/resource/remote_directory'
 require 'chef/resource/remote_file'
 require 'chef/resource/rpm_package'
+require 'chef/resource/solaris_package'
 require 'chef/resource/route'
 require 'chef/resource/ruby'
 require 'chef/resource/ruby_block'
@@ -69,3 +70,4 @@ require 'chef/resource/timestamped_deploy'
 require 'chef/resource/user'
 require 'chef/resource/yum_package'
 require 'chef/resource/lwrp_base'
+require 'chef/resource/bff_package'

data/lib/chef/rest.rb

@@ -20,15 +20,18 @@
 # limitations under the License.
 #
 
-require 'zlib'
-require 'net/https'
-require 'uri'
-require 'chef/json_compat'
 require 'tempfile'
-require 'chef/rest/auth_credentials'
-require 'chef/rest/rest_request'
-require 'chef/monkey_patches/string'
-require 'chef/monkey_patches/net_http'
+require 'chef/http'
+class Chef
+  class HTTP; end
+  class REST < HTTP; end
+end
+
+require 'chef/http/authenticator'
+require 'chef/http/decompressor'
+require 'chef/http/json_input'
+require 'chef/http/json_to_model_output'
+require 'chef/http/cookie_manager'
 require 'chef/config'
 require 'chef/exceptions'
 require 'chef/platform/query_helpers'
@@ -37,54 +40,53 @@ class Chef
   # == Chef::REST
   # Chef's custom REST client with built-in JSON support and RSA signed header
   # authentication.
-  class REST
+  class REST < HTTP
 
-    class NoopInflater
-      def inflate(chunk)
-        chunk
-      end
-    end
+    # Backwards compatibility for things that use
+    # Chef::REST::RESTRequest or its constants
+    RESTRequest = HTTP::HTTPRequest
 
-    attr_reader :auth_credentials
     attr_accessor :url, :cookies, :sign_on_redirect, :redirect_limit
 
-    CONTENT_ENCODING  = "content-encoding".freeze
-    GZIP              = "gzip".freeze
-    DEFLATE           = "deflate".freeze
-    IDENTITY          = "identity".freeze
+    attr_reader :authenticator
 
     # Create a REST client object. The supplied +url+ is used as the base for
     # all subsequent requests. For example, when initialized with a base url
     # http://localhost:4000, a call to +get_rest+ with 'nodes' will make an
     # HTTP GET request to http://localhost:4000/nodes
     def initialize(url, client_name=Chef::Config[:node_name], signing_key_filename=Chef::Config[:client_key], options={})
-      @url = url
-      @cookies = CookieJar.instance
-      @default_headers = options[:headers] || {}
-      @signing_key_filename = signing_key_filename
-      @key = load_signing_key(@signing_key_filename, options[:raw_key])
-      @auth_credentials = AuthCredentials.new(client_name, @key)
-      @sign_on_redirect, @sign_request = true, true
-      @redirects_followed = 0
-      @redirect_limit = 10
-      @disable_gzip = false
-      handle_options(options)
+      options[:client_name] = client_name
+      options[:signing_key_filename] = signing_key_filename
+      super(url, options)
+
+      @decompressor = Decompressor.new(options)
+      @authenticator = Authenticator.new(options)
+
+      @middlewares << JSONInput.new(options)
+      @middlewares << JSONToModelOutput.new(options)
+      @middlewares << CookieManager.new(options)
+      @middlewares << @decompressor
+      @middlewares << @authenticator
     end
 
     def signing_key_filename
-      @signing_key_filename
+      authenticator.signing_key_filename
+    end
+
+    def auth_credentials
+      authenticator.auth_credentials
     end
 
     def client_name
-      @auth_credentials.client_name
+      authenticator.client_name
     end
 
     def signing_key
-      @raw_key
+      authenticator.raw_key
     end
 
-    def last_response
-      @last_response
+    def sign_requests?
+      authenticator.sign_requests?
     end
 
     # Send an HTTP GET request to the path
@@ -97,37 +99,18 @@ class Chef
     #   to JSON inflated.
     def get(path, raw=false, headers={})
       if raw
-        streaming_request(create_url(path), headers)
+        streaming_request(path, headers)
       else
-        api_request(:GET, create_url(path), headers)
+        request(:GET, path, headers)
       end
     end
 
-    def head(path, headers={})
-      api_request(:HEAD, create_url(path), headers)
-    end
-
     alias :get_rest :get
 
-    # Send an HTTP DELETE request to the path
-    def delete(path, headers={})
-      api_request(:DELETE, create_url(path), headers)
-    end
-
     alias :delete_rest :delete
 
-    # Send an HTTP POST request to the path
-    def post(path, json, headers={})
-      api_request(:POST, create_url(path), headers, json)
-    end
-
     alias :post_rest :post
 
-    # Send an HTTP PUT request to the path
-    def put(path, json, headers={})
-      api_request(:PUT, create_url(path), headers, json)
-    end
-
     alias :put_rest :put
 
     # Streams a download to a tempfile, then yields the tempfile to a block.
@@ -139,308 +122,61 @@ class Chef
       streaming_request(create_url(path), headers) {|tmp_file| yield tmp_file }
     end
 
-    def create_url(path)
-      if path =~ /^(http|https):\/\//
-        URI.parse(path)
-      else
-        URI.parse("#{@url}/#{path}")
-      end
-    end
+    alias :api_request :request
 
-    def sign_requests?
-      auth_credentials.sign_requests? && @sign_request
-    end
+    alias :raw_http_request :send_http_request
 
-    # Runs an HTTP request to a JSON API with JSON body. File Download not supported.
-    def api_request(method, url, headers={}, data=false)
-      json_body = data ? Chef::JSONCompat.to_json(data) : nil
-      # Force encoding to binary to fix SSL related EOFErrors
-      # cf. http://tickets.opscode.com/browse/CHEF-2363
-      # http://redmine.ruby-lang.org/issues/5233
-      json_body.force_encoding(Encoding::BINARY) if json_body.respond_to?(:force_encoding)
-      raw_http_request(method, url, headers, json_body)
-    end
-    
-    # Runs an HTTP request to a JSON API with raw body. File Download not supported.
-    def raw_http_request(method, url, headers, body)
-      headers = build_headers(method, url, headers, body)
-      retriable_rest_request(method, url, body, headers) do |rest_request|
-        begin
-          response = rest_request.call {|r| r.read_body}
-          @last_response = response
-
-          Chef::Log.debug("---- HTTP Status and Header Data: ----")
-          Chef::Log.debug("HTTP #{response.http_version} #{response.code} #{response.msg}")
-
-          response.each do |header, value|
-            Chef::Log.debug("#{header}: #{value}")
-          end
-          Chef::Log.debug("---- End HTTP Status/Header Data ----")
-
-          response_body = decompress_body(response)
-
-          if response.kind_of?(Net::HTTPSuccess)
-            if response['content-type'] =~ /json/
-              Chef::JSONCompat.from_json(response_body.chomp)
-            else
-              Chef::Log.warn("Expected JSON response, but got content-type '#{response['content-type']}'")
-              response_body.to_s
-            end
-          elsif response.kind_of?(Net::HTTPNotModified) # Must be tested before Net::HTTPRedirection because it's subclass.
-            false
-          elsif redirect_location = redirected_to(response)
-            if [:GET, :HEAD].include?(method)
-              follow_redirect {api_request(method, create_url(redirect_location))}
-            else
-              raise Exceptions::InvalidRedirect, "#{method} request was redirected from #{url} to #{redirect_location}. Only GET and HEAD support redirects."
-            end
-          else
-            # have to decompress the body before making an exception for it. But the body could be nil.
-            response.body.replace(response_body) if response.body.respond_to?(:replace)
-
-            if response['content-type'] =~ /json/
-              exception = Chef::JSONCompat.from_json(response_body)
-              msg = "HTTP Request Returned #{response.code} #{response.message}: "
-              msg << (exception["error"].respond_to?(:join) ? exception["error"].join(", ") : exception["error"].to_s)
-              Chef::Log.info(msg)
-            end
-            response.error!
-          end
-        rescue Exception => e
-          if e.respond_to?(:chef_rest_request=)
-            e.chef_rest_request = rest_request
-          end
-          raise
-        end
-      end
-    end
+    public :raw_http_request
 
-    def decompress_body(response)
-      if gzip_disabled? || response.body.nil?
-        response.body
-      else
-        case response[CONTENT_ENCODING]
-        when GZIP
-          Chef::Log.debug "decompressing gzip response"
-          Zlib::Inflate.new(Zlib::MAX_WBITS + 16).inflate(response.body)
-        when DEFLATE
-          Chef::Log.debug "decompressing deflate response"
-          Zlib::Inflate.inflate(response.body)
-        else
-          response.body
-        end
-      end
-    end
-
-    # Makes a streaming download request. <b>Doesn't speak JSON.</b>
-    # Streams the response body to a tempfile. If a block is given, it's
-    # passed to Tempfile.open(), which means that the tempfile will automatically
-    # be unlinked after the block is executed.
-    #
-    # If no block is given, the tempfile is returned, which means it's up to
-    # you to unlink the tempfile when you're done with it.
-    def streaming_request(url, headers, &block)
-      headers = build_headers(:GET, url, headers, nil, true)
-      retriable_rest_request(:GET, url, nil, headers) do |rest_request|
-        begin
-          tempfile = nil
-          response = rest_request.call do |r|
-            if block_given? && r.kind_of?(Net::HTTPSuccess)
-              begin
-                tempfile = stream_to_tempfile(url, r, &block)
-                yield tempfile
-              ensure
-                tempfile.close!
-              end
-            else
-              tempfile = stream_to_tempfile(url, r)
-            end
-          end
-          @last_response = response
-          if response.kind_of?(Net::HTTPSuccess)
-            tempfile
-          elsif redirect_location = redirected_to(response)
-            # TODO: test tempfile unlinked when following redirects.
-            tempfile && tempfile.close!
-            follow_redirect {streaming_request(create_url(redirect_location), {}, &block)}
-          else
-            tempfile && tempfile.close!
-            response.error!
-          end
-        rescue Exception => e
-          if e.respond_to?(:chef_rest_request=)
-            e.chef_rest_request = rest_request
-          end
-          raise
-        end
-      end
-    end
-
-    def retriable_rest_request(method, url, req_body, headers)
-      rest_request = Chef::REST::RESTRequest.new(method, url, req_body, headers)
+    # Deprecated:
+    # Responsibilities of this method have been split up. The #http_client is
+    # now responsible for making individual requests, while
+    # #retrying_http_errors handles error/retry logic.
+    def retriable_http_request(method, url, req_body, headers)
+      rest_request = Chef::HTTP::HTTPRequest.new(method, url, req_body, headers)
 
       Chef::Log.debug("Sending HTTP Request via #{method} to #{url.host}:#{url.port}#{rest_request.path}")
 
-      http_attempts = 0
-
-      begin
-        http_attempts += 1
-
+      retrying_http_errors(url) do
         yield rest_request
-
-      rescue SocketError, Errno::ETIMEDOUT => e
-        e.message.replace "Error connecting to #{url} - #{e.message}"
-        raise e
-      rescue Errno::ECONNREFUSED
-        if http_retry_count - http_attempts + 1 > 0
-          Chef::Log.error("Connection refused connecting to #{url.host}:#{url.port} for #{rest_request.path}, retry #{http_attempts}/#{http_retry_count}")
-          sleep(http_retry_delay)
-          retry
-        end
-        raise Errno::ECONNREFUSED, "Connection refused connecting to #{url.host}:#{url.port} for #{rest_request.path}, giving up"
-      rescue Timeout::Error
-        if http_retry_count - http_attempts + 1 > 0
-          Chef::Log.error("Timeout connecting to #{url.host}:#{url.port} for #{rest_request.path}, retry #{http_attempts}/#{http_retry_count}")
-          sleep(http_retry_delay)
-          retry
-        end
-        raise Timeout::Error, "Timeout connecting to #{url.host}:#{url.port} for #{rest_request.path}, giving up"
-      rescue Net::HTTPFatalError => e
-        if http_retry_count - http_attempts + 1 > 0
-          sleep_time = 1 + (2 ** http_attempts) + rand(2 ** http_attempts)
-          Chef::Log.error("Server returned error for #{url}, retrying #{http_attempts}/#{http_retry_count} in #{sleep_time}s")
-          sleep(sleep_time)
-          retry
-        end
-        raise
       end
     end
 
-    def authentication_headers(method, url, json_body=nil)
-      request_params = {:http_method => method, :path => url.path, :body => json_body, :host => "#{url.host}:#{url.port}"}
-      request_params[:body] ||= ""
-      auth_credentials.signature_headers(request_params)
-    end
-
-    def http_retry_delay
-      config[:http_retry_delay]
-    end
-
-    def http_retry_count
-      config[:http_retry_count]
+    # Customized streaming behavior; sets the accepted content type to "*/*"
+    # if not otherwise specified for compatibility purposes
+    def streaming_request(url, headers, &block)
+      headers["Accept"] ||= "*/*"
+      super
     end
 
-    def config
-      Chef::Config
-    end
+    alias :retriable_rest_request :retriable_http_request
 
     def follow_redirect
-      raise Chef::Exceptions::RedirectLimitExceeded if @redirects_followed >= redirect_limit
-      @redirects_followed += 1
-      Chef::Log.debug("Following redirect #{@redirects_followed}/#{redirect_limit}")
-      if @sign_on_redirect
-        yield
-      else
-        @sign_request = false
-        yield
+      unless @sign_on_redirect
+        @authenticator.sign_request = false
       end
+      super
     ensure
-      @redirects_followed = 0
-      @sign_request = true
+      @authenticator.sign_request = true
     end
 
-    private
+    public :create_url
 
-    def redirected_to(response)
-      return nil  unless response.kind_of?(Net::HTTPRedirection)
-      # Net::HTTPNotModified is undesired subclass of Net::HTTPRedirection so test for this
-      return nil  if response.kind_of?(Net::HTTPNotModified)
-      response['location']
+    def http_client(base_url=nil)
+      base_url ||= url
+      BasicClient.new(base_url, :ssl_policy => Chef::HTTP::APISSLPolicy)
     end
 
-    def build_headers(method, url, headers={}, json_body=false, raw=false)
-      headers                 = @default_headers.merge(headers)
-      #headers['Accept']       = "application/json" unless raw
-      headers['Accept']       = "application/json" unless raw
-      headers["Content-Type"] = 'application/json' if json_body
-      headers['Content-Length'] = json_body.bytesize.to_s if json_body
-      headers[RESTRequest::ACCEPT_ENCODING] = RESTRequest::ENCODING_GZIP_DEFLATE unless gzip_disabled?
-      headers.merge!(authentication_headers(method, url, json_body)) if sign_requests?
-      headers.merge!(Chef::Config[:custom_http_headers]) if Chef::Config[:custom_http_headers]
-      headers
-    end
-
-    def stream_to_tempfile(url, response)
-      tf = Tempfile.open("chef-rest")
-      if Chef::Platform.windows?
-        tf.binmode # required for binary files on Windows platforms
-      end
-      Chef::Log.debug("Streaming download from #{url.to_s} to tempfile #{tf.path}")
-      # Stolen from http://www.ruby-forum.com/topic/166423
-      # Kudos to _why!
-
-      inflater = if gzip_disabled?
-        NoopInflater.new
-      else
-        case response[CONTENT_ENCODING]
-        when GZIP
-          Chef::Log.debug "decompressing gzip stream"
-          Zlib::Inflate.new(Zlib::MAX_WBITS + 16)
-        when DEFLATE
-          Chef::Log.debug "decompressing inflate stream"
-          Zlib::Inflate.new
-        else
-          NoopInflater.new
-        end
-      end
+    ############################################################################
+    # DEPRECATED
+    ############################################################################
 
-      response.read_body do |chunk|
-        tf.write(inflater.inflate(chunk))
-      end
-      tf.close
-      tf
-    rescue Exception
-      tf.close!
-      raise
+    def decompress_body(body)
+      @decompressor.decompress_body(body)
     end
 
-    # gzip is disabled using the disable_gzip => true option in the
-    # constructor. When gzip is disabled, no 'Accept-Encoding' header will be
-    # set, and the response will not be decompressed, no matter what the
-    # Content-Encoding header of the response is. The intended use case for
-    # this is to work around situations where you request +file.tar.gz+, but
-    # the server responds with a content type of tar and a content encoding of
-    # gzip, tricking the client into decompressing the response so you end up
-    # with a tar archive (no gzip) named file.tar.gz
-    def gzip_disabled?
-      @disable_gzip
-    end
-
-    def handle_options(opts)
-      opts.each do |name, value|
-        case name.to_s
-        when 'disable_gzip'
-          @disable_gzip = value
-        end
-      end
-    end
-
-    def load_signing_key(key_file, raw_key = nil)
-      if (!!key_file)
-        @raw_key = IO.read(key_file).strip
-      elsif (!!raw_key)
-        @raw_key = raw_key.strip
-      else
-        return nil
-      end
-      @key = OpenSSL::PKey::RSA.new(@raw_key)
-    rescue SystemCallError, IOError => e
-      Chef::Log.warn "Failed to read the private key #{key_file}: #{e.inspect}"
-      raise Chef::Exceptions::PrivateKeyMissing, "I cannot read #{key_file}, which you told me to use to sign requests!"
-    rescue OpenSSL::PKey::RSAError
-      msg = "The file #{key_file} or :raw_key option does not contain a correctly formatted private key.\n"
-      msg << "The key file should begin with '-----BEGIN RSA PRIVATE KEY-----' and end with '-----END RSA PRIVATE KEY-----'"
-      raise Chef::Exceptions::InvalidPrivateKey, msg
+    def authentication_headers(method, url, json_body=nil)
+      authenticator.authentication_headers(method, url, json_body)
     end
 
   end