puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/indirector/ldap.rb

@@ -0,0 +1,78 @@
+require 'puppet/indirector/terminus'
+require 'puppet/util/ldap/connection'
+
+class Puppet::Indirector::Ldap < Puppet::Indirector::Terminus
+  # Perform our ldap search and process the result.
+  def find(request)
+    ldapsearch(search_filter(request.key)) { |entry| return process(entry) } || nil
+  end
+
+  # Process the found entry.  We assume that we don't just want the
+  # ldap object.
+  def process(entry)
+    raise Puppet::DevError, "The 'process' method has not been overridden for the LDAP terminus for #{self.name}"
+  end
+
+  # Default to all attributes.
+  def search_attributes
+    nil
+  end
+
+  def search_base
+    Puppet[:ldapbase]
+  end
+
+  # The ldap search filter to use.
+  def search_filter(name)
+    raise Puppet::DevError, "No search string set for LDAP terminus for #{self.name}"
+  end
+
+  # Find the ldap node, return the class list and parent node specially,
+  # and everything else in a parameter hash.
+  def ldapsearch(filter)
+    raise ArgumentError.new("You must pass a block to ldapsearch") unless block_given?
+
+    found = false
+    count = 0
+
+    begin
+      connection.search(search_base, 2, filter, search_attributes) do |entry|
+        found = true
+        yield entry
+      end
+    rescue SystemExit,NoMemoryError
+      raise
+    rescue Exception => detail
+      if count == 0
+        # Try reconnecting to ldap if we get an exception and we haven't yet retried.
+        count += 1
+        @connection = nil
+        Puppet.warning "Retrying LDAP connection"
+        retry
+      else
+        error = Puppet::Error.new("LDAP Search failed")
+        error.set_backtrace(detail.backtrace)
+        raise error
+      end
+    end
+
+    found
+  end
+
+  # Create an ldap connection.
+  def connection
+    unless @connection
+      raise Puppet::Error, "Could not set up LDAP Connection: Missing ruby/ldap libraries" unless Puppet.features.ldap?
+      begin
+        conn = Puppet::Util::Ldap::Connection.instance
+        conn.start
+        @connection = conn.connection
+      rescue => detail
+        puts detail.backtrace if Puppet[:trace]
+        raise Puppet::Error, "Could not connect to LDAP: #{detail}"
+      end
+    end
+
+    @connection
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'puppet/indirector/terminus'
+
+# Manage a memory-cached list of instances.
+class Puppet::Indirector::Memory < Puppet::Indirector::Terminus
+  def initialize
+    @instances = {}
+  end
+
+  def destroy(request)
+    raise ArgumentError.new("Could not find #{request.key} to destroy") unless @instances.include?(request.key)
+    @instances.delete(request.key)
+  end
+
+  def find(request)
+    @instances[request.key]
+  end
+
+  def save(request)
+    @instances[request.key] = request.instance
+  end
+end

data/lib/vendor/puppet/indirector/node/active_record.rb

@@ -0,0 +1,13 @@
+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
+
+  def find(request)
+    node = super
+    node.fact_merge
+    node
+  end
+end

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

@@ -0,0 +1,60 @@
+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)
+
+    create_node(request.key, result)
+  end
+
+  private
+
+  # 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}"
+  end
+end

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

@@ -0,0 +1,256 @@
+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://projects.puppetlabs.com/projects/puppet/wiki/Ldap_Nodes) 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
+    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+    x = 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)
+
+      break if node = info2node(request.key, info)
+    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|
+      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)
+    merge_parent(info) if info[:parent]
+
+    node = Puppet::Node.new(name)
+
+    add_to_node(node, info)
+
+    node.fact_merge
+
+    node
+  end
+
+  def merge_parent(info)
+    parent_info = nil
+    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/lib/vendor/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/lib/vendor/puppet/indirector/node/plain.rb

@@ -0,0 +1,19 @@
+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.fact_merge
+    node
+  end
+end

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

@@ -0,0 +1,7 @@
+require 'puppet/node'
+require 'puppet/indirector/rest'
+
+class Puppet::Node::Rest < Puppet::Indirector::REST
+  desc "This will eventually be a REST-based mechanism for finding nodes.  It is currently non-functional."
+  # TODO/FIXME
+end

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

