Issue#95 - Provide update of server group targeting

Author: rakillen

core/src/main/python/update.py

@@ -32,12 +32,14 @@
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.exception.expection_types import ExceptionType
 from wlsdeploy.logging.platform_logger import PlatformLogger
+from wlsdeploy.tool.create.domain_typedef import DomainTypedef
 from wlsdeploy.tool.deploy import deployer_utils
 from wlsdeploy.tool.deploy import model_deployer
 from wlsdeploy.tool.deploy.topology_updater import TopologyUpdater
 from wlsdeploy.tool.validate.validator import Validator
 from wlsdeploy.tool.util import filter_helper
 from wlsdeploy.tool.util.wlst_helper import WlstHelper
+from wlsdeploy.util import dictionary_utils
 from wlsdeploy.util import getcreds
 from wlsdeploy.util import variables
 from wlsdeploy.util.cla_utils import CommandLineArgUtil
@@ -91,10 +93,18 @@ def __process_args(args):
     __wlst_mode = __process_online_args(optional_arg_map)
     __process_encryption_args(optional_arg_map)
 
+    domain_type = dictionary_utils.get_element(optional_arg_map, CommandLineArgUtil.DOMAIN_TYPE_SWITCH)
+    if domain_type is None:
+        domain_type = 'WLS'
+    domain_typedef = DomainTypedef(_program_name, domain_type)
+    optional_arg_map[CommandLineArgUtil.DOMAIN_TYPEDEF] = domain_typedef
+
     combined_arg_map = optional_arg_map.copy()
     combined_arg_map.update(required_arg_map)
 
-    return ModelContext(_program_name, combined_arg_map)
+    model_context = ModelContext(_program_name, combined_arg_map)
+    domain_typedef.set_model_context(model_context)
+    return model_context
 
 
 def __verify_required_args_present(required_arg_map):

core/src/main/python/wlsdeploy/tool/create/creator.py

@@ -2,9 +2,7 @@
 Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.
 The Universal Permissive License (UPL), Version 1.0
 """
-import copy
 
-from oracle.weblogic.deploy.util import PyOrderedDict as OrderedDict
 from oracle.weblogic.deploy.util import WLSDeployArchive
 
 from wlsdeploy.aliases.location_context import LocationContext
@@ -17,13 +15,8 @@
 from wlsdeploy.tool.util.wlst_helper import WlstHelper
 from wlsdeploy.util import dictionary_utils
 from wlsdeploy.util.model import Model
-from wlsdeploy.util import string_utils
 from wlsdeploy.util.weblogic_helper import WebLogicHelper
 
-from wlsdeploy.aliases.model_constants import CLUSTER
-from wlsdeploy.aliases.model_constants import MODEL_LIST_DELIMITER
-from wlsdeploy.aliases.model_constants import SERVER
-
 
 class Creator(object):
     """
@@ -389,7 +382,6 @@ def _create_subfolders(self, location, model_nodes):
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
         return
 
-
     def _is_type_valid(self, location, type_name):
         """
         Verify that the specified location in valid for the current WLS version.
@@ -447,139 +439,3 @@ def _format_model_path(self, location, name):
             path += '/'
         path += name
         return path
-
-    def _get_existing_server_names(self):
-        """
-        Get the list of server names from WLST.
-        :return: the list of server names
-        :raises: CreateException: 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: CreateException: 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

core/src/main/python/wlsdeploy/tool/create/domain_creator.py

@@ -32,7 +32,6 @@
 from wlsdeploy.aliases.model_constants import SECURITY
 from wlsdeploy.aliases.model_constants import SECURITY_CONFIGURATION
 from wlsdeploy.aliases.model_constants import SERVER
-from wlsdeploy.aliases.model_constants import SERVER_GROUP_TARGETING_LIMITS
 from wlsdeploy.aliases.model_constants import SERVER_START_MODE
 from wlsdeploy.aliases.model_constants import SERVER_TEMPLATE
 from wlsdeploy.aliases.model_constants import SET_OPTION_APP_DIR
@@ -50,6 +49,7 @@
 from wlsdeploy.tool.deploy import model_deployer
 from wlsdeploy.tool.util.archive_helper import ArchiveHelper
 from wlsdeploy.tool.util.library_helper import LibraryHelper
+from wlsdeploy.tool.util.target_helper import TargetHelper
 from wlsdeploy.tool.util.topology_helper import TopologyHelper
 from wlsdeploy.util import dictionary_utils
 from wlsdeploy.util import model as model_helper
