openvox 8.19.0

data/lib/puppet/node/facts.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'time'
+
+require_relative '../../puppet/node'
+require_relative '../../puppet/indirector'
+require_relative '../../puppet/util/psych_support'
+
+# Manage a given node's facts.  This either accepts facts and stores them, or
+# returns facts for a given node.
+class Puppet::Node::Facts
+  include Puppet::Util::PsychSupport
+
+  # Set up indirection, so that nodes can be looked for in
+  # the node sources.
+  extend Puppet::Indirector
+
+  # We want to expire any cached nodes if the facts are saved.
+  module NodeExpirer
+    def save(instance, key = nil, options = {})
+      Puppet::Node.indirection.expire(instance.name, options)
+      super
+    end
+  end
+
+  indirects :facts, :terminus_setting => :facts_terminus, :extend => NodeExpirer
+
+  attr_accessor :name, :values, :timestamp
+
+  def add_local_facts
+    values["implementation"] = Puppet.implementation
+    values["clientcert"] = Puppet.settings[:certname]
+    values["clientversion"] = Puppet.version.to_s
+    values["clientnoop"] = Puppet.settings[:noop]
+  end
+
+  def initialize(name, values = {})
+    @name = name
+    @values = values
+
+    add_timestamp
+  end
+
+  def initialize_from_hash(data)
+    @name = data['name']
+    @values = data['values']
+    # Timestamp will be here in YAML, e.g. when reading old reports
+    timestamp = @values.delete('_timestamp')
+    # Timestamp will be here in JSON
+    timestamp ||= data['timestamp']
+
+    if timestamp.is_a? String
+      @timestamp = Time.parse(timestamp)
+    else
+      @timestamp = timestamp
+    end
+
+    self.expiration = data['expiration']
+    if expiration.is_a? String
+      self.expiration = Time.parse(expiration)
+    end
+  end
+
+  # Add extra values, such as facts given to lookup on the command line. The
+  # extra values will override existing values.
+  # @param extra_values [Hash{String=>Object}] the values to add
+  # @api private
+  def add_extra_values(extra_values)
+    @values.merge!(extra_values)
+    nil
+  end
+
+  # Sanitize fact values by converting everything not a string, Boolean
+  # numeric, array or hash into strings.
+  def sanitize
+    values.each do |fact, value|
+      values[fact] = sanitize_fact value
+    end
+  end
+
+  def ==(other)
+    return false unless name == other.name
+
+    values == other.values
+  end
+
+  def self.from_data_hash(data)
+    new_facts = allocate
+    new_facts.initialize_from_hash(data)
+    new_facts
+  end
+
+  def to_data_hash
+    result = {
+      'name' => name,
+      'values' => values
+    }
+
+    if @timestamp
+      if @timestamp.is_a? Time
+        result['timestamp'] = @timestamp.iso8601(9)
+      else
+        result['timestamp'] = @timestamp
+      end
+    end
+
+    if expiration
+      if expiration.is_a? Time
+        result['expiration'] = expiration.iso8601(9)
+      else
+        result['expiration'] = expiration
+      end
+    end
+
+    result
+  end
+
+  def add_timestamp
+    @timestamp = Time.now
+  end
+
+  def to_yaml
+    facts_to_display = Psych.parse_stream(YAML.dump(self))
+    quote_special_strings(facts_to_display)
+  end
+
+  private
+
+  def quote_special_strings(fact_hash)
+    fact_hash.grep(Psych::Nodes::Scalar).each do |node|
+      next unless node.value =~ /:/
+
+      node.plain  = false
+      node.quoted = true
+      node.style  = Psych::Nodes::Scalar::DOUBLE_QUOTED
+    end
+
+    fact_hash.yaml
+  end
+
+  def sanitize_fact(fact)
+    case fact
+    when Hash
+      ret = {}
+      fact.each_pair { |k, v| ret[sanitize_fact k] = sanitize_fact v }
+      ret
+    when Array
+      fact.collect { |i| sanitize_fact i }
+    when Numeric, TrueClass, FalseClass, String
+      fact
+    else
+      result = fact.to_s
+      # The result may be ascii-8bit encoded without being a binary (low level object.inspect returns ascii-8bit string)
+      if result.encoding == Encoding::ASCII_8BIT
+        begin
+          result = result.encode(Encoding::UTF_8)
+        rescue
+          # return the ascii-8bit - it will be taken as a binary
+          result
+        end
+      end
+      result
+    end
+  end
+end

