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")
