openvox 8.19.0

data/lib/puppet/util/instance_loader.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/util/autoload'
+require_relative '../../puppet/util'
+require_relative '../../puppet/concurrent/lock'
+
+# A module that can easily autoload things for us.  Uses an instance
+# of Puppet::Util::Autoload
+module Puppet::Util::InstanceLoader
+  include Puppet::Util
+
+  # Are we instance-loading this type?
+  def instance_loading?(type)
+    defined?(@autoloaders) and @autoloaders.include?(type.intern)
+  end
+
+  # Define a new type of autoloading.
+  def instance_load(type, path)
+    @autoloaders ||= {}
+    @instances ||= {}
+    type = type.intern
+    @instances[type] = {}
+    @autoloaders[type] = Puppet::Util::Autoload.new(self, path)
+    @instance_loader_lock = Puppet::Concurrent::Lock.new
+
+    # Now define our new simple methods
+    unless respond_to?(type)
+      meta_def(type) do |name|
+        loaded_instance(type, name)
+      end
+    end
+  end
+
+  # Return a list of the names of all instances
+  def loaded_instances(type)
+    @instances[type].keys
+  end
+
+  # Return the instance hash for our type.
+  def instance_hash(type)
+    @instances[type.intern]
+  end
+
+  # Return the Autoload object for a given type.
+  def instance_loader(type)
+    @autoloaders[type.intern]
+  end
+
+  # Retrieve an already-loaded instance, or attempt to load our instance.
+  def loaded_instance(type, name)
+    @instance_loader_lock.synchronize do
+      name = name.intern
+      instances = instance_hash(type)
+      return nil unless instances
+
+      unless instances.include? name
+        if instance_loader(type).load(name, Puppet.lookup(:current_environment))
+          unless instances.include? name
+            Puppet.warning(_("Loaded %{type} file for %{name} but %{type} was not defined") % { type: type, name: name })
+            return nil
+          end
+        else
+          return nil
+        end
+      end
+      instances[name]
+    end
+  end
+end

data/lib/puppet/util/json.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Puppet::Util
+  module Json
+    class ParseError < StandardError
+      attr_reader :cause, :data
+
+      def self.build(original_exception, data)
+        new(original_exception.message).tap do |exception|
+          exception.instance_eval do
+            @cause = original_exception
+            set_backtrace original_exception.backtrace
+            @data = data
+          end
+        end
+      end
+    end
+
+    begin
+      require 'multi_json'
+      # Force backend detection before attempting to use the library
+      # or load any other JSON libraries
+      MultiJson.default_adapter
+
+      # Preserve core type monkey-patching done by the built-in JSON gem
+      require 'json'
+    rescue LoadError
+      require 'json'
+    end
+
+    # Load the content from a file as JSON if
+    # contents are in valid format. This method does not
+    # raise error but returns `nil` when invalid file is
+    # given.
+    def self.load_file_if_valid(filename, options = {})
+      load_file(filename, options)
+    rescue Puppet::Util::Json::ParseError, ArgumentError, Errno::ENOENT => detail
+      Puppet.debug("Could not retrieve JSON content from '#{filename}': #{detail.message}")
+      nil
+    end
+
+    # Load the content from a file as JSON.
+    def self.load_file(filename, options = {})
+      json = Puppet::FileSystem.read(filename, :encoding => 'utf-8')
+      load(json, options)
+    end
+
+    # These methods do similar processing to the fallback implemented by MultiJson
+    # when using the built-in JSON backend, to ensure consistent behavior
+    # whether or not MultiJson can be loaded.
+    def self.load(string, options = {})
+      if defined? MultiJson
+        begin
+          # This ensures that JrJackson and Oj will parse very large or very small
+          # numbers as floats rather than BigDecimals, which are serialized as
+          # strings by the built-in JSON gem and therefore can cause schema errors,
+          # for example, when we are rendering reports to JSON using `to_pson` in
+          # PuppetDB.
+          case MultiJson.adapter.name
+          when "MultiJson::Adapters::JrJackson"
+            options[:use_bigdecimal] = false
+          when "MultiJson::Adapters::Oj"
+            options[:bigdecimal_load] = :float
+          end
+
+          MultiJson.load(string, options)
+        rescue MultiJson::ParseError => e
+          raise Puppet::Util::Json::ParseError.build(e, string)
+        end
+      else
+        begin
+          string = string.read if string.respond_to?(:read)
+
+          options[:symbolize_names] = true if options.delete(:symbolize_keys)
+          ::JSON.parse(string, options)
+        rescue JSON::ParserError => e
+          raise Puppet::Util::Json::ParseError.build(e, string)
+        end
+      end
+    end
+
+    def self.dump(object, options = {})
+      if defined? MultiJson
+        MultiJson.dump(object, options)
+      elsif options.is_a?(JSON::State)
+        # we're being called recursively
+        object.to_json(options)
+      else
+        options.merge!(::JSON::PRETTY_STATE_PROTOTYPE.to_h) if options.delete(:pretty)
+        object.to_json(options)
+      end
+    end
+  end
+end

