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 send_msg(self, msg, unl): assert(type(msg) == OrderedDict) node_id = self.net.unl.deconstruct(unl)["node_id"] msg = ordered_dict_to_list(msg) msg = zlib.compress(str(msg)) self.net.dht_node.repeat_relay_message(node_id, msg)
def start(self, node_unl, size=1): """ :param node_unl: UNL of target :param size: MB to send in transfer :return: deferred with test results """ # Any tests currently in progress? if self.test_node_unl is not None: d = defer.Deferred() d.errback(Exception("Test already in progress")) return d # Reset test state self.test_size = size # Reset deferred. self.active_test = defer.Deferred() # Generate random file to upload. file_size = size * ONE_MB shard = generate_random_file(file_size) # Hash partial content. self.data_id = get_hash(shard).decode("utf-8") _log.debug("FINGER_log.debug HASH") _log.debug(self.data_id) # File meta data. meta = OrderedDict([ (u"file_size", file_size), (u"algorithm", u"sha256"), (u"hash", self.data_id.decode("utf-8")) ]) _log.debug("UNL") _log.debug(self.transfer.net.unl.value) _log.debug("META") _log.debug(meta) # Sign meta data. sig = sign(meta, self.wif)[u"signature"] _log.debug("SIG") _log.debug(sig) # Add file to storage. storjnode.storage.manager.add(self.transfer.store_config, shard) # Build bandwidth test request. req = OrderedDict([ (u"type", u"test_bandwidth_request"), (u"timestamp", int(time.time())), (u"requester", self.transfer.net.unl.value), (u"test_node_unl", node_unl), (u"data_id", self.data_id), (u"file_size", file_size) ]) # Sign request. req = sign(req, self.wif) # Send request. node_id = parse_node_id_from_unl(node_unl) req = ordered_dict_to_list(req) self.api.relay_message(node_id, req) # Set start time. self.start_time = time.time() # Return deferred. return self.active_test
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 get_unl_by_node_id(self, node_id): """Get the WAN IP of this Node. Returns: A twisted.internet.defer.Deferred that resolves to The UNL on success or None. """ # UNL request. _log.debug("In get UNL by node id") unl_req = OrderedDict([ (u"type", u"unl_request"), (u"requester", self.get_address()) ]) # Sign UNL request. unl_req = sign(unl_req, self.get_key()) # Handle responses for this request. def handler_builder(self, d, their_node_id, wif): 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 return handler # Build message handler. d = defer.Deferred() handler = handler_builder(self, d, node_id, self.get_key()) # Register new handler for this UNL request. self.add_message_handler(handler) # Send our get UNL request to node. unl_req = util.ordered_dict_to_list(unl_req) self.repeat_relay_message(node_id, unl_req) # Return a new deferred. return d