openvox 8.19.0

data/lib/puppet/provider/package_targetable.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Targetable package providers implement a `command` attribute.
+#
+# The `packages` hash passed to `Puppet::Provider::Package::prefetch` is deduplicated,
+# as it is keyed only by name in `Puppet::Transaction::prefetch_if_necessary`.
+#
+# (The `packages` hash passed to ``Puppet::Provider::Package::prefetch`` should be keyed by all namevars,
+# possibly via a `prefetchV2` method that could take a better data structure.)
+#
+# In addition, `Puppet::Provider::Package::properties` calls `query` in the provider.
+require_relative '../../puppet/provider/package'
+
+# But `query` in the provider depends upon whether a `command` attribute is defined for the resource.
+# This is a Catch-22.
+#
+# Instead ...
+#
+# Inspect any package to access the catalog (every package includes a reference to the catalog).
+# Inspect the catalog to find all of the `command` attributes for all of the packages of this class.
+# Find all of the package instances using each package `command`, including the default provider command.
+# Assign each instance's `provider` by selecting it from the `packages` hash passed to `prefetch`, based upon `name` and `command`.
+#
+# The original `command` parameter in the catalog is not populated by the default (`:default`) for the parameter in type/package.rb.
+# Rather, the result of the `original_parameters` is `nil` when the `command` parameter is undefined in the catalog.
+
+class Puppet::Provider::Package::Targetable < Puppet::Provider::Package
+  # Prefetch our package list, yo.
+  def self.prefetch(packages)
+    catalog_packages = packages.values.first.catalog.resources.select { |p| p.provider.instance_of?(self) }
+    package_commands = catalog_packages.map { |catalog_package| catalog_package.original_parameters[:command] }.uniq
+    package_commands.each do |command|
+      instances(command).each do |instance|
+        catalog_packages.each do |catalog_package|
+          if catalog_package[:name] == instance.name && catalog_package.original_parameters[:command] == command
+            catalog_package.provider = instance
+            debug "Prefetched instance: %{name} via command: %{cmd}" % { name: instance.name, cmd: command || :default }
+          end
+        end
+      end
+    end
+    package_commands
+  end
+
+  # Returns the resource command or provider command.
+
+  def resource_or_provider_command
+    resource.original_parameters[:command] || self.class.provider_command
+  end
+
+  # Targetable providers use has_command/is_optional to defer validation of provider suitability.
+  # Evaluate provider suitability here and now by validating that the command is defined and exists.
+  #
+  # cmd: the full path to the package command.
+
+  def self.validate_command(cmd)
+    unless cmd
+      raise Puppet::Error, _("Provider %{name} package command is not functional on this host") % { name: name }
+    end
+    unless File.file?(cmd)
+      raise Puppet::Error, _("Provider %{name} package command '%{cmd}' does not exist on this host") % { name: name, cmd: cmd }
+    end
+  end
+
+  # Return information about the package, its provider, and its (optional) command.
+
+  def to_s
+    cmd = resource[:command] || :default
+    "#{@resource}(provider=#{self.class.name})(command=#{cmd})"
+  end
+end

data/lib/puppet/provider/parsedfile.rb

