puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/direct_file_server.rb

@@ -0,0 +1,19 @@
+require 'puppet/file_serving/terminus_helper'
+require 'puppet/indirector/terminus'
+
+class Puppet::Indirector::DirectFileServer < Puppet::Indirector::Terminus
+
+  include Puppet::FileServing::TerminusHelper
+
+  def find(request)
+    return nil unless Puppet::FileSystem.exist?(request.key)
+    instance = model.new(request.key)
+    instance.links = request.options[:links] if request.options[:links]
+    instance
+  end
+
+  def search(request)
+    return nil unless Puppet::FileSystem.exist?(request.key)
+    path2instances(request, request.key)
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/envelope.rb

@@ -0,0 +1,11 @@
+require 'puppet/indirector'
+
+# Provide any attributes or functionality needed for indirected
+# instances.
+module Puppet::Indirector::Envelope
+  attr_accessor :expiration
+
+  def expired?
+    expiration and expiration < Time.now
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/errors.rb

@@ -0,0 +1,5 @@
+require 'puppet/error'
+
+module Puppet::Indirector
+  class ValidationError < Puppet::Error; end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/exec.rb

@@ -0,0 +1,38 @@
+require 'puppet/indirector/terminus'
+require 'puppet/util'
+
+class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
+  # Look for external node definitions.
+  def find(request)
+    name = request.key
+    external_command = command
+
+    # Make sure it's an array
+    raise Puppet::DevError, "Exec commands must be an array" unless external_command.is_a?(Array)
+
+    # Make sure it's fully qualified.
+    raise ArgumentError, "You must set the exec parameter to a fully qualified command" unless Puppet::Util.absolute_path?(external_command[0])
+
+    # Add our name to it.
+    external_command << name
+    begin
+      output = execute(external_command, :failonfail => true, :combine => false)
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Failed to find #{name} via exec: #{detail}", detail.backtrace
+    end
+
+    if output =~ /\A\s*\Z/ # all whitespace
+      Puppet.debug "Empty response for #{name} from #{self.name} terminus"
+      return nil
+    else
+      return output
+    end
+  end
+
+  private
+
+  # Proxy the execution, so it's easier to test.
+  def execute(command, arguments)
+    Puppet::Util::Execution.execute(command,arguments)
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/face.rb

@@ -0,0 +1,139 @@
+require '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
+      result = indirection.__send__(method, key, options)
+    rescue => detail
+      message = "Could not call '#{method}' on '#{indirection_name}': #{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 {|key, options| call_indirection_method :find, key, options[:extra] }
+  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 t = indirection.terminus_class
+        "Run mode '#{Puppet.run_mode.name}': #{t}"
+      else
+        "No default terminus class for run 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_name}"
+    end
+    @indirection
+  end
+
+  def set_terminus(from)
+    begin
+      indirection.terminus_class = from
+    rescue => detail
+      msg = "Could not set '#{indirection.name}' terminus to '#{from}' (#{detail}); valid terminus types are #{self.class.terminus_classes(indirection.name).join(", ") }"
+      raise detail, msg, detail.backtrace
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/facts/active_record.rb

@@ -0,0 +1,44 @@
+require 'puppet/rails/fact_name'
+require 'puppet/rails/fact_value'
+require 'puppet/rails/host'
+require 'puppet/indirector/active_record'
+
+class Puppet::Node::Facts::ActiveRecord < Puppet::Indirector::ActiveRecord
+  use_ar_model Puppet::Rails::Host
+
+  desc "A component of ActiveRecord storeconfigs and inventory. ActiveRecord-based storeconfigs
+    and inventory are deprecated. See http://links.puppetlabs.com/activerecord-deprecation"
+
+  def initialize
+    Puppet.deprecation_warning "ActiveRecord-based storeconfigs and inventory are deprecated. See http://links.puppetlabs.com/activerecord-deprecation"
+    super
+  end
+
+  # Find the Rails host and pull its facts as a Facts instance.
+  def find(request)
+    return nil unless host = ar_model.find_by_name(request.key, :include => {:fact_values => :fact_name})
+
+    facts = Puppet::Node::Facts.new(host.name)
+    facts.values = host.get_facts_hash.inject({}) do |hash, ary|
+      # Convert all single-member arrays into plain values.
+      param = ary[0]
+      values = ary[1].collect { |v| v.value }
+      values = values[0] if values.length == 1
+      hash[param] = values
+      hash
+    end
+
+    facts
+  end
+
+  # Save the values from a Facts instance as the facts on a Rails Host instance.
+  def save(request)
+    facts = request.instance
+
+    host = ar_model.find_by_name(facts.name) || ar_model.create(:name => facts.name)
+
+    host.merge_facts(facts.values)
+
+    host.save
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/facts/couch.rb

@@ -0,0 +1,36 @@
+require 'puppet/node/facts'
+require 'puppet/indirector/couch'
+class Puppet::Node::Facts::Couch < Puppet::Indirector::Couch
+
+  desc "DEPRECATED. This terminus will be removed in Puppet 4.0.
+
+    Store facts in CouchDB. This should not be used with the inventory service;
+    it is for more obscure custom integrations. If you are wondering whether you
+    should use it, you shouldn't; use PuppetDB instead."
+  # Return the facts object or nil if there is no document
+  def find(request)
+    doc = super
+    doc ? model.new(doc['_id'], doc['facts']) : nil
+  end
+
+  private
+
+  # Facts values are stored to the document's 'facts' attribute. Hostname is
+  # stored to 'name'
+  #
+  def hash_from(request)
+    super.merge('facts' => request.instance.values)
+  end
+
+  # Facts are stored to the 'node' document.
+  def document_type_for(request)
+    'node'
+  end
+
+  # The id used to store the object in couchdb.
+  def id_for(request)
+    request.key.to_s
+  end
+
+end
+

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/facts/facter.rb

