chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/lib/chef/application/apply.rb

@@ -0,0 +1,162 @@
+#
+# Author:: Bryan W. Berry (<bryan.berry@gmail.com>)
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2012 Bryan W. Berry
+# Copyright:: Copyright (c) 2012 Daniel DeLeo
+# 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'
+require 'chef/application'
+require 'chef/client'
+require 'chef/config'
+require 'chef/log'
+require 'fileutils'
+require 'tempfile'
+require 'chef/providers'
+require 'chef/resources'
+
+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",
+    :description  => "Execute resources supplied in a string",
+    :proc         => nil
+
+  option :stdin,
+    :short        => "-s",
+    :long         => "--stdin",
+    :description  => "Execute resources read from STDIN",
+    :boolean      => true
+
+  option :log_level,
+    :short        => "-l LEVEL",
+    :long         => "--log_level LEVEL",
+    :description  => "Set the log level (debug, info, warn, error, fatal)",
+    :proc         => lambda { |l| l.to_sym }
+
+  option :help,
+    :short        => "-h",
+    :long         => "--help",
+    :description  => "Show this message",
+    :on           => :tail,
+    :boolean      => true,
+    :show_options => true,
+    :exit         => 0
+
+
+  option :version,
+    :short        => "-v",
+    :long         => "--version",
+    :description  => "Show chef version",
+    :boolean      => true,
+    :proc         => lambda {|v| puts "Chef: #{::Chef::VERSION}"},
+    :exit         => 0
+
+  option :why_run,
+    :short        => '-W',
+    :long         => '--why-run',
+    :description  => 'Enable whyrun mode',
+    :boolean      => true
+
+  def initialize
+    super
+  end
+
+  def reconfigure
+    parse_options
+    Chef::Config.merge!(config)
+    configure_logging
+  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)
+    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
+    Chef::Config[:solo] = true
+    @chef_client = Chef::Client.new
+    @chef_client.run_ohai
+    @chef_client.load_node
+    @chef_client.build_node
+    run_context = if @chef_client.events.nil?
+                    Chef::RunContext.new(@chef_client.node, {})
+                  else
+                    Chef::RunContext.new(@chef_client.node, {}, @chef_client.events)
+                  end
+    recipe = Chef::Recipe.new("(chef-apply cookbook)", "(chef-apply recipe)", run_context)
+    [recipe, run_context]
+  end
+
+  # write recipe to temp file, so in case of error,
+  # user gets error w/ context
+  def temp_recipe_file
+    @recipe_fh = Tempfile.open('recipe-temporary-file')
+    @recipe_fh.write(@recipe_text)
+    @recipe_fh.rewind
+    @recipe_filename = @recipe_fh.path
+  end
+
+  def run_chef_recipe
+    if config[:execute]
+      @recipe_text = config[:execute]
+      temp_recipe_file
+    elsif config[:stdin]
+      @recipe_text = STDIN.read
+      temp_recipe_file
+    else
+      @recipe_filename = ARGV[0]
+      @recipe_text,@recipe_fh = read_recipe_file @recipe_filename
+    end
+    recipe,run_context = get_recipe_and_run_context
+    recipe.instance_eval(@recipe_text, @recipe_filename, 1)
+    runner = Chef::Runner.new(run_context)
+    begin
+      runner.converge
+    ensure
+      @recipe_fh.close
+    end
+  end
+
+  def run_application
+    begin
+      parse_options
+      run_chef_recipe
+      Chef::Application.exit! "Exiting", 0
+    rescue SystemExit => e
+      raise
+    rescue Exception => e
+      Chef::Application.debug_stacktrace(e)
+      Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
+    end
+  end
+
+    # Get this party started
+  def run
+    reconfigure
+    run_application
+  end
+
+end

data/lib/chef/application/client.rb

@@ -40,13 +40,26 @@ class Chef::Application::Client < Chef::Application
   option :formatter,
     :short        => "-F FORMATTER",
     :long         => "--format FORMATTER",
