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

data/lib/chef/role.rb

@@ -233,20 +233,24 @@ class Chef
     # Load a role from disk - prefers to load the JSON, but will happily load
     # the raw rb files as well.
     def self.from_disk(name, force=nil)
-      js_file = File.join(Chef::Config[:role_path], "#{name}.json")
-      rb_file = File.join(Chef::Config[:role_path], "#{name}.rb")
-
-      if File.exists?(js_file) || force == "json"
-        # from_json returns object.class => json_class in the JSON.
-        Chef::JSONCompat.from_json(IO.read(js_file))
-      elsif File.exists?(rb_file) || force == "ruby"
-        role = Chef::Role.new
-        role.name(name)
-        role.from_file(rb_file)
-        role
-      else
-        raise Chef::Exceptions::RoleNotFound, "Role '#{name}' could not be loaded from disk"
+      paths = Array(Chef::Config[:role_path])
+
+      paths.each do |p|
+        js_file = File.join(p, "#{name}.json")
+        rb_file = File.join(p, "#{name}.rb")
+
+        if File.exists?(js_file) || force == "json"
+          # from_json returns object.class => json_class in the JSON.
+          return Chef::JSONCompat.from_json(IO.read(js_file))
+        elsif File.exists?(rb_file) || force == "ruby"
+          role = Chef::Role.new
+          role.name(name)
+          role.from_file(rb_file)
+          return role
+        end
       end
+
+      raise Chef::Exceptions::RoleNotFound, "Role '#{name}' could not be loaded from disk"
     end
 
   end

data/lib/chef/run_context.rb

@@ -204,6 +204,20 @@ class Chef
       @loaded_attributes["#{cookbook}::#{attribute_file}"] = true
     end
 
+    ##
+    # Cookbook File Introspection
+
+    def has_template_in_cookbook?(cookbook, template_name)
+      cookbook = cookbook_collection[cookbook]
+      cookbook.has_template_for_node?(node, template_name)
+    end
+
+    def has_cookbook_file_in_cookbook?(cookbook, cb_file_name)
+      cookbook = cookbook_collection[cookbook]
+      cookbook.has_cookbook_file_for_node?(node, cb_file_name)
+    end
+
+
     private
 
     def loaded_recipe(cookbook, recipe)

data/lib/chef/run_context/cookbook_compiler.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.
@@ -259,7 +259,7 @@ class Chef
         cookbook_collection[cookbook].segment_filenames(segment).sort
       end
 
-      # Yields the name, as a symbol, of each cookbook depended on by 
+      # Yields the name, as a symbol, of each cookbook depended on by
       # +cookbook_name+ in lexical sort order.
       def each_cookbook_dep(cookbook_name, &block)
         cookbook = cookbook_collection[cookbook_name]

data/lib/chef/run_lock.rb

@@ -17,6 +17,9 @@
 
 require 'chef/mixin/create_path'
 require 'fcntl'
+if Chef::Platform.windows?
+  require 'chef/win32/mutex'
+end
 
 class Chef
 
@@ -30,20 +33,16 @@ class Chef
     include Chef::Mixin::CreatePath
 
     attr_reader :runlock
+    attr_reader :mutex
     attr_reader :runlock_file
 
     # Create a new instance of RunLock
     # === Arguments
-    # * config::: This will generally be the `Chef::Config`, but any Hash-like
-    #   object with Symbol keys will work. See 'Parameters' section.
-    # === Parameters/Config
-    # * :lockfile::: if set, this will be used as the full path to the lockfile.
-    # * :file_cache_path::: if `:lockfile` is not set, the lock file will be
-    #   named "chef-client-running.pid" and be placed in the directory given by
-    #   `:file_cache_path`
-    def initialize(config)
-      @runlock_file = config[:lockfile] || "#{config[:file_cache_path]}/chef-client-running.pid"
+    # * :lockfile::: the full path to the lockfile.
+    def initialize(lockfile)
+      @runlock_file = lockfile
       @runlock = nil
+      @mutex = nil
     end
 
     # Acquire the system-wide lock. Will block indefinitely if another process
@@ -52,31 +51,73 @@ class Chef
     # Each call to acquire should have a corresponding call to #release.
     #
     # The implementation is based on File#flock (see also: flock(2)).
