Class: Chef::Application

Inherits:
Object show all
Includes:
Mixlib::CLI
Defined in:
lib/chef/application.rb,
lib/chef/application/windows_service.rb,
lib/chef/application/windows_service_manager.rb

Direct Known Subclasses

Apply, Client, Knife, Solo

Defined Under Namespace

Classes: Apply, Client, Knife, Solo, WindowsService, WindowsServiceManager

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Application

Returns a new instance of Application.



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/chef/application.rb', line 32

def initialize
  super

  @chef_client = nil
  @chef_client_json = nil
  trap("INT") do
    Chef::Application.fatal!("SIGINT received, stopping", 2)
  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

  # 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 



226
227
228
229
230
231
232
233
234
235
 
# File 'lib/chef/application.rb', line 226

def debug_stacktrace(e)
  message = "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
  chef_stacktrace_out = "Generated at #{Time.now.to_s}\n"
  chef_stacktrace_out += message

  Chef::FileCache.store("chef-stacktrace.out", chef_stacktrace_out)
  Chef::Log.fatal("Stacktrace dumped to #{Chef::FileCache.load("chef-stacktrace.out", false)}")
  Chef::Log.debug(message)
  true
end

.destroy_server_connectivity ⇒ Object 



191
192
193
194
195
196
 
# File 'lib/chef/application.rb', line 191

def self.destroy_server_connectivity
  if @chef_zero_server
    @chef_zero_server.stop
    @chef_zero_server = nil
  end
end

.exit!(msg, err = -1)) ⇒ Object 



243
244
245
246
 
# File 'lib/chef/application.rb', line 243

def exit!(msg, err = -1)
  Chef::Log.debug(msg)
  Process.exit err
end

.fatal!(msg, err = -1)) ⇒ Object

Log a fatal error message to both STDERR and the Logger, exit the application



238
239
240
241
 
# File 'lib/chef/application.rb', line 238

def fatal!(msg, err = -1)
  Chef::Log.fatal(msg)
  Process.exit err
end

.setup_server_connectivity ⇒ Object 



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/chef/application.rb', line 170

def self.setup_server_connectivity
  if Chef::Config.chef_zero.enabled
    destroy_server_connectivity

    require 'chef_zero/server'
    require 'chef/chef_fs/chef_fs_data_store'
    require 'chef/chef_fs/config'

    chef_fs = Chef::ChefFS::Config.new.local_fs
    chef_fs.write_pretty_json = true
    server_options = {}
    server_options[:data_store] = Chef::ChefFS::ChefFSDataStore.new(chef_fs)
    server_options[:log_level] = Chef::Log.level
    server_options[:port] = Chef::Config.chef_zero.port
    Chef::Log.info("Starting chef-zero on port #{Chef::Config.chef_zero.port} with repository at #{server_options[:data_store].chef_fs.fs_description}")
    @chef_zero_server = ChefZero::Server.new(server_options)
    @chef_zero_server.start_background
    Chef::Config.chef_server_url = @chef_zero_server.url
  end
end

Instance Method Details

#auto_log_level? ⇒ Boolean

Returns:

  • (Boolean) 


142
143
144
 
# File 'lib/chef/application.rb', line 142

def auto_log_level?
  Chef::Config[:log_level] == :auto
end

#configure_chef ⇒ Object

Parse configuration (options and config file)



70
71
72
73
 
# File 'lib/chef/application.rb', line 70

def configure_chef
  parse_options
  load_config_file
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.



115
116
117
118
119
120
121
 
# File 'lib/chef/application.rb', line 115

def configure_logging
  Chef::Log.init(MonoLogger.new(Chef::Config[:log_location]))
  if want_additional_logger?
    configure_stdout_logger
  end
  Chef::Log.level = resolve_log_level
end

#configure_stdout_logger ⇒ Object 



123
124
125
126
127
128
 
# File 'lib/chef/application.rb', line 123

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

#load_config_file ⇒ Object

Parse the config file



76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/chef/application.rb', line 76

def load_config_file
  config_fetcher = Chef::ConfigFetcher.new(config[:config_file], Chef::Config.config_file_jail)
  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
  Chef::Config.merge!(config)
end

#reconfigure ⇒ Object

Reconfigure the application. You’ll want to override and super this method.



57
58
59
60
 
# File 'lib/chef/application.rb', line 57

def reconfigure
  configure_chef
  configure_logging
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?



148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/chef/application.rb', line 148

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



63
64
65
66
67
 
# File 'lib/chef/application.rb', line 63

def run
  reconfigure
  setup_application
  run_application
end

#run_application ⇒ Object

Actually run the application

Raises:



166
167
168
 
# File 'lib/chef/application.rb', line 166

def run_application
  raise Chef::Exceptions::Application, "#{self.to_s}: you must override run_application"
end

#run_chef_client ⇒ Object

Initializes Chef::Client instance and runs it



199
200
201
202
203
204
205
206
207
208
209
210
211
212
 
# File 'lib/chef/application.rb', line 199

def run_chef_client
  Chef::Application.setup_server_connectivity

  @chef_client = Chef::Client.new(
    @chef_client_json,
    :override_runlist => config[:override_runlist]
  )
  @chef_client_json = nil

  @chef_client.run
  @chef_client = nil

  Chef::Application.destroy_server_connectivity
end

#setup_application ⇒ Object

Called prior to starting the application, by the run method

Raises:



161
162
163
 
# File 'lib/chef/application.rb', line 161

def setup_application
  raise Chef::Exceptions::Application, "#{self.to_s}: you must override setup_application"
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)

Returns:

  • (Boolean) 


138
139
140
 
# File 'lib/chef/application.rb', line 138

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?

Returns:

  • (Boolean) 


132
133
134
 
# File 'lib/chef/application.rb', line 132

def want_additional_logger?
  ( Chef::Config[:log_location] != STDOUT ) && STDOUT.tty? && (!Chef::Config[:daemonize]) && (Chef::Config[:force_logger])
end