data/lib/puppet/util/json_lockfile.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/util/lockfile'
+
+# This class provides a simple API for managing a lock file
+# whose contents are a serialized JSON object.  In addition
+# to querying the basic state (#locked?) of the lock, managing
+# the lock (#lock, #unlock), the contents can be retrieved at
+# any time while the lock is held (#lock_data).  This can be
+# used to store structured data (state messages, etc.) about
+# the lock.
+#
+# @see Puppet::Util::Lockfile
+class Puppet::Util::JsonLockfile < Puppet::Util::Lockfile
+  # Lock the lockfile.  You may optionally pass a data object, which will be
+  # retrievable for the duration of time during which the file is locked.
+  #
+  # @param [Hash] lock_data an optional Hash of data to associate with the lock.
+  #   This may be used to store pids, descriptive messages, etc.  The
+  #   data may be retrieved at any time while the lock is held by
+  #   calling the #lock_data method. <b>NOTE</b> that the JSON serialization
+  #   does NOT support Symbol objects--if you pass them in, they will be
+  #   serialized as Strings, so you should plan accordingly.
+  # @return [boolean] true if lock is successfully acquired, false otherwise.
+  def lock(lock_data = nil)
+    return false if locked?
+
+    super(Puppet::Util::Json.dump(lock_data))
+  end
+
+  # Retrieve the (optional) lock data that was specified at the time the file
+  #  was locked.
+  # @return [Object] the data object.  Remember that the serialization does not
+  #  support Symbol objects, so if your data Object originally contained symbols,
+  #  they will be converted to Strings.
+  def lock_data
+    return nil unless file_locked?
+
+    file_contents = super
+    return nil if file_contents.nil? or file_contents.empty?
+
+    Puppet::Util::Json.load(file_contents)
+  rescue Puppet::Util::Json::ParseError
+    Puppet.warning _("Unable to read lockfile data from %{path}: not in JSON") % { path: @file_path }
+    nil
+  end
+end

