openvox 8.19.0

data/lib/puppet/indirector/resource/ral.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/indirector/resource/validator'
+
+class Puppet::Resource::Ral < Puppet::Indirector::Code
+  include Puppet::Resource::Validator
+
+  desc "Manipulate resources with the resource abstraction layer. Only used internally."
+
+  def allow_remote_requests?
+    false
+  end
+
+  def find(request)
+    # find by name
+    res   = type(request).instances.find { |o| o.name == resource_name(request) }
+    res ||= type(request).new(:name => resource_name(request), :audit => type(request).properties.collect(&:name))
+
+    res.to_resource
+  end
+
+  def search(request)
+    conditions = request.options.dup
+    conditions[:name] = resource_name(request) if resource_name(request)
+
+    type(request).instances.map(&:to_resource).find_all do |res|
+      conditions.all? do |property, value|
+        # even though `res` is an instance of Puppet::Resource, calling
+        # `res[:name]` on it returns nil, and for some reason it is necessary
+        # to invoke the Puppet::Resource#copy_as_resource copy constructor...
+        res.copy_as_resource[property].to_s == value.to_s
+      end
+    end.sort_by(&:title)
+  end
+
+  def save(request)
+    # In RAL-land, to "save" means to actually try to change machine state
+    res = request.instance
+    ral_res = res.to_ral
+
+    catalog = Puppet::Resource::Catalog.new(nil, request.environment)
+    catalog.add_resource ral_res
+    transaction = catalog.apply
+
+    [ral_res.to_resource, transaction.report]
+  end
+
+  private
+
+  # {type,resource}_name: the resource name may contain slashes:
+  # File["/etc/hosts"]. To handle, assume the type name does
+  # _not_ have any slashes in it, and split only on the first.
+
+  def type_name(request)
+    request.key.split('/', 2)[0]
+  end
+
+  def resource_name(request)
+    name = request.key.split('/', 2)[1]
+    name unless name == ""
+  end
+
+  def type(request)
+    Puppet::Type.type(type_name(request)) or raise Puppet::Error, _("Could not find type %{request_type}") % { request_type: type_name(request) }
+  end
+end

data/lib/puppet/indirector/resource/store_configs.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/indirector/store_configs'
+require_relative '../../../puppet/indirector/resource/validator'
+
+class Puppet::Resource::StoreConfigs < Puppet::Indirector::StoreConfigs
+  include Puppet::Resource::Validator
+
+  desc 'Part of the "storeconfigs" feature. Should not be directly set by end users.'
+
+  def allow_remote_requests?
+    false
+  end
+end

data/lib/puppet/indirector/resource/validator.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Puppet::Resource::Validator
+  def validate_key(request)
+    type, title = request.key.split('/', 2)
+    unless type.casecmp(request.instance.type).zero? and title == request.instance.title
+      raise Puppet::Indirector::ValidationError, _("Resource instance does not match request key")
+    end
+  end
+end

data/lib/puppet/indirector/rest.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Access objects via REST
+class Puppet::Indirector::REST < Puppet::Indirector::Terminus
+  def find(request)
+    raise NotImplementedError
+  end
+
+  def head(request)
+    raise NotImplementedError
+  end
+
+  def search(request)
+    raise NotImplementedError
+  end
+
+  def destroy(request)
+    raise NotImplementedError
+  end
+
+  def save(request)
+    raise NotImplementedError
+  end
+
+  def validate_key(request)
+    # Validation happens on the remote end
+  end
+
+  private
+
+  def convert_to_http_error(response)
+    if response.body.to_s.empty? && response.reason
+      returned_message = response.reason
+    elsif response['content-type'].is_a?(String)
+      content_type, body = parse_response(response)
+      if content_type =~ /[pj]son/
+        returned_message = Puppet::Util::Json.load(body)["message"]
+      else
+        returned_message = response.body
+      end
+    else
+      returned_message = response.body
+    end
+
+    message = _("Error %{code} on SERVER: %{returned_message}") % { code: response.code, returned_message: returned_message }
+    Net::HTTPError.new(message, Puppet::HTTP::ResponseConverter.to_ruby_response(response))
+  end
+
+  # Returns the content_type, stripping any appended charset, and the
+  # body, decompressed if necessary
+  def parse_response(response)
+    if response['content-type']
+      [response['content-type'].gsub(/\s*;.*$/, ''), response.body]
+    else
+      raise _("No content type in http response; cannot parse")
+    end
+  end
+
+  def elide(string, length)
+    if Puppet::Util::Log.level == :debug || string.length <= length
+      string
+    else
+      string[0, length - 3] + "..."
+    end
+  end
+end

