class TargetHelper(object):
"""
Shared code for targeting clusters and servers. Domain create and update use this code.
"""
__class_name = 'TargetHelper'
def __init__(self, model, model_context, aliases, exception_type, logger):
self.logger = logger
self.model = model
self.model_context = model_context
self.alias_helper = AliasHelper(aliases, self.logger, exception_type)
self.wlst_helper = WlstHelper(self.logger, exception_type)
self.exception_type = exception_type
topology = model.get_model_topology()
if ADMIN_SERVER_NAME in topology:
self._admin_server_name = topology[ADMIN_SERVER_NAME]
else:
self._admin_server_name = DEFAULT_ADMIN_SERVER_NAME
def target_jrf_groups_to_clusters_servers(self, should_update=True):
"""
Call applyJRF to for those versions of wlst that cannot target servers to server groups.
This assigns the JRF resources to all managed servers. If the managed server is in a
cluster, this method assigns the JRF resources are assigned to the cluster. Else, if
the managed server is stand-alone, the resources are assigned to the managed server.
:param should_update: Control how the applyJRF applies the changes. By default, allow
the applyJRF to automatically update the values
"""
_method_name = 'target_jrf_groups_to_clusters_servers'
self.logger.entering(should_update, class_name=self.__class_name,
method_name=_method_name)
location = LocationContext()
root_path = self.alias_helper.get_wlst_attributes_path(location)
self.wlst_helper.cd(root_path)
admin_server_name = self.wlst_helper.get(ADMIN_SERVER_NAME)
# We need to get the effective list of servers for the domain. Since any servers
# referenced in the model have already been created but the templates may have
# defined new servers not listed in the model, get the list from WLST.
server_names = self.get_existing_server_names()
if admin_server_name in server_names:
server_names.remove(admin_server_name)
# Get the clusters and and their members
cluster_map = self._get_clusters_and_members_map()
self.wlst_helper.save_and_close(self.model_context)
# Get the clusters and and their members
for cluster_name, cluster_servers in cluster_map.iteritems():
self.logger.info('WLSDPLY-12233', 'Cluster', cluster_name, class_name=self.__class_name,
method_name=_method_name)
self.wlst_helper.apply_jrf(cluster_name, self.model_context, should_update=should_update)
for member in cluster_servers:
if member in server_names:
server_names.remove(member)
for ms_name in server_names:
self.logger.info('WLSDPLY-12233', 'Managed Server', ms_name, class_name=self.__class_name,
method_name=_method_name)
self.wlst_helper.apply_jrf(ms_name, self.model_context, should_update=should_update)
self.wlst_helper.reopen(self.model_context)
self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
return
def target_server_groups_to_servers(self, server_groups_to_target):
"""
Target the server groups to the servers.
:param server_groups_to_target: the list of server groups to target
:raises: BundleAwareException of the specified type: if an error occurs
"""
_method_name = 'target_server_groups_to_servers'
self.logger.entering(server_groups_to_target, class_name=self.__class_name, method_name=_method_name)
if len(server_groups_to_target) == 0:
return list(), list()
location = LocationContext()
root_path = self.alias_helper.get_wlst_attributes_path(location)
self.wlst_helper.cd(root_path)
# We need to get the effective list of servers for the domain. Since any servers
# referenced in the model have already been created but the templates may have
# defined new servers not listed in the model, get the list from WLST.
server_names = self._get_existing_server_names()
# Get the clusters and and their members
cluster_map = self._get_clusters_and_members_map()
dynamic_cluster_names = list()
for cluster_name in cluster_map:
if DYNAMIC_SERVERS in cluster_map[cluster_name]:
dynamic_cluster_names.append(cluster_name)
# Get any limits that may have been defined in the model
domain_info = self.model.get_model_domain_info()
server_group_targeting_limits = \
dictionary_utils.get_dictionary_element(domain_info, SERVER_GROUP_TARGETING_LIMITS)
if len(server_group_targeting_limits) > 0:
server_group_targeting_limits = \
self._get_server_group_targeting_limits(server_group_targeting_limits, cluster_map)
self.logger.finer('WLSDPLY-12240', str(server_group_targeting_limits),
class_name=self.__class_name, method_name=_method_name)
# Get the map of server names to server groups to target
server_to_server_groups_map =\
self._get_server_to_server_groups_map(self._admin_server_name,
server_names,
dynamic_cluster_names,
server_groups_to_target,
server_group_targeting_limits) # type: dict
self.logger.finer('WLSDPLY-12242', str(server_to_server_groups_map), class_name=self.__class_name,
method_name=_method_name)
final_assignment_map = dict()
dynamic_cluster_assigns = dict()
# Target servers and dynamic clusters to the server group resources
if len(server_names) > 0 or len(dynamic_cluster_names) > 0:
for server, server_groups in server_to_server_groups_map.iteritems():
if len(server_groups) > 0:
if server in server_names:
final_assignment_map[server] = server_groups
elif server in dynamic_cluster_names:
dynamic_cluster_assigns[server] = server_groups
#
# Domain has not targeted the server groups to managed servers (configured), or the
# domain has no managed servers (configured) but has user server groups. The resources for the
# user server groups must be targeted before the write/update domain or the write/update will fail.
# Thus assign the user server groups to the admin server.
#
# Because of the interaction of the working context in the different wlst helpers, the dynamic
# clusters will be applied to the resources separately and after the write/update domain.
#
# (From original blurb)
# This is really a best effort attempt. It works for JRF domains but it is certainly possible
# that it may cause problems with other custom domain types. Of course, creating a domain with
# no managed servers is not a primary use case of this tool so do it and hope for the best...
#
# (New comment)
# As we have added the intricacies of the dynamic clusters, if the targeting is to dynamic
# clusters only, the set server groups with the admin server will get through the write/update domain
# and the applyJRF with the dynamic cluster should theoretically unset the AdminServer on the user server
# groups. It works with JRF type domains.
if len(server_groups_to_target) > 0:
if len(final_assignment_map) == 0:
# This is a quickie to fix the issue where server groups are not targeted because no configured
# managed servers exist in the domain
final_assignment_map[server_names[0]] = server_groups_to_target
else:
# If a server group or groups is not targeted in the assignments, log it to stdout
no_targets = [server_target for server_target in server_groups_to_target if server_target not in
[server_target for row in final_assignment_map.itervalues() for
server_target in server_groups_to_target if server_target in row]]
if len(no_targets) > 0:
self.logger.info('WLSDPLY-12248', no_targets,
class_name=self.__class_name, method_name=_method_name)
self.logger.exiting(result=str(dynamic_cluster_assigns),
class_name=self.__class_name, method_name=_method_name)
return final_assignment_map, dynamic_cluster_assigns
def target_server_groups(self, server_assigns):
"""
Perform the targeting of the server groups to server from the list of assignments made in the
target helper assignment step. This is separate from creating the list of assignments in order
to control the state of the domain when the target is done.
:param server_assigns: map of server to server group
"""
_method_name = 'target_server_groups'
self.logger.entering(str(server_assigns), class_name=self.__class_name, method_name=_method_name)
for server, server_groups in server_assigns.iteritems():
server_name = self.wlst_helper.get_quoted_name_for_wlst(server)
self.logger.info('WLSDPLY-12224', str(server_groups), server_name,
class_name=self.__class_name, method_name=_method_name)
self.wlst_helper.set_server_groups(server_name, server_groups)
self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
def target_server_groups_to_dynamic_clusters(self, dynamic_cluster_assigns):
"""
Dynamic clusters need special handling to assign the server group resources to the dynamic cluster.
You cannot assign servergroups to a server template. So must search each templates that contain the server group
for resources and specifically add the dynamic target to the resource target.
If JRF or RestrictedJRF skip the check and do the applyJRF function to automatically target to the cluster.
:param dynamic_cluster_assigns: The assignments from domainInfo targeting limits applied to dynamic lusters
"""
_method_name = 'target_server_group_resources_to_dyanamic_cluster'
self.logger.entering(str(dynamic_cluster_assigns), class_name=self.__class_name, method_name=_method_name)
domain_typedef = self.model_context.get_domain_typedef()
if len(dynamic_cluster_assigns) > 0:
self.logger.info('WLSDPLY-12247', class_name=self.__class_name, method_name=_method_name)
# TBD assign server group resources to cluster. The JRF resources could still be applied separately
# using this technique - or remove this technique and replace with the resource targeting
if domain_typedef.has_jrf_resources():
self._target_jrf_resources(dynamic_cluster_assigns)
else:
self.logger.warning('WLSDPLY-12238', domain_typedef.get_domain_type(),
class_name=self.__class_name, method_name=_method_name)
self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
return
def _target_jrf_resources(self, dynamic_cluster_assigns):
# Target the JRF resources directly using the applyJRF method.
_method_name = '_target_jrf_resources'
names_only = list()
for name in dynamic_cluster_assigns:
names_only.append(name)
if self.model_context.is_wlst_online() and \
self.model_context.get_domain_typedef().is_restricted_jrf_domain_type():
self.logger.warning('WLSDPLY-12244', str(names_only), class_name=self.__class_name,
_method_name=_method_name)
else:
self.logger.info('WLSDPLY-12236', str(names_only),
class_name=self.__class_name, method_name=_method_name)
self.wlst_helper.apply_jrf_control_updates(names_only, self.model_context)
def _get_existing_server_names(self):
"""
Get the list of server names from WLST.
:return: the list of server names
:raises: BundleAwareException of the specified type: is an error occurs reading from the aliases or WLST
"""
_method_name = '_get_existing_server_names'
self.logger.entering(class_name=self.__class_name, method_name=_method_name)
server_location = LocationContext().append_location(SERVER)
server_list_path = self.alias_helper.get_wlst_list_path(server_location)
result = self.wlst_helper.get_existing_object_list(server_list_path)
self.logger.exiting(class_name=self.__class_name, method_name=_method_name, result=result)
return result
def _get_clusters_and_members_map(self):
"""
Get a map keyed by cluster name with values that are a list of member server names
:return: the cluster name to member server names map
:raises: BundleAwareException of the specified type: is an error occurs reading from the aliases or WLST
"""
_method_name = '_get_clusters_and_members_map'
self.logger.entering(class_name=self.__class_name, method_name=_method_name)
server_location = LocationContext().append_location(SERVER)
server_list_path = self.alias_helper.get_wlst_list_path(server_location)
server_names = self.wlst_helper.get_existing_object_list(server_list_path)
server_token = self.alias_helper.get_name_token(server_location)
cluster_map = OrderedDict()
for server_name in server_names:
server_location.add_name_token(server_token, server_name)
server_attributes_path = self.alias_helper.get_wlst_attributes_path(server_location)
self.wlst_helper.cd(server_attributes_path)
server_attributes_map = self.wlst_helper.lsa()
cluster_name = dictionary_utils.get_element(server_attributes_map, CLUSTER)
if string_utils.is_empty(cluster_name):
# if server is not part of a cluster, continue with the next server
continue
if cluster_name not in cluster_map:
cluster_map[cluster_name] = list()
cluster_map[cluster_name].append(server_name)
clusters_location = LocationContext().append_location(CLUSTER)
cluster_list_path = self.alias_helper.get_wlst_list_path(clusters_location)
cluster_names = self.wlst_helper.get_existing_object_list(cluster_list_path)
cluster_token = self.alias_helper.get_name_token(clusters_location)
# Add the cluster with dynamic servers, if not already in the cluster member list.
# A cluster may contain both dynamic and configured servers (referred to as mixed cluster).
# Add a token marking DYNAMIC SERVERS in the member list.
for cluster_name in cluster_names:
cluster_location = LocationContext(clusters_location)
cluster_location.add_name_token(cluster_token, cluster_name)
cluster_attributes_path = self.alias_helper.get_wlst_attributes_path(cluster_location)
self.wlst_helper.cd(cluster_attributes_path)
cluster_location.append_location(DYNAMIC_SERVERS)
wlst_subfolder_name = self.alias_helper.get_wlst_mbean_type(cluster_location)
if self.wlst_helper.subfolder_exists(wlst_subfolder_name):
if cluster_name not in cluster_map:
cluster_map[cluster_name] = list()
cluster_map[cluster_name].append(DYNAMIC_SERVERS)
self.logger.exiting(class_name=self.__class_name, method_name=_method_name, result=cluster_map)
return cluster_map
def get_existing_server_names(self):
"""
Get the list of server names from WLST.
:return: the list of server names
:raises: BundleAwareException of the specified type: is an error occurs reading from the aliases or WLST
"""
_method_name = '_get_existing_server_names'
self.logger.entering(class_name=self.__class_name, method_name=_method_name)
server_location = LocationContext().append_location(SERVER)
server_list_path = self.alias_helper.get_wlst_list_path(server_location)
result = self.wlst_helper.get_existing_object_list(server_list_path)
self.logger.exiting(class_name=self.__class_name, method_name=_method_name, result=result)
return result
def get_existing_cluster_names(self):
"""
Get the list of cluster names from WLST.
:return: the list of cluster names
:raises: BundleAwareException of the specified type: is an error occurs reading from the aliases or WLST
"""
_method_name = 'get_existing_cluster_names'
self.logger.entering(class_name=self.__class_name, method_name=_method_name)
cluster_location = LocationContext().append_location(CLUSTER)
cluster_list_path = self.alias_helper.get_wlst_list_path(cluster_location)
result = self.wlst_helper.get_existing_object_list(cluster_list_path)
self.logger.exiting(class_name=self.__class_name, method_name=_method_name, result=result)
return result
def _get_server_group_targeting_limits(self, server_group_targeting_limits, clusters_map):
"""
Get any server group targeting limits specified in the model, converting any cluster
names to the list of members. This method assumes that the limits dictionary is not
None or empty.
:param server_group_targeting_limits: the raw server group targeting_limits from the model
:param clusters_map: the map of cluster names to member server names
:return: the map of server groups to server names to target
"""
_method_name = '_get_server_group_targeting_limits'
self.logger.entering(str(server_group_targeting_limits), str(clusters_map),
class_name=self.__class_name, method_name=_method_name)
sg_targeting_limits = copy.deepcopy(server_group_targeting_limits)
for server_group_name, sg_targeting_limit in sg_targeting_limits.iteritems():
if type(sg_targeting_limit) is str:
if MODEL_LIST_DELIMITER in sg_targeting_limit:
sg_targeting_limit = sg_targeting_limit.split(MODEL_LIST_DELIMITER)
else:
# convert a single value into a list of one...
new_list = list()
new_list.append(sg_targeting_limit)
sg_targeting_limit = new_list
# Convert any references to a cluster name into the list of member server names
new_list = list()
for target_name in sg_targeting_limit:
target_name = target_name.strip()
if target_name in clusters_map:
cluster_members = dictionary_utils.get_element(clusters_map, target_name)
if DYNAMIC_SERVERS in cluster_members:
# This will need special handling to target server group resources
cluster_members.remove(DYNAMIC_SERVERS)
cluster_members.append(target_name)
new_list.extend(cluster_members)
else:
# Assume it is a server name and add it to the new list
# Stand-alone Managed Servers were not added to the cluster: server_name_list map
# which was built from the existing servers and clusters.
new_list.append(target_name)
sg_targeting_limits[server_group_name] = new_list
self.logger.exiting(class_name=self.__class_name, method_name=_method_name, result=sg_targeting_limits)
return sg_targeting_limits
def _get_server_to_server_groups_map(self, admin_server_name, server_names, dynamic_cluster_names,
server_groups, sg_targeting_limits):
"""
Get the map of server names to the list of server groups to target to that server.
:param admin_server_name: the admin server name
:param server_names: the list of server names
:param server_groups: the complete list of server groups that will, by default, be targeted to
all managed servers unless the server is listed in the targeting limits map
:param sg_targeting_limits: the targeting limits map
:return: the map of server names to the list of server groups to target to that server
"""
_method_name = '_get_server_to_server_groups_map'
self.logger.entering(admin_server_name, str(server_names), str(server_groups), str(sg_targeting_limits),
class_name=self.__class_name, method_name=_method_name)
result = OrderedDict()
revised_server_groups = self._revised_list_server_groups(server_groups, sg_targeting_limits)
for server_name in server_names:
server_groups_for_server = self.__get_server_groups_for_entity(server_name, sg_targeting_limits)
if len(server_groups_for_server) > 0:
result[server_name] = server_groups_for_server
elif server_name != admin_server_name:
# By default, we only target managed servers unless explicitly listed in the targeting limits
result[server_name] = list(revised_server_groups)
else:
result[admin_server_name] = list()
for cluster_name in dynamic_cluster_names:
server_groups_for_cluster = \
self.__get_server_groups_for_entity(cluster_name, sg_targeting_limits)
if len(server_groups_for_cluster) > 0:
result[cluster_name] = server_groups_for_cluster
else:
result[cluster_name] = list(revised_server_groups)
self.logger.finer('WLSDPLY-12239', result[cluster_name], cluster_name,
class_name=self.__class_name, method_name=_method_name)
if admin_server_name not in result:
result[admin_server_name] = list()
self.logger.exiting(class_name=self.__class_name, method_name=_method_name, result=result)
return result
def _revised_list_server_groups(self, server_groups, sg_targeting_limits):
"""
Remove all server groups that are explicitly targeted to a cluster, server set or stand-alone
managed server.
:param server_groups: list of server groups applied by the extension templates
:param sg_targeting_limits: list of targeting from the domainInfo section
:return: server group list with the specific targeted server groups removed
"""
_method_name = '_revised_list_server_groups'
self.logger.entering(sg_targeting_limits, class_name=self.__class_name, method_name=_method_name)
result = list()
targeted_server_groups = sg_targeting_limits.keys()
for server_group in server_groups:
if server_group not in targeted_server_groups:
result.append(server_group)
return result
def __get_server_groups_for_entity(self, entity_name, sg_targeting_limits):
"""
Get the servers groups to target for a given server or dynamic cluster name.
:param entity_name: the server or dynamic_cluster name
:param sg_targeting_limits: the targeting limits
:return: the list of server groups to target to the specified entity name, or None
if the entity name does not appear in the targeting limits
"""
_method_name = '__get_server_groups_for_entity'
result = list()
for server_group, entity_names_list in sg_targeting_limits.iteritems():
if entity_name in entity_names_list:
result.append(server_group)
if len(result) > 0:
self.logger.fine('WLSDPLY-12243', entity_name, result, class_name=self.__class_name,
method_name=_method_name)
return result
class MBeanUtils(object):
"""
Utility class used to provide information about WLST attributes as retrieved from the MBeans MBeanInfo or Interface
methods. This class has methods to provide the information stored in different combinations. All methods that want
to combine the information from the MBeans helpers into different combinations are located in this class.
"""
def __init__(self, model_context, alias_helper, exception_type):
self.__model_context = model_context
self.__exception_type = exception_type
self.__alias_helper = alias_helper
self.__wlst_helper = WlstHelper(_logger, exception_type)
self.__helper = self.__get_helper()
self.__ignore_list = None
def get_attributes_not_in_lsa_map(self, location, lsa_map=None):
"""
Return a list of all attributes from the MBeans MBeanInfo or Interface methods that are not contained in the LSA
attributes for the location in the location context.
:param location: current location context of the MBean
:param lsa_map: map returned from WLST ls('a') or None to get the LSA map from the current location context
:return: Any additional attributes or empty list if None found
"""
_method_name = 'get_attributes_not_in_lsa_map'
_logger.entering(location.get_folder_path(),
class_name=self.__class__.__name__,
method_name=_method_name)
mbean_attributes = self.__collapse_attributes(location)
lsa_attributes = self.__get_lsa_attributes(location, lsa_map)
loose_attributes = [
attribute for attribute in mbean_attributes
if not self.__helper.is_attribute_in_lsa_map(
attribute, lsa_attributes)
]
_logger.exiting(class_name=self.__class__.__name__,
method_name=_method_name,
result=loose_attributes)
return loose_attributes
def get_info_attribute_helper(self, location):
"""
Get a wrapper for the MBeanInfo attribute information for the current MBean designated in the location context.
:param location: containing the current MBean context
:return: MBeanAttributes class wrapping the MBeanInfo attributes with convenience methods
"""
return self.__get_info_helper(location)
def get_mbean_info_attributes(self, location=None, helper=None):
"""
Get a list of attribute names for the MBean using the MBeanInfoAttributes wrapper class.
If the helper is not provided, use the location arg to create an instance of the helper
for the MBean designated in the location context.
:param location: If helper is None, the location is required to create the helper instance
:param helper: If not None, the provided helper is used to return the attribute information. The
location arg is not required if helper is provided.
:return: List of attribute names for the MBean
"""
if helper is None:
helper = self.get_info_attribute_helper(location)
return self.get_mbean_attributes(helper)
def get_interface_attribute_helper(self, location):
"""
Return an instance of the InterfaceAttributes helper class for the MBean indicated in the location context.
:param location: context for the current MBean location
:return: InterfaceAttributes helper instance
"""
return self.__get_interface_helper(location)
def get_interface_attributes(self, location=None, helper=None):
"""
Get a list of attribute names for the MBean using the InterfaceAttributes wrapper class.
If the helper is not provided, use the location arg to create an instance of the helper
for the MBean designated in the location context.
:param location: If helper is None, the location is required to create the helper instance
:param helper: If not None, the provided helper is used to return the attribute information. The
location arg is not required if helper is provided.
:return: List of attribute names for the MBean
"""
if helper is None:
helper = self.get_interface_attribute_helper(location)
return self.get_mbean_attributes(helper)
def get_mbean_attributes(self, helper):
"""
Return a list of the MBean attribute names through the MBean attribute helper.
:param helper: MBeanAttributes helper class
:return: list of MBean attribute names
"""
return helper.get_mbean_attributes()
def __collapse_attributes(self, location):
_method_name = '__filter_attributes'
info_helper = self.__get_info_helper(location)
info_attributes = self.get_mbean_attributes(info_helper)
interface_helper = self.__get_interface_helper(location)
interface_attributes = self.get_mbean_attributes(interface_helper)
self.__remove_duplicates(interface_attributes, str(interface_helper),
info_attributes, str(info_helper))
# This is the main list to drive from
info_attributes = self.__slim_list(info_attributes, info_helper)
# Because there are very few valid attributes in the Interface methods that are not in either the LSA map
# or MBeanInfo PropertyDescriptors, remove all the read_only attributes
interface_attributes = self.__slim_list(interface_attributes,
interface_helper,
remove_readonly=True)
consolidated = list()
consolidated.extend(info_attributes)
consolidated.extend(interface_attributes)
_logger.finer('WLSDPLY-01787',
consolidated,
class_name=self.__class__.__name__,
method_name=_method_name)
return consolidated
def __slim_list(self, attributes, attribute_helper, remove_readonly=False):
return [
attribute for attribute in attributes
if not (self.__in_ignore(attribute)
or attribute_helper.is_child_mbean(attribute) or
(remove_readonly
and attribute_helper.is_read_only(attribute)) or self.
__is_clear_text_encrypted(attribute, attribute_helper) or
# The following should always be the final elimination step
not attribute_helper.is_valid_getter(attribute))
]
def __get_info_helper(self, location):
return MBeanInfoAttributes(self.__model_context, self.__alias_helper,
self.__exception_type, location)
def __get_interface_helper(self, location):
return InterfaceAttributes(self.__model_context, self.__alias_helper,
self.__exception_type, location)
def __remove_duplicates(self, check_list, check_list_type, main_list,
main_list_type):
_method_name = '__remove_duplicates'
_logger.entering(len(check_list),
len(main_list),
class_name=self.__class__.__name__,
method_name=_method_name)
for attribute in main_list:
if attribute in check_list:
check_list.remove(attribute)
else:
_logger.fine('WLSDPLY-01788',
attribute,
check_list_type,
main_list_type,
class_name=self.__class__.__name__,
method_name=_method_name)
_logger.exiting(class_name=self.__class__.__name__,
method_name=_method_name,
result=len(check_list))
def __is_clear_text_encrypted(self, attribute_name, attribute_helper):
if not attribute_name.endswith('Encrypted'):
return attribute_helper.is_encrypted(attribute_name + 'Encrypted')
return False
def __get_ignore_attributes(self):
_method_name = '__get_ignore_attributes'
if self.__ignore_list is None:
self.__ignore_list = self.__alias_helper.get_ignore_attribute_names(
)
_logger.finer('WLSDPLY-01779',
self.__ignore_list,
class_name=self.__class__.__name__,
method_name=_method_name)
return self.__ignore_list
def __in_ignore(self, attribute_name):
return attribute_name in self.__get_ignore_attributes()
def __get_helper(self):
if self.__model_context.get_target_wlst_mode() == WlstModes.OFFLINE:
helper = OfflineMBeanHelper(self.__model_context,
self.__exception_type)
else:
helper = OnlineMBeanHelper(self.__model_context,
self.__exception_type)
return helper
def __get_lsa_attributes(self, location, lsa_map=None):
_method_name = '__get_lsa_attributes'
attributes = None
attribute_path = self.__alias_helper.get_wlst_attributes_path(location)
if lsa_map is None:
if location is not None:
if attribute_path is not None:
try:
return_map = self.__wlst_helper.lsa(attribute_path)
if return_map is not None:
attributes = return_map.keys()
else:
attributes = list()
except BundleAwareException:
pass
if attributes is None:
ex = exception_helper.create_exception(self.__exception_type,
'WLSDPLY-01771',
attribute_path)
_logger.throwing(ex,
class_name=self.__class__.__name__,
method_name=_method_name)
raise ex
return attributes
class TargetHelper(object):
"""
Shared code for targeting clusters and servers. Domain create and update use this code.
"""
__class_name = 'TargetHelper'
def __init__(self, model, model_context, aliases, exception_type, logger):
self.logger = logger
self.model = model
self.model_context = model_context
self.alias_helper = AliasHelper(aliases, self.logger, exception_type)
self.wlst_helper = WlstHelper(self.logger, exception_type)
topology = model.get_model_topology()
if ADMIN_SERVER_NAME in topology:
self._admin_server_name = topology[ADMIN_SERVER_NAME]
else:
self._admin_server_name = DEFAULT_ADMIN_SERVER_NAME
def target_server_groups_to_servers(self, server_groups_to_target):
"""
Target the server groups to the servers.
:param server_groups_to_target: the list of server groups to target
:raises: BundleAwareException of the specified type: if an error occurs
"""
_method_name = '__target_server_groups_to_servers'
self.logger.entering(server_groups_to_target,
class_name=self.__class_name,
method_name=_method_name)
if len(server_groups_to_target) == 0:
return
location = LocationContext()
root_path = self.alias_helper.get_wlst_attributes_path(location)
self.wlst_helper.cd(root_path)
# We need to get the effective list of servers for the domain. Since any servers
# referenced in the model have already been created but the templates may have
# defined new servers not listed in the model, get the list from WLST.
server_names = self._get_existing_server_names()
# Get the clusters and and their members
cluster_map = self._get_clusters_and_members_map()
# Get any limits that may have been defined in the model
domain_info = self.model.get_model_domain_info()
server_group_targeting_limits = \
dictionary_utils.get_dictionary_element(domain_info, SERVER_GROUP_TARGETING_LIMITS)
if len(server_group_targeting_limits) > 0:
server_group_targeting_limits = \
self._get_server_group_targeting_limits(server_group_targeting_limits, cluster_map)
# Get the map of server names to server groups to target
server_to_server_groups_map =\
self._get_server_to_server_groups_map(self._admin_server_name,
server_names,
server_groups_to_target,
server_group_targeting_limits) # type: dict
if len(server_names) > 1:
for server, server_groups in server_to_server_groups_map.iteritems(
):
if len(server_groups) > 0:
server_name = self.wlst_helper.get_quoted_name_for_wlst(
server)
self.logger.info('WLSDPLY-12224',
str(server_groups),
server_name,
class_name=self.__class_name,
method_name=_method_name)
self.wlst_helper.set_server_groups(server_name,
server_groups)
elif len(server_group_targeting_limits) == 0:
#
# Domain has no managed servers and there were not targeting limits specified to target
# server groups to the admin server so make sure that the server groups are targeted to
# the admin server.
#
# This is really a best effort attempt. It works for JRF domains but it is certainly possible
# that it may cause problems with other custom domain types. Of course, creating a domain with
# no managed servers is not a primary use case of this tool so do it and hope for the best...
#
server_name = self.wlst_helper.get_quoted_name_for_wlst(
server_names[0])
self.wlst_helper.set_server_groups(server_name,
server_groups_to_target)
self.logger.exiting(class_name=self.__class_name,
method_name=_method_name)
return
def _get_existing_server_names(self):
"""
Get the list of server names from WLST.
:return: the list of server names
:raises: BundleAwareException of the specified type: is an error occurs reading from the aliases or WLST
"""
_method_name = '_get_existing_server_names'
self.logger.entering(class_name=self.__class_name,
method_name=_method_name)
server_location = LocationContext().append_location(SERVER)
server_list_path = self.alias_helper.get_wlst_list_path(
server_location)
result = self.wlst_helper.get_existing_object_list(server_list_path)
self.logger.exiting(class_name=self.__class_name,
method_name=_method_name,
result=result)
return result
def _get_clusters_and_members_map(self):
"""
Get a map keyed by cluster name with values that are a list of member server names
:return: the cluster name to member server names map
:raises: BundleAwareException of the specified type: is an error occurs reading from the aliases or WLST
"""
_method_name = '_get_clusters_and_members_map'
self.logger.entering(class_name=self.__class_name,
method_name=_method_name)
server_location = LocationContext().append_location(SERVER)
server_list_path = self.alias_helper.get_wlst_list_path(
server_location)
server_names = self.wlst_helper.get_existing_object_list(
server_list_path)
server_token = self.alias_helper.get_name_token(server_location)
cluster_map = OrderedDict()
for server_name in server_names:
server_location.add_name_token(server_token, server_name)
server_attributes_path = self.alias_helper.get_wlst_attributes_path(
server_location)
self.wlst_helper.cd(server_attributes_path)
server_attributes_map = self.wlst_helper.lsa()
cluster_name = dictionary_utils.get_element(
server_attributes_map, CLUSTER)
if string_utils.is_empty(cluster_name):
# if server is not part of a cluster, continue with the next server
continue
if cluster_name not in cluster_map:
cluster_map[cluster_name] = list()
cluster_map[cluster_name].append(server_name)
self.logger.exiting(class_name=self.__class_name,
method_name=_method_name,
result=cluster_map)
return cluster_map
def _get_server_group_targeting_limits(self, server_group_targeting_limits,
clusters_map):
"""
Get any server group targeting limits specified in the model, converting any cluster
names to the list of members. This method assumes that the limits dictionary is not
None or empty.
:param server_group_targeting_limits: the raw server group targeting_limits from the model
:param clusters_map: the map of cluster names to member server names
:return: the map of server groups to server names to target
"""
_method_name = '_get_server_group_targeting_limits'
self.logger.entering(str(server_group_targeting_limits),
str(clusters_map),
class_name=self.__class_name,
method_name=_method_name)
sg_targeting_limits = copy.deepcopy(server_group_targeting_limits)
for server_group_name, sg_targeting_limit in sg_targeting_limits.iteritems(
):
if type(sg_targeting_limit) is str:
if MODEL_LIST_DELIMITER in sg_targeting_limit:
sg_targeting_limit = sg_targeting_limit.split(
MODEL_LIST_DELIMITER)
else:
# convert a single value into a list of one...
new_list = list()
new_list.append(sg_targeting_limit)
sg_targeting_limit = new_list
# Convert any references to a cluster name into the list of member server names
new_list = list()
for target_name in sg_targeting_limit:
target_name = target_name.strip()
if target_name in clusters_map:
cluster_members = dictionary_utils.get_element(
clusters_map, target_name)
new_list.extend(cluster_members)
else:
# Assume it is a server name and add it to the new list
new_list.append(target_name)
sg_targeting_limits[server_group_name] = new_list
self.logger.exiting(class_name=self.__class_name,
method_name=_method_name,
result=sg_targeting_limits)
return sg_targeting_limits
def _get_server_to_server_groups_map(self, admin_server_name, server_names,
server_groups, sg_targeting_limits):
"""
Get the map of server names to the list of server groups to target to that server.
:param admin_server_name: the admin server name
:param server_names: the list of server names
:param server_groups: the complete list of server groups that will, by default, be targeted to
all managed servers unless the server is listed in the targeting limits map
:param sg_targeting_limits: the targeting limits map
:return: the map of server names to the list of server groups to target to that server
"""
_method_name = '_get_server_to_server_groups_map'
self.logger.entering(admin_server_name,
str(server_names),
str(server_groups),
str(sg_targeting_limits),
class_name=self.__class_name,
method_name=_method_name)
result = OrderedDict()
for server_name in server_names:
server_groups_for_server = self.__get_server_groups_for_server(
server_name, sg_targeting_limits)
if server_groups_for_server is not None:
result[server_name] = server_groups_for_server
elif server_name != admin_server_name:
# By default, we only target managed servers unless explicitly listed in the targeting limits
result[server_name] = list(server_groups)
else:
result[admin_server_name] = list()
if admin_server_name not in result:
result[admin_server_name] = list()
self.logger.exiting(class_name=self.__class_name,
method_name=_method_name,
result=result)
return result
def __get_server_groups_for_server(self, server_name, sg_targeting_limits):
"""
Get the servers groups to target for a given server name.
:param server_name: the server name
:param sg_targeting_limits: the targeting limits
:return: the list of server groups to target to the specified server name, or None
if the server name does not appear in the targeting limits
"""
_method_name = '__get_server_groups_for_server'
self.logger.entering(server_name,
str(sg_targeting_limits),
class_name=self.__class_name,
method_name=_method_name)
result = None
for server_group, server_names_list in sg_targeting_limits.iteritems():
if server_name in server_names_list:
if result is None:
result = list()
result.append(server_group)
self.logger.exiting(class_name=self.__class_name,
method_name=_method_name,
result=result)
return result