Do not discover dynamic servers in online mode (#696)

Author: CarolynRountree

core/src/main/java/oracle/weblogic/deploy/util/StringUtils.java

@@ -163,4 +163,17 @@ public static String stringForBoolean(int value) {
         }
     }
 
+    /***
+     * Convert the String to an Integer. If the string does not contain a valid integer, return a null.
+     * @param value String to convert to an Integer
+     * @return converted Integer or null if invalid number
+     */
+    public static Integer stringToInteger(String value) {
+        try {
+            return Integer.valueOf(value);
+        } catch (NumberFormatException nfe) {
+            return null;
+        }
+    }
+
 }

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

@@ -107,6 +107,7 @@
 DOMAIN_LIBRARIES = 'domainLibraries'
 DOMAIN_SCRIPTS = 'domainBin'
 DYNAMIC_CLUSTER_SERVER_GROUP_TARGETING_LIMITS = 'DynamicClusterServerGroupTargetingLimits'
+DYNAMIC_CLUSTER_SIZE = 'DynamicClusterSize'
 DOMAIN_VERSION = 'DomainVersion'
 DYNAMIC_SERVERS = 'DynamicServers'
 EMBEDDED_LDAP = 'EmbeddedLDAP'
@@ -249,6 +250,8 @@
 SERVER_FAILURE_TRIGGER = 'ServerFailureTrigger'
 SERVER_GROUP_TARGETING_LIMITS = 'ServerGroupTargetingLimits'
 SERVER_POD = 'serverPod'
+SERVER_NAME_PREFIX = 'ServerNamePrefix'
+SERVER_NAME_START_IDX = 'ServerNameStartingIndex'
 SERVER_START = 'ServerStart'
 SERVER_START_MODE = 'ServerStartMode'
 SERVER_TEMPLATE = 'ServerTemplate'

core/src/main/python/wlsdeploy/tool/discover/topology_discoverer.py

@@ -147,11 +147,12 @@ def get_servers(self):
             _logger.info('WLSDPLY-06603', len(servers), class_name=_class_name, method_name=_method_name)
             name_token = self._aliases.get_name_token(location)
             for server in servers:
-                _logger.info('WLSDPLY-06604', server, class_name=_class_name, method_name=_method_name)
                 location.add_name_token(name_token, server)
-                result[server] = OrderedDict()
-                self._populate_model_parameters(result[server], location)
-                self._discover_subfolders(result[server], location)
+                if not self._dynamic_server(server, location):
+                    _logger.info('WLSDPLY-06604', server, class_name=_class_name, method_name=_method_name)
+                    result[server] = OrderedDict()
+                    self._populate_model_parameters(result[server], location)
+                    self._discover_subfolders(result[server], location)
                 location.remove_name_token(name_token)
         _logger.exiting(class_name=_class_name, method_name=_method_name, result=result)
         return model_top_folder_name, result
@@ -197,12 +198,13 @@ def get_migratable_targets(self):
             _logger.info('WLSDPLY-06607', len(targets), class_name=_class_name, method_name=_method_name)
             name_token = self._aliases.get_name_token(location)
             for target in targets:
-                _logger.info('WLSDPLY-06608', target, class_name=_class_name, method_name=_method_name)
-                location.add_name_token(name_token, target)
-                result[target] = OrderedDict()
-                self._populate_model_parameters(result[target], location)
-                self._discover_subfolders(result[target], location)
-                location.remove_name_token(name_token)
+                if not self._dynamic_target(target, location):
+                    _logger.info('WLSDPLY-06608', target, class_name=_class_name, method_name=_method_name)
+                    location.add_name_token(name_token, target)
+                    result[target] = OrderedDict()
+                    self._populate_model_parameters(result[target], location)
+                    self._discover_subfolders(result[target], location)
+                    location.remove_name_token(name_token)
 
         _logger.exiting(class_name=_class_name, method_name=_method_name)
         return model_top_folder_name, result
@@ -653,6 +655,75 @@ def _get_server_name_from_location(self, location):
         temp.append_location(model_constants.SERVER)
         return location.get_name_for_token(self._aliases.get_name_token(temp))
 
