The Node handler is now obsolete. Node searching is handled through the indirector. I have not yet added the tests for the node handlers themselves, which is next.

2 files changed, 2 insertions, 660 deletions

diff --git a/test/network/handler/configuration.rb b/test/network/handler/configuration.rb
index 072fdc053..0964a4c5e 100755
--- a/test/network/handler/configuration.rb
+++ b/test/network/handler/configuration.rb
@@ -20,19 +20,6 @@ class TestHandlerConfiguration < Test::Unit::TestCase
         assert(config.local?, "Config is not considered local after being started that way")
     end
 
-    # Make sure we create the node handler when necessary.
-    def test_node_handler
-        config = Config.new
-        handler = nil
-        assert_nothing_raised("Could not create node handler") do
-            handler = config.send(:node_handler)
-        end
-        assert_instance_of(Puppet::Network::Handler.handler(:node), handler, "Did not create node handler")
-
-        # Now make sure we get the same object back again
-        assert_equal(handler.object_id, config.send(:node_handler).object_id, "Did not cache node handler")
-    end
-
     # Test creation/returning of the interpreter
     def test_interpreter
         config = Config.new
@@ -170,19 +157,14 @@ class TestHandlerConfiguration < Test::Unit::TestCase
     def test_version
         # First try the case where we can't look up the node
         config = Config.new
-        handler = Object.new
-        handler.expects(:details).with(:client).returns(false)
-        config.expects(:node_handler).returns(handler)
+        node = Object.new
+        Puppet::Node.stubs(:search).with(:client).returns(false, node)
         interp = Object.new
         assert_instance_of(Bignum, config.version(:client), "Did not return configuration version")
 
         # And then when we find the node.
         config = Config.new
-        node = Object.new
-        handler = Object.new
-        handler.expects(:details).with(:client).returns(node)
         config.expects(:update_node_check).with(node)
-        config.expects(:node_handler).returns(handler)
         interp = Object.new
         interp.expects(:configuration_version).returns(:version)
         config.expects(:interpreter).returns(interp)
