def test_servent():
receive_servent = ReceiveServent()
send_servent = SendServent()
assert_equal(receive_servent.files, [])
assert_equal(send_servent.files, [])
# manually set file
receive_servent.set_files([FileInfo(1,"first file", 600), FileInfo(2,"second file", 2500) , FileInfo(3, "third file", 5000)])
assert_equal(receive_servent.check_file(1), True)
assert_equal(receive_servent.check_file(200), False)
receive_servent.reactor.gnutella_connect(send_servent.reactor.address)
try:
scheduler_loop(timeout=1,count=10)
finally:
assert_equal(len(send_servent.sent_message), 1)
assert_equal(len(receive_servent.receive_message), 1)
assert_equal(receive_servent.receive_message[0].message_id, send_servent.sent_message[0].message_id)
assert_equal(receive_servent.receive_message[0].ttl, send_servent.sent_message[0].ttl)
assert_equal(receive_servent.receive_message[0].hops, send_servent.sent_message[0].hops)
assert_equal(receive_servent.receive_message[0].payload_length, send_servent.sent_message[0].payload_length)
assert_equal(receive_servent.receive_message[0].payload_descriptor, send_servent.sent_message[0].payload_descriptor)
assert_equal(receive_servent.receive_message[0].serialize(), send_servent.sent_message[0].serialize())
assert_equal(len(send_servent.receive_message), 1)
assert_equal(send_servent.receive_message[0].body.num_of_files, 3)
assert_equal(send_servent.receive_message[0].body.num_of_kb, 8)
close_all()
def main(args):
# create a network
# if len(args)<3:
# usage();
# return
# ip = args[0]
# port = int(args[1])
# num_node = int(args[2])
# address = (ip, port)
# create_network([CacheServent]*num_node, address)
# implement the network
servent1 = CacheServent()
servent2 = CacheServent()
servent3 = CacheServent()
servent4 = CacheServent()
servent5 = CacheServent()
servent3.set_files(
[FileInfo(1, "first file", 600), FileInfo(2, "second file", 2500), FileInfo(3, "third file", 5000)]
)
servent1.reactor.gnutella_connect(servent2.reactor.address)
servent2.reactor.gnutella_connect(servent3.reactor.address)
servent3.reactor.gnutella_connect(servent4.reactor.address)
servent5.reactor.gnutella_connect(servent2.reactor.address)
try:
scheduler_loop(timeout=1, count=10)
finally:
# flood is query to neighbors
servent1.search_queryhit("first file")
scheduler_loop(timeout=1, count=10)
# servent2.search_queryhit('first file')
# scheduler_loop(timeout=1,count=10)
servent5.search_queryhit("first file")
scheduler_loop(timeout=1, count=15)
close_all()
def main(args):
logging.basicConfig(level=logging.DEBUG, format='%(name)s: %(message)s')
dag = {0: [], 1:[0], 2:[0], 3:[1,2]}
DagBootstrap(dag)
try:
schedule_loop()
finally:
close_all()
def __create_node(servent_cls, bootstrap_address):
logging.basicConfig(level=logging.DEBUG, format='%(name)s: %(message)s')
servent_cls(bootstrap_address = bootstrap_address)
try:
schedule_loop()
except (KeyboardInterrupt, SystemExit):
pass
finally:
close_all()
def __create_node(servent_cls, bootstrap_address, files = []):
logging.basicConfig(level=logging.DEBUG, format='%(name)s: %(message)s')
servent = servent_cls(bootstrap_address = bootstrap_address)
servent.set_files(files = files)
try:
schedule_loop(timeout=1, count=80)
except (KeyboardInterrupt, SystemExit):
pass
finally:
servent.log("result: %s, tx: %s, rx: %s" % (len(servent.search('ABC')), servent.num_tx_message, servent.num_rx_message))
close_all()
def main(argv, argc):
logging.basicConfig(level=logging.DEBUG, format='%(name)s: %(message)s')
if argc == 0:
print "Running with default behavior."
print "To see other options, please run with python run_bootstrap.py help"
dag = {0: [], 1:[0], 2:[0], 3:[1,2]}
print "The default is DagBootstrap with %s" % dag
print "Please use Ctrl+C to terminate"
DagBootstrap(dag)
try:
schedule_loop()
except (KeyboardInterrupt, SystemExit):
pass
finally:
close_all()
return
if argv[0] == 'help':
if argc == 1:
print "You could run the following Bootstrap: "
for bt in bt_name:
print "* ", bt
print "You can find out how to run any of above Bootstrap by typing: "
print "python run_bootstrap.py help <bootstrap name>"
else:
name = argv[1]
for bt in bootstraps:
if bt.__name__ == name:
if bt.__doc__:
print bt.__doc__
print additional_note
return
print "We cannot find a bootstrap with name %s" % name
return
elif argv[0] in bt_name:
name = argv[0]
for bt in bootstraps:
if bt.__name__ == name:
kwargs = bt.parse(argv[1:])
bt(**kwargs)
try:
schedule_loop()
except (KeyboardInterrupt, SystemExit):
pass
finally:
close_all()
return
else:
print "No parameter matches. Please python run_bootstrap.py help for help"
def main(argv, argc):
logging.basicConfig(level=logging.DEBUG, format='%(name)s: %(message)s')
print "Please use Ctrl+C to terminate"
p = 0.5
if argc >= 0:
p = float(argv[0])
RandomBootstrap(p)
try:
schedule_loop()
except (KeyboardInterrupt, SystemExit):
pass
finally:
close_all()
return
def main(args):
# show log message
logging.basicConfig(level=logging.DEBUG, format='%(name)s: %(message)s')
# implement the network
servent1 = LogCacheServent()
servent2 = LogCacheServent()
servent3 = LogCacheServent()
servent4 = LogCacheServent()
servent5 = LogCacheServent()
servent3.set_files([FileInfo(1,"first file", 600),
FileInfo(2,"second file", 2500) ,
FileInfo(3, "third file", 5000)])
servent1.reactor.gnutella_connect(servent2.reactor.address)
servent2.reactor.gnutella_connect(servent3.reactor.address)
servent3.reactor.gnutella_connect(servent4.reactor.address)
servent5.reactor.gnutella_connect(servent2.reactor.address)
try:
print "============Handshake============"
scheduler_loop(timeout=1,count=10)
except:
close_all()
return
query_message = create_message(GnutellaBodyId.QUERY,
min_speed = 0,
search_criteria = "first file")
# generate two identical query with different message_id
query_message2 = create_message(GnutellaBodyId.QUERY,
min_speed = 0,
search_criteria = "first file")
try:
print "============Simulate Query============"
servent1.flood_ex(query_message)
scheduler_loop(timeout=1,count=15)
except:
close_all()
return
try:
print "============Simulate Cache Query============"
servent5.flood_ex(query_message2)
scheduler_loop(timeout=1,count=15)
except:
close_all()
return
print "Servent 1's cache hits: ", servent1.hits, "cache misses", servent1.misses
print "Servent 2's cache hits: ", servent2.hits, "cache misses", servent2.misses
print "Servent 3's cache hits: ", servent3.hits, "cache misses", servent3.misses
print "Servent 4's cache hits: ", servent4.hits, "cache misses", servent4.misses
print "Servent 5's cache hits: ", servent5.hits, "cache misses", servent5.misses
# clean up
close_all()
def test_on_receive():
# test all logic path in on_receive(
basic_servent = BasicServent()
test_handler = TestHandler()
ping_message = create_message(GnutellaBodyId.PING)
basic_servent.on_receive(test_handler, ping_message)
# second one test on forward table
basic_servent.on_receive(test_handler, ping_message)
pong_message = create_message(GnutellaBodyId.PONG, ip = basic_servent.reactor.ip,
port = basic_servent.reactor.port, num_of_files = 0,
num_of_kb = 0)
basic_servent.on_receive(test_handler, pong_message)
pong_message2 = create_message(GnutellaBodyId.PONG, message_id = ping_message.message_id,
ip = basic_servent.reactor.ip, port = basic_servent.reactor.port,
num_of_files = 0, num_of_kb = 0)
basic_servent.on_receive(test_handler, pong_message2)
query_message = create_message(GnutellaBodyId.QUERY, min_speed = 2, search_criteria = 'hello world')
basic_servent.on_receive(test_handler, query_message)
#queryhit_message = create_message(GnutellaBodyId.QUERYHIT)
#TODO:
close_all()
# You should see the following or something like this if you get PYTHONPATH fixed
# explanation: the first message => request from node with port=38383
# bootstrap node with port = 36124
#('127.0.0.1', 38383) -> ('127.0.1.1', 36124) POST 127.0.1.1 3435
#('127.0.0.1', 38383) -> ('127.0.1.1', 36124) GET
#('127.0.0.1', 38384) -> ('127.0.1.1', 36124) POST 127.0.1.1 15025
#('127.0.0.1', 38384) -> ('127.0.1.1', 36124) GET
#('127.0.1.1', 36124) -> ('127.0.0.1', 38383) CLOSE
#('127.0.1.1', 36124) -> ('127.0.0.1', 38384) PEER 127.0.1.1 3435
#('127.0.1.1', 36124) -> ('127.0.0.1', 38384) CLOSE
#('127.0.0.1', 38385) -> ('127.0.1.1', 36124) POST 127.0.1.1 1252
#('127.0.0.1', 38385) -> ('127.0.1.1', 36124) GET
#('127.0.1.1', 36124) -> ('127.0.0.1', 38385) PEER 127.0.1.1 15025
#('127.0.1.1', 36124) -> ('127.0.0.1', 38385) CLOSE
#Node 1: []
#Node 2: [('127.0.1.1', '3435')]
#Node 3: [('127.0.1.1', '15025')]
if __name__ == '__main__':
bootstrap_node = SimpleBootstrap()
node1 = BootstrapOutHandler(('127.0.1.1', 3435), bootstrap_node.addr)
node2 = BootstrapOutHandler(('127.0.1.1', 15025), bootstrap_node.addr)
node3 = BootstrapOutHandler(('127.0.1.1', 1252), bootstrap_node.addr)
try:
scheduler_loop(count=5)
finally:
print "Node 1: ", node1.peer_list
print "Node 2: ", node2.peer_list
print "Node 3: ", node3.peer_list
close_all()
