Exemplo n.º 1
0
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
Exemplo n.º 2
0
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
Exemplo n.º 3
0
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