openvox 7.37.1

data/lib/puppet/indirector/face.rb

@@ -0,0 +1,153 @@
+require_relative '../../puppet/face'
+
+class Puppet::Indirector::Face < Puppet::Face
+  option "--terminus _" + _("TERMINUS") do
+    summary _("The indirector terminus to use.")
+    description <<-EOT
+      Indirector faces expose indirected subsystems of Puppet. These
+      subsystems are each able to retrieve and alter a specific type of data
+      (with the familiar actions of `find`, `search`, `save`, and `destroy`)
+      from an arbitrary number of pluggable backends. In Puppet parlance,
+      these backends are called terminuses.
+
+      Almost all indirected subsystems have a `rest` terminus that interacts
+      with the puppet master's data. Most of them have additional terminuses
+      for various local data models, which are in turn used by the indirected
+      subsystem on the puppet master whenever it receives a remote request.
+
+      The terminus for an action is often determined by context, but
+      occasionally needs to be set explicitly. See the "Notes" section of this
+      face's manpage for more details.
+    EOT
+
+    before_action do |action, args, options|
+      set_terminus(options[:terminus])
+    end
+
+    after_action do |action, args, options|
+      indirection.reset_terminus_class
+    end
+  end
+
+  def self.indirections
+    Puppet::Indirector::Indirection.instances.collect { |t| t.to_s }.sort
+  end
+
+  def self.terminus_classes(indirection)
+    Puppet::Indirector::Terminus.terminus_classes(indirection.to_sym).collect { |t| t.to_s }.sort
+  end
+
+  def call_indirection_method(method, key, options)
+    begin
+      if method == :save
+        # key is really the instance to save
+        result = indirection.__send__(method, key, nil, options)
+      else
+        result = indirection.__send__(method, key, options)
+      end
+    rescue => detail
+      message = _("Could not call '%{method}' on '%{indirection}': %{detail}") % { method: method, indirection: indirection_name, detail: detail }
+      Puppet.log_exception(detail, message)
+      raise RuntimeError, message, detail.backtrace
+    end
+
+    return result
+  end
+
+  option "--extra " + _("HASH") do
+    summary _("Extra arguments to pass to the indirection request")
+    description <<-EOT
+      A terminus can take additional arguments to refine the operation, which
+      are passed as an arbitrary hash to the back-end.  Anything passed as
+      the extra value is just send direct to the back-end.
+    EOT
+    default_to do Hash.new end
+  end
+
+  action :destroy do
+    summary _("Delete an object.")
+    arguments _("<key>")
+    when_invoked {|key, options| call_indirection_method :destroy, key, options[:extra] }
+  end
+
+  action :find do
+    summary _("Retrieve an object by name.")
+    arguments _("[<key>]")
+    when_invoked do |*args|
+      # Default the key to Puppet[:certname] if none is supplied
+      if args.length == 1
+        key = Puppet[:certname]
+        options = args.last
+      else
+        key, options = *args
+      end
+      call_indirection_method :find, key, options[:extra]
+    end
+  end
+
+  action :save do
+    summary _("API only: create or overwrite an object.")
+    arguments _("<key>")
+    description <<-EOT
+      API only: create or overwrite an object. As the Faces framework does not
+      currently accept data from STDIN, save actions cannot currently be invoked
+      from the command line.
+    EOT
+    when_invoked {|key, options| call_indirection_method :save, key, options[:extra] }
+  end
+
+  action :search do
+    summary _("Search for an object or retrieve multiple objects.")
+    arguments _("<query>")
+    when_invoked {|key, options| call_indirection_method :search, key, options[:extra] }
+  end
+
+  # Print the configuration for the current terminus class
+  action :info do
+    summary _("Print the default terminus class for this face.")
+    description <<-EOT
+      Prints the default terminus class for this subcommand. Note that different
+      run modes may have different default termini; when in doubt, specify the
+      run mode with the '--run_mode' option.
+    EOT
+
+    when_invoked do |options|
+      if indirection.terminus_class
+        _("Run mode '%{mode}': %{terminus}") % { mode: Puppet.run_mode.name, terminus: indirection.terminus_class }
+      else
+        _("No default terminus class for run mode '%{mode}'") % { mode: Puppet.run_mode.name }
+      end
+    end
+  end
+
+  attr_accessor :from
+
+  def indirection_name
+    @indirection_name || name.to_sym
+  end
+
+  # Here's your opportunity to override the indirection name.  By default it
+  # will be the same name as the face.
+  def set_indirection_name(name)
+    @indirection_name = name
+  end
+
+  # Return an indirection associated with a face, if one exists;
+  # One usually does.
+  def indirection
+    unless @indirection
+      @indirection = Puppet::Indirector::Indirection.instance(indirection_name)
+      @indirection or raise _("Could not find terminus for %{indirection}") % { indirection: indirection_name }
+    end
+    @indirection
+  end
+
+  def set_terminus(from)
+    begin
+      indirection.terminus_class = from
+    rescue => detail
+      msg = _("Could not set '%{indirection}' terminus to '%{from}' (%{detail}); valid terminus types are %{types}") % { indirection: indirection.name, from: from, detail: detail, types: self.class.terminus_classes(indirection.name).join(", ") }
+      raise detail, msg, detail.backtrace
+    end
+  end
+end