data/lib/puppet/node/server_facts.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Puppet::Node::ServerFacts
+  def self.load
+    server_facts = {}
+
+    # Add implementation information
+    server_facts["implementation"] = Puppet.implementation
+
+    # Add our server Puppet Enterprise version, if available.
+    pe_version_file = '/opt/puppetlabs/server/pe_version'
+    if File.readable?(pe_version_file) and !File.zero?(pe_version_file)
+      server_facts['pe_serverversion'] = File.read(pe_version_file).chomp
+    end
+
+    # Add our server version to the fact list
+    server_facts["serverversion"] = Puppet.version.to_s
+
+    # And then add the server name and IP
+    { "servername" => "networking.fqdn",
+      "serverip" => "networking.ip",
+      "serverip6" => "networking.ip6" }.each do |var, fact|
+      value = Puppet.runtime[:facter].value(fact)
+      unless value.nil?
+        server_facts[var] = value
+      end
+    end
+
+    if server_facts["servername"].nil?
+      host = Puppet.runtime[:facter].value('networking.hostname')
+      if host.nil?
+        Puppet.warning _("Could not retrieve fact servername")
+      elsif domain = Puppet.runtime[:facter].value('networking.domain') # rubocop:disable Lint/AssignmentInCondition
+        server_facts["servername"] = [host, domain].join(".")
+      else
+        server_facts["servername"] = host
+      end
+    end
+
+    if server_facts["serverip"].nil? && server_facts["serverip6"].nil?
+      Puppet.warning _("Could not retrieve either serverip or serverip6 fact")
+    end
+
+    server_facts
+  end
+end

