Merge pull request #104 from oracle/issue#95-add-update-domain-capability

Issue#95 add update domain capability

Author: jshum2479

core/src/main/python/update.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,29 +15,26 @@
 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):
     """
     The base class used by the DomainCreator.
     """
     __class_name = 'Creator'
 
-    def __init__(self, model, model_context, aliases):
-        self.logger = PlatformLogger('wlsdeploy.create')
+    def __init__(self, model, model_context, aliases, exception_type=ExceptionType.CREATE,
+                 logger=PlatformLogger('wlsdeploy.create')):
+
+        self.logger = logger
         self.aliases = aliases
-        self.alias_helper = AliasHelper(self.aliases, self.logger, ExceptionType.CREATE)
-        self.wlst_helper = WlstHelper(self.logger, ExceptionType.CREATE)
+        self.alias_helper = AliasHelper(self.aliases, self.logger, exception_type)
+        self.wlst_helper = WlstHelper(self.logger, exception_type)
         self.model = Model(model)
         self.model_context = model_context
         self.wls_helper = WebLogicHelper(self.logger)
-        self.attribute_setter = AttributeSetter(self.aliases, self.logger, ExceptionType.CREATE)
+        self.attribute_setter = AttributeSetter(self.aliases, self.logger, exception_type)
         # Must be initialized by the subclass since only it has
         # the knowledge required to compute the domain name.
         self.archive_helper = None
@@ -393,7 +388,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.
@@ -451,139 +445,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