openvox 7.37.1

data/lib/puppet/settings/file_setting.rb

@@ -0,0 +1,241 @@
+# 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
+
+  def initialize(args)
+    @group = Unspecified.new
+    @owner = Unspecified.new
+    super(args)
+  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
+    type = self.type
+    return nil unless 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 || Puppet::FileSystem.exist?(path)
+    return nil if path =~ /^\/dev/ || 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::Util::Platform.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

data/lib/puppet/settings/http_extra_headers_setting.rb

@@ -0,0 +1,25 @@
+class Puppet::Settings::HttpExtraHeadersSetting < Puppet::Settings::BaseSetting
+
+  def type
+    :http_extra_headers
+  end
+
+  def munge(headers)
+    return headers if headers.is_a?(Hash)
+
+    headers = headers.split(/\s*,\s*/) if headers.is_a?(String)
+
+    raise ArgumentError, _("Expected an Array, String, or Hash, got a %{klass}") % { klass: headers.class } unless headers.is_a?(Array)
+
+    headers.map! { |header|
+      case header
+      when String
+        header.split(':')
+      when Array
+        header
+      else
+        raise ArgumentError, _("Expected an Array or String, got a %{klass}") % { klass: header.class }
+      end
+    }
+  end
+end

data/lib/puppet/settings/ini_file.rb

@@ -0,0 +1,226 @@
+# @api private
+class Puppet::Settings::IniFile
+  DEFAULT_SECTION_NAME = "main"
+
+  def self.update(config_fh, &block)
+    config = parse(config_fh)
+    manipulator = Manipulator.new(config)
+    yield manipulator
+    config.write(config_fh)
+  end
+
+  def self.parse(config_fh)
+    config = new([DefaultSection.new])
+    config_fh.each_line do |line|
+      case line.chomp
+      when /^(\s*)\[([[:word:]]+)\](\s*)$/
+        config.append(SectionLine.new($1, $2, $3))
+      when /^(\s*)([[:word:]]+)(\s*=\s*)(.*?)(\s*)$/
+        config.append(SettingLine.new($1, $2, $3, $4, $5))
+      else
+        config.append(Line.new(line))
+      end
+    end
+
+    config
+  end
+
+  def initialize(lines = [])
+    @lines = lines
+  end
+
+  def append(line)
+    line.previous = @lines.last
+    @lines << line
+  end
+
+  def delete(section, name)
+    delete_offset = @lines.index(setting(section, name))
+    next_offset = delete_offset + 1
+    if next_offset < @lines.length
+      @lines[next_offset].previous = @lines[delete_offset].previous
+    end
+    @lines.delete_at(delete_offset)
+  end
+
+  def insert_after(line, new_line)
+    new_line.previous = line
+
+    insertion_point = @lines.index(line)
+    @lines.insert(insertion_point + 1, new_line)
+    if @lines.length > insertion_point + 2
+      @lines[insertion_point + 2].previous = new_line
+    end
+  end
+
+  def section_lines
+    @lines.select { |line| line.is_a?(SectionLine) }
+  end
+
+  def section_line(name)
+    section_lines.find { |section| section.name == name }
+  end
+
+  def setting(section, name)
+    settings_in(lines_in(section)).find do |line|
+      line.name == name
+    end
+  end
+
+  def lines_in(section_name)
+    section_lines = []
+    current_section_name = DEFAULT_SECTION_NAME
+    @lines.each do |line|
+      if line.is_a?(SectionLine)
+        current_section_name = line.name
+      elsif current_section_name == section_name
+        section_lines << line
+      end
+    end
+
+    section_lines
+  end
+
+  def settings_in(lines)
+    lines.select { |line| line.is_a?(SettingLine) }
+  end
+
+  def settings_exist_in_default_section?
+    lines_in(DEFAULT_SECTION_NAME).any? { |line| line.is_a?(SettingLine) }
+  end
+
+  def section_exists_with_default_section_name?
+    section_lines.any? do |section|
+      !section.is_a?(DefaultSection) && section.name == DEFAULT_SECTION_NAME
+    end
+  end
+
+  def set_default_section_write_sectionline(value)
+    index = @lines.find_index { |line| line.is_a?(DefaultSection) }
+    if index
+      @lines[index].write_sectionline = true
+    end
+  end
+
+  def write(fh)
+    # If no real section line for the default section exists, configure the
+    # DefaultSection object to write its section line. (DefaultSection objects
+    # don't write the section line unless explicitly configured to do so)
+    if settings_exist_in_default_section? && !section_exists_with_default_section_name?
+      set_default_section_write_sectionline(true)
+    end
+
+    fh.truncate(0)
+    fh.rewind
+    @lines.each do |line|
+      line.write(fh)
+    end
+    fh.flush
+  end
+
+  class Manipulator
+    def initialize(config)
+      @config = config
+    end
+
+    def set(section, name, value)
+      setting = @config.setting(section, name)
+      if setting
+        setting.value = value
+      else
+        add_setting(section, name, value)
+      end
+    end
+
+    def delete(section_name, name)
+      setting = @config.setting(section_name, name)
+      if setting
+        @config.delete(section_name, name)
+        setting.to_s.chomp
+      end
+    end
+
+    private
+
+    def add_setting(section_name, name, value)
+      section = @config.section_line(section_name)
+      if section.nil?
+        previous_line = SectionLine.new("", section_name, "")
+        @config.append(previous_line)
+      else
+        previous_line = @config.settings_in(@config.lines_in(section_name)).last || section
+      end
+
+      @config.insert_after(previous_line, SettingLine.new("", name, " = ", value, ""))
+    end
+  end
+
+  module LineNumber
+    attr_accessor :previous
+
+    def line_number
+      line = 0
+      previous_line = previous
+      while previous_line
+        line += 1
+        previous_line = previous_line.previous
+      end
+      line
+    end
+  end
+
+  Line = Struct.new(:text) do
+    include LineNumber
+
+    def to_s
+      text
+    end
+
+    def write(fh)
+      fh.puts(to_s)
+    end
+  end
+
+  SettingLine = Struct.new(:prefix, :name, :infix, :value, :suffix) do
+    include LineNumber
+
+    def to_s
+      "#{prefix}#{name}#{infix}#{value}#{suffix}"
+    end
+
+    def write(fh)
+      fh.puts(to_s)
+    end
+
+    def ==(other)
+      super(other) && self.line_number == other.line_number
+    end
+  end
+
+  SectionLine = Struct.new(:prefix, :name, :suffix) do
+    include LineNumber
+
+    def to_s
+      "#{prefix}[#{name}]#{suffix}"
+    end
+
+    def write(fh)
+      fh.puts(to_s)
+    end
+  end
+
+  class DefaultSection < SectionLine
+    attr_accessor :write_sectionline
+
+    def initialize
+      @write_sectionline = false
+      super("", DEFAULT_SECTION_NAME, "")
+    end
+
+    def write(fh)
+      if @write_sectionline
+        super(fh)
+      end
+    end
+  end
+end

