openvox 8.19.0

data/lib/puppet/settings/config_file.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/settings/ini_file'
+
+##
+# @api private
+#
+# Parses puppet configuration files
+#
+class Puppet::Settings::ConfigFile
+  ##
+  # @param value_converter [Proc] a function that will convert strings into ruby types
+  def initialize(value_converter)
+    @value_converter = value_converter
+  end
+
+  # @param file [String, File] pointer to the file whose text we are parsing
+  # @param text [String] the actual text of the inifile to be parsed
+  # @param allowed_section_names [Array] an optional array of accepted section
+  #   names; if this list is non-empty, sections outside of it will raise an
+  #   error.
+  # @return A Struct with a +sections+ array representing each configuration section
+  def parse_file(file, text, allowed_section_names = [])
+    result = Conf.new
+    unless allowed_section_names.empty?
+      allowed_section_names << 'main' unless allowed_section_names.include?('main')
+    end
+
+    ini = Puppet::Settings::IniFile.parse(text.encode(Encoding::UTF_8))
+    unique_sections_in(ini, file, allowed_section_names).each do |section_name|
+      section = Section.new(section_name.to_sym)
+      result.with_section(section)
+
+      ini.lines_in(section_name).each do |line|
+        if line.is_a?(Puppet::Settings::IniFile::SettingLine)
+          parse_setting(line, section)
+        elsif line.text !~ /^\s*#|^\s*$/
+          raise Puppet::Settings::ParseError.new(_("Could not match line %{text}") % { text: line.text }, file, line.line_number)
+        end
+      end
+    end
+
+    result
+  end
+
+  Conf = Struct.new(:sections) do
+    def initialize
+      super({})
+    end
+
+    def with_section(section)
+      sections[section.name] = section
+      self
+    end
+  end
+
+  Section = Struct.new(:name, :settings) do
+    def initialize(name)
+      super(name, [])
+    end
+
+    def with_setting(name, value, meta)
+      settings << Setting.new(name, value, meta)
+      self
+    end
+
+    def setting(name)
+      settings.find { |setting| setting.name == name }
+    end
+  end
+
+  Setting = Struct.new(:name, :value, :meta) do
+    def has_metadata?
+      meta != NO_META
+    end
+  end
+
+  Meta = Struct.new(:owner, :group, :mode)
+  NO_META = Meta.new(nil, nil, nil)
+
+  private
+
+  def unique_sections_in(ini, file, allowed_section_names)
+    ini.section_lines.collect do |section|
+      if !allowed_section_names.empty? && !allowed_section_names.include?(section.name)
+        error_location_str = Puppet::Util::Errors.error_location(file, section.line_number)
+        message = _("Illegal section '%{name}' in config file at %{error_location}.") %
+                  { name: section.name, error_location: error_location_str }
+        # TRANSLATORS 'puppet.conf' is the name of the puppet configuration file and should not be translated.
+        message += ' ' + _("The only valid puppet.conf sections are: [%{allowed_sections_list}].") %
+                         { allowed_sections_list: allowed_section_names.join(", ") }
+        message += ' ' + _("Please use the directory environments feature to specify environments.")
+        message += ' ' + _("(See https://puppet.com/docs/puppet/latest/environments_about.html)")
+        raise(Puppet::Error, message)
+      end
+      section.name
+    end.uniq
+  end
+
+  def parse_setting(setting, section)
+    var = setting.name.intern
+    value = @value_converter[setting.value]
+
+    # Check to see if this is a file argument and it has extra options
+    begin
+      options = extract_fileinfo(value) if value.is_a?(String)
+      if options
+        section.with_setting(var, options[:value], Meta.new(options[:owner],
+                                                            options[:group],
+                                                            options[:mode]))
+      else
+        section.with_setting(var, value, NO_META)
+      end
+    rescue Puppet::Error => detail
+      raise Puppet::Settings::ParseError.new(detail.message, file, setting.line_number, detail)
+    end
+  end
+
+  def empty_section
+    { :_meta => {} }
+  end
+
+  def extract_fileinfo(string)
+    result = {}
+    value = string.sub(/\{\s*([^}]+)\s*\}/) do
+      params = ::Regexp.last_match(1)
+      params.split(/\s*,\s*/).each do |str|
+        if str =~ /^\s*(\w+)\s*=\s*(\w+)\s*$/
+          param = ::Regexp.last_match(1).intern
+          value = ::Regexp.last_match(2)
+          result[param] = value
+          unless [:owner, :mode, :group].include?(param)
+            raise ArgumentError, _("Invalid file option '%{parameter}'") % { parameter: param }
+          end
+
+          if param == :mode and value !~ /^\d+$/
+            raise ArgumentError, _("File modes must be numbers")
+          end
+        else
+          raise ArgumentError, _("Could not parse '%{string}'") % { string: string }
+        end
+      end
+      ''
+    end
+    result[:value] = value.sub(/\s*$/, '')
+    result
+  end
+end