data/lib/puppet/indirector/store_configs.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Puppet::Indirector::StoreConfigs < Puppet::Indirector::Terminus
+  def initialize
+    super
+    # This will raise if the indirection can't be found, so we can assume it
+    # is always set to a valid instance from here on in.
+    @target = indirection.terminus Puppet[:storeconfigs_backend]
+  end
+
+  attr_reader :target
+
+  def head(request)
+    target.head request
+  end
+
+  def find(request)
+    target.find request
+  end
+
+  def search(request)
+    target.search request
+  end
+
+  def save(request)
+    target.save request
+  end
+
+  def destroy(request)
+    target.save request
+  end
+end

data/lib/puppet/indirector/terminus.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/indirector'
+require_relative '../../puppet/indirector/errors'
+require_relative '../../puppet/indirector/indirection'
+require_relative '../../puppet/util/instance_loader'
+
+# A simple class that can function as the base class for indirected types.
+class Puppet::Indirector::Terminus
+  require_relative '../../puppet/util/docs'
+  extend Puppet::Util::Docs
+
+  class << self
+    include Puppet::Util::InstanceLoader
+
+    attr_accessor :name, :terminus_type
+    attr_reader :abstract_terminus, :indirection
+
+    # Are we an abstract terminus type, rather than an instance with an
+    # associated indirection?
+    def abstract_terminus?
+      abstract_terminus
+    end
+
+    # Convert a constant to a short name.
+    def const2name(const)
+      const.sub(/^[A-Z]/, &:downcase).gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern
+    end
+
+    # Look up the indirection if we were only provided a name.
+    def indirection=(name)
+      if name.is_a?(Puppet::Indirector::Indirection)
+        @indirection = name
+      else
+        ind = Puppet::Indirector::Indirection.instance(name)
+        if ind
+          @indirection = ind
+        else
+          raise ArgumentError, _("Could not find indirection instance %{name} for %{terminus}") % { name: name, terminus: self.name }
+        end
+      end
+    end
+
+    def indirection_name
+      @indirection.name
+    end
+
+    # Register our subclass with the appropriate indirection.
+    # This follows the convention that our terminus is named after the
+    # indirection.
+    def inherited(subclass)
+      longname = subclass.to_s
+      if longname =~ /#<Class/
+        raise Puppet::DevError, _("Terminus subclasses must have associated constants")
+      end
+
+      names = longname.split("::")
+
+      # Convert everything to a lower-case symbol, converting camelcase to underscore word separation.
+      name = names.pop.sub(/^[A-Z]/, &:downcase).gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern
+
+      subclass.name = name
+
+      # Short-circuit the abstract types, which are those that directly subclass
+      # the Terminus class.
+      if self == Puppet::Indirector::Terminus
+        subclass.mark_as_abstract_terminus
+        return
+      end
+
+      # Set the terminus type to be the name of the abstract terminus type.
+      # Yay, class/instance confusion.
+      subclass.terminus_type = self.name
+
+      # This subclass is specifically associated with an indirection.
+      raise("Invalid name #{longname}") unless names.length > 0
+
+      processed_name = names.pop.sub(/^[A-Z]/, &:downcase).gsub(/[A-Z]/) { |i| "_#{i.downcase}" }
+
+      if processed_name.empty?
+        raise Puppet::DevError, _("Could not discern indirection model from class constant")
+      end
+
+      # This will throw an exception if the indirection instance cannot be found.
+      # Do this last, because it also registers the terminus type with the indirection,
+      # which needs the above information.
+      subclass.indirection = processed_name.intern
+
+      # And add this instance to the instance hash.
+      Puppet::Indirector::Terminus.register_terminus_class(subclass)
+    end
+
+    # Mark that this instance is abstract.
+    def mark_as_abstract_terminus
+      @abstract_terminus = true
+    end
+
+    def model
+      indirection.model
+    end
+
+    # Convert a short name to a constant.
+    def name2const(name)
+      name.to_s.capitalize.sub(/_(.)/) { |_i| ::Regexp.last_match(1).upcase }
+    end
+
+    # Register a class, probably autoloaded.
+    def register_terminus_class(klass)
+      setup_instance_loading klass.indirection_name
+      instance_hash(klass.indirection_name)[klass.name] = klass
+    end
+
+    # Return a terminus by name, using the autoloader.
+    def terminus_class(indirection_name, terminus_type)
+      setup_instance_loading indirection_name
+      loaded_instance(indirection_name, terminus_type)
+    end
+
+    # Return all terminus classes for a given indirection.
+    def terminus_classes(indirection_name)
+      setup_instance_loading indirection_name
+      instance_loader(indirection_name).files_to_load(Puppet.lookup(:current_environment)).map do |file|
+        File.basename(file).chomp(".rb").intern
+      end
+    end
+
+    private
+
+    def setup_instance_loading(type)
+      instance_load type, "puppet/indirector/#{type}" unless instance_loading?(type)
+    end
+  end
+
+  def indirection
+    self.class.indirection
+  end
+
+  def initialize
+    raise Puppet::DevError, _("Cannot create instances of abstract terminus types") if self.class.abstract_terminus?
+  end
+
+  def model
+    self.class.model
+  end
+
+  def name
+    self.class.name
+  end
+
+  def require_environment?
+    true
+  end
+
+  def allow_remote_requests?
+    true
+  end
+
+  def terminus_type
+    self.class.terminus_type
+  end
+
+  def validate(request)
+    if request.instance
+      validate_model(request)
+      validate_key(request)
+    end
+  end
+
+  def validate_key(request)
+    unless request.key == request.instance.name
+      raise Puppet::Indirector::ValidationError, _("Instance name %{name} does not match requested key %{key}") % { name: request.instance.name.inspect, key: request.key.inspect }
+    end
+  end
+
+  def validate_model(request)
+    unless model === request.instance
+      raise Puppet::Indirector::ValidationError, _("Invalid instance type %{klass}, expected %{model_type}") % { klass: request.instance.class.inspect, model_type: model.inspect }
+    end
+  end
+end

