def process_unl_requests(node, src_id, msg):
unl = node._data_transfer.net.unl.value
try:
msg = OrderedDict(msg)
# Not a UNL request.
if msg[u"type"] != u"unl_request":
return
# Check signature.
their_node_id = address_to_node_id(msg[u"requester"])
if not verify_signature(msg, node.get_key(), their_node_id):
return
# Response.
response = sign(OrderedDict(
{
u"type": u"unl_response",
u"requestee": node.get_address(),
u"unl": unl
}
), node.get_key())
# Send response.
node.relay_message(their_node_id, response.items())
except (ValueError, KeyError) as e:
global _log
_log.debug(str(e))
_log.debug("Protocol: invalid JSON")
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 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 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, src_id, msg):
# Is this a response to our request?
try:
msg = OrderedDict(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) as e:
_log.debug(str(e))
_log.debug("Protocol: invalid JSON")
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.
self.relay_message(node_id, unl_req)
# Return a new deferred.
return d
