chef 11.4.4 → 11.6.0.hotfix.1

data/lib/chef/application/knife.rb

@@ -43,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

@@ -147,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',
@@ -215,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
 
@@ -253,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,58 +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 Chef::Application::Wakeup => e
-              Chef::Log.debug("Received Wakeup signal.  Starting run.")
-              next
             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
 
       ################################################################################
@@ -115,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
 
       ################################################################################
@@ -136,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)
@@ -155,16 +190,52 @@ 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
 
-        # Implementation from Chef::Application::Client
-        Mixlib::Authentication::Log.use_log_devices( Chef::Log )
-        Ohai::Log.use_log_devices( Chef::Log )
+      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
+
+      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)
@@ -205,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

data/lib/chef/application/windows_service_manager.rb

@@ -0,0 +1,179 @@
+#
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2011 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 'win32/service'
+require 'chef/config'
+require 'mixlib/cli'
+
+class Chef
+  class Application
+    #
+    # This class is used to create and manage a windows service.
+    # Service should be created using Daemon class from
+    # win32/service gem.
+    # For an example see: Chef::Application::WindowsService
+    #
+    # Outside programs are expected to use this class to manage
+    # windows services.
+    #
+    class WindowsServiceManager
+      include Mixlib::CLI
+
+      option :action,
+        :short => "-a ACTION",
+        :long  => "--action ACTION",
+        :default => "status",
+        :description => "Action to carry out on chef-service (install, uninstall, status, start, stop, pause, or resume)"
+
+      option :config_file,
+        :short => "-c CONFIG",
+        :long  => "--config CONFIG",
+        :default => "#{ENV['SYSTEMDRIVE']}/chef/client.rb",
+        :description => "The configuration file to use for chef runs"
+
+      option :log_location,
+        :short        => "-L LOGLOCATION",
+        :long         => "--logfile LOGLOCATION",
+        :description  => "Set the log file location for chef-service",
+        :default => "#{ENV['SYSTEMDRIVE']}/chef/client.log"
+
+      option :help,
+        :short        => "-h",
+        :long         => "--help",
+        :description  => "Show this message",
+        :on           => :tail,
+        :boolean      => true,
+        :show_options => true,
+        :exit         => 0
+
+      def initialize(service_options)
+        # having to call super in initialize is the most annoying
+        # anti-pattern :(
+        super()
+
+        raise ArgumentError, "Service definition is not provided" if service_options.nil?
+
+        required_options = [:service_name, :service_display_name, :service_name, :service_description, :service_file_path]
+
+        required_options.each do |req_option|
+          if !service_options.has_key?(req_option)
+            raise ArgumentError, "Service definition doesn't contain required option #{req_option}"
+          end
+        end
+
+        @service_name = service_options[:service_name]
+        @service_display_name = service_options[:service_display_name]
+        @service_description = service_options[:service_description]
+        @service_file_path = service_options[:service_file_path]
+      end
+
+      def run(params = ARGV)
+        parse_options(params)
+
+        case config[:action]
+        when 'install'
+          if service_exists?
+            puts "Service #{@service_name} already exists on the system."
+          else
+            ruby = File.join(RbConfig::CONFIG['bindir'], 'ruby')
+
+            opts = ""
+            opts << " -c #{config[:config_file]}" if config[:config_file]
+            opts << " -L #{config[:log_location]}" if config[:log_location]
+
+            # Quote the full paths to deal with possible spaces in the path name.
+            # Also ensure all forward slashes are backslashes
+            cmd = "\"#{ruby}\" \"#{@service_file_path}\" #{opts}".gsub(File::SEPARATOR, File::ALT_SEPARATOR)
+
+            ::Win32::Service.new(
+                                 :service_name     => @service_name,
+                                 :display_name     => @service_display_name,
+                                 :description      => @service_description,
+                                 :start_type       => ::Win32::Service::SERVICE_AUTO_START,
+                                 :binary_path_name => cmd
+                                 )
+            puts "Service '#{@service_name}' has successfully been installed."
+          end
+        when 'status'
+          if !service_exists?
+            puts "Service #{@service_name} doesn't exist on the system."
+          else
+            puts "State of #{@service_name} service is: #{current_state}"
+          end
+        when 'start'
+          # TODO: allow override of startup parameters here?
+          take_action('start', RUNNING)
+        when 'stop'
+          take_action('stop', STOPPED)
+        when 'uninstall', 'delete'
+          take_action('stop', STOPPED)
+          unless service_exists?
+            puts "Service #{@service_name} doesn't exist on the system."
+          else
+            ::Win32::Service.delete(@service_name)
+            puts "Service #{@service_name} deleted"
+          end
+        when 'pause'
+          take_action('pause', PAUSED)
+        when 'resume'
+          take_action('resume', RUNNING)
+        end
+      end
+
+      private
+
+      # Just some state constants
+      STOPPED = "stopped"
+      RUNNING = "running"
+      PAUSED = "paused"
+
+      def service_exists?
+        return ::Win32::Service.exists?(@service_name)
+      end
+
+      def take_action(action=nil, desired_state=nil)
+        if service_exists?
+          if current_state != desired_state
+            ::Win32::Service.send(action, @service_name)
+            wait_for_state(desired_state)
+            puts "Service '#{@service_name}' is now '#{current_state}'."
+          else
+            puts "Service '#{@service_name}' is already '#{desired_state}'."
+          end
+        else
+          puts "Cannot '#{action}' service '#{@service_name}'"
+          puts "Service #{@service_name} doesn't exist on the system."
+        end
+      end
+
+      def current_state
+        ::Win32::Service.status(@service_name).current_state
+      end
+
+      # Helper method that waits for a status to change its state since state
+      # changes aren't usually instantaneous.
+      def wait_for_state(desired_state)
+        while current_state != desired_state
+          puts "One moment... #{current_state}"
+          sleep 1
+        end
+      end
+
+    end
+  end
+end