puppet-retrospec 1.5.0 → 1.6.0

data/vendor/gems/puppet-4.5.2/lib/puppet/settings/config_file.rb

@@ -1,142 +0,0 @@
-require '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
-    if !allowed_section_names.empty?
-      allowed_section_names << 'main' unless allowed_section_names.include?('main')
-    end
-
-    ini = Puppet::Settings::IniFile.parse(StringIO.new(text))
-    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 #{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)
-        raise(Puppet::Error, "Illegal section '#{section.name}' in config file #{file} at line #{section.line_number}. The only valid puppet.conf sections are: [#{allowed_section_names.join(", ")}]. Please use the directory environments feature to specify environments. (See https://docs.puppet.com/puppet/latest/reference/environments.html)")
-      end
-      section.name
-    end.uniq
-  end
-
-  def parse_setting(setting, section)
-    var = setting.name.intern
-
-    # We don't want to munge modes, because they're specified in octal, so we'll
-    # just leave them as a String, since Puppet handles that case correctly.
-    if var == :mode
-      value = setting.value
-    else
-      value = @value_converter[setting.value]
-    end
-
-    # Check to see if this is a file argument and it has extra options
-    begin
-      if value.is_a?(String) and options = extract_fileinfo(value)
-        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 = $1
-      params.split(/\s*,\s*/).each do |str|
-        if str =~ /^\s*(\w+)\s*=\s*([\w\d]+)\s*$/
-          param, value = $1.intern, $2
-          result[param] = value
-          raise ArgumentError, "Invalid file option '#{param}'" unless [:owner, :mode, :group].include?(param)
-
-          if param == :mode and value !~ /^\d+$/
-            raise ArgumentError, "File modes must be numbers"
-          end
-        else
-          raise ArgumentError, "Could not parse '#{string}'"
-        end
-      end
-      ''
-    end
-    result[:value] = value.sub(/\s*$/, '')
-    result
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/settings/directory_setting.rb

@@ -1,12 +0,0 @@
-class Puppet::Settings::DirectorySetting < Puppet::Settings::FileSetting
-  def type
-    :directory
-  end
-
-  # @api private
-  def open_file(filename, option = 'r', &block)
-    controlled_access do |mode|
-      Puppet::FileSystem.open(filename, mode, option, &block)
-    end
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/settings/environment_conf.rb

@@ -1,192 +0,0 @@
-# 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]).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')
-    config = nil
-
-    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
-    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)
-    Static.new(environment, environment_timeout, static_catalogs)
-  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
-        errmsg = ["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_manifest}' which does not match",
-        "the default_manifest setting '#{puppet_conf_manifest}'. If this",
-        "environment is expecting to find modules in",
-        "'#{environment_conf_manifest}', they will not be available!"]
-        Puppet.err(errmsg.join(' '))
-      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.kind_of?(String) ?
-        modulepath.split(File::PATH_SEPARATOR) :
-        modulepath
-      path.map { |p| absolute(p) }.join(File::PATH_SEPARATOR)
-    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
-      Puppet.warning("Invalid sections in environment.conf at '#{path_to_conf_file}'. Environment conf may not have sections. The following sections are being ignored: '#{(section_keys - [:main]).join(',')}'")
-      valid = false
-    end
-
-    extraneous_settings = main.settings.map(&:name) - VALID_SETTINGS
-    if !extraneous_settings.empty?
-      Puppet.warning("Invalid settings in environment.conf at '#{path_to_conf_file}'. The following unknown setting(s) are being ignored: #{extraneous_settings.join(', ')}")
-      valid = false
-    end
-
-    return valid
-  end
-
-  def get_setting(setting_name, default = nil)
-    value = raw_setting(setting_name)
-    value = default if value.nil?
-    yield value
-  end
-
-  def absolute(path)
-    return nil if path.nil?
-    if path =~ /^\$/
-      # Path begins with $something interpolatable
-      path
-    else
-      File.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 :static_catalogs
-
-    def initialize(environment, environment_timeout, static_catalogs, environment_data_provider = 'none')
-      @environment = environment
-      @environment_timeout = environment_timeout
-      @static_catalogs = static_catalogs
-      @environment_data_provider = environment_data_provider
-    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/vendor/gems/puppet-4.5.2/lib/puppet/settings/file_or_directory_setting.rb