-    :description  => "output format to use"
+    :description  => "output format to use",
+    :proc         => lambda { |format| Chef::Config.add_formatter(format) }
+
+  option :force_logger,
+    :long         => "--force-logger",
+    :description  => "Use logger output instead of formatter output",
+    :boolean      => true,
+    :default      => false
+
+  option :force_formatter,
+    :long         => "--force-formatter",
+    :description  => "Use formatter output instead of logger output",
+    :boolean      => true,
+    :default      => false
 
   option :color,
     :long         => '--[no-]color',
     :boolean      => true,
-    :default      => false,
-    :description  => "Use colored output, defaults to enabled"
+    :default      => !Chef::Platform.windows?,
+    :description  => "Use colored output, defaults to false on Windows, true otherwise"
 
   option :log_level,
     :short        => "-l LEVEL",
@@ -81,11 +94,13 @@ class Chef::Application::Client < Chef::Application
     :description => "Group to set privilege to",
     :proc => nil
 
-  option :daemonize,
-    :short => "-d",
-    :long => "--daemonize",
-    :description => "Daemonize the process",
-    :proc => lambda { |p| true }
+  unless Chef::Platform.windows?
+    option :daemonize,
+      :short => "-d",
+      :long => "--daemonize",
+      :description => "Daemonize the process",
+      :proc => lambda { |p| true }
+  end
 
   option :pid_file,
     :short        => "-P PID_FILE",
@@ -169,10 +184,10 @@ class Chef::Application::Client < Chef::Application
     :long         => '--why-run',
     :description  => 'Enable whyrun mode',
     :boolean      => true
-  
+
   option :client_fork,
     :short        => "-f",
-    :long         => "--fork",
+    :long         => "--[no-]fork",
     :description  => "Fork client",
     :boolean      => true
 
@@ -182,6 +197,14 @@ class Chef::Application::Client < Chef::Application
     :description  => "Enable reporting data collection for chef runs",
     :boolean      => true
 
+  if Chef::Platform.windows?
+    option :fatal_windows_admin_check,
+      :short        => "-A",
+      :long         => "--fatal-windows-admin-check",
+      :description  => "Fail the run when chef-client doesn't have administrator privileges on Windows",
+      :boolean      => true
+  end
+
   attr_reader :chef_client_json
 
   def initialize
@@ -195,9 +218,6 @@ class Chef::Application::Client < Chef::Application
     super
 
     Chef::Config[:chef_server_url] = config[:chef_server_url] if config.has_key? :chef_server_url
-    unless Chef::Config[:exception_handlers].any? {|h| Chef::Handler::ErrorReport === h}
-      Chef::Config[:exception_handlers] << Chef::Handler::ErrorReport.new
-    end
 
     if Chef::Config[:daemonize]
       Chef::Config[:interval] ||= 1800
@@ -256,13 +276,10 @@ class Chef::Application::Client < Chef::Application
         SELF_PIPE[1].putc('.') # 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")
-          @exit_gracefully = true
-          SELF_PIPE[1].putc('.')
-        end
+      trap("TERM") do
+        Chef::Log.info("SIGTERM received, exiting gracefully")
+        @exit_gracefully = true
+        SELF_PIPE[1].putc('.')
       end
     end
 
@@ -299,7 +316,6 @@ class Chef::Application::Client < Chef::Application
       rescue Exception => e
         if Chef::Config[:interval]
           Chef::Log.error("#{e.class}: #{e}")
-          Chef::Application.debug_stacktrace(e)
           Chef::Log.error("Sleeping for #{Chef::Config[:interval]} seconds before trying again")
           unless SELF_PIPE.empty?
             client_sleep Chef::Config[:interval]
@@ -309,7 +325,6 @@ class Chef::Application::Client < Chef::Application
           end
           retry
         else
-          Chef::Application.debug_stacktrace(e)
           Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
         end
       end

data/lib/chef/application/knife.rb

