puppet 0.24.4 → 0.24.5

data/lib/puppet/indirector/module_files.rb

@@ -14,24 +14,24 @@ class Puppet::Indirector::ModuleFiles < Puppet::Indirector::Terminus
     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)
+    def authorized?(request)
+        return false unless [:find, :search].include?(request.method)
 
-        uri = key2uri(key)
+        uri = key2uri(request.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])
+        configuration.authorized?(path, :node => request.node, :ipaddress => request.ip)
     end
 
     # Find our key in a module.
-    def find(key, options = {})
-        return nil unless path = find_path(key, options)
+    def find(request)
+        return nil unless path = find_path(request)
 
-        result = model.new(key, :path => path)
-        result.links = options[:links] if options[:links]
+        result = model.new(request.key, :path => path)
+        result.links = request.options[:links] if request.options[:links]
         return result
     end
 
@@ -41,9 +41,9 @@ class Puppet::Indirector::ModuleFiles < Puppet::Indirector::Terminus
     end
 
     # Search for a list of files.
-    def search(key, options = {})
-        return nil unless path = find_path(key, options)
-        path2instances(key, path, options)
+    def search(request)
+        return nil unless path = find_path(request)
+        path2instances(request, path)
     end
 
     private
@@ -63,15 +63,15 @@ class Puppet::Indirector::ModuleFiles < Puppet::Indirector::Terminus
     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)
+    def find_path(request)
+        uri = key2uri(request.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])
+        return nil unless mod = find_module(module_name, request.node)
 
         path = File.join(mod.files, relative_path)
 

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

@@ -15,20 +15,13 @@ class Puppet::Node::Exec < Puppet::Indirector::Exec
     end
 
     # Look for external node definitions.
-    def find(name)
+    def find(request)
         output = super or return nil
 
         # Translate the output to ruby.
-        result = translate(name, output)
+        result = translate(request.key, output)
 
-        return create_node(name, result)
-    end
-
-    # Use the version of the facts, since we assume that's the main thing
-    # that changes.  If someone wants their own way of defining version,
-    # they can easily provide their own, um, version of this class.
-    def version(name)
-        Puppet::Node::Facts.version(name)
+        return create_node(request.key, result)
     end
 
     private

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

@@ -3,7 +3,9 @@ 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 `LdapNodes`:trac: 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
@@ -11,43 +13,53 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
         x = 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)
+    # 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) }
+        return info
+    end
 
-        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
+    # Look for our node in ldap.
+    def find(request)
+        names = [request.key]
+        if request.key.include?(".") # we assume it's an fqdn
+            names << request.key.sub(/\..+/, '')
+        end
+        names << "default"
 
-            ldapsearch(parent) { |entry| parent_info = process(parent, entry) }
+        node = nil
+        names.each do |name|
+            next unless info = name2hash(name)
 
-            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
+            break if node = info2node(request.key, info)
+        end
 
-            information[:environment] ||= parent_info[:environment]
+        return node
+    end
 
-            parent = parent_info[:parent]
+    # 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
 
-        node.classes = information[:classes].uniq unless information[:classes].empty?
-        node.parameters = information[:parameters] unless information[:parameters].empty?
-        node.environment = information[:environment] if information[:environment]
-        node.fact_merge
+        infos = []
+        ldapsearch(filter) { |entry| infos << entry2hash(entry) }
 
-        return node
+        return infos.collect do |info|
+            info2node(info[:name], info)
+        end
     end
 
     # The parent attribute, if we have one.
@@ -59,15 +71,21 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
         end
     end
 
-    # Process the found entry.  We assume that we don't just want the
-    # ldap object.
-    def process(name, entry)
+    # 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)
         result = {}
+        result[:name] = entry.dn.split(',')[0].split("=")[1]
         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]
+                        "Node entry %s specifies more than one parent: %s" % [entry.dn, values.inspect]
                 end
                 unless values.empty?
                     result[:parent] = values.shift
@@ -81,19 +99,46 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
                 values.each do |v| result[:classes] << v end
             end
         }
+        result[:classes].uniq!
+
+        result[:stacked] = []
+        stacked_params = stacked_attributes
+        stacked_params.each { |attr|
+            if values = entry.vals(attr)
+                result[:stacked] = result[:stacked] + values
+            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]
+            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
 
         result[:environment] = result[:parameters]["environment"] if result[:parameters]["environment"]
 
-        return result
+        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
     end
 
     # Default to all attributes.
@@ -124,7 +169,59 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
         filter
     end
 
