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
