bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/settings/directory_setting.rb

@@ -1,18 +0,0 @@
-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/vendored/puppet/lib/puppet/settings/duration_setting.rb

@@ -1,32 +0,0 @@
-# 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)
-    case
-    when value.is_a?(Integer) || value.nil?
-      value
-    when (value.is_a?(String) and value =~ FORMAT)
-      $1.to_i * UNITMAP[$2 || 's']
-    else
-      raise Puppet::Settings::ValidationError, _("Invalid duration format '%{value}' for parameter: %{name}") % { value: value.inspect, name: @name }
-    end
-  end
-end

data/vendored/puppet/lib/puppet/settings/enum_setting.rb

@@ -1,16 +0,0 @@
-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/vendored/puppet/lib/puppet/settings/environment_conf.rb

@@ -1,213 +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, :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
-    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.kind_of?(String) ?
-        modulepath.split(File::PATH_SEPARATOR) :
-        modulepath
-      path.map { |p| absolute(p) }.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
-    if !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
-
-    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
-      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/vendored/puppet/lib/puppet/settings/errors.rb

@@ -1,11 +0,0 @@
-# Exceptions for the settings module
-require '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/vendored/puppet/lib/puppet/settings/file_or_directory_setting.rb

@@ -1,40 +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
-  #
-  # @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

data/vendored/puppet/lib/puppet/settings/file_setting.rb

@@ -1,245 +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") % { name: name }
-      end
-    }
-  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 exclusive_open(option = 'r', &block)
-    controlled_access do |mode|
-      Puppet::FileSystem.exclusive_open(file(), mode, option, &block)
-    end
-  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(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}'") % { parameter: parameter, name: name, value: 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