puppet-retrospec 0.7.0 → 0.7.2

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

@@ -0,0 +1,22 @@
+require 'puppet/rails/host'
+require 'puppet/indirector/active_record'
+require 'puppet/node'
+
+class Puppet::Node::ActiveRecord < Puppet::Indirector::ActiveRecord
+  use_ar_model Puppet::Rails::Host
+
+  desc "A component of ActiveRecord storeconfigs. 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
+
+  def find(request)
+    node = super
+    node.environment = request.environment
+    node.fact_merge
+    node
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'puppet/node'
+require 'puppet/indirector/exec'
+
+class Puppet::Node::Exec < Puppet::Indirector::Exec
+  desc "Call an external program to get node information.  See
+  the [External Nodes](http://docs.puppetlabs.com/guides/external_nodes.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)
+
+    # 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)
+  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)
+    node = Puppet::Node.new(name)
+    set = false
+    [:parameters, :classes, :environment].each do |param|
+      if value = result[param]
+        node.send(param.to_s + "=", value)
+        set = true
+      end
+    end
+
+    node.fact_merge
+    node
+  end
+
+  # Translate the yaml string into Ruby objects.
+  def translate(name, output)
+    YAML.load(output).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 #{data[0].class}, not a string or symbol"
+      end
+
+      hash
+    end
+
+  rescue => detail
+      raise Puppet::Error, "Could not load external node results for #{name}: #{detail}", detail.backtrace
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/node/ldap.rb

