0
@@ -17,6 +17,11 @@ attributetype ( 1.1.3.11 NAME 'environment'
0
   EQUALITY caseIgnoreIA5Match
0
   SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )
0
 
0
+attributetype ( 1.1.3.12 NAME 'puppetvar'
0
+  DESC 'A variable setting for puppet'
0
+  EQUALITY caseIgnoreIA5Match
0
+  SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )
0
+
0
 objectclass ( 1.1.1.2 NAME 'puppetClient' SUP top AUXILIARY
0
   DESC 'Puppet Client objectclass'
0
-  MAY ( puppetclass $ parentnode $ environment ))
0
+  MAY ( puppetclass $ parentnode $ environment $ puppetvar ))

0
@@ -622,6 +622,10 @@ module Puppet
0
         :ldapclassattrs => ["puppetclass",
0
             "The LDAP attributes to use to define Puppet classes.  Values
0
             should be comma-separated."],
0
+        :ldapstackedattrs => ["puppetvar",
0
+            "The LDAP attributes that should be stacked to arrays by adding
0
+            the values in all hierarchy elements of the tree.  Values
0
+            should be comma-separated."],
0
         :ldapattrs => ["all",
0
             "The LDAP attributes to include when querying LDAP for nodes.  All
0
             returned attributes are set as variables in the top-level scope.

0
@@ -19,6 +19,8 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
0
 
0
         node = Puppet::Node.new(name)
0
 
0
+        information[:stacked_parameters] = {}
0
+
0
         parent_info = nil
0
         parent = information[:parent]
0
         parents = [name]
0
@@ -34,6 +36,10 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
0
                 raise Puppet::Error.new("Could not find parent node '%s'" % parent)
0
             end
0
             information[:classes] += parent_info[:classes]
0
+            parent_info[:stacked].each do |value|
0
+                param = value.split('=', 2)
0
+                information[:stacked_parameters][param[0]] = param[1]
0
+            end
0
             parent_info[:parameters].each do |param, value|
0
                 # Specifically test for whether it's set, so false values are handled
0
                 # correctly.
0
@@ -45,6 +51,15 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
0
             parent = parent_info[:parent]
0
         end
0
 
0
+        information[:stacked].each do |value|
0
+            param = value.split('=', 2)
0
+            information[:stacked_parameters][param[0]] = param[1]
0
+        end
0
+
0
+        information[:stacked_parameters].each do |param, value|
0
+            information[:parameters][param] = value unless information[:parameters].include?(param)
0
+        end
0
+
0
         node.classes = information[:classes].uniq unless information[:classes].empty?
0
         node.parameters = information[:parameters] unless information[:parameters].empty?
0
         node.environment = information[:environment] if information[:environment]
0
@@ -62,6 +77,12 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
0
         end
0
     end
0
 
0
+    # The attributes that Puppet will stack as array over the full
0
+    # hierarchy.
0
+    def stacked_attributes
0
+        Puppet[:ldapstackedattrs].split(/\s*,\s*/)
0
+    end
0
+
0
     # Process the found entry.  We assume that we don't just want the
0
     # ldap object.
0
     def process(name, entry)
0
@@ -85,6 +106,14 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
0
             end
0
         }
0
 
0
+        result[:stacked] = []
0
+        stacked_attributes.each { |attr|
0
+            if values = entry.vals(attr)
0
+                result[:stacked] = result[:stacked] + values
0
+            end
0
+        }
0
+        
0
+
0
         result[:parameters] = entry.to_hash.inject({}) do |hash, ary|
0
             if ary[1].length == 1
0
                 hash[ary[0]] = ary[1].shift

0
@@ -17,6 +17,7 @@ describe Puppet::Node::Ldap do
0
             @searcher.stubs(:connection).returns(@connection)
0
             @searcher.stubs(:class_attributes).returns([])
0
             @searcher.stubs(:parent_attribute).returns(nil)
0
+            @searcher.stubs(:stacked_attributes).returns([])
0
             @searcher.stubs(:search_base).returns(:yay)
0
             @searcher.stubs(:search_filter).returns(:filter)
0
 
0
@@ -195,6 +196,96 @@ describe Puppet::Node::Ldap do
0
                 proc { @searcher.find(@request) }.should raise_error(ArgumentError)
0
             end
0
         end
0
+
0
+        describe "and a puppet variable is specified" do
0
+            before do
0
+                @searcher.stubs(:stacked_attributes).returns(['puppetvar'])
0
+            end
0
+
0
+            it "should add the variable to the node parameters" do
0
+                @entry.stubs(:vals).with("puppetvar").returns(%w{one=two})
0
+                @entry.stubs(:to_hash).returns({})
0
+                @node.expects(:parameters=).with("one" => "two")
0
+                @searcher.find(@request)
0
+            end
0
+
0
+            it "should not overwrite node parameters specified as ldap object attribute" do
0
+                @entry.stubs(:vals).with("puppetvar").returns(%w{one=two})
0
+                @entry.stubs(:to_hash).returns("one" => "three")
0
+                @node.expects(:parameters=).with("one" => "three")
0
+                @searcher.find(@request)
0
+            end
0
+
0
+            it "should set entries without an equal sign to nil" do
0
+                @entry.stubs(:vals).with("puppetvar").returns(%w{one})
0
+                @entry.stubs(:to_hash).returns({})
0
+                @node.expects(:parameters=).with("one" => nil)
0
+                @searcher.find(@request)
0
+            end
0
+
0
+            it "should ignore empty entries" do
0
+                @entry.stubs(:vals).with("puppetvar").returns(%w{})
0
+                @entry.stubs(:to_hash).returns({})
0
+                @searcher.find(@request)
0
+            end
0
+        end
0
+        describe "and a puppet variable as well as a parent node are specified" do
0
+            before do
0
+                @parent = mock 'parent'
0
+
0
+                @searcher.meta_def(:search_filter) do |name|
0
+                    return name
0
+                end
0
+                @connection.stubs(:search).with { |*args| args[2] == @name              }.yields(@entry)
0
+                @connection.stubs(:search).with { |*args| args[2] == 'parent'           }.yields(@parent)
0
+
0
+                @searcher.stubs(:stacked_attributes).returns(['puppetvar'])
0
+                @searcher.stubs(:parent_attribute).returns(:parent)
0
+            end
0
+
0
+            it "should add parent node variables to the child node parameters" do
0
+                @parent.stubs(:to_hash).returns({})
0
+                @parent.stubs(:vals).with("puppetvar").returns(%w{one=two})
0
+                @parent.stubs(:vals).with(:parent).returns(nil)
0
+
0
+                @entry.stubs(:to_hash).returns({})
0
+                @entry.stubs(:vals).with("puppetvar").returns(%w{})
0
+                @entry.stubs(:vals).with(:parent).returns(%w{parent})
0
+
0
+                @node.expects(:parameters=).with("one" => "two")
0
+
0
+                @searcher.find(@request)
0
+            end
0
+
0
+            it "should overwrite parent node variables with child node parameters" do
0
+                @parent.stubs(:to_hash).returns({})
0
+                @parent.stubs(:vals).with("puppetvar").returns(%w{one=two})
0
+                @parent.stubs(:vals).with(:parent).returns(nil)
0
+
0
+                @entry.stubs(:to_hash).returns({})
0
+                @entry.stubs(:vals).with("puppetvar").returns(%w{one=three})
0
+                @entry.stubs(:vals).with(:parent).returns(%w{parent})
0
+
0
+                @node.expects(:parameters=).with("one" => "three")
0
+
0
+                @searcher.find(@request)
0
+            end
0
+
0
+            it "should not overwrite parent node parameters specified as ldap object attribute" do
0
+                @parent.stubs(:to_hash).returns("one" => "three")
0
+                @parent.stubs(:vals).with("puppetvar").returns(%w{})
0
+                @parent.stubs(:vals).with(:parent).returns(nil)
0
+
0
+                @entry.stubs(:vals).with("puppetvar").returns(%w{one=two})
0
+                @entry.stubs(:to_hash).returns({})
0
+                @entry.stubs(:vals).with(:parent).returns(%w{parent})
0
+
0
+                @node.expects(:parameters=).with("one" => "three")
0
+
0
+                @searcher.find(@request)
0
+            end
0
+
0
+        end
0
     end
0
 end
0