def __init__(self, encryption_environment, logger): self.encryptionEnvironment = encryption_environment self.passphrase_file_name = None self.bek_filesystem = None self.volume_type = None self.secret_id = None self.encryption_config = ConfigUtil( encryption_environment.encryption_config_file_path, 'azure_crypt_config', logger)
def __init__(self, hutil, logger, distro_patcher, encryption_environment, protected_settings, public_settings): """ TODO: we should validate the parameter first """ self.hutil = hutil self.logger = logger self.distro_patcher = distro_patcher self.encryption_environment = encryption_environment self.disk_util = DiskUtil( hutil=hutil, patching=distro_patcher, logger=logger, encryption_environment=encryption_environment) self.bek_util = BekUtil(self.disk_util, logger) self.encryption_config = EncryptionConfig(encryption_environment, logger) self.command = public_settings.get( CommonVariables.EncryptionEncryptionOperationKey) self.KeyEncryptionKeyURL = public_settings.get( CommonVariables.KeyEncryptionKeyURLKey) self.KeyVaultURL = public_settings.get(CommonVariables.KeyVaultURLKey) self.AADClientID = public_settings.get(CommonVariables.AADClientIDKey) self.AADClientCertThumbprint = public_settings.get( CommonVariables.AADClientCertThumbprintKey) keyEncryptionAlgorithm = public_settings.get( CommonVariables.KeyEncryptionAlgorithmKey) if keyEncryptionAlgorithm is not None and keyEncryptionAlgorithm != "": self.KeyEncryptionAlgorithm = keyEncryptionAlgorithm else: self.KeyEncryptionAlgorithm = 'RSA-OAEP' self.VolumeType = public_settings.get(CommonVariables.VolumeTypeKey) self.DiskFormatQuery = public_settings.get( CommonVariables.DiskFormatQuerykey) """ private settings """ self.AADClientSecret = protected_settings.get( CommonVariables.AADClientSecretKey) if self.AADClientSecret is None: self.AADClientSecret = '' self.passphrase = protected_settings.get(CommonVariables.PassphraseKey) self.DiskEncryptionKeyFileName = "LinuxPassPhraseFileName" # parse the query from the array self.params_config = ConfigUtil( encryption_environment.extension_parameter_file_path, 'azure_extension_params', logger)
def __init__(self, parent, controller): self.conf = Config.get_instance() tk.Frame.__init__(self, parent) self.xadd = 200 self.label = tk.Label(self, text="Configuration", font=LARGE_FONT) self.label.pack(pady=10, padx=10) self.pop = 0 self.cutil = ConfigUtil.get_instance() self.btnBack = ttk.Button( self, text="<< back", command=lambda: controller.show_frame(DefaultPanel)) self.btnBack.place(x=20, y=80) self.lblVirusType = tk.Label(self, text="Select Virus") self.lblVirusType.place(x=400 + self.xadd, y=150) #---------------- combobox to select virus ----------------------- self.combovar = StringVar() self.combovar.trace('w', self.on_change) list_disease = self.cutil.get_all_sections() self.comboBoxVirus = ttk.Combobox(self, textvar=self.combovar, state='readonly', values=list_disease[1:]) self.comboBoxVirus.place(x=500 + self.xadd, y=150) self.comboBoxVirus.current(0) self.set_virus_properties()
def __init__(self, encryption_environment,logger): self.encryptionEnvironment = encryption_environment self.passphrase_file_name = None self.bek_filesystem = None self.volume_type = None self.secret_id = None self.encryption_config = ConfigUtil(encryption_environment.encryption_config_file_path,'azure_crypt_config',logger)
def load_from_file(self, disease_section): factor = 1 cu = ConfigUtil.get_instance() self.set_property_name(disease_section) self.set_population(int(cu.get_value("SIMULATION", "population"))) self.set_initial_infected_percentage( int(cu.get_value("SIMULATION", "initial_infected_percentage"))) self.set_r_factor(int(cu.get_value(disease_section, "r_factor"))) self.set_k_factor(float(cu.get_value(disease_section, "k_factor"))) self.set_days_contageous( int(cu.get_value(disease_section, "days_contageous")) * factor) self.set_mask_introduced_timeline( int(cu.get_value(disease_section, "mask_timeline")) * factor) self.set_mask_usage_effectiveness( float(cu.get_value(disease_section, "mask_usuage_effectiveness"))) self.set_mask_usage_percentage( float(cu.get_value(disease_section, "mask_usuage_percentage"))) self.set_quarantine_introduced_timeline( int(cu.get_value(disease_section, "quarantine_timeline")) * factor) self.set_qurantine_effectiveness( float(cu.get_value(disease_section, "qurantine_effectiveness"))) self.set_qurantine_usage_percentage( float(cu.get_value(disease_section, "qurantine_percentage"))) self.set_vaccine_introduced_timeline( int(cu.get_value(disease_section, "vaccine_timeline")) * factor) self.set_vaccine_effectiveness( float(cu.get_value(disease_section, "vaccine_effectiveness"))) self.set_vaccine_usage_percentage( float(cu.get_value(disease_section, "vaccinated_percentage"))) to_be_infected = int(self.get_r_factor()) * ( int(self.get_population()) * int(self.get_initial_infected_percentage()) / 100) self.set_total_to_infect(to_be_infected)
def test_load_from_file(self): factor = 1 cu = ConfigUtil.get_instance() self.conf.load_from_file("COVID19") disease_section = "COVID19" self.assertTrue(self.conf.get_property_name() == (disease_section)) self.assertTrue(self.conf.get_population() == ( int(cu.get_value("SIMULATION", "population")))) self.assertTrue(self.conf.get_initial_infected_percentage() == ( int(cu.get_value("SIMULATION", "initial_infected_percentage")))) self.assertTrue(self.conf.get_r_factor() == ( int(cu.get_value(disease_section, "r_factor")))) self.assertTrue(self.conf.get_k_factor() == ( float(cu.get_value(disease_section, "k_factor")))) self.assertTrue(self.conf.get_days_contageous() == ( int(cu.get_value(disease_section, "days_contageous")) * factor)) self.assertTrue(self.conf.get_mask_introduced_timeline() == ( int(cu.get_value(disease_section, "mask_timeline")) * factor)) self.assertTrue(self.conf.get_mask_usage_effectiveness() == ( float(cu.get_value(disease_section, "mask_usuage_effectiveness")))) self.assertTrue(self.conf.get_mask_usage_percentage() == ( float(cu.get_value(disease_section, "mask_usuage_percentage")))) self.assertTrue(self.conf.get_quarantine_introduced_timeline() == ( int(cu.get_value(disease_section, "quarantine_timeline")) * factor)) self.assertTrue(self.conf.get_qurantine_effectiveness() == ( float(cu.get_value(disease_section, "qurantine_effectiveness")))) self.assertTrue(self.conf.get_qurantine_usage_percentage() == ( float(cu.get_value(disease_section, "qurantine_percentage")))) self.assertTrue(self.conf.get_vaccine_introduced_timeline() == ( int(cu.get_value(disease_section, "vaccine_timeline")) * factor)) self.assertTrue(self.conf.get_vaccine_effectiveness() == ( float(cu.get_value(disease_section, "vaccine_effectiveness")))) self.assertTrue(self.conf.get_vaccine_usage_percentage() == ( float(cu.get_value(disease_section, "vaccinated_percentage"))))
class SmtpClientConnector(object): def __init__(self): self.config = ConfigUtil(ConfigConst.DEFAULT_CONFIG_FILE_NAME) self.config.loadConfig() print('Configuration data...\n' + str(self.config)) #function to publish the message through the smtp headers def publishMessage(self, topic, data): host = self.config.getProperty(ConfigConst.SMTP_CLOUD_SECTION, ConfigConst.HOST_KEY) port = self.config.getProperty(ConfigConst.SMTP_CLOUD_SECTION, ConfigConst.PORT_KEY) fromAddr = self.config.getProperty(ConfigConst.SMTP_CLOUD_SECTION, ConfigConst.FROM_ADDRESS_KEY) toAddr = self.config.getProperty(ConfigConst.SMTP_CLOUD_SECTION, ConfigConst.TO_ADDRESS_KEY) authToken = self.config.getProperty(ConfigConst.SMTP_CLOUD_SECTION, ConfigConst.USER_AUTH_TOKEN_KEY) msg = MIMEMultipart() msg['From'] = fromAddr msg['To'] = toAddr msg['Subject'] = topic msgBody = str(data) msg.attach(MIMEText(msgBody)) msgText = msg.as_string() # send e-mail notification smtpServer = smtplib.SMTP(host, port) smtpServer.ehlo() smtpServer.starttls() smtpServer.login(fromAddr, authToken) smtpServer.sendmail(fromAddr, toAddr, msgText) smtpServer.quit()
def __init__(self, encryption_environment,logger): self.encryption_environment = encryption_environment self.logger = logger self.original_dev_name_path = None self.original_dev_path = None self.mapper_name = None self.luks_header_file_path = None self.phase = None self.file_system = None self.mount_point = None self.device_size = None self.from_end = None self.header_slice_file_path = None self.current_block_size = None self.current_source_path = None self.current_total_copy_size = None self.current_slice_index = None self.current_destination = None self.ongoing_item_config = ConfigUtil(encryption_environment.azure_crypt_ongoing_item_config_path, 'azure_crypt_ongoing_item_config', logger)
class EncryptionConfig(object): def __init__(self, encryption_environment,logger): self.encryptionEnvironment = encryption_environment self.passphrase_file_name = None self.bek_filesystem = None self.volume_type = None self.secret_id = None self.encryption_config = ConfigUtil(encryption_environment.encryption_config_file_path,'azure_crypt_config',logger) def config_file_exists(self): return self.encryption_config.config_file_exists() def get_bek_filename(self): return self.encryption_config.get_config(CommonVariables.PassphraseFileNameKey) def get_bek_filesystem(self): return self.encryption_config.get_config(CommonVariables.BekVolumeFileSystemKey) def get_secret_id(self): return self.encryption_config.get_config(CommonVariables.SecretUriKey) def commit(self): key_value_pairs = [] command = ConfigKeyValuePair(CommonVariables.PassphraseFileNameKey,self.passphrase_file_name) key_value_pairs.append(command) bek_file_system = ConfigKeyValuePair(CommonVariables.BekVolumeFileSystemKey,CommonVariables.BekVolumeFileSystem) key_value_pairs.append(bek_file_system) parameters = ConfigKeyValuePair(CommonVariables.SecretUriKey,self.secret_id) key_value_pairs.append(parameters) self.encryption_config.save_configs(key_value_pairs)
class EncryptionConfig(object): def __init__(self, encryption_environment, logger): self.encryption_environment = encryption_environment self.passphrase_file_name = None self.volume_type = None self.secret_id = None self.secret_seq_num = None self.encryption_config = ConfigUtil(encryption_environment.encryption_config_file_path, 'azure_crypt_config', logger) self.logger = logger def config_file_exists(self): return self.encryption_config.config_file_exists() def get_bek_filename(self): return self.encryption_config.get_config(CommonVariables.PassphraseFileNameKey) def get_volume_type(self): return self.encryption_config.get_config(CommonVariables.VolumeTypeKey) def get_secret_id(self): return self.encryption_config.get_config(CommonVariables.SecretUriKey) def get_secret_seq_num(self): return self.encryption_config.get_config(CommonVariables.SecretSeqNum) def commit(self): key_value_pairs = [] command = ConfigKeyValuePair(CommonVariables.PassphraseFileNameKey, self.passphrase_file_name) key_value_pairs.append(command) volume_type = ConfigKeyValuePair(CommonVariables.VolumeTypeKey, self.volume_type) key_value_pairs.append(volume_type) parameters = ConfigKeyValuePair(CommonVariables.SecretUriKey, self.secret_id) key_value_pairs.append(parameters) parameters = ConfigKeyValuePair(CommonVariables.SecretSeqNum, self.secret_seq_num) key_value_pairs.append(parameters) self.encryption_config.save_configs(key_value_pairs) def clear_config(self): try: if os.path.exists(self.encryption_environment.encryption_config_file_path): self.logger.log(msg="archiving the encryption config file: {0}".format(self.encryption_environment.encryption_config_file_path)) time_stamp = datetime.datetime.now() new_name = "{0}_{1}".format(self.encryption_environment.encryption_config_file_path, time_stamp) os.rename(self.encryption_environment.encryption_config_file_path, new_name) else: self.logger.log(msg=("the config file not exist: {0}".format(self.encryption_environment.encryption_config_file_path)), level = CommonVariables.WarningLevel) return True except OSError as e: self.logger.log("Failed to archive encryption config with error: {0}, stack trace: {1}".format(e, traceback.format_exc())) return False
def __init__(self, hutil, logger, distro_patcher, encryption_environment, protected_settings, public_settings): """ TODO: we should validate the parameter first """ self.hutil = hutil self.logger = logger self.distro_patcher = distro_patcher self.encryption_environment = encryption_environment self.disk_util = DiskUtil(hutil=hutil, patching=distro_patcher, logger=logger, encryption_environment=encryption_environment) self.bek_util = BekUtil(self.disk_util, logger) self.encryption_config = EncryptionConfig(encryption_environment, logger) self.command = public_settings.get(CommonVariables.EncryptionEncryptionOperationKey) self.KeyEncryptionKeyURL = public_settings.get(CommonVariables.KeyEncryptionKeyURLKey) self.KeyVaultURL = public_settings.get(CommonVariables.KeyVaultURLKey) self.AADClientID = public_settings.get(CommonVariables.AADClientIDKey) self.AADClientCertThumbprint = public_settings.get(CommonVariables.AADClientCertThumbprintKey) keyEncryptionAlgorithm = public_settings.get(CommonVariables.KeyEncryptionAlgorithmKey) if keyEncryptionAlgorithm is not None and keyEncryptionAlgorithm !="": self.KeyEncryptionAlgorithm = keyEncryptionAlgorithm else: self.KeyEncryptionAlgorithm = 'RSA-OAEP' self.VolumeType = public_settings.get(CommonVariables.VolumeTypeKey) self.DiskFormatQuery = public_settings.get(CommonVariables.DiskFormatQuerykey) """ private settings """ self.AADClientSecret = protected_settings.get(CommonVariables.AADClientSecretKey) if self.AADClientSecret is None: self.AADClientSecret = '' self.passphrase = protected_settings.get(CommonVariables.PassphraseKey) self.DiskEncryptionKeyFileName = "LinuxPassPhraseFileName" # parse the query from the array self.params_config = ConfigUtil(encryption_environment.extension_parameter_file_path, 'azure_extension_params', logger)
class EncryptionConfig(object): def __init__(self, encryption_environment, logger): self.encryptionEnvironment = encryption_environment self.passphrase_file_name = None self.bek_filesystem = None self.volume_type = None self.secret_id = None self.encryption_config = ConfigUtil( encryption_environment.encryption_config_file_path, 'azure_crypt_config', logger) def config_file_exists(self): return self.encryption_config.config_file_exists() def get_bek_filename(self): return self.encryption_config.get_config( CommonVariables.PassphraseFileNameKey) def get_bek_filesystem(self): return self.encryption_config.get_config( CommonVariables.BekVolumeFileSystemKey) def get_secret_id(self): return self.encryption_config.get_config(CommonVariables.SecretUriKey) def commit(self): key_value_pairs = [] command = ConfigKeyValuePair(CommonVariables.PassphraseFileNameKey, self.passphrase_file_name) key_value_pairs.append(command) bek_file_system = ConfigKeyValuePair( CommonVariables.BekVolumeFileSystemKey, CommonVariables.BekVolumeFileSystem) key_value_pairs.append(bek_file_system) parameters = ConfigKeyValuePair(CommonVariables.SecretUriKey, self.secret_id) key_value_pairs.append(parameters) self.encryption_config.save_configs(key_value_pairs)
class OnGoingItemConfig(object): def __init__(self, encryption_environment, logger): self.encryption_environment = encryption_environment self.logger = logger self.original_dev_name_path = None self.original_dev_path = None self.mapper_name = None self.luks_header_file_path = None self.phase = None self.file_system = None self.mount_point = None self.device_size = None self.from_end = None self.header_slice_file_path = None self.current_block_size = None self.current_source_path = None self.current_total_copy_size = None self.current_slice_index = None self.current_destination = None self.ongoing_item_config = ConfigUtil( encryption_environment.azure_crypt_ongoing_item_config_path, 'azure_crypt_ongoing_item_config', logger) def config_file_exists(self): return self.ongoing_item_config.config_file_exists() def get_original_dev_name_path(self): return self.ongoing_item_config.get_config( CommonVariables.OngoingItemOriginalDevNamePathKey) def get_original_dev_path(self): return self.ongoing_item_config.get_config( CommonVariables.OngoingItemOriginalDevPathKey) def get_mapper_name(self): return self.ongoing_item_config.get_config( CommonVariables.OngoingItemMapperNameKey) def get_header_file_path(self): return self.ongoing_item_config.get_config( CommonVariables.OngoingItemHeaderFilePathKey) def get_phase(self): return self.ongoing_item_config.get_config( CommonVariables.OngoingItemPhaseKey) def get_header_slice_file_path(self): return self.ongoing_item_config.get_config( CommonVariables.OngoingItemHeaderSliceFilePathKey) def get_file_system(self): return self.ongoing_item_config.get_config( CommonVariables.OngoingItemFileSystemKey) def get_mount_point(self): return self.ongoing_item_config.get_config( CommonVariables.OngoingItemMountPointKey) def get_device_size(self): device_size_value = self.ongoing_item_config.get_config( CommonVariables.OngoingItemDeviceSizeKey) if device_size_value is None or device_size_value == "": return None else: return long(device_size_value) def get_current_slice_index(self): current_slice_index_value = self.ongoing_item_config.get_config( CommonVariables.OngoingItemCurrentSliceIndexKey) if current_slice_index_value is None or current_slice_index_value == "": return None else: return long(current_slice_index_value) def get_from_end(self): return self.ongoing_item_config.get_config( CommonVariables.OngoingItemFromEndKey) def get_current_block_size(self): block_size_value = self.ongoing_item_config.get_config( CommonVariables.OngoingItemCurrentBlockSizeKey) if block_size_value is None or block_size_value == "": return None else: return long(block_size_value) def get_current_source_path(self): return self.ongoing_item_config.get_config( CommonVariables.OngoingItemCurrentSourcePathKey) def get_current_destination(self): return self.ongoing_item_config.get_config( CommonVariables.OngoingItemCurrentDestinationKey) def get_current_total_copy_size(self): total_copy_size_value = self.ongoing_item_config.get_config( CommonVariables.OngoingItemCurrentTotalCopySizeKey) if total_copy_size_value is None or total_copy_size_value == "": return None else: return long(total_copy_size_value) def get_luks_header_file_path(self): return self.ongoing_item_config.get_config( CommonVariables.OngoingItemCurrentLuksHeaderFilePathKey) def load_value_from_file(self): self.original_dev_name_path = self.get_original_dev_name_path() self.original_dev_path = self.get_original_dev_path() self.mapper_name = self.get_mapper_name() self.luks_header_file_path = self.get_luks_header_file_path() self.phase = self.get_phase() self.file_system = self.get_file_system() self.mount_point = self.get_mount_point() self.device_size = self.get_device_size() self.from_end = self.get_from_end() self.header_slice_file_path = self.get_header_slice_file_path() self.current_block_size = self.get_current_block_size() self.current_source_path = self.get_current_source_path() self.current_total_copy_size = self.get_current_total_copy_size() self.current_slice_index = self.get_current_slice_index() self.current_destination = self.get_current_destination() def commit(self): key_value_pairs = [] original_dev_name_path_pair = ConfigKeyValuePair( CommonVariables.OngoingItemOriginalDevNamePathKey, self.original_dev_name_path) key_value_pairs.append(original_dev_name_path_pair) original_dev_path_pair = ConfigKeyValuePair( CommonVariables.OngoingItemOriginalDevPathKey, self.original_dev_path) key_value_pairs.append(original_dev_path_pair) mapper_name_pair = ConfigKeyValuePair( CommonVariables.OngoingItemMapperNameKey, self.mapper_name) key_value_pairs.append(mapper_name_pair) header_file_pair = ConfigKeyValuePair( CommonVariables.OngoingItemHeaderFilePathKey, self.luks_header_file_path) key_value_pairs.append(header_file_pair) phase_pair = ConfigKeyValuePair(CommonVariables.OngoingItemPhaseKey, self.phase) key_value_pairs.append(phase_pair) header_slice_file_pair = ConfigKeyValuePair( CommonVariables.OngoingItemHeaderSliceFilePathKey, self.header_slice_file_path) key_value_pairs.append(header_slice_file_pair) file_system_pair = ConfigKeyValuePair( CommonVariables.OngoingItemFileSystemKey, self.file_system) key_value_pairs.append(file_system_pair) mount_point_pair = ConfigKeyValuePair( CommonVariables.OngoingItemMountPointKey, self.mount_point) key_value_pairs.append(mount_point_pair) device_size_pair = ConfigKeyValuePair( CommonVariables.OngoingItemDeviceSizeKey, self.device_size) key_value_pairs.append(device_size_pair) current_slice_index_pair = ConfigKeyValuePair( CommonVariables.OngoingItemCurrentSliceIndexKey, self.current_slice_index) key_value_pairs.append(current_slice_index_pair) from_end_pair = ConfigKeyValuePair( CommonVariables.OngoingItemFromEndKey, self.from_end) key_value_pairs.append(from_end_pair) current_source_path_pair = ConfigKeyValuePair( CommonVariables.OngoingItemCurrentSourcePathKey, self.current_source_path) key_value_pairs.append(current_source_path_pair) current_destination_pair = ConfigKeyValuePair( CommonVariables.OngoingItemCurrentDestinationKey, self.current_destination) key_value_pairs.append(current_destination_pair) current_total_copy_size_pair = ConfigKeyValuePair( CommonVariables.OngoingItemCurrentTotalCopySizeKey, self.current_total_copy_size) key_value_pairs.append(current_total_copy_size_pair) current_block_size_pair = ConfigKeyValuePair( CommonVariables.OngoingItemCurrentBlockSizeKey, self.current_block_size) key_value_pairs.append(current_block_size_pair) self.ongoing_item_config.save_configs(key_value_pairs) def clear_config(self): try: if os.path.exists(self.encryption_environment. azure_crypt_ongoing_item_config_path): self.logger.log(msg="archive the config file: {0}".format( self.encryption_environment. azure_crypt_ongoing_item_config_path)) time_stamp = datetime.datetime.now() new_name = "{0}_{1}".format( self.encryption_environment. azure_crypt_ongoing_item_config_path, time_stamp) os.rename( self.encryption_environment. azure_crypt_ongoing_item_config_path, new_name) else: self.logger.log(msg=("the config file not exist: {0}".format( self.encryption_environment. azure_crypt_ongoing_item_config_path)), level=CommonVariables.WarningLevel) return True except OSError as e: self.logger.log( "Failed to archive_backup_config with error: {0}, stack trace: {1}" .format(e, traceback.format_exc())) return False def __str__(self): return "dev_uuid_path is {0}, mapper_name is {1}, luks_header_file_path is {2}, phase is {3}, header_slice_file_path is {4}, file system is {5}, mount_point is {6}, device size is {7}"\ .format(self.original_dev_path, self.mapper_name, self.luks_header_file_path, self.phase, self.header_slice_file_path, self.file_system, self.mount_point, self.device_size)
class ExtensionParameter(object): def __init__(self, hutil, logger, distro_patcher, encryption_environment, protected_settings, public_settings): """ TODO: we should validate the parameter first """ self.hutil = hutil self.logger = logger self.distro_patcher = distro_patcher self.encryption_environment = encryption_environment self.disk_util = DiskUtil( hutil=hutil, patching=distro_patcher, logger=logger, encryption_environment=encryption_environment) self.bek_util = BekUtil(self.disk_util, logger) self.encryption_config = EncryptionConfig(encryption_environment, logger) self.command = public_settings.get( CommonVariables.EncryptionEncryptionOperationKey) self.KeyEncryptionKeyURL = public_settings.get( CommonVariables.KeyEncryptionKeyURLKey) self.KeyVaultURL = public_settings.get(CommonVariables.KeyVaultURLKey) self.AADClientID = public_settings.get(CommonVariables.AADClientIDKey) self.AADClientCertThumbprint = public_settings.get( CommonVariables.AADClientCertThumbprintKey) keyEncryptionAlgorithm = public_settings.get( CommonVariables.KeyEncryptionAlgorithmKey) if keyEncryptionAlgorithm is not None and keyEncryptionAlgorithm != "": self.KeyEncryptionAlgorithm = keyEncryptionAlgorithm else: self.KeyEncryptionAlgorithm = 'RSA-OAEP' self.VolumeType = public_settings.get(CommonVariables.VolumeTypeKey) self.DiskFormatQuery = public_settings.get( CommonVariables.DiskFormatQuerykey) """ private settings """ self.AADClientSecret = protected_settings.get( CommonVariables.AADClientSecretKey) if self.AADClientSecret is None: self.AADClientSecret = '' self.passphrase = protected_settings.get(CommonVariables.PassphraseKey) self.DiskEncryptionKeyFileName = "LinuxPassPhraseFileName" # parse the query from the array self.params_config = ConfigUtil( encryption_environment.extension_parameter_file_path, 'azure_extension_params', logger) def config_file_exists(self): return self.params_config.config_file_exists() def get_command(self): return self.params_config.get_config( CommonVariables.EncryptionEncryptionOperationKey) def get_kek_url(self): return self.params_config.get_config( CommonVariables.KeyEncryptionKeyURLKey) def get_keyvault_url(self): return self.params_config.get_config(CommonVariables.KeyVaultURLKey) def get_aad_client_id(self): return self.params_config.get_config(CommonVariables.AADClientIDKey) def get_aad_client_secret(self): return self.params_config.get_config( CommonVariables.AADClientSecretKey) def get_aad_client_cert(self): return self.params_config.get_config( CommonVariables.AADClientCertThumbprintKey) def get_kek_algorithm(self): return self.params_config.get_config( CommonVariables.KeyEncryptionAlgorithmKey) def get_volume_type(self): return self.params_config.get_config(CommonVariables.VolumeTypeKey) def get_disk_format_query(self): return self.params_config.get_config( CommonVariables.DiskFormatQuerykey) def get_bek_filename(self): return self.DiskEncryptionKeyFileName def commit(self): key_value_pairs = [] command = ConfigKeyValuePair( CommonVariables.EncryptionEncryptionOperationKey, self.command) key_value_pairs.append(command) KeyEncryptionKeyURL = ConfigKeyValuePair( CommonVariables.KeyEncryptionKeyURLKey, self.KeyEncryptionKeyURL) key_value_pairs.append(KeyEncryptionKeyURL) KeyVaultURL = ConfigKeyValuePair(CommonVariables.KeyVaultURLKey, self.KeyVaultURL) key_value_pairs.append(KeyVaultURL) AADClientID = ConfigKeyValuePair(CommonVariables.AADClientIDKey, self.AADClientID) key_value_pairs.append(AADClientID) AADClientSecret = ConfigKeyValuePair( CommonVariables.AADClientSecretKey, hashlib.sha256(self.AADClientSecret.encode("utf-8")).hexdigest()) key_value_pairs.append(AADClientSecret) AADClientCertThumbprint = ConfigKeyValuePair( CommonVariables.AADClientCertThumbprintKey, self.AADClientCertThumbprint) key_value_pairs.append(AADClientCertThumbprint) KeyEncryptionAlgorithm = ConfigKeyValuePair( CommonVariables.KeyEncryptionAlgorithmKey, self.KeyEncryptionAlgorithm) key_value_pairs.append(KeyEncryptionAlgorithm) VolumeType = ConfigKeyValuePair(CommonVariables.VolumeTypeKey, self.VolumeType) key_value_pairs.append(VolumeType) DiskFormatQuery = ConfigKeyValuePair( CommonVariables.DiskFormatQuerykey, self.DiskFormatQuery) key_value_pairs.append(DiskFormatQuery) self.params_config.save_configs(key_value_pairs) def clear_config(self): try: if os.path.exists( self.encryption_environment.encryption_config_file_path): self.logger.log( msg="archiving the encryption config file: {0}".format( self.encryption_environment.encryption_config_file_path )) time_stamp = datetime.datetime.now() new_name = "{0}_{1}".format( self.encryption_environment.encryption_config_file_path, time_stamp) os.rename( self.encryption_environment.encryption_config_file_path, new_name) else: self.logger.log(msg=("the config file not exist: {0}".format( self.encryption_environment.encryption_config_file_path)), level=CommonVariables.WarningLevel) return True except OSError as e: self.logger.log( "Failed to archive encryption config with error: {0}, stack trace: {1}" .format(e, traceback.format_exc())) return False def _is_encrypt_command(self, command): return command in [ CommonVariables.EnableEncryption, CommonVariables.EnableEncryptionFormat, CommonVariables.EnableEncryptionFormatAll ] def config_changed(self): if (self.command or self.get_command()) and \ (self.command != self.get_command() and \ # Even if the commands are not exactly the same, if they're both encrypt commands, don't consider this a change not (self._is_encrypt_command(self.command) and self._is_encrypt_command(self.get_command()))): self.logger.log( 'Current config command {0} differs from effective config command {1}' .format(self.command, self.get_command())) return True if (self.KeyEncryptionKeyURL or self.get_kek_url()) and \ (self.KeyEncryptionKeyURL != self.get_kek_url()): self.logger.log( 'Current config KeyEncryptionKeyURL {0} differs from effective config KeyEncryptionKeyURL {1}' .format(self.KeyEncryptionKeyURL, self.get_kek_url())) return True if (self.KeyVaultURL or self.get_keyvault_url()) and \ (self.KeyVaultURL != self.get_keyvault_url()): self.logger.log( 'Current config KeyVaultURL {0} differs from effective config KeyVaultURL {1}' .format(self.KeyVaultURL, self.get_keyvault_url())) return True if (self.AADClientID or self.get_aad_client_id()) and \ (self.AADClientID != self.get_aad_client_id()): self.logger.log( 'Current config AADClientID {0} differs from effective config AADClientID {1}' .format(self.AADClientID, self.get_aad_client_id())) return True if (self.AADClientSecret or self.get_aad_client_secret()) and \ (hashlib.sha256(self.AADClientSecret.encode("utf-8")).hexdigest() != self.get_aad_client_secret()): self.logger.log( 'Current config AADClientSecret {0} differs from effective config AADClientSecret {1}' .format( hashlib.sha256( self.AADClientSecret.encode("utf-8")).hexdigest(), self.get_aad_client_secret())) return True if (self.AADClientCertThumbprint or self.get_aad_client_cert()) and \ (self.AADClientCertThumbprint != self.get_aad_client_cert()): self.logger.log( 'Current config AADClientCertThumbprint {0} differs from effective config AADClientCertThumbprint {1}' .format(self.AADClientCertThumbprint, self.get_aad_client_cert())) return True if (self.KeyEncryptionAlgorithm or self.get_kek_algorithm()) and \ (self.KeyEncryptionAlgorithm != self.get_kek_algorithm()): self.logger.log( 'Current config KeyEncryptionAlgorithm {0} differs from effective config KeyEncryptionAlgorithm {1}' .format(self.KeyEncryptionAlgorithm, self.get_kek_algorithm())) return True bek_passphrase_file = self.bek_util.get_bek_passphrase_file( self.encryption_config) bek_passphrase = file(bek_passphrase_file).read() if (self.passphrase and bek_passphrase) and \ (self.passphrase != bek_passphrase): self.logger.log( 'Current config passphrase differs from effective config passphrase' ) return True self.logger.log( 'Current config is not different from effective config') return False
#!/usr/bin/env python # encoding:utf-8 import time from DirectoryMonitor import MyDirectoryMonitor from LoggerUtil import LoggerUtil from SSHClient import SSHClient from ConfigUtil import ConfigUtil from watchdog.observers import Observer cg = ConfigUtil() loggerUtil = LoggerUtil() monitor = cg.get_monitor_path() print u"正在监听目录%s" % monitor sshClient = SSHClient(cg) event_handler = MyDirectoryMonitor(sshClient,cg,loggerUtil) observer = Observer() observer.schedule(event_handler,monitor,recursive=True) observer.start() try: while True: time.sleep(1) except KeyboardInterrupt: observer.stop() except IOError: print u"远程没有此路径" observer.stop() exit() observer.join()
def __init__(self): self.cu = ConfigUtil.get_instance()
def setUp(self): self.conf = ConfigUtil.get_instance()
class EncryptionConfig(object): def __init__(self, encryption_environment, logger): self.encryptionEnvironment = encryption_environment self.passphrase_file_name = None self.volume_type = None self.secret_id = None self.encryption_config = ConfigUtil( encryption_environment.encryption_config_file_path, 'azure_crypt_config', logger) self.logger = logger def config_file_exists(self): return self.encryption_config.config_file_exists() def get_bek_filename(self): return self.encryption_config.get_config( CommonVariables.PassphraseFileNameKey) def get_volume_type(self): return self.encryption_config.get_config(CommonVariables.VolumeTypeKey) def get_secret_id(self): return self.encryption_config.get_config(CommonVariables.SecretUriKey) def commit(self): key_value_pairs = [] command = ConfigKeyValuePair(CommonVariables.PassphraseFileNameKey, self.passphrase_file_name) key_value_pairs.append(command) volume_type = ConfigKeyValuePair(CommonVariables.VolumeTypeKey, self.volume_type) key_value_pairs.append(volume_type) parameters = ConfigKeyValuePair(CommonVariables.SecretUriKey, self.secret_id) key_value_pairs.append(parameters) self.encryption_config.save_configs(key_value_pairs) def clear_config(self): try: if (os.path.exists( self.encryptionEnvironment.encryption_config_file_path)): self.logger.log( msg="archiving the encryption config file: {0}".format( self.encryptionEnvironment.encryption_config_file_path) ) time_stamp = datetime.datetime.now() new_name = "{0}_{1}".format( self.encryptionEnvironment.encryption_config_file_path, time_stamp) os.rename( self.encryptionEnvironment.encryption_config_file_path, new_name) else: self.logger.log(msg=("the config file not exist: {0}".format( self.encryptionEnvironment.encryption_config_file_path)), level=CommonVariables.WarningLevel) return True except OSError as e: self.logger.log( "Failed to archive encryption config with error: {0}, stack trace: {1}" .format(e, traceback.format_exc())) return False
def __init__(self): self.config = ConfigUtil(ConfigConst.DEFAULT_CONFIG_FILE_NAME) self.config.loadConfig() print('Configuration data...\n' + str(self.config))
class ExtensionParameter(object): def __init__(self, hutil, logger, distro_patcher, encryption_environment, protected_settings, public_settings): """ TODO: we should validate the parameter first """ self.hutil = hutil self.logger = logger self.distro_patcher = distro_patcher self.encryption_environment = encryption_environment self.disk_util = DiskUtil(hutil=hutil, patching=distro_patcher, logger=logger, encryption_environment=encryption_environment) self.bek_util = BekUtil(self.disk_util, logger) self.encryption_config = EncryptionConfig(encryption_environment, logger) self.command = public_settings.get(CommonVariables.EncryptionEncryptionOperationKey) self.KeyEncryptionKeyURL = public_settings.get(CommonVariables.KeyEncryptionKeyURLKey) self.KeyVaultURL = public_settings.get(CommonVariables.KeyVaultURLKey) self.AADClientID = public_settings.get(CommonVariables.AADClientIDKey) self.AADClientCertThumbprint = public_settings.get(CommonVariables.AADClientCertThumbprintKey) keyEncryptionAlgorithm = public_settings.get(CommonVariables.KeyEncryptionAlgorithmKey) if keyEncryptionAlgorithm is not None and keyEncryptionAlgorithm !="": self.KeyEncryptionAlgorithm = keyEncryptionAlgorithm else: self.KeyEncryptionAlgorithm = 'RSA-OAEP' self.VolumeType = public_settings.get(CommonVariables.VolumeTypeKey) self.DiskFormatQuery = public_settings.get(CommonVariables.DiskFormatQuerykey) """ private settings """ self.AADClientSecret = protected_settings.get(CommonVariables.AADClientSecretKey) if self.AADClientSecret is None: self.AADClientSecret = '' self.passphrase = protected_settings.get(CommonVariables.PassphraseKey) self.DiskEncryptionKeyFileName = "LinuxPassPhraseFileName" # parse the query from the array self.params_config = ConfigUtil(encryption_environment.extension_parameter_file_path, 'azure_extension_params', logger) def config_file_exists(self): return self.params_config.config_file_exists() def get_command(self): return self.params_config.get_config(CommonVariables.EncryptionEncryptionOperationKey) def get_kek_url(self): return self.params_config.get_config(CommonVariables.KeyEncryptionKeyURLKey) def get_keyvault_url(self): return self.params_config.get_config(CommonVariables.KeyVaultURLKey) def get_aad_client_id(self): return self.params_config.get_config(CommonVariables.AADClientIDKey) def get_aad_client_secret(self): return self.params_config.get_config(CommonVariables.AADClientSecretKey) def get_aad_client_cert(self): return self.params_config.get_config(CommonVariables.AADClientCertThumbprintKey) def get_kek_algorithm(self): return self.params_config.get_config(CommonVariables.KeyEncryptionAlgorithmKey) def get_volume_type(self): return self.params_config.get_config(CommonVariables.VolumeTypeKey) def get_disk_format_query(self): return self.params_config.get_config(CommonVariables.DiskFormatQuerykey) def get_bek_filename(self): return self.DiskEncryptionKeyFileName def commit(self): key_value_pairs = [] command = ConfigKeyValuePair(CommonVariables.EncryptionEncryptionOperationKey, self.command) key_value_pairs.append(command) KeyEncryptionKeyURL = ConfigKeyValuePair(CommonVariables.KeyEncryptionKeyURLKey, self.KeyEncryptionKeyURL) key_value_pairs.append(KeyEncryptionKeyURL) KeyVaultURL = ConfigKeyValuePair(CommonVariables.KeyVaultURLKey, self.KeyVaultURL) key_value_pairs.append(KeyVaultURL) AADClientID = ConfigKeyValuePair(CommonVariables.AADClientIDKey, self.AADClientID) key_value_pairs.append(AADClientID) AADClientSecret = ConfigKeyValuePair(CommonVariables.AADClientSecretKey, hashlib.sha256(self.AADClientSecret.encode("utf-8")).hexdigest()) key_value_pairs.append(AADClientSecret) AADClientCertThumbprint = ConfigKeyValuePair(CommonVariables.AADClientCertThumbprintKey, self.AADClientCertThumbprint) key_value_pairs.append(AADClientCertThumbprint) KeyEncryptionAlgorithm = ConfigKeyValuePair(CommonVariables.KeyEncryptionAlgorithmKey, self.KeyEncryptionAlgorithm) key_value_pairs.append(KeyEncryptionAlgorithm) VolumeType = ConfigKeyValuePair(CommonVariables.VolumeTypeKey, self.VolumeType) key_value_pairs.append(VolumeType) DiskFormatQuery = ConfigKeyValuePair(CommonVariables.DiskFormatQuerykey, self.DiskFormatQuery) key_value_pairs.append(DiskFormatQuery) self.params_config.save_configs(key_value_pairs) def clear_config(self): try: if os.path.exists(self.encryption_environment.encryption_config_file_path): self.logger.log(msg="archiving the encryption config file: {0}".format(self.encryption_environment.encryption_config_file_path)) time_stamp = datetime.datetime.now() new_name = "{0}_{1}".format(self.encryption_environment.encryption_config_file_path, time_stamp) os.rename(self.encryption_environment.encryption_config_file_path, new_name) else: self.logger.log(msg=("the config file not exist: {0}".format(self.encryption_environment.encryption_config_file_path)), level = CommonVariables.WarningLevel) return True except OSError as e: self.logger.log("Failed to archive encryption config with error: {0}, stack trace: {1}".format(e, traceback.format_exc())) return False def _is_encrypt_command(self, command): return command in [CommonVariables.EnableEncryption, CommonVariables.EnableEncryptionFormat, CommonVariables.EnableEncryptionFormatAll] def config_changed(self): if (self.command or self.get_command()) and \ (self.command != self.get_command() and \ # Even if the commands are not exactly the same, if they're both encrypt commands, don't consider this a change not (self._is_encrypt_command(self.command) and self._is_encrypt_command(self.get_command()))): self.logger.log('Current config command {0} differs from effective config command {1}'.format(self.command, self.get_command())) return True if (self.KeyEncryptionKeyURL or self.get_kek_url()) and \ (self.KeyEncryptionKeyURL != self.get_kek_url()): self.logger.log('Current config KeyEncryptionKeyURL {0} differs from effective config KeyEncryptionKeyURL {1}'.format(self.KeyEncryptionKeyURL, self.get_kek_url())) return True if (self.KeyVaultURL or self.get_keyvault_url()) and \ (self.KeyVaultURL != self.get_keyvault_url()): self.logger.log('Current config KeyVaultURL {0} differs from effective config KeyVaultURL {1}'.format(self.KeyVaultURL, self.get_keyvault_url())) return True if (self.AADClientID or self.get_aad_client_id()) and \ (self.AADClientID != self.get_aad_client_id()): self.logger.log('Current config AADClientID {0} differs from effective config AADClientID {1}'.format(self.AADClientID, self.get_aad_client_id())) return True if (self.AADClientSecret or self.get_aad_client_secret()) and \ (hashlib.sha256(self.AADClientSecret.encode("utf-8")).hexdigest() != self.get_aad_client_secret()): self.logger.log('Current config AADClientSecret {0} differs from effective config AADClientSecret {1}'.format(hashlib.sha256(self.AADClientSecret.encode("utf-8")).hexdigest(), self.get_aad_client_secret())) return True if (self.AADClientCertThumbprint or self.get_aad_client_cert()) and \ (self.AADClientCertThumbprint != self.get_aad_client_cert()): self.logger.log('Current config AADClientCertThumbprint {0} differs from effective config AADClientCertThumbprint {1}'.format(self.AADClientCertThumbprint, self.get_aad_client_cert())) return True if (self.KeyEncryptionAlgorithm or self.get_kek_algorithm()) and \ (self.KeyEncryptionAlgorithm != self.get_kek_algorithm()): self.logger.log('Current config KeyEncryptionAlgorithm {0} differs from effective config KeyEncryptionAlgorithm {1}'.format(self.KeyEncryptionAlgorithm, self.get_kek_algorithm())) return True bek_passphrase_file_name = self.bek_util.get_bek_passphrase_file(self.encryption_config) bek_passphrase = None if bek_passphrase_file_name is not None and os.path.exists(bek_passphrase_file_name): bek_passphrase = file(bek_passphrase_file_name).read() if (self.passphrase and bek_passphrase) and \ (self.passphrase != bek_passphrase): self.logger.log('Current config passphrase differs from effective config passphrase') return True self.logger.log('Current config is not different from effective config') return False
class OnGoingItemConfig(object): def __init__(self, encryption_environment,logger): self.encryption_environment = encryption_environment self.logger = logger self.original_dev_name_path = None self.original_dev_path = None self.mapper_name = None self.luks_header_file_path = None self.phase = None self.file_system = None self.mount_point = None self.device_size = None self.from_end = None self.header_slice_file_path = None self.current_block_size = None self.current_source_path = None self.current_total_copy_size = None self.current_slice_index = None self.current_destination = None self.ongoing_item_config = ConfigUtil(encryption_environment.azure_crypt_ongoing_item_config_path,'azure_crypt_ongoing_item_config',logger) def config_file_exists(self): return self.ongoing_item_config.config_file_exists() def get_original_dev_name_path(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemOriginalDevNamePathKey) def get_original_dev_path(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemOriginalDevPathKey) def get_mapper_name(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemMapperNameKey) def get_header_file_path(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemHeaderFilePathKey) def get_phase(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemPhaseKey) def get_header_slice_file_path(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemHeaderSliceFilePathKey) def get_file_system(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemFileSystemKey) def get_mount_point(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemMountPointKey) def get_device_size(self): return long(self.ongoing_item_config.get_config(CommonVariables.OngoingItemDeviceSizeKey)) def get_current_slice_index(self): return long(self.ongoing_item_config.get_config(CommonVariables.OngoingItemCurrentSliceIndexKey)) def get_from_end(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemFromEndKey) def get_current_block_size(self): return long(self.ongoing_item_config.get_config(CommonVariables.OngoingItemCurrentBlockSizeKey)) def get_current_source_path(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemCurrentSourcePathKey) def get_current_destination(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemCurrentDestinationKey) def get_current_total_copy_size(self): return long(self.ongoing_item_config.get_config(CommonVariables.OngoingItemCurrentTotalCopySizeKey)) def commit(self): key_value_pairs = [] original_dev_name_path_pair = ConfigKeyValuePair(CommonVariables.OngoingItemOriginalDevNamePathKey, self.original_dev_name_path) key_value_pairs.append(original_dev_name_path_pair) original_dev_path_pair = ConfigKeyValuePair(CommonVariables.OngoingItemOriginalDevPathKey, self.original_dev_path) key_value_pairs.append(original_dev_path_pair) mapper_name_pair = ConfigKeyValuePair(CommonVariables.OngoingItemMapperNameKey, self.mapper_name) key_value_pairs.append(mapper_name_pair) header_file_pair = ConfigKeyValuePair(CommonVariables.OngoingItemHeaderFilePathKey, self.luks_header_file_path) key_value_pairs.append(header_file_pair) phase_pair = ConfigKeyValuePair(CommonVariables.OngoingItemPhaseKey, self.phase) key_value_pairs.append(phase_pair) header_slice_file_pair = ConfigKeyValuePair(CommonVariables.OngoingItemHeaderSliceFilePathKey, self.header_slice_file_path) key_value_pairs.append(header_slice_file_pair) file_system_pair = ConfigKeyValuePair(CommonVariables.OngoingItemFileSystemKey, self.file_system) key_value_pairs.append(file_system_pair) mount_point_pair = ConfigKeyValuePair(CommonVariables.OngoingItemMountPointKey, self.mount_point) key_value_pairs.append(mount_point_pair) device_size_pair = ConfigKeyValuePair(CommonVariables.OngoingItemDeviceSizeKey, self.device_size) key_value_pairs.append(device_size_pair) current_slice_index_pair = ConfigKeyValuePair(CommonVariables.OngoingItemCurrentSliceIndexKey, self.current_slice_index) key_value_pairs.append(current_slice_index_pair) from_end_pair = ConfigKeyValuePair(CommonVariables.OngoingItemFromEndKey, self.from_end) key_value_pairs.append(from_end_pair) current_source_path_pair = ConfigKeyValuePair(CommonVariables.OngoingItemCurrentSourcePathKey, self.current_source_path) key_value_pairs.append(current_source_path_pair) current_destination_pair = ConfigKeyValuePair(CommonVariables.OngoingItemCurrentDestinationKey, self.current_destination) key_value_pairs.append(current_destination_pair) current_total_copy_size_pair = ConfigKeyValuePair(CommonVariables.OngoingItemCurrentTotalCopySizeKey, self.current_total_copy_size) key_value_pairs.append(current_total_copy_size_pair) current_block_size_pair = ConfigKeyValuePair(CommonVariables.OngoingItemCurrentBlockSizeKey, self.current_block_size) key_value_pairs.append(current_block_size_pair) self.ongoing_item_config.save_configs(key_value_pairs) def clear_config(self): try: if(os.path.exists(self.encryption_environment.azure_crypt_ongoing_item_config_path)): self.logger.log(msg="remove the config file " + str(self.encryption_environment.azure_crypt_ongoing_item_config_path)) os.remove(self.encryption_environment.azure_crypt_ongoing_item_config_path) else: self.logger.log(msg=("the config file not exist " + str(self.encryption_environment.azure_crypt_ongoing_item_config_path)),level = CommonVariables.WarningLevel) return True except OSError as e: self.logger.log("Failed to clear_queue with error: %s, stack trace: %s" % (str(e), traceback.format_exc())) return False def __str__(self): return "dev_uuid_path is %s, mapper_name is %s, luks_header_file_path is %s, phase is %s, header_slice_file_path is %s, file system is %s, mount_point is %s, device size is %s" % (\ self.original_dev_path,self.mapper_name,self.luks_header_file_path,self.phase,self.header_slice_file_path,self.file_system,self.mount_point,self.device_size)
class OnGoingItemConfig(object): def __init__(self, encryption_environment,logger): self.encryption_environment = encryption_environment self.logger = logger self.original_dev_name_path = None self.original_dev_path = None self.mapper_name = None self.luks_header_file_path = None self.phase = None self.file_system = None self.mount_point = None self.device_size = None self.from_end = None self.header_slice_file_path = None self.current_block_size = None self.current_source_path = None self.current_total_copy_size = None self.current_slice_index = None self.current_destination = None self.ongoing_item_config = ConfigUtil(encryption_environment.azure_crypt_ongoing_item_config_path, 'azure_crypt_ongoing_item_config', logger) def config_file_exists(self): return self.ongoing_item_config.config_file_exists() def get_original_dev_name_path(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemOriginalDevNamePathKey) def get_original_dev_path(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemOriginalDevPathKey) def get_mapper_name(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemMapperNameKey) def get_header_file_path(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemHeaderFilePathKey) def get_phase(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemPhaseKey) def get_header_slice_file_path(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemHeaderSliceFilePathKey) def get_file_system(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemFileSystemKey) def get_mount_point(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemMountPointKey) def get_device_size(self): device_size_value = self.ongoing_item_config.get_config(CommonVariables.OngoingItemDeviceSizeKey) if(device_size_value is None or device_size_value == ""): return None else: return long(device_size_value) def get_current_slice_index(self): current_slice_index_value = self.ongoing_item_config.get_config(CommonVariables.OngoingItemCurrentSliceIndexKey) if(current_slice_index_value is None or current_slice_index_value == ""): return None else: return long(current_slice_index_value) def get_from_end(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemFromEndKey) def get_current_block_size(self): block_size_value = self.ongoing_item_config.get_config(CommonVariables.OngoingItemCurrentBlockSizeKey) if(block_size_value is None or block_size_value == ""): return None else: return long(block_size_value) def get_current_source_path(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemCurrentSourcePathKey) def get_current_destination(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemCurrentDestinationKey) def get_current_total_copy_size(self): total_copy_size_value = self.ongoing_item_config.get_config(CommonVariables.OngoingItemCurrentTotalCopySizeKey) if(total_copy_size_value is None or total_copy_size_value == ""): return None else: return long(total_copy_size_value) def get_luks_header_file_path(self): return self.ongoing_item_config.get_config(CommonVariables.OngoingItemCurrentLuksHeaderFilePathKey) def load_value_from_file(self): self.original_dev_name_path = self.get_original_dev_name_path() self.original_dev_path = self.get_original_dev_path() self.mapper_name = self.get_mapper_name() self.luks_header_file_path = self.get_luks_header_file_path() self.phase = self.get_phase() self.file_system = self.get_file_system() self.mount_point = self.get_mount_point() self.device_size = self.get_device_size() self.from_end = self.get_from_end() self.header_slice_file_path = self.get_header_slice_file_path() self.current_block_size = self.get_current_block_size() self.current_source_path = self.get_current_source_path() self.current_total_copy_size = self.get_current_total_copy_size() self.current_slice_index = self.get_current_slice_index() self.current_destination = self.get_current_destination() def commit(self): key_value_pairs = [] original_dev_name_path_pair = ConfigKeyValuePair(CommonVariables.OngoingItemOriginalDevNamePathKey, self.original_dev_name_path) key_value_pairs.append(original_dev_name_path_pair) original_dev_path_pair = ConfigKeyValuePair(CommonVariables.OngoingItemOriginalDevPathKey, self.original_dev_path) key_value_pairs.append(original_dev_path_pair) mapper_name_pair = ConfigKeyValuePair(CommonVariables.OngoingItemMapperNameKey, self.mapper_name) key_value_pairs.append(mapper_name_pair) header_file_pair = ConfigKeyValuePair(CommonVariables.OngoingItemHeaderFilePathKey, self.luks_header_file_path) key_value_pairs.append(header_file_pair) phase_pair = ConfigKeyValuePair(CommonVariables.OngoingItemPhaseKey, self.phase) key_value_pairs.append(phase_pair) header_slice_file_pair = ConfigKeyValuePair(CommonVariables.OngoingItemHeaderSliceFilePathKey, self.header_slice_file_path) key_value_pairs.append(header_slice_file_pair) file_system_pair = ConfigKeyValuePair(CommonVariables.OngoingItemFileSystemKey, self.file_system) key_value_pairs.append(file_system_pair) mount_point_pair = ConfigKeyValuePair(CommonVariables.OngoingItemMountPointKey, self.mount_point) key_value_pairs.append(mount_point_pair) device_size_pair = ConfigKeyValuePair(CommonVariables.OngoingItemDeviceSizeKey, self.device_size) key_value_pairs.append(device_size_pair) current_slice_index_pair = ConfigKeyValuePair(CommonVariables.OngoingItemCurrentSliceIndexKey, self.current_slice_index) key_value_pairs.append(current_slice_index_pair) from_end_pair = ConfigKeyValuePair(CommonVariables.OngoingItemFromEndKey, self.from_end) key_value_pairs.append(from_end_pair) current_source_path_pair = ConfigKeyValuePair(CommonVariables.OngoingItemCurrentSourcePathKey, self.current_source_path) key_value_pairs.append(current_source_path_pair) current_destination_pair = ConfigKeyValuePair(CommonVariables.OngoingItemCurrentDestinationKey, self.current_destination) key_value_pairs.append(current_destination_pair) current_total_copy_size_pair = ConfigKeyValuePair(CommonVariables.OngoingItemCurrentTotalCopySizeKey, self.current_total_copy_size) key_value_pairs.append(current_total_copy_size_pair) current_block_size_pair = ConfigKeyValuePair(CommonVariables.OngoingItemCurrentBlockSizeKey, self.current_block_size) key_value_pairs.append(current_block_size_pair) self.ongoing_item_config.save_configs(key_value_pairs) def clear_config(self): try: if(os.path.exists(self.encryption_environment.azure_crypt_ongoing_item_config_path)): self.logger.log(msg="archive the config file: {0}".format(self.encryption_environment.azure_crypt_ongoing_item_config_path)) time_stamp = datetime.datetime.now() new_name = "{0}_{1}".format(self.encryption_environment.azure_crypt_ongoing_item_config_path, time_stamp) os.rename(self.encryption_environment.azure_crypt_ongoing_item_config_path, new_name) else: self.logger.log(msg=("the config file not exist: {0}".format(self.encryption_environment.azure_crypt_ongoing_item_config_path)), level = CommonVariables.WarningLevel) return True except OSError as e: self.logger.log("Failed to archive_backup_config with error: {0}, stack trace: {1}".format(e, traceback.format_exc())) return False def __str__(self): return "dev_uuid_path is {0}, mapper_name is {1}, luks_header_file_path is {2}, phase is {3}, header_slice_file_path is {4}, file system is {5}, mount_point is {6}, device size is {7}"\ .format(self.original_dev_path,self.mapper_name,self.luks_header_file_path,self.phase,self.header_slice_file_path,self.file_system,self.mount_point,self.device_size)