instrumentation/next-share/BaseLib/Test/test_secure_overlay.py

   1 # Written by Arno Bakker
   2 # see LICENSE.txt for license information
   3 #
   4 # This test checks the new SecureOverlay class created in Fall 2006
   5 #
   6 # Note that we start a new Python interpreter for each test case.
   7 # Also note we create 2 peers and thus two networking stacks. In principle,
   8 # they should use two different SecureOverlay instances (not a singleton), but
   9 # there may be some interference.
  10 #
  11 # To properly follow the test, enable debugging on BitTornado/SocketHandler,
  12 # BitTornado/ServerPortHandler and BitTornado/Rawserver in addition to
  13 # Tribler/Overlay/SecureOverlay
  14 #
  15 #
  16
  17 import sys
  18 import os
  19 import unittest
  20 from threading import Event, Thread, currentThread
  21 from socket import error as socketerror
  22 from time import sleep
  23 import tempfile
  24 from traceback import print_exc
  25 import shutil
  26
  27 from BaseLib.Core.BitTornado.RawServer import RawServer
  28 from BaseLib.Core.BitTornado.ServerPortHandler import MultiHandler
  29 from BaseLib.Core.BitTornado.BT1.MessageID import GET_METADATA
  30
  31 from M2Crypto import EC
  32 from BaseLib.Core.Overlay.SecureOverlay import SecureOverlay, OLPROTO_VER_CURRENT
  33 import BaseLib.Core.CacheDB.sqlitecachedb as sqlitecachedb
  34 from BaseLib.Core.CacheDB.SqliteCacheDBHandler import PeerDBHandler
  35 from BaseLib.Core.Utilities.utilities import show_permid_short
  36
  37 DEBUG = False
  38
  39 class FakeUserCallbackHandler:
  40     def notify(self, *args):
  41         pass
  42
  43 class FakeSession:
  44
  45     def __init__(self,lm,keypair,permid,listen_port):
  46         self.lm = lm
  47         self.keypair = keypair
  48         self.permid = permid
  49         self.listen_port = listen_port
  50         self.uch = FakeUserCallbackHandler()
  51
  52     def get_permid(self):
  53         return self.permid
  54
  55     def get_listen_port(self):
  56         return self.listen_port
  57
  58 # Thread must come as first parent class!
  59 class Peer(Thread):
  60     def __init__(self,testcase,port,secover):
  61         Thread.__init__(self)
  62         self.setDaemon(True)
  63
  64         self.testcase = testcase
  65
  66         self.doneflag = Event()
  67         config = {}
  68         config['timeout_check_interval'] = 100000
  69         config['timeout'] = 100000
  70         config['ipv6_enabled'] = 0
  71         config['minport'] = port
  72         config['maxport'] = port+5
  73         config['random_port'] = 0
  74         config['bind'] = ''
  75         config['ipv6_binds_v4'] = 0
  76         config['max_message_length'] = 2 ** 23
  77         config['torrent_collecting_dir'] = config['state_dir'] = config['install_dir'] = tempfile.mkdtemp()
  78         config['peer_icon_path'] = 'icons'
  79
  80         self.rawserver = RawServer(self.doneflag,
  81                                    config['timeout_check_interval'],
  82                                    config['timeout'],
  83                                    ipv6_enable = config['ipv6_enabled'],
  84                                    failfunc = self.report_failure,
  85                                    errorfunc = self.report_error)
  86         while 1:
  87             try:
  88                 self.listen_port = self.rawserver.find_and_bind(0,
  89                                 config['minport'], config['maxport'], config['bind'],
  90                                 reuse = True,
  91                                 ipv6_socket_style = config['ipv6_binds_v4'],
  92                                 randomizer = config['random_port'])
  93                 print >> sys.stderr,"test: Got listen port", self.listen_port
  94                 break
  95             except socketerror, e:
  96                 self.report_failure(str(e))
  97                 msg = "Couldn't not bind to listen port - " + str(e)
  98                 self.report_failure(msg)
  99                 return
 100
 101         self.multihandler = MultiHandler(self.rawserver, self.doneflag)
 102         # Note: We don't want a singleton, we want
 103         # two different instances for peer1 and peer2
 104         self.secure_overlay = secover
 105
 106         self.my_keypair = EC.gen_params(EC.NID_sect233k1)
 107         self.my_keypair.gen_key()
 108         self.my_permid = str(self.my_keypair.pub().get_der())
 109
 110
 111         self.session = FakeSession(self,self.my_keypair,self.my_permid,self.listen_port)
 112         self.peer_db = PeerDBHandler.getInstance()
 113
 114         self.secure_overlay.register(self,config['max_message_length'])
 115         print >>sys.stderr,"Peer: Setting",self.secure_overlay.get_handler(),"as handler at SocketHandler"
 116         self.rawserver.sockethandler.set_handler(self.secure_overlay.get_handler())
 117         self.secure_overlay.start_listening()
 118
 119         # Stupid rawserver goes into very long wait if there are no short
 120         # term tasks. Emulate this
 121         self.rawserver.add_task(self.dummy_task,0)
 122
 123     def run(self):
 124         print >> sys.stderr,"test: MyServer: run called by",currentThread().getName()
 125         self.multihandler.listen_forever()
 126
 127     def report_failure(self,msg):
 128         self.testcase.assertRaises(Exception, self.report_failure)
 129
 130     def report_error(self,msg):
 131         self.testcase.assertRaises(Exception, self.report_error)
 132
 133     def dummy_task(self):
 134         self.rawserver.add_task(self.dummy_task,1)
 135
 136     def get_ext_ip(self):
 137         return '127.0.0.1'
 138
 139     def shutdown(self):
 140         self.doneflag.set()
 141         self.rawserver.shutdown()
 142
 143
 144 class TestSecureOverlay(unittest.TestCase):
 145
 146     def setUp(self):
 147         self.config_path = tempfile.mkdtemp()
 148         config = {}
 149         config['state_dir'] = self.config_path
 150         config['install_dir'] = os.path.join('..','..')
 151         config['torrent_collecting_dir'] = self.config_path
 152         config['peer_icon_path'] = os.path.join(self.config_path,'peer_icons')
 153         config['superpeer'] = False
 154         sqlitecachedb.init(config, self.rawserver_fatalerrorfunc)
 155
 156         secover1 = SecureOverlay.getInstance()
 157         secover1.resetSingleton()
 158         secover2 = SecureOverlay.getInstance()
 159         secover2.resetSingleton()
 160
 161         self.peer1 = Peer(self,1234,secover1)
 162         self.peer2 = Peer(self,5678,secover2)
 163         self.peer1.start()
 164         self.peer2.start()
 165         self.wanted = False
 166         self.wanted2 = False
 167         self.got = False
 168         self.got2 = False
 169         self.first = True
 170
 171         print >>sys.stderr,"test: setUp: peer1 permid is",show_permid_short(self.peer1.my_permid)
 172         print >>sys.stderr,"test: setUp: peer2 permid is",show_permid_short(self.peer2.my_permid)
 173
 174         sleep(2) # let server threads start
 175
 176     def tearDown(self):
 177         print >> sys.stderr,"test: tearDown: waiting 10 secs"
 178         sleep(10)
 179         if self.wanted and not self.got:
 180             self.assert_(False,"callback was not called")
 181         if self.wanted2 and not self.got2:
 182             self.assert_(False,"other callback was not called")
 183         self.peer1.shutdown()
 184         self.peer2.shutdown()
 185         sleep(5)
 186         try:
 187             shutil.rmtree(self.config_path)
 188         except:
 189             # Not fatal if something goes wrong here, and Win32 often gives
 190             # spurious Permission Denied errors.
 191             #print_exc()
 192             pass
 193
 194     #
 195     # connect_dns() to an address that noone responds at
 196     #
 197     def singtest_connect_dns_to_dead_peer(self):
 198         print >> sys.stderr,"test: test_connect_dns_to_dead_peer"
 199         self.wanted = True
 200         self.peer1.secure_overlay.connect_dns(("127.0.0.1", 22220),self.connect_dns_to_dead_peer_callback)
 201         # Arno, 2009-04-23: was 2 secs, somehow the failed event comes in real slow now.
 202         sleep(4) # let rawserver thread establish connection, which should fail
 203         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 0)
 204
 205     def connect_dns_to_dead_peer_callback(self,exc,dns,permid,selver):
 206         print >> sys.stderr,"test: connect_dns_to_dead_peer_callback"
 207         self.assert_(exc is not None)
 208         self.assert_(dns == ("127.0.0.1", 22220))
 209         self.assert_(permid is None)
 210         self.got = True
 211
 212
 213     #
 214     # connect_dns() to an address that peer2 responds
 215     #
 216     def singtest_connect_dns_to_live_peer(self):
 217         print >> sys.stderr,"test: test_connect_dns_to_live_peer"
 218         self.wanted = True
 219         self.peer1.secure_overlay.connect_dns(("127.0.0.1", 5678),self.connect_dns_to_live_peer_callback)
 220         sleep(2) # let rawserver thread establish connection, which should succeed
 221         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 1)
 222         self.assert_(self.peer1.secure_overlay.iplport2oc.has_key('127.0.0.1:5678'))
 223
 224     def connect_dns_to_live_peer_callback(self,exc,dns,permid,selver):
 225         print >> sys.stderr,"test: connect_dns_to_live_peer_callback"
 226         self.assert_(exc is None)
 227         self.assert_(dns == ("127.0.0.1", 5678))
 228         self.assert_(permid == self.peer2.my_permid)
 229         self.got = True
 230
 231
 232     #
 233     # connect() to a fake permid
 234     #
 235     def singtest_connect_to_dead_peerA(self):
 236         print >> sys.stderr,"test: test_connect_to_dead_peer"
 237         self.wanted = True
 238         hispermid = 'blabla'
 239         self.peer1.secure_overlay.connect(hispermid,self.connect_to_dead_peerA_callback)
 240         sleep(2) # let rawserver thread establish connection, which should fail
 241         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 0)
 242
 243     def connect_to_dead_peerA_callback(self,exc,dns,permid,selver):
 244         print >> sys.stderr,"test: connect_to_dead_peer_callback"
 245         self.assert_(exc is not None)
 246         self.assert_(permid == 'blabla')
 247         self.got = True
 248
 249     #
 250     # connect() to a real permid for which there is an address in the
 251     # database that noone responds at
 252     #
 253     def singtest_connect_to_dead_peerB(self):
 254         print >> sys.stderr,"test: test_connect_to_dead_peerB"
 255         self.wanted = True
 256
 257         peer_db = PeerDBHandler.getInstance()
 258         hispermid = self.peer2.my_permid
 259         peer_db.addPeer(hispermid, {'ip':"127.0.0.1", 'port':22220})
 260
 261         self.peer1.secure_overlay.connect(hispermid,self.connect_to_dead_peerB_callback)
 262         # Arno, 2009-04-23: was 2 secs, somehow the failed event comes in real slow now.
 263         sleep(4) # let rawserver thread establish connection, which should fail
 264         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 0)
 265
 266     def connect_to_dead_peerB_callback(self,exc,dns,permid,selver):
 267         print >> sys.stderr,"test: connect_to_dead_peerB_callback",exc
 268         self.assert_(exc is not None)
 269         self.assert_(dns == ("127.0.0.1", 22220))
 270         self.assert_(permid == self.peer2.my_permid)
 271         self.got = True
 272
 273
 274     #
 275     # connect() to peer2 which responds
 276     #
 277     def singtest_connect_to_live_peer(self):
 278         print >> sys.stderr,"test: test_connect_to_live_peer"
 279         self.wanted = True
 280
 281         peer_db = PeerDBHandler.getInstance()
 282         hispermid = self.peer2.my_permid
 283         peer_db.addPeer(hispermid,{'ip':"127.0.0.1", 'port':5678})
 284
 285         self.peer1.secure_overlay.connect(hispermid,self.connect_to_live_peer_callback)
 286         sleep(2) # let rawserver thread establish connection, which should succeed
 287         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 1)
 288         self.assert_(self.peer1.secure_overlay.iplport2oc.has_key('127.0.0.1:5678'))
 289
 290     def connect_to_live_peer_callback(self,exc,dns,permid,selver):
 291         print >> sys.stderr,"test: connect_to_live_peer_callback",exc
 292         self.assert_(exc is None)
 293         self.assert_(dns == ("127.0.0.1", 5678))
 294         self.assert_(permid == self.peer2.my_permid)
 295         self.got = True
 296
 297
 298     #
 299     # connect() to peer2 which responds, and then connect again
 300     #
 301     def singtest_connect_twice_to_live_peer(self):
 302         print >> sys.stderr,"test: test_connect_to_live_peer"
 303         self.wanted = True
 304         self.wanted2 = True
 305
 306         peer_db = PeerDBHandler.getInstance()
 307         hispermid = self.peer2.my_permid
 308         peer_db.addPeer(hispermid,{'ip':"127.0.0.1", 'port':5678})
 309
 310         self.peer1.secure_overlay.connect(hispermid,self.connect_to_live_peer_callback)
 311         sleep(2) # let rawserver thread establish connection, which should succeed
 312         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 1)
 313         self.assert_(self.peer1.secure_overlay.iplport2oc.has_key('127.0.0.1:5678'))
 314         self.peer1.secure_overlay.connect(hispermid,self.connect_to_live_peer_again_callback)
 315
 316     def connect_to_live_peer_again_callback(self,exc,dns,permid,selver):
 317         print >> sys.stderr,"test: connect_to_live_peer_callback",exc
 318         self.assert_(exc is None)
 319         self.assert_(dns == ("127.0.0.1", 5678))
 320         self.assert_(permid == self.peer2.my_permid)
 321         self.got2 = True
 322
 323
 324     #
 325     # send() over a non-existing connection to peer2
 326     #
 327     def singtest_send_unopenedA(self):
 328         print >> sys.stderr,"test: test_send_unopenedA"
 329         self.wanted = True
 330         hispermid = self.peer2.my_permid
 331         self.peer1.secure_overlay.send(hispermid,'msg=bla',self.send_unopenedA_send_callback)
 332         sleep(2) # let rawserver thread close connection, which should succeed
 333         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 0)
 334
 335     def send_unopenedA_send_callback(self,exc,permid):
 336         print >> sys.stderr,"test: send_unopenedA_send_callback",exc
 337         self.assert_(exc is not None)
 338         self.assert_(permid == self.peer2.my_permid)
 339         self.got = True
 340
 341
 342     #
 343     # send() over a non-existing connection to peer2 whose address is in database
 344     #
 345     def singtest_send_unopenedB(self):
 346         print >> sys.stderr,"test: test_send_unopenedB"
 347         self.wanted = True
 348         peer_db = PeerDBHandler.getInstance()
 349         hispermid = self.peer2.my_permid
 350         peer_db.addPeer(hispermid,{'ip':"127.0.0.1", 'port':5678})
 351         self.peer1.secure_overlay.send(hispermid,'msg=bla',self.send_unopenedB_send_callback)
 352         sleep(2) # let rawserver thread close connection, which should succeed
 353         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 0)
 354
 355     def send_unopenedB_send_callback(self,exc,permid):
 356         print >> sys.stderr,"test: send_unopenedB_send_callback",exc
 357         self.assert_(exc is not None)
 358         self.assert_(permid == self.peer2.my_permid)
 359         self.got = True
 360
 361
 362     #
 363     # send() over a connection to peer2 that peer1 closed
 364     #
 365     def singtest_send_local_close(self):
 366         print >> sys.stderr,"test: test_send_local_close"
 367         self.wanted = True
 368
 369         self.peer1.secure_overlay.connect_dns(("127.0.0.1", 5678),self.connect_dns_to_live_peer_callback)
 370         sleep(2) # let rawserver thread establish connection, which should succeed
 371         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 1)
 372         self.assert_(self.peer1.secure_overlay.iplport2oc.has_key('127.0.0.1:5678'))
 373
 374         hispermid = self.peer2.my_permid
 375         self.peer1.secure_overlay.close(hispermid)
 376         self.peer1.secure_overlay.send(hispermid,'msg=bla',self.send_local_close_send_callback)
 377         sleep(2) # let rawserver thread close connection, which should succeed
 378         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 0)
 379
 380     def send_local_close_send_callback(self,exc,permid):
 381         print >> sys.stderr,"test: send_local_close_send_callback",exc
 382         self.assert_(exc is not None)
 383         self.assert_(permid == self.peer2.my_permid)
 384         self.got = True
 385
 386     #
 387     # send() over a connection to peer2 that peer2 closed
 388     #
 389     def singtest_send_remote_close(self):
 390         print >> sys.stderr,"test: test_send_remote_close"
 391
 392         self.wanted = True
 393         self.wanted2 = True
 394
 395         # register handler for connections
 396         self.peer2.secure_overlay.register_conns_callback(self.send_remote_close_conns_callback)
 397
 398         self.peer1.secure_overlay.connect_dns(("127.0.0.1", 5678),self.connect_dns_to_live_peer_callback)
 399         # let rawserver thread establish connection, which should succeed
 400         # then let rawserver thread close connection, which should succeed
 401         # net result is no connection to peer2
 402         self.peer1.secure_overlay.send(self.peer2.my_permid,'msg=bla',self.send_remote_close_send_callback)
 403         sleep(2)
 404         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 0)
 405
 406     def send_remote_close_conns_callback(self,exc,permid,selversion,locally_initiated,hisdns=None):
 407         print  >> sys.stderr,"test: send_remote_close_conns_callback",exc,show_permid_short(permid)
 408         if self.first:
 409             self.assert_(exc is None)
 410             self.assert_(permid == self.peer1.my_permid)
 411             self.assert_(selversion == OLPROTO_VER_CURRENT)
 412             self.assert_(not locally_initiated)
 413             self.first = False
 414             self.got2 = True
 415
 416             hispermid = self.peer1.my_permid
 417             self.peer2.secure_overlay.close(hispermid)
 418         else:
 419             self.assert_(exc is not None)
 420             self.assert_(permid == self.peer1.my_permid)
 421             self.assert_(selversion == OLPROTO_VER_CURRENT)
 422             self.assert_(not locally_initiated)
 423
 424     def send_remote_close_send_callback(self,exc,permid):
 425         print >> sys.stderr,"test: send_remote_close_send_callback",exc
 426         self.assert_(exc is not None)
 427         self.assert_(permid == self.peer2.my_permid)
 428         self.got = True
 429
 430
 431     #
 432     # send() over an open connection to peer2
 433     #
 434     def singtest_send_opened(self):
 435         print >> sys.stderr,"test: test_send_opened"
 436         self.wanted = True
 437         self.wanted2 = True
 438         peer_db = PeerDBHandler.getInstance()
 439         hispermid = self.peer2.my_permid
 440         peer_db.addPeer(hispermid,{'ip':"127.0.0.1", 'port':5678})
 441         msg = GET_METADATA+'12345678901234567890'
 442         self.peer1.secure_overlay.connect(hispermid,lambda e,d,p,s: self.send_opened_connect_callback(e,d,p,s,msg))
 443
 444     def send_opened_connect_callback(self,exc,dns,permid,selver,msg):
 445         print >> sys.stderr,"test: send_opened_connect_callback"
 446         self.assert_(exc is None)
 447         self.assert_(dns == ("127.0.0.1", 5678))
 448         self.assert_(permid == self.peer2.my_permid)
 449         self.peer1.secure_overlay.send(permid,msg,self.send_opened_send_callback)
 450         self.got = True
 451
 452     def send_opened_send_callback(self,exc,permid):
 453         print >> sys.stderr,"test: send_opened_send_callback"
 454         self.assert_(exc is None)
 455         self.assert_(permid == self.peer2.my_permid)
 456         self.got2 = True
 457
 458
 459     #
 460     # close() a non-existing to peer2
 461     #
 462     def singtest_close_unopened(self):
 463         print >> sys.stderr,"test: test_close_unopened"
 464         hispermid = self.peer2.my_permid
 465         self.peer1.secure_overlay.close(hispermid)
 466         sleep(2) # let rawserver thread close connection, which should succeed
 467         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 0)
 468
 469
 470     #
 471     # close() an open connection to peer2
 472     #
 473     def singtest_close_opened(self):
 474         print >> sys.stderr,"test: test_close_opened"
 475         self.peer1.secure_overlay.connect_dns(("127.0.0.1", 5678),self.connect_dns_to_live_peer_callback)
 476         sleep(2) # let rawserver thread establish connection, which should succeed
 477         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 1)
 478         self.assert_(self.peer1.secure_overlay.iplport2oc.has_key('127.0.0.1:5678'))
 479
 480         hispermid = self.peer2.my_permid
 481         self.peer1.secure_overlay.close(hispermid)
 482         sleep(2) # let rawserver thread close connection, which should succeed
 483         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 0)
 484
 485
 486     #
 487     # Let peer2 register an receive callback and let peer1 send a message
 488     #
 489     def singtest_receive(self):
 490         print >> sys.stderr,"test: test_receive"
 491         self.wanted = True
 492         self.wanted2 = True
 493         # register handler for messages
 494         self.peer2.secure_overlay.register_recv_callback(self.receive_msg_callback)
 495
 496         peer_db = PeerDBHandler.getInstance()
 497         hispermid = self.peer2.my_permid
 498         peer_db.addPeer(hispermid,{'ip':"127.0.0.1", 'port':5678})
 499         msg = GET_METADATA+'12345678901234567890'
 500         self.peer1.secure_overlay.connect(hispermid,lambda e,d,p,s: self.receive_connect_callback(e,d,p,s,msg))
 501
 502     def receive_connect_callback(self,exc,dns,permid,selver,msg):
 503         print >> sys.stderr,"test: receive_connect_callback"
 504         self.assert_(exc is None)
 505         self.assert_(dns == ("127.0.0.1", 5678))
 506         self.assert_(permid == self.peer2.my_permid)
 507         self.peer1.secure_overlay.send(permid,msg,self.receive_send_callback)
 508         print >> sys.stderr,"test: test_receive exiting"
 509
 510     def receive_send_callback(self,exc,permid):
 511         print >> sys.stderr,"test: receive_send_callback"
 512         self.assert_(exc is None)
 513         self.assert_(permid == self.peer2.my_permid)
 514         self.got2 = True
 515
 516     def receive_msg_callback(self,permid,selversion,message):
 517         print  >> sys.stderr,"test: testcase succesfully received message"
 518         self.got = True
 519         self.assert_(message[0] == GET_METADATA)
 520         self.assert_(permid == self.peer1.my_permid)
 521         self.assert_(selversion == OLPROTO_VER_CURRENT)
 522         return True
 523
 524     #
 525     # Let peer2 register an connection callback and let peer1 send a message
 526     # which implies setting up a connection
 527     #
 528     def singtest_got_conn_incoming(self):
 529         print >> sys.stderr,"test: test_got_conn_incoming"
 530         self.wanted = True
 531         self.wanted2 = True
 532         # register handler for messages
 533         self.peer2.secure_overlay.register_recv_callback(self.receive_msg_callback)
 534         # register handler for connections
 535         self.peer2.secure_overlay.register_conns_callback(self.got_conn_incoming_conns_callback)
 536
 537
 538         peer_db = PeerDBHandler.getInstance()
 539         hispermid = self.peer2.my_permid
 540         peer_db.addPeer(hispermid,{'ip':"127.0.0.1", 'port':5678})
 541         msg = GET_METADATA+'12345678901234567890'
 542         self.peer1.secure_overlay.connect(hispermid,lambda e,d,p,s:self.got_conn_incoming_connect_callback(e,d,p,s,msg))
 543
 544
 545     def got_conn_incoming_connect_callback(self,exc,dns,permid,selver,msg):
 546         print >> sys.stderr,"test: got_conn_incoming_connect_callback",exc
 547         self.assert_(exc is None)
 548         self.assert_(dns == ("127.0.0.1", 5678))
 549         self.assert_(permid == self.peer2.my_permid)
 550         self.peer1.secure_overlay.send(permid,msg,self.receive_send_callback)
 551         print >> sys.stderr,"test: test_got_conn_incoming exiting"
 552
 553     def got_conn_incoming_conns_callback(self,exc,permid,selversion,locally_initiated,hisdns=None):
 554         print  >> sys.stderr,"test: got_conn_incoming_conns_callback",exc,show_permid_short(permid)
 555         self.assert_(exc is None)
 556         self.assert_(permid == self.peer1.my_permid)
 557         self.assert_(selversion == OLPROTO_VER_CURRENT)
 558         self.assert_(not locally_initiated)
 559         self.got = True
 560
 561
 562     #
 563     # Let peer1 register an connection callback and let peer1 send a message
 564     # which implies setting up a connection
 565     #
 566     def singtest_got_conn_outgoing(self):
 567         print >> sys.stderr,"test: test_got_conn_outgoing"
 568         self.wanted = True
 569         self.wanted2 = True
 570         # register handler for connections
 571         self.peer1.secure_overlay.register_conns_callback(self.got_conn_outgoing_conns_callback)
 572
 573         peer_db = PeerDBHandler.getInstance()
 574         hispermid = self.peer2.my_permid
 575         peer_db.addPeer(hispermid,{'ip':"127.0.0.1", 'port':5678})
 576         msg = GET_METADATA+'12345678901234567890'
 577         self.peer1.secure_overlay.connect(hispermid,lambda e,d,p,s:self.got_conn_outgoing_connect_callback(e,d,p,s,msg))
 578
 579
 580     def got_conn_outgoing_connect_callback(self,exc,dns,permid,selver,msg):
 581         print >> sys.stderr,"test: got_conn_outgoing_connect_callback",exc
 582         self.assert_(exc is None)
 583         self.assert_(dns == ("127.0.0.1", 5678))
 584         self.assert_(permid == self.peer2.my_permid)
 585         self.got2 = True
 586
 587     def got_conn_outgoing_conns_callback(self,exc,permid,selversion,locally_initiated,hisdns=None):
 588         print  >> sys.stderr,"test: got_conn_outgoing_conns_callback",exc,show_permid_short(permid)
 589         self.assert_(exc is None)
 590         self.assert_(permid == self.peer2.my_permid)
 591         self.assert_(selversion == OLPROTO_VER_CURRENT)
 592         self.assert_(locally_initiated)
 593         self.got = True
 594
 595
 596
 597     #
 598     # Let peer2 register a connection callback and let peer1 close the connection
 599     # after succesful setup.
 600     #
 601     def singtest_got_conn_local_close(self):
 602         print >> sys.stderr,"test: test_got_conn_local_close"
 603
 604         self.wanted = True
 605         self.wanted2 = True
 606
 607         # register handler for connections
 608         self.peer2.secure_overlay.register_conns_callback(self.got_conn_local_close_conns_callback)
 609
 610         self.peer1.secure_overlay.connect_dns(("127.0.0.1", 5678),self.connect_dns_to_live_peer_callback)
 611         sleep(2) # let rawserver thread establish connection, which should succeed
 612         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 1)
 613         self.assert_(self.peer1.secure_overlay.iplport2oc.has_key('127.0.0.1:5678'))
 614
 615         hispermid = self.peer2.my_permid
 616         self.peer1.secure_overlay.close(hispermid)
 617         sleep(2) # let rawserver thread close connection, which should succeed
 618         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 0)
 619
 620
 621     def got_conn_local_close_conns_callback(self,exc,permid,selversion,locally_initiated,hisdns=None):
 622         print  >> sys.stderr,"test: got_conn_local_close_conns_callback",exc,show_permid_short(permid)
 623         if self.first:
 624             self.assert_(exc is None)
 625             self.assert_(permid == self.peer1.my_permid)
 626             self.assert_(selversion == OLPROTO_VER_CURRENT)
 627             self.assert_(not locally_initiated)
 628             self.first = False
 629             self.got2 = True
 630         else:
 631             self.assert_(exc is not None)
 632             self.assert_(permid == self.peer1.my_permid)
 633             self.assert_(selversion == OLPROTO_VER_CURRENT)
 634             self.assert_(not locally_initiated)
 635             self.got = True
 636
 637     #
 638     # Let peer2 register a connection callback and let peer2 close the connection
 639     # after succesful setup.
 640     #
 641     def singtest_got_conn_remote_close(self):
 642         print >> sys.stderr,"test: test_got_conn_remote_close"
 643
 644         self.wanted = True
 645         self.wanted2 = True
 646
 647         # register handler for connections
 648         self.peer2.secure_overlay.register_conns_callback(self.got_conn_remote_close_conns_callback)
 649
 650         self.peer1.secure_overlay.connect_dns(("127.0.0.1", 5678),self.connect_dns_to_live_peer_callback)
 651         # let rawserver thread establish connection, which should succeed
 652         # then let rawserver thread close connection, which should succeed
 653         # net result is no connection to peer2
 654         sleep(2)
 655         self.assert_(len(self.peer1.secure_overlay.iplport2oc) == 0)
 656
 657     def got_conn_remote_close_conns_callback(self,exc,permid,selversion,locally_initiated,hisdns=None):
 658         print  >> sys.stderr,"test: got_conn_remote_close_conns_callback",exc,show_permid_short(permid)
 659         if self.first:
 660             self.assert_(exc is None)
 661             self.assert_(permid == self.peer1.my_permid)
 662             self.assert_(selversion == OLPROTO_VER_CURRENT)
 663             self.assert_(not locally_initiated)
 664             self.first = False
 665             self.got2 = True
 666
 667             hispermid = self.peer1.my_permid
 668             self.peer2.secure_overlay.close(hispermid)
 669         else:
 670             self.assert_(exc is not None)
 671             self.assert_(permid == self.peer1.my_permid)
 672             self.assert_(selversion == OLPROTO_VER_CURRENT)
 673             self.assert_(not locally_initiated)
 674             self.got = True
 675
 676     def rawserver_fatalerrorfunc(self,e):
 677         """ Called by network thread """
 678         if DEBUG:
 679             print >>sys.stderr,"test_secure_overlay: RawServer fatal error func called",e
 680         print_exc()
 681         self.assert_(False)
 682
 683
 684 def test_suite():
 685     suite = unittest.TestSuite()
 686     # We should run the tests in a separate Python interpreter to prevent
 687     # problems with our singleton classes, e.g. PeerDB, etc.
 688     if len(sys.argv) != 2:
 689         print "Usage: python test_so.py <method name>"
 690     else:
 691         suite.addTest(TestSecureOverlay(sys.argv[1]))
 692
 693     return suite
 694
 695 def main():
 696     unittest.main(defaultTest='test_suite',argv=[sys.argv[0]])
 697
 698 if __name__ == "__main__":
 699     main()