data/lib/puppet/indirector/fact_search.rb

@@ -0,0 +1,60 @@
+# module containing common methods used by json and yaml facts indirection terminus
+module Puppet::Indirector::FactSearch
+  def node_matches?(facts, options)
+    options.each do |key, value|
+      type, name, operator = key.to_s.split(".")
+      operator ||= 'eq'
+
+      return false unless node_matches_option?(type, name, operator, value, facts)
+    end
+    return true
+  end
+
+  def node_matches_option?(type, name, operator, value, facts)
+    case type
+    when "meta"
+      case name
+      when "timestamp"
+        compare_timestamp(operator, facts.timestamp, Time.parse(value))
+      end
+    when "facts"
+      compare_facts(operator, facts.values[name], value)
+    end
+  end
+
+  def compare_facts(operator, value1, value2)
+    return false unless value1
+
+    case operator
+    when "eq"
+      value1.to_s == value2.to_s
+    when "le"
+      value1.to_f <= value2.to_f
+    when "ge"
+      value1.to_f >= value2.to_f
+    when "lt"
+      value1.to_f < value2.to_f
+    when "gt"
+      value1.to_f > value2.to_f
+    when "ne"
+      value1.to_s != value2.to_s
+    end
+  end
+
+  def compare_timestamp(operator, value1, value2)
+    case operator
+    when "eq"
+      value1 == value2
+    when "le"
+      value1 <= value2
+    when "ge"
+      value1 >= value2
+    when "lt"
+      value1 < value2
+    when "gt"
+      value1 > value2
+    when "ne"
+      value1 != value2
+    end
+  end
+end

data/lib/puppet/indirector/facts/facter.rb