diff --git a/test/network/handler/node.rb b/test/network/handler/node.rb
deleted file mode 100755
index 6b8ab9290..000000000
--- a/test/network/handler/node.rb
+++ /dev/null
@@ -1,640 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'mocha'
-require 'puppettest'
-require 'puppettest/resourcetesting'
-require 'puppettest/parsertesting'
-require 'puppettest/servertest'
-require 'puppet/network/handler/node'
-
-module NodeTesting
-    include PuppetTest
-    Node = Puppet::Network::Handler::Node
-    SimpleNode = Puppet::Node
-    
-    def mk_node_mapper
-        # First, make sure our nodesearch command works as we expect
-        # Make a nodemapper
-        mapper = tempfile()
-        ruby = %x{which ruby}.chomp
-        File.open(mapper, "w") { |f|
-            f.puts "#!#{ruby}
-            require 'yaml'
-            name = ARGV.last.chomp
-            result = {}
-
-            if name =~ /a/
-                result[:parameters] = {'one' => ARGV.last + '1', 'two' => ARGV.last + '2'}
-            end
-
-            if name =~ /p/
-                result['classes'] = [1,2,3].collect { |n| ARGV.last + n.to_s }
-            end
-
-            puts YAML.dump(result)
-            "
-        }    
-        File.chmod(0755, mapper)
-        mapper
-    end
-
-    def mk_searcher(name)
-        searcher = Object.new
-        searcher.extend(Node.node_source(name))
-        searcher.meta_def(:newnode) do |name, *args|
-            SimpleNode.new(name, *args)
-        end
-        searcher
-    end
-
-    def mk_node_source
-        @node_info = {}
-        @node_source = Node.newnode_source(:testing, :fact_merge => true) do
-            def nodesearch(key)
-                if info = @node_info[key]
-                    SimpleNode.new(info)
-                else
-                    nil
-                end
-            end
-        end
-        Puppet[:node_source] = "testing"
-
-        cleanup { Node.rm_node_source(:testing) }
-    end
-end
-
-class TestNodeHandler < Test::Unit::TestCase
-    include NodeTesting
-
-    def setup
-        super
-        mk_node_source
-    end
-
-    # Make sure that the handler includes the appropriate
-    # node source.
-    def test_initialize
-        # First try it when passing in the node source
-        handler = nil
-        assert_nothing_raised("Could not specify a node source") do
-            handler = Node.new(:Source => :testing)
-        end
-        assert(handler.metaclass.included_modules.include?(@node_source), "Handler did not include node source")
-
-        # Now use the Puppet[:node_source]
-        Puppet[:node_source] = "testing"
-        assert_nothing_raised("Could not specify a node source") do
-            handler = Node.new()
-        end
-        assert(handler.metaclass.included_modules.include?(@node_source), "Handler did not include node source")
-
-        # And make sure we throw an exception when an invalid node source is used
-        assert_raise(ArgumentError, "Accepted an invalid node source") do
-            handler = Node.new(:Source => "invalid")
-        end
-    end
-
-    # Make sure we can find and we cache a fact handler.
-    def test_fact_handler
-        handler = Node.new
-        fhandler = nil
-        assert_nothing_raised("Could not retrieve the fact handler") do
-            fhandler = handler.send(:fact_handler)
-        end
-        assert_instance_of(Puppet::Network::Handler::Facts, fhandler, "Did not get a fact handler back")
-
-        # Now call it again, making sure we're caching the value.
-        fhandler2 = nil
-        assert_nothing_raised("Could not retrieve the fact handler") do
-            fhandler2 = handler.send(:fact_handler)
-        end
-        assert_instance_of(Puppet::Network::Handler::Facts, fhandler2, "Did not get a fact handler on the second run")
-        assert_equal(fhandler.object_id, fhandler2.object_id, "Did not cache fact handler")
-    end
-
-    # Make sure we can get node facts from the fact handler.
-    def test_node_facts
-        # Check the case where we find the node.
-        handler = Node.new
-        fhandler = handler.send(:fact_handler)
-        fhandler.expects(:get).with("present").returns("a" => "b")
-
-        result = nil
-        assert_nothing_raised("Could not get facts from fact handler") do
-            result = handler.send(:node_facts, "present")
-        end
-        assert_equal({"a" => "b"}, result, "Did not get correct facts back")
-
-        # Now try the case where the fact handler knows nothing about our host
-        fhandler.expects(:get).with('missing').returns(nil)
-        result = nil
-        assert_nothing_raised("Could not get facts from fact handler when host is missing") do
-            result = handler.send(:node_facts, "missing")
-        end
-        assert_equal({}, result, "Did not get empty hash when no facts are known")
-    end
-
-    # Test our simple shorthand
-    def test_newnode
-        SimpleNode.expects(:new).with("stuff")
-        handler = Node.new
-        handler.send(:newnode, "stuff")
-    end
-
-    # Make sure we can build up the correct node names to search for
-    def test_node_names
-        handler = Node.new
-
-        # Verify that the handler asks for the facts if we don't pass them in
-        handler.expects(:node_facts).with("testing").returns({})
-        handler.send(:node_names, "testing")
-
-        handler = Node.new
-        # Test it first with no parameters
-        assert_equal(%w{testing}, handler.send(:node_names, "testing"), "Node names did not default to an array including just the node name")
-
-        # Now test it with a fully qualified name
-        assert_equal(%w{testing.domain.com testing}, handler.send(:node_names, "testing.domain.com"),
-            "Fully qualified names did not get turned into multiple names, longest first")
-
-        # And try it with a short name + domain fact
-        assert_equal(%w{testing host.domain.com host}, handler.send(:node_names, "testing", "domain" => "domain.com", "hostname" => "host"),
-            "The domain fact was not used to build up an fqdn")
-
-        # And with an fqdn
-        assert_equal(%w{testing host.domain.com host}, handler.send(:node_names, "testing", "fqdn" => "host.domain.com"),
-            "The fqdn was not used")
-
-        # And make sure the fqdn beats the domain
-        assert_equal(%w{testing host.other.com host}, handler.send(:node_names, "testing", "domain" => "domain.com", "fqdn" => "host.other.com"),
-            "The domain was used in preference to the fqdn")
-    end
-
-    # Make sure we can retrieve a whole node by name.
-    def test_details_when_we_find_nodes
-        handler = Node.new
-
-        # Make sure we get the facts first
-        handler.expects(:node_facts).with("host").returns(:facts)
-
-        # Find the node names
-        handler.expects(:node_names).with("host", :facts).returns(%w{a b c})
-
-        # Iterate across them
-        handler.expects(:nodesearch).with("a").returns(nil)
-        handler.expects(:nodesearch).with("b").returns(nil)
-
-        # Create an example node to return
-        node = SimpleNode.new("host")
-
-        # Make sure its source is set
-        node.expects(:source=).with(handler.source)
-
-        # And that the names are retained
-        node.expects(:names=).with(%w{a b c})
-
-        # And make sure we actually get it back
-        handler.expects(:nodesearch).with("c").returns(node)
-
-        handler.expects(:fact_merge?).returns(true)
-
-        # Make sure we merge the facts with the node's parameters.
-        node.expects(:fact_merge).with(:facts)
-
-        # Now call the method
-        result = nil
-        assert_nothing_raised("could not call 'details'") do
-            result = handler.details("host")
-        end
-        assert_equal(node, result, "Did not get correct node back")
-    end
-
-    # But make sure we pass through to creating default nodes when appropriate.
-    def test_details_using_default_node
-        handler = Node.new
-
-        # Make sure we get the facts first
-        handler.expects(:node_facts).with("host").returns(:facts)
-
-        # Find the node names
-        handler.expects(:node_names).with("host", :facts).returns([])
-
-        # Create an example node to return
-        node = SimpleNode.new("host")
-
-        # Make sure its source is set
-        node.expects(:source=).with(handler.source)
-
-        # And make sure we actually get it back
-        handler.expects(:nodesearch).with("default").returns(node)
-
-        # This time, have it return false
-        handler.expects(:fact_merge?).returns(false)
-
-        # And because fact_merge was false, we don't merge them.
-        node.expects(:fact_merge).never
-
-        # Now call the method
-        result = nil
-        assert_nothing_raised("could not call 'details'") do
-            result = handler.details("host")
-        end
-        assert_equal(node, result, "Did not get correct node back")
-    end
-
-    # Make sure our handler behaves rationally when it comes to getting environment data.
-    def test_environment
-        # What happens when we can't find the node
-        handler = Node.new
-        handler.expects(:details).with("fake").returns(nil)
-
-        result = nil
-        assert_nothing_raised("Could not call 'Node.environment'") do
-            result = handler.environment("fake")
-        end
-        assert_nil(result, "Got an environment for a node we could not find")
-
-        # Now for nodes we can find
-        handler = Node.new
-        node = SimpleNode.new("fake")
-        handler.expects(:details).with("fake").returns(node)
-        node.expects(:environment).returns("dev")
-
-        result = nil
-        assert_nothing_raised("Could not call 'Node.environment'") do
-            result = handler.environment("fake")
-        end
-        assert_equal("dev", result, "Did not get environment back")
-    end
-
-    # Make sure our handler behaves rationally when it comes to getting parameter data.
-    def test_parameters
-        # What happens when we can't find the node
-        handler = Node.new
-        handler.expects(:details).with("fake").returns(nil)
-
-        result = nil
-        assert_nothing_raised("Could not call 'Node.parameters'") do
-            result = handler.parameters("fake")
-        end
-        assert_nil(result, "Got parameters for a node we could not find")
-
-        # Now for nodes we can find
-        handler = Node.new
-        node = SimpleNode.new("fake")
-        handler.expects(:details).with("fake").returns(node)
-        node.expects(:parameters).returns({"a" => "b"})
-
-        result = nil
-        assert_nothing_raised("Could not call 'Node.parameters'") do
-            result = handler.parameters("fake")
-        end
-        assert_equal({"a" => "b"}, result, "Did not get parameters back")
-    end
-
-    def test_classes
-        # What happens when we can't find the node
-        handler = Node.new
-        handler.expects(:details).with("fake").returns(nil)
-
-        result = nil
-        assert_nothing_raised("Could not call 'Node.classes'") do
-            result = handler.classes("fake")
-        end
-        assert_nil(result, "Got classes for a node we could not find")
-
-        # Now for nodes we can find
-        handler = Node.new
-        node = SimpleNode.new("fake")
-        handler.expects(:details).with("fake").returns(node)
-        node.expects(:classes).returns(%w{yay foo})
-
-        result = nil
-        assert_nothing_raised("Could not call 'Node.classes'") do
-            result = handler.classes("fake")
-        end
-        assert_equal(%w{yay foo}, result, "Did not get classes back")
-    end
-
-    # We reuse the filetimeout for the node caching timeout.
-    def test_node_caching
-        handler = Node.new
-
-        node = Object.new
-        node.metaclass.instance_eval do
-            attr_accessor :time, :name
-        end
-        node.time = Time.now
-        node.name = "yay"
-
-        # Make sure caching works normally
-        assert_nothing_raised("Could not cache node") do
-            handler.send(:cache, node)
-        end
-        assert_equal(node.object_id, handler.send(:cached?, "yay").object_id, "Did not get node back from the cache")
-
-        # And that it's returned if we ask for it, instead of creating a new node.
-        assert_equal(node.object_id, handler.details("yay").object_id, "Did not use cached node")
-
-        # Now set the node's time to be a long time ago
-        node.time = Time.now - 50000
-        assert(! handler.send(:cached?, "yay"), "Timed-out node was returned from cache")
-    end
-end
-
-# Test our configuration object.
-class TestNodeSources < Test::Unit::TestCase
-    include NodeTesting
-
-    def test_node_sources
-        mod = nil
-        assert_nothing_raised("Could not add new search type") do
-            mod = Node.newnode_source(:testing) do
-                def nodesearch(name)
-                end
-            end
-        end
-        assert_equal(mod, Node.node_source(:testing), "Did not get node_source back")
-
-        cleanup do
-            Node.rm_node_source(:testing)
-            assert(! Node.const_defined?("Testing"), "Did not remove constant")
-        end
-    end
-    
-    def test_external_node_source
-        source = Node.node_source(:external)
-        assert(source, "Could not find external node source")
-        mapper = mk_node_mapper
-        searcher = mk_searcher(:external)
-        assert(searcher.fact_merge?, "External node source does not merge facts")
-
-        # Make sure it gives the right response
-        assert_equal({'classes' => %w{apple1 apple2 apple3}, :parameters => {"one" => "apple1", "two" => "apple2"}},
-            YAML.load(%x{#{mapper} apple}))
-        
-        # First make sure we get nil back by default
-        assert_nothing_raised {
-            assert_nil(searcher.nodesearch("apple"),
-                "Interp#nodesearch_external defaulted to a non-nil response")
-        }
-        assert_nothing_raised { Puppet[:external_nodes] = mapper }
-        
-        node = nil
-        # Both 'a' and 'p', so we get classes and parameters
-        assert_nothing_raised { node = searcher.nodesearch("apple") }
-        assert_equal("apple", node.name, "node name was not set correctly for apple")
-        assert_equal(%w{apple1 apple2 apple3}, node.classes, "node classes were not set correctly for apple")
-        assert_equal( {"one" => "apple1", "two" => "apple2"}, node.parameters, "node parameters were not set correctly for apple")
-        
-        # A 'p' but no 'a', so we only get classes
-        assert_nothing_raised { node = searcher.nodesearch("plum") }
-        assert_equal("plum", node.name, "node name was not set correctly for plum")
-        assert_equal(%w{plum1 plum2 plum3}, node.classes, "node classes were not set correctly for plum")
-        assert_equal({}, node.parameters, "node parameters were not set correctly for plum")
-        
-        # An 'a' but no 'p', so we only get parameters.
-        assert_nothing_raised { node = searcher.nodesearch("guava")} # no p's, thus no classes
-        assert_equal("guava", node.name, "node name was not set correctly for guava")
-        assert_equal([], node.classes, "node classes were not set correctly for guava")
-        assert_equal({"one" => "guava1", "two" => "guava2"}, node.parameters, "node parameters were not set correctly for guava")
-        
-        assert_nothing_raised { node = searcher.nodesearch("honeydew")} # neither, thus nil
-        assert_nil(node)
-    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
-
-    # 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
-        source = Node.node_source(:ldap)
-        assert(source, "Could not find ldap node source")
-        searcher = mk_searcher(:ldap)
-        assert(searcher.fact_merge?, "LDAP node source does not merge facts")
-
-        nodetable = {}
-
-        # Override the ldapsearch definition, so we don't have to actually set it up.
-        searcher.meta_def(:ldapsearch) do |name|
-            nodetable[name]
-        end
-
-        # 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
-
-    # Make sure we always get a node back from the 'none' nodesource.
-    def test_nodesource_none
-        source = Node.node_source(:none)
-        assert(source, "Could not find 'none' node source")
-        searcher = mk_searcher(:none)
-        assert(searcher.fact_merge?, "'none' node source does not merge facts")
-
-        # Run a couple of node names through it
-        node = nil
-        %w{192.168.0.1 0:0:0:3:a:f host host.domain.com}.each do |name|
-            assert_nothing_raised("Could not create an empty node with name '%s'" % name) do
-                node = searcher.nodesearch(name)
-            end
-            assert_instance_of(SimpleNode, node, "Did not get a simple node back for %s" % name)
-            assert_equal(name, node.name, "Name was not set correctly")
-        end
-    end
-end
-
-class LdapNodeTest < PuppetTest::TestCase
-    include NodeTesting
-    include PuppetTest::ServerTest
-    include PuppetTest::ParserTesting
-    include PuppetTest::ResourceTesting
-    AST = Puppet::Parser::AST
-    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
-
-    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
-
-class LdapReconnectTests < PuppetTest::TestCase
-    include NodeTesting
-    include PuppetTest::ServerTest
-    include PuppetTest::ParserTesting
-    include PuppetTest::ResourceTesting
-    AST = Puppet::Parser::AST
-    confine "Not running on culain as root" => (Puppet::Util::SUIDManager.uid == 0 and Facter.value("hostname") == "culain")
-
-    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