def test_request(self):
ccd = self._get_config_desc()
ccd.min_price = 10
n = Node()
ka = EllipticalKeysAuth(self.path)
ts = TaskServer(n, ccd, ka, self.client,
use_docker_machine_manager=False)
ts.verify_header_sig = lambda x: True
self.ts = ts
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())
n2 = Node()
n2.prv_addr = "10.10.10.10"
n2.port = 10101
task_header = get_example_task_header()
task_header["task_owner"] = n2
ts.add_task_header(task_header)
self.assertEqual(ts.request_task(), "uvw")
ts.remove_task_header("uvw")
task_header["task_owner_port"] = 0
task_header["task_id"] = "uvw2"
self.assertTrue(ts.add_task_header(task_header))
self.assertIsNotNone(ts.task_keeper.task_headers["uvw2"])
self.assertIsNone(ts.request_task())
self.assertIsNone(ts.task_keeper.task_headers.get("uvw2"))
def test_send_results(self, trust):
ccd = self._get_config_desc()
ccd.min_price = 11
n = Node()
ka = EllipticalKeysAuth(self.path)
ts = TaskServer(n, ccd, ka, self.client,
use_docker_machine_manager=False)
ts.verify_header_sig = lambda x: True
self.ts = ts
ts.client.get_suggested_addr.return_value = "10.10.10.10"
results = {"data": "", "result_type": 0}
task_header = get_example_task_header()
task_header["task_id"] = "xyz"
ts.add_task_header(task_header)
ts.request_task()
self.assertTrue(ts.send_results("xxyyzz", "xyz", results, 40, "10.10.10.10", 10101, "key", n, "node_name"))
self.assertTrue(ts.send_results("xyzxyz", "xyz", results, 40, "10.10.10.10", 10101, "key", n, "node_name"))
self.assertEqual(ts.get_subtask_ttl("xyz"), 120)
wtr = ts.results_to_send["xxyyzz"]
self.assertIsInstance(wtr, WaitingTaskResult)
self.assertEqual(wtr.subtask_id, "xxyyzz")
self.assertEqual(wtr.result, "")
self.assertEqual(wtr.result_type, 0)
self.assertEqual(wtr.computing_time, 40)
self.assertEqual(wtr.last_sending_trial, 0)
self.assertEqual(wtr.delay_time, 0)
self.assertEqual(wtr.owner_address, "10.10.10.10")
self.assertEqual(wtr.owner_port, 10101)
self.assertEqual(wtr.owner_key_id, "key")
self.assertEqual(wtr.owner, n)
self.assertEqual(wtr.already_sending, False)
ts.client.transaction_system.add_to_waiting_payments.assert_called_with(
"xyz", "key", 1)
with self.assertLogs(logger, level='WARNING'):
ts.subtask_rejected("aabbcc")
self.assertIsNotNone(ts.task_keeper.task_headers.get("xyz"))
prev_call_count = trust.PAYMENT.increase.call_count
with self.assertLogs(logger, level="WARNING"):
ts.reward_for_subtask_paid("aa2bb2cc")
self.assertEqual(trust.PAYMENT.increase.call_count, prev_call_count)
ctd = ComputeTaskDef()
ctd.task_id = "xyz"
ctd.subtask_id = "xxyyzz"
ts.task_manager.comp_task_keeper.receive_subtask(ctd)
ts.reward_for_subtask_paid("xxyyzz")
self.assertGreater(trust.PAYMENT.increase.call_count, prev_call_count)
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)
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)
