def worker(self):
"""Process nodes from toscan to scanned until network walked."""
while True:
time.sleep(THREAD_SLEEP)
# get next node to scan
with self.mutex:
node = self.get_next_node()
if node is None and len(self.scanning) == 0:
return # done! Nothing to scan and nothing being scanned
# no node to scan but other workers still scanning, more may come
if node is None:
continue
# get neighbors
address = storjnode.util.node_id_to_address(node.id)
_log.info("Scanning {0}".format(address))
d = self.server.protocol.callFindNode(node, node)
d = util.default_defered(d, [])
try:
neighbours = util.wait_for_defered(d, timeout=QUERY_TIMEOUT)
except TimeoutError: # pragma: no cover
msg = "Timeout getting neighbors of %s" # pragma: no cover
_log.warning(msg % address) # pragma: no cover
neighbours = [] # pragma: no cover
# add to results and neighbours to scanned
self.processed(node, neighbours)
def worker(self):
"""Process nodes from toscan to scanned until network walked."""
while True:
time.sleep(0.002)
# get next node to scan
with self.mutex:
node = self.get_next_node()
if node is None and len(self.scanning) == 0:
return # done! Nothing to scan and nothing being scanned
# no node to scan but other workers still scanning, so more may come
if node is None:
continue
# get neighbors
d = self.server.protocol.callFindNode(node, node)
d = util.default_defered(d, [])
try:
neighbours = util.wait_for_defered(d, timeout=QUERY_TIMEOUT)
except TimeoutError: # pragma: no cover
msg = "Timeout when getting neighbors of %s" # pragma: no cover
hexid = binascii.hexlify(node.id)
_log.debug(msg % hexid) # pragma: no cover
neighbours = [] # pragma: no cover
# add to results and neighbours to scanned
self.processed(node, neighbours)
def worker(self):
"""Process nodes from toscan to scanned until network walked."""
while True:
time.sleep(0.002)
# get next node to scan
with self.mutex:
node = self.get_next_node()
if node is None and len(self.scanning) == 0:
return # done! Nothing to scan and nothing being scanned
# no node to scan but other workers still scanning, so more may come
if node is None:
continue
# get neighbors
d = self.server.protocol.callFindNode(node, node)
d = util.default_defered(d, [])
try:
neighbours = util.wait_for_defered(d, timeout=QUERY_TIMEOUT)
except TimeoutError: # pragma: no cover
msg = "Timeout when getting neighbors of %s" # pragma: no cover
hexid = binascii.hexlify(node.id)
_log.debug(msg % hexid) # pragma: no cover
neighbours = [] # pragma: no cover
# add to results and neighbours to scanned
self.processed(node, neighbours)
def _relay_message(self, entry):
"""Returns entry if failed to relay to a closer node or None"""
dest = Node(entry["dest"])
nearest = self.protocol.router.findNeighbors(dest, exclude=self.node)
self.log.debug("Relaying to nearest: %s" % repr(nearest))
for relay_node in nearest:
# do not relay away from node
if dest.distanceTo(self.node) <= dest.distanceTo(relay_node):
msg = "Skipping %s, farther then self."
self.log.debug(msg % repr(relay_node))
continue
# relay message
hexid = binascii.hexlify(relay_node.id)
self.log.debug("Attempting to relay message for %s" % hexid)
defered = self.protocol.callRelayMessage(
relay_node, entry["dest"], entry["hop_limit"], entry["message"]
)
defered = util.default_defered(defered, None)
# wait for relay result
try:
result = util.wait_for_defered(defered, timeout=QUERY_TIMEOUT)
except TimeoutError: # pragma: no cover
msg = "Timeout while relayed message to %s" # pragma: no cover
self.log.debug(msg % hexid) # pragma: no cover
result = None # pragma: no cover
# successfull relay
if result is not None:
self.log.debug("Successfully relayed message to %s" % hexid)
return # relay to nearest peer, avoid amplification attacks
# failed to relay message
dest_hexid = binascii.hexlify(entry["dest"])
self.log.debug("Failed to relay message for %s" % dest_hexid)
def _relay_message(self, entry):
"""Returns entry if failed to relay to a closer node or None"""
dest = Node(entry["dest"])
nearest = self.protocol.router.findNeighbors(dest, exclude=self.node)
self.log.debug("Relaying to nearest: %s" % repr(nearest))
for relay_node in nearest:
# do not relay away from node
if dest.distanceTo(self.node) <= dest.distanceTo(relay_node):
msg = "Skipping %s, farther then self."
self.log.debug(msg % repr(relay_node))
continue
# relay message
hexid = binascii.hexlify(relay_node.id)
self.log.debug("Attempting to relay message for %s" % hexid)
defered = self.protocol.callRelayMessage(relay_node, entry["dest"],
entry["hop_limit"],
entry["message"])
defered = util.default_defered(defered, None)
# wait for relay result
try:
result = util.wait_for_defered(defered, timeout=QUERY_TIMEOUT)
except TimeoutError: # pragma: no cover
msg = "Timeout while relayed message to %s" # pragma: no cover
self.log.debug(msg % hexid) # pragma: no cover
result = None # pragma: no cover
# successfull relay
if result is not None:
self.log.debug("Successfully relayed message to %s" % hexid)
return # relay to nearest peer, avoid amplification attacks
# failed to relay message
dest_hexid = binascii.hexlify(entry["dest"])
self.log.debug("Failed to relay message for %s" % dest_hexid)