@@ -0,0 +1,257 @@
+require 'puppet/node'
+require 'puppet/indirector/ldap'
+
+class Puppet::Node::Ldap < Puppet::Indirector::Ldap
+  desc "Search in LDAP for node configuration information.  See
+  the [LDAP Nodes](http://docs.puppetlabs.com/guides/ldap_nodes.html) page for more information.  This will first
+  search for whatever the certificate name is, then (if that name
+  contains a `.`) for the short name, then `default`."
+
+  # The attributes that Puppet class information is stored in.
+  def class_attributes
+    Puppet[:ldapclassattrs].split(/\s*,\s*/)
+  end
+
+  # Separate this out so it's relatively atomic.  It's tempting to call
+  # process instead of name2hash() here, but it ends up being
+  # difficult to test because all exceptions get caught by ldapsearch.
+  # LAK:NOTE Unfortunately, the ldap support is too stupid to throw anything
+  # but LDAP::ResultError, even on bad connections, so we are rough-handed
+  # with our error handling.
+  def name2hash(name)
+    info = nil
+    ldapsearch(search_filter(name)) { |entry| info = entry2hash(entry) }
+    info
+  end
+
+  # Look for our node in ldap.
+  def find(request)
+    names = [request.key]
+    names << request.key.sub(/\..+/, '') if request.key.include?(".") # we assume it's an fqdn
+    names << "default"
+
+    node = nil
+    names.each do |name|
+      next unless info = name2hash(name)
+
+      merge_parent(info) if info[:parent]
+      info[:environment] ||= request.environment
+      node = info2node(request.key, info)
+      break
+    end
+
+    node
+  end
+
+  # Find more than one node.  LAK:NOTE This is a bit of a clumsy API, because the 'search'
+  # method currently *requires* a key.  It seems appropriate in some cases but not others,
+  # and I don't really know how to get rid of it as a requirement but allow it when desired.
+  def search(request)
+    if classes = request.options[:class]
+      classes = [classes] unless classes.is_a?(Array)
+      filter = "(&(objectclass=puppetClient)(puppetclass=" + classes.join(")(puppetclass=") + "))"
+    else
+      filter = "(objectclass=puppetClient)"
+    end
+
+    infos = []
+    ldapsearch(filter) { |entry| infos << entry2hash(entry, request.options[:fqdn]) }
+
+    return infos.collect do |info|
+      merge_parent(info) if info[:parent]
+      info[:environment] ||= request.environment
+      info2node(info[:name], info)
+    end
+  end
+
+  # The parent attribute, if we have one.
+  def parent_attribute
+    if pattr = Puppet[:ldapparentattr] and ! pattr.empty?
+      pattr
+    else
+      nil
+    end
+  end
+
+  # The attributes that Puppet will stack as array over the full
+  # hierarchy.
+  def stacked_attributes(dummy_argument=:work_arround_for_ruby_GC_bug)
+    Puppet[:ldapstackedattrs].split(/\s*,\s*/)
+  end
+
+  # Convert the found entry into a simple hash.
+  def entry2hash(entry, fqdn = false)
+    result = {}
+
+    cn  = entry.dn[     /cn\s*=\s*([^,\s]+)/i,1]
+    dcs = entry.dn.scan(/dc\s*=\s*([^,\s]+)/i)
+    result[:name]    = fqdn ? ([cn]+dcs).join('.') : cn
+    result[:parent] = get_parent_from_entry(entry) if parent_attribute
+    result[:classes] = get_classes_from_entry(entry)
+    result[:stacked] = get_stacked_values_from_entry(entry)
+    result[:parameters] = get_parameters_from_entry(entry)
+
+    result[:environment] = result[:parameters]["environment"] if result[:parameters]["environment"]
+
+    result[:stacked_parameters] = {}
+
+    if result[:stacked]
+      result[:stacked].each do |value|
+        param = value.split('=', 2)
+        result[:stacked_parameters][param[0]] = param[1]
+      end
+    end
+
+    if result[:stacked_parameters]
+      result[:stacked_parameters].each do |param, value|
+        result[:parameters][param] = value unless result[:parameters].include?(param)
+      end
+    end
+
+    result[:parameters] = convert_parameters(result[:parameters])
+
+    result
+  end
+
+  # Default to all attributes.
+  def search_attributes
+    ldapattrs = Puppet[:ldapattrs]
+
+    # results in everything getting returned
+    return nil if ldapattrs == "all"
+
+    search_attrs = class_attributes + ldapattrs.split(/\s*,\s*/)
+
+    if pattr = parent_attribute
+      search_attrs << pattr
+    end
+
+    search_attrs
+  end
+
+  # The ldap search filter to use.
+  def search_filter(name)
+    filter = Puppet[:ldapstring]
+
+    if filter.include? "%s"
+      # Don't replace the string in-line, since that would hard-code our node
+      # info.
+      filter = filter.gsub('%s', name)
+    end
+    filter
+  end
+
+  private
+
+  # Add our hash of ldap information to the node instance.
+  def add_to_node(node, information)
+    node.classes = information[:classes].uniq unless information[:classes].nil? or information[:classes].empty?
+    node.parameters = information[:parameters] unless information[:parameters].nil? or information[:parameters].empty?
+    node.environment = information[:environment] if information[:environment]
+  end
+
+  def convert_parameters(parameters)
+    result = {}
+    parameters.each do |param, value|
+      if value.is_a?(Array)
+        result[param] = value.collect { |v| convert(v) }
+      else
+        result[param] = convert(value)
+      end
+    end
+    result
+  end
+
+  # Convert any values if necessary.
+  def convert(value)
+    case value
+    when Integer, Fixnum, Bignum; value
+    when "true"; true
+    when "false"; false
+    else
+      value
+    end
+  end
+
+  # Find information for our parent and merge it into the current info.
+  def find_and_merge_parent(parent, information)
+    parent_info = name2hash(parent) || raise(Puppet::Error.new("Could not find parent node '#{parent}'"))
+    information[:classes] += parent_info[:classes]
+    parent_info[:parameters].each do |param, value|
+      # Specifically test for whether it's set, so false values are handled correctly.
+      information[:parameters][param] = value unless information[:parameters].include?(param)
+    end
+    information[:environment] ||= parent_info[:environment]
+    parent_info[:parent]
+  end
+
+  # Take a name and a hash, and return a node instance.
+  def info2node(name, info)
+    node = Puppet::Node.new(name)
+
+    add_to_node(node, info)
+
+    node.fact_merge
+
+    node
+  end
+
+  def merge_parent(info)
+    parent = info[:parent]
+
+    # Preload the parent array with the node name.
+    parents = [info[:name]]
+    while parent
+      raise ArgumentError, "Found loop in LDAP node parents; #{parent} appears twice" if parents.include?(parent)
+      parents << parent
+      parent = find_and_merge_parent(parent, info)
+    end
+
+    info
+  end
+
+  def get_classes_from_entry(entry)
+    result = class_attributes.inject([]) do |array, attr|
+      if values = entry.vals(attr)
+        values.each do |v| array << v end
+      end
+      array
+    end
+    result.uniq
+  end
+
+  def get_parameters_from_entry(entry)
+    stacked_params = stacked_attributes
+    entry.to_hash.inject({}) do |hash, ary|
+      unless stacked_params.include?(ary[0]) # don't add our stacked parameters to the main param list
+        if ary[1].length == 1
+          hash[ary[0]] = ary[1].shift
+        else
+          hash[ary[0]] = ary[1]
+        end
+      end
+      hash
+    end
+  end
+
+  def get_parent_from_entry(entry)
+    pattr = parent_attribute
+
+    return nil unless values = entry.vals(pattr)
+
+    if values.length > 1
+      raise Puppet::Error,
+        "Node entry #{entry.dn} specifies more than one parent: #{values.inspect}"
+    end
+    return(values.empty? ? nil : values.shift)
+  end
+
+  def get_stacked_values_from_entry(entry)
+    stacked_attributes.inject([]) do |result, attr|
+      if values = entry.vals(attr)
+        result += values
+      end
+      result
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/node/memory.rb

@@ -0,0 +1,10 @@
+require 'puppet/node'
+require '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/vendor/gems/puppet-3.7.3/lib/puppet/indirector/node/msgpack.rb

@@ -0,0 +1,7 @@
+require 'puppet/node'
+require '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/vendor/gems/puppet-3.7.3/lib/puppet/indirector/node/plain.rb

@@ -0,0 +1,20 @@
+require 'puppet/node'
+require '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
+    node.fact_merge
+    node
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/node/rest.rb

@@ -0,0 +1,7 @@
+require 'puppet/node'
+require '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."
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/node/store_configs.rb

@@ -0,0 +1,8 @@
+require 'puppet/indirector/store_configs'
+require '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/vendor/gems/puppet-3.7.3/lib/puppet/indirector/node/write_only_yaml.rb

@@ -0,0 +1,32 @@
+require 'puppet/node'
+require 'puppet/indirector/yaml'
+
+# This is a WriteOnlyYaml terminus that exists only for the purpose of being able to write
+# node cache data that later can be read by the YAML terminus.
+# The use case this supports is to make it possible to search among the "current nodes"
+# when Puppet DB (recommended) or other central storage of information is not available.
+#
+# @see puppet issue 16753
+# @see Puppet::Application::Master#setup_node_cache
+# @api private
+#
+class Puppet::Node::WriteOnlyYaml < Puppet::Indirector::Yaml
+  desc "Store node information as flat files, serialized using YAML,
+    does not deserialize (write only)."
+
+  # Overridden to always return nil. This is a write only terminus.
+  # @param [Object] request Ignored.
+  # @return [nil] This implementation always return nil'
+  # @api public
+  def find(request)
+    nil
+  end
+
+  # Overridden to always return nil. This is a write only terminus.
+  # @param [Object] request Ignored.
+  # @return [nil] This implementation always return nil
+  # @api public
+  def search(request)
+    nil
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/node/yaml.rb

@@ -0,0 +1,22 @@
+require 'puppet/node'
+require '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."
+
+  protected
+
+  def fix(object)
+    # This looks very strange because when the object is read from disk the
+    # environment is a string and by assigning it back onto the object it gets
+    # converted to a Puppet::Node::Environment.
+    #
+    # The Puppet::Node class can't handle this itself because we are loading
+    # with just straight YAML, which doesn't give the object a chance to modify
+    # things as it is loaded. Instead YAML simply sets the instance variable
+    # and leaves it at that.
+    object.environment = object.environment
+    object
+  end
+end