bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/indirector/node/ldap.rb

@@ -1,275 +0,0 @@
-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](https://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`.
-  Requires ruby-ldap with MRI ruby or jruby-ldap with puppetserver/jruby"
-
-  # 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"
-
-    facts = request.options[:facts].is_a?(Puppet::Node::Facts) ? request.options[:facts] : nil
-
-    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, facts)
-      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
-    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)
-
-    # delete from parameters to prevent "Already declered variable $environment" error
-    result[:environment] = result[:parameters].delete(: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; 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}'") % { parent: 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, facts = nil)
-    node = Puppet::Node.new(name)
-
-    add_to_node(node, info)
-
-    node.fact_merge(facts)
-
-    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") % { parent: parent } 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
-
-  # Workaround jruby-ldap 0.0.2 missing the #to_hash method
-  #
-  # @see https://github.com/jruby/jruby-ldap/pull/5
-  #
-  # @param entry [LDAP::Entry] The LDAP::Entry object to convert to a hash
-  # @return [Hash] The hash of the provided LDAP::Entry object with keys
-  #   downcased (puppet variables need to start with lowercase char)
-  def ldap_entry_to_hash(entry)
-     h = {}
-     entry.get_attributes.each { |a| h[a.downcase.to_sym] = entry[a] }
-     h[:dn] = [entry.dn]
-     h
-  end
-
-  def get_parameters_from_entry(entry)
-    stacked_params = stacked_attributes
-    ldap_entry_to_hash(entry).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} specifies more than one parent: %{parents}") % { entry: entry.dn, parents: 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/vendored/puppet/lib/puppet/indirector/node/memory.rb

@@ -1,10 +0,0 @@
-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/vendored/puppet/lib/puppet/indirector/node/msgpack.rb

@@ -1,7 +0,0 @@
-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/vendored/puppet/lib/puppet/indirector/node/plain.rb

@@ -1,21 +0,0 @@
-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
-    facts = request.options[:facts].is_a?(Puppet::Node::Facts) ? request.options[:facts] : nil
-    node.fact_merge(facts)
-    node
-  end
-end

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

@@ -1,7 +0,0 @@
-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/vendored/puppet/lib/puppet/indirector/node/store_configs.rb

@@ -1,8 +0,0 @@
-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/vendored/puppet/lib/puppet/indirector/node/write_only_yaml.rb

@@ -1,39 +0,0 @@
-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
-  def initialize
-    #TRANSLATORS 'Puppet::Node::WriteOnlyYaml' is a class and should not be translated
-    message = _('Puppet::Node::WriteOnlyYaml is deprecated and will be removed in a future release of Puppet.')
-    Puppet.warn_once('deprecations', 'Puppet::Node::WriteOnlyYaml', message)
-    super
-  end
-
-  desc "(Deprecated) 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/vendored/puppet/lib/puppet/indirector/node/yaml.rb

@@ -1,13 +0,0 @@
-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)
-    object
-  end
-end

data/vendored/puppet/lib/puppet/indirector/none.rb

@@ -1,9 +0,0 @@
-require '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/vendored/puppet/lib/puppet/indirector/plain.rb

@@ -1,9 +0,0 @@
-require '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/vendored/puppet/lib/puppet/indirector/report/msgpack.rb

@@ -1,11 +0,0 @@
-require 'puppet/transaction/report'
-require '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/vendored/puppet/lib/puppet/indirector/report/processor.rb

@@ -1,59 +0,0 @@
-require 'puppet/transaction/report'
-require 'puppet/indirector/code'
-require '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|
-      if mod = Puppet::Reports.report(name)
-        yield(mod)
-      else
-        Puppet.warning _("No report named '%{name}'") % { name: name }
-      end
-    end
-  end
-end