Wdt 228 target dynamic servers to cluster (#358)

* Apply JRF resources to dynamic cluster

* Add troubleshooting message for applyJRF

* intermediate checkins

* assign JRF resources using applyJRF

* One working approach

* Add rearrangement of execution of targeting

* Checkin cleanups

* fixes for exception issue message

* Fixes for 10.3.6 testing

* cleanup

* Revert "cleanup"

This reverts commit 0f0b6ca.

* WDT-228 Remove archive file from repository

* clarify warning message 12244

* changed warning message 9701

Author: CarolynRountree

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

@@ -147,4 +147,20 @@ public static String[] splitCommaSeparatedList(String listString) {
         return listString.split(COMMA_SEPARATED_LIST_SPLITTER);
     }
 
+    /**
+     * Return a printable string representing the Boolean True or False value for the integer.
+     * @param value containing the integer value of a boolean
+     * @return String representation of the boolean integer
+     */
+    public static String stringForBoolean(int value) {
+        switch(value) {
+            case 0:
+                return Boolean.FALSE.toString();
+            case 1:
+                return Boolean.TRUE.toString();
+            default:
+                return "UNKNOWN";
+        }
+    }
+
 }

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

@@ -10,15 +10,15 @@
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.exception.expection_types import ExceptionType
 from wlsdeploy.logging.platform_logger import PlatformLogger
-from wlsdeploy.tool.deploy import deployer_utils
+from wlsdeploy.util import dictionary_utils
 from wlsdeploy.tool.util.alias_helper import AliasHelper
 from wlsdeploy.tool.util.attribute_setter import AttributeSetter
 from wlsdeploy.tool.util.custom_folder_helper import CustomFolderHelper
 from wlsdeploy.tool.util.wlst_helper import WlstHelper
-from wlsdeploy.util import dictionary_utils
 from wlsdeploy.util.model import Model
 from wlsdeploy.util.weblogic_helper import WebLogicHelper
- 
+from wlsdeploy.tool.deploy import deployer_utils
+
 
 class Creator(object):
     """

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

@@ -4,7 +4,6 @@
 """
 import javaos as os
 from oracle.weblogic.deploy.create import RCURunner
-
 from wlsdeploy.aliases.location_context import LocationContext
 from wlsdeploy.aliases.model_constants import ADMIN_PASSWORD
 from wlsdeploy.aliases.model_constants import ADMIN_SERVER_NAME
@@ -415,8 +414,6 @@ def __extend_domain(self, domain_home):
             self.target_helper.target_server_groups_to_servers(server_groups_to_target)
             self.wlst_helper.update_domain()
         elif self._domain_typedef.is_jrf_domain_type():
-            # Update the domain to apply the extension templates.
-            self.wlst_helper.update_domain()
             self.target_helper.target_jrf_groups_to_clusters_servers(domain_home)
 
         self.wlst_helper.close_domain()
@@ -457,13 +454,20 @@ def __create_domain_with_select_template(self, domain_home):
             self.__set_app_dir()
             self.__configure_fmw_infra_database()
 
-            server_groups_to_target = self._domain_typedef.get_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)
+
+        server_groups_to_target = self._domain_typedef.get_server_groups_to_target()
+        server_assigns, dynamic_assigns = self.target_helper.target_server_groups_to_servers(server_groups_to_target)
+        if server_assigns is not None:
+            self.target_helper.target_server_groups(server_assigns)
+
         self.wlst_helper.write_domain(domain_home)
         self.wlst_helper.close_template()
+
+        if dynamic_assigns is not None:
+            self.target_helper.target_server_groups_to_dynamic_clusters(dynamic_assigns)
+
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
         return
 

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

@@ -29,6 +29,7 @@ class DomainTypedef(object):
     __domain_typedef_extension = '.json'
 
     JRF_TEMPLATE_REGEX = "^(.*jrf_template[0-9._]*\\.jar)|(Oracle JRF WebServices Asynchronous services)$"
+    RESTRICTED_JRF_TEMPLATE_REGEX = "^(Oracle Restricted JRF)$"
 
     def __init__(self, program_name, domain_type):
         """
@@ -94,6 +95,13 @@ def get_domain_type(self):
         """
         return self._domain_type
 
