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()
def send_query_to_network(self):
"""
This is core of the experiment
"""
# check if we already host the file
# we hardcode the file name (doesn't really matter)
self.log("send_query_to_network()")
criteria = 'ABC'
result = self.search(criteria)
if result == []:
# if it is not in cache or not host it
query_message = create_message(GnutellaBodyId.QUERY,
min_speed = 0,
search_criteria = criteria)
# save the message id
self.query_message_id = query_message.message_id
self.log("message id: %s", self.query_message_id.encode('hex_codec'))
# flood the message to everyone
self.flood_ex(query_message)
def test_cache():
test_servent = CacheServent()
ip = dotted_quad_to_num('127.0.0.1')
port = 59850
speed = 100
result_set = [{
'file_index': 3435,
'file_size': 100,
'file_name': 'A'
},
{
'file_index': 3535,
'file_size': 200,
'file_name': 'B'
}]
servent_id = 'thisisservent_id'
fake_queryhit = create_message(GnutellaBodyId.QUERYHIT,
ip = ip,
port = port,
result_set = result_set,
servent_id = servent_id,
speed = 1)
test_servent.save_queryhit(fake_queryhit)
cache_result = test_servent.search_queryhit("A")
# test the result
assert_equal(len(cache_result), 1)
assert_equal(cache_result[0][3][0]['file_index'], 3435)
# test the merge
result_set2 = [{
'file_index': 3435,
'file_size': 100,
'file_name': 'A'
},
{
'file_index': 35345,
'file_size': 200,
'file_name': 'C'
}]
fake_queryhit2 = create_message(GnutellaBodyId.QUERYHIT,
ip = ip,
port = port,
result_set = result_set2,
servent_id = servent_id,
speed = 1)
test_servent.save_queryhit(fake_queryhit2)
# check if it actually merge
assert_equal(len(test_servent.queryhit_cache), 1)
cache_result = test_servent.search_queryhit("C")
# test the result
assert_equal(len(cache_result), 1)
assert_equal(cache_result[0][3][0]['file_index'], 35345)
# complex test, use two servent
servent_id2 = 'thisisserventid1'
fake_queryhit3 = create_message(GnutellaBodyId.QUERYHIT,
ip = ip,
port = port,
result_set = result_set,
servent_id = servent_id2,
speed = 1)
test_servent.save_queryhit(fake_queryhit3)
# test if it does not merge
assert_equal(len(test_servent.queryhit_cache), 2)
# test the result
cache_result = test_servent.search_queryhit("A")
assert_equal(len(cache_result), 2)
def on_connect(self, connection_handler):
LogServent.on_connect(self, connection_handler)
ping_message = create_message(GnutellaBodyId.PING)
self.log("sending %s", ping_message)
self.send_message(ping_message, connection_handler)
def on_connect(self, connection_handler):
ping_message = create_message(GnutellaBodyId.PING)
self.sent_message.append(ping_message)
self.send_message(ping_message, connection_handler)
return
def on_connect(self, connection_handler):
ping_message = create_message(GnutellaBodyId.PING)
self.sent_message.append(ping_message)
self.log("sending %s", ping_message)
connection_handler.write(ping_message.serialize())
return