+    def _dynamic_target(self, target, location):
+        """
+        Determine if the Migratable Target is connected to a dynamic server. This is determined in online mode
+        only when the dynamic server and dynamic migratable target are created.
+        :param target: migratable target to test for connection to dynamic server
+        :param location: current location context
+        :return: True if a dynamic server Migratable Target
+        """
+        if target.endswith('(migratable)'):
+            server_name = target.split('(migratable)')[0].strip()
+            server_location = LocationContext()
+            server_location.append_location(model_constants.SERVER)
+            server_location.add_name_token(self._aliases.get_name_token(server_location), server_name)
+            wlst_path = self._aliases.get_wlst_attributes_path(server_location)
+            if self._wlst_helper.path_exists(wlst_path):
+                return self._dynamic_server(server_name, server_location)
+        return False
+
+    def _dynamic_server(self, server, location):
+        """
+        If this is online discover, determine if the server is part of a dynamic cluster.
+        :param server: name of the server
+        :param location: current location of the server
+        :return: True if dynamic server
+        """
+        _method_name = '_dynamic_server'
+        if self._wlst_mode == WlstModes.ONLINE and self._weblogic_helper.is_dynamic_clusters_supported():
+            wlst_path = self._aliases.get_wlst_attributes_path(location)
+            self._wlst_helper.cd(wlst_path)
+            cluster_attr = self._aliases.get_wlst_attribute_name(location, model_constants.CLUSTER)
+            cluster = self._wlst_helper.get(cluster_attr)
+            if cluster is not None:
+                __, cluster_name = self._aliases.get_model_attribute_name_and_value(location, cluster_attr, cluster)
+                cluster_location = LocationContext()
+                cluster_location.append_location(model_constants.CLUSTER)
+                cluster_location.add_name_token(self._aliases.get_name_token(cluster_location), cluster_name)
+                cluster_location.append_location(model_constants.DYNAMIC_SERVERS)
+                cluster_location.add_name_token(self._aliases.get_name_token(cluster_location), cluster_name)
+                wlst_path = self._aliases.get_wlst_attributes_path(cluster_location)
+                if self._wlst_helper.path_exists(wlst_path):
+                    _logger.fine('WLSDPLY-06613', server, class_name=_class_name, method_name=_method_name)
+                    self._wlst_helper.cd(wlst_path)
+                    attr_name = self._aliases.get_wlst_attribute_name(cluster_location,
+                                                                      model_constants.DYNAMIC_CLUSTER_SIZE)
+                    dynamic_size = self._wlst_helper.get(attr_name)
+                    attr_name = self._aliases.get_wlst_attribute_name(cluster_location,
+                                                                      model_constants.SERVER_NAME_PREFIX)
+                    prefix = self._wlst_helper.get(attr_name)
+                    starting = 1
+                    present, __ = self._aliases.is_valid_model_attribute_name(location,
+                                                                              model_constants.SERVER_NAME_PREFIX)
+                    if present:
+                        attr_name = self._aliases.get_model_attribute_name(cluster_location,
+                                                                           model_constants.SERVER_NAME_START_IDX)
+                        starting = self._wlst_helper.get(attr_name)
+                    return check_against_server_list(server, dynamic_size, prefix, starting)
+        _logger.finer('WLSDPLY-06614', server, class_name=_class_name, method_name=_method_name)
+        return False
+
+
+def check_against_server_list(server_name, dynamic_size, prefix, starting):
+    if dynamic_size > 0 and prefix is not None and server_name.startswith(prefix):
+        split_it = server_name.split(prefix)
+        if len(split_it) == 2:
+            number = StringUtils.stringToInteger(split_it[1].strip())
+            if number is not None and starting <= number < (dynamic_size + starting):
+                return True
+    return False
+
 
 def _kss_file_type(file_name):
     if file_name.startswith(KSS_KEYSTORE_FILE_INDICATOR):

core/src/main/resources/oracle/weblogic/deploy/messages/wlsdeploy_rb.properties

@@ -709,7 +709,8 @@ WLSDPLY-06609=Discovering {0} Unix machines
 WLSDPLY-06610=Adding Unix Machine {0}
 WLSDPLY-06611=Discovering {0} machines
 WLSDPLY-06612=Adding Machine {0}
-
+WLSDPLY-06613=Dynamic Server {0} discovered in online mode will not be added to the model
+WLSDPLY-06614=Server {0} is a configured Server and will be added to the model
 
 
 

core/src/test/python/wlsdeploy/tool/discover/discover_test.py

@@ -0,0 +1,34 @@
+"""
+Copyright (c) 2020, Oracle Corporation and/or its affiliates.
+Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+"""
+import unittest
+
+import wlsdeploy.tool.discover.topology_discoverer as topology_discoverer
+
+
+class DiscoverTest(unittest.TestCase):
+
+    def testDynamicServerValid(self):
+        server_name = 'ps0'
+        prefix = 'ps'
+        dynamic_size = 3
+        starting = 0
+        result = topology_discoverer.check_against_server_list(server_name, dynamic_size, prefix, starting)
+        self.assertEqual(True, result)
+
+    def testDynamicServerInValid(self):
+        server_name = 'ps0'
+        prefix = 'ps'
+        dynamic_size = 3
+        starting = 1
+        result = topology_discoverer.check_against_server_list(server_name, dynamic_size, prefix, starting)
+        self.assertEqual(False, result)
+
+    def testDynamicServerValidEnd(self):
+        server_name = 'managed-server-112'
+        prefix = 'managed-server-'
+        dynamic_size = 12
+        starting = 101
+        result = topology_discoverer.check_against_server_list(server_name, dynamic_size, prefix, starting)
+        self.assertEqual(True, result)