data/lib/puppet/settings/directory_setting.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Puppet::Settings::DirectorySetting < Puppet::Settings::FileSetting
+  def type
+    :directory
+  end
+
+  # @api private
+  #
+  # @param option [String] Extra file operation mode information to use
+  #   (defaults to read-only mode 'r')
+  #   This is the standard mechanism Ruby uses in the IO class, and therefore
+  #   encoding may be explicitly like fmode : encoding or fmode : "BOM|UTF-*"
+  #   for example, a:ASCII or w+:UTF-8
+  def open_file(filename, option = 'r', &block)
+    controlled_access do |mode|
+      Puppet::FileSystem.open(filename, mode, option, &block)
+    end
+  end
+end

data/lib/puppet/settings/duration_setting.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# A setting that represents a span of time, and evaluates to an integer
+# number of seconds after being parsed
+class Puppet::Settings::DurationSetting < Puppet::Settings::BaseSetting
+  # How we convert from various units to seconds.
+  UNITMAP = {
+    # 365 days isn't technically a year, but is sufficient for most purposes
+    "y" => 365 * 24 * 60 * 60,
+    "d" => 24 * 60 * 60,
+    "h" => 60 * 60,
+    "m" => 60,
+    "s" => 1
+  }
+
+  # A regex describing valid formats with groups for capturing the value and units
+  FORMAT = /^(\d+)(y|d|h|m|s)?$/
+
+  def type
+    :duration
+  end
+
+  # Convert the value to an integer, parsing numeric string with units if necessary.
+  def munge(value)
+    if value.is_a?(Integer) || value.nil?
+      value
+    elsif value.is_a?(String) and value =~ FORMAT
+      ::Regexp.last_match(1).to_i * UNITMAP[::Regexp.last_match(2) || 's']
+    else
+      raise Puppet::Settings::ValidationError, _("Invalid duration format '%{value}' for parameter: %{name}") % { value: value.inspect, name: @name }
+    end
+  end
+end

data/lib/puppet/settings/enum_setting.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Puppet::Settings::EnumSetting < Puppet::Settings::BaseSetting
+  attr_accessor :values
+
+  def type
+    :enum
+  end
+
+  def munge(value)
+    if values.include?(value)
+      value
+    else
+      raise Puppet::Settings::ValidationError,
+            _("Invalid value '%{value}' for parameter %{name}. Allowed values are '%{allowed_values}'") % { value: value, name: @name, allowed_values: values.join("', '") }
+    end
+  end
+end

