chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

data/lib/chef/application/apply.rb

@@ -31,7 +31,6 @@ class Chef::Application::Apply < Chef::Application
 
   banner "Usage: chef-apply [RECIPE_FILE] [-e RECIPE_TEXT] [-s]"
 
-
   option :execute,
     :short        => "-e RECIPE_TEXT",
     :long         => "--execute RECIPE_TEXT",
@@ -92,14 +91,17 @@ class Chef::Application::Apply < Chef::Application
   end
 
   def read_recipe_file(file_name)
-    recipe_path = file_name
-    unless File.exist?(recipe_path)
-      Chef::Application.fatal!("No file exists at #{recipe_path}", 1)
+    if file_name.nil?
+      Chef::Application.fatal!("No recipe file was provided", 1)
+    else
+      recipe_path = File.expand_path(file_name)
+      unless File.exist?(recipe_path)
+        Chef::Application.fatal!("No file exists at #{recipe_path}", 1)
+      end
+      recipe_fh = open(recipe_path)
+      recipe_text = recipe_fh.read
+      [recipe_text, recipe_fh]
     end
-    recipe_path = File.expand_path(recipe_path)
-    recipe_fh = open(recipe_path)
-    recipe_text = recipe_fh.read
-    [recipe_text, recipe_fh]
   end
 
   def get_recipe_and_run_context

data/lib/chef/application/client.rb

@@ -238,8 +238,12 @@ class Chef::Application::Client < Chef::Application
       :boolean      => true
   end
 
+  option :audit_mode,
+    :long           => "--[no-]audit-mode",
+    :description    => "If not specified, run converge and audit phase.  If true, run only audit phase.  If false, run only converge phase.",
+    :boolean        => true
+
   IMMEDIATE_RUN_SIGNAL = "1".freeze
-  GRACEFUL_EXIT_SIGNAL = "2".freeze
 
   attr_reader :chef_client_json
 
@@ -268,6 +272,8 @@ class Chef::Application::Client < Chef::Application
       Chef::Config[:splay] = nil
     end
 
+    Chef::Application.fatal!(unforked_interval_error_message) if !Chef::Config[:client_fork] && Chef::Config[:interval]
+
     if Chef::Config[:json_attribs]
       config_fetcher = Chef::ConfigFetcher.new(Chef::Config[:json_attribs])
       @chef_client_json = config_fetcher.fetch_json
@@ -295,8 +301,9 @@ class Chef::Application::Client < Chef::Application
     Chef::Daemon.change_privilege
   end
 
-  # Run the chef client, optionally daemonizing or looping at intervals.
-  def run_application
+  def setup_signal_handlers
+    super
+
     unless Chef::Platform.windows?
       SELF_PIPE.replace IO.pipe
 
@@ -304,52 +311,54 @@ class Chef::Application::Client < Chef::Application
         Chef::Log.info("SIGUSR1 received, waking up")
         SELF_PIPE[1].putc(IMMEDIATE_RUN_SIGNAL) # wakeup master process from select
       end
-
-      # see CHEF-5172
-      if Chef::Config[:daemonize] || Chef::Config[:interval]
-        trap("TERM") do
-          Chef::Log.info("SIGTERM received, exiting gracefully")
-          SELF_PIPE[1].putc(GRACEFUL_EXIT_SIGNAL)
-        end
-      end
     end
+  end
 
+  # Run the chef client, optionally daemonizing or looping at intervals.
+  def run_application
     if Chef::Config[:version]
       puts "Chef version: #{::Chef::VERSION}"
     end
 
+    if !Chef::Config[:client_fork] || Chef::Config[:once]
+      begin
+        # run immediately without interval sleep, or splay
+        run_chef_client(Chef::Config[:specific_recipes])
+      rescue SystemExit
+        raise
+      rescue Exception => e
+        Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
+      end
+    else
+      interval_run_chef_client
+    end
+  end
+
+  private
+  def interval_run_chef_client
     if Chef::Config[:daemonize]
       Chef::Daemon.daemonize("chef-client")
     end
 
-    signal = nil
-
     loop do
       begin
