Class: Puppet::Settings
- Extended by:
- Forwardable
- Includes:
- Enumerable
- Defined in:
- lib/puppet/settings.rb,
lib/puppet/settings/errors.rb
Overview
The class for handling configuration files.
Defined Under Namespace
Classes: ArraySetting, AutosignSetting, BaseSetting, BooleanSetting, ChainedValues, ConfigFile, DirectorySetting, DurationSetting, EnumSetting, EnvironmentConf, FileOrDirectorySetting, FileSetting, IniFile, InterpolationError, ParseError, PathSetting, PrioritySetting, SearchPathElement, ServerListSetting, SettingsError, StringSetting, SymbolicEnumSetting, TTLSetting, TerminusSetting, ValidationError, ValueTranslator, Values, ValuesFromEnvironmentConf, ValuesFromSection
Constant Summary collapse
- PuppetOptionParser =
local reference for convenience
Puppet::Util::CommandLine::PuppetOptionParser
- REQUIRED_APP_SETTINGS =
These are the settings that every app is required to specify; there are reasonable defaults defined in application.rb.
[:logdir, :confdir, :vardir, :codedir]
- ALLOWED_SECTION_NAMES =
The acceptable sections of the puppet.conf configuration file.
['main', 'master', 'agent', 'user'].freeze
- NONE =
'none'.freeze
- SETTING_TYPES =
{ :string => StringSetting, :file => FileSetting, :directory => DirectorySetting, :file_or_directory => FileOrDirectorySetting, :path => PathSetting, :boolean => BooleanSetting, :terminus => TerminusSetting, :duration => DurationSetting, :ttl => TTLSetting, :array => ArraySetting, :enum => EnumSetting, :symbolic_enum => SymbolicEnumSetting, :priority => PrioritySetting, :autosign => AutosignSetting, :server_list => ServerListSetting }
Instance Attribute Summary collapse
-
#files ⇒ Object
writeonly
Sets the attribute files.
-
#timer ⇒ Object
readonly
Returns the value of attribute timer.
Class Method Summary collapse
-
.app_defaults_for_run_mode(run_mode) ⇒ Object
This method is intended for puppet internal use only; it is a convenience method that returns reasonable application default settings values for a given run_mode.
-
.clean_opt(opt, val) ⇒ Object
A utility method (public, is used by application.rb and perhaps elsewhere) that munges a command-line option string into the format that Puppet.settings expects.
- .default_certname ⇒ Object
- .default_config_file_name ⇒ Object
- .domain_fact ⇒ Object
- .hostname_fact ⇒ Object
Instance Method Summary collapse
-
#[](param) ⇒ Object
private
Retrieve a config value.
-
#[]=(param, value) ⇒ Object
private
Set a config value.
-
#addargs(options) ⇒ Object
Generate the list of valid arguments, in a format that GetoptLong can understand, and add them to the passed option list.
- #app_defaults_initialized? ⇒ Boolean
- #apply_metadata_from_section(section) ⇒ Object
-
#boolean?(param) ⇒ Boolean
Is our setting a boolean setting?.
-
#clear ⇒ Object
Remove all set values, potentially skipping cli values.
-
#clear_environment_settings(environment) ⇒ Object
private
Clears all cached settings for a particular environment to ensure that changes to environment.conf are reflected in the settings if the environment timeout has expired.
- #clearused ⇒ Object
-
#configsearchpath(environment = nil, run_mode = preferred_run_mode) ⇒ Array<SearchPathElement>
private
The order in which to search for values, without defaults.
-
#define_settings(section, defs) ⇒ Object
Define a group of settings.
-
#description(name) ⇒ Object
Return a value’s description.
-
#eachsection ⇒ Object
Iterate over each section name.
-
#flush_cache ⇒ Object
Clear @cache, @used and the Environment.
- #generate_config ⇒ Object
- #generate_manifest ⇒ Object
- #global_defaults_initialized? ⇒ Boolean
-
#handlearg(opt, value = nil) ⇒ Object
Handle a command-line argument.
- #include?(name) ⇒ Boolean
-
#initialize ⇒ Settings
constructor
Create a new collection of config settings.
- #initialize_app_defaults(app_defaults) ⇒ Object
- #initialize_global_settings(args = []) ⇒ Object
-
#optparse_addargs(options) ⇒ Object
Generate the list of valid arguments, in a format that OptionParser can understand, and add them to the passed option list.
-
#override_default(param, value) ⇒ Object
private
Create a new default value for the given setting.
- #parse_config(text, file = "text") ⇒ Object
-
#parse_file(file, allowed_sections = []) ⇒ Puppet::Settings::ConfigFile::Conf
private
This method just turns a file into a new ConfigFile::Conf instance.
-
#patch_value(param, value, type) ⇒ Object
private
Patches the value for a param in a section.
-
#persection(section) ⇒ Object
Iterate across all of the objects in a given section.
-
#preferred_run_mode ⇒ Object
The currently configured run mode that is preferred for constructing the application configuration.
-
#preferred_run_mode=(mode) ⇒ Object
private
PRIVATE! This only exists because we need a hook to validate the run mode when it’s being set, and it should never, ever, ever, ever be called from outside of this file.
-
#print_config_options ⇒ Object
Prints the contents of a config file with the available config settings, or it prints a single value of a config setting.
- #print_configs ⇒ Object
- #print_configs? ⇒ Boolean
-
#reparse_config_files ⇒ Object
Reparse our config file, if necessary.
- #reuse ⇒ Object
-
#searchpath(environment = nil, run_mode = preferred_run_mode) ⇒ Array<SearchPathElement>
private
The order in which to search for values.
-
#searchpath_values(source) ⇒ Object
private
Get values from a search path entry.
- #service_group_available? ⇒ Boolean
- #service_user_available? ⇒ Boolean
-
#set_by_cli?(param) ⇒ Boolean
Allow later inspection to determine if the setting was set on the command line, or through some other code path.
-
#set_by_config?(param, environment = nil, run_mode = preferred_run_mode) ⇒ Boolean
Allow later inspection to determine if the setting was set by user config, rather than a default setting.
-
#setting(param) ⇒ Puppet::Settings::BaseSetting
Returns a given setting by name.
-
#to_catalog(*sections) ⇒ Object
Convert the settings we manage into a catalog full of resources that model those settings.
-
#to_config ⇒ Object
Convert our list of config settings into a configuration file.
-
#to_manifest ⇒ Object
Convert to a parseable manifest.
-
#use(*sections) ⇒ Object
Create the necessary objects to use a section.
- #valid?(param) ⇒ Boolean
-
#value(param, environment = nil, bypass_interpolation = false) ⇒ Object
Find the correct value using our search path.
-
#value_sym(param, environment = nil, bypass_interpolation = false) ⇒ Object
Find the correct value using symbols and our search path.
-
#values(environment, section) ⇒ Puppet::Settings::ChainedValues
Retrieve an object that can be used for looking up values of configuration settings.
-
#which_configuration_file ⇒ Object
private
(#15337) All of the logic to determine the configuration file to use should be centralized into this method.
Methods included from Enumerable
Constructor Details
#initialize ⇒ Settings
Create a new collection of config settings.
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 |
# File 'lib/puppet/settings.rb', line 87 def initialize @config = {} @shortnames = {} @created = [] # Keep track of set values. @value_sets = { :cli => Values.new(:cli, @config), :memory => Values.new(:memory, @config), :application_defaults => Values.new(:application_defaults, @config), :overridden_defaults => Values.new(:overridden_defaults, @config), } @configuration_file = nil # And keep a per-environment cache @cache = Hash.new { |hash, key| hash[key] = {} } @values = Hash.new { |hash, key| hash[key] = {} } # The list of sections we've used. @used = [] @hooks_to_call_on_application_initialization = [] @deprecated_setting_names = [] @deprecated_settings_that_have_been_configured = [] @translate = Puppet::Settings::ValueTranslator.new @config_file_parser = Puppet::Settings::ConfigFile.new(@translate) end |
Instance Attribute Details
#files=(value) ⇒ Object
Sets the attribute files
37 38 39 |
# File 'lib/puppet/settings.rb', line 37 def files=(value) @files = value end |
#timer ⇒ Object (readonly)
Returns the value of attribute timer.
38 39 40 |
# File 'lib/puppet/settings.rb', line 38 def timer @timer end |
Class Method Details
.app_defaults_for_run_mode(run_mode) ⇒ Object
This method is intended for puppet internal use only; it is a convenience method that returns reasonable application default settings values for a given run_mode.
51 52 53 54 55 56 57 58 59 60 61 |
# File 'lib/puppet/settings.rb', line 51 def self.app_defaults_for_run_mode(run_mode) { :name => run_mode.to_s, :run_mode => run_mode.name, :confdir => run_mode.conf_dir, :codedir => run_mode.code_dir, :vardir => run_mode.var_dir, :rundir => run_mode.run_dir, :logdir => run_mode.log_dir, } end |
.clean_opt(opt, val) ⇒ Object
A utility method (public, is used by application.rb and perhaps elsewhere) that munges a command-line option string into the format that Puppet.settings expects. (This mostly has to deal with handling the “no-” prefix on flag/boolean options).
314 315 316 317 318 319 320 321 322 |
# File 'lib/puppet/settings.rb', line 314 def self.clean_opt(opt, val) # rewrite --[no-]option to --no-option if that's what was given if opt =~ /\[no-\]/ and !val opt = opt.gsub(/\[no-\]/,'no-') end # otherwise remove the [no-] prefix to not confuse everybody opt = opt.gsub(/\[no-\]/, '') [opt, val] end |
.default_certname ⇒ Object
63 64 65 66 67 68 69 70 71 72 |
# File 'lib/puppet/settings.rb', line 63 def self.default_certname() hostname = hostname_fact domain = domain_fact if domain and domain != "" fqdn = [hostname, domain].join(".") else fqdn = hostname end fqdn.to_s.gsub(/\.$/, '') end |
.default_config_file_name ⇒ Object
82 83 84 |
# File 'lib/puppet/settings.rb', line 82 def self.default_config_file_name "puppet.conf" end |
.domain_fact ⇒ Object
78 79 80 |
# File 'lib/puppet/settings.rb', line 78 def self.domain_fact() Facter.value :domain end |
.hostname_fact ⇒ Object
74 75 76 |
# File 'lib/puppet/settings.rb', line 74 def self.hostname_fact() Facter.value :hostname end |
Instance Method Details
#[](param) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Retrieve a config value
121 122 123 124 125 126 |
# File 'lib/puppet/settings.rb', line 121 def [](param) if @deprecated_setting_names.include?(param) issue_deprecation_warning(setting(param), "Accessing '#{param}' as a setting is deprecated.") end value(param) end |
#[]=(param, value) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Set a config value. This doesn’t set the defaults, it sets the value itself.
132 133 134 135 136 137 138 |
# File 'lib/puppet/settings.rb', line 132 def []=(param, value) if @deprecated_setting_names.include?(param) issue_deprecation_warning(setting(param), "Modifying '#{param}' as a setting is deprecated.") end @value_sets[:memory].set(param, value) unsafe_flush_cache end |
#addargs(options) ⇒ Object
Generate the list of valid arguments, in a format that GetoptLong can understand, and add them to the passed option list.
156 157 158 159 160 161 162 163 |
# File 'lib/puppet/settings.rb', line 156 def addargs() # Add all of the settings as valid options. self.each { |name, setting| setting.getopt_args.each { |args| << args } } end |
#app_defaults_initialized? ⇒ Boolean
325 326 327 |
# File 'lib/puppet/settings.rb', line 325 def app_defaults_initialized? @app_defaults_initialized end |
#apply_metadata_from_section(section) ⇒ Object
650 651 652 653 654 655 656 |
# File 'lib/puppet/settings.rb', line 650 def (section) section.settings.each do |setting| if setting. && type = @config[setting.name] type.(setting.) end end end |
#boolean?(param) ⇒ Boolean
Is our setting a boolean setting?
177 178 179 180 |
# File 'lib/puppet/settings.rb', line 177 def boolean?(param) param = param.to_sym @config.include?(param) and @config[param].kind_of?(BooleanSetting) end |
#clear ⇒ Object
Remove all set values, potentially skipping cli values.
183 184 185 |
# File 'lib/puppet/settings.rb', line 183 def clear unsafe_clear end |
#clear_environment_settings(environment) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Clears all cached settings for a particular environment to ensure that changes to environment.conf are reflected in the settings if the environment timeout has expired.
param [String, Symbol] environment the name of environment to clear settings for
219 220 221 222 223 224 225 226 227 |
# File 'lib/puppet/settings.rb', line 219 def clear_environment_settings(environment) if environment.nil? return end @cache[environment.to_sym].clear @values[environment.to_sym] = {} end |
#clearused ⇒ Object
248 249 250 251 |
# File 'lib/puppet/settings.rb', line 248 def clearused @cache.clear @used = [] end |
#configsearchpath(environment = nil, run_mode = preferred_run_mode) ⇒ Array<SearchPathElement>
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
The order in which to search for values, without defaults.
764 765 766 767 768 769 770 771 772 |
# File 'lib/puppet/settings.rb', line 764 def configsearchpath(environment = nil, run_mode = preferred_run_mode) searchpath = [ SearchPathElement.new(:memory, :values), SearchPathElement.new(:cli, :values), ] searchpath << SearchPathElement.new(environment.intern, :environment) if environment searchpath << SearchPathElement.new(run_mode, :section) if run_mode searchpath << SearchPathElement.new(:main, :section) end |
#define_settings(section, defs) ⇒ Object
Define a group of settings.
889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 |
# File 'lib/puppet/settings.rb', line 889 def define_settings(section, defs) section = section.to_sym call = [] defs.each do |name, hash| raise ArgumentError, "setting definition for '#{name}' is not a hash!" unless hash.is_a? Hash name = name.to_sym hash[:name] = name hash[:section] = section raise ArgumentError, "Setting #{name} is already defined" if @config.include?(name) tryconfig = newsetting(hash) if short = tryconfig.short if other = @shortnames[short] raise ArgumentError, "Setting #{other.name} is already using short name '#{short}'" end @shortnames[short] = tryconfig end @config[name] = tryconfig # Collect the settings that need to have their hooks called immediately. # We have to collect them so that we can be sure we're fully initialized before # the hook is called. if tryconfig.has_hook? if tryconfig.call_hook_on_define? call << tryconfig elsif tryconfig.call_hook_on_initialize? @hooks_to_call_on_application_initialization |= [ tryconfig ] end end @deprecated_setting_names << name if tryconfig.deprecated? end call.each do |setting| setting.handle(self.value(setting.name)) end end |
#description(name) ⇒ Object
Return a value’s description.
381 382 383 384 385 386 387 |
# File 'lib/puppet/settings.rb', line 381 def description(name) if obj = @config[name.to_sym] obj.desc else nil end end |
#eachsection ⇒ Object
Iterate over each section name.
392 393 394 395 396 397 398 399 400 401 |
# File 'lib/puppet/settings.rb', line 392 def eachsection yielded = [] @config.each_value do |object| section = object.section unless yielded.include? section yield section yielded << section end end end |
#flush_cache ⇒ Object
Clear @cache, @used and the Environment.
Whenever an object is returned by Settings, a copy is stored in @cache. As long as Setting attributes that determine the content of returned objects remain unchanged, Settings can keep returning objects from @cache without re-fetching or re-generating them.
Whenever a Settings attribute changes, such as @values or @preferred_run_mode, this method must be called to clear out the caches so that updated objects will be returned.
239 240 241 |
# File 'lib/puppet/settings.rb', line 239 def flush_cache unsafe_flush_cache end |
#generate_config ⇒ Object
484 485 486 487 |
# File 'lib/puppet/settings.rb', line 484 def generate_config puts to_config true end |
#generate_manifest ⇒ Object
489 490 491 492 |
# File 'lib/puppet/settings.rb', line 489 def generate_manifest puts to_manifest true end |
#global_defaults_initialized? ⇒ Boolean
253 254 255 |
# File 'lib/puppet/settings.rb', line 253 def global_defaults_initialized?() @global_defaults_initialized end |
#handlearg(opt, value = nil) ⇒ Object
Handle a command-line argument.
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 |
# File 'lib/puppet/settings.rb', line 412 def handlearg(opt, value = nil) @cache.clear if value.is_a?(FalseClass) value = "false" elsif value.is_a?(TrueClass) value = "true" end value &&= @translate[value] str = opt.sub(/^--/,'') bool = true newstr = str.sub(/^no-/, '') if newstr != str str = newstr bool = false end str = str.intern if @config[str].is_a?(Puppet::Settings::BooleanSetting) if value == "" or value.nil? value = bool end end if s = @config[str] @deprecated_settings_that_have_been_configured << s if s.completely_deprecated? end @value_sets[:cli].set(str, value) unsafe_flush_cache end |
#include?(name) ⇒ Boolean
446 447 448 449 |
# File 'lib/puppet/settings.rb', line 446 def include?(name) name = name.intern if name.is_a? String @config.include?(name) end |
#initialize_app_defaults(app_defaults) ⇒ Object
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 |
# File 'lib/puppet/settings.rb', line 329 def initialize_app_defaults(app_defaults) REQUIRED_APP_SETTINGS.each do |key| raise SettingsError, "missing required app default setting '#{key}'" unless app_defaults.has_key?(key) end app_defaults.each do |key, value| if key == :run_mode self.preferred_run_mode = value else @value_sets[:application_defaults].set(key, value) unsafe_flush_cache end end call_hooks_deferred_to_application_initialization issue_deprecations REQUIRED_APP_SETTINGS.each do |key| create_ancestors(Puppet[key]) end @app_defaults_initialized = true end |
#initialize_global_settings(args = []) ⇒ Object
257 258 259 260 261 262 263 264 265 266 267 268 269 |
# File 'lib/puppet/settings.rb', line 257 def initialize_global_settings(args = []) raise Puppet::DevError, "Attempting to initialize global default settings more than once!" if global_defaults_initialized? # The first two phases of the lifecycle of a puppet application are: # 1) Parse the command line options and handle any of them that are # registered, defined "global" puppet settings (mostly from defaults.rb). # 2) Parse the puppet config file(s). (args) parse_config_files @global_defaults_initialized = true end |
#optparse_addargs(options) ⇒ Object
Generate the list of valid arguments, in a format that OptionParser can understand, and add them to the passed option list.
167 168 169 170 171 172 173 174 |
# File 'lib/puppet/settings.rb', line 167 def optparse_addargs() # Add all of the settings as valid options. self.each { |name, setting| << setting.optparse_args } end |
#override_default(param, value) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Create a new default value for the given setting. The default overrides are higher precedence than the defaults given in defaults.rb, but lower precedence than any other values for the setting. This allows one setting ‘a` to change the default of setting `b`, but still allow a user to provide a value for setting `b`.
149 150 151 152 |
# File 'lib/puppet/settings.rb', line 149 def override_default(param, value) @value_sets[:overridden_defaults].set(param, value) unsafe_flush_cache end |
#parse_config(text, file = "text") ⇒ Object
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 |
# File 'lib/puppet/settings.rb', line 525 def parse_config(text, file = "text") begin data = @config_file_parser.parse_file(file, text, ALLOWED_SECTION_NAMES) rescue => detail Puppet.log_exception(detail, "Could not parse #{file}: #{detail}") return end # If we get here and don't have any data, we just return and don't muck with the current state of the world. return if data.nil? # If we get here then we have some data, so we need to clear out any # previous settings that may have come from config files. unsafe_clear(false, false) # Screen settings which have been deprecated and removed from puppet.conf # but are still valid on the command line and/or in environment.conf screen_non_puppet_conf_settings(data) # Make note of deprecated settings we will warn about later in initialization record_deprecations_from_puppet_conf(data) # And now we can repopulate with the values from our last parsing of the config files. @configuration_file = data # Determine our environment, if we have one. if @config[:environment] env = self.value(:environment).to_sym else env = NONE end # Call any hooks we should be calling. value_sets = value_sets_for(env, preferred_run_mode) @config.values.select(&:has_hook?).each do |setting| value_sets.each do |source| if source.include?(setting.name) # We still have to use value to retrieve the value, since # we want the fully interpolated value, not $vardir/lib or whatever. # This results in extra work, but so few of the settings # will have associated hooks that it ends up being less work this # way overall. if setting.call_hook_on_initialize? @hooks_to_call_on_application_initialization |= [ setting ] else setting.handle(ChainedValues.new( preferred_run_mode, env, value_sets, @config).interpolate(setting.name)) end break end end end call_hooks_deferred_to_application_initialization :ignore_interpolation_dependency_errors => true end |
#parse_file(file, allowed_sections = []) ⇒ Puppet::Settings::ConfigFile::Conf
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
This method just turns a file into a new ConfigFile::Conf instance
1110 1111 1112 |
# File 'lib/puppet/settings.rb', line 1110 def parse_file(file, allowed_sections = []) @config_file_parser.parse_file(file, read_file(file), allowed_sections) end |
#patch_value(param, value, type) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Patches the value for a param in a section. This method is required to support the use case of unifying –dns-alt-names and –dns_alt_names in the certificate face. Ideally this should be cleaned up. See PUP-3684 for more information. For regular use of setting a value, the method ‘[]=` should be used.
853 854 855 856 857 858 |
# File 'lib/puppet/settings.rb', line 853 def patch_value(param, value, type) if @value_sets[type] @value_sets[type].set(param, value) unsafe_flush_cache end end |
#persection(section) ⇒ Object
Iterate across all of the objects in a given section.
706 707 708 709 710 711 712 713 |
# File 'lib/puppet/settings.rb', line 706 def persection(section) section = section.to_sym self.each { |name, obj| if obj.section == section yield obj end } end |
#preferred_run_mode ⇒ Object
The currently configured run mode that is preferred for constructing the application configuration.
505 506 507 |
# File 'lib/puppet/settings.rb', line 505 def preferred_run_mode @preferred_run_mode_name || :user end |
#preferred_run_mode=(mode) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
PRIVATE! This only exists because we need a hook to validate the run mode when it’s being set, and
it should never, ever, ever, ever be called from outside of this file.
This method is also called when –run_mode MODE is used on the command line to set the default
515 516 517 518 519 520 521 522 523 |
# File 'lib/puppet/settings.rb', line 515 def preferred_run_mode=(mode) mode = mode.to_s.downcase.intern raise ValidationError, "Invalid run mode '#{mode}'" unless [:master, :agent, :user].include?(mode) @preferred_run_mode_name = mode # Changing the run mode has far-reaching consequences. Flush any cached # settings so they will be re-generated. flush_cache mode end |
#print_config_options ⇒ Object
Prints the contents of a config file with the available config settings, or it prints a single value of a config setting.
453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 |
# File 'lib/puppet/settings.rb', line 453 def env = value(:environment) val = value(:configprint) if val == "all" hash = {} each do |name, obj| val = value(name,env) val = val.inspect if val == "" hash[name] = val end hash.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, v| puts "#{name} = #{v}" end else val.split(/\s*,\s*/).sort.each do |v| if include?(v) #if there is only one value, just print it for back compatibility if v == val puts value(val,env) break end puts "#{v} = #{value(v,env)}" else puts "invalid setting: #{v}" return false end end end true end |
#print_configs ⇒ Object
494 495 496 497 498 |
# File 'lib/puppet/settings.rb', line 494 def print_configs return if value(:configprint) != "" return generate_config if value(:genconfig) generate_manifest if value(:genmanifest) end |
#print_configs? ⇒ Boolean
500 501 502 |
# File 'lib/puppet/settings.rb', line 500 def print_configs? (value(:configprint) != "" || value(:genconfig) || value(:genmanifest)) && true end |
#reparse_config_files ⇒ Object
Reparse our config file, if necessary.
716 717 718 719 720 721 722 723 724 |
# File 'lib/puppet/settings.rb', line 716 def reparse_config_files if files if filename = any_files_changed? Puppet.notice "Config file #{filename} changed; triggering re-parse of all config files." parse_config_files reuse end end end |
#reuse ⇒ Object
749 750 751 752 753 754 |
# File 'lib/puppet/settings.rb', line 749 def reuse return unless defined?(@used) new = @used @used = [] self.use(*new) end |
#searchpath(environment = nil, run_mode = preferred_run_mode) ⇒ Array<SearchPathElement>
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
The order in which to search for values.
780 781 782 783 784 |
# File 'lib/puppet/settings.rb', line 780 def searchpath(environment = nil, run_mode = preferred_run_mode) searchpath = configsearchpath(environment, run_mode) searchpath << SearchPathElement.new(:application_defaults, :values) searchpath << SearchPathElement.new(:overridden_defaults, :values) end |
#searchpath_values(source) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Get values from a search path entry.
820 821 822 823 824 825 826 827 828 829 830 831 832 833 |
# File 'lib/puppet/settings.rb', line 820 def searchpath_values(source) case source.type when :values @value_sets[source.name] when :section if @configuration_file && section = @configuration_file.sections[source.name] ValuesFromSection.new(source.name, section) end when :environment ValuesFromEnvironmentConf.new(source.name) else raise(Puppet::DevError, "Unknown searchpath case: #{source.type} for the #{source} settings path element.") end end |
#service_group_available? ⇒ Boolean
798 799 800 801 802 803 804 805 806 807 808 |
# File 'lib/puppet/settings.rb', line 798 def service_group_available? return @service_group_available if defined?(@service_group_available) if self[:group] group = Puppet::Type.type(:group).new :name => self[:group], :audit => :ensure @service_group_available = group.exists? else @service_group_available = false end end |
#service_user_available? ⇒ Boolean
786 787 788 789 790 791 792 793 794 795 796 |
# File 'lib/puppet/settings.rb', line 786 def service_user_available? return @service_user_available if defined?(@service_user_available) if self[:user] user = Puppet::Type.type(:user).new :name => self[:user], :audit => :ensure @service_user_available = user.exists? else @service_user_available = false end end |
#set_by_cli?(param) ⇒ Boolean
Allow later inspection to determine if the setting was set on the command line, or through some other code path. Used for the ‘dns_alt_names` option during cert generate. –daniel 2011-10-18
813 814 815 816 |
# File 'lib/puppet/settings.rb', line 813 def set_by_cli?(param) param = param.to_sym !@value_sets[:cli].lookup(param).nil? end |
#set_by_config?(param, environment = nil, run_mode = preferred_run_mode) ⇒ Boolean
Allow later inspection to determine if the setting was set by user config, rather than a default setting.
837 838 839 840 841 842 843 844 |
# File 'lib/puppet/settings.rb', line 837 def set_by_config?(param, environment = nil, run_mode = preferred_run_mode) param = param.to_sym configsearchpath(environment, run_mode).any? do |source| if vals = searchpath_values(source) vals.lookup(param) end end end |
#setting(param) ⇒ Puppet::Settings::BaseSetting
Returns a given setting by name
406 407 408 409 |
# File 'lib/puppet/settings.rb', line 406 def setting(param) param = param.to_sym @config[param] end |
#to_catalog(*sections) ⇒ Object
Convert the settings we manage into a catalog full of resources that model those settings.
928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 |
# File 'lib/puppet/settings.rb', line 928 def to_catalog(*sections) sections = nil if sections.empty? catalog = Puppet::Resource::Catalog.new("Settings", Puppet::Node::Environment::NONE) @config.keys.find_all { |key| @config[key].is_a?(FileSetting) }.each do |key| file = @config[key] next if file.value.nil? next unless (sections.nil? or sections.include?(file.section)) next unless resource = file.to_resource next if catalog.resource(resource.ref) Puppet.debug {"Using settings: adding file resource '#{key}': '#{resource.inspect}'"} catalog.add_resource(resource) end add_user_resources(catalog, sections) add_environment_resources(catalog, sections) catalog end |
#to_config ⇒ Object
Convert our list of config settings into a configuration file.
951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 |
# File 'lib/puppet/settings.rb', line 951 def to_config str = %{The configuration file for #{Puppet.run_mode.name}. Note that this file is likely to have unused settings in it; any setting that's valid anywhere in Puppet can be in any config file, even if it's not used. Every section can specify three special parameters: owner, group, and mode. These parameters affect the required permissions of any files specified after their specification. Puppet will sometimes use these parameters to check its own configured state, so they can be used to make Puppet a bit more self-managing. The file format supports octothorpe-commented lines, but not partial-line comments. Generated on #{Time.now}. }.gsub(/^/, "# ") # Add a section heading that matches our name. str += "[#{preferred_run_mode}]\n" eachsection do |section| persection(section) do |obj| str += obj.to_config + "\n" unless obj.name == :genconfig end end return str end |
#to_manifest ⇒ Object
Convert to a parseable manifest
979 980 981 982 983 984 |
# File 'lib/puppet/settings.rb', line 979 def to_manifest catalog = to_catalog catalog.resource_refs.collect do |ref| catalog.resource(ref).to_manifest end.join("\n\n") end |
#use(*sections) ⇒ Object
Create the necessary objects to use a section. This is idempotent; you can ‘use’ a section as many times as you want.
988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 |
# File 'lib/puppet/settings.rb', line 988 def use(*sections) sections = sections.collect { |s| s.to_sym } sections = sections.reject { |s| @used.include?(s) } return if sections.empty? Puppet.debug("Applying settings catalog for sections #{sections.join(', ')}") begin catalog = to_catalog(*sections).to_ral rescue => detail Puppet.log_and_raise(detail, "Could not create resources for managing Puppet's files and directories in sections #{sections.inspect}: #{detail}") end catalog.host_config = false catalog.apply do |transaction| if transaction.any_failed? report = transaction.report status_failures = report.resource_statuses.values.select { |r| r.failed? } status_fail_msg = status_failures. collect(&:events). flatten. select { |event| event.status == 'failure' }. collect { |event| "#{event.resource}: #{event.}" }.join("; ") raise "Got #{status_failures.length} failure(s) while initializing: #{status_fail_msg}" end end sections.each { |s| @used << s } @used.uniq! end |
#valid?(param) ⇒ Boolean
1021 1022 1023 1024 |
# File 'lib/puppet/settings.rb', line 1021 def valid?(param) param = param.to_sym @config.has_key?(param) end |
#value(param, environment = nil, bypass_interpolation = false) ⇒ Object
Find the correct value using our search path.
1050 1051 1052 1053 |
# File 'lib/puppet/settings.rb', line 1050 def value(param, environment = nil, bypass_interpolation = false) environment &&= environment.to_sym value_sym(param.to_sym, environment, bypass_interpolation) end |
#value_sym(param, environment = nil, bypass_interpolation = false) ⇒ Object
Find the correct value using symbols and our search path.
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 |
# File 'lib/puppet/settings.rb', line 1064 def value_sym(param, environment = nil, bypass_interpolation = false) # Check the cache first. It needs to be a per-environment # cache so that we don't spread values from one env # to another. cached_env = @cache[environment || NONE] # Avoid two lookups in cache_env unless val is nil. When it is, it's important # to check if the key is included so that further processing (that will result # in nil again) is avoided. val = cached_env[param] return val if !val.nil? || cached_env.include?(param) # Short circuit to nil for undefined settings. return nil unless @config.include?(param) vals = values(environment, preferred_run_mode) val = bypass_interpolation ? vals.lookup(param) : vals.interpolate(param) cached_env[param] = val val end |
#values(environment, section) ⇒ Puppet::Settings::ChainedValues
Retrieve an object that can be used for looking up values of configuration settings.
1033 1034 1035 1036 1037 1038 1039 |
# File 'lib/puppet/settings.rb', line 1033 def values(environment, section) @values[environment][section] ||= ChainedValues.new( section, environment, value_sets_for(environment, section), @config) end |
#which_configuration_file ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
this code duplicates Util::RunMode#which_dir as described in #16637
(#15337) All of the logic to determine the configuration file to use
should be centralized into this method. The simplified approach is:
-
If there is an explicit configuration file, use that. (–confdir or –config)
-
If we’re running as a root process, use the system puppet.conf (usually /etc/puppetlabs/puppet/puppet.conf)
-
Otherwise, use the user puppet.conf (usually ~/.puppetlabs/etc/puppet/puppet.conf)
1098 1099 1100 1101 1102 1103 1104 |
# File 'lib/puppet/settings.rb', line 1098 def which_configuration_file if explicit_config_file? or Puppet.features.root? then return main_config_file else return user_config_file end end |