@@ -106,6 +106,9 @@ def __init__(self, model_dictionary, model_context, aliases):
         self.library_helper = LibraryHelper(self.model, self.model_context, self.aliases, self._domain_home,
                                             ExceptionType.CREATE, self.logger)
 
+        self.target_helper = TargetHelper(self.model, self.model_context, self.aliases, ExceptionType.CREATE,
+                                          self.logger)
+
         #
         # Creating domains with the wls.jar template is busted for pre-12.1.2 domains with regards to the
         # names of the default authentication providers (both the DefaultAuthenticator and the
@@ -303,7 +306,7 @@ def __extend_domain(self, domain_home):
         self.__configure_fmw_infra_database()
 
         server_groups_to_target = self._domain_typedef.get_server_groups_to_target()
-        self.__target_server_groups_to_servers(server_groups_to_target)
+        self.target_helper.target_server_groups_to_servers(server_groups_to_target)
 
         self.logger.info('WLSDPLY-12209', self._domain_name,
                          class_name=self.__class_name, method_name=_method_name)
@@ -345,7 +348,7 @@ def __create_domain_with_select_template(self, domain_home):
             self.__configure_fmw_infra_database()
 
             server_groups_to_target = self._domain_typedef.get_server_groups_to_target()
-            self.__target_server_groups_to_servers(server_groups_to_target)
+            self.target_helper.target_server_groups_to_servers(server_groups_to_target)
 
         self.logger.info('WLSDPLY-12206', self._domain_name, domain_home,
                          class_name=self.__class_name, method_name=_method_name)
@@ -611,67 +614,6 @@ def __configure_fmw_infra_database(self):
         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: CreateException: 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)
-        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 __set_app_dir(self):
         """
         Set the AppDir domain option.

core/src/main/python/wlsdeploy/tool/deploy/topology_updater.py

@@ -17,6 +17,7 @@
 from wlsdeploy.tool.deploy import deployer_utils
 from wlsdeploy.tool.deploy.deployer import Deployer
 from wlsdeploy.tool.util.library_helper import LibraryHelper
+from wlsdeploy.tool.util.target_helper import TargetHelper
 from wlsdeploy.tool.util.topology_helper import TopologyHelper
 from wlsdeploy.util import dictionary_utils
 
@@ -32,12 +33,17 @@ def __init__(self, model, model_context, aliases, wlst_mode=WlstModes.OFFLINE):
         self._topology = self.model.get_model_topology()
         self._resources = self.model.get_model_resources()
         self._topology_helper = TopologyHelper(self.aliases, ExceptionType.DEPLOY, self.logger)
+        self._domain_typedef = self.model_context.get_domain_typedef()
+
         self._security_provider_creator = SecurityProviderCreator(model.get_model(), model_context, aliases,
                                                                   ExceptionType.DEPLOY, self.logger)
 
         self.library_helper = LibraryHelper(self.model, self.model_context, self.aliases,
                                             model_context.get_domain_home(), ExceptionType.DEPLOY, self.logger)
 
+        self.target_helper = TargetHelper(self.model, self.model_context, self.aliases, ExceptionType.DEPLOY,
+                                          self.logger)
+
     # Override
     def _add_named_elements(self, type_name, model_nodes, location):
         """
@@ -86,7 +92,8 @@ def update(self):
         for folder_name in remaining:
             self._process_section(self._topology, folder_list, folder_name, location)
 
-        # TODO: update targeting
+        server_groups_to_target = self._domain_typedef.get_server_groups_to_target()
+        self.target_helper.target_server_groups_to_servers(server_groups_to_target)
 
         # files referenced in attributes are extracted as attributes are processed
 

core/src/main/python/wlsdeploy/tool/util/library_helper.py

@@ -36,7 +36,6 @@ def install_domain_libraries(self):
         :raises: BundleAwareException of the specified type: if an error occurs
         """
         _method_name = 'install_domain_libraries'
-        print('\n' + _method_name)
 
         self.logger.entering(self.domain_home, class_name=self.__class_name, method_name=_method_name)
         domain_info_dict = self.model.get_model_domain_info()
@@ -63,7 +62,6 @@ def extract_classpath_libraries(self):
         :raises: BundleAwareException of the specified type: if an error occurs
         """
         _method_name = 'extract_classpath_libraries'
-        print('\n' + _method_name)
 
         self.logger.entering(self.domain_home, class_name=self.__class_name, method_name=_method_name)
         if self.archive_helper is None: