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 test_send_should_return_http_400_if_task_id_already_use(self):
response_202 = self.send_request(
url='core:send',
data=dump(
self.correct_golem_data,
self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY,
),
)
self.assertIsInstance(response_202, HttpResponse)
self.assertEqual(response_202.status_code, 202)
self.correct_golem_data.encrypted = None
self.correct_golem_data.sig = None
response_400 = self.send_request(
url='core:send',
data=dump(
self.correct_golem_data,
self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY,
),
)
self.assertIsInstance(response_400, JsonResponse)
self._test_400_response(
response_400,
error_code=ErrorCode.SUBTASK_DUPLICATE_REQUEST
)
def test_assert_methods(self):
requestor_keys = self._fake_keys()
provider_keys = self._fake_keys()
concent_keys = self._fake_keys()
rct = msg_factories.tasks.ReportComputedTaskFactory()
dump(rct, provider_keys.raw_privkey, requestor_keys.raw_pubkey)
stored_rct = pickle.loads(pickle.dumps(rct))
frct_concent = message.concents.ForceReportComputedTask(
report_computed_task=rct)
frct_concent_data = dump(frct_concent, provider_keys.raw_privkey,
concent_keys.raw_pubkey)
stored_frct = pickle.loads(pickle.dumps(frct_concent))
frct_concent_rcv = load(frct_concent_data, concent_keys.raw_privkey,
provider_keys.raw_pubkey)
concent_rct = frct_concent_rcv.report_computed_task
frct_requestor = message.concents.ForceReportComputedTask(
report_computed_task=concent_rct)
frct_requestor_data = dump(frct_requestor, concent_keys.raw_privkey,
requestor_keys.raw_pubkey)
frct_requestor_rcv = load(frct_requestor_data,
requestor_keys.raw_privkey,
concent_keys.raw_pubkey)
self.assertEqual(frct_requestor_rcv.report_computed_task, stored_rct)
self.assertNotEqual(frct_requestor_rcv, stored_frct)
self.assertSamePayload(frct_requestor_rcv, stored_frct)
def test_send_should_return_http_400_if_task_id_already_use(self):
response_202 = self.client.post(
reverse('core:send'),
data=dump(
self.correct_golem_data,
PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY,
),
content_type='application/octet-stream',
)
self.assertIsInstance(response_202, HttpResponse)
self.assertEqual(response_202.status_code, 202)
self.correct_golem_data.encrypted = None
self.correct_golem_data.sig = None
response_400 = self.client.post(
reverse('core:send'),
data=dump(
self.correct_golem_data,
PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY,
),
content_type='application/octet-stream',
)
self.assertIsInstance(response_400, JsonResponse)
self._test_400_response(response_400,
error_code=ErrorCode.SUBTASK_DUPLICATE_REQUEST)
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)
report_computed_task = factories.tasks.ReportComputedTaskFactory()
# Dump TaskToCompute to make it signed
s_rct = shortcuts.dump(
report_computed_task,
requestor_keys.raw_privkey,
provider_keys.raw_pubkey,
)
# Load TaskToCompute back to its original format
# Task TaskToCompute is verified correctly
report_computed_task = shortcuts.load(
s_rct,
provider_keys.raw_privkey,
requestor_keys.raw_pubkey,
)
first_sig = report_computed_task.sig
first_hash = report_computed_task.get_short_hash()
force_report = message.ForceReportComputedTask()
force_report.report_computed_task = report_computed_task
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.report_computed_task.sig
second_hash = force_report.report_computed_task.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.report_computed_task.sig,
force_report.report_computed_task.get_short_hash(),
)
def test_validation(self):
for key in ('nonce', 'gasprice', 'startgas', 'value', 'r', 's'):
invalid_message_instance = self.FACTORY(**{key: '1' * 79})
serialized_message = dump(invalid_message_instance, None, None)
with self.assertRaises(FieldError):
load(serialized_message, None, None)
invalid_message_instance = self.FACTORY(v='1' * 4)
serialized_message = dump(invalid_message_instance, None, None)
with self.assertRaises(FieldError):
load(serialized_message, None, None)
def test_send_should_return_http_400_if_task_to_compute_deadline_is_not_an_integer(self):
compute_task_def = ComputeTaskDefFactory()
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=self._get_provider_hex_public_key(),
requestor_public_key=self._get_requestor_hex_public_key(),
)
serialized_task_to_compute = dump(
task_to_compute,
self.REQUESTOR_PRIVATE_KEY,
self.PROVIDER_PUBLIC_KEY,
)
deserialized_task_to_compute = load(
serialized_task_to_compute,
self.PROVIDER_PRIVATE_KEY,
self.REQUESTOR_PUBLIC_KEY,
check_time=False,
)
with freeze_time("2017-11-17 10:00:00"):
force_report_computed_task = message.concents.ForceReportComputedTask(
report_computed_task=message.tasks.ReportComputedTask(
task_to_compute=deserialized_task_to_compute
)
)
response_400 = self.send_request(
url='core:send',
data=dump(
force_report_computed_task,
self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY
),
)
self._test_400_response(response_400)
def test_send_should_accept_valid_message_with_non_numeric_task_id(self):
assert StoredMessage.objects.count() == 0
compute_task_def = self._get_deserialized_compute_task_def(
task_id='ABC00XYZ',
subtask_id='ABC00XYZ',
deadline=self.message_timestamp)
task_to_compute = self._get_deserialized_task_to_compute(
compute_task_def=compute_task_def, )
report_computed_task = self._get_deserialized_report_computed_task(
task_to_compute=task_to_compute)
correct_golem_data = self._get_deserialized_force_report_computed_task(
report_computed_task=report_computed_task, )
response = self.client.post(
reverse('core:send'),
data=dump(correct_golem_data, self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY),
content_type='application/octet-stream',
)
self.assertEqual(response.status_code, 202)
self._assert_stored_message_counter_increased(increased_by=2)
self._test_last_stored_messages(
expected_messages=[
message.TaskToCompute,
message.ReportComputedTask,
],
task_id='ABC00XYZ',
subtask_id='ABC00XYZ',
)
def test_send_should_return_http_200_if_message_timeout(self):
assert StoredMessage.objects.count() == 0
task_to_compute = self.task_to_compute
task_to_compute.compute_task_def[
'deadline'] = self.message_timestamp - 1 # pylint: disable=no-member
task_to_compute.sig = None
task_to_compute = self._sign_message(task_to_compute)
report_computed_task = self._get_deserialized_report_computed_task(
task_to_compute=task_to_compute)
correct_golem_data = self._get_deserialized_force_report_computed_task(
report_computed_task=report_computed_task)
response = self.client.post(
reverse('core:send'),
data=dump(correct_golem_data, self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY),
content_type='application/octet-stream',
)
self.assertEqual(response.status_code, 200)
response_message = load(
response.content,
self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY,
)
self.assertIsInstance(response_message,
message.concents.ForceReportComputedTaskResponse)
def test_send_should_return_http_400_if_task_to_compute_younger_than_report_computed(self):
deserialized_task_to_compute = self._get_deserialized_task_to_compute(
task_id = '1',
subtask_id = '3',
deadline = get_current_utc_timestamp() + (60 * 37),
)
with freeze_time("2017-11-17 10:00:00"):
force_report_computed_task = self._get_deserialized_force_report_computed_task(
report_computed_task = self._get_deserialized_report_computed_task(
subtask_id = '3',
task_to_compute = deserialized_task_to_compute
)
)
response = 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._test_400_response(
response,
error_code=ErrorCode.MESSAGE_TIMESTAMP_TOO_OLD
)
def test_upload_should_return_401_if_specific_file_info_data(self):
file = FileTransferToken.FileInfo(
path=get_storage_result_file_path(task_id=self._get_uuid(),
subtask_id=self._get_uuid()),
size=1,
checksum='sha1:356a192b7913b04c54574d18c28d46e6395428ab\n',
)
self.upload_token.files = [file]
golem_upload_token = dump(self.upload_token,
settings.CONCENT_PRIVATE_KEY,
settings.CONCENT_PUBLIC_KEY)
encoded_token = b64encode(golem_upload_token).decode()
response = self.client.post(
'{}{}'.format(
reverse('gatekeeper:upload'),
get_storage_result_file_path(
task_id=self._get_uuid(),
subtask_id=self._get_uuid(),
),
),
HTTP_AUTHORIZATION='Golem ' + encoded_token,
HTTP_CONCENT_AUTH=self.header_concent_auth,
content_type='application/x-www-form-urlencoded',
HTTP_X_Golem_Messages=settings.GOLEM_MESSAGES_VERSION,
)
self.assertIsInstance(response, JsonResponse)
self.assertEqual(response.status_code, 401)
self.assertIn('message', response.json().keys())
self.assertEqual("application/json", response["Content-Type"])
def test_that_send_should_refuse_request_if_all_stored_messages_have_incompatible_protocol_version(self):
with override_settings(GOLEM_MESSAGES_VERSION='1.11.0'):
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.FORCING_REPORT,
next_deadline=int(self.task_to_compute.compute_task_def['deadline']) + settings.CONCENT_MESSAGING_TIME,
task_to_compute=self.task_to_compute,
report_computed_task=self.report_computed_task,
)
with mock.patch('core.views.logging.log_message_received') as log_not_called_mock, \
mock.patch('core.subtask_helpers.log') as log_called_mock:
response = self.send_request(
url='core:send',
data=dump(
self.force_report_computed_task,
self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY),
)
self._test_response(
response,
status=200,
key=self.PROVIDER_PRIVATE_KEY,
message_type=message.concents.ServiceRefused,
fields={
'reason': message.concents.ServiceRefused.REASON.UnsupportedProtocolVersion,
}
)
log_called_mock.assert_called()
log_not_called_mock.assert_not_called()
self.assertIn(f'Version stored in database is 1.11.0, Concent version is {settings.GOLEM_MESSAGES_VERSION}', str(log_called_mock.call_args))
def test_send_should_return_http_202_if_task_to_compute_deadline_is_correct(self):
compute_task_def = ComputeTaskDefFactory()
valid_values = [
11,
True,
0,
False,
]
for deadline in valid_values:
StoredMessage.objects.all().delete()
compute_task_def['deadline'] = deadline
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(
task_to_compute=deserialized_task_to_compute
)
)
response_202 = self.send_request(
url='core:send',
data=dump(
force_report_computed_task,
self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY
),
)
self.assertIn(response_202.status_code, [200, 202])
def test_send_should_accept_valid_message_with_non_numeric_task_id(self):
assert StoredMessage.objects.count() == 0
compute_task_def = self._get_deserialized_compute_task_def(
deadline=self.message_timestamp
)
task_to_compute = self._get_deserialized_task_to_compute(
compute_task_def=compute_task_def,
)
report_computed_task = self._get_deserialized_report_computed_task(
task_to_compute=task_to_compute
)
correct_golem_data = self._get_deserialized_force_report_computed_task(
report_computed_task=report_computed_task,
)
response = self.send_request(
url='core:send',
data=dump(
correct_golem_data,
self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY),
)
self.assertEqual(response.status_code, 202)
self._assert_stored_message_counter_increased(increased_by=3)
self._test_last_stored_messages(
expected_messages=[
message.TaskToCompute,
message.WantToComputeTask,
message.ReportComputedTask,
],
task_id=task_to_compute.task_id,
subtask_id=task_to_compute.subtask_id,
)
def test_send_should_return_http_400_if_task_to_compute_younger_than_report_computed(self):
deserialized_task_to_compute = self._get_deserialized_task_to_compute(
deadline=get_current_utc_timestamp() + (60 * 37),
)
with freeze_time("2017-11-17 10:00:00"):
force_report_computed_task = self._get_deserialized_force_report_computed_task(
report_computed_task=self._get_deserialized_report_computed_task(
subtask_id=deserialized_task_to_compute.subtask_id,
task_to_compute=deserialized_task_to_compute
)
)
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,
error_code=ErrorCode.MESSAGE_TIMESTAMP_TOO_OLD
)
def test_send_should_return_http_200_if_message_timeout(self):
assert StoredMessage.objects.count() == 0
task_to_compute = self._get_deserialized_task_to_compute(
deadline=self.message_timestamp - 1
)
report_computed_task = self._get_deserialized_report_computed_task(
task_to_compute=task_to_compute
)
correct_golem_data = self._get_deserialized_force_report_computed_task(
report_computed_task=report_computed_task
)
response = self.send_request(
url='core:send',
data=dump(
correct_golem_data,
self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY),
)
self.assertEqual(response.status_code, 200)
response_message = load(
response.content,
self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY,
)
self.assertIsInstance(response_message, message.concents.ForceReportComputedTaskResponse)
self.assertEqual(response_message.reason,
message.concents.ForceReportComputedTaskResponse.REASON.SubtaskTimeout)
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_load_without_public_key_should_load_message(self):
"""
Test that message loaded with load_without_public_key function will be the same as load
with golem_messages load function.
"""
# Create and fill some data into ComputeTaskDef
compute_task_def = tasks.ComputeTaskDefFactory(
task_id=generate_uuid_for_tests(),
subtask_id=generate_uuid_for_tests(),
deadline=1510912800,
)
# Create TaskToCompute
task_to_compute = tasks.TaskToComputeFactory(
compute_task_def = compute_task_def,
price=0,
)
# Dump TaskToCompute to make it signed
dumped_task_to_compute = dump(task_to_compute, REQUESTOR_PRIVATE_KEY, CONCENT_PUBLIC_KEY)
loaded_task_to_compute_with_utility_function = load_without_public_key(
dumped_task_to_compute,
REQUESTOR_PUBLIC_KEY,
)
loaded_task_to_compute_with_golem_messages_load = load(
dumped_task_to_compute,
CONCENT_PRIVATE_KEY,
REQUESTOR_PUBLIC_KEY,
)
self.assertEqual(loaded_task_to_compute_with_utility_function, loaded_task_to_compute_with_golem_messages_load)
def request_upload_status(
report_computed_task: message.ReportComputedTask) -> bool:
slash = '/'
assert settings.STORAGE_CLUSTER_ADDRESS.endswith(slash)
file_transfer_token = create_file_transfer_token_for_concent(
subtask_id=report_computed_task.subtask_id,
result_package_path=get_storage_result_file_path(
subtask_id=report_computed_task.subtask_id,
task_id=report_computed_task.task_id,
),
result_size=report_computed_task.size,
result_package_hash=report_computed_task.package_hash,
operation=FileTransferToken.Operation.download)
assert len(file_transfer_token.files) == 1
assert not file_transfer_token.files[0]['path'].startswith(slash)
file_transfer_token.sig = None
dumped_file_transfer_token = shortcuts.dump(file_transfer_token,
settings.CONCENT_PRIVATE_KEY,
settings.CONCENT_PUBLIC_KEY)
headers = {
'Authorization':
'Golem ' + b64encode(dumped_file_transfer_token).decode(),
'Concent-Auth':
b64encode(
shortcuts.dump(
message.concents.ClientAuthorization(
client_public_key=settings.CONCENT_PUBLIC_KEY, ),
settings.CONCENT_PRIVATE_KEY,
settings.CONCENT_PUBLIC_KEY), ).decode(),
}
request_http_address = settings.STORAGE_CLUSTER_ADDRESS + CLUSTER_DOWNLOAD_PATH + file_transfer_token.files[
0]['path']
storage_cluster_response = send_request_to_storage_cluster(
headers, request_http_address)
if storage_cluster_response.status_code == 200:
return True
elif storage_cluster_response.status_code == 404:
return False
else:
raise exceptions.UnexpectedResponse(
f'Cluster storage returned HTTP {storage_cluster_response.status_code}'
)
def test_that_receive_should_refuse_request_if_stored_messages_in_database_have_incompatible_protocol_version(self):
"""
This case may happen, if client sends a request to core:send and in next step sends request to core:receive
using different protocol version. The client is always required to stay on the same protocol version while
communicating about the same subtask.
"""
response = self.send_request(
url='core:send',
data=dump(
self.force_report_computed_task,
self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY),
)
self._test_response(
response,
status=202,
key=self.PROVIDER_PRIVATE_KEY,
)
response1 = self.send_request(
url='core:send',
data=dump(
self.reject_report_computed_task,
self.REQUESTOR_PRIVATE_KEY,
CONCENT_PUBLIC_KEY),
)
self._test_response(
response1,
status=202,
key=self.REQUESTOR_PRIVATE_KEY,
)
with override_settings(GOLEM_MESSAGES_VERSION='1.11.0'):
response2 = self.send_request(
url='core:receive',
data=self._create_client_auth_message(self.PROVIDER_PRIVATE_KEY, self.PROVIDER_PUBLIC_KEY),
golem_messages_version='1.11.0'
)
self._test_response(
response2,
status=200,
key=self.PROVIDER_PRIVATE_KEY,
message_type=message.concents.ServiceRefused,
fields={
'reason': message.concents.ServiceRefused.REASON.UnsupportedProtocolVersion,
}
)
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 _prepare_data(data: Union[Message, bytes]) -> bytes:
if isinstance(data, bytes):
return data
return dump(
data,
private_key,
public_key,
)
def test_send_reject_message_save_as_receive_out_of_band_status(self):
assert StoredMessage.objects.count() == 0
self.correct_golem_data.report_computed_task = self._get_deserialized_report_computed_task(
task_to_compute = self.cannot_compute_task.task_to_compute # pylint: disable=no-member
)
force_response = self.client.post(
reverse('core:send'),
data = dump(
self.correct_golem_data,
PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY),
content_type = 'application/octet-stream',
)
self.assertEqual(force_response.status_code, 202)
self._test_last_stored_messages(
expected_messages = [
message.TaskToCompute,
message.ReportComputedTask,
],
task_id = '8',
subtask_id = '8',
timestamp = "2017-11-17 10:00:00"
)
reject_response = self.client.post(
reverse('core:send'),
data = dump(
self.reject_report_computed_task,
REQUESTOR_PRIVATE_KEY,
CONCENT_PUBLIC_KEY
),
content_type = 'application/octet-stream',
)
self.assertEqual(reject_response.status_code, 202)
self._test_last_stored_messages(
expected_messages = [
message.RejectReportComputedTask,
],
task_id = '8',
subtask_id = '8',
timestamp = "2017-11-17 10:00:00"
)
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 test_ethereum_address(self):
msg = factories.tasks.TaskToComputeFactory()
serialized = shortcuts.dump(msg, None, None)
msg_l = shortcuts.load(serialized, None, None)
for addr_slot in (
'requestor_ethereum_address',
'provider_ethereum_address'):
address = getattr(msg_l, addr_slot)
self.assertEqual(len(address), 2 + (20*2))
def _prepare_data(data):
if data is None:
return ''
if isinstance(data, bytes):
return data
return dump(
data,
private_key,
public_key,
)
def test_send_reject_message_save_as_receive_out_of_band_status(self):
assert StoredMessage.objects.count() == 0
self.correct_golem_data.report_computed_task = self._get_deserialized_report_computed_task(
task_to_compute=self.cannot_compute_task.task_to_compute # pylint: disable=no-member
)
force_response = self.send_request(
url='core:send',
data=dump(
self.correct_golem_data,
self.PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY),
)
self.assertEqual(force_response.status_code, 202)
self._test_last_stored_messages(
expected_messages=[
message.TaskToCompute,
message.WantToComputeTask,
message.ReportComputedTask,
],
task_id=self.correct_golem_data.report_computed_task.task_id,
subtask_id=self.correct_golem_data.report_computed_task.subtask_id,
)
reject_response = self.send_request(
url='core:send',
data=dump(
self.reject_report_computed_task,
self.REQUESTOR_PRIVATE_KEY,
CONCENT_PUBLIC_KEY
),
)
self.assertEqual(reject_response.status_code, 202)
self._test_last_stored_messages(
expected_messages=[
message.tasks.RejectReportComputedTask,
],
task_id=self.reject_report_computed_task.task_id,
subtask_id=self.reject_report_computed_task.subtask_id,
)
def test_upload_should_return_401_if_checksum_is_wrong(self):
invalid_values_with_expected_error_code = {
b'sha1:95a0f391c7ad86686ab1366bcd519ba5ab3cce89':
ErrorCode.MESSAGE_FILES_CHECKSUM_WRONG_TYPE,
'': ErrorCode.MESSAGE_FILES_CHECKSUM_EMPTY,
'95a0f391c7ad86686ab1366bcd519ba5ab3cce89':
ErrorCode.MESSAGE_FILES_CHECKSUM_WRONG_FORMAT,
':95a0f391c7ad86686ab1366bcd519ba5ab3cce89':
ErrorCode.MESSAGE_FILES_CHECKSUM_INVALID_ALGORITHM,
'sha1:95a0f391c7ad86686ab1366bcd519ba5amONj':
ErrorCode.MESSAGE_FILES_CHECKSUM_INVALID_SHA1_HASH,
'sha1:': ErrorCode.MESSAGE_FILES_CHECKSUM_INVALID_SHA1_HASH,
}
for invalid_value, error_code in invalid_values_with_expected_error_code.items(
):
file1 = FileTransferToken.FileInfo(
path=
'blender/benchmark/test_task/scene-Helicopter-27-cycles.blend',
checksum='sha1:95a0f391c7ad86686ab1366bcd519ba5ab3cce89',
size=1024,
)
file2 = FileTransferToken.FileInfo(
path=
'blenderrr/benchmark/test_task/scene-Helicopter-27-cycles.blend',
checksum=invalid_value,
size=1024,
)
self.upload_token.files = [file1, file2]
self.upload_token.sig = None
golem_upload_token = dump(self.upload_token,
settings.CONCENT_PRIVATE_KEY,
settings.CONCENT_PUBLIC_KEY)
encoded_token = b64encode(golem_upload_token).decode()
response = self.client.post(
'{}{}'.format(
reverse('gatekeeper:upload'),
'blender/benchmark/test_task/scene-Helicopter-27-cycles.blend'
),
HTTP_AUTHORIZATION='Golem ' + encoded_token,
HTTP_CONCENT_AUTH=self.header_concent_auth,
content_type='application/x-www-form-urlencoded',
HTTP_X_Golem_Messages=settings.GOLEM_MESSAGES_VERSION,
)
self.assertIsInstance(response, JsonResponse)
self.assertEqual(response.status_code, 401)
self.assertIn('message', response.json().keys())
self.assertIn('error_code', response.json().keys())
self.assertEqual("application/json", response["Content-Type"])
self.assertEqual(response.json()["error_code"], error_code.value)
def prepare_storage_request_headers(file_transfer_token: message.FileTransferToken) -> dict:
""" Prepare headers for request to storage cluster. """
dumped_file_transfer_token = dump(
file_transfer_token,
settings.CONCENT_PRIVATE_KEY,
settings.CONCENT_PUBLIC_KEY,
)
headers = {
'Authorization': 'Golem ' + b64encode(dumped_file_transfer_token).decode(),
'Concent-Auth': b64encode(
dump(
message.concents.ClientAuthorization(
client_public_key=settings.CONCENT_PUBLIC_KEY,
),
settings.CONCENT_PRIVATE_KEY,
settings.CONCENT_PUBLIC_KEY
),
).decode(),
}
return headers
def send(self, cluster_url, message):
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)