@@ -0,0 +1,494 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet'
+require_relative '../../puppet/util/filetype'
+require_relative '../../puppet/util/fileparsing'
+
+# This provider can be used as the parent class for a provider that
+# parses and generates files.  Its content must be loaded via the
+# 'prefetch' method, and the file will be written when 'flush' is called
+# on the provider instance.  At this point, the file is written once
+# for every provider instance.
+#
+# Once the provider prefetches the data, it's the resource's job to copy
+# that data over to the @is variables.
+#
+# NOTE: The prefetch method swallows FileReadErrors by treating the
+# corresponding target as an empty file. If you would like to turn this
+# behavior off, then set the raise_prefetch_errors class variable to
+# true. Doing so will error all resources associated with the failed
+# target.
+class Puppet::Provider::ParsedFile < Puppet::Provider
+  extend Puppet::Util::FileParsing
+
+  class << self
+    attr_accessor :default_target, :target, :raise_prefetch_errors
+  end
+
+  attr_accessor :property_hash
+
+  def self.clean(hash)
+    newhash = hash.dup
+    [:record_type, :on_disk].each do |p|
+      newhash.delete(p) if newhash.include?(p)
+    end
+
+    newhash
+  end
+
+  def self.clear
+    @target_objects.clear
+    @records.clear
+  end
+
+  def self.filetype
+    @filetype ||= Puppet::Util::FileType.filetype(:flat)
+  end
+
+  def self.filetype=(type)
+    if type.is_a?(Class)
+      @filetype = type
+    else
+      klass = Puppet::Util::FileType.filetype(type)
+      if klass
+        @filetype = klass
+      else
+        raise ArgumentError, _("Invalid filetype %{type}") % { type: type }
+      end
+    end
+  end
+
+  # Flush all of the targets for which there are modified records.  The only
+  # reason we pass a record here is so that we can add it to the stack if
+  # necessary -- it's passed from the instance calling 'flush'.
+  def self.flush(record)
+    # Make sure this record is on the list to be flushed.
+    unless record[:on_disk]
+      record[:on_disk] = true
+      @records << record
+
+      # If we've just added the record, then make sure our
+      # target will get flushed.
+      modified(record[:target] || default_target)
+    end
+
+    return unless defined?(@modified) and !@modified.empty?
+
+    flushed = []
+    begin
+      @modified.sort_by(&:to_s).uniq.each do |target|
+        Puppet.debug "Flushing #{@resource_type.name} provider target #{target}"
+        flushed << target
+        flush_target(target)
+      end
+    ensure
+      @modified.reject! { |t| flushed.include?(t) }
+    end
+  end
+
+  # Make sure our file is backed up, but only back it up once per transaction.
+  # We cheat and rely on the fact that @records is created on each prefetch.
+  def self.backup_target(target)
+    return nil unless target_object(target).respond_to?(:backup)
+
+    @backup_stats ||= {}
+    return nil if @backup_stats[target] == @records.object_id
+
+    target_object(target).backup
+    @backup_stats[target] = @records.object_id
+  end
+
+  # Flush all of the records relating to a specific target.
+  def self.flush_target(target)
+    if @raise_prefetch_errors && @failed_prefetch_targets.key?(target)
+      raise Puppet::Error, _("Failed to read %{target}'s records when prefetching them. Reason: %{detail}") % { target: target, detail: @failed_prefetch_targets[target] }
+    end
+
+    backup_target(target)
+
+    records = target_records(target).reject { |r|
+      r[:ensure] == :absent
+    }
+
+    target_object(target).write(to_file(records))
+  end
+
+  # Return the header placed at the top of each generated file, warning
+  # users that modifying this file manually is probably a bad idea.
+  def self.header
+    %(# HEADER: This file was autogenerated at #{Time.now}
+# HEADER: by puppet.  While it can still be managed manually, it
+# HEADER: is definitely not recommended.\n)
+  end
+
+  # An optional regular expression matched by third party headers.
+  #
+  # For example, this can be used to filter the vixie cron headers as
+  # erroneously exported by older cron versions.
+  #
+  # @api private
+  # @abstract Providers based on ParsedFile may implement this to make it
+  #   possible to identify a header maintained by a third party tool.
+  #   The provider can then allow that header to remain near the top of the
+  #   written file, or remove it after composing the file content.
+  #   If implemented, the function must return a Regexp object.
+  #   The expression must be tailored to match exactly one third party header.
+  # @see drop_native_header
+  # @note When specifying regular expressions in multiline mode, avoid
+  #   greedy repetitions such as '.*' (use .*? instead). Otherwise, the
+  #   provider may drop file content between sparse headers.
+  def self.native_header_regex
+    nil
+  end
+
+  # How to handle third party headers.
+  # @api private
+  # @abstract Providers based on ParsedFile that make use of the support for
+  #   third party headers may override this method to return +true+.
+  #   When this is done, headers that are matched by the native_header_regex
+  #   are not written back to disk.
+  # @see native_header_regex
+  def self.drop_native_header
+    false
+  end
+
+  # Add another type var.
+  def self.initvars
+    @records = []
+    @target_objects = {}
+
+    # Hash of <target> => <failure reason>.
+    @failed_prefetch_targets = {}
+    @raise_prefetch_errors = false
+
+    @target = nil
+
+    # Default to flat files
+    @filetype ||= Puppet::Util::FileType.filetype(:flat)
+    super
+  end
+
+  # Return a list of all of the records we can find.
+  def self.instances
+    targets.collect do |target|
+      prefetch_target(target)
+    end.flatten.reject { |r| skip_record?(r) }.collect do |record|
+      new(record)
+    end
+  end
+
+  # Override the default method with a lot more functionality.
+  def self.mk_resource_methods
+    [resource_type.validproperties, resource_type.parameters].flatten.each do |attr|
+      attr = attr.intern
+      define_method(attr) do
+        # If it's not a valid field for this record type (which can happen
+        # when different platforms support different fields), then just
+        # return the should value, so the resource shuts up.
+        if @property_hash[attr] or self.class.valid_attr?(self.class.name, attr)
+          @property_hash[attr] || :absent
+        elsif defined?(@resource)
+          @resource.should(attr)
+        else
+          nil
+        end
+      end
+
+      define_method(attr.to_s + "=") do |val|
+        mark_target_modified
+        @property_hash[attr] = val
+      end
+    end
+  end
+
+  # Always make the resource methods.
+  def self.resource_type=(resource)
+    super
+    mk_resource_methods
+  end
+
+  # Mark a target as modified so we know to flush it.  This only gets
+  # used within the attr= methods.
+  def self.modified(target)
+    @modified ||= []
+    @modified << target unless @modified.include?(target)
+  end
+
+  # Retrieve all of the data from disk.  There are three ways to know
+  # which files to retrieve:  We might have a list of file objects already
+  # set up, there might be instances of our associated resource and they
+  # will have a path parameter set, and we will have a default path
+  # set.  We need to turn those three locations into a list of files,
+  # prefetch each one, and make sure they're associated with each appropriate
+  # resource instance.
+  def self.prefetch(resources = nil)
+    # Reset the record list.
+    @records = prefetch_all_targets(resources)
+
+    match_providers_with_resources(resources)
+  end
+
+  # Match a list of catalog resources with provider instances
+  #
+  # @api private
+  #
+  # @param [Array<Puppet::Resource>] resources A list of resources using this class as a provider
+  def self.match_providers_with_resources(resources)
+    return unless resources
+
+    matchers = resources.dup
+    @records.each do |record|
+      # Skip things like comments and blank lines
+      next if skip_record?(record)
+
+      if (resource = resource_for_record(record, resources))
+        resource.provider = new(record)
+      elsif respond_to?(:match)
+        resource = match(record, matchers)
+        if resource
+          matchers.delete(resource.title)
+          record[:name] = resource[:name]
+          resource.provider = new(record)
+        end
+      end
+    end
+  end
+
+  # Look up a resource based on a parsed file record
+  #
+  # @api private
+  #
+  # @param [Hash<Symbol, Object>] record
+  # @param [Array<Puppet::Resource>] resources
+  #
+  # @return [Puppet::Resource, nil] The resource if found, else nil
+  def self.resource_for_record(record, resources)
+    name = record[:name]
+    if name
+      resources[name]
+    end
+  end
+
+  def self.prefetch_all_targets(resources)
+    records = []
+    targets(resources).each do |target|
+      records += prefetch_target(target)
+    end
+    records
+  end
+
+  # Prefetch an individual target.
+  def self.prefetch_target(target)
+    begin
+      target_records = retrieve(target)
+      unless target_records
+        raise Puppet::DevError, _("Prefetching %{target} for provider %{name} returned nil") % { target: target, name: name }
+      end
+    rescue Puppet::Util::FileType::FileReadError => detail
+      if @raise_prefetch_errors
+        # We will raise an error later in flush_target. This way,
+        # only the resources linked to our target will fail
+        # evaluation.
+        @failed_prefetch_targets[target] = detail.to_s
+      else
+        puts detail.backtrace if Puppet[:trace]
+        Puppet.err _("Could not prefetch %{resource} provider '%{name}' target '%{target}': %{detail}. Treating as empty") % { resource: resource_type.name, name: name, target: target, detail: detail }
+      end
+
+      target_records = []
+    end
+
+    target_records.each do |r|
+      r[:on_disk] = true
+      r[:target] = target
+      r[:ensure] = :present
+    end
+
+    target_records = prefetch_hook(target_records) if respond_to?(:prefetch_hook)
+
+    raise Puppet::DevError, _("Prefetching %{target} for provider %{name} returned nil") % { target: target, name: name } unless target_records
+
+    target_records
+  end
+
+  # Is there an existing record with this name?
+  def self.record?(name)
+    return nil unless @records
+
+    @records.find { |r| r[:name] == name }
+  end
+
+  # Retrieve the text for the file. Returns nil in the unlikely
+  # event that it doesn't exist.
+  def self.retrieve(path)
+    # XXX We need to be doing something special here in case of failure.
+    text = target_object(path).read
+    if text.nil? or text == ""
+      # there is no file
+      []
+    else
+      # Set the target, for logging.
+      old = @target
+      begin
+        @target = path
+        parse(text)
+      rescue Puppet::Error => detail
+        detail.file = @target if detail.respond_to?(:file=)
+        raise detail
+      ensure
+        @target = old
+      end
+    end
+  end
+
+  # Should we skip the record?  Basically, we skip text records.
+  # This is only here so subclasses can override it.
+  def self.skip_record?(record)
+    record_type(record[:record_type]).text?
+  end
+
+  # The mode for generated files if they are newly created.
+  # No mode will be set on existing files.
+  #
+  # @abstract Providers inheriting parsedfile can override this method
+  #   to provide a mode. The value should be suitable for File.chmod
+  def self.default_mode
+    nil
+  end
+
+  # Initialize the object if necessary.
+  def self.target_object(target)
+    # only send the default mode if the actual provider defined it,
+    # because certain filetypes (e.g. the crontab variants) do not
+    # expect it in their initialize method
+    if default_mode
+      @target_objects[target] ||= filetype.new(target, default_mode)
+    else
+      @target_objects[target] ||= filetype.new(target)
+    end
+
+    @target_objects[target]
+  end
+
+  # Find all of the records for a given target
+  def self.target_records(target)
+    @records.find_all { |r| r[:target] == target }
+  end
+
+  # Find a list of all of the targets that we should be reading.  This is
+  # used to figure out what targets we need to prefetch.
+  def self.targets(resources = nil)
+    targets = []
+    # First get the default target
+    raise Puppet::DevError, _("Parsed Providers must define a default target") unless default_target
+
+    targets << default_target
+
+    # Then get each of the file objects
+    targets += @target_objects.keys
+
+    # Lastly, check the file from any resource instances
+    if resources
+      resources.each do |_name, resource|
+        value = resource.should(:target)
+        if value
+          targets << value
+        end
+      end
+    end
+
+    targets.uniq.compact
+  end
+
+  # Compose file contents from the set of records.
+  #
+  # If self.native_header_regex is not nil, possible vendor headers are
+  # identified by matching the return value against the expression.
+  # If one (or several consecutive) such headers, are found, they are
+  # either moved in front of the self.header if self.drop_native_header
+  # is false (this is the default), or removed from the return value otherwise.
+  #
+  # @api private
+  def self.to_file(records)
+    text = super
+    if native_header_regex and (match = text.match(native_header_regex))
+      if drop_native_header
+        # concatenate the text in front of and after the native header
+        text = match.pre_match + match.post_match
+      else
+        native_header = match[0]
+        return native_header + header + match.pre_match + match.post_match
+      end
+    end
+    header + text
+  end
+
+  def create
+    @resource.class.validproperties.each do |property|
+      value = @resource.should(property)
+      if value
+        @property_hash[property] = value
+      end
+    end
+    mark_target_modified
+    (@resource.class.name.to_s + "_created").intern
+  end
+
+  def destroy
+    # We use the method here so it marks the target as modified.
+    self.ensure = :absent
+    (@resource.class.name.to_s + "_deleted").intern
+  end
+
+  def exists?
+    !(@property_hash[:ensure] == :absent or @property_hash[:ensure].nil?)
+  end
+
+  # Write our data to disk.
+  def flush
+    # Make sure we've got a target and name set.
+
+    # If the target isn't set, then this is our first modification, so
+    # mark it for flushing.
+    unless @property_hash[:target]
+      @property_hash[:target] = @resource.should(:target) || self.class.default_target
+      self.class.modified(@property_hash[:target])
+    end
+    @resource.class.key_attributes.each do |attr|
+      @property_hash[attr] ||= @resource[attr]
+    end
+
+    self.class.flush(@property_hash)
+  end
+
+  def initialize(record)
+    super
+
+    # The 'record' could be a resource or a record, depending on how the provider
+    # is initialized.  If we got an empty property hash (probably because the resource
+    # is just being initialized), then we want to set up some defaults.
+    @property_hash = self.class.record?(resource[:name]) || { :record_type => self.class.name, :ensure => :absent } if @property_hash.empty?
+  end
+
+  # Retrieve the current state from disk.
+  def prefetch
+    raise Puppet::DevError, _("Somehow got told to prefetch with no resource set") unless @resource
+
+    self.class.prefetch(@resource[:name] => @resource)
+  end
+
+  def record_type
+    @property_hash[:record_type]
+  end
+
+  private
+
+  # Mark both the resource and provider target as modified.
+  def mark_target_modified
+    restarget = @resource.should(:target) if defined?(@resource)
+    if restarget && restarget != @property_hash[:target]
+      self.class.modified(restarget)
+    end
+    self.class.modified(@property_hash[:target]) if @property_hash[:target] != :absent and @property_hash[:target]
+  end
+end

data/lib/puppet/provider/service/base.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+Puppet::Type.type(:service).provide :base, :parent => :service do
+  desc "The simplest form of Unix service support.
+
+  You have to specify enough about your service for this to work; the
+  minimum you can specify is a binary for starting the process, and this
+  same binary will be searched for in the process table to stop the
+  service.  As with `init`-style services, it is preferable to specify start,
+  stop, and status commands.
+
+  "
+
+  commands :kill => "kill"
+
+  # get the proper 'ps' invocation for the platform
+  # ported from the facter 2.x implementation, since facter 3.x
+  # is dropping the fact (for which this was the only use)
+  def getps
+    case Puppet.runtime[:facter].value('os.name')
+    when 'OpenWrt'
+      'ps www'
+    when 'FreeBSD', 'NetBSD', 'OpenBSD', 'Darwin', 'DragonFly'
+      'ps auxwww'
+    else
+      'ps -ef'
+    end
+  end
+  private :getps
+
+  # Get the process ID for a running process. Requires the 'pattern'
+  # parameter.
+  def getpid
+    @resource.fail "Either stop/status commands or a pattern must be specified" unless @resource[:pattern]
+    regex = Regexp.new(@resource[:pattern])
+    ps = getps
+
+    debug "Executing '#{ps}'"
+    table = Puppet::Util::Execution.execute(ps)
+
+    # The output of the PS command can be a mashup of several different
+    # encodings depending on which processes are running and what
+    # arbitrary data has been used to set their name in the process table.
+    #
+    # First, try a polite conversion to in order to match the UTF-8 encoding
+    # of our regular expression.
+    table = Puppet::Util::CharacterEncoding.convert_to_utf_8(table)
+    # If that fails, force to UTF-8 and then scrub as most uses are scanning
+    # for ACII-compatible program names.
+    table.force_encoding(Encoding::UTF_8) unless table.encoding == Encoding::UTF_8
+    table = table.scrub unless table.valid_encoding?
+
+    table.each_line { |line|
+      next unless regex.match(line)
+
+      debug "Process matched: #{line}"
+      ary = line.sub(/^[[:space:]]+/u, '').split(/[[:space:]]+/u)
+      return ary[1]
+    }
+
+    nil
+  end
+  private :getpid
+
+  # Check if the process is running.  Prefer the 'status' parameter,
+  # then 'statuscmd' method, then look in the process table.  We give
+  # the object the option to not return a status command, which might
+  # happen if, for instance, it has an init script (and thus responds to
+  # 'statuscmd') but does not have 'hasstatus' enabled.
+  def status
+    if @resource[:status] or statuscmd
+      # Don't fail when the exit status is not 0.
+      status = service_command(:status, false)
+
+      # Explicitly calling exitstatus to facilitate testing
+      if status.exitstatus == 0
+        :running
+      else
+        :stopped
+      end
+    else
+      pid = getpid
+      if pid
+        debug "PID is #{pid}"
+        :running
+      else
+        :stopped
+      end
+    end
+  end
+
+  # There is no default command, which causes other methods to be used
+  def statuscmd
+  end
+
+  # Run the 'start' parameter command, or the specified 'startcmd'.
+  def start
+    service_command(:start)
+    nil
+  end
+
+  # The command used to start.  Generated if the 'binary' argument
+  # is passed.
+  def startcmd
+    @resource[:binary] || raise(Puppet::Error, "Services must specify a start command or a binary")
+  end
+
+  # Stop the service.  If a 'stop' parameter is specified, it
+  # takes precedence; otherwise checks if the object responds to
+  # a 'stopcmd' method, and if so runs that; otherwise, looks
+  # for the process in the process table.
+  # This method will generally not be overridden by submodules.
+  def stop
+    if @resource[:stop] or stopcmd
+      service_command(:stop)
+      nil
+    else
+      pid = getpid
+      unless pid
+        info _("%{name} is not running") % { name: name }
+        return false
+      end
+      begin
+        output = kill pid
+      rescue Puppet::ExecutionFailure => e
+        @resource.fail Puppet::Error, "Could not kill #{name}, PID #{pid}: #{output}", e
+      end
+      true
+    end
+  end
+
+  # There is no default command, which causes other methods to be used
+  def stopcmd
+  end
+end