__release_edit_session_and_disconnect()
raise ex
model_deployer.deploy_applications(model,
model_context,
aliases,
wlst_mode=__wlst_mode)
try:
__wlst_helper.disconnect()
except BundleAwareException, ex:
# All the changes are made and active so don't raise an error that causes the program
# to indicate a failure...just log the error since the process is going to exit anyway.
__logger.warning('WLSDPLY-09009',
_program_name,
ex.getLocalizedMessage(),
error=ex,
class_name=_class_name,
method_name=_method_name)
return exit_code
def __deploy_offline(model, model_context, aliases):
"""
Offline deployment orchestration
:param model: the model
:param model_context: the model context
:param aliases: the aliases object
:raises: DeployException: if an error occurs
"""
_method_name = '__deploy_offline'
class_name=_class_name,
method_name=_method_name)
injector_dictionary = dict()
if os.path.isfile(injector_file_name):
try:
injector_dictionary = JsonToPython(injector_file_name).parse()
__temporary_fix(injector_dictionary)
except (IllegalArgumentException, JsonException), e:
_logger.warning('WLDPLY-19409',
injector_file_name,
e.getLocalizedMessage(),
class_name=_class_name,
method_name=_method_name)
else:
_logger.warning('WLSDPLY-19510',
injector_file_name,
class_name=_class_name,
method_name=_method_name)
_logger.exiting(class_name=_class_name, method_name=_method_name)
return injector_dictionary
def _get_append_to_variable_file(**kwargs):
if VARIABLE_FILE_APPEND_ARG in kwargs:
return kwargs[VARIABLE_FILE_APPEND_ARG]
return False
def _format_variable_value(value):
if type(value) == bool:
if value:
exit_code = 0
try:
# First we enable the stdout again and then redirect the stdoout to a string output stream
# call isRestartRequired to get the output, capture the string and then silence wlst output again
#
__wlst_helper.enable_stdout()
sostream = StringOutputStream()
System.setOut(PrintStream(sostream))
restart_required = __wlst_helper.is_restart_required()
is_restartreq_output = sostream.get_string()
__wlst_helper.silence()
if model_context.is_rollback_if_restart_required(
) and restart_required:
__wlst_helper.cancel_edit()
__logger.warning('WLSDPLY_09015', is_restartreq_output)
exit_code = CommandLineArgUtil.PROG_ROLLBACK_IF_RESTART_EXIT_CODE
deployer_utils.list_rollback_changes(model_context,
is_restartreq_output)
else:
__wlst_helper.save()
__wlst_helper.activate(
model_context.get_model_config().get_activate_timeout())
if restart_required:
exit_code = CommandLineArgUtil.PROG_RESTART_REQUIRED
exit_code = deployer_utils.list_restarts(
model_context, exit_code)
except BundleAwareException, ex:
__release_edit_session_and_disconnect()
raise ex
class OnlineGenerator(GeneratorHelper):
"""
Generate MBean and attribute information into a dictionary from the online wlst session.
The data is traversed using the registered mbean information for the online session.
"""
def __init__(self, model_context, dictionary):
GeneratorHelper.__init__(self, model_context, dictionary)
self.__class_name__ = self.__class__.__name__
self._domain_home = None
self.__logger = PlatformLogger('test.aliases.generate', resource_bundle_name='aliastest_rb')
self.__logger.set_level(Level.FINER)
def generate(self):
"""
Generate the mbean dictionary for weblogic in wlst online mode.
:return: the domain home of the connected session
"""
_method_name = 'generate'
self.__logger.entering(class_name=self.__class_name__, method_name=_method_name)
if generator_wlst.connect(self._helper.admin_user(), self._helper.admin_password(), self._helper.admin_url()):
try:
self.__folder_hierarchy(self._dictionary, '/')
finally:
generator_wlst.disconnect()
self.__logger.exiting(class_name=self.__class_name__, method_name=_method_name)
return
def __folder_hierarchy(self, mbean_dictionary, mbean_path):
_method_name = '__folder_hierarchy'
self.__logger.entering(mbean_path, class_name=self.__class_name__, method_name=_method_name)
mbean_instance = generator_wlst.get_mbean_proxy(mbean_path)
mbean_dictionary[all_utils.ATTRIBUTES] = self.__get_attributes(mbean_instance)
mbean_map = self.__create_any_subfolders()
info_helper = MBeanInfoHelper(mbean_instance, mbean_path)
mbean_info_map = info_helper.get_child_mbeans()
mbean_info_list = mbean_info_map.keys()
mbi_helper = MBIHelper(mbean_instance, mbean_path)
mbean_mbi_map = mbi_helper.get_child_mbeans()
for mbean_type, attribute_helper in mbean_mbi_map.iteritems():
mbean_name = None
# mbean_type is the name of the child MBean attribute in the mbean Helper attribute list
if mbean_type in mbean_map:
mbean_name = mbean_map[mbean_type]
del mbean_map[mbean_type]
if mbean_type in mbean_info_list:
mbean_info_list.remove(mbean_type)
self.__logger.finest('Child MBean {0} is in both the MBI information and the MBeanInfo information',
mbean_type, class_name=self.__class_name__, method_name=_method_name)
else:
self.__logger.fine('Child MBean {0} is in the MBI information but not the MBeanInfo information',
mbean_type, class_name=self.__class_name__, method_name=_method_name)
if attribute_helper.is_reference_only():
mbean_dictionary[mbean_type] = all_utils.dict_obj()
# This non-attribute might have been added as a folder, which it is not
mbean_dictionary[mbean_type][all_utils.ONLINE_REFERENCE_ONLY] = all_utils.TRUE
continue
if self._is_valid_folder(attribute_helper):
self.__logger.fine('WLSDPLYST-01115', mbean_type, generator_wlst.current_path(),
class_name=self.__class_name__, method_name=_method_name)
mbean_dictionary[mbean_type] = all_utils.dict_obj()
attribute_helper.generate_mbean(mbean_dictionary[mbean_type])
if mbean_name is None:
mbean_name = generator_wlst.get_singleton_name(mbean_type)
if mbean_name is not None:
if mbean_type in generator_wlst.child_mbean_types():
mbean_dictionary[mbean_type][all_utils.INSTANCE_TYPE] = all_utils.MULTIPLE
else:
mbean_dictionary[mbean_type][all_utils.INSTANCE_TYPE] = all_utils.SINGLE
bean_dir = mbean_type + '/' + mbean_name
if not generator_wlst.cd_mbean(bean_dir):
self.__logger.fine('WLSDPLYST-01117', mbean_type, generator_wlst.current_path(), '',
class_name=self.__class_name__, method_name=_method_name)
mbean_dictionary[mbean_type][all_utils.RECHECK] = \
'cd to mbean and mbean name returned exception'
continue
self.__folder_hierarchy(mbean_dictionary[mbean_type], generator_wlst.current_path())
generator_wlst.cd_mbean('../..')
else:
# make this a real message
self.__logger.warning('Ignore invalid MBean folder {0} containment : {1}, deprecated : {2}',
mbean_type, all_utils.str_bool(attribute_helper.is_containment()),
all_utils.str_bool(attribute_helper.is_deprecated()),
class_name=self.__class_name__, method_name=_method_name)
if len(mbean_map) > 0:
mbeans_only = [leftover for leftover in mbean_map if leftover not in mbi_helper.get_all_attributes()]
if len(mbeans_only) > 0:
for mbean_type in mbeans_only:
# If it is in the attribute list, its a reference
if mbi_helper.get_all_attribute(mbean_type).is_attribute_found() is False:
self.__logger.fine('MBean {0} was not found in the MBI map but is in the LSC map',
mbean_type, class_name=self.__class_name__, method_name=_method_name)
info_attribute_helper = info_helper.get_child_mbean(mbean_type)
if info_attribute_helper.is_attribute_found():
self.__logger.fine('Child MBean {0} is in the MBeanInfo information but not'
' the MBI information',
class_name=self.__class_name__, method_name=_method_name)
mbean_name = mbean_map[mbean_type]
if mbean_name is not None:
bean_dir = mbean_type + '/' + mbean_name
mbean_dictionary[mbean_type] = all_utils.dict_obj()
if generator_wlst.cd_mbean(bean_dir) is False:
self.__logger.fine('WLSDPLYST-01117', mbean_type, generator_wlst.current_path(), '',
class_name=self.__class_name__, method_name=_method_name)
mbean_dictionary[mbean_type][all_utils.RECHECK] = \
'cd to mbean and mbean name returned exception'
continue
self.__folder_hierarchy(mbean_dictionary[mbean_type], generator_wlst.current_path())
generator_wlst.cd_mbean('../..')
self.__logger.exiting(class_name=self.__class_name__, method_name=_method_name)
return
def __get_attributes(self, mbean_instance):
_method_name = '__get_attributes'
mbean_path = generator_wlst.current_path()
self.__logger.entering(mbean_instance, mbean_path, class_name=self.__class_name__, method_name=_method_name)
lsa_map = generator_wlst.lsa_map_modified()
not_found_mbean_list = list()
if len(lsa_map) > 0:
not_found_mbean_list = lsa_map.keys()
not_found_mbean_list.sort()
mbean_instance = generator_wlst.get_mbean_proxy(mbean_path)
operation_list = generator_wlst.ls_operations()
info_helper = MBeanInfoHelper(mbean_instance, mbean_path)
mbean_type = info_helper.get_mbean_type()
mbean_info_map = info_helper.get_attributes()
mbean_info_list = mbean_info_map.keys()
self.__logger.finest('MBean {0} LSA map attributes are {1} at location {2} mbean_path',
mbean_type, not_found_mbean_list, mbean_path,
class_name=self.__class_name__, method_name=_method_name)
method_helper = MBeanMethodHelper(mbean_instance, mbean_path)
method_map = method_helper.get_attributes()
# The main driver must have all attributes in the map
mbi_helper = MBIHelper(mbean_instance, mbean_path)
mbean_mbi_map = mbi_helper.get_all_attributes()
attributes = all_utils.dict_obj()
for attribute, attribute_helper in mbean_mbi_map.iteritems():
self.__logger.finer('Processing MBean {0} attribute {1} from MBI map', mbean_type, attribute,
class_name=self.__class_name__, method_name=_method_name)
info_attribute_helper = None
if attribute in mbean_info_list:
info_attribute_helper = mbean_info_map[attribute]
mbean_info_list.remove(attribute)
method_helper = None
if attribute in method_map:
method_helper = method_map[attribute]
if attribute not in lsa_map:
if self._is_valid_cmo_attribute(attribute_helper, info_attribute_helper):
self.__logger.fine('Adding MBean {0} attribute {1} from location {2} '
'that is in MBI map and not in LSA map', mbean_type, attribute, mbean_path,
class_name=self.__class_name__, method_name=_method_name)
holder = all_utils.dict_obj()
self.add_default_value(holder, lsa_map, attribute_helper, method_helper)
attribute_helper.generate_attribute(holder)
attributes[attribute] = all_utils.sort_dict(holder)
else:
not_found_mbean_list.remove(attribute)
if self._is_valid_attribute(attribute, attribute_helper, info_attribute_helper):
self.__logger.finer('Adding MBean {0} attribute {1} from location {2} which is in LSA and MBI maps',
mbean_type, attribute, mbean_path,
class_name=self.__class_name__, method_name=_method_name)
holder = all_utils.dict_obj()
self.add_default_value(holder, lsa_map, attribute_helper, method_helper)
attribute_helper.generate_attribute(holder)
attributes[attribute] = all_utils.sort_dict(holder)
for attribute in mbean_info_list:
self.__logger.finer('Processing MBean {0} attribute {1} from MBeanInfo map',
mbean_type, attribute,
class_name=self.__class_name__, method_name=_method_name)
if attribute in not_found_mbean_list:
not_found_mbean_list.remove(attribute)
attribute_helper = mbean_info_map[attribute]
method_helper = None
if attribute in method_map:
method_helper = method_map[attribute]
if self._is_valid_cmo_attribute(attribute_helper, method_helper):
self.__logger.fine('Adding MBean {0} attribute {1} found in MBeanInfo but not MBI',
mbean_type, attribute,
class_name=self.__class_name__, method_name=_method_name)
holder = all_utils.dict_obj()
self.add_default_value(holder, lsa_map, attribute_helper, method_helper)
attribute_helper.generate_attribute(holder)
attributes[attribute] = all_utils.sort_dict(holder)
for lsa_only in not_found_mbean_list:
self.__logger.finer('Processing MBean {0} attribute {1} from LSA map', mbean_type, lsa_only,
class_name=self.__class_name__, method_name=_method_name)
if lsa_only in operation_list:
continue
method_helper = None
if lsa_only in method_map:
method_helper = method_map[lsa_only]
if lsa_only in mbean_info_map:
attribute_helper = mbean_info_map[lsa_only]
mbean_info_list.remove(lsa_only)
elif method_helper is not None:
attribute_helper = method_helper
else:
# Fake one up
attribute_helper = mbi_helper.get_attribute(lsa_only)
if self._is_valid_lsa(attribute_helper):
self.__logger.fine('MBean {0} attribute {1} that is in LSA and not MBI is found in the MBeanInfo : {2}',
mbean_type, lsa_only, Boolean(info_helper.get_attribute(lsa_only) is not None),
class_name=self.__class_name__, method_name=_method_name)
holder = all_utils.dict_obj()
# Not all LSA with -rw- really are -rw-. Might need to add in a physical attempt to set
# if to find attributes without a set method that CAN be set in offline.
# However, I suspect that if no set method, then cannot RW
self.add_default_value(holder, lsa_map, attribute_helper, method_helper)
if attribute_helper.is_attribute_found():
self.__logger.finer('MBean {0} attribute {1} in LSA map will generate attribute info '
'from additional helper', mbean_type, lsa_only,
class_name=self.__class_name__, method_name=_method_name)
attribute_helper.generate_attribute(holder)
else:
self.__logger.fine('MBean {0} attribute {1} is found only in the LSA map', mbean_type, lsa_only,
class_name=self.__class_name__, method_name=_method_name)
attributes[lsa_only] = all_utils.sort_dict(holder)
self.__logger.exiting(class_name=self.__class_name__, method_name=_method_name)
return all_utils.sort_dict(attributes)
def __create_any_subfolders(self):
_method_name = 'create_any_subfolders'
subfolder_list = all_utils.dict_obj()
operation_map = generator_wlst.ls_operations()
# create_by_operation_list = HashSet(operation_map.keySet())
# for operation in operation_map.keySet():
# if operation.startswith(CREATE) and not operation.endswith('FromBuiltin'):
# mbean_type = operation[len(CREATE):]
# name1, name2 = helper.mbean_name(mbean_type)
# if not do_operation(name1, operation) and not do_operation(name2, operation):
# create_by_operation_list.remove(operation)
checklist = generator_wlst.lsc_modified()
if checklist is None:
self.__logger.fine('WLSDPLYST-01320', generator_wlst.current_path(), '',
class_name=self.__class_name__, method_name=_method_name)
return subfolder_list
for check in checklist:
if check not in operation_map:
name_list = generator_wlst.ls_mbean_names(check)
if name_list is None:
self.__logger.finer('WLSDPLYST-01121', check, '',
class_name=self.__class_name__, method_name=_method_name)
continue
# if empty, it returns a str
if name_list and len(str(name_list).strip()) > 0:
subfolder_list[check] = name_list[0]
child_types = generator_wlst.child_mbean_types()
if child_types is not None:
for child_type in child_types:
if child_type not in subfolder_list:
name1, name2 = all_utils.mbean_name(child_type)
if generator_wlst.created(child_type, name1) or generator_wlst.created(child_type, name2):
name_list = generator_wlst.ls_mbean_names(child_type)
if name_list is not None and len(str(name_list).strip()) > 0:
subfolder_list[child_type] = name_list[0]
return subfolder_list
online_wlst_exception = _load_global('WLSTException')
local_ls = _load_global('ls')
try:
name_list = local_ls(mbean_type, returnMap='true')
except (offlineWLSTException, online_wlst_exception), we:
__logger.warning('Unable to ls({0}) at location {1} : {2}',
mbean_type,
current_path(),
str(we),
class_name=__class_name,
method_name=_method_name)
return None
if len(name_list) == 0:
__logger.warning(
'No MBean instance found for {0} at location {1} and was not in listChildTypes',
mbean_type,
current_path(),
class_name=__class_name,
method_name=_method_name)
return None
if len(name_list) > 1:
__logger.warning(
'Singleton MBean {0} has more than one instance at location {1}',
mbean_type,
current_path(),
class_name=__class_name,
method_name=_method_name)
return name_list[0]
def read_domain(domain_home):
"""