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