@@ -0,0 +1,78 @@
+require 'puppet/node/facts'
+require '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 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)
+    Facter.reset
+    self.class.setup_external_search_paths(request) if Puppet.features.external_facts?
+    self.class.setup_search_paths(request)
+
+    result = Puppet::Node::Facts.new(request.key, Facter.to_hash)
+    result.add_local_facts
+    Puppet[:stringify_facts] ? result.stringify : result.sanitize
+    result
+  end
+
+  private
+
+  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
+
+    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
+
+    Facter.search_external dirs
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/facts/inventory_active_record.rb

@@ -0,0 +1,110 @@
+require 'puppet/rails'
+require 'puppet/rails/inventory_node'
+require 'puppet/rails/inventory_fact'
+require 'puppet/indirector/active_record'
+require 'puppet/util/retryaction'
+
+class Puppet::Node::Facts::InventoryActiveRecord < Puppet::Indirector::ActiveRecord
+
+  desc "Medium-performance fact storage suitable for the inventory service.
+    Most users should use PuppetDB instead. Note: ActiveRecord-based storeconfigs
+    and inventory are deprecated. See http://links.puppetlabs.com/activerecord-deprecation"
+
+  def initialize
+    raise Puppet::Error, "ActiveRecords-based inventory is unsupported with Ruby 2 and Rails 3.0" if RUBY_VERSION[0] == '2'
+    Puppet.deprecation_warning "ActiveRecord-based storeconfigs and inventory are deprecated. See http://links.puppetlabs.com/activerecord-deprecation"
+    super
+  end
+
+  def find(request)
+    node = Puppet::Rails::InventoryNode.find_by_name(request.key)
+    return nil unless node
+    facts = Puppet::Node::Facts.new(node.name, node.facts_to_hash)
+    facts.timestamp = node.timestamp
+    facts
+  end
+
+  def save(request)
+    Puppet::Util::RetryAction.retry_action :retries => 4, :retry_exceptions => {ActiveRecord::StatementInvalid => 'MySQL Error.  Retrying'} do
+      facts = request.instance
+      node = Puppet::Rails::InventoryNode.find_by_name(request.key) || Puppet::Rails::InventoryNode.create(:name => request.key, :timestamp => facts.timestamp)
+      node.timestamp = facts.timestamp
+
+      ActiveRecord::Base.transaction do
+        Puppet::Rails::InventoryFact.delete_all(:node_id => node.id)
+        # We don't want to save internal values as facts, because those are
+        # metadata that belong on the node
+        facts.values.each do |name,value|
+          next if name.to_s =~ /^_/
+          node.facts.build(:name => name, :value => value)
+        end
+        node.save
+      end
+    end
+  end
+
+  def search(request)
+    return [] unless request.options
+    matching_nodes = []
+    fact_filters = Hash.new {|h,k| h[k] = []}
+    meta_filters = Hash.new {|h,k| h[k] = []}
+    request.options.each do |key,value|
+      type, name, operator = key.to_s.split(".")
+      operator ||= "eq"
+      if type == "facts"
+        fact_filters[operator] << [name,value]
+      elsif type == "meta" and name == "timestamp"
+        meta_filters[operator] << [name,value]
+      end
+    end
+
+    matching_nodes = nodes_matching_fact_filters(fact_filters) + nodes_matching_meta_filters(meta_filters)
+
+    # to_a because [].inject == nil
+    matching_nodes.inject {|nodes,this_set| nodes & this_set}.to_a.sort
+  end
+
+  private
+
+  def nodes_matching_fact_filters(fact_filters)
+    node_sets = []
+    fact_filters['eq'].each do |name,value|
+      node_sets << Puppet::Rails::InventoryNode.has_fact_with_value(name,value).map {|node| node.name}
+    end
+    fact_filters['ne'].each do |name,value|
+      node_sets << Puppet::Rails::InventoryNode.has_fact_without_value(name,value).map {|node| node.name}
+    end
+    {
+      'gt' => '>',
+      'lt' => '<',
+      'ge' => '>=',
+      'le' => '<='
+    }.each do |operator_name,operator|
+      fact_filters[operator_name].each do |name,value|
+        facts = Puppet::Rails::InventoryFact.find_by_sql(["SELECT inventory_facts.value, inventory_nodes.name AS node_name
+                                                           FROM inventory_facts INNER JOIN inventory_nodes
+                                                           ON inventory_facts.node_id = inventory_nodes.id
+                                                           WHERE inventory_facts.name = ?", name])
+        node_sets << facts.select {|fact| fact.value.to_f.send(operator, value.to_f)}.map {|fact| fact.node_name}
+      end
+    end
+    node_sets
+  end
+
+  def nodes_matching_meta_filters(meta_filters)
+    node_sets = []
+    {
+      'eq' => '=',
+      'ne' => '!=',
+      'gt' => '>',
+      'lt' => '<',
+      'ge' => '>=',
+      'le' => '<='
+    }.each do |operator_name,operator|
+      meta_filters[operator_name].each do |name,value|
+        node_sets << Puppet::Rails::InventoryNode.find(:all, :select => "name", :conditions => ["timestamp #{operator} ?", value]).map {|node| node.name}
+      end
+    end
+    node_sets
+  end
+end