def test_that_calculate_maximum_download_time_will_not_call_maximum_download_time_when_custom_protocol_times_is_on(self):
with mock.patch('core.utils.maximum_download_time', return_value=datetime.timedelta()) as mock_maximum_download_time:
calculate_maximum_download_time(
size=1,
rate=settings.MINIMUM_UPLOAD_RATE,
)
mock_maximum_download_time.assert_not_called()
def _precalculate_subtask_verification_time(
minimum_upload_rate: int, concent_messaging_time: int) -> int:
maxiumum_download_time = calculate_maximum_download_time(
size=REPORT_COMPUTED_TASK_SIZE,
rate=minimum_upload_rate,
)
return ((4 * concent_messaging_time) + (3 * maxiumum_download_time))
def calculate_token_expiration_deadline_for_verification_case(
subtask_results_verify: message.concents.SubtaskResultsVerify) -> int:
subtask_results_rejected = subtask_results_verify.subtask_results_rejected
return int(subtask_results_rejected.timestamp +
settings.ADDITIONAL_VERIFICATION_CALL_TIME +
calculate_maximum_download_time(
subtask_results_rejected.report_computed_task.size,
settings.MINIMUM_UPLOAD_RATE))
def test_that_both_maximum_download_time_implementation_should_return_same_result_when_golem_messages_constants_match_concent_settings(self):
for size, rate in [
(7, 19),
(10, 10),
(19, 7),
(100, 100),
(331, 331),
(1000, 1000),
(9999, 9999),
]:
self.assertEqual(
calculate_maximum_download_time(size, rate),
int(helpers.maximum_download_time(size, rate).total_seconds())
)
self.assertEqual(
calculate_maximum_download_time(size, settings.MINIMUM_UPLOAD_RATE),
calculate_maximum_download_time(size, constants.DEFAULT_UPLOAD_RATE),
)
def _get_deadline_exceeded_time_for_download_token(self, size):
return self.time + datetime.timedelta(
seconds=(
3 * settings.CONCENT_MESSAGING_TIME +
2 * calculate_maximum_download_time(
size,
settings.MINIMUM_UPLOAD_RATE,
) + self.deadline + 1
)
)
def calculate_verification_deadline(
subtask_results_rejected_timestamp: int,
additional_verification_call_time: int,
report_computed_task_size: int,
minimum_upload_rate: int,
) -> int:
return (
subtask_results_rejected_timestamp +
additional_verification_call_time +
calculate_maximum_download_time(
report_computed_task_size,
minimum_upload_rate,
)
)
def test_that_maximum_download_time_query_gives_correct_value_without_custom_protocol_times(
self):
with override_settings(
CUSTOM_PROTOCOL_TIMES=False,
DOWNLOAD_LEADIN_TIME=int(
constants.DOWNLOAD_LEADIN_TIME.total_seconds()),
):
maximum_download_deadline = calculate_maximum_download_time(
size=self.report_computed_task.size,
rate=settings.MINIMUM_UPLOAD_RATE,
)
assert_that(
Subtask.objects_with_timing_columns.get(
subtask_id=self.report_computed_task.task_to_compute.
subtask_id).maximum_download_time).is_equal_to(
maximum_download_deadline)
def calculate_token_expiration_deadline(
operation: FileTransferToken.Operation,
report_computed_task: message.tasks.ReportComputedTask,
) -> int:
if operation == FileTransferToken.Operation.upload:
token_expiration_deadline = (
int(report_computed_task.task_to_compute.compute_task_def['deadline']) +
3 * settings.CONCENT_MESSAGING_TIME +
2 * calculate_maximum_download_time(report_computed_task.size, settings.MINIMUM_UPLOAD_RATE)
)
elif operation == FileTransferToken.Operation.download:
token_expiration_deadline = (
int(report_computed_task.task_to_compute.compute_task_def['deadline']) +
calculate_subtask_verification_time(report_computed_task)
)
return token_expiration_deadline
def test_that_maximum_download_time_query_gives_correct_value(
self,
minimum_upload_rate,
download_leadin_time,
concent_messaging_time,
custom_protocol_times,
):
with override_settings(
MINIMUM_UPLOAD_RATE=minimum_upload_rate,
DOWNLOAD_LEADIN_TIME=download_leadin_time,
CONCENT_MESSAGING_TIME=concent_messaging_time,
CUSTOM_PROTOCOL_TIMES=custom_protocol_times,
):
maximum_download_deadline = calculate_maximum_download_time(
size=self.report_computed_task.size,
rate=settings.MINIMUM_UPLOAD_RATE,
)
assert_that(
Subtask.objects_with_timing_columns.get(
subtask_id=self.report_computed_task.task_to_compute.
subtask_id).maximum_download_time).is_equal_to(
maximum_download_deadline)
def create_file_transfer_token_for_concent(
subtask_id: str,
result_package_path: str,
result_size: int,
result_package_hash: str,
operation: FileTransferToken.Operation,
source_package_path: Optional[str] = None,
source_size: Optional[int] = None,
source_package_hash: Optional[str] = None,
) -> FileTransferToken:
return _create_file_transfer_token(
subtask_id=subtask_id,
source_package_path=source_package_path,
source_size=source_size,
source_package_hash=source_package_hash,
result_package_path=result_package_path,
result_size=result_size,
result_package_hash=result_package_hash,
authorized_client_public_key=settings.CONCENT_PUBLIC_KEY,
operation=operation,
token_expiration_deadline=get_current_utc_timestamp() + calculate_maximum_download_time(result_size, settings.MINIMUM_UPLOAD_RATE)
)
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