data/lib/puppet/settings/integer_setting.rb

@@ -0,0 +1,17 @@
+class Puppet::Settings::IntegerSetting < Puppet::Settings::BaseSetting
+  def munge(value)
+    return value if Integer === value
+
+    begin
+      value = Integer(value)
+    rescue ArgumentError, TypeError
+      raise Puppet::Settings::ValidationError, _("Cannot convert '%{value}' to an integer for parameter: %{name}") % { value: value.inspect, name: @name }
+    end
+
+    value
+  end
+
+  def type
+    :integer
+  end
+end

data/lib/puppet/settings/path_setting.rb

@@ -0,0 +1,8 @@
+class Puppet::Settings::PathSetting < Puppet::Settings::StringSetting
+  def munge(value)
+    if value.is_a?(String)
+      value = value.split(File::PATH_SEPARATOR).map { |d| File.expand_path(d) }.join(File::PATH_SEPARATOR)
+    end
+    value
+  end
+end

data/lib/puppet/settings/port_setting.rb

@@ -0,0 +1,15 @@
+class Puppet::Settings::PortSetting < Puppet::Settings::IntegerSetting
+  def munge(value)
+    value = super
+
+    if value < 0 || value > 65535
+      raise Puppet::Settings::ValidationError, _("Value '%{value}' is not a valid port number for parameter: %{name}") % { value: value.inspect, name: @name }
+    end
+
+    value
+  end
+
+  def type
+    :port
+  end
+end

data/lib/puppet/settings/priority_setting.rb