data/lib/puppet/util/ldap/connection.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/util/ldap'
+
+class Puppet::Util::Ldap::Connection
+  attr_accessor :host, :port, :user, :password, :reset, :ssl
+
+  attr_reader :connection
+
+  # Return a default connection, using our default settings.
+  def self.instance
+    ssl = if Puppet[:ldaptls]
+            :tls
+          elsif Puppet[:ldapssl]
+            true
+          else
+            false
+          end
+
+    options = {}
+    options[:ssl] = ssl
+    user = Puppet.settings[:ldapuser]
+    if user && user != ""
+      options[:user] = user
+      pass = Puppet.settings[:ldappassword]
+      if pass && pass != ""
+        options[:password] = pass
+      end
+    end
+
+    new(Puppet[:ldapserver], Puppet[:ldapport], options)
+  end
+
+  def close
+    connection.unbind if connection.bound?
+  end
+
+  def initialize(host, port, user: nil, password: nil, reset: nil, ssl: nil)
+    raise Puppet::Error, _("Could not set up LDAP Connection: Missing ruby/ldap libraries") unless Puppet.features.ldap?
+
+    @host = host
+    @port = port
+    @user = user
+    @password = password
+    @reset = reset
+    @ssl = ssl
+  end
+
+  # Create a per-connection unique name.
+  def name
+    [host, port, user, password, ssl].collect(&:to_s).join("/")
+  end
+
+  # Should we reset the connection?
+  def reset?
+    reset
+  end
+
+  # Start our ldap connection.
+  def start
+    case ssl
+    when :tls
+      @connection = LDAP::SSLConn.new(host, port, true)
+    when true
+      @connection = LDAP::SSLConn.new(host, port)
+    else
+      @connection = LDAP::Conn.new(host, port)
+    end
+    @connection.set_option(LDAP::LDAP_OPT_PROTOCOL_VERSION, 3)
+    @connection.set_option(LDAP::LDAP_OPT_REFERRALS, LDAP::LDAP_OPT_ON)
+    @connection.simple_bind(user, password)
+  rescue => detail
+    raise Puppet::Error, _("Could not connect to LDAP: %{detail}") % { detail: detail }, detail.backtrace
+  end
+end

data/lib/puppet/util/ldap/generator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/util/ldap'
+
+class Puppet::Util::Ldap::Generator
+  # Declare the attribute we'll use to generate the value.
+  def from(source)
+    @source = source
+    self
+  end
+
+  # Actually do the generation.
+  def generate(value = nil)
+    if value.nil?
+      @generator.call
+    else
+      @generator.call(value)
+    end
+  end
+
+  # Initialize our generator with the name of the parameter
+  # being generated.
+  def initialize(name)
+    @name = name
+  end
+
+  def name
+    @name.to_s
+  end
+
+  def source
+    if @source
+      @source.to_s
+    else
+      nil
+    end
+  end
+
+  # Provide the code that does the generation.
+  def with(&block)
+    @generator = block
+    self
+  end
+end

