Merge pull request #4 from oracle/server-group-targeting

adding ServerGroupTargetingLimits element to the model

Author: ddsharpe

README.md

@@ -659,7 +659,7 @@ This file tells the Create Domain tool what templates to use to create the domai
                 "Oracle SOA Suite"
             ],
             "serverGroupsToTarget": [ "JRF-MAN-SVR", "WSMPM-MAN-SVR",  "SOA-MGD-SVRS" ],
-            "rcuSchemas": [ "STB", "WLS", "MDS", "IAU", "IAU_VIEWER", "IAU_APPEND", "OPSS", "UCSUMS", "ESS", "SOAINFRA" ]
+            "rcuSchemas": [ "STB", "WLS", "MDS", "IAU", "IAU_VIEWER", "IAU_APPEND", "OPSS", "UCSUMS", "SOAINFRA" ]
         }
     }
 }
@@ -669,6 +669,105 @@ Once the new domain typedef file exists, simply specify the new domain type name
 
     weblogic-deploy\bin\createDomain.cmd -oracle_home d:\SOA12213 -domain_type SOA -domain_parent d:\demo\domains -model_file DemoDomain.yaml -archive_file DemoDomain.zip -variable_file DemoDomain.properties -run_rcu -rcu_db mydb.example.com:1539/PDBORCL -rcu_prefix DEMO
 
+To create more complex domains with clusters of different types, it is necessary to control the targeting of server groups to managed servers.  By default, all server groups in the domain type definition are targeted to all managed servers.  To create a SOA domain with a SOA and OSB clusters, simply add the OSB template and server group to the SOA domain definition, as shown below.
+
+```json
+{
+    "name": "SOA",
+    "description": "SOA type domain definitions",
+    "versions": {
+        "12.2.1.3": "SOA_12213"
+    },
+    "definitions": {
+        "SOA_12213": {
+            "baseTemplate": "Basic WebLogic Server Domain",
+            "extensionTemplates": [
+                "Oracle SOA Suite",
+                "Oracle Service Bus"
+            ],
+            "serverGroupsToTarget": [ "JRF-MAN-SVR", "WSMPM-MAN-SVR",  "SOA-MGD-SVRS",  "OSB-MGD-SVRS-COMBINED" ],
+            "rcuSchemas": [ "STB", "WLS", "MDS", "IAU", "IAU_VIEWER", "IAU_APPEND", "OPSS", "UCSUMS", "SOAINFRA" ]
+        }
+    }
+}
+```
+
+Then, use the `ServerGroupTargetingLimits` map in the `domainInfo` section to limit the targeting of the Web Services Manager, SOA, and OSB server groups to the `soa_cluster` or `osb_cluster`, as appropriate.  In the example below, notice that the `JRF-MAN-SVR` server group is not listed; therefore, it will use the default targeting and be targeted to all managed servers.  The value of each element in this section is a logically list of server and/or cluster names.  As shown in the example, the value for each server group can be specified as a list, a comma-separated string, or a single-valued string.  There is no semantic difference between listing a cluster's member server names versus using the cluster name; the example uses these simply to show what is possible.
+
+```$yaml
+domainInfo:
+    AdminUserName: weblogic
+    AdminPassword: welcome1
+    ServerStartMode: prod
+    ServerGroupTargetingLimits:
+        'WSMPM-MAN-SVR': soa_cluster
+        'SOA-MGD-SVRS': 'soa_server1,soa_server2'
+        'OSB-MGD-SVRS-COMBINED': [ osb_server1, osb_server2 ]
+
+topology:
+    Name: soa_domain
+    AdminServerName: AdminServer
+    Cluster:
+        soa_cluster:
+        osb_cluster:
+    Server:
+        AdminServer:
+            ListenAddress: myadmin.example.com
+            ListenPort: 7001
+            Machine: machine1
+            SSL:
+                Enabled: true
+                ListenPort: 7002
+        soa_server1:
+            ListenAddress: managed1.example.com
+            ListenPort: 8001
+            Cluster: soa_cluster
+            Machine: machine2
+            SSL:
+                Enabled: true
+                ListenPort: 8002
+        soa_server2:
+            ListenAddress: managed2.example.com
+            ListenPort: 8001
+            Cluster: soa_cluster
+            Machine: machine3
+            SSL:
+                Enabled: true
+                ListenPort: 8002
+        osb_server1:
+            ListenAddress: managed1.example.com
+            ListenPort: 9001
+            Cluster: osb_cluster
+            Machine: machine2
+            SSL:
+                Enabled: true
+                ListenPort: 9002
+        osb_server2:
+            ListenAddress: managed2.example.com
+            ListenPort: 9001
+            Cluster: osb_cluster
+            Machine: machine3
+            SSL:
+                Enabled: true
+                ListenPort: 9002
+    UnixMachine:
+        machine1:
+            NodeManager:
+                ListenAddress: myadmin.example.com
+                ListenPort: 5556
+        machine2:
+            NodeManager:
+                ListenAddress: managed1.example.com
+                ListenPort: 5556
+        machine3:
+            NodeManager:
+                ListenAddress: managed2.example.com
+                ListenPort: 5556
+    SecurityConfiguration:
+        NodeManagerUsername: weblogic
+        NodeManagerPasswordEncrypted: welcome1
+```
+
 One last note is that if the model or variables file contains encrypted passwords, add the `-use_encryption` flag to the command-line to tell the Create Domain tool that encryption is being used and to prompt for the encryption passphrase.  As with the database passwords, the tool can also read the passphrase from standard input (i.e., stdin) to allow the tool to run without any user input.
 
 ## The Deploy Applications Tool

core/src/main/python/wlsdeploy/aliases/alias_entries.py

@@ -155,7 +155,12 @@ class AliasEntries(object):
         'AdminUserName': 'string',
         'AdminPassword': 'string',
         'ServerStartMode': 'string',
-        'domainLibraries': 'list'
+        'domainLibraries': 'list',
+        # A map of Server Group names to the list of servers/clusters to which they should
+        # be targeted.  The ServerGroup must appear in the domain typedef definition.  If
+        # the ServerGroup is not listed in this map, it will be targeted to all managed
+        # servers in the domain.
+        'ServerGroupTargetingLimits': 'dict'
     }
 
     __domain_name_token = 'DOMAIN'

core/src/main/python/wlsdeploy/aliases/model_constants.py

@@ -199,6 +199,7 @@
 SELF_TUNING = 'SelfTuning'
 SERVER = 'Server'
 SERVER_FAILURE_TRIGGER = 'ServerFailureTrigger'
+SERVER_GROUP_TARGETING_LIMITS = 'ServerGroupTargetingLimits'
 SERVER_START = 'ServerStart'
 SERVER_START_MODE = 'ServerStartMode'
 SERVER_TEMPLATE = 'ServerTemplate'

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

@@ -2,6 +2,9 @@
 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
@@ -13,8 +16,14 @@
 from wlsdeploy.tool.util.attribute_setter import AttributeSetter
 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):
     """
@@ -27,7 +36,7 @@ def __init__(self, model, model_context, aliases):
         self.aliases = aliases
         self.alias_helper = AliasHelper(self.aliases, self.logger, ExceptionType.CREATE)
         self.wlst_helper = WlstHelper(self.logger, ExceptionType.CREATE)
-        self.model = model
+        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)
@@ -436,3 +445,139 @@ 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