-        Chef::Application.exit!("Exiting", 0) if signal == GRACEFUL_EXIT_SIGNAL
-
-        if Chef::Config[:splay] and signal != IMMEDIATE_RUN_SIGNAL
-          splay = rand Chef::Config[:splay]
-          Chef::Log.debug("Splay sleep #{splay} seconds")
-          sleep splay
+        @signal = test_signal
+        if @signal != IMMEDIATE_RUN_SIGNAL
+          sleep_sec = time_to_sleep
+          Chef::Log.debug("Sleeping for #{sleep_sec} seconds")
+          interval_sleep(sleep_sec)
         end
 
-        signal = nil
+        @signal = nil
         run_chef_client(Chef::Config[:specific_recipes])
 
-        if Chef::Config[:interval]
-          Chef::Log.debug("Sleeping for #{Chef::Config[:interval]} seconds")
-          signal = interval_sleep
-        else
-          Chef::Application.exit! "Exiting", 0
-        end
+        Chef::Application.exit!("Exiting", 0) if !Chef::Config[:interval]
       rescue SystemExit => e
         raise
       rescue Exception => e
         if Chef::Config[:interval]
           Chef::Log.error("#{e.class}: #{e}")
-          Chef::Log.error("Sleeping for #{Chef::Config[:interval]} seconds before trying again")
-          signal = interval_sleep
+          Chef::Log.debug("#{e.class}: #{e}\n#{e.backtrace.join("\n")}")
           retry
         else
           Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
@@ -358,19 +367,35 @@ class Chef::Application::Client < Chef::Application
     end
   end
 
-  private
+  def test_signal
+    @signal = interval_sleep(0)
+  end
 
-  def interval_sleep
+  def time_to_sleep
+    duration = 0
+    duration += rand(Chef::Config[:splay]) if Chef::Config[:splay]
+    duration += Chef::Config[:interval] if Chef::Config[:interval]
+    duration
+  end
+
+  def interval_sleep(sec)
     unless SELF_PIPE.empty?
-      client_sleep Chef::Config[:interval]
+      client_sleep(sec)
     else
       # Windows
-      sleep Chef::Config[:interval]
+      sleep(sec)
     end
   end
 
   def client_sleep(sec)
     IO.select([ SELF_PIPE[0] ], nil, nil, sec) or return
-    SELF_PIPE[0].getc.chr
+    @signal = SELF_PIPE[0].getc.chr
+  end
+
+  def unforked_interval_error_message
+    "Unforked chef-client interval runs are disabled in Chef 12." +
+    "\nConfiguration settings:" +
+    "#{"\n  interval  = #{Chef::Config[:interval]} seconds" if Chef::Config[:interval]}" +
+    "\nEnable chef-client interval runs by setting `:client_fork = true` in your config file or adding `--fork` to your command line options."
   end
 end

data/lib/chef/application/solo.rb

@@ -185,6 +185,8 @@ class Chef::Application::Solo < Chef::Application
       Chef::Config[:interval] ||= 1800
     end
 
