def test_send_should_return_http_400_if_task_to_compute_deadline_exceeded(self):
compute_task_def = message.ComputeTaskDef()
compute_task_def['task_id'] = '8'
compute_task_def['deadline'] = self.message_timestamp - 9000
with freeze_time(datetime.datetime.fromtimestamp(self.message_timestamp - 10000)):
task_to_compute = tasks.TaskToComputeFactory(
compute_task_def = self.compute_task_def,
provider_public_key = PROVIDER_PUBLIC_KEY,
requestor_public_key = REQUESTOR_PUBLIC_KEY,
price=0,
)
serialized_task_to_compute = dump(task_to_compute, REQUESTOR_PRIVATE_KEY, PROVIDER_PUBLIC_KEY)
deserialized_task_to_compute = load(serialized_task_to_compute, PROVIDER_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY, check_time = False)
ack_report_computed_task = message.AckReportComputedTask()
ack_report_computed_task.report_computed_task = message.ReportComputedTask(
task_to_compute = deserialized_task_to_compute
)
response_400 = self.client.post(
reverse('core:send'),
data = dump(
ack_report_computed_task,
PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY
),
content_type = 'application/octet-stream',
)
self._test_400_response(
response_400,
error_code=ErrorCode.QUEUE_COMMUNICATION_NOT_STARTED
)
def test_send_should_return_http_400_if_task_to_compute_deadline_exceeded(self):
compute_task_def = ComputeTaskDefFactory()
compute_task_def['deadline'] = self.message_timestamp - 9000
with freeze_time(parse_timestamp_to_utc_datetime(self.message_timestamp - 10000)):
task_to_compute = self._get_deserialized_task_to_compute(
compute_task_def=self.compute_task_def,
provider_public_key=self._get_provider_hex_public_key(),
requestor_public_key=self._get_requestor_hex_public_key(),
)
report_computed_task = message.ReportComputedTask(
task_to_compute=task_to_compute
)
report_computed_task.sign_message(self.PROVIDER_PRIVATE_KEY)
ack_report_computed_task = message.tasks.AckReportComputedTask(
report_computed_task=report_computed_task
)
response_400 = self.send_request(
url='core:send',
data=dump(
ack_report_computed_task,
self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY
),
)
self._test_400_response(
response_400,
error_code=ErrorCode.QUEUE_COMMUNICATION_NOT_STARTED
)
def _get_deserialized_ack_report_computed_task(
self,
timestamp = None,
deadline = None,
subtask_id = '1',
report_computed_task = None,
task_to_compute = None
):
""" Returns AckReportComputedTask deserialized. """
with freeze_time(timestamp or self._get_timestamp_string()):
ack_report_computed_task = message.AckReportComputedTask(
report_computed_task = (
report_computed_task if report_computed_task is not None else message.ReportComputedTask(
task_to_compute = (
task_to_compute or
self._get_deserialized_task_to_compute(
timestamp = timestamp,
deadline = deadline,
subtask_id=subtask_id
)
),
)
)
)
return ack_report_computed_task
def get_subtask_results_verify(
task_id,
subtask_id,
current_time,
reason,
report_computed_task_size,
report_computed_task_package_hash,
task_to_compute_size,
task_to_compute_package_hash,
requestor_ethereum_public_key=None,
provider_ethereum_public_key=None,
price=1,
script_src=None,
):
task_to_compute = create_signed_task_to_compute(
task_id=task_id,
subtask_id=subtask_id,
deadline=current_time + CALCULATED_VERIFICATION_TIME,
price=price if price is not None else 1,
size=task_to_compute_size,
package_hash=task_to_compute_package_hash,
requestor_ethereum_public_key=requestor_ethereum_public_key,
provider_ethereum_public_key=provider_ethereum_public_key,
script_src=script_src,
)
report_computed_task = message.ReportComputedTask(
task_to_compute=task_to_compute,
subtask_id=subtask_id,
size=report_computed_task_size,
package_hash=report_computed_task_package_hash,
)
report_computed_task.sign_message(PROVIDER_PRIVATE_KEY,
report_computed_task.get_short_hash())
with freeze_time(timestamp_to_isoformat(current_time - 1)):
subtask_results_rejected = message.tasks.SubtaskResultsRejected(
reason=reason,
report_computed_task=report_computed_task,
)
subtask_results_rejected.sign_message(
REQUESTOR_PRIVATE_KEY,
subtask_results_rejected.get_short_hash(),
)
subtask_results_verify = message.concents.SubtaskResultsVerify(
subtask_results_rejected=subtask_results_rejected, )
return subtask_results_verify
def setUp(self):
super().setUp()
compute_task_def = message.ComputeTaskDef()
task_to_compute = tasks.TaskToComputeFactory(
compute_task_def=compute_task_def
)
serialized_task_to_compute = dump(task_to_compute, REQUESTOR_PRIVATE_KEY, PROVIDER_PUBLIC_KEY)
deserialized_task_to_compute = load(serialized_task_to_compute, PROVIDER_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY,
check_time=False)
self.ack_report_computed_task = message.tasks.AckReportComputedTask()
self.ack_report_computed_task.report_computed_task = message.ReportComputedTask(
task_to_compute=deserialized_task_to_compute
)
def get_force_get_task_result(task_id, subtask_id, current_time,
cluster_consts, size, package_hash):
task_to_compute = create_signed_task_to_compute(
task_id=task_id,
subtask_id=subtask_id,
deadline=current_time,
price=0,
)
with freeze_time(timestamp_to_isoformat(current_time - 1)):
report_computed_task = message.ReportComputedTask(
task_to_compute=task_to_compute,
size=size,
package_hash=package_hash,
subtask_id=subtask_id,
)
with freeze_time(timestamp_to_isoformat(current_time)):
force_get_task_result = message.concents.ForceGetTaskResult(
report_computed_task=report_computed_task, )
return force_get_task_result
def get_subtask_results_verify(
current_time: int,
reason: message.tasks.SubtaskResultsRejected.REASON,
report_computed_task_size: int,
report_computed_task_package_hash: str,
task_to_compute_size: int,
task_to_compute_package_hash: str,
provider_public_key: Optional[bytes] = None,
provider_private_key: Optional[bytes] = None,
requestor_public_key: Optional[bytes] = None,
requestor_private_key: Optional[bytes] = None,
price: int = 1,
is_verification_deadline_before_current_time: bool = False,
additional_verification_call_time: int = 0,
minimum_upload_rate: int = 0,
render_parameters: Dict[str, Any] = None
) -> message.concents.SubtaskResultsVerify:
task_to_compute = create_signed_task_to_compute(
deadline=current_time,
price=price if price is not None else 1,
size=task_to_compute_size,
package_hash=task_to_compute_package_hash,
render_parameters=render_parameters,
provider_public_key=provider_public_key if provider_public_key else sci_base.provider_public_key,
provider_private_key=provider_private_key if provider_private_key else sci_base.provider_private_key,
requestor_public_key=requestor_public_key if requestor_public_key else sci_base.requestor_public_key,
requestor_private_key=requestor_private_key if requestor_private_key else sci_base.requestor_private_key,
)
report_computed_task = message.ReportComputedTask(
task_to_compute=task_to_compute,
size=report_computed_task_size,
package_hash=report_computed_task_package_hash,
)
report_computed_task.sign_message(
provider_private_key if provider_private_key else sci_base.provider_private_key,
report_computed_task.get_short_hash()
)
with freeze_time(timestamp_to_isoformat(current_time - 1)):
subtask_results_rejected = message.tasks.SubtaskResultsRejected(
reason=reason,
report_computed_task=report_computed_task,
)
if is_verification_deadline_before_current_time:
override_timestamp(
subtask_results_rejected,
subtask_results_rejected.timestamp - (
additional_verification_call_time +
calculate_maximum_download_time(
report_computed_task.size,
minimum_upload_rate,
) + 1
)
)
subtask_results_rejected.sign_message(
requestor_private_key if requestor_private_key else sci_base.requestor_private_key,
subtask_results_rejected.get_short_hash(),
)
subtask_results_verify = message.concents.SubtaskResultsVerify(
subtask_results_rejected=subtask_results_rejected,
)
subtask_results_verify.sign_concent_promissory_note(
deposit_contract_address=GNT_DEPOSIT_CONTRACT_ADDRESS,
private_key=provider_private_key or sci_base.provider_private_key,
)
return subtask_results_verify
def test_receive_should_return_first_messages_in_order_they_were_added_to_queue_if_the_receive_queue_contains_only_force_report_and_its_past_deadline(
self):
message_timestamp = datetime.datetime.now(timezone.utc)
new_message = StoredMessage(
type=self.force_golem_data.report_computed_task.TYPE,
timestamp=message_timestamp,
data=self.force_golem_data.report_computed_task.serialize(),
task_id=self.compute_task_def['task_id'], # pylint: disable=no-member
subtask_id=self.compute_task_def['subtask_id'], # pylint: disable=no-member
)
new_message.full_clean()
new_message.save()
task_to_compute_message = StoredMessage(
type=self.task_to_compute.TYPE,
timestamp=message_timestamp,
data=self.task_to_compute.serialize(),
task_id=self.compute_task_def['task_id'], # pylint: disable=no-member
subtask_id=self.compute_task_def['subtask_id'], # pylint: disable=no-member
)
task_to_compute_message.full_clean()
task_to_compute_message.save()
ack_report_computed_task = message.AckReportComputedTask(
report_computed_task=message.ReportComputedTask(
task_to_compute=self.task_to_compute, ))
stored_ack_report_computed_task = StoredMessage(
type=ack_report_computed_task.TYPE,
timestamp=message_timestamp,
data=ack_report_computed_task.serialize(),
task_id=self.compute_task_def['task_id'], # pylint: disable=no-member
subtask_id=self.compute_task_def['subtask_id'], # pylint: disable=no-member
)
stored_ack_report_computed_task.full_clean()
stored_ack_report_computed_task.save()
client_provider = Client(public_key_bytes=PROVIDER_PUBLIC_KEY)
client_provider.full_clean()
client_provider.save()
client_requestor = Client(public_key_bytes=REQUESTOR_PUBLIC_KEY)
client_requestor.full_clean()
client_requestor.save()
subtask = Subtask(
task_id=self.compute_task_def['task_id'],
subtask_id=self.compute_task_def['subtask_id'],
report_computed_task=new_message,
task_to_compute=task_to_compute_message,
ack_report_computed_task=stored_ack_report_computed_task,
state=Subtask.SubtaskState.REPORTED.name, # pylint: disable=no-member
provider=client_provider,
requestor=client_requestor,
result_package_size=self.size,
computation_deadline=parse_timestamp_to_utc_datetime(
self.compute_task_def['deadline']))
subtask.full_clean()
subtask.save()
new_message_inbox = PendingResponse(
response_type=PendingResponse.ResponseType.ForceReportComputedTask.
name, # pylint: disable=no-member
client=client_requestor,
queue=PendingResponse.Queue.Receive.name, # pylint: disable=no-member
subtask=subtask,
)
new_message_inbox.full_clean()
new_message_inbox.save()
new_message_inbox_out_of_band = PendingResponse(
response_type=PendingResponse.ResponseType.
VerdictReportComputedTask.name, # pylint: disable=no-member
client=client_requestor,
queue=PendingResponse.Queue.ReceiveOutOfBand.name, # pylint: disable=no-member
subtask=subtask,
)
new_message_inbox_out_of_band.full_clean()
new_message_inbox_out_of_band.save()
with freeze_time("2017-11-17 12:00:00"):
response = self.client.post(
reverse('core:receive'),
content_type='application/octet-stream',
data=self._create_client_auth_message(REQUESTOR_PRIVATE_KEY,
REQUESTOR_PUBLIC_KEY),
)
decoded_message = load(
response.content,
REQUESTOR_PRIVATE_KEY,
CONCENT_PUBLIC_KEY,
check_time=False,
)
self.assertIsInstance(decoded_message,
message.concents.ForceReportComputedTask)
self.assertEqual(response.status_code, 200)
self.assertEqual(
decoded_message.timestamp,
int(dateutil.parser.parse("2017-11-17 12:00:00").timestamp()))
self.assertEqual(decoded_message.report_computed_task.task_to_compute.
compute_task_def,
self.task_to_compute.compute_task_def) # pylint: disable=no-member
self.assertEqual(
decoded_message.report_computed_task.task_to_compute.sig,
self.task_to_compute.sig)
with freeze_time("2017-11-17 12:00:00"):
response = self.client.post(
reverse('core:receive_out_of_band'),
content_type='application/octet-stream',
data=self._create_client_auth_message(REQUESTOR_PRIVATE_KEY,
REQUESTOR_PUBLIC_KEY),
)
decoded_message = load(
response.content,
REQUESTOR_PRIVATE_KEY,
CONCENT_PUBLIC_KEY,
check_time=False,
)
self.assertIsInstance(decoded_message,
message.concents.VerdictReportComputedTask)
self.assertEqual(response.status_code, 200)
self.assertEqual(
decoded_message.timestamp,
int(dateutil.parser.parse("2017-11-17 12:00:00").timestamp()))
self.assertEqual(decoded_message.ack_report_computed_task.
report_computed_task.task_to_compute.compute_task_def,
self.task_to_compute.compute_task_def) # pylint: disable=no-member
self.assertEqual(
decoded_message.ack_report_computed_task.report_computed_task.
task_to_compute.sig, self.task_to_compute.sig)