def test_deserialization_with_time_verification(self, vft_mock):
msg = message.Ping()
payload = golem_messages.dump(msg, self.ecc.raw_privkey,
self.ecc.raw_pubkey)
self.assertEqual(vft_mock.call_count, 0)
golem_messages.load(payload, self.ecc.raw_privkey, self.ecc.raw_pubkey)
self.assertEqual(vft_mock.call_count, 1)
def test_slots_reselialization_optimization(self, dumps_mock):
"""Don't reserialize message slots immediately after deserialization"""
msg = message.p2p.Tasks() # Choose msg type with SIGN = True
payload = golem_messages.dump(msg, self.ecc.raw_privkey,
self.ecc.raw_pubkey)
# One call for slots and second for hash_header
self.assertEqual(dumps_mock.call_count, 2)
dumps_mock.reset_mock()
golem_messages.load(payload, self.ecc.raw_privkey, self.ecc.raw_pubkey)
# One call for hash_header
dumps_mock.assert_called_once_with(mock.ANY)
def test_hello_version_verify(self, v_mock):
msg = message.Hello()
serialized = golem_messages.dump(
msg,
self.ecc.raw_privkey,
self.ecc.raw_pubkey,
)
golem_messages.load(
serialized,
self.ecc.raw_privkey,
self.ecc.raw_pubkey,
)
v_mock.assert_called_once_with(golem_messages.__version__)
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 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_response(self,
response,
status,
key,
message_type=None,
fields=None,
nested_message_verifiable_by=None):
self.assertEqual(response.status_code, status)
if message_type:
message_from_concent = load(response.content,
key,
settings.CONCENT_PUBLIC_KEY,
check_time=False)
self.assertIsInstance(message_from_concent, message_type)
if fields:
for field_name, field_value in fields.items():
self.assertEqual(
functools.reduce(getattr, field_name.split('.'),
message_from_concent), field_value)
else:
self.assertEqual(len(response.content), 0)
if nested_message_verifiable_by is not None:
assert isinstance(nested_message_verifiable_by, dict)
for nested_message, public_key in nested_message_verifiable_by.items(
):
nested_message = functools.reduce(getattr,
nested_message.split('.'),
message_from_concent)
self.assertTrue(
Message.verify_signature(nested_message, public_key))
def test_dump_load(self):
msg = message.Ping()
payload = golem_messages.dump(msg, self.ecc.raw_privkey,
self.ecc.raw_pubkey)
msg2 = golem_messages.load(payload, self.ecc.raw_privkey,
self.ecc.raw_pubkey)
self.assertEqual(msg, msg2)
def _load_message(self, data):
msg = golem_messages.load(data, None, None)
logger.debug(
'BasicProtocol._load_message(): received %r',
msg,
)
return msg
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()
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 _prepare_subtask_results_verify(self,
serialized_subtask_results_verify):
subtask_results_verify = load(
serialized_subtask_results_verify,
CONCENT_PRIVATE_KEY,
self.PROVIDER_PUBLIC_KEY,
check_time=False,
)
subtask_results_verify.encrypted = False
return subtask_results_verify
def _load_message(self, data):
msg = golem_messages.load(
data,
self.session.my_private_key,
self.session.theirs_public_key,
)
logger.debug(
'SafeProtocol._load_message(): received %r',
msg,
)
return msg
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_hello_version_signature(self):
msg = message.Hello()
serialized = golem_messages.dump(
msg,
self.ecc.raw_privkey,
self.ecc.raw_pubkey,
)
msg = golem_messages.load(
serialized,
self.ecc.raw_privkey,
self.ecc.raw_pubkey,
)
msg._version = 'haxior'
with self.assertRaises(exceptions.InvalidSignature):
self.ecc.verify(msg.sig, msg.get_short_hash())
def setUp(self):
self.request_factory = RequestFactory()
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,
)
self.message_to_view = {
"node_name": self.want_to_compute.node_name, # pylint: disable=no-member
"task_id": self.want_to_compute.task_id, # pylint: disable=no-member
"perf_index": self.want_to_compute.perf_index, # pylint: disable=no-member
"price": self.want_to_compute.price, # pylint: disable=no-member
"max_resource_size": self.want_to_compute.max_resource_size, # pylint: disable=no-member
"max_memory_size": self.want_to_compute.max_memory_size, # pylint: disable=no-member
"num_cores": self.want_to_compute.num_cores, # pylint: disable=no-member
}
deadline_offset = 10
message_timestamp = get_current_utc_timestamp() + deadline_offset
compute_task_def = tasks.ComputeTaskDefFactory(
task_id='8',
subtask_id='8',
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,
)
self.force_report_computed_task = message.ForceReportComputedTask()
self.force_report_computed_task.report_computed_task = message.tasks.ReportComputedTask(
)
self.force_report_computed_task.report_computed_task.task_to_compute = task_to_compute
def test_handle_errors_and_responses_should_return_http_response_with_serialized_message(
self):
dumped_message = dump(self._create_test_ping_message(),
CONCENT_PRIVATE_KEY, self.PROVIDER_PUBLIC_KEY)
request = self.request_factory.post(
"/dummy-url/",
content_type='application/octet-stream',
data=dumped_message,
HTTP_X_Golem_Messages=settings.GOLEM_MESSAGES_VERSION,
)
response = dummy_view_handle_errors_and_responses(
request, dumped_message, self.PROVIDER_PUBLIC_KEY)
loaded_response = load(response.content, self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY)
self.assertEqual(response.status_code, 200)
self.assertIsInstance(loaded_response, message.Ping)
def test_handle_errors_and_responses_should_return_serialized_message_if_gets_deserialized(
self):
with freeze_time("2017-12-31 00:00:00"):
client_auth = message.concents.ClientAuthorization()
client_auth.client_public_key = self.PROVIDER_PUBLIC_KEY
request = self.request_factory.post(
"/dummy-url/", content_type='application/octet-stream')
with freeze_time("2017-12-31 00:00:10"):
response = dummy_view_handle_errors_and_responses(
request, client_auth, self.PROVIDER_PUBLIC_KEY)
loaded_response = load(response.content, self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY) # pylint: disable=no-member
self.assertEqual(response.status_code, 200) # pylint: disable=no-member
self.assertIsInstance(loaded_response,
message.concents.ClientAuthorization)
self.assertEqual(loaded_response.timestamp,
parse_iso_date_to_timestamp("2017-12-31 00:00:00"))
def react_to_concent_message(self,
data: typing.Optional[bytes],
response_to: message.Message = None):
if data is None:
logger.debug('Received nothing from Concent')
return
try:
msg = golem_messages.load(
data,
self.keys_auth.ecc.raw_privkey,
self.variant['pubkey'],
)
logger.debug('Concent Message received: %s', msg)
except golem_messages.exceptions.MessageError as e:
logger.warning("Can't deserialize concent message %s:%r", e, data)
logger.debug('Problem parsing msg', exc_info=True)
return
if not response_to:
self.received_messages.put(msg)
else:
self.process_synchronous_response(msg, response_to)
def _load_response(self, response, priv_key):
if response is None:
return None
return golem_messages.load(response, priv_key, self.variant['pubkey'])
def test_serialization(self):
msg = self.get_instance()
s_msg = golem_messages.dump(msg, None, None)
msg2 = golem_messages.load(s_msg, None, None)
self.assertEqual(msg, msg2)
