openvox 7.37.1

data/lib/puppet/indirector/node/exec.rb

@@ -0,0 +1,70 @@
+require_relative '../../../puppet/node'
+require_relative '../../../puppet/indirector/exec'
+
+class Puppet::Node::Exec < Puppet::Indirector::Exec
+  desc "Call an external program to get node information.  See
+  the [External Nodes](https://puppet.com/docs/puppet/latest/lang_write_functions_in_puppet.html) page for more information."
+  include Puppet::Util
+
+  def command
+    command = Puppet[:external_nodes]
+    raise ArgumentError, _("You must set the 'external_nodes' parameter to use the external node terminus") unless command != _("none")
+    command.split
+  end
+
+  # Look for external node definitions.
+  def find(request)
+    output = super or return nil
+
+    # Translate the output to ruby.
+    result = translate(request.key, output)
+
+    facts = request.options[:facts].is_a?(Puppet::Node::Facts) ? request.options[:facts] : nil
+
+    # Set the requested environment if it wasn't overridden
+    # If we don't do this it gets set to the local default
+    result[:environment] ||= request.environment
+
+    create_node(request.key, result, facts)
+  end
+
+  private
+
+  # Proxy the execution, so it's easier to test.
+  def execute(command, arguments)
+    Puppet::Util::Execution.execute(command,arguments)
+  end
+
+  # Turn our outputted objects into a Puppet::Node instance.
+  def create_node(name, result, facts = nil)
+    node = Puppet::Node.new(name)
+    [:parameters, :classes, :environment].each do |param|
+      value = result[param]
+      if value
+        node.send(param.to_s + "=", value)
+      end
+    end
+
+    node.fact_merge(facts)
+    node
+  end
+
+  # Translate the yaml string into Ruby objects.
+  def translate(name, output)
+    Puppet::Util::Yaml.safe_load(output, [Symbol]).inject({}) do |hash, data|
+      case data[0]
+      when String
+        hash[data[0].intern] = data[1]
+      when Symbol
+        hash[data[0]] = data[1]
+      else
+        raise Puppet::Error, _("key is a %{klass}, not a string or symbol") % { klass: data[0].class }
+      end
+
+      hash
+    end
+
+  rescue => detail
+      raise Puppet::Error, _("Could not load external node results for %{name}: %{detail}") % { name: name, detail: detail }, detail.backtrace
+  end
+end

data/lib/puppet/indirector/node/json.rb

@@ -0,0 +1,8 @@
+require_relative '../../../puppet/node'
+require_relative '../../../puppet/indirector/json'
+
+class Puppet::Node::Json < Puppet::Indirector::JSON
+  desc "Store node information as flat files, serialized using JSON,
+    or deserialize stored JSON nodes."
+
+end

data/lib/puppet/indirector/node/memory.rb

@@ -0,0 +1,10 @@
+require_relative '../../../puppet/node'
+require_relative '../../../puppet/indirector/memory'
+
+class Puppet::Node::Memory < Puppet::Indirector::Memory
+  desc "Keep track of nodes in memory but nowhere else.  This is used for
+    one-time compiles, such as what the stand-alone `puppet` does.
+    To use this terminus, you must load it with the data you want it
+    to contain; it is only useful for developers and should generally not
+    be chosen by a normal user."
+end

data/lib/puppet/indirector/node/msgpack.rb

@@ -0,0 +1,7 @@
+require_relative '../../../puppet/node'
+require_relative '../../../puppet/indirector/msgpack'
+
+class Puppet::Node::Msgpack < Puppet::Indirector::Msgpack
+  desc "Store node information as flat files, serialized using MessagePack,
+    or deserialize stored MessagePack nodes."
+end

data/lib/puppet/indirector/node/plain.rb

@@ -0,0 +1,21 @@
+require_relative '../../../puppet/node'
+require_relative '../../../puppet/indirector/plain'
+
+class Puppet::Node::Plain < Puppet::Indirector::Plain
+  desc "Always return an empty node object. Assumes you keep track of nodes
+    in flat file manifests.  You should use it when you don't have some other,
+    functional source you want to use, as the compiler will not work without a
+    valid node terminus.
+
+    Note that class is responsible for merging the node's facts into the
+    node instance before it is returned."
+
+  # Just return an empty node.
+  def find(request)
+    node = super
+    node.environment = request.environment
+    facts = request.options[:facts].is_a?(Puppet::Node::Facts) ? request.options[:facts] : nil
+    node.fact_merge(facts)
+    node
+  end
+end

data/lib/puppet/indirector/node/rest.rb

@@ -0,0 +1,29 @@
+require_relative '../../../puppet/node'
+require_relative '../../../puppet/indirector/rest'
+
+class Puppet::Node::Rest < Puppet::Indirector::REST
+  desc "Get a node via REST. Puppet agent uses this to allow the puppet master
+    to override its environment."
+
+  def find(request)
+    session = Puppet.lookup(:http_session)
+    api = session.route_to(:puppet)
+    _, node = api.get_node(
+      request.key,
+      environment: request.environment.to_s,
+      configured_environment: request.options[:configured_environment],
+      transaction_uuid: request.options[:transaction_uuid]
+    )
+    node
+  rescue Puppet::HTTP::ResponseError => e
+    if e.response.code == 404
+      return nil unless request.options[:fail_on_404]
+
+      _, body = parse_response(e.response)
+      msg = _("Find %{uri} resulted in 404 with the message: %{body}") % { uri: elide(e.response.url.path, 100), body: body }
+      raise Puppet::Error, msg
+    else
+      raise convert_to_http_error(e.response)
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+require_relative '../../../puppet/indirector/store_configs'
+require_relative '../../../puppet/node'
+
+class Puppet::Node::StoreConfigs < Puppet::Indirector::StoreConfigs
+
+  desc %q{Part of the "storeconfigs" feature. Should not be directly set by end users.}
+
+end

data/lib/puppet/indirector/node/yaml.rb

@@ -0,0 +1,7 @@
+require_relative '../../../puppet/node'
+require_relative '../../../puppet/indirector/yaml'
+
+class Puppet::Node::Yaml < Puppet::Indirector::Yaml
+  desc "Store node information as flat files, serialized using YAML,
+    or deserialize stored YAML nodes."
+end

data/lib/puppet/indirector/none.rb

@@ -0,0 +1,9 @@
+require_relative '../../puppet/indirector/terminus'
+
+# A none terminus type, meant to always return nil
+class Puppet::Indirector::None < Puppet::Indirector::Terminus
+  def find(request)
+    return nil
+  end
+end
+

data/lib/puppet/indirector/plain.rb

@@ -0,0 +1,9 @@
+require_relative '../../puppet/indirector/terminus'
+
+# An empty terminus type, meant to just return empty objects.
+class Puppet::Indirector::Plain < Puppet::Indirector::Terminus
+  # Just return nothing.
+  def find(request)
+    indirection.model.new(request.key)
+  end
+end

data/lib/puppet/indirector/report/json.rb

@@ -0,0 +1,34 @@
+require_relative '../../../puppet/transaction/report'
+require_relative '../../../puppet/indirector/json'
+
+class Puppet::Transaction::Report::Json < Puppet::Indirector::JSON
+  include Puppet::Util::SymbolicFileMode
+
+  desc "Store last report as a flat file, serialized using JSON."
+
+  # Force report to be saved there
+  def path(name,ext='.json')
+    Puppet[:lastrunreport]
+  end
+
+  def save(request)
+    filename = path(request.key)
+    mode = Puppet.settings.setting(:lastrunreport).mode
+
+    unless valid_symbolic_mode?(mode)
+      raise Puppet::DevError, _("replace_file mode: %{mode} is invalid") % { mode: mode }
+    end
+
+    mode = symbolic_mode_to_int(normalize_symbolic_mode(mode))
+
+    FileUtils.mkdir_p(File.dirname(filename))
+
+    begin
+      Puppet::FileSystem.replace_file(filename, mode) do |fh|
+        fh.print JSON.dump(request.instance)
+      end
+    rescue TypeError => detail
+      Puppet.err _("Could not save %{indirection} %{request}: %{detail}") % { indirection: self.name, request: request.key, detail: detail }
+    end
+  end
+end

data/lib/puppet/indirector/report/msgpack.rb

@@ -0,0 +1,11 @@
+require_relative '../../../puppet/transaction/report'
+require_relative '../../../puppet/indirector/msgpack'
+
+class Puppet::Transaction::Report::Msgpack < Puppet::Indirector::Msgpack
+  desc "Store last report as a flat file, serialized using MessagePack."
+
+  # Force report to be saved there
+  def path(name,ext='.msgpack')
+    Puppet[:lastrunreport]
+  end
+end

data/lib/puppet/indirector/report/processor.rb

@@ -0,0 +1,60 @@
+require_relative '../../../puppet/transaction/report'
+require_relative '../../../puppet/indirector/code'
+require_relative '../../../puppet/reports'
+
+class Puppet::Transaction::Report::Processor < Puppet::Indirector::Code
+  desc "Puppet's report processor.  Processes the report with each of
+    the report types listed in the 'reports' setting."
+
+  def initialize
+    Puppet.settings.use(:main, :reporting, :metrics)
+  end
+
+  def save(request)
+    process(request.instance)
+  end
+
+  def destroy(request)
+    processors do |mod|
+      mod.destroy(request.key) if mod.respond_to?(:destroy)
+    end
+  end
+
+  private
+
+  # Process the report with each of the configured report types.
+  # LAK:NOTE This isn't necessarily the best design, but it's backward
+  # compatible and that's good enough for now.
+  def process(report)
+    Puppet.debug { "Received report to process from #{report.host}" }
+    processors do |mod|
+      Puppet.debug { "Processing report from #{report.host} with processor #{mod}" }
+      # We have to use a dup because we're including a module in the
+      # report.
+      newrep = report.dup
+      begin
+        newrep.extend(mod)
+        newrep.process
+      rescue => detail
+        Puppet.log_exception(detail, _("Report %{report} failed: %{detail}") % { report: name, detail: detail })
+      end
+    end
+  end
+
+  # Handle the parsing of the reports attribute.
+  def reports
+    Puppet[:reports].gsub(/(^\s+)|(\s+$)/, '').split(/\s*,\s*/)
+  end
+
+  def processors(&blk)
+    return [] if Puppet[:reports] == "none"
+    reports.each do |name|
+      mod = Puppet::Reports.report(name)
+      if mod
+        yield(mod)
+      else
+        Puppet.warning _("No report named '%{name}'") % { name: name }
+      end
+    end
+  end
+end

data/lib/puppet/indirector/report/rest.rb

@@ -0,0 +1,42 @@
+require_relative '../../../puppet/indirector/rest'
+require 'semantic_puppet'
+
+class Puppet::Transaction::Report::Rest < Puppet::Indirector::REST
+  desc "Get server report over HTTP via REST."
+
+  def save(request)
+    session = Puppet.lookup(:http_session)
+    api = session.route_to(:report)
+    response = api.put_report(
+      request.key,
+      request.instance,
+      environment: request.environment.to_s
+    )
+    content_type, body = parse_response(response)
+    deserialize_save(content_type, body)
+  rescue Puppet::HTTP::ResponseError => e
+    return nil if e.response.code == 404
+
+    raise convert_to_http_error(e.response)
+  end
+
+  # This is called by the superclass when not using our httpclient.
+  def handle_response(request, response)
+    if !response.success?
+      server_version = response[Puppet::Network::HEADER_PUPPET_VERSION]
+      if server_version &&
+         SemanticPuppet::Version.parse(server_version).major < Puppet::Indirector::REST::MAJOR_VERSION_JSON_DEFAULT &&
+         Puppet[:preferred_serialization_format] != 'pson'
+        format = Puppet[:preferred_serialization_format]
+        raise Puppet::Error.new(_("Server version %{version} does not accept reports in '%{format}', use `preferred_serialization_format=pson`") % {version: server_version, format: format})
+      end
+    end
+  end
+
+  private
+
+  def deserialize_save(content_type, body)
+    format = Puppet::Network::FormatHandler.format_for(content_type)
+    format.intern(Array, body)
+  end
+end

data/lib/puppet/indirector/report/yaml.rb

@@ -0,0 +1,34 @@
+require_relative '../../../puppet/transaction/report'
+require_relative '../../../puppet/indirector/yaml'
+
+class Puppet::Transaction::Report::Yaml < Puppet::Indirector::Yaml
+  include Puppet::Util::SymbolicFileMode
+
+  desc "Store last report as a flat file, serialized using YAML."
+
+  # Force report to be saved there
+  def path(name,ext='.yaml')
+    Puppet[:lastrunreport]
+  end
+
+  def save(request)
+    filename = path(request.key)
+    mode = Puppet.settings.setting(:lastrunreport).mode
+
+    unless valid_symbolic_mode?(mode)
+      raise Puppet::DevError, _("replace_file mode: %{mode} is invalid") % { mode: mode }
+    end
+
+    mode = symbolic_mode_to_int(normalize_symbolic_mode(mode))
+
+    FileUtils.mkdir_p(File.dirname(filename))
+
+    begin
+      Puppet::FileSystem.replace_file(filename, mode) do |fh|
+        fh.print YAML.dump(request.instance)
+      end
+    rescue TypeError => detail
+      Puppet.err _("Could not save %{indirection} %{request}: %{detail}") % { indirection: self.name, request: request.key, detail: detail }
+    end
+  end
+end

data/lib/puppet/indirector/request.rb

@@ -0,0 +1,194 @@
+require 'cgi'
+require 'uri'
+require_relative '../../puppet/indirector'
+require_relative '../../puppet/util/psych_support'
+require_relative '../../puppet/util/warnings'
+
+# This class encapsulates all of the information you need to make an
+# Indirection call, and as a result also handles REST calls.  It's somewhat
+# analogous to an HTTP Request object, except tuned for our Indirector.
+class Puppet::Indirector::Request
+  include Puppet::Util::PsychSupport
+  include Puppet::Util::Warnings
+
+  attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_cache_save, :ignore_terminus
+
+  attr_accessor :server, :port, :uri, :protocol
+
+  attr_reader :indirection_name
+
+  # trusted_information is specifically left out because we can't serialize it
+  # and keep it "trusted"
+  OPTION_ATTRIBUTES = [:ip, :node, :authenticated, :ignore_terminus, :ignore_cache, :ignore_cache_save, :instance, :environment]
+
+  # Is this an authenticated request?
+  def authenticated?
+    # Double negative, so we just get true or false
+    ! ! authenticated
+  end
+
+  def environment
+    # If environment has not been set directly, we should use the application's
+    # current environment
+    @environment ||= Puppet.lookup(:current_environment)
+  end
+
+  def environment=(env)
+    @environment =
+    if env.is_a?(Puppet::Node::Environment)
+      env
+    else
+      Puppet.lookup(:environments).get!(env)
+    end
+  end
+
+  # LAK:NOTE This is a messy interface to the cache, and it's only
+  # used by the Configurer class.  I decided it was better to implement
+  # it now and refactor later, when we have a better design, than
+  # to spend another month coming up with a design now that might
+  # not be any better.
+  def ignore_cache?
+    ignore_cache
+  end
+
+  def ignore_cache_save?
+    ignore_cache_save
+  end
+
+  def ignore_terminus?
+    ignore_terminus
+  end
+
+  def initialize(indirection_name, method, key, instance, options = {})
+    @instance = instance
+    options ||= {}
+
+    self.indirection_name = indirection_name
+    self.method = method
+
+    options = options.inject({}) { |hash, ary| hash[ary[0].to_sym] = ary[1]; hash }
+
+    set_attributes(options)
+
+    @options = options
+
+    if key
+      # If the request key is a URI, then we need to treat it specially,
+      # because it rewrites the key.  We could otherwise strip server/port/etc
+      # info out in the REST class, but it seemed bad design for the REST
+      # class to rewrite the key.
+
+      if key.to_s =~ /^\w+:\// and not Puppet::Util.absolute_path?(key.to_s) # it's a URI
+        set_uri_key(key)
+      else
+        @key = key
+      end
+    end
+
+    @key = @instance.name if ! @key and @instance
+  end
+
+  # Look up the indirection based on the name provided.
+  def indirection
+    Puppet::Indirector::Indirection.instance(indirection_name)
+  end
+
+  def indirection_name=(name)
+    @indirection_name = name.to_sym
+  end
+
+  def model
+    ind = indirection
+    raise ArgumentError, _("Could not find indirection '%{indirection}'") % { indirection: indirection_name } unless ind
+    ind.model
+  end
+
+  # Are we trying to interact with multiple resources, or just one?
+  def plural?
+    method == :search
+  end
+
+  def initialize_from_hash(hash)
+    @indirection_name = hash['indirection_name'].to_sym
+    @method = hash['method'].to_sym
+    @key = hash['key']
+    @instance = hash['instance']
+    @options = hash['options']
+  end
+
+  def to_data_hash
+    { 'indirection_name' => @indirection_name.to_s,
+      'method' => @method.to_s,
+      'key' => @key,
+      'instance' => @instance,
+      'options' => @options }
+  end
+
+  def to_hash
+    result = options.dup
+
+    OPTION_ATTRIBUTES.each do |attribute|
+      value = send(attribute)
+      if value
+        result[attribute] = value
+      end
+    end
+    result
+  end
+
+  def description
+    return(uri ? uri : "/#{indirection_name}/#{key}")
+  end
+
+  def remote?
+    self.node or self.ip
+  end
+
+  private
+
+  def set_attributes(options)
+    OPTION_ATTRIBUTES.each do |attribute|
+      if options.include?(attribute.to_sym)
+        send(attribute.to_s + "=", options[attribute])
+        options.delete(attribute)
+      end
+    end
+  end
+
+  # Parse the key as a URI, setting attributes appropriately.
+  def set_uri_key(key)
+    @uri = key
+    begin
+      # calling uri_encode for UTF-8 characters will % escape them and keep them UTF-8
+      uri = URI.parse(Puppet::Util.uri_encode(key))
+    rescue => detail
+      raise ArgumentError, _("Could not understand URL %{key}: %{detail}") % { key: key, detail: detail }, detail.backtrace
+    end
+
+    # Just short-circuit these to full paths
+    if uri.scheme == "file"
+      @key = Puppet::Util.uri_to_path(uri)
+      return
+    end
+
+    @server = uri.host if uri.host && !uri.host.empty?
+
+    # If the URI class can look up the scheme, it will provide a port,
+    # otherwise it will default to '0'.
+    if uri.port.to_i == 0 and uri.scheme == "puppet"
+      @port = Puppet.settings[:serverport].to_i
+    else
+      @port = uri.port.to_i
+    end
+
+    # filebucket:// is only used internally to pass request details
+    # from Dipper objects to the indirector. The wire always uses HTTPS.
+    if uri.scheme == 'filebucket'
+      @protocol = 'https'
+    else
+      @protocol = uri.scheme
+    end
+
+    @key = Puppet::Util.uri_unescape(uri.path.sub(/^\//, ''))
+  end
+end

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

@@ -0,0 +1,66 @@
+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 { |s| s.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 do |res|
+      res.to_resource
+    end.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,12 @@
+require_relative '../../../puppet/indirector/store_configs'
+require_relative '../../../puppet/indirector/resource/validator'
+
+class Puppet::Resource::StoreConfigs < Puppet::Indirector::StoreConfigs
+  include Puppet::Resource::Validator
+
+  desc %q{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,8 @@
+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