bolt 0.0.1 → 0.5.0

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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,204 @@
+# 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')
+    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, 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
+        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 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
+      Puppet.warning(_("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?
+      Puppet.warning(_("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

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

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

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