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

data/lib/chef/config_fetcher.rb

@@ -0,0 +1,79 @@
+require 'chef/application'
+require 'chef/chef_fs/path_utils'
+require 'chef/http/simple'
+require 'chef/json_compat'
+
+class Chef
+  class ConfigFetcher
+
+    attr_reader :config_location
+    attr_reader :config_file_jail
+
+    def initialize(config_location, config_file_jail)
+      @config_location = config_location
+      @config_file_jail = config_file_jail
+    end
+
+    def fetch_json
+      config_data = read_config
+      begin
+        Chef::JSONCompat.from_json(config_data)
+      rescue JSON::ParserError => error
+        Chef::Application.fatal!("Could not parse the provided JSON file (#{config_location}): " + error.message, 2)
+      end
+    end
+
+    def read_config
+      if remote_config?
+        fetch_remote_config
+      else
+        read_local_config
+      end
+    end
+
+    def fetch_remote_config
+      http.get("")
+    rescue SocketError, SystemCallError, Net::HTTPServerException => error
+      Chef::Application.fatal!("Cannot fetch config '#{config_location}': '#{error.class}: #{error.message}", 2)
+    end
+
+    def read_local_config
+      ::File.read(config_location)
+    rescue Errno::ENOENT => error
+      Chef::Application.fatal!("Cannot load configuration from #{config_location}", 2)
+    rescue Errno::EACCES => error
+      Chef::Application.fatal!("Permissions are incorrect on #{config_location}. Please chmod a+r #{config_location}", 2)
+    end
+
+    def config_missing?
+      return false if remote_config?
+
+      # Check if the config file exists, and check if it is underneath the config file jail
+      begin
+        real_config_file = Pathname.new(config_location).realpath.to_s
+      rescue Errno::ENOENT
+        return true
+      end
+
+      # If realpath succeeded, the file exists
+      return false if !config_file_jail
+
+      begin
+        real_jail = Pathname.new(config_file_jail).realpath.to_s
+      rescue Errno::ENOENT
+        Chef::Log.warn("Config file jail #{config_file_jail} does not exist: will not load any config file.")
+        return true
+      end
+
+      !Chef::ChefFS::PathUtils.descendant_of?(real_config_file, real_jail)
+    end
+
+    def http
+      Chef::HTTP::Simple.new(config_location)
+    end
+
+    def remote_config?
+      !!(config_location =~ %r{^(http|https)://})
+    end
+  end
+end

data/lib/chef/cookbook/file_vendor.rb

@@ -7,9 +7,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 self.on_create(&block)
         @instance_creator = block
       end
-      
+
       # Factory method that creates the appropriate kind of
       # Cookbook::FileVendor to serve the contents of the manifest
       def self.create_from_manifest(manifest)
         raise "Must call Chef::Cookbook::FileVendor.on_create before calling create_from_manifest factory" unless defined?(@instance_creator)
         @instance_creator.call(manifest)
       end
-      
+
       # Gets the on-disk location for the given cookbook file.
       #
       # Subclasses are responsible for determining exactly how the
@@ -42,7 +42,7 @@ class Chef
       def get_filename(filename)
         raise NotImplemented, "Subclasses must implement this method"
       end
-      
+
     end
   end
 end

data/lib/chef/cookbook/metadata.rb

@@ -110,8 +110,8 @@ class Chef
         @version = Version.new "0.0.0"
         if cookbook
           @recipes = cookbook.fully_qualified_recipe_names.inject({}) do |r, e|
-            e = self.name if e =~ /::default$/
-            r[e] = ""
+            e = self.name.to_s if e =~ /::default$/
+            r[e] ||= ""
             self.provides e
             r
           end

data/lib/chef/cookbook/syntax_check.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.
@@ -39,19 +39,9 @@ class Chef
         attr_reader :cache_path
 
         # Create a new PersistentSet. Values in the set are persisted by
-        # creating a file in the +cache_path+ directory. If not given, the
-        # value of Chef::Config[:syntax_check_cache_path] is used; if that
-        # value is not configured, the value of
-        # Chef::Config[:cache_options][:path] is used.
-        #--
-        # history: prior to Chef 11, the cache implementation was based on
-        # moneta and configured via cache_options[:path]. Knife configs
-        # generated with Chef 11 will have `syntax_check_cache_path`, but older
-        # configs will have `cache_options[:path]`. `cache_options` is marked
-        # deprecated in chef/config.rb but doesn't currently trigger a warning.
-        # See also: CHEF-3715
-        def initialize(cache_path=nil)
-          @cache_path = cache_path || Chef::Config[:syntax_check_cache_path] || Chef::Config[:cache_options][:path]
+        # creating a file in the +cache_path+ directory.
+        def initialize(cache_path=Chef::Config[:syntax_check_cache_path])
+          @cache_path = cache_path
           @cache_path_created = false
         end
 
@@ -137,7 +127,7 @@ class Chef
       end
 
       def untested_template_files
-        template_files.reject do |file| 
+        template_files.reject do |file|
           if validated?(file)
             Chef::Log.debug("Template #{file} is unchanged, skipping syntax check")
             true

data/lib/chef/cookbook_site_streaming_uploader.rb

@@ -208,8 +208,11 @@ class Chef
         @parts.inject(0) {|size, part| size + part.size}
       end
 
-      def read(how_much)
-        return nil if @part_no >= @parts.size
+      def read(how_much, dst_buf = nil)
+        if @part_no >= @parts.size
+          dst_buf.replace('') if dst_buf
+          return dst_buf
+        end
 
         how_much_current_part = @parts[@part_no].size - @part_offset
 
@@ -228,15 +231,16 @@ class Chef
           @part_no += 1
           @part_offset = 0
           next_part = read(how_much_next_part)
-          current_part + if next_part
+          result = current_part + if next_part
                            next_part
                          else
                            ''
                          end
         else
           @part_offset += how_much_current_part
-          current_part
+          result = current_part
         end
+        dst_buf ? dst_buf.replace(result || '') : result
       end
     end
 

data/lib/chef/cookbook_uploader.rb

@@ -137,15 +137,17 @@ class Chef
         timestamp = Time.now.utc.iso8601
         file_contents = File.open(file, "rb") {|f| f.read}
         # TODO - 5/28/2010, cw: make signing and sending the request streaming
-        sign_obj = Mixlib::Authentication::SignedHeaderAuth.signing_object(
-                                                                           :http_method => :put,
-                                                                           :path        => URI.parse(url).path,
-                                                                           :body        => file_contents,
-                                                                           :timestamp   => timestamp,
-                                                                           :user_id     => rest.client_name
-                                                                           )
         headers = { 'content-type' => 'application/x-binary', 'content-md5' => checksum64, :accept => 'application/json' }
-        headers.merge!(sign_obj.sign(OpenSSL::PKey::RSA.new(rest.signing_key)))
+        if rest.signing_key
+          sign_obj = Mixlib::Authentication::SignedHeaderAuth.signing_object(
+                                                                             :http_method => :put,
+                                                                             :path        => URI.parse(url).path,
+                                                                             :body        => file_contents,
+                                                                             :timestamp   => timestamp,
+                                                                             :user_id     => rest.client_name
+                                                                             )
+          headers.merge!(sign_obj.sign(OpenSSL::PKey::RSA.new(rest.signing_key)))
+        end
 
         begin
           RestClient::Resource.new(url, :headers=>headers, :timeout=>1800, :open_timeout=>1800).put(file_contents)

data/lib/chef/cookbook_version.rb

@@ -265,6 +265,18 @@ class Chef
       end
     end
 
+    # Query whether a template file +template_filename+ is available. File
+    # specificity for the given +node+ is obeyed in the lookup.
+    def has_template_for_node?(node, template_filename)
+      !!find_preferred_manifest_record(node, :templates, template_filename)
+    end
+
+    # Query whether a cookbook_file file +cookbook_filename+ is available. File
+    # specificity for the given +node+ is obeyed in the lookup.
+    def has_cookbook_file_for_node?(node, cookbook_filename)
+      !!find_preferred_manifest_record(node, :files, cookbook_filename)
+    end
+
     # Determine the most specific manifest record for the given
     # segment/filename, given information in the node. Throws
     # FileNotFound if there is no such segment and filename in the
@@ -278,14 +290,7 @@ class Chef
     #   :checksum => "1234"
     # }
     def preferred_manifest_record(node, segment, filename)
-      preferences = preferences_for_path(node, segment, filename)
-
-      # ensure that we generate the manifest, which will also generate
-      # @manifest_records_by_path
-      manifest
-
-      # in order of prefernce, look for the filename in the manifest
-      found_pref = preferences.find {|preferred_filename| @manifest_records_by_path[preferred_filename] }
+      found_pref = find_preferred_manifest_record(node, segment, filename)
       if found_pref
         @manifest_records_by_path[found_pref]
       else
@@ -567,6 +572,17 @@ class Chef
 
     private
 
+    def find_preferred_manifest_record(node, segment, filename)
+      preferences = preferences_for_path(node, segment, filename)
+
+      # ensure that we generate the manifest, which will also generate
+      # @manifest_records_by_path
+      manifest
+
+      # in order of prefernce, look for the filename in the manifest
+      preferences.find {|preferred_filename| @manifest_records_by_path[preferred_filename] }
+    end
+
     # For each filename, produce a mapping of base filename (i.e. recipe name
     # or attribute file) to on disk location
     def filenames_by_name(filenames)

data/lib/chef/daemon.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.
@@ -18,12 +18,14 @@
 # I love you Merb (lib/merb-core/server.rb)
 
 require 'chef/config'
+require 'chef/run_lock'
 require 'etc'
 
 class Chef
   class Daemon
     class << self
       attr_accessor :name
+      attr_accessor :runlock
 
       # Daemonize the current process, managing pidfiles and process uid/gid
       #
@@ -32,9 +34,9 @@ class Chef
       #
       def daemonize(name)
         @name = name
-        pid = pid_from_file
-        unless running?
-          remove_pid_file()
+        @runlock = RunLock.new(pid_file)
+        if runlock.test
+          # We've acquired the daemon lock. Now daemonize.
           Chef::Log.info("Daemonizing..")
           begin
             exit if fork
@@ -45,53 +47,15 @@ class Chef
             $stdin.reopen("/dev/null")
             $stdout.reopen("/dev/null", "a")
             $stderr.reopen($stdout)
-            save_pid_file
-            at_exit { remove_pid_file }
+            runlock.save_pid
           rescue NotImplementedError => e
             Chef::Application.fatal!("There is no fork: #{e.message}")
           end
         else
-          Chef::Application.fatal!("Chef is already running pid #{pid}")
-        end
-      end
-  
-      # Check if Chef is running based on the pid_file
-      # ==== Returns
-      # Boolean::
-      # True if Chef is running
-      # False if Chef is not running
-      #
-      def running?
-        if pid_from_file.nil?
-          false
-        else
-          Process.kill(0, pid_from_file)
-          true
-        end
-      rescue Errno::ESRCH, Errno::ENOENT
-        false
-      rescue Errno::EACCES => e
-        Chef::Application.fatal!("You don't have access to the PID file at #{pid_file}: #{e.message}")
-      end
-      
-      # Check if this process if forked from a Chef daemon
-      # ==== Returns
-      # Boolean::
-      # True if this process is forked 
-      # False if this process is not forked
-      #
-      def forked?
-        if running? and Process.ppid == pid_from_file.to_i
-          # chef daemon is running and this process is a child of it
-          true
-        elsif not running? and Process.ppid == 1
-          # an orphaned fork, its parent becomes init, launchd, etc. after chef daemon dies
-          true
-        else
-          false
+          Chef::Application.fatal!("Chef is already running pid #{pid_from_file}")
         end
       end
-      
+
       # Gets the pid file for @name
       # ==== Returns
       # String::
@@ -99,7 +63,7 @@ class Chef
       def pid_file
          Chef::Config[:pid_file] or "/tmp/#{@name}.pid"
       end
-      
+
       # Suck the pid out of pid_file
       # ==== Returns
       # Integer::
@@ -112,31 +76,6 @@ class Chef
       rescue Errno::ENOENT, Errno::EACCES
         nil
       end
-    
-      # Store the PID on the filesystem
-      # This uses the Chef::Config[:pid_file] option, or "/tmp/name.pid" otherwise
-      #
-      def save_pid_file
-        file = pid_file
-        begin
-          FileUtils.mkdir_p(File.dirname(file))
-        rescue Errno::EACCES => e
-          Chef::Application.fatal!("Failed store pid in #{File.dirname(file)}, permission denied: #{e.message}")
-        end
-      
-        begin
-          File.open(file, "w") { |f| f.write(Process.pid.to_s) }
-        rescue Errno::EACCES => e
-          Chef::Application.fatal!("Couldn't write to pidfile #{file}, permission denied: #{e.message}")
-        end
-      end
-  
-      # Delete the PID from the filesystem
-      def remove_pid_file
-        if not forked? then
-          FileUtils.rm(pid_file) if File.exists?(pid_file)
-        end
-      end           
 
       # Change process user/group to those specified in Chef::Config
       #
@@ -151,7 +90,7 @@ class Chef
           _change_privilege(Chef::Config[:user])
         end
       end
-    
+
       # Change privileges of the process to be the specified user and group
       #
       # ==== Parameters
@@ -170,14 +109,14 @@ class Chef
           Chef::Application.fatal!("Failed to get UID for user #{user}, does it exist? #{e.message}")
           return false
         end
-   
+
         begin
           target_gid = Etc.getgrnam(group).gid
         rescue ArgumentError => e
           Chef::Application.fatal!("Failed to get GID for group #{group}, does it exist? #{e.message}")
           return false
         end
-      
+
         if (uid != target_uid) or (gid != target_gid)
           Process.initgroups(user, target_gid)
           Process::GID.change_privilege(target_gid)

data/lib/chef/data_bag.rb

@@ -129,11 +129,10 @@ class Chef
         if Chef::Config[:why_run]
           Chef::Log.warn("In whyrun mode, so NOT performing data bag save.")
         else
-          chef_server_rest.put_rest("data/#{@name}", self)
+          create
         end
       rescue Net::HTTPServerException => e
-        raise e unless e.response.code == "404"
-        chef_server_rest.post_rest("data", self)
+        raise e unless e.response.code == "409"
       end
       self
     end