@@ -19,8 +19,6 @@ require 'chef/knife'
 require 'chef/application'
 require 'mixlib/log'
 require 'ohai/config'
-require 'chef/monkey_patches/net_http.rb'
-require 'chef/monkey_patches/uri.rb'
 
 class Chef::Application::Knife < Chef::Application
 
@@ -45,8 +43,8 @@ class Chef::Application::Knife < Chef::Application
   option :color,
     :long         => '--[no-]color',
     :boolean      => true,
-    :default      => true,
-    :description  => "Use colored output, defaults to enabled"
+    :default      => !Chef::Platform.windows?,
+    :description  => "Use colored output, defaults to false on Windows, true otherwise"
 
   option :environment,
     :short        => "-E ENVIRONMENT",

data/lib/chef/application/solo.rb

@@ -37,13 +37,26 @@ class Chef::Application::Solo < Chef::Application
   option :formatter,
     :short        => "-F FORMATTER",
     :long         => "--format FORMATTER",
-    :description  => "output format to use"
+    :description  => "output format to use",
+    :proc         => lambda { |format| Chef::Config.add_formatter(format) }
+
+  option :force_logger,
+    :long         => "--force-logger",
+    :description  => "Use logger output instead of formatter output",
+    :boolean      => true,
+    :default      => false
+
+  option :force_formatter,
+    :long         => "--force-formatter",
+    :description  => "Use formatter output instead of logger output",
+    :boolean      => true,
+    :default      => false
 
   option :color,
     :long         => '--[no-]color',
     :boolean      => true,
-    :default      => false,
-    :description  => "Use colored output, defaults to disabled"
+    :default      => true,
+    :description  => "Use colored output, defaults to enabled"
 
   option :log_level,
     :short        => "-l LEVEL",
@@ -78,11 +91,13 @@ class Chef::Application::Solo < Chef::Application
     :description => "Group to set privilege to",
     :proc => nil
 
-  option :daemonize,
-    :short => "-d",
-    :long => "--daemonize",
-    :description => "Daemonize the process",
-    :proc => lambda { |p| true }
+  unless Chef::Platform.windows?
+    option :daemonize,
+      :short => "-d",
+      :long => "--daemonize",
+      :description => "Daemonize the process",
+      :proc => lambda { |p| true }
+  end
 
   option :interval,
     :short => "-i SECONDS",
@@ -132,13 +147,13 @@ class Chef::Application::Solo < Chef::Application
         Chef::RunList::RunListItem.new(item)
       }
     }
-  
+
   option :client_fork,
     :short        => "-f",
-    :long         => "--fork",
+    :long         => "--[no-]fork",
     :description  => "Fork client",
     :boolean      => true
-  
+
   option :why_run,
     :short        => '-W',
     :long         => '--why-run',
@@ -200,7 +215,7 @@ class Chef::Application::Solo < Chef::Application
           f.write(r.read)
         end
       end
-      Chef::Mixin::Command.run_command(:command => "tar zxvfC #{path} #{recipes_path}")
+      Chef::Mixin::Command.run_command(:command => "tar zxvf #{path} -C #{recipes_path}")
     end
   end
 
@@ -238,7 +253,6 @@ class Chef::Application::Solo < Chef::Application
           sleep Chef::Config[:interval]
           retry
         else
-          Chef::Application.debug_stacktrace(e)
           Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
         end
       end

data/lib/chef/application/windows_service.rb

@@ -17,6 +17,7 @@
 #
 
 require 'chef'
+require 'chef/monologger'
 require 'chef/application'
 require 'chef/client'
 require 'chef/config'
@@ -56,55 +57,53 @@ class Chef
         :description  => "Set the number of seconds to wait between chef-client runs",
         :proc         => lambda { |s| s.to_i }
 
-      option :override_runlist,
-        :short        => "-o RunlistItem,RunlistItem...",
-        :long         => "--override-runlist RunlistItem,RunlistItem...",
-        :description  => "Replace current run list with specified items",
-        :proc         => lambda{|items|
-          items = items.split(',')
-          items.compact.map{|item|
-            Chef::RunList::RunListItem.new(item)
-          }
-        }
-
       def service_init