+    #
+    # Either acquire() or test() methods should be called in order to
+    # get the ownership of run_lock.
     def acquire
+      wait unless test
+    end
+
+    #
+    # Tests and if successful acquires the system-wide lock.
+    # Returns true if the lock is acquired, false otherwise.
+    #
+    # Either acquire() or test() methods should be called in order to
+    # get the ownership of run_lock.
+    def test
       # ensure the runlock_file path exists
       create_path(File.dirname(runlock_file))
-      @runlock = File.open(runlock_file,'w+')
-      # if we support FD_CLOEXEC (linux, !windows), then use it.
-      # NB: ruby-2.0.0-p195 sets FD_CLOEXEC by default, but not ruby-1.8.7/1.9.3
-      if Fcntl.const_defined?('F_SETFD') && Fcntl.const_defined?('FD_CLOEXEC')
-        runlock.fcntl(Fcntl::F_SETFD, runlock.fcntl(Fcntl::F_GETFD, 0) | Fcntl::FD_CLOEXEC)
+      @runlock = File.open(runlock_file,'a+')
+
+      if Chef::Platform.windows?
+        acquire_win32_mutex
+      else
+        # If we support FD_CLOEXEC, then use it.
+        # NB: ruby-2.0.0-p195 sets FD_CLOEXEC by default, but not
+        # ruby-1.8.7/1.9.3
+        if Fcntl.const_defined?('F_SETFD') && Fcntl.const_defined?('FD_CLOEXEC')
+          runlock.fcntl(Fcntl::F_SETFD, runlock.fcntl(Fcntl::F_GETFD, 0) | Fcntl::FD_CLOEXEC)
+        end
+        # Flock will return 0 if it can acquire the lock otherwise it
+        # will return false
+        if runlock.flock(File::LOCK_NB|File::LOCK_EX) == 0
+          true
+        else
+          false
+        end
       end
-      unless runlock.flock(File::LOCK_EX|File::LOCK_NB)
-        # Another chef client running...
-        runpid = runlock.read.strip.chomp
-        Chef::Log.warn("Chef client #{runpid} is running, will wait for it to finish and then run.")
+    end
+
+    #
+    # Waits until acquiring the system-wide lock.
+    #
+    def wait
+      runpid = runlock.read.strip.chomp
+      Chef::Log.warn("Chef client #{runpid} is running, will wait for it to finish and then run.")
+      if Chef::Platform.windows?
+        mutex.wait
+      else
         runlock.flock(File::LOCK_EX)
       end
-      # We grabbed the run lock.  Save the pid.
+    end
+
+    def save_pid
       runlock.truncate(0)
       runlock.rewind # truncate doesn't reset position to 0.
       runlock.write(Process.pid.to_s)
+      # flush the file fsync flushes the system buffers
+      # in addition to ruby buffers
+      runlock.fsync
     end
 
     # Release the system-wide lock.
     def release
       if runlock
-        runlock.flock(File::LOCK_UN)
+        if Chef::Platform.windows?
+          mutex.release
+        else
+          runlock.flock(File::LOCK_UN)
+        end
         runlock.close
         # Don't unlink the pid file, if another chef-client was waiting, it
         # won't be recreated. Better to leave a "dead" pid file than not have
@@ -89,8 +130,20 @@ class Chef
 
     def reset
       @runlock = nil
+      @mutex = nil
     end
 
+    # Since flock mechanism doesn't exist on windows we are using
+    # platform Mutex.
+    # We are creating a "Global" mutex here so that non-admin
+    # users can not DoS chef-client by creating the same named
+    # mutex we are using locally.
+    # Mutex name is case-sensitive contrary to other things in
+    # windows. "\" is the only invalid character.
+    def acquire_win32_mutex
+      @mutex = Chef::ReservedNames::Win32::Mutex.new("Global\\#{runlock_file.gsub(/[\\]/, "/").downcase}")
+      mutex.test
+    end
   end
 end
 

data/lib/chef/server_api.rb

