def delete_named_element(location, delete_name, existing_names, aliases):
"""
Delete the specified named element if present. If the name is not present, log a warning and return.
:param location: the location of the element to be deleted
:param delete_name: the name of the element to be deleted, assumed to include the "!" prefix
:param existing_names: a list of names to check against
:param aliases: alias helper for lookups
"""
_method_name = 'delete_named_element'
name = model_helper.get_delete_item_name(delete_name)
type_name = aliases.get_wlst_mbean_type(location)
if name not in existing_names:
_logger.warning('WLSDPLY-09109',
type_name,
name,
class_name=_class_name,
method_name=_method_name)
else:
_logger.info('WLSDPLY-09110',
type_name,
name,
class_name=_class_name,
method_name=_method_name)
type_path = aliases.get_wlst_create_path(location)
_wlst_helper.cd(type_path)
_wlst_helper.delete(name, type_name)
def _add_group_params(self, group_name_nodes, location):
"""
Add each group param entry from group name nodes and set its attributes.
A two-pass approach is required since the new folder's name does not always match the group name.
Special processing for error destination attributes (build mbean)
:param group_name_nodes: the nodes containing group parameter names
:param location: the WLST location where the parameters should be added
"""
_method_name = '_add_group_params'
if len(group_name_nodes) == 0:
return
# use a copy of the dictionary to remove items as they are deleted
remaining_name_nodes = group_name_nodes.copy()
parent_type, parent_name = self.get_location_type_and_name(location)
template_path = self.alias_helper.get_wlst_subfolders_path(location)
groups_location = LocationContext(location)
groups_location.append_location(GROUP_PARAMS)
groups_token = self.alias_helper.get_name_token(groups_location)
name_attribute = self.alias_helper.get_wlst_attribute_name(groups_location, SUB_DEPLOYMENT_NAME)
mbean_type = self.alias_helper.get_wlst_mbean_type(groups_location)
for group_name in group_name_nodes:
if model_helper.is_delete_name(group_name):
group_nodes = group_name_nodes[group_name]
name = model_helper.get_delete_item_name(group_name)
sub_name = self._get_subdeployment_name(group_nodes, name)
self._delete_mapped_mbean(groups_location, groups_token, mbean_type, name_attribute, sub_name)
del remaining_name_nodes[group_name]
# loop once to create and name any missing folders.
folder_map = self._build_folder_map(groups_location, groups_token, name_attribute)
for group_name in remaining_name_nodes:
group_nodes = remaining_name_nodes[group_name]
sub_deployment_name = self._get_subdeployment_name(group_nodes, group_name)
folder_name = dictionary_utils.get_element(folder_map, sub_deployment_name)
if folder_name is None:
self.wlst_helper.cd(template_path)
group = self.wlst_helper.create(sub_deployment_name, mbean_type)
group.setSubDeploymentName(sub_deployment_name)
# loop a second time to set attributes
new_folder_map = self._build_folder_map(groups_location, groups_token, name_attribute)
for group_name in remaining_name_nodes:
group_nodes = remaining_name_nodes[group_name]
sub_deployment_name = self._get_subdeployment_name(group_nodes, group_name)
is_add = sub_deployment_name not in folder_map
log_helper.log_updating_named_folder(GROUP_PARAMS, group_name, parent_type, parent_name, is_add,
self._class_name, _method_name)
folder_name = dictionary_utils.get_element(new_folder_map, sub_deployment_name)
groups_location.add_name_token(groups_token, folder_name)
self.wlst_helper.cd(self.alias_helper.get_wlst_attributes_path(groups_location))
self.set_attributes(groups_location, group_nodes)
def _add_jndi_properties(self, property_name_nodes, location):
"""
Add each property entry from property nodes and set its attributes.
A two-pass approach is required since the new folder's name does not always match the property name.
:param property_name_nodes: the nodes containing property names
:param location: the WLST location where the properties should be added
"""
_method_name = '_add_jndi_properties'
if len(property_name_nodes) == 0:
return
# use a copy of the dictionary to remove items as they are deleted
remaining_name_nodes = property_name_nodes.copy()
parent_type, parent_name = self.get_location_type_and_name(location)
is_online = self.wlst_mode == WlstModes.ONLINE
if is_online and deployer_utils.is_in_resource_group_or_template(location):
self.logger.info('WLSDPLY-09501', JNDI_PROPERTY, parent_type, parent_name, class_name=self._class_name,
method_name=_method_name)
return
foreign_server_path = self.alias_helper.get_wlst_subfolders_path(location)
properties_location = LocationContext(location).append_location(JNDI_PROPERTY)
properties_token = self.alias_helper.get_name_token(properties_location)
name_attribute = self.alias_helper.get_wlst_attribute_name(properties_location, KEY)
mbean_type = self.alias_helper.get_wlst_mbean_type(properties_location)
for property_name in property_name_nodes:
if model_helper.is_delete_name(property_name):
name = model_helper.get_delete_item_name(property_name)
self._delete_mapped_mbean(properties_location, properties_token, mbean_type, name_attribute, name)
del remaining_name_nodes[property_name]
# loop once to create and name any missing folders.
folder_map = self._build_folder_map(properties_location, properties_token, name_attribute)
for property_name in remaining_name_nodes:
folder_name = dictionary_utils.get_element(folder_map, property_name)
if folder_name is None:
self.wlst_helper.cd(foreign_server_path)
new_property = self.wlst_helper.create(property_name, mbean_type)
new_property.setKey(property_name)
# loop a second time to set attributes
new_folder_map = self._build_folder_map(properties_location, properties_token, name_attribute)
for property_name in remaining_name_nodes:
is_add = property_name not in folder_map
log_helper.log_updating_named_folder(JNDI_PROPERTY, property_name, parent_type, parent_name, is_add,
self._class_name, _method_name)
folder_name = dictionary_utils.get_element(new_folder_map, property_name)
properties_location.add_name_token(properties_token, folder_name)
self.wlst_helper.cd(self.alias_helper.get_wlst_attributes_path(properties_location))
property_nodes = remaining_name_nodes[property_name]
self.set_attributes(properties_location, property_nodes)
def _get_merge_match_key(key, variable_map):
"""
Get the key name to use for matching in model merge.
This includes resolving any variables, and removing delete notation if present.
:param key: the key to be examined
:param variable_map: variable map to use for substitutions
:return: the key to use for matching
"""
match_key = variables.substitute_key(key, variable_map)
if model_helper.is_delete_name(match_key):
match_key = model_helper.get_delete_item_name(match_key)
return match_key
def merge_model_and_existing_lists(model_list, existing_list, location_path="(unknown)", attribute_name="(unknown)"):
"""
Merge the two lists so that the resulting list contains all of the elements in both lists one time.
:param model_list: the list to merge, possibly a string or None
:param existing_list: the existing list, possibly a string or None
:param location_path: optional, the path of the attribute location, for logging
:param attribute_name: optional, the attribute name, for logging
:return: the merged list as a list or a string, depending on the type of the model_list
:raises: DeployException: if either list is not either a string or a list
"""
_method_name = 'merge_model_and_existing_lists'
_logger.entering(model_list, existing_list, location_path, attribute_name, class_name=_class_name,
method_name=_method_name)
if model_list is None:
result_is_string = isinstance(existing_list, basestring)
else:
result_is_string = isinstance(model_list, basestring)
result = create_list(existing_list, 'WLSDPLY-08001')
model_iterator = create_list(model_list, 'WLSDPLY-08000')
for item in model_iterator:
if model_helper.is_delete_name(item):
item_name = model_helper.get_delete_item_name(item)
if item_name in result:
result.remove(item_name)
else:
_logger.warning('WLSDPLY-08022', item_name, attribute_name, location_path, class_name=_class_name,
method_name=_method_name)
elif item not in result:
result.append(item)
if result_is_string:
result = MODEL_LIST_DELIMITER.join(result)
_logger.exiting(class_name=_class_name, method_name=_method_name, result=result)
return result
def __delete_online_targets(app_deployments, model_type, aliases):
"""
For online deploy and update, remove any deleted targets from existing objects of the specified type.
Objects may be applications or libraries.
:param app_deployments: the APP_DEPLOYMENTS dictionary from the model
:param model_type: map of library targets to be deleted
:param aliases: the parent location of the apps and libraries
"""
_method_name = '__delete_online_targets'
location = LocationContext().append_location(model_type)
wlst_path = aliases.get_wlst_list_path(location)
wlst_names = _wlst_helper.get_existing_object_list(wlst_path)
name_token = aliases.get_name_token(location)
deploy_dict = dictionary_utils.get_dictionary_element(app_deployments, model_type)
for deploy_name in deploy_dict.keys():
if deploy_name in wlst_names:
value_dict = deploy_dict[deploy_name]
delete_names = []
model_targets = dictionary_utils.get_element(value_dict, TARGET)
targets = alias_utils.create_list(model_targets, 'WLSDPLY-08000')
for target in targets:
if model_helper.is_delete_name(target):
delete_names.append(model_helper.get_delete_item_name(target))
location.add_name_token(name_token, deploy_name)
mbean_path = aliases.get_wlst_attributes_path(location)
mbean = _wlst_helper.get_mbean_for_wlst_path(mbean_path)
mbean_targets = mbean.getTargets()
for mbean_target in mbean_targets:
mbean_name = mbean_target.getName()
if mbean_name in delete_names:
_logger.info('WLSDPLY-09114', mbean_name, model_type, deploy_name, class_name=_class_name,
method_name=_method_name)
mbean.removeTarget(mbean_target)
