def _prelaunch(self, operation, view_model, available_disk_space=0):
"""
Overwrite method in order to return the correct number of stored datatypes.
"""
self.nr_of_datatypes = 0
msg, _ = ABCUploader._prelaunch(self, operation, view_model, available_disk_space)
return msg, self.nr_of_datatypes
def _prelaunch(self,
operation,
uid=None,
available_disk_space=0,
**kwargs):
"""
Overwrite method in order to return the correct number of stored datatypes.
"""
self.nr_of_datatypes = 0
msg, _ = ABCUploader._prelaunch(self, operation, uid=None, **kwargs)
return msg, self.nr_of_datatypes
def __import_pearson_coefficients_datatype(self, fc_folder, patient,
user_tag, ts_gid):
path = os.path.join(fc_folder, self.FC_MAT_FILE)
result = ABCUploader.read_matlab_data(path, self.FC_DATASET_NAME)
result = result.reshape((result.shape[0], result.shape[1], 1, 1))
project = dao.get_project_by_id(self.current_project_id)
user = dao.get_user_by_id(project.fk_admin)
pearson_gid = uuid.uuid4()
h5_path = "CorrelationCoefficients_{}.h5".format(pearson_gid.hex)
operation_folder = self.storage_interface.get_project_folder(
project.name, str(self.operation_id))
h5_path = os.path.join(operation_folder, h5_path)
generic_attributes = GenericAttributes()
generic_attributes.user_tag_1 = user_tag
generic_attributes.state = DEFAULTDATASTATE_RAW_DATA
with CorrelationCoefficientsH5(h5_path) as pearson_correlation_h5:
pearson_correlation_h5.array_data.store(result)
pearson_correlation_h5.gid.store(pearson_gid)
pearson_correlation_h5.source.store(ts_gid)
pearson_correlation_h5.labels_ordering.store(
CorrelationCoefficients.labels_ordering.default)
pearson_correlation_h5.subject.store(patient)
pearson_correlation_h5.store_generic_attributes(generic_attributes)
pearson_correlation_index = CorrelationCoefficientsIndex()
pearson_correlation_index.gid = pearson_gid.hex
pearson_correlation_index.fk_from_operation = self.operation_id
pearson_correlation_index.subject = patient
pearson_correlation_index.state = DEFAULTDATASTATE_RAW_DATA
pearson_correlation_index.ndim = 4
pearson_correlation_index.fk_source_gid = ts_gid.hex # we need a random gid here to store the index
pearson_correlation_index.has_valid_time_series = False
dao.store_entity(pearson_correlation_index)
def __init__(self):
ABCUploader.__init__(self)
self.logger = get_logger(self.__class__.__module__)
def test_encrypt_decrypt(self, dir_name, file_name):
# Generate a private key and public key
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048,
backend=default_backend()
)
public_key = private_key.public_key()
# Convert private key to bytes and save it so ABCUploader can use it
pem = private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.NoEncryption()
)
private_key_path = os.path.join(TvbProfile.current.TVB_TEMP_FOLDER, 'private_key.pem')
with open(private_key_path, 'wb') as f:
f.write(pem)
path_to_file = os.path.join(os.path.dirname(tvb_data.__file__), dir_name, file_name)
# Create model for ABCUploader
connectivity_model = ZIPConnectivityImporterModel()
# Generate password
pass_size = TvbProfile.current.hpc.CRYPT_PASS_SIZE
password = StorageInterface.generate_random_password(pass_size)
# Encrypt files using an AES symmetric key
encrypted_file_path = ABCUploader.get_path_to_encrypt(path_to_file)
buffer_size = TvbProfile.current.hpc.CRYPT_BUFFER_SIZE
pyAesCrypt.encryptFile(path_to_file, encrypted_file_path, password, buffer_size)
# Asynchronously encrypt the password used at the previous step for the symmetric encryption
password = str.encode(password)
encrypted_password = ABCUploader.encrypt_password(public_key, password)
# Save encrypted password
ABCUploader.save_encrypted_password(encrypted_password, TvbProfile.current.TVB_TEMP_FOLDER)
path_to_encrypted_password = os.path.join(TvbProfile.current.TVB_TEMP_FOLDER, ENCRYPTED_PASSWORD_NAME)
# Prepare model for decrypting
connectivity_model.uploaded = encrypted_file_path
connectivity_model.encrypted_aes_key = path_to_encrypted_password
TvbProfile.current.UPLOAD_KEY_PATH = os.path.join(TvbProfile.current.TVB_TEMP_FOLDER, 'private_key.pem')
# Decrypting
ABCUploader._decrypt_content(connectivity_model, 'uploaded')
decrypted_file_path = connectivity_model.uploaded.replace(ENCRYPTED_DATA_SUFFIX, DECRYPTED_DATA_SUFFIX)
with open(path_to_file, 'rb') as f_original:
with open(decrypted_file_path, 'rb') as f_decrypted:
while True:
original_content_chunk = f_original.read(buffer_size)
decrypted_content_chunk = f_decrypted.read(buffer_size)
assert original_content_chunk == decrypted_content_chunk,\
"Original and Decrypted chunks are not equal, so decryption hasn't been done correctly!"
# check if EOF was reached
if len(original_content_chunk) < buffer_size:
break
# Clean-up
os.remove(encrypted_file_path)
os.remove(decrypted_file_path)
os.remove(private_key_path)
os.remove(path_to_encrypted_password)