@@ -0,0 +1,41 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2012 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'
+require 'chef/http/authenticator'
+require 'chef/http/cookie_manager'
+require 'chef/http/decompressor'
+require 'chef/http/json_input'
+require 'chef/http/json_output'
+
+class Chef
+  class ServerAPI < Chef::HTTP
+
+    def initialize(url = Chef::Config[:chef_server_url], options = {})
+      options[:client_name] ||= Chef::Config[:node_name]
+      options[:signing_key_filename] ||= Chef::Config[:client_key]
+      super(url, options)
+    end
+
+    use Chef::HTTP::JSONInput
+    use Chef::HTTP::JSONOutput
+    use Chef::HTTP::CookieManager
+    use Chef::HTTP::Decompressor
+    use Chef::HTTP::Authenticator
+  end
+end

data/lib/chef/shell.rb

@@ -24,6 +24,7 @@ require 'chef'
 require 'chef/version'
 require 'chef/client'
 require 'chef/config'
+require 'chef/config_fetcher'
 
 require 'chef/shell/shell_session'
 require 'chef/shell/ext'
@@ -151,26 +152,9 @@ module Shell
   end
 
   def self.parse_json
-    # HACK: copied verbatim from chef/application/client, because it's not
-    # reusable as written there :(
     if Chef::Config[:json_attribs]
-      begin
-        json_io = open(Chef::Config[:json_attribs])
-      rescue SocketError => error
-        fatal!("I cannot connect to #{Chef::Config[:json_attribs]}", 2)
-      rescue Errno::ENOENT => error
-        fatal!("I cannot find #{Chef::Config[:json_attribs]}", 2)
-      rescue Errno::EACCES => error
-        fatal!("Permissions are incorrect on #{Chef::Config[:json_attribs]}. Please chmod a+r #{Chef::Config[:json_attribs]}", 2)
-      rescue Exception => error
-        fatal!("Got an unexpected error reading #{Chef::Config[:json_attribs]}: #{error.message}", 2)
-      end
-
-      begin
-        @json_attribs = Chef::JSONCompat.from_json(json_io.read)
-      rescue JSON::ParserError => error
-        fatal!("Could not parse the provided JSON file (#{Chef::Config[:json_attribs]})!: " + error.message, 2)
-      end
+      config_fetcher = Chef::ConfigFetcher.new(Chef::Config[:json_attribs])
+      @json_attribs = config_fetcher.fetch_json
     end
   end
 

data/lib/chef/shell/shell_session.rb

@@ -173,7 +173,7 @@ module Shell
       cl = Chef::CookbookLoader.new(Chef::Config[:cookbook_path])
       cl.load_cookbooks
       cookbook_collection = Chef::CookbookCollection.new(cl)
-      @run_context = Chef::RunContext.new(node, cookbook_collection, @events) 
+      @run_context = Chef::RunContext.new(node, cookbook_collection, @events)
       @run_context.load(Chef::RunList::RunListExpansionFromDisk.new("_default", []))
       @run_status.run_context = run_context
     end

data/lib/chef/streaming_cookbook_uploader.rb

@@ -15,22 +15,23 @@ class Chef
   class StreamingCookbookUploader
 
     DefaultHeaders = { 'accept' => 'application/json', 'x-chef-version' => ::Chef::VERSION }
-    
+
     class << self
 
       def post(to_url, user_id, secret_key_filename, params = {}, headers = {})
         make_request(:post, to_url, user_id, secret_key_filename, params, headers)
       end
-      
+
       def put(to_url, user_id, secret_key_filename, params = {}, headers = {})
         make_request(:put, to_url, user_id, secret_key_filename, params, headers)
       end
-      
+
       def make_request(http_verb, to_url, user_id, secret_key_filename, params = {}, headers = {})
+        Chef::Log.warn('[DEPRECATED] StreamingCookbookUploader class is deprecated. It will be removed in Chef 12. Please use CookbookSiteStreamingUploader instead.')
         boundary = '----RubyMultipartClient' + rand(1000000).to_s + 'ZZZZZ'
         parts = []
         content_file = nil
-        
+
         timestamp = Time.now.utc.iso8601
         secret_key = OpenSSL::PKey::RSA.new(File.read(secret_key_filename))
 
@@ -53,31 +54,31 @@ class Chef
           end
           parts << StringPart.new("--" + boundary + "--\r\n")
         end