data/lib/puppet/util/ldap/manager.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/util/ldap'
+require_relative '../../../puppet/util/ldap/connection'
+require_relative '../../../puppet/util/ldap/generator'
+
+# The configuration class for LDAP providers, plus
+# connection handling for actually interacting with ldap.
+class Puppet::Util::Ldap::Manager
+  attr_reader :objectclasses, :puppet2ldap, :location, :rdn
+
+  # A null-op that just returns the config.
+  def and
+    self
+  end
+
+  # Set the offset from the search base and return the config.
+  def at(location)
+    @location = location
+    self
+  end
+
+  # The basic search base.
+  def base
+    [location, Puppet[:ldapbase]].join(",")
+  end
+
+  # Convert the name to a dn, then pass the args along to
+  # our connection.
+  def create(name, attributes)
+    attributes = attributes.dup
+
+    # Add the objectclasses
+    attributes["objectClass"] = objectclasses.collect(&:to_s)
+    attributes["objectClass"] << "top" unless attributes["objectClass"].include?("top")
+
+    attributes[rdn.to_s] = [name]
+
+    # Generate any new values we might need.
+    generate(attributes)
+
+    # And create our resource.
+    connect { |conn| conn.add dn(name), attributes }
+  end
+
+  # Open, yield, and close the connection.  Cannot be left
+  # open, at this point.
+  def connect
+    # TRANSLATORS '#connect' is a method name and and should not be translated, 'block' refers to a Ruby code block
+    raise ArgumentError, _("You must pass a block to #connect") unless block_given?
+
+    unless @connection
+      if Puppet[:ldaptls]
+        ssl = :tls
+      elsif Puppet[:ldapssl]
+        ssl = true
+      else
+        ssl = false
+      end
+      options = { :ssl => ssl }
+      user = Puppet[:ldapuser]
+      if user && user != ""
+        options[:user] = user
+      end
+      password = Puppet[:ldappassword]
+      if password && password != ""
+        options[:password] = password
+      end
+      @connection = Puppet::Util::Ldap::Connection.new(Puppet[:ldapserver], Puppet[:ldapport], options)
+    end
+    @connection.start
+    begin
+      yield @connection.connection
+    ensure
+      @connection.close
+    end
+    nil
+  end
+
+  # Convert the name to a dn, then pass the args along to
+  # our connection.
+  def delete(name)
+    connect { |connection| connection.delete dn(name) }
+  end
+
+  # Calculate the dn for a given resource.
+  def dn(name)
+    ["#{rdn}=#{name}", base].join(",")
+  end
+
+  # Convert an ldap-style entry hash to a provider-style hash.
+  def entry2provider(entry)
+    # TRANSLATOR 'dn' refers to a 'distinguished name' in LDAP (Lightweight Directory Access Protocol) and they should not be translated
+    raise ArgumentError, _("Could not get dn from ldap entry") unless entry["dn"]
+
+    # DN is always a single-entry array.  Strip off the bits before the
+    # first comma, then the bits after the remaining equal sign.  This is the
+    # name.
+    name = entry["dn"].dup.pop.split(",").shift.split("=").pop
+
+    result = { :name => name }
+
+    @ldap2puppet.each do |ldap, puppet|
+      result[puppet] = entry[ldap.to_s] || :absent
+    end
+
+    result
+  end
+
+  # Create our normal search filter.
+  def filter
+    (objectclasses.length == 1 ? "objectclass=#{objectclasses[0]}" : "(&(objectclass=" + objectclasses.join(")(objectclass=") + "))")
+  end
+
+  # Find the associated entry for a resource.  Returns a hash, minus
+  # 'dn', or nil if the entry cannot be found.
+  def find(name)
+    connect do |conn|
+      conn.search2(dn(name), 0, "objectclass=*") do |result|
+        # Convert to puppet-appropriate attributes
+        return entry2provider(result)
+      end
+    rescue
+      return nil
+    end
+  end
+
+  # Declare a new attribute generator.
+  def generates(parameter)
+    @generators << Puppet::Util::Ldap::Generator.new(parameter)
+    @generators[-1]
+  end
+
+  # Generate any extra values we need to make the ldap entry work.
+  def generate(values)
+    return unless @generators.length > 0
+
+    @generators.each do |generator|
+      # Don't override any values that might exist.
+      next if values[generator.name]
+
+      if generator.source
+        value = values[generator.source]
+        unless value
+          raise ArgumentError, _("%{source} must be defined to generate %{name}") %
+                               { source: generator.source, name: generator.name }
+        end
+        result = generator.generate(value)
+      else
+        result = generator.generate
+      end
+
+      result = [result] unless result.is_a?(Array)
+      result = result.collect(&:to_s)
+
+      values[generator.name] = result
+    end
+  end
+
+  def initialize
+    @rdn = :cn
+    @generators = []
+  end
+
+  # Specify what classes this provider models.
+  def manages(*classes)
+    @objectclasses = classes
+    self
+  end
+
+  # Specify the attribute map.  Assumes the keys are the puppet
+  # attributes, and the values are the ldap attributes, and creates a map
+  # for each direction.
+  def maps(attributes)
+    # The map with the puppet attributes as the keys
+    @puppet2ldap = attributes
+
+    # and the ldap attributes as the keys.
+    @ldap2puppet = attributes.each_with_object({}) { |ary, map| map[ary[1]] = ary[0]; }
+
+    self
+  end
+
+  # Return the ldap name for a puppet attribute.
+  def ldap_name(attribute)
+    @puppet2ldap[attribute].to_s
+  end
+
+  # Convert the name to a dn, then pass the args along to
+  # our connection.
+  def modify(name, mods)
+    connect { |connection| connection.modify dn(name), mods }
+  end
+
+  # Specify the rdn that we use to build up our dn.
+  def named_by(attribute)
+    @rdn = attribute
+    self
+  end
+
+  # Return the puppet name for an ldap attribute.
+  def puppet_name(attribute)
+    @ldap2puppet[attribute]
+  end
+
+  # Search for all entries at our base.  A potentially expensive search.
+  def search(sfilter = nil)
+    sfilter ||= filter
+
+    result = []
+    connect do |conn|
+      conn.search2(base, 1, sfilter) do |entry|
+        result << entry2provider(entry)
+      end
+    end
+    (result.empty? ? nil : result)
+  end
+
+  # Update the ldap entry with the desired state.
+  def update(name, is, should)
+    if should[:ensure] == :absent
+      Puppet.info _("Removing %{name} from ldap") % { name: dn(name) }
+      delete(name)
+      return
+    end
+
+    # We're creating a new entry
+    if is.empty? or is[:ensure] == :absent
+      Puppet.info _("Creating %{name} in ldap") % { name: dn(name) }
+      # Remove any :absent params and :ensure, then convert the names to ldap names.
+      attrs = ldap_convert(should)
+      create(name, attrs)
+      return
+    end
+
+    # We're modifying an existing entry.  Yuck.
+
+    mods = []
+    # For each attribute we're deleting that is present, create a
+    # modify instance for deletion.
+    [is.keys, should.keys].flatten.uniq.each do |property|
+      # They're equal, so do nothing.
+      next if is[property] == should[property]
+
+      attributes = ldap_convert(should)
+
+      prop_name = ldap_name(property).to_s
+
+      # We're creating it.
+      if is[property] == :absent or is[property].nil?
+        mods << LDAP::Mod.new(LDAP::LDAP_MOD_ADD, prop_name, attributes[prop_name])
+        next
+      end
+
+      # We're deleting it
+      if should[property] == :absent or should[property].nil?
+        mods << LDAP::Mod.new(LDAP::LDAP_MOD_DELETE, prop_name, [])
+        next
+      end
+
+      # We're replacing an existing value
+      mods << LDAP::Mod.new(LDAP::LDAP_MOD_REPLACE, prop_name, attributes[prop_name])
+    end
+
+    modify(name, mods)
+  end
+
+  # Is this a complete ldap configuration?
+  def valid?
+    location and objectclasses and !objectclasses.empty? and puppet2ldap
+  end
+
+  private
+
+  # Convert a hash of attributes to ldap-like forms.  This mostly means
+  # getting rid of :ensure and making sure everything's an array of strings.
+  def ldap_convert(attributes)
+    attributes.reject { |param, value| value == :absent or param == :ensure }.each_with_object({}) do |ary, result|
+      value = (ary[1].is_a?(Array) ? ary[1] : [ary[1]]).collect(&:to_s)
+      result[ldap_name(ary[0])] = value
+    end
+  end
+end

data/lib/puppet/util/ldap.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Puppet::Util::Ldap
+end

data/lib/puppet/util/libuser.conf

@@ -0,0 +1,15 @@
+[import]
+login_defs = /etc/login.defs
+default_useradd = /etc/default/useradd
+
+[defaults]
+crypt_style = md5
+modules = files shadow
+create_modules = files shadow
+
+[userdefaults]
+LU_USERNAME = %n
+LU_GIDNUMBER = %u
+
+[groupdefaults]
+LU_GROUPNAME = %n

data/lib/puppet/util/libuser.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Puppet::Util::Libuser
+   def self.getconf
+     File.expand_path('libuser.conf', __dir__)
+   end
+
+   def self.getenv
+     newenv = {}
+     newenv['LIBUSER_CONF'] = getconf
+     newenv
+   end
+end

data/lib/puppet/util/limits.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/util'
+
+module Puppet::Util::Limits
+  # @api private
+  def setpriority(priority)
+    return unless priority
+
+    Process.setpriority(0, Process.pid, priority)
+  rescue Errno::EACCES, NotImplementedError
+    Puppet.warning(_("Failed to set process priority to '%{priority}'") % { priority: priority })
+  end
+end