def ack_report_computed_task(task_to_compute): ack_report_computed_task = AckReportComputedTask() ack_report_computed_task.report_computed_task = ReportComputedTaskFactory() ack_report_computed_task.report_computed_task.task_to_compute = task_to_compute sign_message(ack_report_computed_task.report_computed_task, PROVIDER_PRIVATE_KEY) return ack_report_computed_task
def create_subtask_results_accepted_list( # pylint: disable=no-self-use self, task_to_compute_1, task_to_compute_2, subtask_1_signed_by=REQUESTOR_PRIVATE_KEY, subtask_2_signed_by=REQUESTOR_PRIVATE_KEY, ) -> list: subtask_results_accepted_1 = SubtaskResultsAcceptedFactory( payment_ts="2018-02-05 12:00:16", report_computed_task=ReportComputedTaskFactory( task_to_compute=task_to_compute_1 ) ) sign_message(subtask_results_accepted_1, subtask_1_signed_by) subtask_results_accepted_2 = SubtaskResultsAcceptedFactory( payment_ts="2018-02-05 12:00:16", report_computed_task=ReportComputedTaskFactory( task_to_compute=task_to_compute_2 ) ) sign_message(subtask_results_accepted_2, subtask_2_signed_by) subtask_results_accepted_list = [ subtask_results_accepted_1, subtask_results_accepted_2, ] return subtask_results_accepted_list
def force_report_computed_task(task_to_compute): report_computed_task = ReportComputedTaskFactory() report_computed_task.task_to_compute = task_to_compute sign_message(report_computed_task, PROVIDER_PRIVATE_KEY) force_report_computed_task = ForceReportComputedTask() force_report_computed_task.report_computed_task = report_computed_task return force_report_computed_task
def create_signed_task_to_compute( deadline: int, timestamp: Optional[Union[datetime.datetime, str]] = None, provider_public_key: Optional[bytes] = None, requestor_public_key: Optional[bytes] = None, requestor_ethereum_public_key: Optional[bytes] = None, requestor_ethereum_private_key: Optional[bytes] = None, provider_ethereum_public_key: Optional[bytes] = None, want_to_compute_task: Optional[WantToComputeTask] = None, price: int = 1, size: int = 1, package_hash: str = 'sha1:57786d92d1a6f7eaaba1c984db5e108c68b03f0d', script_src: Optional[str] = None, ) -> TaskToCompute: with freeze_time(timestamp): compute_task_def = ComputeTaskDefFactory( deadline=deadline, extra_data={ 'output_format': 'png', 'scene_file': '/golem/resources/golem-header-light.blend', 'frames': [1], 'script_src': script_src, }) if script_src is not None: compute_task_def['extra_data']['script_src'] = script_src want_to_compute_task = want_to_compute_task if want_to_compute_task is not None else WantToComputeTaskFactory( provider_public_key=encode_hex(provider_public_key) if provider_public_key is not None else _get_provider_hex_public_key(), provider_ethereum_public_key=encode_hex( provider_ethereum_public_key) if provider_ethereum_public_key is not None else encode_hex(PROVIDER_ETHEREUM_PUBLIC_KEY), ) want_to_compute_task = sign_message(want_to_compute_task, PROVIDER_PRIVATE_KEY) task_to_compute = TaskToComputeFactory( requestor_public_key=encode_hex(requestor_public_key) if requestor_public_key is not None else _get_requestor_hex_public_key(), compute_task_def=compute_task_def, want_to_compute_task=want_to_compute_task, requestor_ethereum_public_key=encode_hex( requestor_ethereum_public_key) if requestor_ethereum_public_key is not None else encode_hex(REQUESTOR_ETHEREUM_PUBLIC_KEY), price=price, size=size, package_hash=package_hash, ) task_to_compute.generate_ethsig( requestor_ethereum_private_key if requestor_ethereum_private_key is not None else REQUESTOR_ETHEREUM_PRIVATE_KEY) signed_task_to_compute: TaskToCompute = sign_message( task_to_compute, REQUESTOR_PRIVATE_KEY) return signed_task_to_compute
def send(self, cluster_url: str, message: Message) -> None: for party, message_types in KEY_MAP.items(): if isinstance(message, message_types): priv_key, _ = self.select_keys(party) break else: raise Exception(f'Unsupported Message Type: {type(message)}') print_message(message, cluster_url, 'send') sign_message(get_field_from_message(message, 'task_to_compute'), self.requestor_private_key) serialized_message = dump(message, priv_key, self.concent_pub_key) self._exchange_message(priv_key, cluster_url, serialized_message)
def create_report_computed_task() -> ReportComputedTask: current_time = get_current_utc_timestamp() task_to_compute = create_signed_task_to_compute( timestamp=timestamp_to_isoformat(current_time), deadline=(current_time + 100), price=10000, ) report_computed_task = ReportComputedTaskFactory( task_to_compute=task_to_compute, ) sign_message(report_computed_task, PROVIDER_PRIVATE_KEY) return report_computed_task
def ack_report_computed_task(timestamp=None, report_computed_task=None): with freeze_time(timestamp): return sign_message( message.AckReportComputedTask( report_computed_task=report_computed_task, ), REQUESTOR_PRIVATE_KEY, )
def test_add_signature_with_correct_keys_pair(self): ping_message = message.Ping() self.assertEqual(ping_message.sig, None) ping_message = sign_message(ping_message, CONCENT_PRIVATE_KEY) self.assertIsNot(ping_message.sig, None) self.assertIsInstance(ping_message.sig, bytes)
def create_signed_task_to_compute( task_id, subtask_id, deadline, timestamp=None, provider_public_key=None, requestor_public_key=None, requestor_ethereum_public_key=None, provider_ethereum_public_key=None, price=0, size=1, package_hash='sha1:57786d92d1a6f7eaaba1c984db5e108c68b03f0d', script_src=None, ): with freeze_time(timestamp): compute_task_def = ComputeTaskDefFactory( task_id=task_id, subtask_id=subtask_id, deadline=deadline, extra_data={ 'output_format': 'png', 'scene_file': 'golem-header-light.blend', 'frames': [1], 'script_src': script_src, }) if script_src is not None: compute_task_def['extra_data']['script_src'] = script_src task_to_compute = TaskToComputeFactory( provider_public_key=provider_public_key if provider_public_key is not None else _get_provider_hex_public_key(), requestor_public_key=requestor_public_key if requestor_public_key is not None else _get_requestor_hex_public_key(), compute_task_def=compute_task_def, requestor_ethereum_public_key=requestor_ethereum_public_key if requestor_ethereum_public_key is not None else REQUESTOR_ETHEREUM_PUBLIC_KEY, provider_ethereum_public_key=provider_ethereum_public_key if provider_ethereum_public_key is not None else PROVIDER_ETHEREUM_PUBLIC_KEY, price=price, size=size, package_hash=package_hash, ) sign_message(task_to_compute, REQUESTOR_PRIVATE_KEY) return task_to_compute
def subtask_results_accepted(timestamp=None, payment_ts=None, task_to_compute=None): with freeze_time(timestamp): return sign_message( message.tasks.SubtaskResultsAccepted( payment_ts=payment_ts, task_to_compute=task_to_compute), REQUESTOR_PRIVATE_KEY, )
def report_computed_task(timestamp=None, task_to_compute=None): with freeze_time(timestamp): return sign_message( message.tasks.ReportComputedTask( task_to_compute=task_to_compute, size=REPORT_COMPUTED_TASK_SIZE, ), PROVIDER_PRIVATE_KEY, )
def _create_file_transfer_token( subtask_id: str, result_package_path: str, result_size: int, result_package_hash: str, authorized_client_public_key: bytes, operation: FileTransferToken.Operation, source_package_path: Optional[str] = None, source_size: Optional[int] = None, source_package_hash: Optional[str] = None, token_expiration_deadline: Optional[int] = None, ) -> FileTransferToken: assert (source_size and source_package_hash and source_package_path) or (result_size and result_package_hash and result_package_path) assert isinstance(authorized_client_public_key, bytes) assert isinstance(token_expiration_deadline, int) and not isinstance( token_expiration_deadline, bool) or token_expiration_deadline is None assert operation in [ FileTransferToken.Operation.download, FileTransferToken.Operation.upload ] file_transfer_token = FileTransferToken( token_expiration_deadline=token_expiration_deadline, storage_cluster_address=settings.STORAGE_CLUSTER_ADDRESS, authorized_client_public_key=authorized_client_public_key, operation=operation, subtask_id=subtask_id) files = [] if result_package_path and result_package_hash and result_size: files.append( create_file_info( file_path=result_package_path, package_hash=result_package_hash, size=result_size, category=FileTransferToken.FileInfo.Category.results, )) if source_package_path and source_package_hash and source_size: files.append( create_file_info( file_path=source_package_path, package_hash=source_package_hash, size=source_size, category=FileTransferToken.FileInfo.Category.resources, )) file_transfer_token.files = files file_transfer_token = sign_message(file_transfer_token, settings.CONCENT_PRIVATE_KEY) validate_file_transfer_token(file_transfer_token) return file_transfer_token
def setUp(self, event_loop): self.mocked_writer = prepare_mocked_writer() self.message_tracker = OrderedDict({}) self.golem_message = Ping() sign_message(self.golem_message, CONCENT_PRIVATE_KEY) self.connection_id = 4 self.request_id = 888 self.queue = Queue(loop=event_loop) self.queue_pool = QueuePool( {self.connection_id: Queue(loop=event_loop)}, loop=event_loop, ) self.signing_service_request_id = 1 self.request_queue_item = RequestQueueItem( self.connection_id, self.request_id, self.golem_message, FROZEN_TIMESTAMP )
def subtask_results_rejected(timestamp=None, reason=None, report_computed_task=None): with freeze_time(timestamp): return sign_message( message.tasks.SubtaskResultsRejected( reason=reason, report_computed_task=report_computed_task, ), REQUESTOR_PRIVATE_KEY, )
def create_ack_report_computed_task( timestamp: Optional[str] = None, report_computed_task: Optional[message.tasks.ReportComputedTask] = None, ) -> message.tasks.AckReportComputedTask: with freeze_time(timestamp): signed_message: message.tasks.AckReportComputedTask = sign_message( message.tasks.AckReportComputedTask( report_computed_task=report_computed_task, ), REQUESTOR_PRIVATE_KEY, ) return signed_message
def create_signed_report_computed_task( task_to_compute: message.tasks.TaskToCompute, timestamp: Optional[str] = None) -> message.tasks.ReportComputedTask: with freeze_time(timestamp): signed_message: message.tasks.ReportComputedTask = sign_message( message.tasks.ReportComputedTask( task_to_compute=task_to_compute, size=REPORT_COMPUTED_TASK_SIZE, ), PROVIDER_PRIVATE_KEY, ) return signed_message
def subtask_results_accepted( timestamp: Optional[Union[datetime.datetime, str]] = None, payment_ts: Optional[int] = None, task_to_compute: Optional[message.TaskToCompute] = None ) -> message.tasks.SubtaskResultsAccepted: with freeze_time(timestamp): signed_message: message.tasks.SubtaskResultsAccepted = sign_message( message.tasks.SubtaskResultsAccepted( payment_ts=payment_ts, task_to_compute=task_to_compute), REQUESTOR_PRIVATE_KEY, ) return signed_message
def create_subtask_results_accepted_list( # pylint: disable=no-self-use self, task_to_compute_1, task_to_compute_2, subtask_1_signed_by=REQUESTOR_PRIVATE_KEY, subtask_2_signed_by=REQUESTOR_PRIVATE_KEY, ) -> list: with freeze_time(): subtask_results_accepted_1 = SubtaskResultsAcceptedFactory( report_computed_task=ReportComputedTaskFactory( task_to_compute=task_to_compute_1)) sign_message(subtask_results_accepted_1, subtask_1_signed_by) subtask_results_accepted_2 = SubtaskResultsAcceptedFactory( report_computed_task=ReportComputedTaskFactory( task_to_compute=task_to_compute_2)) sign_message(subtask_results_accepted_2, subtask_2_signed_by) subtask_results_accepted_list = [ subtask_results_accepted_1, subtask_results_accepted_2, ] return subtask_results_accepted_list
def create_ack_report_computed_task( requestor_private_key: bytes, timestamp: Optional[str] = None, report_computed_task: Optional[message.tasks.ReportComputedTask] = None, ) -> message.tasks.AckReportComputedTask: with freeze_time(timestamp): signed_message: message.tasks.AckReportComputedTask = sign_message( message.tasks.AckReportComputedTask( report_computed_task=report_computed_task, ), requestor_private_key, ) return signed_message
def create_signed_report_computed_task( provider_private_key: bytes, task_to_compute: message.tasks.TaskToCompute, timestamp: Optional[str] = None) -> message.tasks.ReportComputedTask: with freeze_time(timestamp): signed_message: message.tasks.ReportComputedTask = sign_message( message.tasks.ReportComputedTask( task_to_compute=task_to_compute, size=REPORT_COMPUTED_TASK_SIZE, ), provider_private_key, ) return signed_message
def setUp(self): super().setUp() deadline_offset = 10 message_timestamp = get_current_utc_timestamp() + deadline_offset self.compute_task_def = ComputeTaskDefFactory() self.compute_task_def['deadline'] = message_timestamp want_to_compute_task = WantToComputeTaskFactory( provider_public_key=encode_hex(PROVIDER_PUBLIC_KEY), ) want_to_compute_task = sign_message(want_to_compute_task, PROVIDER_PRIVATE_KEY) task_to_compute = tasks.TaskToComputeFactory( compute_task_def=self.compute_task_def, requestor_public_key=encode_hex(REQUESTOR_PUBLIC_KEY), requestor_ethereum_public_key=encode_hex( REQUESTOR_ETHERUM_PUBLIC_KEY), want_to_compute_task=want_to_compute_task, price=1, ) task_to_compute.generate_ethsig(REQUESTOR_ETHEREUM_PRIVATE_KEY) task_to_compute.sign_all_promissory_notes( deposit_contract_address=settings.GNT_DEPOSIT_CONTRACT_ADDRESS, private_key=REQUESTOR_ETHEREUM_PRIVATE_KEY, ) self.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=self.task_to_compute) self.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.concents.ForceReportComputedTask( report_computed_task=self.report_computed_task) self.force_get_task_result = message.concents.ForceGetTaskResult( report_computed_task=self.report_computed_task)
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 = ReportComputedTaskFactory( task_to_compute=task_to_compute, size=size, package_hash=package_hash, subtask_id=subtask_id, ) sign_message(report_computed_task, PROVIDER_PRIVATE_KEY) 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 create_signed_subtask_results_accepted( payment_ts: int, report_computed_task: message.tasks.ReportComputedTask, timestamp: Optional[str] = None, ) -> message.tasks.SubtaskResultsAccepted: with freeze_time(timestamp): signed_message: message.tasks.SubtaskResultsAccepted = sign_message( message.tasks.SubtaskResultsAccepted( payment_ts=payment_ts, report_computed_task=report_computed_task, ), REQUESTOR_PRIVATE_KEY, ) return signed_message
def create_subtask_results_rejected( timestamp: Optional[str] = None, reason: Optional[message.tasks.SubtaskResultsRejected.REASON] = None, report_computed_task: Optional[message.tasks.ReportComputedTask] = None, ) -> message.tasks.SubtaskResultsRejected: with freeze_time(timestamp): signed_message: message.tasks.SubtaskResultsRejected = sign_message( message.tasks.SubtaskResultsRejected( reason=reason, report_computed_task=report_computed_task, ), REQUESTOR_PRIVATE_KEY, ) return signed_message
def create_subtask_results_rejected( requestor_private_key: bytes, timestamp: Optional[str] = None, reason: Optional[message.tasks.SubtaskResultsRejected.REASON] = None, report_computed_task: Optional[message.tasks.ReportComputedTask] = None, ) -> message.tasks.SubtaskResultsRejected: with freeze_time(timestamp): signed_message: message.tasks.SubtaskResultsRejected = sign_message( message.tasks.SubtaskResultsRejected( reason=reason, report_computed_task=report_computed_task, ), requestor_private_key, ) return signed_message
def get_force_get_task_result( current_time: int, size: int, package_hash: str, ) -> message.concents.ForceGetTaskResult: task_to_compute = create_signed_task_to_compute( deadline=current_time, price=1, ) with freeze_time(timestamp_to_isoformat(current_time - 1)): report_computed_task = ReportComputedTaskFactory( task_to_compute=task_to_compute, size=size, package_hash=package_hash, ) sign_message(report_computed_task, PROVIDER_PRIVATE_KEY) 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 create_signed_subtask_results_accepted( requestor_private_key: bytes, payment_ts: int, report_computed_task: message.tasks.ReportComputedTask, timestamp: Optional[str] = None, ) -> message.tasks.SubtaskResultsAccepted: with freeze_time(timestamp): signed_message: message.tasks.SubtaskResultsAccepted = sign_message( message.tasks.SubtaskResultsAccepted( payment_ts=payment_ts, report_computed_task=report_computed_task, ), requestor_private_key, ) return signed_message
def setUp(self): super().setUp() deadline_offset = 10 message_timestamp = get_current_utc_timestamp() + deadline_offset self.compute_task_def = ComputeTaskDefFactory() self.compute_task_def['deadline'] = message_timestamp want_to_compute_task = WantToComputeTaskFactory( provider_public_key=encode_hex(PROVIDER_PUBLIC_KEY), ) want_to_compute_task = sign_message(want_to_compute_task, PROVIDER_PRIVATE_KEY) task_to_compute = tasks.TaskToComputeFactory( compute_task_def=self.compute_task_def, requestor_public_key=encode_hex(REQUESTOR_PUBLIC_KEY), want_to_compute_task=want_to_compute_task, price=1, ) self.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=self.task_to_compute) self.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.concents.ForceReportComputedTask( report_computed_task=self.report_computed_task) self.force_get_task_result = message.concents.ForceGetTaskResult( report_computed_task=self.report_computed_task)
def _sign_message(self, golem_message, client_private_key=None): return sign_message( golem_message, self.REQUESTOR_PRIVATE_KEY if client_private_key is None else client_private_key, )
def create_signed_task_to_compute( deadline: int, timestamp: Optional[Union[datetime.datetime, str]] = None, 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, size: int = 1, package_hash: str = 'sha1:57786d92d1a6f7eaaba1c984db5e108c68b03f0d', render_parameters: Optional[Dict[str, Any]] = None, ) -> TaskToCompute: # Temporary workaround for requestor's and provider's keys until all Concent use cases will have payments # When we will have payments then all keys will be taken from SCIBaseTest class if provider_public_key is None and provider_private_key is None: provider_public_key = PROVIDER_PUBLIC_KEY provider_private_key = PROVIDER_PRIVATE_KEY if requestor_public_key is None and requestor_private_key is None: requestor_public_key = REQUESTOR_PUBLIC_KEY requestor_private_key = REQUESTOR_PRIVATE_KEY with freeze_time(timestamp): compute_task_def = ComputeTaskDefFactory( deadline=deadline, extra_data={ 'output_format': 'png', 'scene_file': '/golem/resources/golem-header-light.blend', 'frames': [1], 'resolution': render_parameters.get('resolution') if render_parameters is not None else [400, 400], 'use_compositing': render_parameters.get('use_compositing') if render_parameters is not None else False, 'samples': render_parameters.get('samples') if render_parameters is not None else 0, 'crops': [{ 'borders_x': render_parameters['borders_x'] if render_parameters is not None else [0.0, 1.0], 'borders_y': render_parameters['borders_y'] if render_parameters is not None else [0.0, 1.0], }] }) task_header: TaskHeader = TaskHeaderFactory( task_id=compute_task_def['task_id'], sign__privkey=requestor_private_key, ) want_to_compute_task = WantToComputeTaskFactory( provider_public_key=encode_hex(provider_public_key), task_header=task_header, sign__privkey=provider_private_key) task_to_compute = TaskToComputeFactory( requestor_public_key=encode_hex(requestor_public_key), compute_task_def=compute_task_def, want_to_compute_task=want_to_compute_task, requestor_ethereum_public_key=encode_hex(requestor_public_key), price=price, size=size, package_hash=package_hash, ) task_to_compute.generate_ethsig(requestor_private_key) task_to_compute.sign_all_promissory_notes( deposit_contract_address=settings.GNT_DEPOSIT_CONTRACT_ADDRESS, private_key=requestor_private_key, ) signed_task_to_compute: TaskToCompute = sign_message( task_to_compute, requestor_private_key) # type: ignore return signed_task_to_compute