-    def version(name)
-        Puppet::Node::Facts.version(name)
+    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
+
+    # Find information for our parent and merge it into the current info.
+    def find_and_merge_parent(parent, information)
+        unless parent_info = name2hash(parent)
+            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
+
+        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
+            if parents.include?(parent)
+                raise ArgumentError, "Found loop in LDAP node parents; %s appears twice" % parent
+            end
+            parents << parent
+            parent = find_and_merge_parent(parent, info)
+        end
+
+        return info
     end
 end

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

@@ -11,16 +11,9 @@ class Puppet::Node::Plain < Puppet::Indirector::Plain
         node instance before it is returned."
 
     # Just return an empty node.
-    def find(name)
+    def find(request)
         node = super
         node.fact_merge
         node
     end
-
-    # Use the version of the facts, since we assume that's the main thing
-    # that changes.  If someone wants their own way of defining version,
-    # they can easily provide their own, um, version of this class.
-    def version(name)
-        Puppet::Node::Facts.version(name)
-    end
 end

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

@@ -1,7 +1,7 @@
 require 'puppet/node'
 require 'puppet/indirector/rest'
 
-class Puppet::Node::REST < 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/plain.rb

@@ -3,7 +3,7 @@ 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)
+    def find(request)
+        indirection.model.new(request.key)
     end
 end

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

@@ -10,8 +10,8 @@ class Puppet::Transaction::Report::Processor < Puppet::Indirector::Code
         Puppet.settings.use(:main, :reporting, :metrics)
     end
 
-    def save(report)
-        process(report)
+    def save(request)
+        process(request.instance)
     end
 
     private

data/lib/puppet/indirector/request.rb

@@ -0,0 +1,42 @@
+require 'puppet/indirector'
+
+# Provide any attributes or functionality needed for indirected
+# instances.
+class Puppet::Indirector::Request
+    attr_accessor :indirection_name, :key, :method, :options, :instance, :node, :ip, :authenticated
+
+    # Is this an authenticated request?
+    def authenticated?
+        # Double negative, so we just get true or false
+        ! ! authenticated
+    end
+
+    def initialize(indirection_name, method, key, options = {})
+        options ||= {}
+        raise ArgumentError, "Request options must be a hash, not %s" % options.class unless options.is_a?(Hash)
+
+        @indirection_name, @method = indirection_name, method
+
+        @options = options.inject({}) do |result, ary|
+            param, value = ary
+            if respond_to?(param.to_s + "=")
+                send(param.to_s + "=", value)
+            else
+                result[param] = value
+            end
+            result
+        end
+
+        if key.is_a?(String) or key.is_a?(Symbol)
+            @key = key
+        else
+            @instance = key
+            @key = @instance.name
+        end
+    end
+
+    # Look up the indirection based on the name provided.
+    def indirection
+        Puppet::Indirector::Indirection.instance(@indirection_name)
+    end
+end

data/lib/puppet/indirector/rest.rb

@@ -1,8 +1,56 @@
-require 'puppet/indirector/rest'
+require 'net/http'
+require 'uri'
 
 # Access objects via REST
 class Puppet::Indirector::REST < Puppet::Indirector::Terminus
-    def find(name, options = {})
-        indirection.model.new(name)
+
+    def rest_connection_details
+        { :host => Puppet[:server], :port => Puppet[:masterport].to_i }
+    end
+
+    def network_fetch(path)
+        network {|conn| conn.get("/#{path}").body }
+    end
+    
+    def network_delete(path)
+        network {|conn| conn.delete("/#{path}").body }
+    end
+    
+    def network_put(path, data)
+        network {|conn| conn.put("/#{path}", data).body }
+    end
+    
+    def find(request)
+        network_result = network_fetch("#{indirection.name}/#{request.key}")
+        raise YAML.load(network_result) if exception?(network_result)
+        indirection.model.from_yaml(network_result)
+    end
+    
+    def search(request)
+        network_results = network_fetch("#{indirection.name}s/#{request.key}")
+        raise YAML.load(network_results) if exception?(network_results)
+        YAML.load(network_results.to_s).collect {|result| indirection.model.from_yaml(result) }
+    end
+    
+    def destroy(request)
+        network_result = network_delete("#{indirection.name}/#{request.key}")
+        raise YAML.load(network_result) if exception?(network_result)
+        YAML.load(network_result.to_s)      
+    end
+    
+    def save(request)
+        network_result = network_put("#{indirection.name}/", request.instance.to_yaml)
+        raise YAML.load(network_result) if exception?(network_result)
+        indirection.model.from_yaml(network_result)
+    end
+    
+  private
+  
+    def network(&block)
+        Net::HTTP.start(rest_connection_details[:host], rest_connection_details[:port]) {|conn| yield(conn) }
+    end
+  
+    def exception?(yaml_string)
+        yaml_string =~ %r{--- !ruby/exception}
     end
 end