puppet 0.23.2 → 0.24.0

data/lib/puppet/indirector/ldap.rb

@@ -0,0 +1,90 @@
+require 'puppet/indirector/terminus'
+
+class Puppet::Indirector::Ldap < Puppet::Indirector::Terminus
+    # Perform our ldap search and process the result.
+    def find(name)
+        # We have to use 'yield' here because the LDAP::Entry objects
+        # get destroyed outside the scope of the search, strangely.
+        ldapsearch(name) { |entry| return process(name, entry) }
+
+        # Return nil if we haven't found something.
+        return nil
+    end
+
+    # Process the found entry.  We assume that we don't just want the
+    # ldap object.
+    def process(name, entry)
+        raise Puppet::DevError, "The 'process' method has not been overridden for the LDAP terminus for %s" % 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 %s" % self.name
+    end
+
+    # Find the ldap node, return the class list and parent node specially,
+    # and everything else in a parameter hash.
+    def ldapsearch(node)
+        raise ArgumentError.new("You must pass a block to ldapsearch") unless block_given?
+
+        found = false
+        count = 0
+
+        begin
+            connection.search(search_base, 2, search_filter(node), search_attributes) do |entry|
+                found = true
+                yield entry
+            end
+        rescue => 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
+                raise Puppet::Error, "LDAP Search failed: %s" % detail
+            end
+        end
+
+        return found
+    end
+
+    private
+
+    # Create an ldap connection.
+    def connection
+        unless defined? @connection and @connection
+            unless Puppet.features.ldap?
+                raise Puppet::Error, "Could not set up LDAP Connection: Missing ruby/ldap libraries"
+            end
+            begin
+                if Puppet[:ldapssl]
+                    @connection = LDAP::SSLConn.new(Puppet[:ldapserver], Puppet[:ldapport])
+                elsif Puppet[:ldaptls]
+                    @connection = LDAP::SSLConn.new(
+                        Puppet[:ldapserver], Puppet[:ldapport], true
+                    )
+                else
+                    @connection = LDAP::Conn.new(Puppet[:ldapserver], Puppet[:ldapport])
+                end
+                @connection.set_option(LDAP::LDAP_OPT_PROTOCOL_VERSION, 3)
+                @connection.set_option(LDAP::LDAP_OPT_REFERRALS, LDAP::LDAP_OPT_ON)
+                @connection.simple_bind(Puppet[:ldapuser], Puppet[:ldappassword])
+            rescue => detail
+                raise Puppet::Error, "Could not connect to LDAP: %s" % detail
+            end
+        end
+
+        return @connection
+    end
+end

data/lib/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(instance)
+        raise ArgumentError.new("Could not find %s to destroy" % instance) unless @instances.include?(instance.name)
+        @instances.delete(instance.name)
+    end
+
+    def find(name)
+        @instances[name]
+    end
+
+    def save(instance)
+        @instances[instance.name] = instance
+    end
+end

data/lib/puppet/indirector/module_files.rb

@@ -0,0 +1,82 @@
+#
+#  Created by Luke Kanies on 2007-10-19.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'puppet/util/uri_helper'
+require 'puppet/indirector/terminus'
+require 'puppet/file_serving/configuration'
+require 'puppet/file_serving/fileset'
+require 'puppet/file_serving/terminus_helper'
+
+# Look files up in Puppet modules.
+class Puppet::Indirector::ModuleFiles < Puppet::Indirector::Terminus
+    include Puppet::Util::URIHelper
+    include Puppet::FileServing::TerminusHelper
+
+    # Is the client allowed access to this key with this method?
+    def authorized?(method, key, options = {})
+        return false unless [:find, :search].include?(method)
+
+        uri = key2uri(key)
+
+        # Make sure our file path starts with /modules, so that we authorize
+        # against the 'modules' mount.
+        path = uri.path =~ /^\/modules/ ? uri.path : "/modules" + uri.path
+
+        configuration.authorized?(path, :node => options[:node], :ipaddress => options[:ipaddress])
+    end
+
+    # Find our key in a module.
+    def find(key, options = {})
+        return nil unless path = find_path(key, options)
+
+        result = model.new(key, :path => path)
+        result.links = options[:links] if options[:links]
+        return result
+    end
+
+    # Try to find our module.
+    def find_module(module_name, node_name)
+        Puppet::Module::find(module_name, environment(node_name))
+    end
+
+    # Search for a list of files.
+    def search(key, options = {})
+        return nil unless path = find_path(key, options)
+        path2instances(key, path, options)
+    end
+
+    private
+
+    # Our fileserver configuration, if needed.
+    def configuration
+        Puppet::FileServing::Configuration.create
+    end
+    
+    # Determine the environment to use, if any.
+    def environment(node_name)
+        if node_name and node = Puppet::Node.find(node_name)
+            node.environment
+        else
+            Puppet::Node::Environment.new.name
+        end
+    end
+
+    # The abstracted method for turning a key into a path; used by both :find and :search.
+    def find_path(key, options)
+        uri = key2uri(key)
+
+        # Strip off /modules if it's there -- that's how requests get routed to this terminus.
+        # Also, strip off the leading slash if present.
+        module_name, relative_path = uri.path.sub(/^\/modules\b/, '').sub(%r{^/}, '').split(File::Separator, 2)
+
+        # And use the environment to look up the module.
+        return nil unless mod = find_module(module_name, options[:node])
+
+        path = File.join(mod.files, relative_path)
+
+        return nil unless FileTest.exists?(path)
+
+        return path
+    end
+end

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