data/lib/puppet/node.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require_relative '../puppet/indirector'
+
+# A class for managing nodes, including their facts and environment.
+class Puppet::Node
+  require_relative 'node/facts'
+  require_relative 'node/environment'
+
+  # Set up indirection, so that nodes can be looked for in
+  # the node sources.
+  extend Puppet::Indirector
+
+  # Asymmetric serialization/deserialization required in this class via to/from datahash
+  include Puppet::Util::PsychSupport
+
+  # Use the node source as the indirection terminus.
+  indirects :node, :terminus_setting => :node_terminus, :doc => "Where to find node information.
+    A node is composed of its name, its facts, and its environment."
+
+  attr_accessor :name, :classes, :source, :ipaddress, :parameters, :environment_name
+  attr_reader :time, :facts, :trusted_data
+
+  attr_reader :server_facts
+
+  ENVIRONMENT = 'environment'
+
+  def initialize_from_hash(data)
+    @name       = data['name']       || (raise ArgumentError, _("No name provided in serialized data"))
+    @classes    = data['classes']    || []
+    @parameters = data['parameters'] || {}
+    env_name = data['environment'] || @parameters[ENVIRONMENT]
+    unless env_name.nil?
+      @parameters[ENVIRONMENT] = env_name
+      @environment_name = env_name.intern
+    end
+  end
+
+  def self.from_data_hash(data)
+    node = new(name)
+    node.initialize_from_hash(data)
+    node
+  end
+
+  def to_data_hash
+    result = {
+      'name' => name,
+      'environment' => environment.name.to_s,
+    }
+    result['classes'] = classes unless classes.empty?
+    serialized_params = serializable_parameters
+    result['parameters'] = serialized_params unless serialized_params.empty?
+    result
+  end
+
+  def serializable_parameters
+    new_params = parameters.dup
+    new_params.delete(ENVIRONMENT)
+    new_params
+  end
+
+  def environment
+    unless @environment
+      env = parameters[ENVIRONMENT]
+      if env
+        self.environment = env
+      elsif environment_name
+        self.environment = environment_name
+      else
+        # This should not be :current_environment, this is the default
+        # for a node when it has not specified its environment
+        # it will be used to establish what the current environment is.
+        #
+        self.environment = Puppet.lookup(:environments).get!(Puppet[:environment])
+      end
+
+    end
+    @environment
+  end
+
+  def environment=(env)
+    if env.is_a?(String) or env.is_a?(Symbol)
+      @environment = Puppet.lookup(:environments).get!(env)
+    else
+      @environment = env
+    end
+
+    # Keep environment_name attribute and parameter in sync if they have been set
+    unless @environment.nil?
+      # always set the environment parameter. It becomes top scope $environment for a manifest during catalog compilation.
+      @parameters[ENVIRONMENT] = @environment.name.to_s
+      self.environment_name = @environment.name
+    end
+  end
+
+  def has_environment_instance?
+    !@environment.nil?
+  end
+
+  def initialize(name, options = {})
+    raise ArgumentError, _("Node names cannot be nil") unless name
+
+    @name = name
+
+    classes = options[:classes]
+    if classes
+      if classes.is_a?(String)
+        @classes = [classes]
+      else
+        @classes = classes
+      end
+    else
+      @classes = []
+    end
+
+    @parameters = options[:parameters] || {}
+
+    @facts = options[:facts]
+
+    @server_facts = {}
+
+    env = options[:environment]
+    if env
+      self.environment = env
+    end
+
+    @time = Time.now
+  end
+
+  # Merge the node facts with parameters from the node source.
+  # @api public
+  # @param facts [optional, Puppet::Node::Facts] facts to merge into node parameters.
+  #   Will query Facts indirection if not supplied.
+  # @raise [Puppet::Error] Raise on failure to retrieve facts if not supplied
+  # @return [nil]
+  def fact_merge(facts = nil)
+    begin
+      @facts = facts.nil? ? Puppet::Node::Facts.indirection.find(name, :environment => environment) : facts
+    rescue => detail
+      error = Puppet::Error.new(_("Could not retrieve facts for %{name}: %{detail}") % { name: name, detail: detail }, detail)
+      error.set_backtrace(detail.backtrace)
+      raise error
+    end
+
+    unless @facts.nil?
+      @facts.sanitize
+      # facts should never modify the environment parameter
+      orig_param_env = @parameters[ENVIRONMENT]
+      merge(@facts.values)
+      @parameters[ENVIRONMENT] = orig_param_env
+    end
+  end
+
+  # Merge any random parameters into our parameter list.
+  def merge(params)
+    params.each do |name, value|
+      if @parameters.include?(name)
+        Puppet::Util::Warnings.warnonce(_("The node parameter '%{param_name}' for node '%{node_name}' was already set to '%{value}'. It could not be set to '%{desired_value}'") % { param_name: name, node_name: @name, value: @parameters[name], desired_value: value })
+      else
+        @parameters[name] = value
+      end
+    end
+  end
+
+  # Add extra facts, such as facts given to lookup on the command line The
+  # extra facts will override existing ones.
+  # @param extra_facts [Hash{String=>Object}] the facts to tadd
+  # @api private
+  def add_extra_facts(extra_facts)
+    @facts.add_extra_values(extra_facts)
+    @parameters.merge!(extra_facts)
+    nil
+  end
+
+  def add_server_facts(facts)
+    # Append the current environment to the list of server facts
+    @server_facts = facts.merge({ "environment" => environment.name.to_s })
+
+    # Merge the server facts into the parameters for the node
+    merge(facts)
+  end
+
+  # Calculate the list of names we might use for looking
+  # up our node.  This is only used for AST nodes.
+  def names
+    @names ||= [name]
+  end
+
+  def split_name(name)
+    list = name.split(".")
+    tmp = []
+    list.each_with_index do |_short, i|
+      tmp << list[0..i].join(".")
+    end
+    tmp.reverse
+  end
+
+  # Ensures the data is frozen
+  #
+  def trusted_data=(data)
+    Puppet.warning(_("Trusted node data modified for node %{name}") % { name: name }) unless @trusted_data.nil?
+    @trusted_data = data.freeze
+  end
+
+  # Resurrects and sanitizes trusted information in the node by modifying it and setting
+  # the trusted_data in the node from parameters.
+  # This modifies the node
+  #
+  def sanitize
+    # Resurrect "trusted information" that comes from node/fact terminus.
+    # The current way this is done in puppet db (currently the only one)
+    # is to store the node parameter 'trusted' as a hash of the trusted information.
+    #
+    # Thus here there are two main cases:
+    # 1. This terminus was used in a real agent call (only meaningful if someone curls the request as it would
+    #  fail since the result is a hash of two catalogs).
+    # 2  It is a command line call with a given node that use a terminus that:
+    # 2.1 does not include a 'trusted' fact - use local from node trusted information
+    # 2.2 has a 'trusted' fact - this in turn could be
+    # 2.2.1 puppet db having stored trusted node data as a fact (not a great design)
+    # 2.2.2 some other terminus having stored a fact called "trusted" (most likely that would have failed earlier, but could
+    #       be spoofed).
+    #
+    # For the reasons above, the resurrection of trusted node data with authenticated => true is only performed
+    # if user is running as root, else it is resurrected as unauthenticated.
+    #
+    trusted_param = @parameters['trusted']
+    if trusted_param
+      # Blows up if it is a parameter as it will be set as $trusted by the compiler as if it was a variable
+      @parameters.delete('trusted')
+      unless trusted_param.is_a?(Hash) && %w[authenticated certname extensions].all? { |key| trusted_param.has_key?(key) }
+        # trusted is some kind of garbage, do not resurrect
+        trusted_param = nil
+      end
+    else
+      # trusted may be Boolean false if set as a fact by someone
+      trusted_param = nil
+    end
+
+    # The options for node.trusted_data in priority order are:
+    # 1) node came with trusted_data so use that
+    # 2) else if there is :trusted_information in the puppet context
+    # 3) else if the node provided a 'trusted' parameter (parsed out above)
+    # 4) last, fallback to local node trusted information
+    #
+    # Note that trusted_data should be a hash, but (2) and (4) are not
+    # hashes, so we to_h at the end
+    unless trusted_data
+      trusted = Puppet.lookup(:trusted_information) do
+        trusted_param || Puppet::Context::TrustedInformation.local(self)
+      end
+
+      self.trusted_data = trusted.to_h
+    end
+  end
+end

