class Chef::Application::WindowsService
Public Instance Methods
service_init()
click to toggle source
# File lib/chef/application/windows_service.rb, line 65 def service_init @service_action_mutex = Mutex.new @service_signal = ConditionVariable.new reconfigure Chef::Log.info("#{Chef::Dist::CLIENT} Service initialized") end
service_main(*startup_parameters)
click to toggle source
# File lib/chef/application/windows_service.rb, line 73 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? # Grab the service_action_mutex to make a chef-client run @service_action_mutex.synchronize do begin Chef::Log.info("Next #{Chef::Dist::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] # Honor splay sleep config timeout += rand Chef::Config[:splay] # run chef-client only if service is in RUNNING state next if state != RUNNING Chef::Log.info("#{Chef::Dist::CLIENT} service is starting a #{Chef::Dist::CLIENT} run...") run_chef_client rescue SystemExit => e # 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}") end end end # Daemon class needs to have all the signal callbacks return # before service_main returns. Chef::Log.trace("Giving signal callbacks some time to exit...") sleep 1 Chef::Log.trace("Exiting service...") end
service_pause()
click to toggle source
# File lib/chef/application/windows_service.rb, line 146 def service_pause 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::Dist::PRODUCT} run is happening.") Chef::Log.info("Service will pause once it's completed.") else Chef::Log.info("Service is pausing....") end end
service_resume()
click to toggle source
# File lib/chef/application/windows_service.rb, line 160 def service_resume # 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
service_shutdown()
click to toggle source
# File lib/chef/application/windows_service.rb, line 168 def service_shutdown Chef::Log.info("SHUTDOWN signal received from the OS.") # Treat shutdown similar to stop. service_stop end
service_stop()
click to toggle source
Control Signal Callback Methods
# File lib/chef/application/windows_service.rb, line 122 def service_stop run_warning_displayed = false Chef::Log.info("STOP request from operating system.") loop do # See if a run is in flight if @service_action_mutex.try_lock # Run is not in flight. Wake up service_main to exit. @service_signal.signal @service_action_mutex.unlock break else unless run_warning_displayed Chef::Log.info("Currently a #{Chef::Dist::PRODUCT} run is happening on this system.") Chef::Log.info("Service will stop when run is completed.") run_warning_displayed = true end Chef::Log.trace("Waiting for #{Chef::Dist::PRODUCT} run...") sleep 1 end end Chef::Log.info("Service is stopping....") end
Private Instance Methods
apply_config(config_file_path)
click to toggle source
# File lib/chef/application/windows_service.rb, line 221 def apply_config(config_file_path) Chef::Config.from_file(config_file_path) Chef::Config.merge!(config) end
auto_log_level?()
click to toggle source
# File lib/chef/application/windows_service.rb, line 269 def auto_log_level? Chef::Config[:log_level] == :auto end
configure_chef(startup_parameters)
click to toggle source
# File lib/chef/application/windows_service.rb, line 292 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 # or by using the registry (I think). # In order to accommodate all possible sources of parameterization, we first parse any command line # arguments. We then parse any startup parameters. This works, because Mixlib::CLI reuses its internal # 'config' hash; thus, anything in startup parameters will override any command line parameters that # might be set via the service's binary_path_name # # All these parameters then get layered on top of those from Chef::Config parse_options # Operates on ARGV by default parse_options startup_parameters begin case config[:config_file] when /^(http|https):\/\// Chef::HTTP.new("").streaming_request(config[:config_file]) { |f| apply_config(f.path) } else ::File.open(config[:config_file]) { |f| apply_config(f.path) } end rescue Errno::ENOENT Chef::Log.warn("*****************************************") Chef::Log.warn("Did not find config file: #{config[:config_file]}. Using command line options instead.") Chef::Log.warn("*****************************************") Chef::Config.merge!(config) rescue SocketError Chef::Application.fatal!("Error getting config file #{Chef::Config[:config_file]}") rescue Chef::Exceptions::ConfigurationError => error Chef::Application.fatal!("Error processing config file #{Chef::Config[:config_file]} with error #{error.message}") rescue Exception => error Chef::Application.fatal!("Unknown error processing config file #{Chef::Config[:config_file]} with error #{error.message}") end end
configure_logging()
click to toggle source
Lifted from application.rb See application.rb for related comments.
# File lib/chef/application/windows_service.rb, line 243 def configure_logging Chef::Log.init(MonoLogger.new(resolve_log_location)) if want_additional_logger? configure_stdout_logger end Chef::Log.level = resolve_log_level end
configure_stdout_logger()
click to toggle source
# File lib/chef/application/windows_service.rb, line 251 def configure_stdout_logger stdout_logger = MonoLogger.new(STDOUT) stdout_logger.formatter = Chef::Log.logger.formatter Chef::Log.loggers << stdout_logger end
reconfigure(startup_parameters = [])
click to toggle source
Lifted from Chef::Application
, with addition of optional startup parameters for playing nicely with Windows Services
# File lib/chef/application/windows_service.rb, line 228 def reconfigure(startup_parameters = []) configure_chef startup_parameters configure_logging Chef::Config[:chef_server_url] = config[:chef_server_url] if config.key? :chef_server_url unless Chef::Config[:exception_handlers].any? { |h| Chef::Handler::ErrorReport === h } Chef::Config[:exception_handlers] << Chef::Handler::ErrorReport.new end Chef::Config[:interval] ||= 1800 end
resolve_log_level()
click to toggle source
if log_level is `:auto`, convert it to :warn (when using output formatter) or :info (no output formatter). See also using_output_formatter?
# File lib/chef/application/windows_service.rb, line 280 def resolve_log_level if auto_log_level? if using_output_formatter? :warn else :info end else Chef::Config[:log_level] end end
resolve_log_location()
click to toggle source
# File lib/chef/application/windows_service.rb, line 273 def resolve_log_location # STDOUT is the default log location, but makes no sense for a windows service Chef::Config[:log_location] == STDOUT ? DEFAULT_LOG_LOCATION : Chef::Config[:log_location] end
run_chef_client()
click to toggle source
Initializes Chef::Client
instance and runs it
# File lib/chef/application/windows_service.rb, line 183 def run_chef_client # The chef client will be started in a new process. We have used shell_out to start the chef-client. # The log_location and config_file of the parent process is passed to the new chef-client process. # We need to add the --no-fork, as by default it is set to fork=true. Chef::Log.info "Starting #{Chef::Dist::CLIENT} in a new process" # Pass config params to the new process config_params = " --no-fork" config_params += " -c #{Chef::Config[:config_file]}" unless Chef::Config[:config_file].nil? # log_location might be an event logger and if so we cannot pass as a command argument # but shed no tears! If the logger is an event logger, it must have been configured # as such in the config file and chef-client will use that when no arg is passed here config_params += " -L #{resolve_log_location}" if resolve_log_location.is_a?(String) # Starts a new process and waits till the process exits result = shell_out( "#{Chef::Dist::CLIENT}.bat #{config_params}", timeout: Chef::Config[:windows_service][:watchdog_timeout], logger: Chef::Log ) Chef::Log.trace (result.stdout).to_s Chef::Log.trace (result.stderr).to_s rescue Mixlib::ShellOut::CommandTimeout => e Chef::Log.error "#{Chef::Dist::CLIENT} timed out\n(#{e})" Chef::Log.error(<<-EOF) Your #{Chef::Dist::CLIENT} run timed out. You can increase the time #{Chef::Dist::CLIENT} is given to complete by configuring windows_service.watchdog_timeout in your client.rb. EOF rescue Mixlib::ShellOut::ShellCommandFailed => e Chef::Log.warn "Not able to start #{Chef::Dist::CLIENT} in new process (#{e})" rescue => e Chef::Log.error e ensure # Once process exits, we log the current process' pid Chef::Log.info "Child process exited (pid: #{Process.pid})" end
using_output_formatter?()
click to toggle source
Use of output formatters is assumed if `force_formatter` is set or if `force_logger` is not set
# File lib/chef/application/windows_service.rb, line 265 def using_output_formatter? Chef::Config[:force_formatter] || !Chef::Config[:force_logger] end
want_additional_logger?()
click to toggle source
Based on config and whether or not STDOUT is a tty, should we setup a secondary logger for stdout?
# File lib/chef/application/windows_service.rb, line 259 def want_additional_logger? ( Chef::Config[:log_location] != STDOUT ) && STDOUT.tty? && !Chef::Config[:daemonize] end