@@ -0,0 +1,52 @@
+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 `ExternalNodes`:trac: page for more information."
+    include Puppet::Util
+
+    def command
+        command = Puppet[:external_nodes]
+        unless command != "none"
+            raise ArgumentError, "You must set the 'external_nodes' parameter to use the external node terminus"
+        end
+        command.split
+    end
+
+    # Look for external node definitions.
+    def find(name)
+        output = super or return nil
+
+        # Translate the output to ruby.
+        result = translate(name, output)
+
+        return create_node(name, 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].each do |param|
+            if value = result[param]
+                node.send(param.to_s + "=", value)
+                set = true
+            end
+        end
+
+        node.fact_merge
+        return node
+    end
+
+    # Translate the yaml string into Ruby objects.
+    def translate(name, output)
+        begin
+            YAML.load(output).inject({}) { |hash, data| hash[symbolize(data[0])] = data[1]; hash }
+        rescue => detail
+            raise Puppet::Error, "Could not load external node results for %s: %s" % [name, detail]
+        end
+    end
+end

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

@@ -0,0 +1,120 @@
+require 'puppet/node'
+require 'puppet/indirector/ldap'
+
+class Puppet::Node::Ldap < Puppet::Indirector::Ldap
+    desc "Search in LDAP for node configuration information.  See
+    the `LdapNodes`:trac: page for more information."
+
+    # The attributes that Puppet class information is stored in.
+    def class_attributes
+        Puppet[:ldapclassattrs].split(/\s*,\s*/)
+    end
+
+    # Look for our node in ldap.
+    def find(name)
+        return nil unless information = super
+        node = Puppet::Node.new(name)
+
+        parent_info = nil
+        parent = information[:parent]
+        parents = [name]
+        while parent
+            if parents.include?(parent)
+                raise ArgumentError, "Found loop in LDAP node parents; %s appears twice" % parent
+            end
+            parents << parent
+
+            ldapsearch(parent) { |entry| parent_info = process(parent, entry) }
+
+            unless parent_info
+                raise Puppet::Error.new("Could not find parent node '%s'" % parent)
+            end
+            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
+
+            parent = parent_info[:parent]
+        end
+
+        node.classes = information[:classes].uniq unless information[:classes].empty?
+        node.parameters = information[:parameters] unless information[:parameters].empty?
+        node.fact_merge
+
+        return node
+    end
+
+    # The parent attribute, if we have one.
+    def parent_attribute
+        if pattr = Puppet[:ldapparentattr] and ! pattr.empty?
+            pattr
+        else
+            nil
+        end
+    end
+
+    # Process the found entry.  We assume that we don't just want the
+    # ldap object.
+    def process(name, entry)
+        result = {}
+        if pattr = parent_attribute
+            if values = entry.vals(pattr)
+                if values.length > 1
+                    raise Puppet::Error,
+                        "Node %s has more than one parent: %s" % [name, values.inspect]
+                end
+                unless values.empty?
+                    result[:parent] = values.shift
+                end
+            end
+        end
+
+        result[:classes] = []
+        class_attributes.each { |attr|
+            if values = entry.vals(attr)
+                values.each do |v| result[:classes] << v end
+            end
+        }
+
+        result[:parameters] = entry.to_hash.inject({}) do |hash, ary|
+            if ary[1].length == 1
+                hash[ary[0]] = ary[1].shift
+            else
+                hash[ary[0]] = ary[1]
+            end
+            hash
+        end
+
+        return 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
+end

data/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/lib/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(name)
+        node = super
+        node.fact_merge
+        node
+    end
+end

data/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 "This will eventually be a REST-based mechanism for finding nodes.  It is currently non-functional."
+    # TODO/FIXME
+end

data/lib/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/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(name)
+        indirection.model.new(name)
+    end
+end

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

@@ -0,0 +1,50 @@
+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(report)
+        process(report)
+    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)
+        return if Puppet[:reports] == "none"
+
+        reports().each do |name|
+            if mod = Puppet::Reports.report(name)
+                # 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
+                    if Puppet[:trace]
+                        puts detail.backtrace
+                    end
+                    Puppet.err "Report %s failed: %s" %
+                        [name, detail]
+                end
+            else
+                Puppet.warning "No report named '%s'" % name
+            end
+        end
+    end
+
+    # Handle the parsing of the reports attribute.
+    def reports
+        Puppet[:reports].gsub(/(^\s+)|(\s+$)/, '').split(/\s*,\s*/)
+    end
+end