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)