data/lib/puppet/pal/catalog_compiler.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Puppet
+module Pal
+  # A CatalogCompiler is a compiler that builds a catalog of resources and dependencies as a side effect of
+  # evaluating puppet language code.
+  # When the compilation of the given input manifest(s)/code string/file is finished the catalog is complete
+  # for encoding and use. It is also possible to evaluate more strings within the same compilation context to
+  # add or remove things from the catalog.
+  #
+  # @api public
+  class CatalogCompiler < Compiler
+    # @api private
+    def catalog
+      internal_compiler.catalog
+    end
+    private :catalog
+
+    # Returns true if this is a compiler that compiles a catalog.
+    # This implementation returns `true`
+    # @return [Boolean] true
+    # @api public
+    def has_catalog?
+      true
+    end
+
+    # Calls a block of code and yields a configured `JsonCatalogEncoder` to the block.
+    # @example Get resulting catalog as pretty printed Json
+    #   Puppet::Pal.in_environment(...) do |pal|
+    #     pal.with_catalog_compiler(...) do |compiler|
+    #       compiler.with_json_encoding { |encoder| encoder.encode }
+    #     end
+    #   end
+    #
+    # @api public
+    #
+    def with_json_encoding(pretty: true, exclude_virtual: true)
+      yield JsonCatalogEncoder.new(catalog, pretty: pretty, exclude_virtual: exclude_virtual)
+    end
+
+    # Returns a hash representation of the compiled catalog.
+    #
+    # @api public
+    def catalog_data_hash
+      catalog.to_data_hash
+    end
+
+    # Evaluates an AST obtained from `parse_string` or `parse_file` in topscope.
+    # If the ast is a `Puppet::Pops::Model::Program` (what is returned from the `parse` methods, any definitions
+    # in the program (that is, any function, plan, etc. that is defined will be made available for use).
+    #
+    # @param ast [Puppet::Pops::Model::PopsObject] typically the returned `Program` from the parse methods, but can be any `Expression`
+    # @returns [Object] whatever the ast evaluates to
+    #
+    def evaluate(ast)
+      if ast.is_a?(Puppet::Pops::Model::Program)
+        bridged = Puppet::Parser::AST::PopsBridge::Program.new(ast)
+        # define all catalog types
+        internal_compiler.environment.known_resource_types.import_ast(bridged, "")
+        bridged.evaluate(internal_compiler.topscope)
+      else
+        internal_evaluator.evaluate(topscope, ast)
+      end
+    end
+
+    # Compiles the result of additional evaluation taking place in a PAL catalog compilation.
+    # This will evaluate all lazy constructs until all have been evaluated, and will the validate
+    # the result.
+    #
+    # This should be called if evaluating string or files of puppet logic after the initial
+    # compilation taking place by giving PAL a manifest or code-string.
+    # This method should be called when a series of evaluation should have reached a
+    # valid state (there should be no dangling relationships (to resources that does not
+    # exist).
+    #
+    # As an alternative the methods `evaluate_additions` can be called without any
+    # requirements on consistency and then calling `validate` at the end.
+    #
+    # Can be called multiple times.
+    #
+    # @return [Void]
+    def compile_additions
+      internal_compiler.compile_additions
+    end
+
+    # Validates the state of the catalog (without performing evaluation of any elements
+    # requiring lazy evaluation. Can be called multiple times.
+    #
+    def validate
+      internal_compiler.validate
+    end
+
+    # Evaluates all lazy constructs that were produced as a side effect of evaluating puppet logic.
+    # Can be called multiple times.
+    #
+    def evaluate_additions
+      internal_compiler.evaluate_additions
+    end
+
+    # Attempts to evaluate AST for node defnintions https://puppet.com/docs/puppet/latest/lang_node_definitions.html
+    # if there are any.
+    def evaluate_ast_node
+      internal_compiler.evaluate_ast_node
+    end
+  end
+end
+end