@@ -1,34 +0,0 @@
-class Puppet::Settings::FileOrDirectorySetting < Puppet::Settings::FileSetting
-
-  def initialize(args)
-    super
-  end
-
-  def type
-    if Puppet::FileSystem.directory?(self.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 =~ /[\\\/]$/
-      @path_ends_with_slash = true
-    end
-    super
-  end
-
-  # @api private
-  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

data/vendor/gems/puppet-4.5.2/lib/puppet/settings/file_setting.rb

@@ -1,235 +0,0 @@
-# A file.
-class Puppet::Settings::FileSetting < Puppet::Settings::StringSetting
-  class SettingError < StandardError; end
-
-  # An unspecified user or group
-  #
-  # @api private
-  class Unspecified
-    def value
-      nil
-    end
-  end
-
-  # A "root" user or group
-  #
-  # @api private
-  class Root
-    def value
-      "root"
-    end
-  end
-
-  # A "service" user or group that picks up values from settings when the
-  # referenced user or group is safe to use (it exists or will be created), and
-  # uses the given fallback value when not safe.
-  #
-  # @api private
-  class Service
-    # @param name [Symbol] the name of the setting to use as the service value
-    # @param fallback [String, nil] the value to use when the service value cannot be used
-    # @param settings [Puppet::Settings] the puppet settings object
-    # @param available_method [Symbol] the name of the method to call on
-    #   settings to determine if the value in settings is available on the system
-    #
-    def initialize(name, fallback, settings, available_method)
-      @settings = settings
-      @available_method = available_method
-      @name = name
-      @fallback = fallback
-    end
-
-    def value
-      if safe_to_use_settings_value?
-        @settings[@name]
-      else
-        @fallback
-      end
-    end
-
-  private
-    def safe_to_use_settings_value?
-      @settings[:mkusers] or @settings.send(@available_method)
-    end
-  end
-
-  attr_accessor :mode, :create
-
-  def initialize(args)
-    @group = Unspecified.new
-    @owner = Unspecified.new
-    super(args)
-  end
-
-  # Should we create files, rather than just directories?
-  def create_files?
-    create
-  end
-
-  # @param value [String] the group to use on the created file (can only be "root" or "service")
-  # @api public
-  def group=(value)
-    @group = case value
-             when "root"
-               Root.new
-             when "service"
-               # Group falls back to `nil` because we cannot assume that a "root" group exists.
-               # Some systems have root group, others have wheel, others have something else.
-               Service.new(:group, nil, @settings, :service_group_available?)
-             else
-               unknown_value(':group', value)
-             end
-  end
-
-  # @param value [String] the owner to use on the created file (can only be "root" or "service")
-  # @api public
-  def owner=(value)
-    @owner = case value
-             when "root"
-               Root.new
-             when "service"
-               Service.new(:user, "root", @settings, :service_user_available?)
-             else
-               unknown_value(':owner', value)
-             end
-  end
-
-  # @return [String, nil] the name of the group to use for the file or nil if the group should not be managed
-  # @api public
-  def group
-    @group.value
-  end
-
-  # @return [String, nil] the name of the user to use for the file or nil if the user should not be managed
-  # @api public
-  def owner
-    @owner.value
-  end
-
-  def set_meta(meta)
-    self.owner = meta.owner if meta.owner
-    self.group = meta.group if meta.group
-    self.mode = meta.mode if meta.mode
-  end
-
-  def munge(value)
-    if value.is_a?(String) and value != ':memory:' # for sqlite3 in-memory tests
-      value = File.expand_path(value)
-    end
-    value
-  end
-
-  def type
-    :file
-  end
-
-  # Turn our setting thing into a Puppet::Resource instance.
-  def to_resource
-    return nil unless type = self.type
-
-    path = self.value
-
-    return nil unless path.is_a?(String)
-
-    # Make sure the paths are fully qualified.
-    path = File.expand_path(path)
-
-    return nil unless type == :directory or create_files? or Puppet::FileSystem.exist?(path)
-    return nil if path =~ /^\/dev/ or path =~ /^[A-Z]:\/dev/i
-
-    resource = Puppet::Resource.new(:file, path)
-
-    if Puppet[:manage_internal_file_permissions]
-      if self.mode
-        # This ends up mimicking the munge method of the mode
-        # parameter to make sure that we're always passing the string
-        # version of the octal number.  If we were setting the
-        # 'should' value for mode rather than the 'is', then the munge
-        # method would be called for us automatically.  Normally, one
-        # wouldn't need to call the munge method manually, since
-        # 'should' gets set by the provider and it should be able to
-        # provide the data in the appropriate format.
-        mode = self.mode
-        mode = mode.to_i(8) if mode.is_a?(String)
-        mode = mode.to_s(8)
-        resource[:mode] = mode
-      end
-
-      # REMIND fails on Windows because chown/chgrp functionality not supported yet
-      if Puppet.features.root? and !Puppet.features.microsoft_windows?
-        resource[:owner] = self.owner if self.owner
-        resource[:group] = self.group if self.group
-      end
-    end
-
-    resource[:ensure] = type
-    resource[:loglevel] = :debug
-    resource[:links] = :follow
-    resource[:backup] = false
-
-    resource.tag(self.section, self.name, "settings")
-
-    resource
-  end
-
-  # Make sure any provided variables look up to something.
-  def validate(value)
-    return true unless value.is_a? String
-    value.scan(/\$(\w+)/) { |name|
-      name = $1
-      unless @settings.include?(name)
-        raise ArgumentError,
-          "Settings parameter '#{name}' is undefined"
-      end
-    }
-  end
-
-  # @api private
-  def exclusive_open(option = 'r', &block)
-    controlled_access do |mode|
-      Puppet::FileSystem.exclusive_open(file(), mode, option, &block)
-    end
-  end
-
-  # @api private
-  def open(option = 'r', &block)
-    controlled_access do |mode|
-      Puppet::FileSystem.open(file, mode, option, &block)
-    end
-  end
-
-  private
-
-  def file
-    Puppet::FileSystem.pathname(value)
-  end
-
-  def unknown_value(parameter, value)
-    raise SettingError, "The #{parameter} parameter for the setting '#{name}' must be either 'root' or 'service', not '#{value}'"
-  end
-
-  def controlled_access(&block)
-    chown = nil
-    if Puppet.features.root?
-      chown = [owner, group]
-    else
-      chown = [nil, nil]
-    end
-
-    Puppet::Util::SUIDManager.asuser(*chown) do
-      # Update the umask to make non-executable files
-      Puppet::Util.withumask(File.umask ^ 0111) do
-        yielded_value = case self.mode
-                        when String
-                          self.mode.to_i(8)
-                        when NilClass
-                          0640
-                        else
-                          self.mode
-                        end
-
-        yield yielded_value
-      end
-    end
-  end
-end