def _react_to_set_task_session(self, msg):
super_node_info = None
if msg.super_node_info:
super_node_info = Node.from_dict(msg.super_node_info)
self.p2p_service.want_to_start_task_session(
msg.key_id, Node.from_dict(msg.node_info), msg.conn_id,
super_node_info)
def _react_to_peers(self, msg):
if not isinstance(msg.peers, list):
return
peers_info = msg.peers[:SEND_PEERS_NUM]
self.degree = len(peers_info)
for pi in peers_info:
pi['node'] = Node.from_dict(pi['node'])
self.p2p_service.try_to_add_peer(pi)
def test_json(self) -> None:
"Test serialization and deserialization"
n = Node(node_name="Blabla", key="ABC")
json_dict = n.to_dict()
json_str = json.dumps(json_dict)
print(json_str)
deser_dict = json.loads(json_str)
print(deser_dict)
n_deser = Node.from_dict(deser_dict)
self.assertEqual(n.__dict__, n_deser.__dict__)
def _react_to_hello(self, msg):
if self.verified:
logger.error("Received unexpected Hello message, ignoring")
return
# Check if sender is a seed/bootstrap node
port = getattr(msg, 'port', None)
if (self.address, port) in self.p2p_service.seeds:
compare_version(getattr(msg, 'client_ver', None))
if not self.conn.opened:
return
proto_id = getattr(msg, 'proto_id', None)
if proto_id != variables.PROTOCOL_CONST.ID:
logger.info(
"P2P protocol version mismatch %r vs %r (local)"
" for node %r:%r", proto_id, variables.PROTOCOL_CONST.ID,
self.address, self.port)
self.disconnect(message.base.Disconnect.REASON.ProtocolVersion)
return
self.node_info = Node.from_dict(msg.node_info)
if not KeysAuth.is_pubkey_difficult(self.node_info.key,
self.p2p_service.key_difficulty):
logger.info(
"Key from %r (%s:%d) is not difficult enough (%d < %d).",
self.node_info.node_name, self.address, self.port,
KeysAuth.get_difficulty(self.node_info.key),
self.p2p_service.key_difficulty)
self.disconnect(message.base.Disconnect.REASON.KeyNotDifficult)
return
self.node_name = msg.node_name
self.client_ver = msg.client_ver
self.listen_port = msg.port
self.key_id = msg.client_key_id
self.metadata = msg.metadata
solve_challenge = msg.solve_challenge
challenge = msg.challenge
difficulty = msg.difficulty
if not self.__should_init_handshake():
self.__send_hello()
if solve_challenge:
self._solve_challenge(challenge, difficulty)
else:
self.send(message.base.RandVal(rand_val=msg.rand_val))
def test_send_results(self, trust, *_):
ccd = ClientConfigDescriptor()
ccd.min_price = 11
keys_auth = KeysAuth(self.path, 'priv_key', '')
task_header = get_example_task_header(keys_auth.public_key)
n = Node.from_dict(task_header["fixed_header"]['task_owner'])
ts = self.ts
ts._is_address_accessible = Mock(return_value=True)
ts.verify_header_sig = lambda x: True
ts.client.get_suggested_addr.return_value = "10.10.10.10"
ts.client.get_requesting_trust.return_value = ts.max_trust
fd, result_file = tempfile.mkstemp()
os.close(fd)
results = {"data": [result_file]}
task_header = get_example_task_header(keys_auth.public_key)
task_id = task_header["fixed_header"]["task_id"]
assert ts.add_task_header(task_header)
assert ts.request_task()
subtask_id = idgenerator.generate_new_id_from_id(task_id)
subtask_id2 = idgenerator.generate_new_id_from_id(task_id)
self.assertTrue(ts.send_results(subtask_id, task_id, results))
self.assertTrue(ts.send_results(subtask_id2, task_id, results))
wtr = ts.results_to_send[subtask_id]
self.assertIsInstance(wtr, WaitingTaskResult)
self.assertEqual(wtr.subtask_id, subtask_id)
self.assertEqual(wtr.result, [result_file])
self.assertEqual(wtr.last_sending_trial, 0)
self.assertEqual(wtr.delay_time, 0)
self.assertEqual(wtr.owner, n)
self.assertEqual(wtr.already_sending, False)
self.assertIsNotNone(ts.task_keeper.task_headers.get(task_id))
ctd = ComputeTaskDef()
ctd['task_id'] = task_id
ctd['subtask_id'] = subtask_id
ttc = msg_factories.tasks.TaskToComputeFactory(price=1)
ttc.compute_task_def = ctd
ts.task_manager.comp_task_keeper.receive_subtask(ttc)
prev_call_count = trust.PAYMENT.increase.call_count
ts.increase_trust_payment("xyz")
self.assertGreater(trust.PAYMENT.increase.call_count, prev_call_count)
prev_call_count = trust.PAYMENT.decrease.call_count
ts.decrease_trust_payment("xyz")
self.assertGreater(trust.PAYMENT.decrease.call_count, prev_call_count)
os.remove(result_file)
def test_react_to_peers(self, add_peer_mock):
node = p2p_factories.Node()
peers = [
{
'address': node.prv_addr,
'port': node.prv_port,
'node_name': node.node_name,
'node': node.to_dict(),
},
]
msg = message.p2p.Peers(peers=copy.deepcopy(peers))
self.peer_session._react_to_peers(msg)
peers[0]['node'] = Node.from_dict(peers[0]['node'])
add_peer_mock.assert_called_once_with(peers[0])
def from_dict(dictionary) -> 'TaskFixedHeader':
if 'subtasks_count' not in dictionary:
logger.debug(
"Subtasks count missing. Implicit 1. dictionary=%r",
dictionary,
)
dictionary['subtasks_count'] = 1
th: TaskFixedHeader = \
DictSerializer.load(dictionary, as_class=TaskFixedHeader)
th.last_checking = time.time()
if isinstance(th.task_owner, dict):
th.task_owner = Node.from_dict(th.task_owner)
th.update_checksum()
return th
def from_dict(data: dict) -> 'PaymentDetails':
det = PaymentDetails()
det.__dict__.update(data)
det.__dict__['node_info'] = Node.from_dict(data['node_info'])
return det
def _react_to_want_to_start_task_session(self, msg):
super_node_info = None
if msg.super_node_info:
super_node_info = Node.from_dict(msg.super_node_info)
self.p2p_service.peer_want_task_session(Node.from_dict(msg.node_info),
super_node_info, msg.conn_id)