Class: Chef::Application
- Inherits:
-
Object
- Object
- Chef::Application
- Includes:
- Mixlib::CLI
- Defined in:
- lib/chef/application.rb,
lib/chef/application/exit_code.rb,
lib/chef/application/windows_service.rb,
lib/chef/application/windows_service_manager.rb
Defined Under Namespace
Classes: Apply, Client, ExitCode, Knife, Solo, WindowsService, WindowsServiceManager
Class Method Summary collapse
- .debug_stacktrace(e) ⇒ Object
- .exit!(msg, err = nil) ⇒ Object
-
.fatal!(msg, err = nil) ⇒ Object
Log a fatal error message to both STDERR and the Logger, exit the application.
- .normalize_exit_code(exit_code) ⇒ Object
Instance Method Summary collapse
- #auto_log_level? ⇒ Boolean
-
#configure_chef ⇒ Object
Parse configuration (options and config file).
-
#configure_encoding ⇒ Object
Sets the default external encoding to UTF-8 (users can change this, but they shouldn’t).
-
#configure_log_location ⇒ Object
Turn ‘log_location :syslog` and `log_location :win_evt` into the appropriate loggers.
-
#configure_logging ⇒ Object
Initialize and configure the logger.
- #configure_stdout_logger ⇒ Object
-
#initialize ⇒ Application
constructor
A new instance of Application.
-
#load_config_file ⇒ Object
Parse the config file.
-
#reconfigure ⇒ Object
Reconfigure the application.
-
#resolve_log_level ⇒ Object
if log_level is ‘:auto`, convert it to :warn (when using output formatter) or :info (no output formatter).
-
#run ⇒ Object
Get this party started.
-
#run_application ⇒ Object
Actually run the application.
-
#run_chef_client(specific_recipes = []) ⇒ Object
Initializes Chef::Client instance and runs it.
- #set_specific_recipes ⇒ Object
-
#setup_application ⇒ Object
Called prior to starting the application, by the run method.
- #setup_signal_handlers ⇒ Object
-
#using_output_formatter? ⇒ Boolean
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).
-
#want_additional_logger? ⇒ Boolean
Based on config and whether or not STDOUT is a tty, should we setup a secondary logger for stdout?.
Constructor Details
#initialize ⇒ Application
Returns a new instance of Application.
37 38 39 40 41 42 43 44 45 |
# File 'lib/chef/application.rb', line 37 def initialize super @chef_client = nil @chef_client_json = nil # Always switch to a readable directory. Keeps subsequent Dir.chdir() {} # from failing due to permissions when launched as a less privileged user. end |
Class Method Details
.debug_stacktrace(e) ⇒ Object
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 |
# File 'lib/chef/application.rb', line 349 def debug_stacktrace(e) = "#{e.class}: #{e}\n#{e.backtrace.join("\n")}" cause = e.cause if e.respond_to?(:cause) while cause != nil << "\n\n>>>> Caused by #{cause.class}: #{cause}\n#{cause.backtrace.join("\n")}" cause = cause.respond_to?(:cause) ? cause.cause : nil end chef_stacktrace_out = "Generated at #{Time.now}\n" chef_stacktrace_out += Chef::FileCache.store("chef-stacktrace.out", chef_stacktrace_out) Chef::Log.fatal("Stacktrace dumped to #{Chef::FileCache.load("chef-stacktrace.out", false)}") Chef::Log.fatal("Please provide the contents of the stacktrace.out file if you file a bug report") Chef::Log.debug() true end |
.exit!(msg, err = nil) ⇒ Object
378 379 380 381 |
# File 'lib/chef/application.rb', line 378 def exit!(msg, err = nil) Chef::Log.debug(msg) Process.exit(normalize_exit_code(err)) end |
.fatal!(msg, err = nil) ⇒ Object
Log a fatal error message to both STDERR and the Logger, exit the application
373 374 375 376 |
# File 'lib/chef/application.rb', line 373 def fatal!(msg, err = nil) Chef::Log.fatal(msg) Process.exit(normalize_exit_code(err)) end |
.normalize_exit_code(exit_code) ⇒ Object
368 369 370 |
# File 'lib/chef/application.rb', line 368 def normalize_exit_code(exit_code) Chef::Application::ExitCode.normalize_exit_code(exit_code) end |
Instance Method Details
#auto_log_level? ⇒ Boolean
204 205 206 |
# File 'lib/chef/application.rb', line 204 def auto_log_level? Chef::Config[:log_level] == :auto end |
#configure_chef ⇒ Object
Parse configuration (options and config file)
85 86 87 88 89 90 |
# File 'lib/chef/application.rb', line 85 def configure_chef load_config_file Chef::Config.export_proxies Chef::Config.init_openssl end |
#configure_encoding ⇒ Object
Sets the default external encoding to UTF-8 (users can change this, but they shouldn’t)
223 224 225 |
# File 'lib/chef/application.rb', line 223 def configure_encoding Encoding.default_external = Chef::Config[:ruby_encoding] end |
#configure_log_location ⇒ Object
Turn ‘log_location :syslog` and `log_location :win_evt` into the appropriate loggers.
174 175 176 177 178 179 180 181 182 183 184 |
# File 'lib/chef/application.rb', line 174 def configure_log_location log_location = Chef::Config[:log_location] return unless log_location.respond_to?(:to_sym) Chef::Config[:log_location] = case log_location.to_sym when :syslog then Chef::Log::Syslog.new when :win_evt then Chef::Log::WinEvt.new else log_location # Probably a path; let MonoLogger sort it out end end |
#configure_logging ⇒ Object
Initialize and configure the logger.
Loggers and Formatters
In Chef 10.x and previous, the Logger was the primary/only way that Chef communicated information to the user. In Chef 10.14, a new system, “output formatters” was added, and in Chef 11.0+ it is the default when running chef in a console (detected by ‘STDOUT.tty?`). Because output formatters are more complex than the logger system and users have less experience with them, the config option `force_logger` is provided to restore the Chef 10.x behavior.
Conversely, for users who want formatter output even when chef is running unattended, the ‘force_formatter` option is provided.
Auto Log Level
When ‘log_level` is set to `:auto` (default), the log level will be `:warn` when the primary output mode is an output formatter (see using_output_formatter?
) and `:info` otherwise.
Automatic STDOUT Logging
When ‘force_logger` is configured (e.g., Chef 10 mode), a second logger with output on STDOUT is added when running in a console (STDOUT is a tty) and the configured log_location isn’t STDOUT. This accounts for the case that a user has configured a log_location in client.rb, but is running chef-client by hand to troubleshoot a problem.
160 161 162 163 164 165 166 167 168 169 170 |
# File 'lib/chef/application.rb', line 160 def configure_logging configure_log_location Chef::Log.init(MonoLogger.new(Chef::Config[:log_location])) if want_additional_logger? configure_stdout_logger end Chef::Log.level = resolve_log_level rescue StandardError => error Chef::Log.fatal("Failed to open or create log file at #{Chef::Config[:log_location]}: #{error.class} (#{error.})") Chef::Application.fatal!("Aborting due to invalid 'log_location' configuration", error) end |
#configure_stdout_logger ⇒ Object
186 187 188 189 190 |
# File 'lib/chef/application.rb', line 186 def configure_stdout_logger stdout_logger = MonoLogger.new(STDOUT) stdout_logger.formatter = Chef::Log.logger.formatter Chef::Log.loggers << stdout_logger end |
#load_config_file ⇒ Object
Parse the config file
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 |
# File 'lib/chef/application.rb', line 93 def load_config_file config_fetcher = Chef::ConfigFetcher.new(config[:config_file]) # Some config settings are derived relative to the config file path; if # given as a relative path, this is computed relative to cwd, but # chef-client will later chdir to root, so we need to get the absolute path # here. config[:config_file] = config_fetcher. if config[:config_file].nil? Chef::Log.warn("No config file found or specified on command line, using command line options.") elsif config_fetcher.config_missing? Chef::Log.warn("*****************************************") Chef::Log.warn("Did not find config file: #{config[:config_file]}, using command line options.") Chef::Log.warn("*****************************************") else config_content = config_fetcher.read_config apply_config(config_content, config[:config_file]) end = config.delete(:config_option) Chef::Config.merge!(config) if = .inject({}) do |memo, option| # Sanity check value. Chef::Application.fatal!("Unparsable config option #{option.inspect}") if option.empty? || !option.include?("=") # Split including whitespace if someone does truly odd like # --config-option "foo = bar" key, value = option.split(/\s*=\s*/, 2) # Call to_sym because Chef::Config expects only symbol keys. Also # runs a simple parse on the string for some common types. memo[key.to_sym] = YAML.safe_load(value) memo end Chef::Config.merge!() end end |
#reconfigure ⇒ Object
Reconfigure the application. You’ll want to override and super this method.
48 49 50 51 52 53 |
# File 'lib/chef/application.rb', line 48 def reconfigure configure_chef configure_logging configure_encoding emit_warnings end |
#resolve_log_level ⇒ Object
if log_level is ‘:auto`, convert it to :warn (when using output formatter) or :info (no output formatter). See also using_output_formatter?
210 211 212 213 214 215 216 217 218 219 220 |
# File 'lib/chef/application.rb', line 210 def resolve_log_level if auto_log_level? if using_output_formatter? :warn else :info end else Chef::Config[:log_level] end end |
#run ⇒ Object
Get this party started
56 57 58 59 60 61 |
# File 'lib/chef/application.rb', line 56 def run setup_signal_handlers reconfigure setup_application run_application end |
#run_application ⇒ Object
Actually run the application
233 234 235 |
# File 'lib/chef/application.rb', line 233 def run_application raise Chef::Exceptions::Application, "#{self}: you must override run_application" end |
#run_chef_client(specific_recipes = []) ⇒ Object
Initializes Chef::Client instance and runs it
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 |
# File 'lib/chef/application.rb', line 238 def run_chef_client(specific_recipes = []) unless specific_recipes.respond_to?(:size) raise ArgumentError, "received non-Array like specific_recipes argument" end Chef::LocalMode.with_server_connectivity do override_runlist = config[:override_runlist] override_runlist ||= [] if specific_recipes.size > 0 @chef_client = Chef::Client.new( @chef_client_json, override_runlist: override_runlist, specific_recipes: specific_recipes, runlist: config[:runlist] ) @chef_client_json = nil if can_fork? fork_chef_client # allowed to run client in forked process else # Unforked interval runs are disabled, so this runs chef-client # once and then exits. If TERM signal is received, will "ignore" # the signal to finish converge. run_with_graceful_exit_option end @chef_client = nil end end |
#set_specific_recipes ⇒ Object
130 131 132 133 134 |
# File 'lib/chef/application.rb', line 130 def set_specific_recipes Chef::Config[:specific_recipes] = cli_arguments.map { |file| File.(file) } if cli_arguments.respond_to?(:map) end |
#setup_application ⇒ Object
Called prior to starting the application, by the run method
228 229 230 |
# File 'lib/chef/application.rb', line 228 def setup_application raise Chef::Exceptions::Application, "#{self}: you must override setup_application" end |
#setup_signal_handlers ⇒ Object
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
# File 'lib/chef/application.rb', line 63 def setup_signal_handlers trap("INT") do Chef::Application.fatal!("SIGINT received, stopping", Chef::Exceptions::SigInt.new) end trap("TERM") do Chef::Application.fatal!("SIGTERM received, stopping", Chef::Exceptions::SigTerm.new) end unless Chef::Platform.windows? trap("QUIT") do Chef::Log.info("SIGQUIT received, call stack:\n " + caller.join("\n ")) end trap("HUP") do Chef::Log.info("SIGHUP received, reconfiguring") reconfigure end end end |
#using_output_formatter? ⇒ Boolean
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)
200 201 202 |
# File 'lib/chef/application.rb', line 200 def using_output_formatter? Chef::Config[:force_formatter] || (!Chef::Config[:force_logger] && STDOUT.tty?) end |
#want_additional_logger? ⇒ Boolean
Based on config and whether or not STDOUT is a tty, should we setup a secondary logger for stdout?
194 195 196 |
# File 'lib/chef/application.rb', line 194 def want_additional_logger? ( Chef::Config[:log_location] != STDOUT ) && STDOUT.tty? && (!Chef::Config[:daemonize]) && (Chef::Config[:force_logger]) end |