def protocol(client, msg): try: assert type(msg) != str _log.debug(msg) msg = list_to_ordered_dict(msg) except (ValueError, TypeError) as e: _log.debug(e) _log.debug("Protocol: unable to serialize as OrderedDict") return -1 msg_handlers = {u"SYN": process_syn, u"SYN-ACK": process_syn_ack, u"ACK": process_ack, u"RST": process_rst} # Sanity checking. if u"status" not in msg: _log.debug("Protocol: no status in msg") return -2 # Message too large. if len(str(msg)) >= 5242880: # 5MB. _log.debug("Protocol: msg too big") return -3 # Process msg. status = msg[u"status"] if status in msg_handlers: msg_handlers[status](client, msg) return 1 else: print("MSG HANDLER NOT FOUND") return -4
def handler(node, msg): # Is this a response to our request? try: msg = util.list_to_ordered_dict(msg) # Not a UNL response. if msg[u"type"] != u"unl_response": _log.debug("unl response: type !=") return # Invalid UNL. their_unl = UNL(value=msg[u"unl"]).deconstruct() if their_unl is None: _log.debug("unl response:their unl !=") return # Invalid signature. if not verify_signature(msg, wif, their_node_id): _log.debug("unl response: their sig") return # Everything passed: fire callback. d.callback(msg[u"unl"]) # Remove this callback. node.remove_message_handler(handler) except (ValueError, KeyError): _log.debug("unl response:val or key er") pass # not a unl response
def handle_requests(node, msg): _log.debug("In handle requests") # Check message type. msg = list_to_ordered_dict(msg) if msg[u"type"] != u"test_bandwidth_request": _log.debug("req: Invalid request") return -1 # Drop request if test already active. if self.test_node_unl is not None: _log.debug("req: test already active") return -2 # Check they got our node unl right. our_unl = self.transfer.net.unl.value if our_unl != msg[u"test_node_unl"]: _log.debug("req: they got our node unl wrong") return -3 # Check sig. src_node_id = parse_node_id_from_unl(msg[u"requester"]) if not verify_signature(msg, self.wif, src_node_id): _log.debug("req: Invalid sig") return -4 # Build response. res = OrderedDict([ (u"type", u"test_bandwidth_response"), (u"timestamp", time.time()), (u"requestee", our_unl), (u"request", msg) ]) # Sign response res = sign(res, self.wif) # Save their node ID! self.test_node_unl = msg[u"requester"] # Add accept handler for bandwidth tests. accept_handler = build_accept_handler(self, msg) self.add_handler("accept", accept_handler) # Add start handler. start_handler = build_start_handler(self, msg) self.add_handler("start", start_handler) # Set start time. self.start_time = time.time() # Save data id. self.data_id = msg[u"data_id"] # Send request back to source. res = ordered_dict_to_list(res) self.api.repeat_relay_message(src_node_id, res) _log.debug("req: got request") return res
def process_unl_requests(node, msg): _log.debug("In process unl requests: ") _log.debug(msg) unl = node._data_transfer.net.unl.value _log.debug(unl) try: msg = list_to_ordered_dict(msg) # Not a UNL request. if msg[u"type"] != u"unl_request": _log.debug("unl req: invalid type") _log.debug(msg[u"type"]) return # Check signature. their_node_id = address_to_node_id(msg[u"requester"]) if not verify_signature(msg, node.get_key(), their_node_id): _log.debug("unl req: invalid sig") return # Response. response = sign(OrderedDict( { u"type": u"unl_response", u"requestee": node.get_address(), u"unl": unl } ), node.get_key()) # Send response. response = ordered_dict_to_list(response) node.repeat_relay_message(their_node_id, response) except (ValueError, KeyError): _log.debug("val err or key err") pass # not a unl request
def test_handle_requests(self): handle_requests = handle_requests_builder(self.bob_test) # Invalid message type. req = list_to_ordered_dict(copy.deepcopy(self.req)) req[u"type"] = "garbage" req = ordered_dict_to_list(req) self.assertTrue(handle_requests( self.alice_dht, self.alice_node_id, req ) == -1) # Already active. req = list_to_ordered_dict(copy.deepcopy(self.req)) req = ordered_dict_to_list(req) self.bob_test.test_node_unl = True self.assertTrue(handle_requests( self.alice_dht, self.alice_node_id, req ) == -2) self.bob_test.test_node_unl = None # Incorrect node id. req = list_to_ordered_dict(copy.deepcopy(self.req)) req["test_node_unl"] = 1 req = ordered_dict_to_list(req) self.assertTrue(handle_requests( self.alice_dht, self.alice_node_id, req ) == -3) # Invalid sig. req = list_to_ordered_dict(copy.deepcopy(self.req)) req["something"] = 1 req = ordered_dict_to_list(req) self.assertTrue(handle_requests( self.alice_dht, self.alice_node_id, req ) == -4) # Sending to us req = list_to_ordered_dict(copy.deepcopy(self.req)) req["requester"] = self.bob_transfer.net.unl.value req = ordered_dict_to_list(req) self.assertTrue(handle_requests( self.alice_dht, self.alice_node_id, req ) == -5) # Success. req = copy.deepcopy(self.req) self.assertTrue(type(handle_requests( self.alice_dht, self.alice_node_id, req )) == list) """ ---------------------- Test accept handler. ---------------------- """ # Handler expired. req = list_to_ordered_dict(copy.deepcopy(self.req)) accept_handler = self.bob_test.handlers["accept"].pop() self.assertTrue(accept_handler( "contract_id", self.alice_transfer.net.unl.value, req["data_id"], ONE_MB ) == -1) self.bob_test.handlers["accept"].add(accept_handler) # Invalid data id. self.assertTrue(accept_handler( "contract_id", self.alice_transfer.net.unl.value, "test", ONE_MB ) == -2) # Invalid data id. self.assertTrue(accept_handler( "contract_id", self.bob_transfer.net.unl.value, req["data_id"], ONE_MB ) == -3) # Invalid data id. self.bob_test.test_size = 0 self.assertTrue(accept_handler( "contract_id", self.alice_transfer.net.unl.value, req["data_id"], ONE_MB ) == -4) self.bob_test.test_size = 1 # Invalid data id. self.assertTrue(accept_handler( "contract_id", self.alice_transfer.net.unl.value, req["data_id"], ONE_MB ) == 1) """ ---------------------- Test start handler. ---------------------- """ # Handler expired. req = list_to_ordered_dict(copy.deepcopy(self.req)) start_handler = self.bob_test.handlers["start"].pop() self.assertTrue(start_handler( self.bob_transfer, None, "start_contract_id" ) == -1) self.bob_test.handlers["start"].add(start_handler) # This should pass. contract = { "host_unl": self.bob_transfer.net.unl.value, "data_id": req["data_id"] } self.bob_transfer.contracts[req["data_id"]] = contract self.assertTrue(start_handler( self.bob_transfer, None, req["data_id"] ) == 1) # Invalid data id. contract = { "host_unl": self.bob_transfer.net.unl.value, "data_id": "x" } self.bob_transfer.contracts[req["data_id"]] = contract self.assertTrue(start_handler( self.bob_transfer, None, req["data_id"] ) == -2) """ ---------------------- Test completion handler. ---------------------- completion_handler(client, contract_id, con): """ # Handler expired. req = list_to_ordered_dict(copy.deepcopy(self.req)) complete_handler = self.bob_test.handlers["complete"].pop() contract_id = "" self.assertTrue(complete_handler( self.bob_transfer, contract_id, None ) == -1) self.bob_test.handlers["complete"].add(complete_handler) # Invalid data id. req = list_to_ordered_dict(copy.deepcopy(self.req)) contract_id = "test" contract = { "data_id": "yyy" } self.bob_transfer.contracts[contract_id] = contract self.assertTrue(complete_handler( self.bob_transfer, contract_id, None ) == -2) # Upload: invalid src unl. req = list_to_ordered_dict(copy.deepcopy(self.req)) contract_id = "test" contract = { "data_id": req["data_id"], "dest_unl": self.bob_transfer.net.unl.value, "host_unl": self.bob_transfer.net.unl.value } self.bob_transfer.contracts[contract_id] = contract self.assertTrue(complete_handler( self.bob_transfer, contract_id, None ) == -3) # Download: invalid src unl. req = list_to_ordered_dict(copy.deepcopy(self.req)) contract_id = "test" contract = { "data_id": req["data_id"], "dest_unl": self.bob_transfer.net.unl.value, "host_unl": self.alice_transfer.net.unl.value, "src_unl": self.bob_transfer.net.unl.value } self.bob_transfer.contracts[contract_id] = contract self.assertTrue(complete_handler( self.bob_transfer, contract_id, None ) == -4) # Upload: bad results req = list_to_ordered_dict(copy.deepcopy(self.req)) contract_id = "test" contract = { "data_id": req["data_id"], "dest_unl": self.alice_transfer.net.unl.value, "host_unl": self.bob_transfer.net.unl.value } self.bob_transfer.contracts[contract_id] = contract self.assertTrue(complete_handler( self.bob_transfer, contract_id, None ) == 1)
def test_handle_responses(self): handle_requests = handle_requests_builder(self.bob_test) req = list_to_ordered_dict(copy.deepcopy(self.req)) req = ordered_dict_to_list(req) self.req = handle_requests( self.alice_dht, req ) print(req) print("-----------") # Handle responses. handle_responses = handle_responses_builder(self.alice_test) # Test invalid message type. req = list_to_ordered_dict(copy.deepcopy(self.req)) req[u"type"] = "garbage" req = ordered_dict_to_list(req) res = handle_responses( self.bob_dht, req ) self.assertTrue(res == -1) # Test transfer already active. req = list_to_ordered_dict(copy.deepcopy(self.req)) req = ordered_dict_to_list(req) self.alice_test.test_node_unl = True res = handle_responses( self.bob_dht, req ) self.assertTrue(res == -2) self.alice_test.test_node_unl = None # Check our sig is valid. req = list_to_ordered_dict(copy.deepcopy(self.req)) req[u"request"][u"something"] = u"invalidate our sig" req = ordered_dict_to_list(req) res = handle_responses( self.bob_dht, req ) self.assertTrue(res == -3) # Test node ides match. req = list_to_ordered_dict(copy.deepcopy(self.req)) req[u"request"][u"test_node_unl"] = u"nope" req = ordered_dict_to_list(req) res = handle_responses( self.bob_dht, req ) self.assertTrue(res == -4) # Their sig does not match. req = list_to_ordered_dict(copy.deepcopy(self.req)) req[u"something"] = u"invalid" req = ordered_dict_to_list(req) res = handle_responses( self.bob_dht, req ) self.assertTrue(res == -5) # This should pass. req = list_to_ordered_dict(copy.deepcopy(self.req)) req = ordered_dict_to_list(req) res = handle_responses( self.bob_dht, req ) self.assertTrue(res is None) """ ---------------------- Test accept handler. ---------------------- """ # Handler expired. req = list_to_ordered_dict(copy.deepcopy(self.req)) accept_handler = self.alice_test.handlers["accept"].pop() self.assertTrue(accept_handler( "contract_id", self.bob_transfer.net.unl.value, req[u"request"][u"data_id"], ONE_MB ) == -1) self.alice_test.handlers["accept"].add(accept_handler) # Invalid data id. self.assertTrue(accept_handler( "contract_id", self.bob_transfer.net.unl.value, "test", ONE_MB ) == -2) # Invalid node id. self.assertTrue(accept_handler( "contract_id", self.alice_transfer.net.unl.value, req[u"request"][u"data_id"], ONE_MB ) == -3) # Invalid file size. self.alice_test.test_size = 0 self.assertTrue(accept_handler( "contract_id", self.bob_transfer.net.unl.value, req[u"request"][u"data_id"], ONE_MB ) == -4) self.alice_test.test_size = 1 # This should pass self.assertTrue(accept_handler( "contract_id", self.bob_transfer.net.unl.value, req[u"request"][u"data_id"], ONE_MB ) == 1) """ ---------------------- Test start handler. ---------------------- """ # Handler expired. req = list_to_ordered_dict(copy.deepcopy(self.req)) start_handler = self.alice_test.handlers["start"].pop() self.assertTrue(start_handler( self.alice_transfer, None, "start_contract_id" ) == -1) self.alice_test.handlers["start"].add(start_handler) # This should pass. contract = { "host_unl": self.bob_transfer.net.unl.value, "dest_unl": self.alice_transfer.net.unl.value, "data_id": req["request"]["data_id"] } self.alice_transfer.contracts[req["request"]["data_id"]] = contract self.assertTrue(start_handler( self.alice_transfer, None, req["request"]["data_id"] ) == 1) # Invalid data id. contract = { "host_unl": self.bob_transfer.net.unl.value, "dest_unl": self.alice_transfer.net.unl.value, "data_id": "x" } self.alice_transfer.contracts[req["request"]["data_id"]] = contract self.assertTrue(start_handler( self.alice_transfer, None, req["request"]["data_id"] ) == -2) # Invalid dest unl for upload. contract = { "host_unl": self.bob_transfer.net.unl.value, "dest_unl": self.alice_transfer.net.unl.value, "data_id": req["request"]["data_id"] } self.alice_transfer.contracts[req["request"]["data_id"]] = contract def get_direction_wrapper(contract_id): return u"send" original_get_direction = self.alice_transfer.get_direction self.alice_transfer.get_direction = get_direction_wrapper self.assertTrue(start_handler( self.alice_transfer, None, req["request"]["data_id"] ) == -3) self.alice_transfer.get_direction = original_get_direction """ ---------------------- Test completion handler. ---------------------- completion_handler(client, contract_id, con): """ # Handler expired. req = list_to_ordered_dict(copy.deepcopy(self.req)) complete_handler = self.alice_test.handlers["complete"].pop() contract_id = "" self.assertTrue(complete_handler( self.alice_transfer, contract_id, None ) == -1) self.alice_test.handlers["complete"].add(complete_handler) # Check data ID. req = list_to_ordered_dict(copy.deepcopy(self.req)) contract_id = "test" contract = { "data_id": "yyy" } self.alice_transfer.contracts[contract_id] = contract self.assertTrue(complete_handler( self.alice_transfer, contract_id, None ) == -2) # Upload: invalid src unl. req = list_to_ordered_dict(copy.deepcopy(self.req)) contract_id = "test" contract = { "data_id": req["request"]["data_id"], "dest_unl": self.alice_transfer.net.unl.value, "host_unl": self.alice_transfer.net.unl.value } self.alice_transfer.contracts[contract_id] = contract self.assertTrue(complete_handler( self.alice_transfer, contract_id, None ) == -3) # Upload: invalid src unl. req = list_to_ordered_dict(copy.deepcopy(self.req)) contract_id = "test" contract = { "data_id": req["request"]["data_id"], "src_unl": self.alice_transfer.net.unl.value, "dest_unl": self.alice_transfer.net.unl.value, "host_unl": self.alice_transfer.net.unl.value } self.alice_transfer.contracts[contract_id] = contract def get_direction_wrapper(contract_id): return u"receive" original_get_direction = self.alice_transfer.get_direction self.alice_transfer.get_direction = get_direction_wrapper self.assertTrue(complete_handler( self.alice_transfer, contract_id, None ) == -4) self.alice_transfer.get_direction = original_get_direction # Check bad results. req = list_to_ordered_dict(copy.deepcopy(self.req)) contract_id = "test" contract = { "data_id": req["request"]["data_id"], "src_unl": self.bob_transfer.net.unl.value, "dest_unl": self.alice_transfer.net.unl.value, "host_unl": self.alice_transfer.net.unl.value } self.alice_transfer.contracts[contract_id] = contract def get_direction_wrapper(contract_id): return u"receive" original_get_direction = self.alice_transfer.get_direction self.alice_transfer.get_direction = get_direction_wrapper self.assertTrue(complete_handler( self.alice_transfer, contract_id, None ) == -1) self.alice_transfer.get_direction = original_get_direction # Test schedule new transfer. req = list_to_ordered_dict(copy.deepcopy(self.req)) contract_id = "test" contract = { "data_id": req["request"]["data_id"], "src_unl": self.bob_transfer.net.unl.value, "dest_unl": self.alice_transfer.net.unl.value, "host_unl": self.alice_transfer.net.unl.value } self.alice_transfer.contracts[contract_id] = contract def get_direction_wrapper(contract_id): return u"receive" original_get_direction = self.alice_transfer.get_direction self.alice_transfer.get_direction = get_direction_wrapper start_time = time.time() end_time = start_time + 10 self.alice_test.results = { "upload": { "transferred": int(1000), "start_time": int(start_time), "end_time": int(end_time) }, "download": { "transferred": int(1000), "start_time": int(start_time), "end_time": int(end_time) } } self.alice_test.test_size = 1000 self.assertTrue(complete_handler( self.alice_transfer, contract_id, None ) == -5) self.alice_transfer.get_direction = original_get_direction self.alice_test.test_size = 1 # This should work: req = list_to_ordered_dict(copy.deepcopy(self.req)) contract_id = "test" contract = { "data_id": req["request"]["data_id"], "src_unl": self.bob_transfer.net.unl.value, "dest_unl": self.alice_transfer.net.unl.value, "host_unl": self.alice_transfer.net.unl.value } self.alice_transfer.contracts[contract_id] = contract def get_direction_wrapper(contract_id): return u"receive" original_get_direction = self.alice_transfer.get_direction self.alice_transfer.get_direction = get_direction_wrapper start_time = time.time() end_time = start_time + 60 self.alice_test.results = { "upload": { "transferred": int(1000), "start_time": int(start_time), "end_time": int(end_time) }, "download": { "transferred": int(1000), "start_time": int(start_time), "end_time": int(end_time) } } self.assertTrue(complete_handler( self.alice_transfer, contract_id, None )) self.alice_transfer.get_direction = original_get_direction
def handle_responses(node, msg): # Check message type. msg = list_to_ordered_dict(msg) if msg[u"type"] != u"test_bandwidth_response": _log.debug("res: Invalid response") return -1 # Transfer already active. if self.test_node_unl is not None: _log.debug("res: transfer already active") return -2 # Check we sent the request. req = msg[u"request"] _log.debug(req) # Check node IDs match. if req[u"test_node_unl"] != msg[u"requestee"]: _log.debug("res: node ids don't match") return -4 # Check signature. valid_sig = verify_signature( msg[u"request"], self.wif, self.api.get_id() ) # Quit if sig is invalid. if not valid_sig: _log.debug("res: our request sig was invalid") return -3 # Check their sig. src_node_id = parse_node_id_from_unl(msg[u"requestee"]) if not verify_signature(msg, self.wif, src_node_id): _log.debug("res: their sig did not match") return -5 # Set active node ID. self.test_node_unl = msg[u"requestee"] # Register accept handler. accept_handler = build_accept_handler(self, req) self.add_handler("accept", accept_handler) # Register start handler. start_handler = build_start_handler(self, req) self.add_handler("start", start_handler) # Send upload request to remote host! contract_id = self.transfer.data_request( "download", req[u"data_id"], req[u"file_size"], req[u"test_node_unl"] ) # Fire error. def errback(ret): if self.active_test is not None: self.active_test.errback(ret) self.reset_state() # Register error handler for transfer. self.transfer.defers[contract_id].addErrback(errback) # Build completion handler. completion_handler = build_completion_handler( self, req, accept_handler ) # Register completion handler. self.add_handler("complete", completion_handler) _log.debug("res: got response")