def test_decode_introduction_response(self):
identifier = int(random() * 2**16)
destination_address = ("8.8.8.8", 8)
source_lan_address = ("192.168.1.200", 20000)
source_wan_address = ("35.1.2.3", 20000)
lan_introduction_address = ("2.2.2.2", 2)
wan_introduction_address = ("3.3.3.3", 3)
message = Message(
neighbor_discovery=neighbor_discovery,
identifier=identifier,
destination_address=destination_address,
source_private_address=source_lan_address,
source_public_address=source_wan_address,
private_introduction_address=lan_introduction_address,
public_introduction_address=wan_introduction_address)
message.encode_introduction_response()
message_decode = Message(packet=message.packet)
message_decode.decode_introduction_response()
assert_equals(message.destination_address,
message_decode.destination_address)
assert_equals(message.source_private_address,
message_decode.source_private_address)
assert_equals(message.source_public_address,
message_decode.source_public_address)
assert_equals(message.private_introduction_address,
message_decode.private_introduction_address)
assert_equals(message.public_introduction_address,
message_decode.public_introduction_address)
def on_introduction_response(self, packet, addr):
"""
1.decode a introduction response
2.do public address vote to determine our public address
3.add the introduced neighbor to neighbor_group
"""
self.database.add_visit_count_record(ip=addr[0],
port=addr[1],
public_key="000")
message = Message(packet=packet)
message.decode_introduction_response()
self.global_time = message.global_time
self.public_address_vote(message.destination_address, addr)
message_sender = Neighbor(message.source_private_address,
addr,
identity=message.sender_identity)
self.neighbor_group.add_neighbor_to_outgoing_list(message_sender)
print("the introduced candidate is: " +
str(message.public_introduction_address))
if message.private_introduction_address != (
"0.0.0.0",
0) and message.public_introduction_address != ("0.0.0.0", 0):
introduced_neighbor = Neighbor(
message.private_introduction_address,
message.public_introduction_address)
self.neighbor_group.add_neighbor_to_intro_list(introduced_neighbor)
self.neighbor_group.update_current_neighbor(
responder=message_sender,
introduced_neighbor=introduced_neighbor)
print("new candidate has been added to intro list")
#send a missing identity by the way
identity = message.sender_identity
responder_member = self.database.get_member(identity=identity)
if responder_member is None:
message_missing_identity = Message(
neighbor_discovery=self,
the_missing_identity=message.sender_identity)
message_missing_identity.encode_missing_identity()
#self.transport.write(message_missing_identity.packet,addr)
self.send_message(message_missing_identity.packet, addr)
print(
"receive introduction response, send missing identity message")
member = self.database.get_member(identity=identity)
if member is not None:
print("the member of the introduction response is: " +
str(member[0]))
public_key = member[1]
requested_sequence_number = self.database.get_latest_sequence_number(
public_key=public_key) + 1
#message_crawl_request = Message(neighbor_discovery=self,requested_sequence_number = requested_sequence_number)
#message_crawl_request.encode_crawl_request()
message_crawl = Message(
neighbor_discovery=self,
requested_sequence_number=requested_sequence_number)
message_crawl.encode_crawl()
#self.transport.write(message_crawl.packet,addr)
self.send_message(message_crawl.packet, addr)
print("crawl sent")