+        @service_action_mutex = Mutex.new
+        @service_signal = ConditionVariable.new
+
         reconfigure
         Chef::Log.info("Chef Client Service initialized")
       end
 
       def service_main(*startup_parameters)
+        # Chef::Config is initialized during service_init
+        # Set the initial timeout to splay sleep time
+        timeout = rand Chef::Config[:splay]
 
-        while running?
-          if state == RUNNING
+        while running? do
+          # Grab the service_action_mutex to make a chef-client run
+          @service_action_mutex.synchronize do
             begin
+              Chef::Log.info("Next chef-client run will happen in #{timeout} seconds")
+              @service_signal.wait(@service_action_mutex, timeout)
+
+              # Continue only if service is RUNNING
+              next if state != RUNNING
+
               # Reconfigure each time through to pick up any changes in the client file
               Chef::Log.info("Reconfiguring with startup parameters")
               reconfigure(startup_parameters)
+              timeout = Chef::Config[:interval]
 
-              splay = rand Chef::Config[:splay]
-              Chef::Log.debug("Splay sleep #{splay} seconds")
-              sleep splay
+              # Honor splay sleep config
+              timeout += rand Chef::Config[:splay]
 
-              # If we've stopped, then bail out now, instead of going on to run Chef
+              # run chef-client only if service is in RUNNING state
               next if state != RUNNING
 
+              Chef::Log.info("Chef-Client service is starting a chef-client run...")
               run_chef_client
-
-              Chef::Log.debug("Sleeping for #{Chef::Config[:interval]} seconds")
-              client_sleep Chef::Config[:interval]
             rescue SystemExit => e
-              raise
+              # Do not raise any of the errors here in order to
+              # prevent service crash
+              Chef::Log.error("#{e.class}: #{e}")
             rescue Exception => e
               Chef::Log.error("#{e.class}: #{e}")
-              Chef::Application.debug_stacktrace(e)
-              Chef::Log.error("Sleeping for #{Chef::Config[:interval]} seconds before trying again")
-              client_sleep Chef::Config[:interval]
-              retry
             end
-          else # PAUSED or IDLE
-            sleep 5
           end
         end
+
+        Chef::Log.debug("Exiting service...")
       end
 
       ################################################################################
@@ -112,19 +111,45 @@ class Chef
       ################################################################################
 
       def service_stop
-        Chef::Log.info("SERVICE_CONTROL_STOP received, stopping")
+        Chef::Log.info("STOP request from operating system.")
+        if @service_action_mutex.try_lock
+          @service_signal.signal
+          @service_action_mutex.unlock
+          Chef::Log.info("Service is stopping....")
+        else
+          Chef::Log.info("Currently a chef-client run is happening.")
+          Chef::Log.info("Service will stop once it's completed.")
+        end
       end
 
       def service_pause
-        Chef::Log.info("SERVICE_CONTROL_PAUSE received, pausing")
+        Chef::Log.info("PAUSE request from operating system.")
+
+        # We don't need to wake up the service_main if it's waiting
+        # since this is a PAUSE signal.
+
+        if @service_action_mutex.locked?
+          Chef::Log.info("Currently a chef-client run is happening.")
+          Chef::Log.info("Service will pause once it's completed.")
+        else
+          Chef::Log.info("Service is pausing....")
+        end
       end
 
       def service_resume
-        Chef::Log.info("SERVICE_CONTROL_CONTINUE received, resuming")
+        # We don't need to wake up the service_main if it's waiting
+        # since this is a RESUME signal.
+
+        Chef::Log.info("RESUME signal received from the OS.")
+        Chef::Log.info("Service is resuming....")
       end
 
       def service_shutdown