data/lib/puppet/indirector/yaml.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/indirector/terminus'
+require_relative '../../puppet/util/yaml'
+
+# The base class for YAML indirection termini.
+class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
+  # Read a given name's file in and convert it from YAML.
+  def find(request)
+    file = path(request.key)
+    return nil unless Puppet::FileSystem.exist?(file)
+
+    begin
+      load_file(file)
+    rescue Puppet::Util::Yaml::YamlLoadError => detail
+      raise Puppet::Error, _("Could not parse YAML data for %{indirection} %{request}: %{detail}") % { indirection: indirection.name, request: request.key, detail: detail }, detail.backtrace
+    end
+  end
+
+  # Convert our object to YAML and store it to the disk.
+  def save(request)
+    raise ArgumentError, _("You can only save objects that respond to :name") unless request.instance.respond_to?(:name)
+
+    file = path(request.key)
+
+    basedir = File.dirname(file)
+
+    # This is quite likely a bad idea, since we're not managing ownership or modes.
+    Dir.mkdir(basedir) unless Puppet::FileSystem.exist?(basedir)
+
+    begin
+      Puppet::Util::Yaml.dump(request.instance, file)
+    rescue TypeError => detail
+      Puppet.err _("Could not save %{indirection} %{request}: %{detail}") % { indirection: name, request: request.key, detail: detail }
+    end
+  end
+
+  # Return the path to a given node's file.
+  def path(name, ext = '.yaml')
+    if name =~ Puppet::Indirector::BadNameRegexp then
+      Puppet.crit(_("directory traversal detected in %{indirection}: %{name}") % { indirection: self.class, name: name.inspect })
+      raise ArgumentError, _("invalid key")
+    end
+
+    base = Puppet.run_mode.server? ? Puppet[:yamldir] : Puppet[:clientyamldir]
+    File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
+  end
+
+  def destroy(request)
+    file_path = path(request.key)
+    Puppet::FileSystem.unlink(file_path) if Puppet::FileSystem.exist?(file_path)
+  end
+
+  def search(request)
+    Dir.glob(path(request.key, '')).collect do |file|
+      load_file(file)
+    end
+  end
+
+  protected
+
+  def load_file(file)
+    Puppet::Util::Yaml.safe_load_file(file, [model, Symbol])
+  end
+end