@@ -0,0 +1,117 @@
+require_relative '../../../puppet/node/facts'
+require_relative '../../../puppet/indirector/code'
+
+class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
+  desc "Retrieve facts from Facter.  This provides a somewhat abstract interface
+    between Puppet and Facter.  It's only `somewhat` abstract because it always
+    returns the local host's facts, regardless of what you attempt to find."
+
+  def allow_remote_requests?
+    false
+  end
+
+  def destroy(facts)
+    raise Puppet::DevError, _('You cannot destroy facts in the code store; it is only used for getting facts from Facter')
+  end
+
+  def save(facts)
+    raise Puppet::DevError, _('You cannot save facts to the code store; it is only used for getting facts from Facter')
+  end
+
+  # Lookup a host's facts up in Facter.
+  def find(request)
+    Puppet.runtime[:facter].reset
+
+    # Note: we need to setup puppet's external search paths before adding the puppetversion
+    # fact. This is because in Facter 2.x, the first `Puppet.runtime[:facter].add` causes Facter to create
+    # its directory loaders which cannot be changed, meaning other external facts won't
+    # be resolved. (PUP-4607)
+    self.class.setup_external_search_paths(request)
+    self.class.setup_search_paths(request)
+
+    # Initialize core Puppet facts, such as puppetversion
+    Puppet.initialize_facts
+
+    result = if request.options[:resolve_options]
+               raise(Puppet::Error, _("puppet facts show requires version 4.0.40 or greater of Facter.")) unless Facter.respond_to?(:resolve)
+               find_with_options(request)
+             elsif Puppet[:include_legacy_facts]
+               # to_hash returns both structured and legacy facts
+               Puppet::Node::Facts.new(request.key, Puppet.runtime[:facter].to_hash)
+             else
+               # resolve does not return legacy facts unless requested
+               facts = Puppet.runtime[:facter].resolve('')
+               # some versions of Facter 4 return a Facter::FactCollection instead of
+               # a Hash, breaking API compatibility, so force a hash using `to_h`
+               Puppet::Node::Facts.new(request.key, facts.to_h)
+             end
+
+    result.add_local_facts unless request.options[:resolve_options]
+    result.sanitize
+    result
+  end
+
+  def self.setup_search_paths(request)
+    # Add any per-module fact directories to facter's search path
+    dirs = request.environment.modulepath.collect do |dir|
+      ['lib', 'plugins'].map do |subdirectory|
+        Dir.glob("#{dir}/*/#{subdirectory}/facter")
+      end
+    end.flatten + Puppet[:factpath].split(File::PATH_SEPARATOR)
+
+    dirs = dirs.select do |dir|
+      next false unless FileTest.directory?(dir)
+
+      # Even through we no longer directly load facts in the terminus,
+      # print out each .rb in the facts directory as module
+      # developers may find that information useful for debugging purposes
+      if Puppet::Util::Log.sendlevel?(:info)
+        Puppet.info _("Loading facts")
+        Dir.glob("#{dir}/*.rb").each do |file|
+          Puppet.debug { "Loading facts from #{file}" }
+        end
+      end
+
+      true
+    end
+    dirs << request.options[:custom_dir] if request.options[:custom_dir]
+    Puppet.runtime[:facter].search(*dirs)
+  end
+
+  def self.setup_external_search_paths(request)
+    # Add any per-module external fact directories to facter's external search path
+    dirs = []
+    request.environment.modules.each do |m|
+      if m.has_external_facts?
+        dir = m.plugin_fact_directory
+        Puppet.debug { "Loading external facts from #{dir}" }
+        dirs << dir
+      end
+    end
+
+    # Add system external fact directory if it exists
+    if FileTest.directory?(Puppet[:pluginfactdest])
+      dir = Puppet[:pluginfactdest]
+      Puppet.debug { "Loading external facts from #{dir}" }
+      dirs << dir
+    end
+
+    dirs << request.options[:external_dir] if request.options[:external_dir]
+    Puppet.runtime[:facter].search_external dirs
+  end
+
+  private
+
+  def find_with_options(request)
+    options = request.options
+    options_for_facter = String.new
+    options_for_facter += options[:user_query].join(' ')
+    options_for_facter += " --config #{options[:config_file]}" if options[:config_file]
+    options_for_facter += " --show-legacy" if options[:show_legacy]
+    options_for_facter += " --no-block" if options[:no_block] == false
+    options_for_facter += " --no-cache" if options[:no_cache] == false
+    options_for_facter += " --timing" if options[:timing]
+
+    Puppet::Node::Facts.new(request.key, Puppet.runtime[:facter].resolve(options_for_facter))
+  end
+end

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