-        
+
         body_stream = MultipartStream.new(parts)
-        
+
         timestamp = Time.now.utc.iso8601
-        
+
         url = URI.parse(to_url)
-        
+
         Chef::Log.logger.debug("Signing: method: #{http_verb}, path: #{url.path}, file: #{content_file}, User-id: #{user_id}, Timestamp: #{timestamp}")
-        
+
         # We use the body for signing the request if the file parameter
-        # wasn't a valid file or wasn't included. Extract the body (with 
+        # wasn't a valid file or wasn't included. Extract the body (with
         # multi-part delimiters intact) to sign the request.
         # TODO: tim: 2009-12-28: It'd be nice to remove this special case, and
         # always hash the entire request body. In the file case it would just be
         # expanded multipart text - the entire body of the POST.
         content_body = parts.inject("") { |result,part| result + part.read(0, part.size) }
         content_file.rewind if content_file # we consumed the file for the above operation, so rewind it.
-        
+
         signing_options = {
           :http_method=>http_verb,
           :path=>url.path,
           :user_id=>user_id,
           :timestamp=>timestamp}
         (content_file && signing_options[:file] = content_file) || (signing_options[:body] = (content_body || ""))
-        
+
         headers.merge!(Mixlib::Authentication::SignedHeaderAuth.signing_object(signing_options).sign(secret_key))
 
         content_file.rewind if content_file
@@ -90,11 +91,11 @@ class Chef
                 Net::HTTP::Put.new(url.path, headers)
               when :post
                 Net::HTTP::Post.new(url.path, headers)
-              end              
+              end
         req.content_length = body_stream.size
         req.content_type = 'multipart/form-data; boundary=' + boundary unless parts.empty?
         req.body_stream = body_stream
-        
+
         http = Net::HTTP.new(url.host, url.port)
         if url.scheme == "https"
           http.use_ssl = true
@@ -107,30 +108,31 @@ class Chef
         # TODO: stop the following madness!
         class << res
           alias :to_s :body
-          
+
           # BUGBUG this makes the response compatible with what respsonse_steps expects to test headers (response.headers[] -> response[])
           def headers
             self
           end
-          
+
           def status
             code.to_i
           end
         end
         res
       end
-      
+
     end
 
     class StreamPart
       def initialize(stream, size)
+        Chef::Log.warn('[DEPRECATED] StreamingCookbookUploader::StreamPart class is deprecated. It will be removed in Chef 12. Please use CookbookSiteStreamingUploader::StreamPart instead.')
         @stream, @size = stream, size
       end
-      
+
       def size
         @size
       end
-      
+
       # read the specified amount from the stream
       def read(offset, how_much)
         @stream.read(how_much)
@@ -139,9 +141,10 @@ class Chef
 
     class StringPart
       def initialize(str)
+        Chef::Log.warn('[DEPRECATED] StreamingCookbookUploader::StringPart class is deprecated. It will be removed in Chef 12. Please use CookbookSiteStreamingUploader::StringPart instead.')
         @str = str
       end
-      
+
       def size
         @str.length
       end
@@ -154,30 +157,31 @@ class Chef
 
     class MultipartStream
       def initialize(parts)
+        Chef::Log.warn('[DEPRECATED] StreamingCookbookUploader::MultipartStream class is deprecated. It will be removed in Chef 12. Please use CookbookSiteStreamingUploader::MultipartStream instead.')
         @parts = parts
         @part_no = 0
         @part_offset = 0
       end
-      
+
       def size
         @parts.inject(0) {|size, part| size + part.size}
       end
-      
+
       def read(how_much)
         return nil if @part_no >= @parts.size
 
         how_much_current_part = @parts[@part_no].size - @part_offset
-        
+
         how_much_current_part = if how_much_current_part > how_much
                                   how_much
                                 else
                                   how_much_current_part
                                 end
-        
+
         how_much_next_part = how_much - how_much_current_part
 
         current_part = @parts[@part_no].read(@part_offset, how_much_current_part)
-        
+
         # recurse into the next part if the current one was not large enough
         if how_much_next_part > 0
           @part_no += 1
@@ -194,7 +198,7 @@ class Chef
         end
       end
     end
-    
+
   end