data/lib/puppet/indirector.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# Manage indirections to termini.  They are organized in terms of indirections -
+# - e.g., configuration, node, file, certificate -- and each indirection has one
+# or more terminus types defined.  The indirection is configured via the
+# +indirects+ method, which will be called by the class extending itself
+# with this module.
+module Puppet::Indirector
+  # LAK:FIXME We need to figure out how to handle documentation for the
+  # different indirection types.
+
+  require_relative 'indirector/indirection'
+  require_relative 'indirector/terminus'
+  require_relative 'indirector/code'
+  require_relative 'indirector/envelope'
+  require_relative '../puppet/network/format_support'
+
+  def self.configure_routes(application_routes)
+    application_routes.each do |indirection_name, termini|
+      indirection_name = indirection_name.to_sym
+      terminus_name = termini["terminus"]
+      cache_name    = termini["cache"]
+
+      Puppet::Indirector::Terminus.terminus_class(indirection_name, terminus_name || cache_name)
+
+      indirection = Puppet::Indirector::Indirection.instance(indirection_name)
+      raise _("Indirection %{indirection_name} does not exist") % { indirection_name: indirection_name } unless indirection
+
+      indirection.set_global_setting(:terminus_class, terminus_name) if terminus_name
+      indirection.set_global_setting(:cache_class, cache_name) if cache_name
+    end
+  end
+
+  # Declare that the including class indirects its methods to
+  # this terminus.  The terminus name must be the name of a Puppet
+  # default, not the value -- if it's the value, then it gets
+  # evaluated at parse time, which is before the user has had a chance
+  # to override it.
+  def indirects(indirection, options = {})
+    raise(ArgumentError, _("Already handling indirection for %{current}; cannot also handle %{next}") % { current: @indirection.name, next: indirection }) if @indirection
+
+    # populate this class with the various new methods
+    extend ClassMethods
+    include Puppet::Indirector::Envelope
+    include Puppet::Network::FormatSupport
+
+    # record the indirected class name for documentation purposes
+    options[:indirected_class] = name
+
+    # instantiate the actual Terminus for that type and this name (:ldap, w/ args :node)
+    # & hook the instantiated Terminus into this class (Node: @indirection = terminus)
+    @indirection = Puppet::Indirector::Indirection.new(self, indirection, **options)
+  end
+
+  module ClassMethods
+    attr_reader :indirection
+  end
+
+  # Helper definition for indirections that handle filenames.
+  BadNameRegexp = Regexp.union(/^\.\./,
+                               %r{[\\/]},
+                               "\0",
+                               /(?i)^[a-z]:/)
+end

data/lib/puppet/info_service/class_information_service.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet'
+require_relative '../../puppet/pops'
+require_relative '../../puppet/pops/evaluator/json_strict_literal_evaluator'
+
+class Puppet::InfoService::ClassInformationService
+  def initialize
+    @file_to_result = {}
+    @parser = Puppet::Pops::Parser::EvaluatingParser.new()
+  end
+
+  def classes_per_environment(env_file_hash)
+    # In this version of puppet there is only one way to parse manifests, as feature switches per environment
+    # are added or removed, this logic needs to change to compute the result per environment with the correct
+    # feature flags in effect.
+
+    unless env_file_hash.is_a?(Hash)
+      raise ArgumentError, _('Given argument must be a Hash')
+    end
+
+    result = {}
+
+    # for each environment
+    #   for each file
+    #     if file already processed, use last result or error
+    #
+    env_file_hash.each do |env, files|
+      env_result = result[env] = {}
+      files.each do |f|
+        env_result[f] = result_of(f)
+      end
+    end
+    result
+  end
+
+  private
+
+  def type_parser
+    Puppet::Pops::Types::TypeParser.singleton
+  end
+
+  def literal_evaluator
+    @@literal_evaluator ||= Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator.new
+  end
+
+  def result_of(f)
+    entry = @file_to_result[f]
+    if entry.nil?
+      @file_to_result[f] = entry = parse_file(f)
+    end
+    entry
+  end
+
+  def parse_file(f)
+    return { :error => _("The file %{f} does not exist") % { f: f } } unless Puppet::FileSystem.exist?(f)
+
+    begin
+      parse_result = @parser.parse_file(f)
+      { :classes =>
+        parse_result.definitions.select { |d| d.is_a?(Puppet::Pops::Model::HostClassDefinition) }.map do |d|
+          { :name => d.name,
+            :params => d.parameters.map { |p| extract_param(p) } }
+        end }
+    rescue StandardError => e
+      { :error => e.message }
+    end
+  end
+
+  def extract_param(p)
+    extract_default(extract_type({ :name => p.name }, p), p)
+  end
+
+  def extract_type(structure, p)
+    return structure if p.type_expr.nil?
+
+    structure[:type] = typeexpr_to_string(p.name, p.type_expr)
+    structure
+  end
+
+  def extract_default(structure, p)
+    value_expr = p.value
+    return structure if value_expr.nil?
+
+    default_value = value_as_literal(value_expr)
+    structure[:default_literal] = default_value unless default_value.nil?
+    structure[:default_source] = extract_value_source(value_expr)
+    structure
+  end
+
+  def typeexpr_to_string(name, type_expr)
+    type_parser.interpret_any(type_expr, nil).to_s
+  rescue Puppet::ParseError => e
+    raise Puppet::Error, "The parameter '$#{name}' is invalid: #{e.message}", e.backtrace
+  end
+
+  def value_as_literal(value_expr)
+    catch(:not_literal) do
+      return literal_evaluator.literal(value_expr)
+    end
+    nil
+  end
+
+  # Extracts the source for the expression
+  def extract_value_source(value_expr)
+    value_expr.locator.extract_tree_text(value_expr)
+  end
+end

