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 setUp(self): super().setUp() deadline_offset = 10 message_timestamp = get_current_utc_timestamp() + deadline_offset compute_task_def = message.ComputeTaskDef() compute_task_def['task_id'] = '8' compute_task_def['subtask_id'] = '8' compute_task_def['deadline'] = message_timestamp task_to_compute = tasks.TaskToComputeFactory( compute_task_def=compute_task_def, requestor_public_key=encode_hex(REQUESTOR_PUBLIC_KEY), provider_public_key=encode_hex(PROVIDER_PUBLIC_KEY), price=0, ) task_to_compute = load( dump( task_to_compute, REQUESTOR_PRIVATE_KEY, settings.CONCENT_PUBLIC_KEY, ), settings.CONCENT_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY, check_time=False, ) report_computed_task = tasks.ReportComputedTaskFactory( task_to_compute=task_to_compute) self.force_report_computed_task = message.ForceReportComputedTask( report_computed_task=report_computed_task)
def test_type(self): ctd = message.ComputeTaskDef() ctd['src_code'] = "custom code" msg = message.TaskToCompute(compute_task_def=ctd) s = msg.serialize() msg2 = message.Message.deserialize(s, None) self.assertEqual(ctd, msg2.compute_task_def) self.assertIsInstance(msg2.compute_task_def, message.ComputeTaskDef)
def test_valid_task_to_compute(self): TEST_SIG = (b'jak przystalo na bistro czesto sie zmienia' b'i jest wypisywane na tablicy w lokalu' )[:message.Message.SIG_LEN] # noqa for class_ in message.registered_message_types.values(): if 'task_to_compute' not in class_.__slots__: continue msg = class_() msg.task_to_compute = \ factories.tasks.TaskToComputeFactory(sig=TEST_SIG) msg.task_to_compute.compute_task_def = message.ComputeTaskDef() s = msg.serialize() msg2 = message.Message.deserialize(s, decrypt_func=None) self.assertEqual(msg2.task_to_compute.sig, TEST_SIG)
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 test_receive_should_return_ack_if_the_receive_queue_contains_only_force_report_and_its_past_deadline( self): with freeze_time("2017-11-17 10:00:00"): self.compute_task_def = message.ComputeTaskDef() self.compute_task_def['task_id'] = '2' self.compute_task_def['subtask_id'] = '2' self.compute_task_def['deadline'] = get_current_utc_timestamp() self.task_to_compute = message.TaskToCompute( compute_task_def=self.compute_task_def, provider_public_key=PROVIDER_PUBLIC_KEY, requestor_public_key=REQUESTOR_PUBLIC_KEY, price=0, ) self.force_golem_data = message.ForceReportComputedTask( report_computed_task=message.tasks.ReportComputedTask( task_to_compute=self.task_to_compute))
def test_send_should_return_http_400_if_task_to_compute_deadline_is_not_an_integer( self): compute_task_def = message.ComputeTaskDef() compute_task_def['task_id'] = '8' compute_task_def['subtask_id'] = '8' invalid_values = [ -11, 'a11b', {}, [], (1, 2, 3), None, ] for deadline in invalid_values: StoredMessage.objects.all().delete() compute_task_def['deadline'] = deadline task_to_compute = tasks.TaskToComputeFactory( compute_task_def=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) with freeze_time("2017-11-17 10:00:00"): force_report_computed_task = message.ForceReportComputedTask( report_computed_task=message.tasks.ReportComputedTask( task_to_compute=deserialized_task_to_compute)) response_400 = self.client.post( reverse('core:send'), data=dump(force_report_computed_task, PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY), content_type='application/octet-stream', ) self._test_400_response(response_400)
def test_reject_report_computed_task_with_cannot_compute_task(self): msg = message.RejectReportComputedTask() msg.reason = message.RejectReportComputedTask.Reason.GOT_MESSAGE_CANNOT_COMPUTE_TASK # noqa msg.cannot_compute_task = message.CannotComputeTask() msg.cannot_compute_task.reason =\ message.CannotComputeTask.REASON.WrongCTD msg.cannot_compute_task.task_to_compute = message.TaskToCompute() invalid_deadline = ("You call it madness, " "but I call it Love -- Nat King Cole") msg.cannot_compute_task.task_to_compute.compute_task_def =\ message.ComputeTaskDef({'deadline': invalid_deadline, }) s = msg.serialize() msg2 = message.Message.deserialize(s, None) self.assertEqual( msg2.cannot_compute_task.task_to_compute. compute_task_def['deadline'], # noqa invalid_deadline)
def test_send_should_return_http_400_if_data_is_incorrect(self): compute_task_def = message.ComputeTaskDef() task_to_compute = message.TaskToCompute( compute_task_def = compute_task_def, provider_public_key = PROVIDER_PUBLIC_KEY, requestor_public_key = REQUESTOR_PUBLIC_KEY, price=0, ) report_computed_task = message.tasks.ReportComputedTask( task_to_compute = task_to_compute ) with freeze_time("2017-11-17 9:56:00"): force_report_computed_task = message.ForceReportComputedTask( report_computed_task = report_computed_task ) response = self.client.post( reverse('core:send'), data = dump( force_report_computed_task, PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY, ), content_type = 'application/octet-stream', ) self._test_400_response( response, error_code=ErrorCode.MESSAGE_VALUE_BLANK ) data = message.ForceReportComputedTask() data.report_computed_task = message.tasks.ReportComputedTask() compute_task_def['deadline'] = self.message_timestamp - 3600 data.report_computed_task.task_to_compute = message.TaskToCompute(compute_task_def = compute_task_def) response = self.client.post( reverse('core:send'), data = dump( data, PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY, ), content_type = 'application/octet-stream', ) self._test_400_response(response)
def setUp(self): with freeze_time("2017-11-17 10:00:00"): super().setUp() self.compute_task_def = message.ComputeTaskDef() self.compute_task_def['task_id'] = '1' self.compute_task_def['subtask_id'] = '1' self.compute_task_def['deadline'] = get_current_utc_timestamp() + ( 60 * 37) self.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, ) self.size = 58 self.force_golem_data = message.ForceReportComputedTask( report_computed_task=message.tasks.ReportComputedTask( task_to_compute=self.task_to_compute, size=self.size))
def setUp(self): super().setUp() deadline_offset = 10 message_timestamp = get_current_utc_timestamp() + deadline_offset compute_task_def = message.ComputeTaskDef() compute_task_def['task_id'] = '8' compute_task_def['subtask_id'] = '8' compute_task_def['deadline'] = message_timestamp compute_task_def['extra_data'] = { 'frames': [1], 'output_format': 'PNG', 'scene_file': 'kitten.blend', } task_to_compute = tasks.TaskToComputeFactory( compute_task_def=compute_task_def, requestor_public_key=encode_hex(REQUESTOR_PUBLIC_KEY), provider_public_key=encode_hex(PROVIDER_PUBLIC_KEY), price=0, ) task_to_compute = load( dump( task_to_compute, REQUESTOR_PRIVATE_KEY, settings.CONCENT_PUBLIC_KEY, ), settings.CONCENT_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY, check_time=False, ) report_computed_task = tasks.ReportComputedTaskFactory( task_to_compute=task_to_compute) report_computed_task = load( dump( report_computed_task, PROVIDER_PRIVATE_KEY, settings.CONCENT_PUBLIC_KEY, ), settings.CONCENT_PRIVATE_KEY, PROVIDER_PUBLIC_KEY, check_time=False, ) self.force_report_computed_task = message.ForceReportComputedTask( report_computed_task=report_computed_task)
def setUp(self): super().setUp() self.stored_message_counter = 0 self.message_timestamp = get_current_utc_timestamp() # 1510912800 self.compute_task_def = self._get_deserialized_compute_task_def( task_id='8', subtask_id='8', deadline=self.message_timestamp ) self.task_to_compute = self._get_deserialized_task_to_compute( 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.correct_golem_data = self._get_deserialized_force_report_computed_task( report_computed_task=self.report_computed_task ) self.want_to_compute = message.WantToComputeTask( node_name = 1, task_id = 2, perf_index = 3, price = 4, max_resource_size = 5, max_memory_size = 6, num_cores = 7, ) compute_task_def = message.ComputeTaskDef() compute_task_def['task_id'] = '8' compute_task_def['subtask_id'] = '8' compute_task_def['deadline'] = self.message_timestamp + 600 task_to_compute = self._get_deserialized_task_to_compute( compute_task_def = compute_task_def ) self.cannot_compute_task = message.CannotComputeTask( task_to_compute = task_to_compute ) self.reject_report_computed_task = self._get_deserialized_reject_report_computed_task( task_to_compute=task_to_compute, reason=message.RejectReportComputedTask.REASON.SubtaskTimeLimitExceeded, )
def test_send_should_return_http_400_if_data_is_incorrect(self): compute_task_def = message.ComputeTaskDef() task_to_compute = message.TaskToCompute( compute_task_def=compute_task_def, requestor_public_key=self._get_encoded_requestor_public_key(), want_to_compute_task=WantToComputeTaskFactory(), ) report_computed_task = message.tasks.ReportComputedTask( task_to_compute=task_to_compute ) with freeze_time("2017-11-17 9:56:00"): force_report_computed_task = message.concents.ForceReportComputedTask( report_computed_task=report_computed_task ) response = self.send_request( url='core:send', data=dump( force_report_computed_task, self.PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY), ) self._test_400_response(response) data = message.concents.ForceReportComputedTask() data.report_computed_task = message.tasks.ReportComputedTask() compute_task_def['deadline'] = self.message_timestamp - 3600 data.report_computed_task.task_to_compute = message.TaskToCompute(compute_task_def=compute_task_def) response = self.send_request( url='core:send', data=dump( data, self.PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY), ) self._test_400_response(response) self.assertIn('Error in Golem Message', response.json()['error'])
def test_send_should_return_http_202_if_task_to_compute_deadline_is_correct( self): compute_task_def = message.ComputeTaskDef() valid_values = [ 11, True, 0, False, ] for i, deadline in enumerate(valid_values): StoredMessage.objects.all().delete() compute_task_def['task_id'] = str(i) compute_task_def['subtask_id'] = str(i) compute_task_def['deadline'] = deadline compute_task_def['extra_data'] = { 'frames': [1], 'output_format': 'PNG', 'scene_file': 'kitten.blend', } deserialized_task_to_compute = self._get_deserialized_task_to_compute( compute_task_def=compute_task_def, ) force_report_computed_task = self._get_deserialized_force_report_computed_task( report_computed_task=self. _get_deserialized_report_computed_task( subtask_id=str(i), task_to_compute=deserialized_task_to_compute)) response_202 = self.client.post( reverse('core:send'), data=dump(force_report_computed_task, self.PROVIDER_PRIVATE_KEY, CONCENT_PUBLIC_KEY), content_type='application/octet-stream', ) self.assertIn(response_202.status_code, [200, 202])
def setUp(self): super().setUp() self.source_package_path = 'blender/source/ef0dc1/ef0dc1.zzz523.zip' self.result_package_path = 'blender/result/ef0dc1/ef0dc1.zzz523.zip' self.scene_file = 'blender/scene/ef0dc1/ef0dc1.zzz523.zip' self.compute_task_def = message.ComputeTaskDef() self.compute_task_def['task_id'] = 'ef0dc1' self.compute_task_def['subtask_id'] = 'zzz523' self.report_computed_task = self._get_deserialized_report_computed_task( task_to_compute=self._get_deserialized_task_to_compute( compute_task_def=self.compute_task_def)) store_subtask( task_id=self.compute_task_def['task_id'], subtask_id=self.compute_task_def['subtask_id'], provider_public_key=self.PROVIDER_PUBLIC_KEY, requestor_public_key=self.REQUESTOR_PUBLIC_KEY, state=Subtask.SubtaskState.REPORTED, task_to_compute=self.report_computed_task.task_to_compute, report_computed_task=self.report_computed_task, next_deadline=None)
def test_message_sig(self): """Signed message inside a signed message""" concent_keys = cryptography.ECCx(None) provider_keys = cryptography.ECCx(None) requestor_keys = cryptography.ECCx(None) task_to_compute = message.TaskToCompute() ctd = message.ComputeTaskDef({ 'task_id': 20, }) task_to_compute.compute_task_def = ctd # Dump TaskToCompute to make it signed s_task_to_compute = shortcuts.dump( task_to_compute, requestor_keys.raw_privkey, provider_keys.raw_pubkey, ) # Load TaskToCompute back to its original format task_to_compute = shortcuts.load( s_task_to_compute, provider_keys.raw_privkey, requestor_keys.raw_pubkey, ) first_sig = task_to_compute.sig first_hash = task_to_compute.get_short_hash() # Task TaskToCompute is verified correctly cryptography.ecdsa_verify( requestor_keys.raw_pubkey, task_to_compute.sig, task_to_compute.get_short_hash(), ) force_report = message.ForceReportComputedTask() force_report.task_to_compute = task_to_compute s_force_report = shortcuts.dump( force_report, provider_keys.raw_privkey, concent_keys.raw_pubkey, ) force_report = shortcuts.load( s_force_report, concent_keys.raw_privkey, provider_keys.raw_pubkey, ) second_sig = force_report.task_to_compute.sig second_hash = force_report.task_to_compute.get_short_hash() self.assertEqual(first_sig, second_sig) self.assertEqual(first_hash, second_hash) # Now, attached TaskToCompute should still be verified using # original key. ecdsa_verify will raise InvalidSignature on # failure. cryptography.ecdsa_verify( requestor_keys.raw_pubkey, force_report.task_to_compute.sig, force_report.task_to_compute.get_short_hash(), )
def setUp(self): super().setUp() self.compute_task_def = message.ComputeTaskDef() self.compute_task_def['task_id'] = '1' self.compute_task_def['subtask_id'] = '1' self.compute_task_def['deadline'] = get_current_utc_timestamp() - 60 self.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, ) self.size = 58 with freeze_time("2017-11-17 10:00:00"): self.force_golem_data = message.ForceReportComputedTask( report_computed_task=message.tasks.ReportComputedTask( task_to_compute=self.task_to_compute, size=self.size)) 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.tasks.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.ReceiveOutOfBand.name, # pylint: disable=no-member subtask=subtask, ) new_message_inbox.full_clean() new_message_inbox.save()