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_change_config(self, *_): ts = self.ts ccd2 = ClientConfigDescriptor() ccd2.task_session_timeout = 124 ccd2.min_price = 0.0057 ccd2.use_distributed_resource_management = 0 ccd2.task_request_interval = 31 # ccd2.use_waiting_ttl = False ts.change_config(ccd2) self.assertEqual(ts.config_desc, ccd2) self.assertEqual(ts.last_message_time_threshold, 124) self.assertEqual(ts.task_keeper.min_price, 0.0057) self.assertEqual(ts.task_manager.use_distributed_resources, False) self.assertEqual(ts.task_computer.task_request_frequency, 31)
def test_connection_for_task_request_established(self, *_): ccd = ClientConfigDescriptor() ccd.min_price = 11 ts = self.ts session = Mock() session.address = "10.10.10.10" session.port = 1020 ts.conn_established_for_type[TASK_CONN_TYPES['task_request']]( session, "abc", "nodename", "key", "xyz", 1010, 30, 3, 1, 2) self.assertEqual(session.task_id, "xyz") self.assertEqual(session.key_id, "key") self.assertEqual(session.conn_id, "abc") self.assertEqual(ts.task_sessions["xyz"], session) session.send_hello.assert_called_with() session.request_task.assert_called_with("nodename", "xyz", 1010, 30, 3, 1, 2)
def test_request(self, tar, *_): ccd = ClientConfigDescriptor() ccd.min_price = 10 n = NodeFactory() ts = TaskServer( node=n, config_desc=ccd, client=self.client, use_docker_manager=False, task_archiver=tar, ) ts.verify_header_sig = lambda x: True self.ts = ts ts._is_address_accessible = Mock(return_value=True) ts.client.get_suggested_addr.return_value = "10.10.10.10" ts.client.get_suggested_conn_reverse.return_value = False ts.client.get_requesting_trust.return_value = 0.3 self.assertIsInstance(ts, TaskServer) self.assertIsNone(ts.request_task()) keys_auth = KeysAuth(self.path, 'prv_key', '') task_header = get_example_task_header(keys_auth.public_key) task_id = task_header["fixed_header"]["task_id"] ts.add_task_header(task_header) self.assertEqual(ts.request_task(), task_id) assert ts.remove_task_header(task_id) task_header = get_example_task_header(keys_auth.public_key) task_header["fixed_header"]["task_owner"]["pub_port"] = 0 task_id2 = task_header["fixed_header"]["task_id"] self.assertTrue(ts.add_task_header(task_header)) self.assertIsNotNone(ts.task_keeper.task_headers[task_id2]) # FIXME FIx this test # self.assertIsNone(ts.request_task()) # self.assertIsNone(ts.task_keeper.task_headers.get(task_id2)) # assert not ts.remove_task_header(task_id2) # FIXME remove me ts.remove_task_header(task_id2) # Task can be rejected for 3 reasons at this stage; in all cases # the task should be reported TaskArchiver listed as unsupported: # 1. Requestor's trust level is too low tar.reset_mock() ts.config_desc.requesting_trust = 0.5 task_header = get_example_task_header(keys_auth.public_key) task_id3 = task_header["fixed_header"]["task_id"] ts.add_task_header(task_header) self.assertIsNone(ts.request_task()) tar.add_support_status.assert_called_with( task_id3, SupportStatus(False, {UnsupportReason.REQUESTOR_TRUST: 0.3})) assert ts.remove_task_header(task_id3) # 2. Task's max price is too low tar.reset_mock() ts.config_desc.requesting_trust = 0.0 task_header = get_example_task_header(keys_auth.public_key) task_id4 = task_header["fixed_header"]["task_id"] task_header["fixed_header"]["max_price"] = 1 ts.add_task_header(task_header) self.assertIsNone(ts.request_task()) tar.add_support_status.assert_called_with( task_id4, SupportStatus(False, {UnsupportReason.MAX_PRICE: 1})) assert ts.remove_task_header(task_id4) # 3. Requestor is on a black list. tar.reset_mock() ts.acl.disallow(keys_auth.key_id) task_header = get_example_task_header(keys_auth.public_key) task_id5 = task_header["fixed_header"]["task_id"] ts.add_task_header(task_header) self.assertIsNone(ts.request_task()) tar.add_support_status.assert_called_with( task_id5, SupportStatus(False, {UnsupportReason.DENY_LIST: keys_auth.key_id})) assert ts.remove_task_header(task_id5)