def _find_dictionary_merge_key(dictionary, new_key, variable_map):
"""
Find the key corresponding to new_key in the specified dictionary.
Determine if the new_key should completely replace the value in the dictionary.
If no direct match is found, and a variable map is specified, perform check with variable substitution.
If keys have the same name, but one has delete notation (!server), that is a match, and replace is true.
:param dictionary: the dictionary to be searched
:param new_key: the key being checked
:param variable_map: variables to be used for name resolution, or None
:return: tuple - the corresponding key from the dictionary, True if dictionary key should be replaced
"""
if new_key in dictionary:
return new_key, False
new_is_delete = deployer_utils.is_delete_name(new_key)
match_new_key = _get_merge_match_key(new_key, variable_map)
for dictionary_key in dictionary.keys():
dictionary_is_delete = deployer_utils.is_delete_name(dictionary_key)
match_dictionary_key = _get_merge_match_key(dictionary_key,
variable_map)
if match_dictionary_key == match_new_key:
replace_key = new_is_delete != dictionary_is_delete
return dictionary_key, replace_key
return None, False
def _merge_dictionaries(dictionary, new_dictionary, variable_map):
"""
Merge the values from the new dictionary to the existing one.
Use variables to resolve keys.
:param dictionary: the existing dictionary
:param new_dictionary: the new dictionary to be merged
:param variable_map: variables to be used for name resolution, or None
"""
for new_key in new_dictionary:
new_value = new_dictionary[new_key]
dictionary_key, replace_key = _find_dictionary_merge_key(
dictionary, new_key, variable_map)
# the key is not in the original dictionary, just add it
if dictionary_key is None:
dictionary[new_key] = new_value
# the new key should replace the existing one - delete the existing key and add the new one
elif replace_key:
del dictionary[dictionary_key]
if not deployer_utils.is_delete_name(new_key):
dictionary[new_key] = new_value
# the key is in both dictionaries - merge if the values are dictionaries, otherwise replace the value
else:
value = dictionary[dictionary_key]
if isinstance(value, dict) and isinstance(new_value, dict):
_merge_dictionaries(value, new_value, variable_map)
else:
dictionary[new_key] = new_value
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 deployer_utils.is_delete_name(group_name):
group_nodes = group_name_nodes[group_name]
name = deployer_utils.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 deployer_utils.is_delete_name(property_name):
name = deployer_utils.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 _create_named_mbeans(self, type_name, model_nodes, base_location, log_created=False):
"""
Create the specified type of MBeans that support multiple instances in the specified location.
:param type_name: the model folder type
:param model_nodes: the model dictionary of the specified model folder type
:param base_location: the base location object to use to create the MBeans
:param log_created: whether or not to log created at INFO level, by default it is logged at the FINE level
:raises: CreateException: if an error occurs
"""
_method_name = '_create_named_mbeans'
self.logger.entering(type_name, str(base_location), log_created,
class_name=self.__class_name, method_name=_method_name)
if model_nodes is None or len(model_nodes) == 0 or not self._is_type_valid(base_location, type_name):
return
location = LocationContext(base_location).append_location(type_name)
self._process_flattened_folder(location)
token_name = self.alias_helper.get_name_token(location)
create_path = self.alias_helper.get_wlst_create_path(location)
list_path = self.alias_helper.get_wlst_list_path(location)
existing_folder_names = self._get_existing_folders(list_path)
for model_name in model_nodes:
name = self.wlst_helper.get_quoted_name_for_wlst(model_name)
if deployer_utils.is_delete_name(name):
deployer_utils.delete_named_element(location, name, existing_folder_names, self.alias_helper)
continue
if token_name is not None:
location.add_name_token(token_name, name)
wlst_type, wlst_name = self.alias_helper.get_wlst_mbean_type_and_name(location)
if wlst_name not in existing_folder_names:
if log_created:
self.logger.info('WLSDPLY-12100', type_name, name,
class_name=self.__class_name, method_name=_method_name)
else:
self.logger.fine('WLSDPLY-12100', type_name, name,
class_name=self.__class_name, method_name=_method_name)
self.wlst_helper.create_and_cd(self.alias_helper, wlst_type, wlst_name, location, create_path)
else:
if log_created:
self.logger.info('WLSDPLY-12101', type_name, name,
class_name=self.__class_name, method_name=_method_name)
else:
self.logger.fine('WLSDPLY-12101', type_name, name,
class_name=self.__class_name, method_name=_method_name)
attribute_path = self.alias_helper.get_wlst_attributes_path(location)
self.wlst_helper.cd(attribute_path)
child_nodes = dictionary_utils.get_dictionary_element(model_nodes, name)
self._process_child_nodes(location, child_nodes)
self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
return
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
"""
if variable_map is not None:
match_key = variables.substitute_key(key, variable_map)
else:
match_key = key
if deployer_utils.is_delete_name(match_key):
match_key = deployer_utils.get_delete_item_name(match_key)
return match_key
def create_placeholder_named_elements(self, location, model_type,
model_nodes):
"""
Create a placeholder entry for each element in the specified named element nodes.
This is necessary when there can be circular references with other elements.
:param location: the location for the nodes to be added
:param model_type: the type of the specified model nodes
:param model_nodes: the model nodes
"""
_method_name = 'create_placeholder_named_elements'
original_location = self.wlst_helper.get_pwd()
resource_location = LocationContext(location).append_location(
model_type)
if self.alias_helper.get_wlst_mbean_type(
resource_location) is not None:
existing_names = deployer_utils.get_existing_object_list(
resource_location, self.alias_helper)
name_nodes = dictionary_utils.get_dictionary_element(
model_nodes, model_type)
for name in name_nodes:
if deployer_utils.is_delete_name(name):
# don't create placeholder for delete names
continue
if name not in existing_names:
self.logger.info('WLSDPLY-19403',
model_type,
name,
class_name=self.__class_name,
method_name=_method_name)
token = self.alias_helper.get_name_token(resource_location)
resource_location.add_name_token(token, name)
deployer_utils.create_and_cd(resource_location,
existing_names,
self.alias_helper)
self.wlst_helper.cd(original_location)
def _add_named_elements(self, type_name, model_nodes, location):
"""
Add each named element from the specified nodes in WLST and set its attributes.
Sub-folders are processed in a generic manner if present.
It is assumed that there are no attributes or sub-folders with special processing.
:param type_name: the type name of the child nodes
:param model_nodes: the child nodes of a model element
:param location: the location where elements should be added
"""
_method_name = '_add_named_elements'
if len(model_nodes) == 0:
return
parent_type, parent_name = self.get_location_type_and_name(location)
location = LocationContext(location).append_location(type_name)
if not self._check_location(location):
return
deployer_utils.check_flattened_folder(location, self.alias_helper)
existing_names = deployer_utils.get_existing_object_list(location, self.alias_helper)
token = self.alias_helper.get_name_token(location)
for name in model_nodes:
if deployer_utils.is_delete_name(name):
deployer_utils.delete_named_element(location, name, existing_names, self.alias_helper)
continue
is_add = name not in existing_names
log_helper.log_updating_named_folder(type_name, name, parent_type, parent_name, is_add, self._class_name,
_method_name)
if token is not None:
location.add_name_token(token, name)
deployer_utils.create_and_cd(location, existing_names, self.alias_helper)
child_nodes = dictionary_utils.get_dictionary_element(model_nodes, name)
self._set_attributes_and_add_subfolders(location, child_nodes)
return