data/lib/puppet/info_service/plan_information_service.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Puppet::InfoService::PlanInformationService
+  require_relative '../../puppet/module'
+
+  def self.plans_per_environment(environment_name)
+    # get the actual environment object, raise error if the named env doesn't exist
+    env = Puppet.lookup(:environments).get!(environment_name)
+    env.modules.map do |mod|
+      mod.plans.map do |plan|
+        { :module => { :name => plan.module.name }, :name => plan.name }
+      end
+    end.flatten
+  end
+
+  def self.plan_data(environment_name, module_name, plan_name)
+    # raise EnvironmentNotFound if applicable
+    Puppet.lookup(:environments).get!(environment_name)
+
+    pup_module = Puppet::Module.find(module_name, environment_name)
+    if pup_module.nil?
+      raise Puppet::Module::MissingModule, _("Module %{module_name} not found in environment %{environment_name}.") %
+                                           { module_name: module_name, environment_name: environment_name }
+    end
+
+    plan = pup_module.plans.find { |t| t.name == plan_name }
+    if plan.nil?
+      raise Puppet::Module::Plan::PlanNotFound.new(plan_name, module_name)
+    end
+
+    begin
+      plan.validate
+      { :metadata => plan.metadata, :files => plan.files }
+    rescue Puppet::Module::Plan::Error => err
+      { :metadata => nil, :files => [], :error => err.to_h }
+    end
+  end
+end

data/lib/puppet/info_service/task_information_service.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Puppet::InfoService::TaskInformationService
+  require_relative '../../puppet/module'
+
+  def self.tasks_per_environment(environment_name)
+    # get the actual environment object, raise error if the named env doesn't exist
+    env = Puppet.lookup(:environments).get!(environment_name)
+
+    env.modules.map do |mod|
+      mod.tasks.map do |task|
+        # If any task is malformed continue to list other tasks in module
+
+        task.validate
+        { :module => { :name => task.module.name }, :name => task.name, :metadata => task.metadata }
+      rescue Puppet::Module::Task::Error => err
+        Puppet.log_exception(err)
+        nil
+      end
+    end.flatten.compact
+  end
+
+  def self.task_data(environment_name, module_name, task_name)
+    # raise EnvironmentNotFound if applicable
+    Puppet.lookup(:environments).get!(environment_name)
+
+    pup_module = Puppet::Module.find(module_name, environment_name)
+    if pup_module.nil?
+      raise Puppet::Module::MissingModule, _("Module %{module_name} not found in environment %{environment_name}.") %
+                                           { module_name: module_name, environment_name: environment_name }
+    end
+
+    task = pup_module.tasks.find { |t| t.name == task_name }
+    if task.nil?
+      raise Puppet::Module::Task::TaskNotFound.new(task_name, module_name)
+    end
+
+    begin
+      task.validate
+      { :metadata => task.metadata, :files => task.files }
+    rescue Puppet::Module::Task::Error => err
+      { :metadata => nil, :files => [], :error => err.to_h }
+    end
+  end
+end