+    Chef::Application.fatal!(unforked_interval_error_message) if !Chef::Config[:client_fork] && Chef::Config[:interval]
+
     if Chef::Config[:recipe_url]
       cookbooks_path = Array(Chef::Config[:cookbook_path]).detect{|e| e =~ /\/cookbooks\/*$/ }
       recipes_path = File.expand_path(File.join(cookbooks_path, '..'))
@@ -209,23 +211,39 @@ class Chef::Application::Solo < Chef::Application
   end
 
   def run_application
+    if !Chef::Config[:client_fork] || Chef::Config[:once]
+      # Run immediately without interval sleep or splay
+      begin
+        run_chef_client(Chef::Config[:specific_recipes])
+      rescue SystemExit
+        raise
+      rescue Exception => e
+        Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
+      end
+    else
+      interval_run_chef_client
+    end
+  end
+
+  private
+  def interval_run_chef_client
     if Chef::Config[:daemonize]
       Chef::Daemon.daemonize("chef-client")
     end
 
     loop do
       begin
-        if Chef::Config[:splay]
-          splay = rand Chef::Config[:splay]
-          Chef::Log.debug("Splay sleep #{splay} seconds")
-          sleep splay
+
+        sleep_sec = 0
+        sleep_sec += rand(Chef::Config[:splay]) if Chef::Config[:splay]
+        sleep_sec += Chef::Config[:interval] if Chef::Config[:interval]
+        if sleep_sec != 0
+          Chef::Log.debug("Sleeping for #{sleep_sec} seconds")
+          sleep(sleep_sec)
         end
 
         run_chef_client
-        if Chef::Config[:interval]
-          Chef::Log.debug("Sleeping for #{Chef::Config[:interval]} seconds")
-          sleep Chef::Config[:interval]
-        else
+        if !Chef::Config[:interval]
           Chef::Application.exit! "Exiting", 0
         end
       rescue SystemExit => e
@@ -234,8 +252,6 @@ class Chef::Application::Solo < Chef::Application
         if Chef::Config[:interval]
           Chef::Log.error("#{e.class}: #{e}")
           Chef::Log.debug("#{e.class}: #{e}\n#{e.backtrace.join("\n")}")
-          Chef::Log.fatal("Sleeping for #{Chef::Config[:interval]} seconds before trying again")
-          sleep Chef::Config[:interval]
           retry
         else
           Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
@@ -244,8 +260,6 @@ class Chef::Application::Solo < Chef::Application
     end
   end
 
-  private
-
   def fetch_recipe_tarball(url, path)
     Chef::Log.debug("Download recipes tarball from #{url} to #{path}")
     File.open(path, 'wb') do |f|
@@ -254,4 +268,11 @@ class Chef::Application::Solo < Chef::Application
       end
     end
   end
+
+  def unforked_interval_error_message
+    "Unforked chef-client interval runs are disabled in Chef 12." +
+    "\nConfiguration settings:" +
+    "#{"\n  interval  = #{Chef::Config[:interval]} seconds" if Chef::Config[:interval]}" +
+    "\nEnable chef-client interval runs by setting `:client_fork = true` in your config file or adding `--fork` to your command line options."
+  end
 end

data/lib/chef/chef_fs/chef_fs_data_store.rb

@@ -168,7 +168,7 @@ class Chef
                   end
                 end
               end
-              JSON.pretty_generate(result)
+              Chef::JSONCompat.to_json_pretty(result)
 
             else
               begin

data/lib/chef/chef_fs/command_line.rb

@@ -253,7 +253,7 @@ class Chef
       def self.canonicalize_json(json_text)
         parsed_json = Chef::JSONCompat.parse(json_text)
         sorted_json = sort_keys(parsed_json)
-        JSON.pretty_generate(sorted_json)
+        Chef::JSONCompat.to_json_pretty(sorted_json)
       end
 
       def self.diff_text(old_path, new_path, old_value, new_value)

data/lib/chef/chef_fs/file_system/organization_invites_entry.rb

@@ -1,5 +1,6 @@
 require 'chef/chef_fs/file_system/rest_list_entry'
 require 'chef/chef_fs/data_handler/organization_invites_data_handler'
+require 'chef/json_compat'
 
 class Chef
   module ChefFS
@@ -34,7 +35,7 @@ class Chef
         end
 
         def write(contents)
-          desired_invites = minimize_value(JSON.parse(contents, :create_additions => false))
+          desired_invites = minimize_value(Chef::JSONCompat.parse(contents, :create_additions => false))
           actual_invites = _read_json.inject({}) { |h,val| h[val['username']] = val['id']; h }
           invites = actual_invites.keys
           (desired_invites - invites).each do |invite|

data/lib/chef/chef_fs/file_system/organization_members_entry.rb

@@ -1,5 +1,6 @@
 require 'chef/chef_fs/file_system/rest_list_entry'
 require 'chef/chef_fs/data_handler/organization_members_data_handler'
+require 'chef/json_compat'
 
 class Chef
   module ChefFS
@@ -34,7 +35,7 @@ class Chef
         end
 
         def write(contents)
-          desired_members = minimize_value(JSON.parse(contents, :create_additions => false))
+          desired_members = minimize_value(Chef::JSONCompat.parse(contents, :create_additions => false))
           members = minimize_value(_read_json)
           (desired_members - members).each do |member|
             begin

data/lib/chef/chef_fs/file_system/rest_list_entry.rb

@@ -21,6 +21,7 @@ require 'chef/chef_fs/file_system/not_found_error'
 require 'chef/chef_fs/file_system/operation_failed_error'
 require 'chef/role'
 require 'chef/node'
+require 'chef/json_compat'
 
 class Chef
   module ChefFS
@@ -172,7 +173,7 @@ class Chef
 
         def api_error_text(response)
           begin
-            JSON.parse(response.body)['error'].join("\n")
+            Chef::JSONCompat.parse(response.body)['error'].join("\n")
           rescue
             response.body
           end

data/lib/chef/client.rb

@@ -36,6 +36,8 @@ require 'chef/cookbook/file_vendor'
 require 'chef/cookbook/file_system_file_vendor'
 require 'chef/cookbook/remote_file_vendor'
 require 'chef/event_dispatch/dispatcher'
+require 'chef/event_loggers/base'
+require 'chef/event_loggers/windows_eventlog'
 require 'chef/formatters/base'
 require 'chef/formatters/doc'
 require 'chef/formatters/minimal'
@@ -151,7 +153,7 @@ class Chef
       @runner = nil
       @ohai = Ohai::System.new
 
-      event_handlers = configure_formatters
+      event_handlers = configure_formatters + configure_event_loggers
       event_handlers += Array(Chef::Config[:event_handlers])
 
       @events = EventDispatch::Dispatcher.new(*event_handlers)
@@ -191,52 +193,20 @@ class Chef
       end
     end
 
-    # Do a full run for this Chef::Client.  Calls:
-    # * do_run
-    #
-    # This provides a wrapper around #do_run allowing the
-    # run to be optionally forked.
-    # === Returns
-    # boolean:: Return value from #do_run. Should always returns true.
-    def run
-      # win32-process gem exposes some form of :fork for Process
-      # class. So we are seperately ensuring that the platform we're
-      # running on is not windows before forking.
-      if(Chef::Config[:client_fork] && Process.respond_to?(:fork) && !Chef::Platform.windows?)
-        Chef::Log.info "Forking chef instance to converge..."
-        pid = fork do
-          [:INT, :TERM].each {|s| trap(s, "EXIT") }
-          client_solo = Chef::Config[:solo] ? "chef-solo" : "chef-client"
-          $0 = "#{client_solo} worker: ppid=#{Process.ppid};start=#{Time.new.strftime("%R:%S")};"
-          begin
-            Chef::Log.debug "Forked instance now converging"
-            do_run
-          rescue Exception => e
-            Chef::Log.error(e.to_s)
-            exit 1
+    def configure_event_loggers
+      if Chef::Config.disable_event_logger
+        []
+      else
+        Chef::Config.event_loggers.map do |evt_logger|
+          case evt_logger
+          when Symbol
+            Chef::EventLoggers.new(evt_logger)
+          when Class
+            evt_logger.new
           else
-            exit 0
           end
         end
-        Chef::Log.debug "Fork successful. Waiting for new chef pid: #{pid}"
-        result = Process.waitpid2(pid)
-        handle_child_exit(result)
-        Chef::Log.debug "Forked instance successfully reaped (pid: #{pid})"
-        true
-      else
-        do_run
-      end
-    end
-
-    def handle_child_exit(pid_and_status)
-      status = pid_and_status[1]
-      return true if status.success?
-      message = if status.signaled?
-        "Chef run process terminated by signal #{status.termsig} (#{Signal.list.invert[status.termsig]})"
-      else
-        "Chef run process exited unsuccessfully (exit code #{status.exitstatus})"
       end
-      raise Exceptions::ChildConvergeError, message
     end
 
     # Instantiates a Chef::Node object, possibly loading the node's prior state
@@ -330,7 +300,7 @@ class Chef
     rescue Exception => e
       # TODO: munge exception so a semantic failure message can be given to the
       # user
-      @events.registration_failed(node_name, e, config)
+      @events.registration_failed(client_name, e, config)
       raise
     end
 
@@ -383,8 +353,6 @@ class Chef
       end
     end
 
-    private
-
     # Do a full run for this Chef::Client.  Calls:
     #
     #  * run_ohai - Collect information about the system
@@ -395,7 +363,7 @@ class Chef
     #
     # === Returns
     # true:: Always returns true.
-    def do_run
+    def run
       runlock = RunLock.new(Chef::Config.lockfile)
       runlock.acquire
       # don't add code that may fail before entering this section to be sure to release lock
@@ -428,7 +396,7 @@ class Chef
 
         run_context = setup_run_context
 
-        catch (:end_client_run_early) do
+        catch(:end_client_run_early) do
           converge(run_context)
         end
 
@@ -466,6 +434,8 @@ class Chef
       true
     end
 
+    private
+
     def empty_directory?(path)
       !File.exists?(path) || (Dir.entries(path).size <= 2)
     end