@@ -0,0 +1,43 @@
+require_relative '../../puppet/settings/base_setting'
+
+# A setting that represents a scheduling priority, and evaluates to an
+# OS-specific priority level.
+class Puppet::Settings::PrioritySetting < Puppet::Settings::BaseSetting
+  PRIORITY_MAP =
+    if Puppet::Util::Platform.windows?
+      require_relative '../../puppet/util/windows/process'
+      require_relative '../../puppet/ffi/windows/constants'
+      {
+        :high    => Puppet::FFI::Windows::Constants::HIGH_PRIORITY_CLASS,
+        :normal  => Puppet::FFI::Windows::Constants::NORMAL_PRIORITY_CLASS,
+        :low     => Puppet::FFI::Windows::Constants::BELOW_NORMAL_PRIORITY_CLASS,
+        :idle    => Puppet::FFI::Windows::Constants::IDLE_PRIORITY_CLASS
+      }
+    else
+      {
+        :high    => -10,
+        :normal  => 0,
+        :low     => 10,
+        :idle    => 19
+      }
+    end
+
+  def type
+    :priority
+  end
+
+  def munge(value)
+    return unless value
+
+    case
+    when value.is_a?(Integer)
+      value
+    when (value.is_a?(String) and value =~ /\d+/)
+      value.to_i
+    when (value.is_a?(String) and PRIORITY_MAP[value.to_sym])
+      PRIORITY_MAP[value.to_sym]
+    else
+      raise Puppet::Settings::ValidationError, _("Invalid priority format '%{value}' for parameter: %{name}") % { value: value.inspect, name: @name }
+    end
+  end
+end

data/lib/puppet/settings/server_list_setting.rb

@@ -0,0 +1,29 @@
+class Puppet::Settings::ServerListSetting < Puppet::Settings::ArraySetting
+
+  def type
+    :server_list
+  end
+
+  def print(value)
+    if value.is_a?(Array)
+      #turn into a string
+      value.map {|item| item.join(":") }.join(",")
+    else
+      value
+    end
+  end
+  
+  def munge(value)
+    servers = super 
+    servers.map! { |server| 
+      case server
+      when String
+        server.split(':')
+      when Array
+        server
+      else
+        raise ArgumentError, _("Expected an Array of String, got a %{klass}") % { klass: value.class }
+      end
+    }
+  end
+end

data/lib/puppet/settings/string_setting.rb

@@ -0,0 +1,9 @@
+class Puppet::Settings::StringSetting < Puppet::Settings::BaseSetting
+  def type
+    :string
+  end
+
+  def validate(value)
+    value.nil? or value.is_a?(String)
+  end
+end

data/lib/puppet/settings/symbolic_enum_setting.rb

@@ -0,0 +1,17 @@
+class Puppet::Settings::SymbolicEnumSetting < Puppet::Settings::BaseSetting
+  attr_accessor :values
+
+  def type
+    :symbolic_enum
+  end
+
+  def munge(value)
+    sym = value.to_sym
+    if values.include?(sym)
+      sym
+    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/terminus_setting.rb

@@ -0,0 +1,14 @@
+class Puppet::Settings::TerminusSetting < Puppet::Settings::BaseSetting
+  def munge(value)
+    case value
+    when '', nil
+      nil
+    when String
+      value.intern
+    when Symbol
+      value
+    else
+      raise Puppet::Settings::ValidationError, _("Invalid terminus setting: %{value}") % { value: value }
+    end
+  end
+end

data/lib/puppet/settings/ttl_setting.rb

@@ -0,0 +1,51 @@
+# A setting that represents a span of time to live, and evaluates to Numeric
+# seconds to live where 0 means shortest possible time to live, a positive numeric value means time
+# to live in seconds, and the symbolic entry 'unlimited' is an infinite amount of time.
+#
+class Puppet::Settings::TTLSetting < 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
+    :ttl
+  end
+
+  # Convert the value to Numeric, parsing numeric string with units if necessary.
+  def munge(value)
+    self.class.munge(value, @name)
+  end
+
+  def print(value)
+    val = munge(value)
+    val == Float::INFINITY ? 'unlimited' : val
+  end
+
+  # Convert the value to Numeric, parsing numeric string with units if necessary.
+  def self.munge(value, param_name)
+    case
+    when value.is_a?(Numeric)
+      if value < 0
+        raise Puppet::Settings::ValidationError, _("Invalid negative 'time to live' %{value} - did you mean 'unlimited'?") % { value: value.inspect }
+      end
+      value
+
+    when value == 'unlimited'
+      Float::INFINITY
+
+    when (value.is_a?(String) and value =~ FORMAT)
+      $1.to_i * UNITMAP[$2 || 's']
+    else
+      raise Puppet::Settings::ValidationError, _("Invalid 'time to live' format '%{value}' for parameter: %{param_name}") % { value: value.inspect, param_name: param_name }
+    end
+  end
+end