@@ -0,0 +1,5 @@
+require 'puppet/indirector/store_configs'
+require 'puppet/node'
+
+class Puppet::Node::StoreConfigs < Puppet::Indirector::StoreConfigs
+end

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

@@ -0,0 +1,7 @@
+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."
+end

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

@@ -0,0 +1,9 @@
+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/lib/vendor/puppet/indirector/queue.rb

@@ -0,0 +1,81 @@
+require 'puppet/indirector/terminus'
+require 'puppet/util/queue'
+require 'puppet/util'
+
+# Implements the <tt>:queue</tt> abstract indirector terminus type, for storing
+# model instances to a message queue, presumably for the purpose of out-of-process
+# handling of changes related to the model.
+#
+# Relies upon Puppet::Util::Queue for registry and client object management,
+# and specifies a default queue type of <tt>:stomp</tt>, appropriate for use with a variety of message brokers.
+#
+# It's up to the queue client type to instantiate itself correctly based on Puppet configuration information.
+#
+# A single queue client is maintained for the abstract terminus, meaning that you can only use one type
+# of queue client, one message broker solution, etc., with the indirection mechanism.
+#
+# Per-indirection queues are assumed, based on the indirection name.  If the <tt>:catalog</tt> indirection makes
+# use of this <tt>:queue</tt> terminus, queue operations work against the "catalog" queue.  It is up to the queue
+# client library to handle queue creation as necessary (for a number of popular queuing solutions, queue
+# creation is automatic and not a concern).
+class Puppet::Indirector::Queue < Puppet::Indirector::Terminus
+  extend ::Puppet::Util::Queue
+  include Puppet::Util
+
+  def initialize(*args)
+    super
+    raise ArgumentError, "Queueing requires pson support" unless Puppet.features.pson?
+  end
+
+  # Queue has no idiomatic "find"
+  def find(request)
+    nil
+  end
+
+  # Place the request on the queue
+  def save(request)
+      result = nil
+      benchmark :info, "Queued #{indirection.name} for #{request.key}" do
+        result = client.publish_message(queue, request.instance.render(:pson))
+      end
+      result
+  rescue => detail
+      raise Puppet::Error, "Could not write #{request.key} to queue: #{detail}\nInstance::#{request.instance}\n client : #{client}"
+  end
+
+  def self.queue
+    indirection_name
+  end
+
+  def queue
+    self.class.queue
+  end
+
+  # Returns the singleton queue client object.
+  def client
+    self.class.client
+  end
+
+  # converts the _message_ from deserialized format to an actual model instance.
+  def self.intern(message)
+    result = nil
+    benchmark :info, "Loaded queued #{indirection.name}" do
+      result = model.convert_from(:pson, message)
+    end
+    result
+  end
+
+  # Provides queue subscription functionality; for a given indirection, use this method on the terminus
+  # to subscribe to the indirection-specific queue.  Your _block_ will be executed per new indirection
+  # model received from the queue, with _obj_ being the model instance.
+  def self.subscribe
+    client.subscribe(queue) do |msg|
+      begin
+        yield(self.intern(msg))
+      rescue => detail
+        puts detail.backtrace if Puppet[:trace]
+        Puppet.err "Error occured with subscription to queue #{queue} for indirection #{indirection_name}: #{detail}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+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
+        puts detail.backtrace if Puppet[:trace]
+        Puppet.err "Report #{name} failed: #{detail}"
+      end
+    end
+  end
+
+  # Handle the parsing of the reports attribute.
+  def reports
+    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+    x = 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}'"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+require 'puppet/indirector/rest'
+
+class Puppet::Transaction::Report::Rest < Puppet::Indirector::REST
+  desc "Get server report over HTTP via REST."
+  use_server_setting(:report_server)
+  use_port_setting(:report_port)
+end

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

@@ -0,0 +1,11 @@
+require 'puppet/transaction/report'
+require 'puppet/indirector/yaml'
+
+class Puppet::Transaction::Report::Yaml < Puppet::Indirector::Yaml
+  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
+end