Another intermediate commit. The node and fact classes are now functional and are used instead of the network handlers, which have been removed. There are some failing tests as a result, but I want to get this code committed before I massage the rest of the system to make it work again.

3 files changed, 394 insertions, 0 deletions

diff --git a/spec/unit/indirector/node/external.rb b/spec/unit/indirector/node/external.rb
new file mode 100755
index 000000000..30b2f74c2
--- /dev/null
+++ b/spec/unit/indirector/node/external.rb
@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'yaml'
+require 'puppet/indirector'
+
+describe Puppet::Indirector.terminus(:node, :external), " when searching for nodes" do
+    require 'puppet/node'
+
+    before do
+        Puppet.config[:external_nodes] = "/yay/ness"
+        @searcher = Puppet::Indirector.terminus(:node, :external).new
+
+        # Set the searcher up so that we do not need to actually call the
+        # external script.
+        @searcher.meta_def(:execute) do |command|
+            name = command.last.chomp
+            result = {}
+
+            if name =~ /a/
+                result[:parameters] = {'one' => command.last + '1', 'two' => command.last + '2'}
+            end
+
+            if name =~ /p/
+                result['classes'] = [1,2,3].collect { |n| command.last + n.to_s }
+            end
+
+            return YAML.dump(result)
+        end
+    end
+
+    it "should throw an exception if the node_source is external but no external node command is set" do
+        Puppet[:external_nodes] = "none"
+        proc { @searcher.get("foo") }.should raise_error(ArgumentError)
+    end
+
+    it "should throw an exception if the external node source is not fully qualified" do
+        Puppet[:external_nodes] = "mycommand"
+        proc { @searcher.get("foo") }.should raise_error(ArgumentError)
+    end
+
+    it "should execute the command with the node name as the only argument" do
+        command = [Puppet[:external_nodes], "yay"]
+        @searcher.expects(:execute).with(command).returns("")
+        @searcher.get("yay")
+    end
+
+    it "should return a node object" do
+        @searcher.get("apple").should be_instance_of(Puppet::Node)
+    end
+
+    it "should set the node's name" do
+        @searcher.get("apple").name.should == "apple"
+    end
+    
+    # If we use a name that has a 'p' but no 'a', then our test generator
+    # will return classes but no parameters.
+    it "should be able to configure a node's classes" do
+        node = @searcher.get("plum")
+        node.classes.should == %w{plum1 plum2 plum3}
+        node.parameters.should == {}
+    end
+    
+    # If we use a name that has an 'a' but no 'p', then our test generator
+    # will return parameters but no classes.
+    it "should be able to configure a node's parameters" do
+        node = @searcher.get("guava")
+        node.classes.should == []
+        node.parameters.should == {"one" => "guava1", "two" => "guava2"}
+    end
+    
+    it "should be able to configure a node's classes and parameters" do
+        node = @searcher.get("apple")
+        node.classes.should == %w{apple1 apple2 apple3}
+        node.parameters.should == {"one" => "apple1", "two" => "apple2"}
+    end
+
+    it "should merge node facts with returned parameters" do
+        facts = Puppet::Node::Facts.new("apple", "three" => "four")
+        Puppet::Node::Facts.expects(:get).with("apple").returns(facts)
+        node = @searcher.get("apple")
+        node.parameters["three"].should == "four"
+    end
+
+    it "should return nil when it cannot find the node" do
+        @searcher.get("honeydew").should be_nil
+    end
+    
+    # Make sure a nodesearch with arguments works
+    def test_nodesearch_external_arguments
+        mapper = mk_node_mapper
+        Puppet[:external_nodes] = "#{mapper} -s something -p somethingelse"
+        searcher = mk_searcher(:external)
+        node = nil
+        assert_nothing_raised do
+            node = searcher.nodesearch("apple")
+        end
+        assert_instance_of(SimpleNode, node, "did not create node")
+    end
+    
+    # A wrapper test, to make sure we're correctly calling the external search method.
+    def test_nodesearch_external_functional
+        mapper = mk_node_mapper
+        searcher = mk_searcher(:external)
+        
+        Puppet[:external_nodes] = mapper
+        
+        node = nil
+        assert_nothing_raised do
+            node = searcher.nodesearch("apple")
+        end
+        assert_instance_of(SimpleNode, node, "did not create node")
+    end
+
+    after do
+        Puppet.config.clear
+    end
+end
diff --git a/spec/unit/indirector/node/ldap.rb b/spec/unit/indirector/node/ldap.rb
new file mode 100755
index 000000000..c6eb45ffc
--- /dev/null
+++ b/spec/unit/indirector/node/ldap.rb
@@ -0,0 +1,243 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'yaml'
+require 'puppet/indirector'
+
+describe Puppet::Indirector.terminus(:node, :ldap), " when searching for nodes" do
+    require 'puppet/node'
+
+    def setup
+        Puppet.config[:external_nodes] = "/yay/ness"
+        @searcher = Puppet::Indirector.terminus(:node, :ldap).new
+        nodetable = {}
+        @nodetable = nodetable
+        # Override the ldapsearch definition, so we don't have to actually set it up.
+        @searcher.meta_def(:ldapsearch) do |name|
+            nodetable[name]
+        end
+    end
+
+    it "should return nil for hosts that cannot be found" do
+        @searcher.get("foo").should be_nil
+    end
+
+    it "should return Puppet::Node instances" do
+        @nodetable["foo"] = [nil, %w{}, {}]
+        @searcher.get("foo").should be_instance_of(Puppet::Node)
+    end
+
+    it "should set the node name" do
+        @nodetable["foo"] = [nil, %w{}, {}]
+        @searcher.get("foo").name.should == "foo"
+    end
+
+    it "should set the classes" do
+        @nodetable["foo"] = [nil, %w{one two}, {}]
+        @searcher.get("foo").classes.should == %w{one two}
+    end
+
+    it "should set the parameters" do
+        @nodetable["foo"] = [nil, %w{}, {"one" => "two"}]
+        @searcher.get("foo").parameters.should == {"one" => "two"}
+    end
+
+    it "should set classes and parameters from the parent node" do
+        @nodetable["foo"] = ["middle", %w{one two}, {"one" => "two"}]
+        @nodetable["middle"] = [nil, %w{three four}, {"three" => "four"}]
+        node = @searcher.get("foo")
+        node.classes.sort.should == %w{one two three four}.sort
+        node.parameters.should == {"one" => "two", "three" => "four"}
+    end
+
+    it "should prefer child parameters to parent parameters" do
+        @nodetable["foo"] = ["middle", %w{}, {"one" => "two"}]
+        @nodetable["middle"] = [nil, %w{}, {"one" => "four"}]
+        @searcher.get("foo").parameters["one"].should == "two"
+    end
+
+    it "should recurse indefinitely through parent relationships" do
+        @nodetable["foo"] = ["middle", %w{one two}, {"one" => "two"}]
+        @nodetable["middle"] = ["top", %w{three four}, {"three" => "four"}]
+        @nodetable["top"] = [nil, %w{five six}, {"five" => "six"}]
+        node = @searcher.get("foo")
+        node.parameters.should == {"one" => "two", "three" => "four", "five" => "six"}
+        node.classes.sort.should == %w{one two three four five six}.sort
+    end
+
+    # This can stay in the main test suite because it doesn't actually use ldapsearch,
+    # it just overrides the method so it behaves as though it were hitting ldap.
+    def test_ldap_nodesearch
+
+        # Make sure we get nothing for nonexistent hosts
+        node = nil
+        assert_nothing_raised do
+            node = searcher.nodesearch("nosuchhost")
+        end
+
+        assert_nil(node, "Got a node for a non-existent host")
+
+        # Now add a base node with some classes and parameters
+        nodetable["base"] = [nil, %w{one two}, {"base" => "true"}]
+
+        assert_nothing_raised do
+            node = searcher.nodesearch("base")
+        end
+
+        assert_instance_of(SimpleNode, node, "Did not get node from ldap nodesearch")
+        assert_equal("base", node.name, "node name was not set")
+
+        assert_equal(%w{one two}, node.classes, "node classes were not set")
+        assert_equal({"base" => "true"}, node.parameters, "node parameters were not set")
+
+        # Now use a different with this as the base
+        nodetable["middle"] = ["base", %w{three}, {"center" => "boo"}]
+        assert_nothing_raised do
+            node = searcher.nodesearch("middle")
+        end
+
+        assert_instance_of(SimpleNode, node, "Did not get node from ldap nodesearch")
+        assert_equal("middle", node.name, "node name was not set")
+
+        assert_equal(%w{one two three}.sort, node.classes.sort, "node classes were not set correctly with a parent node")
+        assert_equal({"base" => "true", "center" => "boo"}, node.parameters, "node parameters were not set correctly with a parent node")
+
+        # And one further, to make sure we fully recurse
+        nodetable["top"] = ["middle", %w{four five}, {"master" => "far"}]
+        assert_nothing_raised do
+            node = searcher.nodesearch("top")
+        end
+
+        assert_instance_of(SimpleNode, node, "Did not get node from ldap nodesearch")
+        assert_equal("top", node.name, "node name was not set")
+
+        assert_equal(%w{one two three four five}.sort, node.classes.sort, "node classes were not set correctly with the top node")
+        assert_equal({"base" => "true", "center" => "boo", "master" => "far"}, node.parameters, "node parameters were not set correctly with the top node")
+    end
+end
+
+describe Puppet::Indirector.terminus(:node, :ldap), " when interacting with ldap" do
+    confine "LDAP is not available" => Puppet.features.ldap?
+    confine "No LDAP test data for networks other than Luke's" => Facter.value(:domain) == "madstop.com"
+
+    def ldapconnect
+
+        @ldap = LDAP::Conn.new("ldap", 389)
+        @ldap.set_option( LDAP::LDAP_OPT_PROTOCOL_VERSION, 3 )
+        @ldap.simple_bind("", "")
+
+        return @ldap
+    end
+
+    def ldaphost(name)
+        node = Puppet::Node.new(name)
+        parent = nil
+        found = false
+        @ldap.search( "ou=hosts, dc=madstop, dc=com", 2,
+            "(&(objectclass=puppetclient)(cn=%s))" % name
+        ) do |entry|
+            node.classes = entry.vals("puppetclass") || []
+            node.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
+            parent = node.parameters["parentnode"]
+            found = true
+        end
+        raise "Could not find node %s" % name unless found
+
+        return node, parent
+    end
+
+    it "should have tests" do
+        raise ArgumentError
+    end
+
+    def test_ldapsearch
+        Puppet[:ldapbase] = "ou=hosts, dc=madstop, dc=com"
+        Puppet[:ldapnodes] = true
+
+        searcher = Object.new
+        searcher.extend(Node.node_source(:ldap))
+
+        ldapconnect()
+
+        # Make sure we get nil and nil back when we search for something missing
+        parent, classes, parameters = nil
+        assert_nothing_raised do
+            parent, classes, parameters = searcher.ldapsearch("nosuchhost")
+        end
+
+        assert_nil(parent, "Got a parent for a non-existent host")
+        assert_nil(classes, "Got classes for a non-existent host")
+
+        # Make sure we can find 'culain' in ldap
+        assert_nothing_raised do
+            parent, classes, parameters = searcher.ldapsearch("culain")
+        end
+
+        node, realparent = ldaphost("culain")
+        assert_equal(realparent, parent, "did not get correct parent node from ldap")
+        assert_equal(node.classes, classes, "did not get correct ldap classes from ldap")
+        assert_equal(node.parameters, parameters, "did not get correct ldap parameters from ldap")
+
+        # Now compare when we specify the attributes to get.
+        Puppet[:ldapattrs] = "cn"
+        assert_nothing_raised do
+            parent, classes, parameters = searcher.ldapsearch("culain")
+        end
+        assert_equal(realparent, parent, "did not get correct parent node from ldap")
+        assert_equal(node.classes, classes, "did not get correct ldap classes from ldap")
+
+        list = %w{cn puppetclass parentnode dn}
+        should = node.parameters.inject({}) { |h, a| h[a[0]] = a[1] if list.include?(a[0]); h }
+        assert_equal(should, parameters, "did not get correct ldap parameters from ldap")
+    end
+end
+
+describe Puppet::Indirector.terminus(:node, :ldap), " when connecting to ldap" do
+    confine "Not running on culain as root" => (Puppet::Util::SUIDManager.uid == 0 and Facter.value("hostname") == "culain")
+
+    it "should have tests" do
+        raise ArgumentError
+    end
+
+    def test_ldapreconnect
+        Puppet[:ldapbase] = "ou=hosts, dc=madstop, dc=com"
+        Puppet[:ldapnodes] = true
+
+        searcher = Object.new
+        searcher.extend(Node.node_source(:ldap))
+        hostname = "culain.madstop.com"
+
+        # look for our host
+        assert_nothing_raised {
+            parent, classes = searcher.nodesearch(hostname)
+        }
+
+        # Now restart ldap
+        system("/etc/init.d/slapd restart 2>/dev/null >/dev/null")
+        sleep(1)
+
+        # and look again
+        assert_nothing_raised {
+            parent, classes = searcher.nodesearch(hostname)
+        }
+
+        # Now stop ldap
+        system("/etc/init.d/slapd stop 2>/dev/null >/dev/null")
+        cleanup do
+            system("/etc/init.d/slapd start 2>/dev/null >/dev/null")
+        end
+
+        # And make sure we actually fail here
+        assert_raise(Puppet::Error) {
+            parent, classes = searcher.nodesearch(hostname)
+        }
+    end
+end
diff --git a/spec/unit/indirector/node/none.rb b/spec/unit/indirector/node/none.rb
new file mode 100755
index 000000000..d52d7ca83
--- /dev/null
+++ b/spec/unit/indirector/node/none.rb
@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/indirector'
+require 'puppet/node/facts'
+
+describe Puppet::Indirector.terminus(:node, :none), " when searching for nodes" do
+    before do
+        Puppet.config[:node_source] = "none"
+        @searcher = Puppet::Indirector.terminus(:node, :none).new
+    end
+
+    it "should create a node instance" do
+        @searcher.get("yay").should be_instance_of(Puppet::Node)
+    end
+
+    it "should create a new node with the correct name" do
+        @searcher.get("yay").name.should == "yay"
+    end
+
+    it "should merge the node's facts" do
+        facts = Puppet::Node::Facts.new("yay", "one" => "two", "three" => "four")
+        Puppet::Node::Facts.expects(:get).with("yay").returns(facts)
+        node = @searcher.get("yay")
+        node.parameters["one"].should == "two"
+        node.parameters["three"].should == "four"
+    end
+
+    after do
+        Puppet.config.clear
+    end
+end