@@ -0,0 +1,27 @@
+require_relative '../../../puppet/node/facts'
+require_relative '../../../puppet/indirector/json'
+require_relative '../../../puppet/indirector/fact_search'
+
+class Puppet::Node::Facts::Json < Puppet::Indirector::JSON
+  desc "Store client facts as flat files, serialized using JSON, or
+    return deserialized facts from disk."
+
+  include Puppet::Indirector::FactSearch
+  
+  def search(request)
+    node_names = []
+    Dir.glob(json_dir_path).each do |file|
+      facts = load_json_from_file(file, '')
+      if facts && node_matches?(facts, request.options)
+        node_names << facts.name
+      end
+    end
+    node_names
+  end
+
+  private
+
+  def json_dir_path
+    self.path("*")
+  end
+end

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

@@ -0,0 +1,9 @@
+require_relative '../../../puppet/node/facts'
+require_relative '../../../puppet/indirector/memory'
+
+class Puppet::Node::Facts::Memory < Puppet::Indirector::Memory
+  desc "Keep track of facts 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."
+end

data/lib/puppet/indirector/facts/network_device.rb

@@ -0,0 +1,27 @@
+require_relative '../../../puppet/node/facts'
+require_relative '../../../puppet/indirector/code'
+
+class Puppet::Node::Facts::NetworkDevice < Puppet::Indirector::Code
+  desc "Retrieve facts from a network device."
+
+  def allow_remote_requests?
+    false
+  end
+
+  # Look a device's facts up through the current device.
+  def find(request)
+    result = Puppet::Node::Facts.new(request.key, Puppet::Util::NetworkDevice.current.facts)
+
+    result.add_local_facts
+    result.sanitize
+    result
+  end
+
+  def destroy(facts)
+    raise Puppet::DevError, _("You cannot destroy facts in the code store; it is only used for getting facts from a remote device")
+  end
+
+  def save(facts)
+    raise Puppet::DevError, _("You cannot save facts to the code store; it is only used for getting facts from a remote device")
+  end
+end

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

@@ -0,0 +1,44 @@
+require_relative '../../../puppet/node/facts'
+require_relative '../../../puppet/indirector/rest'
+
+class Puppet::Node::Facts::Rest < Puppet::Indirector::REST
+  desc "Find and save facts about nodes over HTTP via REST."
+
+  def find(request)
+    session = Puppet.lookup(:http_session)
+    api = session.route_to(:puppet)
+    _, facts = api.get_facts(
+      request.key,
+      environment: request.environment.to_s
+    )
+    facts
+  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
+
+  def save(request)
+    raise ArgumentError, _("PUT does not accept options") unless request.options.empty?
+
+    session = Puppet.lookup(:http_session)
+    api = session.route_to(:puppet)
+    api.put_facts(
+      request.key,
+      facts: request.instance,
+      environment: request.environment.to_s
+    )
+
+    # preserve existing behavior
+    nil
+  rescue Puppet::HTTP::ResponseError => e
+    # always raise even if fail_on_404 is false
+    raise convert_to_http_error(e.response)
+  end
+end

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

@@ -0,0 +1,11 @@
+require_relative '../../../puppet/node/facts'
+require_relative '../../../puppet/indirector/store_configs'
+
+class Puppet::Node::Facts::StoreConfigs < Puppet::Indirector::StoreConfigs
+
+  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/facts/yaml.rb

@@ -0,0 +1,29 @@
+require_relative '../../../puppet/node/facts'
+require_relative '../../../puppet/indirector/yaml'
+require_relative '../../../puppet/indirector/fact_search'
+
+class Puppet::Node::Facts::Yaml < Puppet::Indirector::Yaml
+  desc "Store client facts as flat files, serialized using YAML, or
+    return deserialized facts from disk."
+
+  include Puppet::Indirector::FactSearch
+
+  def search(request)
+    node_names = []
+    Dir.glob(yaml_dir_path).each do |file|
+      facts = load_file(file)
+      if facts && node_matches?(facts, request.options)
+        node_names << facts.name
+      end
+    end
+    node_names
+  end
+
+  private
+
+  # Return the path to a given node's file.
+  def yaml_dir_path
+    base = Puppet.run_mode.server? ? Puppet[:yamldir] : Puppet[:clientyamldir]
+    File.join(base, 'facts', '*.yaml')
+  end
+end