def testStartAutoDiscoveryClient(self): '''Try to start a bootstrap node with autodiscovery on. ''' log.msg("---------------------- BEGIN testStartAutoDiscoveryClient -------------- ") self.allNodes = [] self.allMetricsObservers = [] self.allTestObservers = [] # Create Bootstrap port = 12345 enclaveStr = 'testclave' bsNodeLocation = NodeLocation(None, self.myIP, port) bootstrapNodeList = [ bsNodeLocation ] (self.bsClient, self.bsNetwork, d) = self.startBootstrapNode(enclaveStr, self.myIP, port, "authenticate:succeed", bootstrapNodeList) yield d # Now try and join with autodiscovery yield self.startClientNodeAutoDiscovery(None, self.myIP, port+1, enclaveStr, bootstrapNodeList) # Shut it all down for (clientAPI, networkAPI) in self.allNodes: yield networkAPI.disconnect() yield self.bsNetwork.disconnect() # Try and wait for connection cache to finish disconnects (just in case). yield TestUtils.waitForConnectionCache()
def testStartAutoDiscoveryClientTimeout(self): '''Try to start a bootstrap node with autodiscovery on. This should show a failure notice. ''' log.msg("---------------------- BEGIN testStartAutoDiscoveryClientTimeout -------------- ") self.allNodes = [] self.allMetricsObservers = [] self.allTestObservers = [] # Create Bootstrap port = 12345 enclaveStr = 'testclave' # Now try and join with autodiscovery d = defer.Deferred() clientAPI = SampleClient(self.myIP, port, None) networkAPI = classChordNetworkChord(clientAPI, port, self.myIP) nodeID = networkAPI.generateNodeID(str(port), enclaveStr) # Get the ID with the bits on it we need. Use "port" because it'll be uniq for tests # Join the network callFunc = lambda result, payload: self.shouldFailCallback(result, payload, d) networkAPI.start(callFunc, nodeID, enclaveStr, "authenticate:succeed", None, False, True) yield d yield TestUtils.waitForConnectionCache()
def testMultipleBSNodesAutoDiscoveryClient(self): '''Try to start multiple bootstrap nodes then a client and make sure it connects to one of them. ''' log.msg("---------------------- BEGIN testMultipleBSNodesAutoDiscoveryClient -------------- ") self.allNodes = [] self.allMetricsObservers = [] self.allTestObservers = [] # Create Bootstrap port = 12345 enclaveStr = 'testclave' bootstrapNodeList = [ NodeLocation(None, self.myIP, port), NodeLocation(None, self.myIP, port+1)] (self.bsClient1, self.bsNetwork1, d) = self.startBootstrapNode(enclaveStr, self.myIP, port, "authenticate:succeed", bootstrapNodeList) yield d (self.bsClient2, self.bsNetwork2, d) = self.startBootstrapNode(enclaveStr, self.myIP, port+1, "authenticate:succeed", None) yield d # Now try and join with autodiscovery yield self.startClientNodeAutoDiscovery(None, self.myIP, port+2, enclaveStr, bootstrapNodeList) # Shut it all down for (clientAPI, networkAPI) in self.allNodes: yield networkAPI.disconnect() yield self.bsNetwork1.disconnect() yield self.bsNetwork2.disconnect() yield TestUtils.waitForConnectionCache()
def testDisconnectedBootstraps(self): '''Create a BS node and some clients. Create another bootstrap node and some clients (so we essentially have two rings). Verify, that the bootstrap nodes autodiscover each other and connect together ''' global startingPort # Create Bootstrap port = 12345 bootstrapNodeLocation = NodeLocation(None, self.myIP, port) bootstrapNodeLocation2 = NodeLocation(None, self.myIP, port+1) self.allNodes = [] self.allMetricsObservers = [] self.allTestObservers = [] # Build the BS node (status, bsClientAPI, bsNetworkAPI) = yield TestUtils.startNodeUsingAPI(bootstrapNodeLocation.ip, bootstrapNodeLocation.port, None, 'theEnclave', True, True) self.allMetricsObservers.append(MetricsMessageObserver(bsNetworkAPI.chordNode)) self.assertTrue(status, 'Could not build bootstrap node') # Build second BS node (status, bsClientAPI2, bsNetworkAPI2) = yield TestUtils.startNodeUsingAPI(bootstrapNodeLocation2.ip, bootstrapNodeLocation2.port, None, 'theEnclave', True, True) self.allMetricsObservers.append(MetricsMessageObserver(bsNetworkAPI2.chordNode)) self.assertTrue(status, 'Could not build bootstrap node 2') # Build the client node (status, clClientAPI, clNetworkAPI) = yield TestUtils.startNodeUsingAPI(self.myIP, port+2, bootstrapNodeLocation, 'theEnclave', False, False) self.allMetricsObservers.append(MetricsMessageObserver(clNetworkAPI.chordNode)) self.assertTrue(status, 'Could not build client node') # Build the client node (status, clClientAPI2, clNetworkAPI2) = yield TestUtils.startNodeUsingAPI(self.myIP, port+3, bootstrapNodeLocation2, 'theEnclave', False, False) self.allMetricsObservers.append(MetricsMessageObserver(clNetworkAPI2.chordNode)) self.assertTrue(status, 'Could not build client node') # Wait for flooding to reach all the nodes waiter = ConnectivityCounter() yield waiter.waitForConnectivity(3, clNetworkAPI.chordNode) # Does not count clNode itself. # Now shut everything down yield clNetworkAPI.disconnect() yield clNetworkAPI2.disconnect() yield bsNetworkAPI.disconnect() yield bsNetworkAPI2.disconnect() if Config.USE_CONNECTION_CACHE: yield TestUtils.waitForConnectionCache() else: yield TestUtils.wait(5) defer.returnValue(True)
def testStartAutoDiscoverySameNodeError(self): '''Try to start a bootstrap node and then two clients on the same port with autodiscovery on. Should log an error when the second node attempts to join. ''' log.msg("---------------------- BEGIN testStartAutoDiscoverySameNodeError -------------- ") self.allNodes = [] self.allMetricsObservers = [] self.allTestObservers = [] # Create Bootstrap port = 12345 enclaveStr = 'testclave' bsNodeLocation = NodeLocation(None, self.myIP, port) bootstrapNodeList = [ bsNodeLocation ] (self.bsClient, self.bsNetwork, d) = self.startBootstrapNode(enclaveStr, self.myIP, port, "authenticate:succeed", bootstrapNodeList) yield d # Now startup one client which will succeed d2 = defer.Deferred() port = port + 1 clientAPI = SampleClient(self.myIP, port, None) networkAPI = classChordNetworkChord(clientAPI, port, self.myIP) nodeID = networkAPI.generateNodeID(str(port), enclaveStr) # Get the ID with the bits on it we need. Use "port" because it'll be uniq for tests # Join the network callFunc = lambda result, payload: self.shouldSucceedCallback(result, payload, d2, networkAPI) networkAPI.start(callFunc, nodeID, enclaveStr, "authenticate:succeed", bootstrapNodeList, False, True) yield d2 # Now startup one which should fail due to duplicate port d3 = defer.Deferred() clientAPI2 = SampleClient(self.myIP, port, None) networkAPI2 = classChordNetworkChord(clientAPI2, port, self.myIP) nodeID = networkAPI.generateNodeID(str(port), enclaveStr) # Get the ID with the bits on it we need. Use "port" because it'll be uniq for tests # Join the network callFunc2 = lambda result, payload: self.shouldFailureCallback(result, payload, d3) networkAPI2.start(callFunc2, nodeID, enclaveStr, "authenticate:succeed",bootstrapNodeList, False, True) yield d3 yield networkAPI.disconnect() #yield networkAPI2.disconnect() yield self.bsNetwork.disconnect() # Try and wait for connection cache to finish disconnects (just in case). yield TestUtils.waitForConnectionCache()
def testNodeAuth(self): log.msg("---> Starting BootstrapNode") yield self.startBootStrapNode() log.msg("---> Creating Good Client") yield self.startClientNode(self.myIP, 12350, self.bootstrapNodeLocation, self.enclaveStr) log.msg("---> Creating Bad Client") yield self.startBadClientNode(self.myIP, 12351, self.bootstrapNodeLocation, self.enclaveStr) # Shut it all down for (clientAPI, networkAPI) in self.allNodes: yield networkAPI.disconnect() yield self.bsNetwork.disconnect() if Config.USE_CONNECTION_CACHE: yield TestUtils.waitForConnectionCache() else: yield TestUtils.wait(2) defer.returnValue(True)
def testAutoDiscoveryRebootstrap(self): '''Try to start a bootstrap node and client with autodiscovery on. Then start another bootstrap node. Then kill first bootstrap node and have client try to re-bootstrap to new bootstrap node. ''' log.msg("---------------------- BEGIN testAutoDiscoveryRebootstrap -------------- ") self.allNodes = [] self.allMetricsObservers = [] self.allTestObservers = [] # Create Bootstrap port = 12345 enclaveStr = 'testclave' bsNodeLocation = NodeLocation(None, self.myIP, port) bootstrapNodeList = [ bsNodeLocation ] log.msg("Starting bootstrap... \n\n") (self.bsClient, self.bsNetwork, d) = self.startBootstrapNode(enclaveStr, self.myIP, port, "authenticate:succeed", bootstrapNodeList) yield d # Now try and join with autodiscovery yield TestUtils.wait(1) log.msg("Starting client... \n\n") yield self.startClientNodeAutoDiscovery(None, self.myIP, port+1, enclaveStr, bootstrapNodeList) # Now start a second bootstrap node #NOT DONE YET log.msg("Shutting down client... \n\n") # Shut it all down for (clientAPI, networkAPI) in self.allNodes: yield networkAPI.disconnect() yield self.bsNetwork.disconnect() # Try and wait for connection cache to finish disconnects (just in case). yield TestUtils.waitForConnectionCache()
def testStartAutoDiscoveryMultipleClients(self): '''Try to start a bootstrap node and the many many clients all at once with autodiscovery on. ''' log.msg("---------------------- BEGIN testStartAutoDiscoveryMultipleClients -------------- ") self.allNodes = [] self.allMetricsObservers = [] self.allTestObservers = [] numNodes = 15 # Create Bootstrap port = 12345 enclaveStr = 'testclave' bootstrapNodeList = [ NodeLocation(None, self.myIP, port) ] (self.bsClient, self.bsNetwork, d) = self.startBootstrapNode(enclaveStr, self.myIP, port, "authenticate:succeed", bootstrapNodeList) yield d # Now try and join a bunch of nodes with autodiscovery allDefs = [] # A list of deferreds for counter in range(numNodes): allDefs.append(self.startClientNodeAutoDiscovery(None, self.myIP, port+1+counter, enclaveStr, bootstrapNodeList)) dl = defer.DeferredList(allDefs) yield dl # Wait for all deferred joins to complete # Shut it all down for (clientAPI, networkAPI) in self.allNodes: yield networkAPI.disconnect() yield self.bsNetwork.disconnect() if Config.USE_CONNECTION_CACHE: # Try and wait for connection cache to finish disconnects (just in case). yield TestUtils.waitForConnectionCache() else: # Wait a few seconds for network timeouts yield TestUtils.wait(5)
def testReBootstrap(self): '''Create a BS node, then a client node, then kill the BS Node, wait, restart a BS node and check for re-Bootstrap ''' global startingPort # Create Bootstrap port = 12345 bootstrapNodeLocation = NodeLocation(None, self.myIP, port) self.allNodes = [] self.allMetricsObservers = [] self.allTestObservers = [] # Build the BS node log.msg("building BS node...") (status, bsClientAPI, bsNetworkAPI) = yield TestUtils.startNodeUsingAPI(self.myIP, port, None, 'theEnclave', False, True) self.assertTrue(status, 'Could not build bootstrap node') # Build the client node log.msg("building client node...") (status, clClientAPI, clNetworkAPI) = yield TestUtils.startNodeUsingAPI(self.myIP, port+1, bootstrapNodeLocation, 'theEnclave', False, False) self.assertTrue(status, 'Could not build client node') # Check that the client is connected to something connected = yield clNetworkAPI.isConnected() self.assertTrue(connected, "Client did not connect to the bootstrap node in testReBootstrap!") # Now kill the BS node yield bsNetworkAPI.disconnect() bsNetworkAPI = None bsClientAPI = None # Gotta wait for disconnect to really finish yield TestUtils.waitForConnectionCache() # Check that the client is connected to something connected = yield clNetworkAPI.isConnected() self.assertTrue(not connected, "Client remains connected to the bootstrap node in testReBootstrap after killing BS node!") # Now startup another bootstrap node log.msg("building BS node...") (status, bsClientAPI, bsNetworkAPI) = yield TestUtils.startNodeUsingAPI(self.myIP, port, None, 'theEnclave', False, True) self.assertTrue(status, 'Could not build second bootstrap node') # Wait for it to connect or fail -- basically waiting for the # maintenance call to run correctly. for _ in range(10): # Check that the client is connected to something connected = yield clNetworkAPI.isConnected() if connected: break yield TestUtils.wait(1) self.assertTrue(connected, "Client could not re-bootstrap!") # Now shut everything down log.msg("\n\ntestReBootstrap: Shutting down now...\n\n") yield clNetworkAPI.disconnect() yield bsNetworkAPI.disconnect() if Config.USE_CONNECTION_CACHE: yield TestUtils.waitForConnectionCache() else: yield TestUtils.wait(5) defer.returnValue(True)