class ModelContext(object): """ This class contains fields derived from the command-line parameters and external configuration files, excluding the model file. """ _class_name = "ModelContext" __ORACLE_HOME_TOKEN = '@@ORACLE_HOME@@' __WL_HOME_TOKEN = '@@WL_HOME@@' __DOMAIN_HOME_TOKEN = '@@DOMAIN_HOME@@' __JAVA_HOME_TOKEN = '@@JAVA_HOME@@' __CURRENT_DIRECTORY_TOKEN = '@@PWD@@' __TEMP_DIRECTORY_TOKEN = '@@TMP@@' def __init__(self, program_name, arg_map): """ Create a new model context instance. Tools should use model_context_helper.create_context(), to ensure that the typedef is initialized correctly. Unit tests should use this constructor directly, since typedef files are not deployed. :param program_name: the program name, used for logging :param arg_map: all the arguments passed to the tool """ self._program_name = program_name self._logger = platform_logger.PlatformLogger('wlsdeploy.util') self._wls_helper = WebLogicHelper(self._logger) self._oracle_home = None self._wl_home = None self._java_home = None self._domain_home = None self._domain_name = None self._domain_parent_dir = None self._domain_type = 'WLS' self._domain_typedef = None self._admin_url = None self._admin_user = None self._admin_password = None self._archive_file_name = None self._archive_file = None self._model_file = None self._previous_model_file = None self._print_usage = None self._variable_file_name = None self._run_rcu = False self._rcu_database = None self._rcu_prefix = None self._rcu_sys_pass = None self._rcu_schema_pass = None self._encryption_passphrase = None self._encrypt_manual = False self._encrypt_one_pass = None self._use_encryption = False self._wl_version = None self._wlst_mode = None self._recursive = False self._attributes_only = False self._folders_only = False self._opss_wallet_passphrase = None self._opss_wallet = None self._validation_method = None self._rollback_if_restart_required = None if CommandLineArgUtil.ORACLE_HOME_SWITCH in arg_map: self._oracle_home = arg_map[CommandLineArgUtil.ORACLE_HOME_SWITCH] self._wl_home = self._wls_helper.get_weblogic_home(self._oracle_home) if CommandLineArgUtil.JAVA_HOME_SWITCH in arg_map: self._java_home = arg_map[CommandLineArgUtil.JAVA_HOME_SWITCH] if CommandLineArgUtil.DOMAIN_HOME_SWITCH in arg_map: self._domain_home = arg_map[CommandLineArgUtil.DOMAIN_HOME_SWITCH] self._domain_name = os.path.basename(self._domain_home) if CommandLineArgUtil.DOMAIN_PARENT_SWITCH in arg_map: self._domain_parent_dir = arg_map[CommandLineArgUtil.DOMAIN_PARENT_SWITCH] if CommandLineArgUtil.DOMAIN_TYPE_SWITCH in arg_map: self._domain_type = arg_map[CommandLineArgUtil.DOMAIN_TYPE_SWITCH] if CommandLineArgUtil.ADMIN_URL_SWITCH in arg_map: self._admin_url = arg_map[CommandLineArgUtil.ADMIN_URL_SWITCH] if CommandLineArgUtil.ADMIN_USER_SWITCH in arg_map: self._admin_user = arg_map[CommandLineArgUtil.ADMIN_USER_SWITCH] if CommandLineArgUtil.ADMIN_PASS_SWITCH in arg_map: self._admin_password = arg_map[CommandLineArgUtil.ADMIN_PASS_SWITCH] if CommandLineArgUtil.ARCHIVE_FILE_SWITCH in arg_map: self._archive_file_name = arg_map[CommandLineArgUtil.ARCHIVE_FILE_SWITCH] if CommandLineArgUtil.MODEL_FILE_SWITCH in arg_map: self._model_file = arg_map[CommandLineArgUtil.MODEL_FILE_SWITCH] if CommandLineArgUtil.PREVIOUS_MODEL_FILE_SWITCH in arg_map: self._previous_model_file = arg_map[CommandLineArgUtil.PREVIOUS_MODEL_FILE_SWITCH] if CommandLineArgUtil.PRINT_USAGE_SWITCH in arg_map: self._print_usage = arg_map[CommandLineArgUtil.PRINT_USAGE_SWITCH] if CommandLineArgUtil.ATTRIBUTES_ONLY_SWITCH in arg_map: self._attributes_only = arg_map[CommandLineArgUtil.ATTRIBUTES_ONLY_SWITCH] if CommandLineArgUtil.FOLDERS_ONLY_SWITCH in arg_map: self._folders_only = arg_map[CommandLineArgUtil.FOLDERS_ONLY_SWITCH] if CommandLineArgUtil.RECURSIVE_SWITCH in arg_map: self._recursive = arg_map[CommandLineArgUtil.RECURSIVE_SWITCH] if CommandLineArgUtil.VARIABLE_FILE_SWITCH in arg_map: self._variable_file_name = arg_map[CommandLineArgUtil.VARIABLE_FILE_SWITCH] if CommandLineArgUtil.RUN_RCU_SWITCH in arg_map: self._run_rcu = arg_map[CommandLineArgUtil.RUN_RCU_SWITCH] if CommandLineArgUtil.RCU_DB_SWITCH in arg_map: self._rcu_database = arg_map[CommandLineArgUtil.RCU_DB_SWITCH] if CommandLineArgUtil.RCU_PREFIX_SWITCH in arg_map: self._rcu_prefix = arg_map[CommandLineArgUtil.RCU_PREFIX_SWITCH] if CommandLineArgUtil.RCU_SYS_PASS_SWITCH in arg_map: self._rcu_sys_pass = arg_map[CommandLineArgUtil.RCU_SYS_PASS_SWITCH] if CommandLineArgUtil.RCU_SCHEMA_PASS_SWITCH in arg_map: self._rcu_schema_pass = arg_map[CommandLineArgUtil.RCU_SCHEMA_PASS_SWITCH] if CommandLineArgUtil.DOMAIN_TYPEDEF in arg_map: self._domain_typedef = arg_map[CommandLineArgUtil.DOMAIN_TYPEDEF] if CommandLineArgUtil.PASSPHRASE_SWITCH in arg_map: self._encryption_passphrase = arg_map[CommandLineArgUtil.PASSPHRASE_SWITCH] if CommandLineArgUtil.ENCRYPT_MANUAL_SWITCH in arg_map: self._encrypt_manual = arg_map[CommandLineArgUtil.ENCRYPT_MANUAL_SWITCH] if CommandLineArgUtil.ONE_PASS_SWITCH in arg_map: self._encrypt_one_pass = arg_map[CommandLineArgUtil.ONE_PASS_SWITCH] if CommandLineArgUtil.ROLLBACK_IF_RESTART_REQ_SWITCH in arg_map: self._rollback_if_restart_required = arg_map[CommandLineArgUtil.ROLLBACK_IF_RESTART_REQ_SWITCH] if CommandLineArgUtil.USE_ENCRYPTION_SWITCH in arg_map: self._use_encryption = arg_map[CommandLineArgUtil.USE_ENCRYPTION_SWITCH] if CommandLineArgUtil.ARCHIVE_FILE in arg_map: self._archive_file = arg_map[CommandLineArgUtil.ARCHIVE_FILE] if CommandLineArgUtil.OPSS_WALLET_PASSPHRASE in arg_map: self._opss_wallet_passphrase = arg_map[CommandLineArgUtil.OPSS_WALLET_PASSPHRASE] if CommandLineArgUtil.OPSS_WALLET_SWITCH in arg_map: self._opss_wallet = arg_map[CommandLineArgUtil.OPSS_WALLET_SWITCH] if CommandLineArgUtil.VALIDATION_METHOD in arg_map: self._validation_method = arg_map[CommandLineArgUtil.VALIDATION_METHOD] if CommandLineArgUtil.TARGET_VERSION_SWITCH in arg_map: self._wl_version = arg_map[CommandLineArgUtil.TARGET_VERSION_SWITCH] if CommandLineArgUtil.TARGET_MODE_SWITCH in arg_map: wlst_mode_string = arg_map[CommandLineArgUtil.TARGET_MODE_SWITCH] if wlst_mode_string.lower() == 'online': self._wlst_mode = WlstModes.ONLINE else: self._wlst_mode = WlstModes.OFFLINE if self._wl_version is None: self._wl_version = self._wls_helper.get_actual_weblogic_version() if self._wlst_mode is None: self._wlst_mode = WlstModes.OFFLINE return def get_program_name(self): """ Get the program name of the program that is executing. :return: the program name """ return self._program_name def get_oracle_home(self): """ Get the Oracle Home. :return: the Oracle Home """ return self._oracle_home def get_wl_home(self): """ Get the WebLogic Home. :return: the WebLogic Home """ return self._wl_home def get_java_home(self): """ Get the Java Home. :return: the Java Home """ return self._java_home def get_domain_home(self): """ Get the Domain Home. :return: the Domain Home """ return self._domain_home def get_domain_name(self): """ Get the Domain name. :return: the Domain name """ return self._domain_name def set_domain_home(self, domain_home): """ This method is a hack to allow create to add the domain home after reading the domain name from the model. This method is a no-op if the domain home was previously initialized via command-line argument processing. :param domain_home: the domain home directory """ if self._domain_home is None and domain_home is not None and len(domain_home) > 0: self._domain_home = domain_home self._domain_name = os.path.basename(self._domain_home) return def get_domain_parent_dir(self): """ Get the domain parent directory :return: the domain parent directory """ return self._domain_parent_dir def get_domain_type(self): """ Get the domain type. :return: the domain type """ return self._domain_type def get_domain_typedef(self): """ Get the domain typedef. :return: the domain typedef """ return self._domain_typedef def get_admin_url(self): """ Get the admin URL. :return: the admin URL """ return self._admin_url def get_admin_user(self): """ Get the admin username. :return: the admin username """ return self._admin_user def get_admin_password(self): """ Get the admin password. :return: the admin password """ return self._admin_password def get_archive_file_name(self): """ Get the archive file name. :return: the archive file name """ return self._archive_file_name def is_rollback_if_restart_required(self): """ Get the rollback if restart required :return: true or false """ return self._rollback_if_restart_required def get_opss_wallet(self): """ Get the opss wallet. :return: the opss wallet """ return self._opss_wallet def get_opss_wallet_passphrase(self): """ Get the wallet passphrase. :return: the wallet passphrase """ return self._opss_wallet_passphrase def get_validation_method(self): """ Get the validation method. :return: the validation method """ if self._validation_method is None: self._validation_method = 'strict' return self._validation_method def get_archive_file(self): """ Get the archive file. :return: the archive file """ return self._archive_file def get_model_file(self): """ Get the model file. :return: the model file """ return self._model_file def get_previous_model_file(self): """ Get the previous model file. :return: the previous model file """ return self._previous_model_file def get_print_usage(self): """ Get the print usage value. :return: the print usage value """ return self._print_usage def get_folders_only_control_option(self): """ Get the -folders_only command-line switch associated with print usage value. :return: the -folders_only command-line switch """ return self._folders_only def get_attributes_only_control_option(self): """ Get the -attributes_only command-line switch associated with print usage value. :return: the -attributes_only command-line switch """ return self._attributes_only def get_recursive_control_option(self): """ Get the -recursive command-line switch associated with print usage value. :return: the -recursive command-line switch """ return self._recursive def get_variable_file(self): """ Get the variable file. :return: the variable file """ return self._variable_file_name def is_run_rcu(self): """ Get whether or not to run RCU. :return: whether or not to run RCU """ return self._run_rcu def get_rcu_database(self): """ Get the RCU database connect string. :return: the RCU database connect string """ return self._rcu_database def get_rcu_prefix(self): """ Get the RCU prefix. :return: the RCU prefix """ return self._rcu_prefix def get_rcu_sys_pass(self): """ Get the RCU database SYS user password. :return: the RCU database SYS user password """ return self._rcu_sys_pass def get_rcu_schema_pass(self): """ Get the RCU schema users' password. :return: the RCU schema users' password """ return self._rcu_schema_pass def get_encryption_passphrase(self): """ Get the encryption passphrase. :return: the encryption passphrase """ return self._encryption_passphrase def is_encryption_manual(self): """ Get whether or not the user selected to do manual encryption. :return: whether or not the user selected to do manual encryption """ return self._encrypt_manual def get_encrypt_one_pass(self): """ Get the password to encrypt manually. :return: the password to encrypt manually """ return self._encrypt_one_pass def is_using_encryption(self): """ Get whether or not the model is using encryption. :return: whether or not the model is using encryption """ return self._use_encryption def get_target_wls_version(self): """ Get the target WebLogic version. :return: the target WebLogic version """ return self._wl_version def get_target_wlst_mode(self): """ Get the target WLST mode. :return: the target WLST mode """ return self._wlst_mode def is_wlst_online(self): """ Determine if the tool was started using WLST online mode :return: True if the tool is in online mode """ return self._wlst_mode == WlstModes.ONLINE def is_wlst_offline(self): """ Determine if the tool was started using WLST offline mode :return: True if the tool is in offline mode """ return self._wlst_mode == WlstModes.OFFLINE def replace_tokens_in_path(self, attribute_name, resource_dict): """ Replace any tokens in a path with the current values. :param attribute_name: the attrribute name :param resource_dict: the dictionary to use to lookup and replace the attribute value """ separator = ':' path_elements = resource_dict[attribute_name].split(':') semicolon_path_elements = resource_dict[attribute_name].split(';') if len(semicolon_path_elements) > len(path_elements): separator = ';' path_elements = semicolon_path_elements for index, value in enumerate(path_elements): path_elements[index] = self.replace_token_string(value) result = '' for path_element in path_elements: if len(result) != 0: result += separator result += path_element resource_dict[attribute_name] = result return def has_token_prefix(self, path): """ Determines if the specified path begins with one of the known, portable token prefix paths. :param path: the path to check for token prefix :return: true if the path begins with a known prefix, false otherwise """ return path.startswith(self.__ORACLE_HOME_TOKEN) or \ path.startswith(self.__WL_HOME_TOKEN) or \ path.startswith(self.__DOMAIN_HOME_TOKEN) or \ path.startswith(self.__JAVA_HOME_TOKEN) or \ path.startswith(self.__CURRENT_DIRECTORY_TOKEN) or \ path.startswith(self.__TEMP_DIRECTORY_TOKEN) def replace_tokens(self, resource_type, resource_name, attribute_name, resource_dict): """ Replace the tokens in attribute value with the current value. :param resource_type: the resource type (used for logging purposes) :param resource_name: the resource name (used for logging purposes) :param attribute_name: the attribute name for which to replace tokens :param resource_dict: the dictionary to use to lookup and replace the attribute value """ attribute_value = resource_dict[attribute_name] if attribute_value.startswith(self.__ORACLE_HOME_TOKEN): message = "Replacing {0} in {1} {2} {3} with {4}" self._logger.fine(message, self.__ORACLE_HOME_TOKEN, resource_type, resource_name, attribute_name, self.get_oracle_home(), class_name=self._class_name, method_name='_replace_tokens') resource_dict[attribute_name] = attribute_value.replace(self.__ORACLE_HOME_TOKEN, self.get_oracle_home()) elif attribute_value.startswith(self.__WL_HOME_TOKEN): message = "Replacing {0} in {1} {2} {3} with {4}" self._logger.fine(message, self.__WL_HOME_TOKEN, resource_type, resource_name, attribute_name, self.get_wl_home(), class_name=self._class_name, method_name='_replace_tokens') resource_dict[attribute_name] = attribute_value.replace(self.__WL_HOME_TOKEN, self.get_wl_home()) elif attribute_value.startswith(self.__DOMAIN_HOME_TOKEN): message = "Replacing {0} in {1} {2} {3} with {4}" self._logger.fine(message, self.__DOMAIN_HOME_TOKEN, resource_type, resource_name, attribute_name, self.get_domain_home(), class_name=self._class_name, method_name='_replace_tokens') resource_dict[attribute_name] = attribute_value.replace(self.__DOMAIN_HOME_TOKEN, self.get_domain_home()) elif attribute_value.startswith(self.__JAVA_HOME_TOKEN): message = "Replacing {0} in {1} {2} {3} with {4}" self._logger.fine(message, self.__JAVA_HOME_TOKEN, resource_type, resource_name, attribute_name, self.get_domain_home(), class_name=self._class_name, method_name='_replace_tokens') resource_dict[attribute_name] = attribute_value.replace(self.__JAVA_HOME_TOKEN, self.get_java_home()) elif attribute_value.startswith(self.__CURRENT_DIRECTORY_TOKEN): cwd = path_utils.fixup_path(os.getcwd()) message = "Replacing {0} in {1} {2} {3} with {4}" self._logger.fine(message, self.__CURRENT_DIRECTORY_TOKEN, resource_type, resource_name, attribute_name, cwd, class_name=self._class_name, method_name='_replace_tokens') resource_dict[attribute_name] = attribute_value.replace(self.__CURRENT_DIRECTORY_TOKEN, cwd) elif attribute_value.startswith(self.__TEMP_DIRECTORY_TOKEN): temp_dir = path_utils.fixup_path(tempfile.gettempdir()) message = "Replacing {0} in {1} {2} {3} with {4}" self._logger.fine(message, self.__TEMP_DIRECTORY_TOKEN, resource_type, resource_name, attribute_name, temp_dir, class_name=self._class_name, method_name='_replace_tokens') resource_dict[attribute_name] = attribute_value.replace(self.__TEMP_DIRECTORY_TOKEN, temp_dir) return def replace_token_string(self, string_value): """ Replace the tokens in string value with the current value of the token. :param string_value: the value on which to perform token replacement :return: the detokenized value, or the original value if there were no tokens """ if string_value is None: result = None elif string_value.startswith(self.__ORACLE_HOME_TOKEN): result = _replace(string_value, self.__ORACLE_HOME_TOKEN, self.get_oracle_home()) elif string_value.startswith(self.__WL_HOME_TOKEN): result = _replace(string_value, self.__WL_HOME_TOKEN, self.get_wl_home()) elif string_value.startswith(self.__DOMAIN_HOME_TOKEN): result = _replace(string_value, self.__DOMAIN_HOME_TOKEN, self.get_domain_home()) elif string_value.startswith(self.__JAVA_HOME_TOKEN): result = _replace(string_value, self.__JAVA_HOME_TOKEN, self.get_java_home()) elif string_value.startswith(self.__CURRENT_DIRECTORY_TOKEN): result = _replace(string_value, self.__CURRENT_DIRECTORY_TOKEN, path_utils.fixup_path(os.getcwd())) elif string_value.startswith(self.__TEMP_DIRECTORY_TOKEN): result = _replace(string_value, self.__TEMP_DIRECTORY_TOKEN, path_utils.fixup_path(tempfile.gettempdir())) else: result = string_value return result def tokenize_path(self, path): """ Replace known directories that will be different in the target with tokens denoting the type of directory :param path: to check for directories to be tokenized :return: tokenized path or original path """ my_path = path_utils.fixup_path(path) wl_home = path_utils.fixup_path(self.get_wl_home()) domain_home = path_utils.fixup_path(self.get_domain_home()) oracle_home = path_utils.fixup_path(self.get_oracle_home()) java_home = path_utils.fixup_path(self.get_java_home()) tmp_dir = path_utils.fixup_path(tempfile.gettempdir()) cwd = path_utils.fixup_path(os.path.dirname(os.path.abspath(__file__))) # decide later what is required to be in context home for appropriate exception prevention result = my_path if not string_utils.is_empty(my_path): if wl_home is not None and my_path.startswith(wl_home): result = my_path.replace(wl_home, self.__WL_HOME_TOKEN) elif domain_home is not None and my_path.startswith(domain_home): result = my_path.replace(domain_home, self.__DOMAIN_HOME_TOKEN) elif oracle_home is not None and my_path.startswith(oracle_home): result = my_path.replace(oracle_home, self.__ORACLE_HOME_TOKEN) elif java_home is not None and my_path.startswith(java_home): result = my_path.replace(java_home, self.__JAVA_HOME_TOKEN) elif my_path.startswith(cwd): result = my_path.replace(cwd, self.__CURRENT_DIRECTORY_TOKEN) elif my_path.startswith(tmp_dir): result = my_path.replace(tmp_dir, self.__TEMP_DIRECTORY_TOKEN) return result def tokenize_classpath(self, classpath): """ Replace known types of directories with a tokens that represent the directory. :param classpath: containing a string of directories separated by environment specific classpath separator :return: tokenized classpath string """ cp_elements, separator = path_utils.split_classpath(classpath) for index, value in enumerate(cp_elements): cp_elements[index] = self.tokenize_path(value) return separator.join(cp_elements)
class ModelContext(object): """ This class contains fields derived from the command-line parameters and external configuration files, excluding the model file. """ _class_name = "ModelContext" ORACLE_HOME_TOKEN = '@@ORACLE_HOME@@' WL_HOME_TOKEN = '@@WL_HOME@@' DOMAIN_HOME_TOKEN = '@@DOMAIN_HOME@@' JAVA_HOME_TOKEN = '@@JAVA_HOME@@' CURRENT_DIRECTORY_TOKEN = '@@PWD@@' TEMP_DIRECTORY_TOKEN = '@@TMP@@' DB_USER_DEFAULT = 'SYS' def __init__(self, program_name, arg_map): """ Create a new model context instance. Tools should use model_context_helper.create_context(), to ensure that the typedef is initialized correctly. Unit tests should use this constructor directly, since typedef files are not deployed. :param program_name: the program name, used for logging :param arg_map: all the arguments passed to the tool """ self._program_name = program_name self._logger = platform_logger.PlatformLogger('wlsdeploy.util') self._wls_helper = WebLogicHelper(self._logger) self._oracle_home = None self._wl_home = None self._java_home = None self._domain_home = None self._domain_name = None self._domain_parent_dir = None self._domain_type = 'WLS' self._domain_typedef = None self._admin_url = None self._admin_user = None self._admin_password = None self._archive_file_name = None self._archive_file = None self._model_file = None self._previous_model_file = None self._variable_file_name = None self._run_rcu = False self._rcu_database = None self._rcu_prefix = None self._rcu_sys_pass = None self._rcu_schema_pass = None self._encryption_passphrase = None self._encrypt_manual = False self._encrypt_one_pass = None self._use_encryption = False self._wl_version = None self._wlst_mode = None self._recursive = False self._attributes_only = False self._folders_only = False self._opss_wallet_passphrase = None self._opss_wallet = None self._update_rcu_schema_pass = False self._validation_method = None self._cancel_changes_if_restart_required = None self._domain_resource_file = None self._output_dir = None self._target = None self._target_configuration = None self._variable_injector_file = None self._variable_keywords_file = None self._variable_properties_file = None self._rcu_db_user = self.DB_USER_DEFAULT self._discard_current_edit = False self._model_config = None self._ignore_missing_archive_entries = False self._trailing_args = [] if self._wl_version is None: self._wl_version = self._wls_helper.get_actual_weblogic_version() if self._wlst_mode is None: self._wlst_mode = WlstModes.OFFLINE self.__copy_from_args(arg_map) return def __copy_from_args(self, arg_map): if CommandLineArgUtil.ORACLE_HOME_SWITCH in arg_map: self._oracle_home = arg_map[CommandLineArgUtil.ORACLE_HOME_SWITCH] self._wl_home = self._wls_helper.get_weblogic_home( self._oracle_home) if CommandLineArgUtil.JAVA_HOME_SWITCH in arg_map: self._java_home = arg_map[CommandLineArgUtil.JAVA_HOME_SWITCH] if CommandLineArgUtil.DOMAIN_HOME_SWITCH in arg_map: self._domain_home = arg_map[CommandLineArgUtil.DOMAIN_HOME_SWITCH] self._domain_name = os.path.basename(self._domain_home) if CommandLineArgUtil.DOMAIN_PARENT_SWITCH in arg_map: self._domain_parent_dir = arg_map[ CommandLineArgUtil.DOMAIN_PARENT_SWITCH] if CommandLineArgUtil.DOMAIN_TYPE_SWITCH in arg_map: self._domain_type = arg_map[CommandLineArgUtil.DOMAIN_TYPE_SWITCH] if CommandLineArgUtil.ADMIN_URL_SWITCH in arg_map: self._admin_url = arg_map[CommandLineArgUtil.ADMIN_URL_SWITCH] if CommandLineArgUtil.ADMIN_USER_SWITCH in arg_map: self._admin_user = arg_map[CommandLineArgUtil.ADMIN_USER_SWITCH] if CommandLineArgUtil.ADMIN_PASS_SWITCH in arg_map: self._admin_password = arg_map[ CommandLineArgUtil.ADMIN_PASS_SWITCH] if CommandLineArgUtil.ARCHIVE_FILE_SWITCH in arg_map: self._archive_file_name = arg_map[ CommandLineArgUtil.ARCHIVE_FILE_SWITCH] if CommandLineArgUtil.MODEL_FILE_SWITCH in arg_map: self._model_file = arg_map[CommandLineArgUtil.MODEL_FILE_SWITCH] if CommandLineArgUtil.DISCARD_CURRENT_EDIT_SWITCH in arg_map: self._discard_current_edit = arg_map[ CommandLineArgUtil.DISCARD_CURRENT_EDIT_SWITCH] if CommandLineArgUtil.PREVIOUS_MODEL_FILE_SWITCH in arg_map: self._previous_model_file = arg_map[ CommandLineArgUtil.PREVIOUS_MODEL_FILE_SWITCH] if CommandLineArgUtil.ATTRIBUTES_ONLY_SWITCH in arg_map: self._attributes_only = arg_map[ CommandLineArgUtil.ATTRIBUTES_ONLY_SWITCH] if CommandLineArgUtil.FOLDERS_ONLY_SWITCH in arg_map: self._folders_only = arg_map[ CommandLineArgUtil.FOLDERS_ONLY_SWITCH] if CommandLineArgUtil.RECURSIVE_SWITCH in arg_map: self._recursive = arg_map[CommandLineArgUtil.RECURSIVE_SWITCH] if CommandLineArgUtil.VARIABLE_FILE_SWITCH in arg_map: self._variable_file_name = arg_map[ CommandLineArgUtil.VARIABLE_FILE_SWITCH] if CommandLineArgUtil.RUN_RCU_SWITCH in arg_map: self._run_rcu = arg_map[CommandLineArgUtil.RUN_RCU_SWITCH] if CommandLineArgUtil.RCU_DB_SWITCH in arg_map: self._rcu_database = arg_map[CommandLineArgUtil.RCU_DB_SWITCH] if CommandLineArgUtil.RCU_PREFIX_SWITCH in arg_map: self._rcu_prefix = arg_map[CommandLineArgUtil.RCU_PREFIX_SWITCH] if CommandLineArgUtil.RCU_SYS_PASS_SWITCH in arg_map: self._rcu_sys_pass = arg_map[ CommandLineArgUtil.RCU_SYS_PASS_SWITCH] if CommandLineArgUtil.RCU_DB_USER_SWITCH in arg_map: self._rcu_db_user = arg_map[CommandLineArgUtil.RCU_DB_USER_SWITCH] if CommandLineArgUtil.RCU_SCHEMA_PASS_SWITCH in arg_map: self._rcu_schema_pass = arg_map[ CommandLineArgUtil.RCU_SCHEMA_PASS_SWITCH] if CommandLineArgUtil.DOMAIN_TYPEDEF in arg_map: self._domain_typedef = arg_map[CommandLineArgUtil.DOMAIN_TYPEDEF] if CommandLineArgUtil.PASSPHRASE_SWITCH in arg_map: self._encryption_passphrase = arg_map[ CommandLineArgUtil.PASSPHRASE_SWITCH] if CommandLineArgUtil.ENCRYPT_MANUAL_SWITCH in arg_map: self._encrypt_manual = arg_map[ CommandLineArgUtil.ENCRYPT_MANUAL_SWITCH] if CommandLineArgUtil.ONE_PASS_SWITCH in arg_map: self._encrypt_one_pass = arg_map[ CommandLineArgUtil.ONE_PASS_SWITCH] if CommandLineArgUtil.CANCEL_CHANGES_IF_RESTART_REQ_SWITCH in arg_map: self._cancel_changes_if_restart_required = arg_map[ CommandLineArgUtil.CANCEL_CHANGES_IF_RESTART_REQ_SWITCH] if CommandLineArgUtil.USE_ENCRYPTION_SWITCH in arg_map: self._use_encryption = arg_map[ CommandLineArgUtil.USE_ENCRYPTION_SWITCH] if CommandLineArgUtil.ARCHIVE_FILE in arg_map: self._archive_file = arg_map[CommandLineArgUtil.ARCHIVE_FILE] if CommandLineArgUtil.OPSS_WALLET_PASSPHRASE in arg_map: self._opss_wallet_passphrase = arg_map[ CommandLineArgUtil.OPSS_WALLET_PASSPHRASE] if CommandLineArgUtil.OPSS_WALLET_SWITCH in arg_map: self._opss_wallet = arg_map[CommandLineArgUtil.OPSS_WALLET_SWITCH] if CommandLineArgUtil.UPDATE_RCU_SCHEMA_PASS_SWITCH in arg_map: self._update_rcu_schema_pass = True if CommandLineArgUtil.VALIDATION_METHOD in arg_map: self._validation_method = arg_map[ CommandLineArgUtil.VALIDATION_METHOD] if CommandLineArgUtil.TARGET_VERSION_SWITCH in arg_map: self._wl_version = arg_map[ CommandLineArgUtil.TARGET_VERSION_SWITCH] if CommandLineArgUtil.DOMAIN_RESOURCE_FILE_SWITCH in arg_map: self._domain_resource_file = arg_map[ CommandLineArgUtil.DOMAIN_RESOURCE_FILE_SWITCH] if CommandLineArgUtil.TRAILING_ARGS_SWITCH in arg_map: self._trailing_args = arg_map[ CommandLineArgUtil.TRAILING_ARGS_SWITCH] if CommandLineArgUtil.TARGET_SWITCH in arg_map: self._target = arg_map[CommandLineArgUtil.TARGET_SWITCH] if CommandLineArgUtil.TARGET_MODE_SWITCH in arg_map: wlst_mode_string = arg_map[CommandLineArgUtil.TARGET_MODE_SWITCH] if type(wlst_mode_string) == int: self._wlst_mode = wlst_mode_string else: if wlst_mode_string.lower() == 'online': self._wlst_mode = WlstModes.ONLINE else: self._wlst_mode = WlstModes.OFFLINE if CommandLineArgUtil.OUTPUT_DIR_SWITCH in arg_map: self._output_dir = arg_map[CommandLineArgUtil.OUTPUT_DIR_SWITCH] if CommandLineArgUtil.VARIABLE_INJECTOR_FILE_SWITCH in arg_map: self._variable_injector_file = arg_map[ CommandLineArgUtil.VARIABLE_INJECTOR_FILE_SWITCH] if CommandLineArgUtil.VARIABLE_KEYWORDS_FILE_SWITCH in arg_map: self._variable_keywords_file = arg_map[ CommandLineArgUtil.VARIABLE_KEYWORDS_FILE_SWITCH] if CommandLineArgUtil.VARIABLE_PROPERTIES_FILE_SWITCH in arg_map: self._variable_properties_file = arg_map[ CommandLineArgUtil.VARIABLE_PROPERTIES_FILE_SWITCH] def __copy__(self): arg_map = dict() if self._oracle_home is not None: arg_map[CommandLineArgUtil.ORACLE_HOME_SWITCH] = self._oracle_home if self._java_home is not None: arg_map[CommandLineArgUtil.JAVA_HOME_SWITCH] = self._java_home if self._domain_home is not None: arg_map[CommandLineArgUtil.DOMAIN_HOME_SWITCH] = self._domain_home if self._domain_parent_dir is not None: arg_map[CommandLineArgUtil. DOMAIN_PARENT_SWITCH] = self._domain_parent_dir if self._domain_type is not None: arg_map[CommandLineArgUtil.DOMAIN_TYPE_SWITCH] = self._domain_type if self._admin_url is not None: arg_map[CommandLineArgUtil.ADMIN_URL_SWITCH] = self._admin_url if self._admin_user is not None: arg_map[CommandLineArgUtil.ADMIN_USER_SWITCH] = self._admin_user if self._admin_password is not None: arg_map[ CommandLineArgUtil.ADMIN_PASS_SWITCH] = self._admin_password if self._archive_file_name is not None: arg_map[CommandLineArgUtil. ARCHIVE_FILE_SWITCH] = self._archive_file_name if self._model_file is not None: arg_map[CommandLineArgUtil.MODEL_FILE_SWITCH] = self._model_file if self._previous_model_file is not None: arg_map[CommandLineArgUtil. PREVIOUS_MODEL_FILE_SWITCH] = self._previous_model_file if self._attributes_only is not None: arg_map[CommandLineArgUtil. ATTRIBUTES_ONLY_SWITCH] = self._attributes_only if self._folders_only is not None: arg_map[ CommandLineArgUtil.FOLDERS_ONLY_SWITCH] = self._folders_only if self._recursive is not None: arg_map[CommandLineArgUtil.RECURSIVE_SWITCH] = self._recursive if self._variable_file_name is not None: arg_map[CommandLineArgUtil. VARIABLE_FILE_SWITCH] = self._variable_file_name if self._run_rcu is not None: arg_map[CommandLineArgUtil.RUN_RCU_SWITCH] = self._run_rcu if self._discard_current_edit is not None: arg_map[CommandLineArgUtil. DISCARD_CURRENT_EDIT_SWITCH] = self._discard_current_edit if self._rcu_database is not None: arg_map[CommandLineArgUtil.RCU_DB_SWITCH] = self._rcu_database if self._rcu_prefix is not None: arg_map[CommandLineArgUtil.RCU_PREFIX_SWITCH] = self._rcu_prefix if self._rcu_sys_pass is not None: arg_map[ CommandLineArgUtil.RCU_SYS_PASS_SWITCH] = self._rcu_sys_pass if self._rcu_db_user is not None: arg_map[CommandLineArgUtil.RCU_DB_USER_SWITCH] = self._rcu_db_user if self._rcu_schema_pass is not None: arg_map[CommandLineArgUtil. RCU_SCHEMA_PASS_SWITCH] = self._rcu_schema_pass if self._domain_typedef is not None: arg_map[CommandLineArgUtil.DOMAIN_TYPEDEF] = self._domain_typedef if self._encryption_passphrase is not None: arg_map[CommandLineArgUtil. PASSPHRASE_SWITCH] = self._encryption_passphrase if self._encrypt_manual is not None: arg_map[CommandLineArgUtil. ENCRYPT_MANUAL_SWITCH] = self._encrypt_manual if self._encrypt_one_pass is not None: arg_map[ CommandLineArgUtil.ONE_PASS_SWITCH] = self._encrypt_one_pass if self._cancel_changes_if_restart_required is not None: arg_map[ CommandLineArgUtil. CANCEL_CHANGES_IF_RESTART_REQ_SWITCH] = self._cancel_changes_if_restart_required if self._use_encryption is not None: arg_map[CommandLineArgUtil. USE_ENCRYPTION_SWITCH] = self._use_encryption if self._archive_file is not None: arg_map[CommandLineArgUtil.ARCHIVE_FILE] = self._archive_file if self._opss_wallet_passphrase is not None: arg_map[CommandLineArgUtil. OPSS_WALLET_PASSPHRASE] = self._opss_wallet_passphrase if self._opss_wallet is not None: arg_map[CommandLineArgUtil.OPSS_WALLET_SWITCH] = self._opss_wallet if self._update_rcu_schema_pass is not None: arg_map[ CommandLineArgUtil. UPDATE_RCU_SCHEMA_PASS_SWITCH] = self._update_rcu_schema_pass if self._validation_method is not None: arg_map[ CommandLineArgUtil.VALIDATION_METHOD] = self._validation_method if self._wl_version is not None: arg_map[ CommandLineArgUtil.TARGET_VERSION_SWITCH] = self._wl_version if self._domain_resource_file is not None: arg_map[CommandLineArgUtil. DOMAIN_RESOURCE_FILE_SWITCH] = self._domain_resource_file if self._trailing_args is not None: arg_map[ CommandLineArgUtil.TRAILING_ARGS_SWITCH] = self._trailing_args if self._target is not None: arg_map[CommandLineArgUtil.TARGET_SWITCH] = self._target if self._wlst_mode is not None: arg_map[CommandLineArgUtil.TARGET_MODE_SWITCH] = self._wlst_mode if self._output_dir is not None: arg_map[CommandLineArgUtil.OUTPUT_DIR_SWITCH] = self._output_dir if self._variable_injector_file is not None: arg_map[ CommandLineArgUtil. VARIABLE_INJECTOR_FILE_SWITCH] = self._variable_injector_file if self._variable_keywords_file is not None: arg_map[ CommandLineArgUtil. VARIABLE_KEYWORDS_FILE_SWITCH] = self._variable_keywords_file if self._variable_properties_file is not None: arg_map[ CommandLineArgUtil. VARIABLE_PROPERTIES_FILE_SWITCH] = self._variable_properties_file model_context = ModelContext(self._program_name, arg_map) model_context._ignore_missing_archive_entries = self._ignore_missing_archive_entries return model_context def get_model_config(self): """ Return the encapsulated tool properties configuration instance. This will load the ModelConfiguration from the tool properties on the first request :return: model configuration instance """ if self._model_config is None: self._model_config = ModelConfiguration(self._program_name) return self._model_config def get_program_name(self): """ Get the program name of the program that is executing. :return: the program name """ return self._program_name def get_oracle_home(self): """ Get the Oracle Home. :return: the Oracle Home """ return self._oracle_home def get_wl_home(self): """ Get the WebLogic Home. :return: the WebLogic Home """ return self._wl_home def get_java_home(self): """ Get the Java Home. :return: the Java Home """ return self._java_home def get_domain_home(self): """ Get the Domain Home. :return: the Domain Home """ return self._domain_home def get_domain_name(self): """ Get the Domain name. :return: the Domain name """ return self._domain_name def set_domain_home(self, domain_home): """ This method is a hack to allow create to add the domain home after reading the domain name from the model. This method is a no-op if the domain home was previously initialized via command-line argument processing. :param domain_home: the domain home directory """ if self._domain_home is None and domain_home is not None and len( domain_home) > 0: self._domain_home = domain_home self._domain_name = os.path.basename(self._domain_home) return def get_domain_parent_dir(self): """ Get the domain parent directory :return: the domain parent directory """ return self._domain_parent_dir def get_domain_type(self): """ Get the domain type. :return: the domain type """ return self._domain_type def get_domain_typedef(self): """ Get the domain typedef. :return: the domain typedef """ return self._domain_typedef def get_domain_resource_file(self): """ Get the domain resource file. :return: the domain resource file """ return self._domain_resource_file def get_admin_url(self): """ Get the admin URL. :return: the admin URL """ return self._admin_url def get_admin_user(self): """ Get the admin username. :return: the admin username """ return self._admin_user def get_admin_password(self): """ Get the admin password. :return: the admin password """ return self._admin_password def get_archive_file_name(self): """ Get the archive file name. :return: the archive file name """ return self._archive_file_name def is_cancel_changes_if_restart_required(self): """ Get the cancel changes if restart required :return: true or false """ return self._cancel_changes_if_restart_required def is_discard_current_edit(self): """ Get the discard current edit value. :return: true or false """ return self._discard_current_edit def get_opss_wallet(self): """ Get the opss wallet. :return: the opss wallet """ return self._opss_wallet def get_opss_wallet_passphrase(self): """ Get the wallet passphrase. :return: the wallet passphrase """ return self._opss_wallet_passphrase def get_update_rcu_schema_pass(self): """ Get the update rcu schema password flag """ return self._update_rcu_schema_pass def get_validation_method(self): """ Get the validation method. :return: the validation method """ if self._validation_method is None: self._validation_method = 'strict' return self._validation_method def set_validation_method(self, method): """ Set the validation method. :param method: validation method """ self._validation_method = method def get_archive_file(self): """ Get the archive file. :return: the archive file """ return self._archive_file def get_model_file(self): """ Get the model file. :return: the model file """ return self._model_file def get_previous_model_file(self): """ Get the previous model file. :return: the previous model file """ return self._previous_model_file def get_folders_only_control_option(self): """ Get the -folders_only command-line switch for model help tool. :return: the -folders_only command-line switch """ return self._folders_only def get_attributes_only_control_option(self): """ Get the -attributes_only command-line switch for model help tool. :return: the -attributes_only command-line switch """ return self._attributes_only def get_recursive_control_option(self): """ Get the -recursive command-line switch for model help tool. :return: the -recursive command-line switch """ return self._recursive def get_variable_file(self): """ Get the variable file. :return: the variable file """ return self._variable_file_name def is_run_rcu(self): """ Get whether or not to run RCU. :return: whether or not to run RCU """ return self._run_rcu def get_rcu_database(self): """ Get the RCU database connect string. :return: the RCU database connect string """ return self._rcu_database def get_rcu_prefix(self): """ Get the RCU prefix. :return: the RCU prefix """ return self._rcu_prefix def get_rcu_db_user(self): """ Get the RCU DB user. :return: the RCU dbUser """ return self._rcu_db_user def get_rcu_sys_pass(self): """ Get the RCU database SYS user password. :return: the RCU database SYS user password """ return self._rcu_sys_pass def get_rcu_schema_pass(self): """ Get the RCU schema users' password. :return: the RCU schema users' password """ return self._rcu_schema_pass def get_encryption_passphrase(self): """ Get the encryption passphrase. :return: the encryption passphrase """ return self._encryption_passphrase def get_output_dir(self): """ Return the output directory. :return: output directory """ return self._output_dir def get_target_configuration(self): """ Return the target configuration object, based on the target name. Lazy-load this the first time it is requested. Return a default target configuration if none was specified. :return: target configuration object """ if self._target_configuration is None: configuration_dict = {} if self._target: target_path = os.path.join('targets', self._target, 'target.json') target_configuration_file = path_utils.find_config_path( target_path) if os.path.exists(target_configuration_file): file_handle = open(target_configuration_file) configuration_dict = eval(file_handle.read()) self._target_configuration = TargetConfiguration( configuration_dict) return self._target_configuration def get_target(self): return self._target def is_targetted_config(self): """ Return the output directory for generated k8s target. :return: output directory """ return self._target is not None def is_encryption_manual(self): """ Get whether or not the user selected to do manual encryption. :return: whether or not the user selected to do manual encryption """ return self._encrypt_manual def get_encrypt_one_pass(self): """ Get the password to encrypt manually. :return: the password to encrypt manually """ return self._encrypt_one_pass def is_using_encryption(self): """ Get whether or not the model is using encryption. :return: whether or not the model is using encryption """ return self._use_encryption def get_target_wls_version(self): """ Get the target WebLogic version. :return: the target WebLogic version """ return self._wl_version def get_target_wlst_mode(self): """ Get the target WLST mode. :return: the target WLST mode """ return self._wlst_mode def get_variable_injector_file(self): """ Get the variable injector file override. :return: the variable injector file """ return self._variable_injector_file def get_variable_keywords_file(self): """ Get the variable keywords file override. :return: the variable keywords file """ return self._variable_keywords_file def get_variable_properties_file(self): """ Get the variable properties file override. :return: the variable properties file """ return self._variable_properties_file def get_trailing_argument(self, index): """ Get the trailing argument at index. :param index: the index of the trailing argument :return: the trailing argument """ return self._trailing_args[index] def get_ignore_missing_archive_entries(self): """ Determine if the tool should ignore missing archive entries during validation. :return: True if the tool should ignore missing entries """ return self._ignore_missing_archive_entries def set_ignore_missing_archive_entries(self, ignore): """ Configure the tool to ignore missing archive entries during validation. :param ignore: True if the tool should ignore missing entries, False otherwise """ self._ignore_missing_archive_entries = ignore def is_wlst_online(self): """ Determine if the tool was started using WLST online mode :return: True if the tool is in online mode """ return self._wlst_mode == WlstModes.ONLINE def is_wlst_offline(self): """ Determine if the tool was started using WLST offline mode :return: True if the tool is in offline mode """ return self._wlst_mode == WlstModes.OFFLINE def replace_tokens_in_path(self, attribute_name, resource_dict): """ Replace any tokens in a path with the current values. :param attribute_name: the attrribute name :param resource_dict: the dictionary to use to lookup and replace the attribute value """ separator = ':' attribute_value = resource_dict[attribute_name] path_elements = attribute_value.split(':') semicolon_path_elements = resource_dict[attribute_name].split(';') if len(semicolon_path_elements) > len(path_elements): separator = ';' path_elements = semicolon_path_elements for index, value in enumerate(path_elements): path_elements[index] = self.replace_token_string(value) result = '' for path_element in path_elements: if len(result) != 0: result += separator result += path_element resource_dict[attribute_name] = result return def has_token_prefix(self, path): """ Determines if the specified path begins with one of the known, portable token prefix paths. :param path: the path to check for token prefix :return: true if the path begins with a known prefix, false otherwise """ return path.startswith(self.ORACLE_HOME_TOKEN) or \ path.startswith(self.WL_HOME_TOKEN) or \ path.startswith(self.DOMAIN_HOME_TOKEN) or \ path.startswith(self.JAVA_HOME_TOKEN) or \ path.startswith(self.CURRENT_DIRECTORY_TOKEN) or \ path.startswith(self.TEMP_DIRECTORY_TOKEN) def replace_tokens(self, resource_type, resource_name, attribute_name, resource_dict): """ Replace the tokens in attribute value with the current value. :param resource_type: the resource type (used for logging purposes) :param resource_name: the resource name (used for logging purposes) :param attribute_name: the attribute name for which to replace tokens :param resource_dict: the dictionary to use to lookup and replace the attribute value """ attribute_value = resource_dict[attribute_name] if attribute_value is None: return uri = URI(attribute_value) uri_scheme = uri.getScheme() if uri_scheme is not None and str(uri_scheme).startswith('file'): attribute_value = uri.getPath() if attribute_value.startswith(self.ORACLE_HOME_TOKEN): message = "Replacing {0} in {1} {2} {3} with {4}" self._logger.fine(message, self.ORACLE_HOME_TOKEN, resource_type, resource_name, attribute_name, self.get_oracle_home(), class_name=self._class_name, method_name='_replace_tokens') resource_dict[attribute_name] = attribute_value.replace( self.ORACLE_HOME_TOKEN, self.get_oracle_home()) elif attribute_value.startswith(self.WL_HOME_TOKEN): message = "Replacing {0} in {1} {2} {3} with {4}" self._logger.fine(message, self.WL_HOME_TOKEN, resource_type, resource_name, attribute_name, self.get_wl_home(), class_name=self._class_name, method_name='_replace_tokens') resource_dict[attribute_name] = attribute_value.replace( self.WL_HOME_TOKEN, self.get_wl_home()) elif attribute_value.startswith(self.DOMAIN_HOME_TOKEN): message = "Replacing {0} in {1} {2} {3} with {4}" self._logger.fine(message, self.DOMAIN_HOME_TOKEN, resource_type, resource_name, attribute_name, self.get_domain_home(), class_name=self._class_name, method_name='_replace_tokens') resource_dict[attribute_name] = attribute_value.replace( self.DOMAIN_HOME_TOKEN, self.get_domain_home()) elif attribute_value.startswith(self.JAVA_HOME_TOKEN): message = "Replacing {0} in {1} {2} {3} with {4}" self._logger.fine(message, self.JAVA_HOME_TOKEN, resource_type, resource_name, attribute_name, self.get_domain_home(), class_name=self._class_name, method_name='_replace_tokens') resource_dict[attribute_name] = attribute_value.replace( self.JAVA_HOME_TOKEN, self.get_java_home()) elif attribute_value.startswith(self.CURRENT_DIRECTORY_TOKEN): cwd = path_utils.fixup_path(os.getcwd()) message = "Replacing {0} in {1} {2} {3} with {4}" self._logger.fine(message, self.CURRENT_DIRECTORY_TOKEN, resource_type, resource_name, attribute_name, cwd, class_name=self._class_name, method_name='_replace_tokens') resource_dict[attribute_name] = attribute_value.replace( self.CURRENT_DIRECTORY_TOKEN, cwd) elif attribute_value.startswith(self.TEMP_DIRECTORY_TOKEN): temp_dir = path_utils.fixup_path(tempfile.gettempdir()) message = "Replacing {0} in {1} {2} {3} with {4}" self._logger.fine(message, self.TEMP_DIRECTORY_TOKEN, resource_type, resource_name, attribute_name, temp_dir, class_name=self._class_name, method_name='_replace_tokens') resource_dict[attribute_name] = attribute_value.replace( self.TEMP_DIRECTORY_TOKEN, temp_dir) return def replace_token_string(self, string_value): """ Replace the tokens in string value with the current value of the token. :param string_value: the value on which to perform token replacement :return: the detokenized value, or the original value if there were no tokens """ if string_value is None: result = None elif string_value.startswith(self.ORACLE_HOME_TOKEN): result = _replace(string_value, self.ORACLE_HOME_TOKEN, self.get_oracle_home()) elif string_value.startswith(self.WL_HOME_TOKEN): result = _replace(string_value, self.WL_HOME_TOKEN, self.get_wl_home()) elif string_value.startswith(self.DOMAIN_HOME_TOKEN): result = _replace(string_value, self.DOMAIN_HOME_TOKEN, self.get_domain_home()) elif string_value.startswith(self.JAVA_HOME_TOKEN): result = _replace(string_value, self.JAVA_HOME_TOKEN, self.get_java_home()) elif string_value.startswith(self.CURRENT_DIRECTORY_TOKEN): result = _replace(string_value, self.CURRENT_DIRECTORY_TOKEN, path_utils.fixup_path(os.getcwd())) elif string_value.startswith(self.TEMP_DIRECTORY_TOKEN): result = _replace(string_value, self.TEMP_DIRECTORY_TOKEN, path_utils.fixup_path(tempfile.gettempdir())) else: result = string_value return result def tokenize_path(self, path): """ Replace known directories that will be different in the target with tokens denoting the type of directory :param path: to check for directories to be tokenized :return: tokenized path or original path """ my_path = path_utils.fixup_path(path) wl_home = path_utils.fixup_path(self.get_wl_home()) domain_home = path_utils.fixup_path(self.get_domain_home()) oracle_home = path_utils.fixup_path(self.get_oracle_home()) java_home = path_utils.fixup_path(self.get_java_home()) tmp_dir = path_utils.fixup_path(tempfile.gettempdir()) cwd = path_utils.fixup_path(os.path.dirname(os.path.abspath(__file__))) # decide later what is required to be in context home for appropriate exception prevention result = my_path if not string_utils.is_empty(my_path): if wl_home is not None and my_path.startswith(wl_home): result = my_path.replace(wl_home, self.WL_HOME_TOKEN) elif domain_home is not None and my_path.startswith(domain_home): result = my_path.replace(domain_home, self.DOMAIN_HOME_TOKEN) elif oracle_home is not None and my_path.startswith(oracle_home): result = my_path.replace(oracle_home, self.ORACLE_HOME_TOKEN) elif java_home is not None and my_path.startswith(java_home): result = my_path.replace(java_home, self.JAVA_HOME_TOKEN) elif my_path.startswith(cwd): result = my_path.replace(cwd, self.CURRENT_DIRECTORY_TOKEN) elif my_path.startswith(tmp_dir): result = my_path.replace(tmp_dir, self.TEMP_DIRECTORY_TOKEN) return result def tokenize_classpath(self, classpath): """ Replace known types of directories with a tokens that represent the directory. :param classpath: containing a string of directories separated by environment specific classpath separator :return: tokenized classpath string """ cp_elements, separator = path_utils.split_classpath(classpath) for index, value in enumerate(cp_elements): cp_elements[index] = self.tokenize_path(value) return separator.join(cp_elements) def copy(self, arg_map): model_context_copy = copy.copy(self) model_context_copy.__copy_from_args(arg_map) return model_context_copy