-        Chef::Log.info("SERVICE_CONTROL_SHUTDOWN received, shutting down")
+        Chef::Log.info("SHUTDOWN signal received from the OS.")
+
+        # Treat shutdown similar to stop.
+
+        service_stop
       end
 
       ################################################################################
@@ -133,6 +158,19 @@ class Chef
 
       private
 
+      # Initializes Chef::Client instance and runs it
+      def run_chef_client
+        @chef_client = Chef::Client.new(
+          @chef_client_json,
+          :override_runlist => config[:override_runlist]
+        )
+        @chef_client_json = nil
+
+        @chef_client.run
+        @chef_client = nil
+      end
+
+
       def apply_config(config_file_path)
         Chef::Config.from_file(config_file_path)
         Chef::Config.merge!(config)
@@ -152,22 +190,58 @@ class Chef
         Chef::Config[:interval] ||= 1800
       end
 
-      # Lifted from Chef::Application and Chef::Application::Client
-      # MUST BE RUN AFTER configuration has been parsed!
+      # Lifted from application.rb
+      # See application.rb for related comments.
+
       def configure_logging
-        # Implementation from Chef::Application
-        Chef::Log.init(Chef::Config[:log_location])
-        Chef::Log.level = Chef::Config[:log_level]
+        Chef::Log.init(MonoLogger.new(Chef::Config[:log_location]))
+        if want_additional_logger?
+          configure_stdout_logger
+        end
+        Chef::Log.level = resolve_log_level
+      end
+
+      def configure_stdout_logger
+        stdout_logger = MonoLogger.new(STDOUT)
+        STDOUT.sync = true
+        stdout_logger.formatter = Chef::Log.logger.formatter
+        Chef::Log.loggers <<  stdout_logger
+      end
+
+      # Based on config and whether or not STDOUT is a tty, should we setup a
+      # secondary logger for stdout?
+      def want_additional_logger?
+        ( Chef::Config[:log_location] != STDOUT ) && STDOUT.tty? && (!Chef::Config[:daemonize]) && (Chef::Config[:force_logger])
+      end
+
+      # Use of output formatters is assumed if `force_formatter` is set or if
+      # `force_logger` is not set and STDOUT is to a console (tty)
+      def using_output_formatter?
+        Chef::Config[:force_formatter] || (!Chef::Config[:force_logger] && STDOUT.tty?)
+      end
 
-        # Implementation from Chef::Application::Client
-        Mixlib::Authentication::Log.use_log_devices( Chef::Log )
-        Ohai::Log.use_log_devices( Chef::Log )
+      def auto_log_level?
+        Chef::Config[:log_level] == :auto
+      end
+
+      # if log_level is `:auto`, convert it to :warn (when using output formatter)
+      # or :info (no output formatter). See also +using_output_formatter?+
+      def resolve_log_level
+        if auto_log_level?
+          if using_output_formatter?
+            :warn
+          else
+            :info
+          end
+        else
+          Chef::Config[:log_level]
+        end
       end
 
       def configure_chef(startup_parameters)
         # Bit of a hack ahead:
         # It is possible to specify a service's binary_path_name with arguments, like "foo.exe -x argX".
-        # It is also possible to specify startup parameters separately, either via the Services manager
+        # It is also possible to specify startup parameters separately, either via the the Services manager
         # or by using the registry (I think).
 
         # In order to accommodate all possible sources of parameterization, we first parse any command line
@@ -202,20 +276,6 @@ class Chef
         end
       end
 
-      # Since we need to be able to respond to signals between Chef runs, we need to periodically
-      # wake up to see if we're still in the running state.  The method returns when it has slept
-      # for +sec+ seconds (but at least +10+ seconds), or when the service
-      # is no client_sleep in the +RUNNING+ state, whichever comes first.
-      def client_sleep(sec)
-        chunk_length = 10
-        chunks = sec / chunk_length
-        chunks = 1 if chunks < 1
-        (1..chunks).each do
-          return unless state == RUNNING
-          sleep chunk_length
-        end
-      end
-
     end
   end
 end