def setUp(self): super().setUp() self.compute_task_def = self._get_deserialized_compute_task_def( deadline=get_current_utc_timestamp() + 100 ) self.task_to_compute = self._get_deserialized_task_to_compute( timestamp=parse_timestamp_to_utc_datetime(get_current_utc_timestamp()), compute_task_def=self.compute_task_def, ) self.report_computed_task = self._get_deserialized_report_computed_task( task_to_compute=self.task_to_compute, ) self.force_report_computed_task = self._get_deserialized_force_report_computed_task( report_computed_task=self.report_computed_task ) self.reject_report_computed_task = self._get_deserialized_reject_report_computed_task( reason=message.tasks.RejectReportComputedTask.REASON.SubtaskTimeLimitExceeded, task_to_compute=self.task_to_compute, ) self.force_get_task_result = self._get_deserialized_force_subtask_results( timestamp=parse_timestamp_to_utc_datetime(get_current_utc_timestamp()), task_to_compute=self.task_to_compute, ) self.provider_public_key = hex_to_bytes_convert(self.task_to_compute.provider_public_key) self.requestor_public_key = hex_to_bytes_convert(self.task_to_compute.requestor_public_key)
def test_case_2c_send_force_payment_with_no_value_to_be_paid( cluster_consts: ProtocolConstants, cluster_url: str) -> None: # Test CASE 2C - Send ForcePayment with no value to be paid receive_pending_messages_for_requestor_and_provider( cluster_url, sci_base, CONCENT_PUBLIC_KEY) current_time = get_current_utc_timestamp() api_request( cluster_url, 'send', sci_base.provider_private_key, CONCENT_PUBLIC_KEY, force_payment( timestamp=timestamp_to_isoformat(current_time), subtask_results_accepted_list=[ create_signed_subtask_results_accepted( timestamp=timestamp_to_isoformat( current_time - cluster_consts.payment_due_time + AVERAGE_TIME_FOR_TWO_BLOCKS), payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, report_computed_task=create_signed_report_computed_task( task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime( current_time), deadline=current_time, price=0, provider_public_key=sci_base.provider_public_key, provider_private_key=sci_base.provider_private_key, requestor_public_key=sci_base.requestor_public_key, requestor_private_key=sci_base. requestor_private_key, ), provider_private_key=sci_base.provider_private_key), requestor_private_key=sci_base.requestor_private_key, ), create_signed_subtask_results_accepted( timestamp=timestamp_to_isoformat( current_time - cluster_consts.payment_due_time + AVERAGE_TIME_FOR_TWO_BLOCKS), payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, report_computed_task=create_signed_report_computed_task( task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime( current_time), deadline=current_time, price=0, provider_public_key=sci_base.provider_public_key, provider_private_key=sci_base.provider_private_key, requestor_public_key=sci_base.requestor_public_key, requestor_private_key=sci_base. requestor_private_key, ), provider_private_key=sci_base.provider_private_key), requestor_private_key=sci_base.requestor_private_key, ), ]), expected_status=200, expected_message_type=message.concents.ServiceRefused, )
def calculate_subtask_verification_time( report_computed_task: message.ReportComputedTask) -> int: """ This function calls `subtask_verification_time` helper function from golem messages or Concent custom implementation of it, depending on CUSTOM_PROTOCOL_TIMES setting value. The reason for using custom implementation is because it has hard-coded values and we cannot make it use values from our settings. """ assert isinstance(report_computed_task, message.ReportComputedTask) if settings.CUSTOM_PROTOCOL_TIMES: mdt = calculate_maximum_download_time( size=report_computed_task.size, rate=settings.MINIMUM_UPLOAD_RATE) ttc_dt = parse_timestamp_to_utc_datetime( report_computed_task.task_to_compute.timestamp, ) subtask_dt = parse_timestamp_to_utc_datetime( report_computed_task.task_to_compute.compute_task_def['deadline'], ) subtask_timeout = subtask_dt - ttc_dt return int((4 * settings.CONCENT_MESSAGING_TIME) + (3 * mdt) + (0.5 * subtask_timeout.total_seconds())) else: return int( subtask_verification_time(report_computed_task).total_seconds())
def test_case_2b_send_force_payment_beyond_payment_time( cluster_consts: ProtocolConstants, cluster_url: str) -> None: # Test CASE 2B - Send ForcePayment beyond payment time receive_pending_messages_for_requestor_and_provider( cluster_url, sci_base, CONCENT_PUBLIC_KEY) current_time = get_current_utc_timestamp() api_request( cluster_url, 'send', sci_base.provider_private_key, CONCENT_PUBLIC_KEY, force_payment( timestamp=timestamp_to_isoformat(current_time), subtask_results_accepted_list=[ create_signed_subtask_results_accepted( timestamp=timestamp_to_isoformat(current_time), payment_ts=current_time, report_computed_task=create_signed_report_computed_task( task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime( current_time), deadline=current_time, price=15000, provider_public_key=sci_base.provider_public_key, provider_private_key=sci_base.provider_private_key, requestor_public_key=sci_base.requestor_public_key, requestor_private_key=sci_base. requestor_private_key, ), provider_private_key=sci_base.provider_private_key, ), requestor_private_key=sci_base.requestor_private_key), create_signed_subtask_results_accepted( timestamp=timestamp_to_isoformat( current_time - cluster_consts.payment_due_time + AVERAGE_TIME_FOR_TWO_BLOCKS), payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, report_computed_task=create_signed_report_computed_task( task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime( current_time), deadline=current_time, price=15000, provider_public_key=sci_base.provider_public_key, provider_private_key=sci_base.provider_private_key, requestor_public_key=sci_base.requestor_public_key, requestor_private_key=sci_base. requestor_private_key, ), provider_private_key=sci_base.provider_private_key, ), requestor_private_key=sci_base.requestor_private_key) ]), expected_status=200, expected_message_type=message.concents.ForcePaymentRejected, expected_content_type='application/octet-stream', )
def test_case_2d_send_correct_force_payment(cluster_consts, cluster_url, test_id): # Test CASE 2D - Send correct ForcePayment current_time = get_current_utc_timestamp() (task_id, subtask_id) = get_task_id_and_subtask_id(test_id, '2D') correct_force_payment = force_payment(subtask_results_accepted_list=[ subtask_results_accepted( payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime(current_time), task_id=task_id + 'a', subtask_id=subtask_id + 'A', deadline=current_time, price=1000, )), subtask_results_accepted( payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime(current_time), task_id=task_id + 'b', subtask_id=subtask_id + 'B', deadline=current_time, price=1000, )) ]) correct_force_payment.sig = None api_request( cluster_url, 'send', PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY, correct_force_payment, headers={ 'Content-Type': 'application/octet-stream', }, expected_status=200, expected_message_type=message.concents.ForcePaymentCommitted.TYPE, expected_content_type='application/octet-stream', ) time.sleep(5) api_request( cluster_url, 'receive-out-of-band', REQUESTOR_PRIVATE_KEY, CONCENT_PUBLIC_KEY, create_client_auth_message(REQUESTOR_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY, CONCENT_PUBLIC_KEY), headers={ 'Content-Type': 'application/octet-stream', }, expected_status=200, expected_message_type=message.concents.ForcePaymentCommitted.TYPE, expected_content_type='application/octet-stream', )
def queryset(self, request: HttpRequest, queryset: QuerySet) -> QuerySet: assert self.value() in {'active', 'passive', 'active_or_downloads', None} current_timestamp = get_current_utc_timestamp() if self.value() == 'active': return queryset.filter(state__in=ACTIVE_STATE_NAMES, next_deadline__gte=parse_timestamp_to_utc_datetime(current_timestamp)) elif self.value() == 'passive': return queryset.filter( Q(state__in=PASSIVE_STATE_NAMES) | Q(state__in=ACTIVE_STATE_NAMES, next_deadline__lt=parse_timestamp_to_utc_datetime(current_timestamp)) ) elif self.value() == 'active_or_downloads': return Subtask.objects_with_timing_columns.filter( Q(download_deadline__gte=current_timestamp, state=Subtask.SubtaskState.RESULT_UPLOADED.name) | # pylint: disable=no-member Q(state__in=ACTIVE_STATE_NAMES, next_deadline__gte=parse_timestamp_to_utc_datetime(current_timestamp)) ) return queryset
def test_parse_timestamp_to_utc_datetime_should_return_utc_datetime(self): """ Tests if parse_timestamp_to_utc_datetime function works as expected. """ for timestamp, expected_datetime in { 946684800: datetime.datetime(year=2000, month=1, day=1, hour=0, minute=0, second=0, tzinfo=timezone.utc), 946684800 + 3666: datetime.datetime(year=2000, month=1, day=1, hour=1, minute=1, second=6, tzinfo=timezone.utc), 1321009871: datetime.datetime(year=2011, month=11, day=11, hour=11, minute=11, second=11, tzinfo=timezone.utc), }.items(): self.assertEqual(parse_timestamp_to_utc_datetime(timestamp), expected_datetime)
def store_verification_request_and_blender_subtask_definition( subtask_id: str, source_package_path: str, result_package_path: str, output_format: str, scene_file: str, verification_deadline: int, blender_crop_script: Optional[str], ) -> tuple: verification_request = VerificationRequest( subtask_id=subtask_id, source_package_path=source_package_path, result_package_path=result_package_path, verification_deadline=parse_timestamp_to_utc_datetime( verification_deadline), ) verification_request.full_clean() verification_request.save() blender_subtask_definition = BlenderSubtaskDefinition( verification_request=verification_request, output_format=BlenderSubtaskDefinition.OutputFormat[output_format]. name, scene_file=scene_file, blender_crop_script=blender_crop_script, ) blender_subtask_definition.full_clean() blender_subtask_definition.save() return (verification_request, blender_subtask_definition)
def test_that_if_stored_messages_have_incompatible_protocol_version_function_should_return_false( self): with override_settings( GOLEM_MESSAGES_VERSION='1.11.1', MAJOR_MINOR_GOLEM_MESSAGES_VERSION='1.11', ): subtask = Subtask( task_id=self.task_to_compute.compute_task_def['task_id'], subtask_id=self.task_to_compute.compute_task_def['subtask_id'], provider=self.provider, requestor=self.requestor, result_package_size=self.size, state=Subtask.SubtaskState.REPORTED.name, # pylint: disable=no-member next_deadline=None, computation_deadline=parse_timestamp_to_utc_datetime( self.compute_task_def['deadline']), task_to_compute=store_message(self.task_to_compute, self.task_id, self.subtask_id), want_to_compute_task=store_message( self.task_to_compute.want_to_compute_task, self.task_id, self.subtask_id), report_computed_task=store_message(self.report_computed_task, self.task_id, self.subtask_id), protocol_version=settings.MAJOR_MINOR_GOLEM_MESSAGES_VERSION, ) subtask.full_clean() subtask.save() self.assertFalse( is_protocol_version_compatible( subtask.task_to_compute.protocol_version, ))
def test_that_verification_result_error_should_add_pending_messages_subtask_results_settled_and_change_subtask_state_to_accepted( self): with freeze_time( parse_timestamp_to_utc_datetime(get_current_utc_timestamp())): with mock.patch('core.tasks.logger.info') as logging_info_mock: verification_result( # pylint: disable=no-value-for-parameter self.subtask.subtask_id, VerificationResult.ERROR.name, 'test', ErrorCode.REQUEST_BODY_NOT_EMPTY.name, ) self.subtask.refresh_from_db() self.assertEqual(self.subtask.state_enum, Subtask.SubtaskState.ACCEPTED) self.assertEqual(self.subtask.next_deadline, None) self.assertEqual(PendingResponse.objects.count(), 2) self.assertTrue( PendingResponse.objects.filter( client=self.subtask.provider).exists()) self.assertTrue( PendingResponse.objects.filter( client=self.subtask.requestor).exists()) self.assertEqual(logging_info_mock.call_count, 3) self.assertIn( f'SUBTASK_ID: {self.subtask.subtask_id}. Verification_result_task starts. Result: ERROR', str(logging_info_mock.call_args_list)) self.assertIn( f'SUBTASK_ID: {self.subtask.subtask_id}. Verification_result_task ends. Result: ERROR', str(logging_info_mock.call_args_list))
def test_that_if_stored_messages_are_compatible_with_protocol_version_function_should_return_true( self): subtask = Subtask( task_id=self.task_to_compute.compute_task_def['task_id'], subtask_id=self.task_to_compute.compute_task_def['subtask_id'], provider=self.provider, requestor=self.requestor, result_package_size=self.size, state=Subtask.SubtaskState.REPORTED.name, # pylint: disable=no-member next_deadline=None, computation_deadline=parse_timestamp_to_utc_datetime( self.compute_task_def['deadline']), task_to_compute=store_message(self.task_to_compute, self.task_id, self.subtask_id), want_to_compute_task=store_message( self.task_to_compute.want_to_compute_task, self.task_id, self.subtask_id), report_computed_task=store_message(self.report_computed_task, self.task_id, self.subtask_id), ) subtask.full_clean() subtask.save() self.assertTrue( is_protocol_version_compatible( subtask.task_to_compute.protocol_version, ))
def test_that_exception_is_not_raised_when_subtask_is_null_and_concent_use_case_is_forced_payment( self): self.deposit_claim.subtask = None self.deposit_claim.concent_use_case = ConcentUseCase.FORCED_PAYMENT.value self.deposit_claim.closure_time = parse_timestamp_to_utc_datetime( get_current_utc_timestamp()) self.deposit_claim.clean()
def update_subtasks_states(subtask: Subtask, client_public_key: bytes) -> None: if (subtask.state in [state.name for state in Subtask.ACTIVE_STATES] and subtask.next_deadline <= parse_timestamp_to_utc_datetime( get_current_utc_timestamp())): verify_file_status(subtask=subtask, client_public_key=client_public_key) _update_timed_out_subtask(subtask)
def update_all_timed_out_subtasks_of_a_client( client_public_key: bytes) -> None: """ Function looks for all subtasks in active state of client. All found subtasks are processed in separate transactions, locked in database, file status is verified (check additional conditions in verify_file_status) and subtask's state is updated in _update_timed_out_subtask """ encoded_client_public_key = b64encode(client_public_key) clients_subtask_list = Subtask.objects.filter( Q(requestor__public_key=encoded_client_public_key) | Q(provider__public_key=encoded_client_public_key), state__in=[state.name for state in Subtask.ACTIVE_STATES], ) # Check if files are uploaded for all clients subtasks. It is checked for all clients subtasks, not only timeouted. for subtask in clients_subtask_list: with transaction.atomic(using='control'): Subtask.objects.select_for_update().filter( subtask_id=subtask.subtask_id) verify_file_status(subtask=subtask, client_public_key=client_public_key) # Subtask may change it's state to passive (RESULT UPLOADED) in verify_file_status. In this case there # is no need to call _update_timed_out_subtask any more. Next_deadline will be set to None, so it is # necessary to check it before checking if deadline is exceeded. if subtask.next_deadline is not None and subtask.next_deadline <= parse_timestamp_to_utc_datetime( get_current_utc_timestamp()): _update_timed_out_subtask(subtask)
def test_that_update_subtask_passes_validations_from_passive_to_active_state( self): subtask = store_subtask( task_id=self.task_to_compute.compute_task_def['task_id'], subtask_id=self.task_to_compute.compute_task_def['subtask_id'], provider_public_key=self.provider_public_key, requestor_public_key=self.requestor_public_key, state=Subtask.SubtaskState.REPORTED, next_deadline=None, task_to_compute=self.task_to_compute, report_computed_task=self.report_computed_task, ) subtask_state = Subtask.objects.get( subtask_id=self.task_to_compute.compute_task_def['subtask_id'] ).state self.assertEqual(subtask_state, Subtask.SubtaskState.REPORTED.name) # pylint: disable=no-member self.assertEqual(subtask.next_deadline, None) next_deadline = int(self.task_to_compute.compute_task_def['deadline'] ) + settings.CONCENT_MESSAGING_TIME update_and_return_updated_subtask( subtask=subtask, state=Subtask.SubtaskState.FORCING_RESULT_TRANSFER, next_deadline=next_deadline, force_get_task_result=self.force_get_task_result, set_next_deadline=True, ) subtask_state = Subtask.objects.get( subtask_id=self.task_to_compute.compute_task_def['subtask_id'] ).state self.assertEqual(subtask_state, Subtask.SubtaskState.FORCING_RESULT_TRANSFER.name) # pylint: disable=no-member self.assertEqual(subtask.next_deadline, parse_timestamp_to_utc_datetime(next_deadline))
def store_pending_message( response_type: PendingResponse.ResponseType, client_public_key: bytes, queue: PendingResponse.Queue, subtask: Optional[Subtask] = None, payment_message: Optional[message.concents.ForcePaymentCommitted] = None, ) -> None: try: client = Client.objects.get_or_create_full_clean(client_public_key) receive_queue = PendingResponse( response_type=response_type.name, client=client, queue=queue.name, subtask=subtask, ) receive_queue.full_clean() receive_queue.save() if payment_message is not None: payment_committed_message = PaymentInfo( payment_ts=parse_timestamp_to_utc_datetime( payment_message.payment_ts), task_owner_key=payment_message.task_owner_key, provider_eth_account=payment_message.provider_eth_account, amount_paid=payment_message.amount_paid, recipient_type=payment_message.recipient_type.name, # pylint: disable=no-member amount_pending=payment_message.amount_pending, pending_response=receive_queue) payment_committed_message.full_clean() payment_committed_message.save() except IntegrityError: raise CreateModelIntegrityError logging.log_new_pending_response(logger, response_type.name, queue.name, subtask)
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 test_case_2d_send_correct_force_payment(cluster_consts: ProtocolConstants, cluster_url: str) -> None: # Test CASE 2D - Send correct ForcePayment current_time = get_current_utc_timestamp() correct_force_payment = force_payment(subtask_results_accepted_list=[ create_signed_subtask_results_accepted( payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, report_computed_task=create_signed_report_computed_task( task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime(current_time), deadline=current_time, price=1000, ))), create_signed_subtask_results_accepted( payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, report_computed_task=create_signed_report_computed_task( task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime(current_time), deadline=current_time, price=1000, ))) ]) correct_force_payment.sig = None api_request( cluster_url, 'send', PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY, correct_force_payment, expected_status=200, expected_message_type=message.concents.ForcePaymentCommitted, expected_content_type='application/octet-stream', ) time.sleep(5) api_request( cluster_url, 'receive', REQUESTOR_PRIVATE_KEY, CONCENT_PUBLIC_KEY, create_client_auth_message(REQUESTOR_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY, CONCENT_PUBLIC_KEY), expected_status=200, expected_message_type=message.concents.ForcePaymentCommitted, expected_content_type='application/octet-stream', )
def populate_subtask_deadline_field(apps, _schema_editor): Subtask = apps.get_model('core', 'Subtask') for subtask in Subtask.objects.all(): subtask.computation_deadline = parse_timestamp_to_utc_datetime( deserialize_message( subtask.task_to_compute.data).compute_task_def['deadline']) subtask.full_clean() subtask.save()
def test_that_exception_is_raised_when_closure_time_is_set_in_use_case_other_than_forced_payment( self): self.deposit_claim.concent_use_case = ConcentUseCase.ADDITIONAL_VERIFICATION.value self.deposit_claim.closure_time = parse_timestamp_to_utc_datetime( get_current_utc_timestamp()) with pytest.raises(ValidationError) as exception_info: self.deposit_claim.clean() self.assertIn('closure_time', exception_info.value.error_dict)
def test_case_2_a_force_payment_with_subtask_result_accepted_where_ethereum_accounts_are_different( cluster_consts, cluster_url, test_id): # Test CASE 2A - Send ForcePayment with SubtaskResultsAccepted where ethereum accounts are different current_time = get_current_utc_timestamp() (task_id, subtask_id) = get_task_id_and_subtask_id(test_id, '2A') api_request( cluster_url, 'send', PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY, force_payment( timestamp=timestamp_to_isoformat(current_time), subtask_results_accepted_list=[ subtask_results_accepted( timestamp=timestamp_to_isoformat(current_time), payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime( current_time), task_id=task_id + 'a', subtask_id=subtask_id + 'A', deadline=current_time, price=15000, )), subtask_results_accepted( timestamp=timestamp_to_isoformat(current_time), payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime( current_time), task_id=task_id + 'b', subtask_id=subtask_id + 'B', deadline=current_time, price=15000, requestor_ethereum_public_key=encode_hex( b'0' * GOLEM_PUBLIC_KEY_LENGTH))) ]), headers={ 'Content-Type': 'application/octet-stream', }, expected_status=200, expected_message_type=message.concents.ServiceRefused.TYPE, expected_content_type='application/octet-stream', )
def test_case_2_a_force_payment_with_subtask_result_accepted_where_ethereum_accounts_are_different( cluster_consts: ProtocolConstants, cluster_url: str, ) -> None: # Test CASE 2A - Send ForcePayment with SubtaskResultsAccepted where ethereum accounts are different current_time = get_current_utc_timestamp() api_request( cluster_url, 'send', PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY, force_payment( timestamp=timestamp_to_isoformat(current_time), subtask_results_accepted_list=[ create_signed_subtask_results_accepted( timestamp=timestamp_to_isoformat(current_time), payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, report_computed_task=create_signed_report_computed_task( task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime( current_time), deadline=current_time, price=15000, ))), create_signed_subtask_results_accepted( timestamp=timestamp_to_isoformat(current_time), payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, report_computed_task=create_signed_report_computed_task( task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime( current_time), deadline=current_time, price=15000, requestor_ethereum_public_key= DIFFERENT_REQUESTOR_ETHEREUM_PUBLIC_KEY, requestor_ethereum_private_key= DIFFERENT_REQUESTOR_ETHEREUM_PRIVATE_KEY, ))) ]), expected_status=200, expected_message_type=message.concents.ServiceRefused, expected_content_type='application/octet-stream', )
def test_case_2c_send_force_payment_with_no_value_to_be_paid( cluster_consts, cluster_url, test_id): # Test CASE 2C - Send ForcePayment with no value to be paid current_time = get_current_utc_timestamp() (task_id, subtask_id) = get_task_id_and_subtask_id(test_id, '2C') api_request( cluster_url, 'send', PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY, force_payment( timestamp=timestamp_to_isoformat(current_time), subtask_results_accepted_list=[ subtask_results_accepted( timestamp=timestamp_to_isoformat(current_time), payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime( current_time), task_id=task_id + 'a', subtask_id=subtask_id + 'A', deadline=current_time, price=0, )), subtask_results_accepted( timestamp=timestamp_to_isoformat(current_time), payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime( current_time), task_id=task_id + 'b', subtask_id=subtask_id + 'B', deadline=current_time, price=0, )) ]), headers={ 'Content-Type': 'application/octet-stream', }, expected_status=200, expected_message_type=message.concents.ForcePaymentRejected.TYPE, expected_content_type='application/octet-stream', )
def _prepare_file_transfer_token(self, subtask_results_verify): date_time = parse_timestamp_to_utc_datetime( subtask_results_verify.timestamp) with freeze_time(date_time): file_transfer_token = create_file_transfer_token_for_verification_use_case( subtask_results_verify, self.PROVIDER_PUBLIC_KEY, ) return file_transfer_token
def switch_stored_message_timestamp_to_message_creation_time(apps, _schema_editor): StoredMessage = apps.get_model('core', 'StoredMessage') for stored_message in StoredMessage.objects.all(): stored_message.timestamp = parse_timestamp_to_utc_datetime( deserialize_message(stored_message.data.tobytes()).timestamp ) stored_message.full_clean() stored_message.save()
def _get_verification_deadline_as_datetime( self, subtask_results_rejected_timestamp: int, task_to_compute: message.tasks.TaskToCompute, ) -> datetime.datetime: return parse_timestamp_to_utc_datetime( self._get_verification_deadline_as_timestamp( subtask_results_rejected_timestamp, task_to_compute, ))
def update_subtask_state(subtask: Subtask, state: str, next_deadline: Union[int, float, None] = None) -> None: old_state = subtask.state subtask.state = state subtask.next_deadline = None if next_deadline is None else parse_timestamp_to_utc_datetime(next_deadline) subtask.full_clean() subtask.save() log( logger, f'Subtask changed its state from {old_state} to {subtask.state}', subtask_id=subtask.subtask_id )
def test_that_verification_result_mismatch_should_add_pending_messages_subtask_results_rejected(self): with freeze_time(parse_timestamp_to_utc_datetime(get_current_utc_timestamp())): verification_result( # pylint: disable=no-value-for-parameter self.subtask.subtask_id, VerificationResult.MISMATCH.name, ) self.subtask.refresh_from_db() self.assertEqual(self.subtask.state_enum, Subtask.SubtaskState.FAILED) self.assertEqual(self.subtask.next_deadline, None) self.assertEqual(PendingResponse.objects.count(), 2) self.assertTrue(PendingResponse.objects.filter(client=self.subtask.provider).exists()) self.assertTrue(PendingResponse.objects.filter(client=self.subtask.requestor).exists())
def test_case_2b_send_force_payment_beyond_payment_time( cluster_consts: ProtocolConstants, cluster_url: str) -> None: # Test CASE 2B - Send ForcePayment beyond payment time current_time = get_current_utc_timestamp() api_request( cluster_url, 'send', PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY, force_payment( timestamp=timestamp_to_isoformat(current_time), subtask_results_accepted_list=[ create_signed_subtask_results_accepted( timestamp=timestamp_to_isoformat(current_time), payment_ts=current_time, report_computed_task=create_signed_report_computed_task( task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime( current_time), deadline=current_time, price=15000, ))), create_signed_subtask_results_accepted( timestamp=timestamp_to_isoformat(current_time), payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, report_computed_task=create_signed_report_computed_task( task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime( current_time), deadline=current_time, price=15000, ))) ]), expected_status=200, expected_message_type=message.concents.ForcePaymentRejected, expected_content_type='application/octet-stream', )
def test_case_2c_send_force_payment_with_no_value_to_be_paid( cluster_consts: ProtocolConstants, cluster_url: str) -> None: # Test CASE 2C - Send ForcePayment with no value to be paid current_time = get_current_utc_timestamp() api_request( cluster_url, 'send', PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY, force_payment( timestamp=timestamp_to_isoformat(current_time), subtask_results_accepted_list=[ create_signed_subtask_results_accepted( timestamp=timestamp_to_isoformat(current_time), payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, report_computed_task=create_signed_report_computed_task( task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime( current_time), deadline=current_time, price=0, ))), create_signed_subtask_results_accepted( timestamp=timestamp_to_isoformat(current_time), payment_ts=current_time - cluster_consts.payment_due_time - AVERAGE_TIME_FOR_TWO_BLOCKS, report_computed_task=create_signed_report_computed_task( task_to_compute=create_signed_task_to_compute( timestamp=parse_timestamp_to_utc_datetime( current_time), deadline=current_time, price=0, ))) ]), expected_status=400, expected_error_code='message.value_negative', )