data/lib/puppet/settings/environment_conf.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+# Configuration settings for a single directory Environment.
+# @api private
+class Puppet::Settings::EnvironmentConf
+  ENVIRONMENT_CONF_ONLY_SETTINGS = [:modulepath, :manifest, :config_version].freeze
+  VALID_SETTINGS = (ENVIRONMENT_CONF_ONLY_SETTINGS + [:environment_timeout, :environment_data_provider, :static_catalogs, :rich_data]).freeze
+
+  # Given a path to a directory environment, attempts to load and parse an
+  # environment.conf in ini format, and return an EnvironmentConf instance.
+  #
+  # An environment.conf is optional, so if the file itself is missing, or
+  # empty, an EnvironmentConf with default values will be returned.
+  #
+  # @note logs warnings if the environment.conf contains any ini sections,
+  # or has settings other than the three handled for directory environments
+  # (:manifest, :modulepath, :config_version)
+  #
+  # @param path_to_env [String] path to the directory environment
+  # @param global_module_path [Array<String>] the installation's base modulepath
+  #   setting, appended to default environment modulepaths
+  # @return [EnvironmentConf] the parsed EnvironmentConf object
+  def self.load_from(path_to_env, global_module_path)
+    path_to_env = File.expand_path(path_to_env)
+    conf_file = File.join(path_to_env, 'environment.conf')
+
+    begin
+      config = Puppet.settings.parse_file(conf_file)
+      validate(conf_file, config)
+      section = config.sections[:main]
+    rescue Errno::ENOENT
+      # environment.conf is an optional file
+      Puppet.debug { "Path to #{path_to_env} does not exist, using default environment.conf" }
+    end
+
+    new(path_to_env, section, global_module_path)
+  end
+
+  # Provides a configuration object tied directly to the passed environment.
+  # Configuration values are exactly those returned by the environment object,
+  # without interpolation.  This is a special case for the default configured
+  # environment returned by the Puppet::Environments::StaticPrivate loader.
+  def self.static_for(environment, environment_timeout = 0, static_catalogs = false, rich_data = false)
+    Static.new(environment, environment_timeout, static_catalogs, nil, rich_data)
+  end
+
+  attr_reader :section, :path_to_env, :global_modulepath
+
+  # Create through EnvironmentConf.load_from()
+  def initialize(path_to_env, section, global_module_path)
+    @path_to_env = path_to_env
+    @section = section
+    @global_module_path = global_module_path
+  end
+
+  def manifest
+    puppet_conf_manifest = Pathname.new(Puppet.settings.value(:default_manifest))
+    disable_per_environment_manifest = Puppet.settings.value(:disable_per_environment_manifest)
+
+    fallback_manifest_directory =
+      if puppet_conf_manifest.absolute?
+        puppet_conf_manifest.to_s
+      else
+        File.join(@path_to_env, puppet_conf_manifest.to_s)
+      end
+
+    if disable_per_environment_manifest
+      environment_conf_manifest = absolute(raw_setting(:manifest))
+      if environment_conf_manifest && fallback_manifest_directory != environment_conf_manifest
+        # TRANSLATORS 'disable_per_environment_manifest' is a setting and 'environment.conf' is a file name and should not be translated
+        message = _("The 'disable_per_environment_manifest' setting is true, but the environment located at %{path_to_env} has a manifest setting in its environment.conf of '%{environment_conf}' which does not match the default_manifest setting '%{puppet_conf}'.") %
+                  { path_to_env: @path_to_env, environment_conf: environment_conf_manifest, puppet_conf: puppet_conf_manifest }
+        message += ' ' + _("If this environment is expecting to find modules in '%{environment_conf}', they will not be available!") % { environment_conf: environment_conf_manifest }
+        Puppet.err(message)
+      end
+      fallback_manifest_directory.to_s
+    else
+      get_setting(:manifest, fallback_manifest_directory) do |manifest|
+        absolute(manifest)
+      end
+    end
+  end
+
+  def environment_timeout
+    # gen env specific config or use the default value
+    get_setting(:environment_timeout, Puppet.settings.value(:environment_timeout)) do |ttl|
+      # munges the string form statically without really needed the settings system, only
+      # its ability to munge "4s, 3m, 5d, and 'unlimited' into seconds - if already munged into
+      # numeric form, the TTLSetting handles that.
+      Puppet::Settings::TTLSetting.munge(ttl, 'environment_timeout')
+    end
+  end
+
+  def environment_data_provider
+    get_setting(:environment_data_provider, Puppet.settings.value(:environment_data_provider)) do |value|
+      value
+    end
+  end
+
+  def modulepath
+    default_modulepath = [File.join(@path_to_env, "modules")] + @global_module_path
+    get_setting(:modulepath, default_modulepath) do |modulepath|
+      path = modulepath.is_a?(String) ?
+        modulepath.split(File::PATH_SEPARATOR) :
+        modulepath
+      path.map { |p| expand_glob(absolute(p)) }.flatten.join(File::PATH_SEPARATOR)
+    end
+  end
+
+  def rich_data
+    get_setting(:rich_data, Puppet.settings.value(:rich_data)) do |value|
+      value
+    end
+  end
+
+  def static_catalogs
+    get_setting(:static_catalogs, Puppet.settings.value(:static_catalogs)) do |value|
+      value
+    end
+  end
+
+  def config_version
+    get_setting(:config_version) do |config_version|
+      absolute(config_version)
+    end
+  end
+
+  def raw_setting(setting_name)
+    setting = section.setting(setting_name) if section
+    setting.value if setting
+  end
+
+  private
+
+  def self.validate(path_to_conf_file, config)
+    valid = true
+    section_keys = config.sections.keys
+    main = config.sections[:main]
+    if section_keys.size > 1
+      # warn once per config file path
+      Puppet.warn_once(
+        :invalid_settings_section, "EnvironmentConf-section:#{path_to_conf_file}",
+        _("Invalid sections in environment.conf at '%{path_to_conf_file}'. Environment conf may not have sections. The following sections are being ignored: '%{sections}'") % {
+          path_to_conf_file: path_to_conf_file,
+          sections: (section_keys - [:main]).join(',')
+        }
+      )
+      valid = false
+    end
+
+    extraneous_settings = main.settings.map(&:name) - VALID_SETTINGS
+    unless extraneous_settings.empty?
+      # warn once per config file path
+      Puppet.warn_once(
+        :invalid_settings, "EnvironmentConf-settings:#{path_to_conf_file}",
+        _("Invalid settings in environment.conf at '%{path_to_conf_file}'. The following unknown setting(s) are being ignored: %{ignored_settings}") % {
+          path_to_conf_file: path_to_conf_file,
+          ignored_settings: extraneous_settings.join(', ')
+        }
+      )
+      valid = false
+    end
+
+    valid
+  end
+  private_class_method :validate
+
+  def get_setting(setting_name, default = nil)
+    value = raw_setting(setting_name)
+    value = default if value.nil?
+    yield value
+  end
+
+  def expand_glob(path)
+    return nil if path.nil?
+
+    if path =~ /[*?\[{]/
+      Dir.glob(path)
+    else
+      path
+    end
+  end
+
+  def absolute(path)
+    return nil if path.nil?
+
+    if path =~ /^\$/
+      # Path begins with $something interpolatable
+      path
+    else
+      Puppet::FileSystem.expand_path(path, @path_to_env)
+    end
+  end
+
+  # Models configuration for an environment that is not loaded from a directory.
+  #
+  # @api private
+  class Static
+    attr_reader :environment_timeout
+    attr_reader :environment_data_provider
+    attr_reader :rich_data
+    attr_reader :static_catalogs
+
+    def initialize(environment, environment_timeout, static_catalogs, environment_data_provider = nil, rich_data = false)
+      @environment = environment
+      @environment_timeout = environment_timeout
+      @static_catalogs = static_catalogs
+      @environment_data_provider = environment_data_provider
+      @rich_data = rich_data
+    end
+
+    def path_to_env
+      nil
+    end
+
+    def manifest
+      @environment.manifest
+    end
+
+    def modulepath
+      @environment.modulepath.join(File::PATH_SEPARATOR)
+    end
+
+    def config_version
+      @environment.config_version
+    end
+  end
+end

data/lib/puppet/settings/errors.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Exceptions for the settings module
+require_relative '../../puppet/error'
+
+class Puppet::Settings
+  class SettingsError < Puppet::Error; end
+  class ValidationError < SettingsError; end
+  class InterpolationError < SettingsError; end
+
+  class ParseError < SettingsError
+    include Puppet::ExternalFileError
+  end
+end

data/lib/puppet/settings/file_or_directory_setting.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Puppet::Settings::FileOrDirectorySetting < Puppet::Settings::FileSetting
+  def type
+    if Puppet::FileSystem.directory?(value) || @path_ends_with_slash
+      :directory
+    else
+      :file
+    end
+  end
+
+  # Overrides munge to be able to read the un-munged value (the FileSetting.munch removes trailing slash)
+  #
+  def munge(value)
+    if value.is_a?(String) && value =~ %r{[\\/]$}
+      @path_ends_with_slash = true
+    end
+    super
+  end
+
+  # @api private
+  #
+  # @param option [String] Extra file operation mode information to use
+  #   (defaults to read-only mode 'r')
+  #   This is the standard mechanism Ruby uses in the IO class, and therefore
+  #   encoding may be explicitly like fmode : encoding or fmode : "BOM|UTF-*"
+  #   for example, a:ASCII or w+:UTF-8
+  def open_file(filename, option = 'r', &block)
+    if type == :file
+      super
+    else
+      controlled_access do |mode|
+        Puppet::FileSystem.open(filename, mode, option, &block)
+      end
+    end
+  end
+end