+    def has_jrf_resources(self):
+        """
+        Determine if the domain type has domain resources from either the JRF or Restricted JRF templates.
+        :return: True if the domain type has resources from one of the JRF type
+        """
+        return self.is_jrf_domain_type() or self.is_restricted_jrf_domain_type()
+
     def is_jrf_domain_type(self):
         """
         Determine if this is a JRF domain type by checking for the JRF extension template.
@@ -105,12 +113,15 @@ def is_jrf_domain_type(self):
                 return True
         return False
 
-    def domain_type_has_jrf_resources(self):
+    def is_restricted_jrf_domain_type(self):
         """
-        Does the running domain type contain the JRF server group ?
-        :return:
+        Determine if this domain type applies the Restricted JRF template.
+        :return: True if the Restricted JRF template is in the extension templates list
         """
-        return 'JRF-MAN-SVR' in self.get_server_groups_to_target()
+        for template in self.get_extension_templates():
+            if re.match(self.RESTRICTED_JRF_TEMPLATE_REGEX, template):
+                return True
+            return False
 
     def get_base_template(self):
         """
@@ -121,6 +132,14 @@ def get_base_template(self):
         self.__resolve_paths()
         return self._domain_typedef['baseTemplate']
 
+    def has_extension_templates(self):
+        """
+        Determine if the domain type has extension templates.
+        :return: True if the domain type will apply extension templates
+        """
+        ets = self.get_extension_templates()
+        return ets is not None and len(ets) > 0
+
     def get_extension_templates(self):
         """
         Get the list of extension templates to apply when create/extending the domain.

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

@@ -279,44 +279,3 @@ def get_file_hash(file_name):
         raise ex
     _logger.exiting(class_name=_class_name, method_name=_method_name, result=result)
     return result
-
-
-def save_changes(model_context):
-    """
-    Call this if necessary to save changes and disconnect from the domain.
-    This works in both offline and online.
-    :param model_context: contains information about the current tool settings
-    """
-    _method_name = 'save_changes'
-    if model_context.get_target_wlst_mode() == WlstModes.ONLINE:
-        if _wlst_helper.is_connected():
-            _logger.fine('WLSDPLY-09110', class_name=_class_name, method_name=_method_name)
-            _wlst_helper.save()
-            _wlst_helper.activate()
-            _wlst_helper.disconnect()
-        else:
-            _logger.fine('WLSDPLY-09109', class_name=_class_name, method_name=_method_name)
-    else:
-        _logger.fine('WLSDPLY-09111', class_name=_class_name, method_name=_method_name)
-        _wlst_helper.update_domain()
-
-
-def read_again(model_context):
-    """
-    Establish connection with the domain and start editing in both online and offline wlst mode.
-    :param model_context: contains information about the current tool settings
-    """
-    _method_name = 'read_again'
-    if model_context.get_target_wlst_mode() == WlstModes.ONLINE:
-        if not _wlst_helper.is_connected():
-            _logger.fine('WLSDPLY-09113', class_name=_class_name, method_name=_method_name)
-            _wlst_helper.connect(model_context.get_admin_user(), model_context.get_admin_password(),
-                                 model_context.get_admin_url())
-            _wlst_helper.edit()
-            _wlst_helper.start_edit()
-        else:
-            _logger.fine('WLSDPLY-09112', class_name=_class_name, method_name=_method_name)
-    else:
-        _logger.fine('WLSDPLY-09114', class_name=_class_name, method_name=_method_name)
-        _wlst_helper.close_domain()
-        _wlst_helper.read_domain(model_context.get_domain_home())

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

@@ -14,6 +14,7 @@
 from wlsdeploy.aliases.model_constants import SERVER_TEMPLATE
 from wlsdeploy.aliases.model_constants import UNIX_MACHINE
 from wlsdeploy.aliases.wlst_modes import WlstModes
+from wlsdeploy.exception import exception_helper
 from wlsdeploy.exception.expection_types import ExceptionType
 from wlsdeploy.tool.create.security_provider_creator import SecurityProviderCreator
 from wlsdeploy.tool.deploy import deployer_utils
@@ -34,16 +35,17 @@ def __init__(self, model, model_context, aliases, wlst_mode=WlstModes.OFFLINE):
         Deployer.__init__(self, model, model_context, aliases, wlst_mode)
         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._exception_type = ExceptionType.DEPLOY
+        self._topology_helper = TopologyHelper(self.aliases, self._exception_type, 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._exception_type, self.logger)
 
         self.library_helper = LibraryHelper(self.model, self.model_context, self.aliases,
-                                            model_context.get_domain_home(), ExceptionType.DEPLOY, self.logger)
+                                            model_context.get_domain_home(), self._exception_type, self.logger)
 
-        self.target_helper = TargetHelper(self.model, self.model_context, self.aliases, ExceptionType.DEPLOY,
+        self.target_helper = TargetHelper(self.model, self.model_context, self.aliases, self._exception_type,
                                           self.logger)
 
     # Override
@@ -72,7 +74,11 @@ def update(self):
         """
         Deploy resource model elements at the domain level, including multi-tenant elements.
         """
+        # For issue in setServerGroups in online mode (new configured clusters and stand-alone managed servers
+        # will not have extension template resources targeted)
+        existing_managed_servers, existing_configured_clusters = self._create_list_of_setservergroups_targets()
         domain_token = deployer_utils.get_domain_token(self.alias_helper)
+
         location = LocationContext()
         location.add_name_token(domain_token, self.model_context.get_domain_name())
 
@@ -104,24 +110,33 @@ def update(self):
         # create placeholders for Servers that are in a cluster as /Server/JTAMigratableTarget
         # can reference "other" servers
         self._topology_helper.create_placeholder_servers_in_cluster(self._topology)
+
         self._process_section(self._topology, folder_list, SERVER, location)
 
         self._process_section(self._topology, folder_list, MIGRATABLE_TARGET, location)
 
+        new_managed_server_list, new_configured_cluster_list = self._create_list_of_setservergroups_targets()
+
+        self._check_for_online_setservergroups_issue(existing_managed_servers, new_managed_server_list)
+        self._check_for_online_setservergroups_issue(existing_configured_clusters, new_configured_cluster_list)
+
         # process remaining top-level folders. copy list to avoid concurrent update in loop
         remaining = list(folder_list)
         for folder_name in remaining:
             self._process_section(self._topology, folder_list, folder_name, location)
 
         if self.wls_helper.is_set_server_groups_supported():
             server_groups_to_target = self._domain_typedef.get_server_groups_to_target()
-            self.target_helper.target_server_groups_to_servers(server_groups_to_target)
-        elif self._domain_typedef.domain_type_has_jrf_resources():
-            deployer_utils.save_changes(self.model_context)
-            self.target_helper.target_jrf_groups_to_clusters_servers(self.model_context.get_domain_home())
-            deployer_utils.read_again(self.model_context)
-
-        # files referenced in attributes are extracted as attributes are processed
+            server_assigns, dynamic_assigns = \
+                self.target_helper.target_server_groups_to_servers(server_groups_to_target)
+            if dynamic_assigns is not None:
+                self.wlst_helper.save_and_close(self.model_context)
+                self.target_helper.target_server_groups_to_dynamic_clusters(dynamic_assigns)
+                self.wlst_helper.reopen(self.model_context)
+            if server_assigns is not None:
+                self.target_helper.target_server_groups(server_assigns)
+        elif self._domain_typedef.is_jrf_domain_type():
+            self.target_helper.target_jrf_groups_to_clusters_servers()
 
         self.library_helper.install_domain_libraries()
         self.library_helper.extract_classpath_libraries()
@@ -153,3 +168,67 @@ def _set_domain_attributes(self):
         attribute_path = self.alias_helper.get_wlst_attributes_path(location)
         self.wlst_helper.cd(attribute_path)
         self.set_attributes(location, attrib_dict)
+
+    def is_online_with_ext_templates(self):
+        return self.model_context.is_wlst_online() and self.model_context.get_domain_typedef().has_extension_templates()
+
+    def _check_for_online_setservergroups_issue(self, existing_list, new_list):
+        _method_name = '_check_for_online_setservergroups_issue'
+        if len(existing_list) != len(new_list):
+            for entity_name in new_list:
+                if entity_name not in existing_list:
+                    self.logger.warning('WLSDPLY-09701', entity_name,
+                                        class_name=self._class_name, method_name=_method_name)
+        return
+
+    def _create_list_of_setservergroups_targets(self):
+        """
+        If an update is executed in online WLST mode, return a list of all existing configured / mixed clusters and
+        stand-alone managed servers. This method will be invoked to create a list of existing, and a list of new
+        as added by the update tool. These lists will be compared to determine if they will encounter
+        the online WLST problem with setServerGroups. The setServerGroups will target template resources to the
+        new entities, but this targeting is not persisted to the config.xml.
+        """
+        _method_name = '_create_list_of_setservergroups_targets'
+        self.logger.entering(class_name=self._class_name, method_name=_method_name)
+
+        if not self.is_online_with_ext_templates():
+            self.logger.exiting(class_name=self._class_name, method_name=_method_name)
+            return list(), list()
+
+        location = LocationContext().append_location(SERVER)
+        server_path = self.alias_helper.get_wlst_list_path(location)
+        existing_managed_servers = list()
+        existing_servers = self.wlst_helper.get_existing_object_list(server_path)
+        if existing_servers is not None:
+            name_token = self.alias_helper.get_name_token(location)
+            for server_name in existing_servers:
+                location.add_name_token(name_token, server_name)
+                wlst_path = self.alias_helper.get_wlst_attributes_path(location)
+                self.wlst_helper.cd(wlst_path)
+                cluster_attribute = self.alias_helper.get_wlst_attribute_name(location, CLUSTER)
+                cluster_value = self.wlst_helper.get(cluster_attribute)
+                if cluster_value is None:
+                    existing_managed_servers.append(server_name)
+                location.remove_name_token(name_token)
+
+        existing_configured_clusters = list()
+        location = LocationContext().append_location(CLUSTER)
+        cluster_path = self.alias_helper.get_wlst_list_path(location)
+        existing_clusters = self.wlst_helper.get_existing_object_list(cluster_path)
+        if existing_clusters is not None:
+            name_token = self.alias_helper.get_name_token(location)
+            for cluster_name in existing_clusters:
+                location.add_name_token(name_token, cluster_name)
+                wlst_path = self.alias_helper.get_wlst_attributes_path(location)
+                self.wlst_helper.cd(wlst_path)
+                ds_mbean = self.alias_helper.get_wlst_mbean_type(location)
+                if not self.wlst_helper.subfolder_exists(ds_mbean,
+                                                         self.alias_helper.get_wlst_subfolders_path(location)):
+                    existing_configured_clusters.append(cluster_name)
+                location.remove_name_token(name_token)
+
+        self.logger.exiting(class_name=self._class_name, method_name=_method_name,
+                            result='configured_clusters=' + str(existing_configured_clusters) +
+                                   ' managed servers=' + str(existing_managed_servers))
+        return existing_configured_clusters, existing_managed_servers

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

@@ -2,6 +2,10 @@
 Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
 The Universal Permissive License (UPL), Version 1.0
 """
+from com.sun.identity.agents.weblogic.v10 import AgentAuthenticatorMBeanImplBeanInfo
+from com.sun.identity.agents.weblogic.v10 import AgentAuthenticatorMBeanImpl
+from com.sun.identity.agents.weblogic.v10 import AgentAuthenticatorMBean
+from com.sun.identity.agents.weblogic.v10 import AgentAuthenticatorImpl
 from java.io import File
 from java.lang import IllegalArgumentException
 
@@ -46,6 +50,7 @@ def __init__(self, model_context, topology_dictionary, base_location, wlst_mode=
         self._add_att_handler(model_constants.CLASSPATH, self._add_classpath_libraries_to_archive)
         self._add_att_handler(model_constants.CUSTOM_IDENTITY_KEYSTORE_FILE, self._add_keystore_file_to_archive)
         self._add_att_handler(model_constants.CUSTOM_TRUST_KEYSTORE_FILE, self._add_keystore_file_to_archive)
+        self.agent_authenticator = AgentAuthenticatorImpl()
 
     def discover(self):
         """