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)
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 my_path:
if self.get_wl_home() and my_path.startswith(self.get_wl_home()):
result = my_path.replace(self.get_wl_home(),
self.__WL_HOME_TOKEN)
elif self.get_domain_home() and my_path.startswith(
self.get_domain_home()):
result = my_path.replace(self.get_domain_home(),
self.__DOMAIN_HOME_TOKEN)
elif self.get_oracle_home() and my_path.startswith(
self.get_oracle_home()):
result = my_path.replace(self.get_oracle_home(),
self.__ORACLE_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 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.__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 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 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 _add_classpath_libraries_to_archive(self, model_name, model_value, location):
"""
This is a private method.
Add the server files and directories listed in the server classpath attribute to the archive file.
File locations in the oracle_home will be removed from the classpath and will not be added to the archive file.
:param model_name: attribute for the server server start classpath attribute
:param model_value: classpath value in domain
:param location: context containing current location information
:return model
"""
_method_name = 'add_classpath_libraries_to_archive'
server_name = self._get_server_name_from_location(location)
_logger.entering(server_name, model_name, model_value, class_name=_class_name, method_name=_method_name)
classpath_string = None
if not StringUtils.isEmpty(model_value):
classpath = path_utils.fixup_path(model_value)
# model values are comma-separated
classpath_entries = classpath.split(MODEL_LIST_DELIMITER)
if classpath_entries:
classpath_list = []
for classpath_entry in classpath_entries:
new_source_name = self._add_library(server_name, classpath_entry)
if new_source_name is not None:
classpath_list.append(new_source_name)
classpath_string = StringUtils.getStringFromList(classpath_list, MODEL_LIST_DELIMITER)
_logger.fine('WLSDPLY-06617', server_name, classpath_string, class_name=_class_name,
method_name=_method_name)
_logger.exiting(class_name=_class_name, method_name=_method_name, result=classpath_string)
return classpath_string
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 _is_oracle_home_file(self, file_name):
"""
Determine if the absolute file name starts with an oracle home. Disregard if the application is
located in the domain home.
:param file_name: to check for oracle home or weblogic home
:return: true if in oracle home location
"""
py_str = path_utils.fixup_path(str(file_name))
return (not py_str.startswith(self._model_context.get_domain_home())) and \
(py_str.startswith(self._model_context.get_oracle_home()) or
py_str.startswith(self._model_context.get_wl_home()))
