delay delete until after set server groups (WDT-790) (#808)

Author: CarolynRountree

core/src/main/python/update.py

@@ -138,10 +138,10 @@ def __update_online(model, model_context, aliases):
 
     __logger.info("WLSDPLY-09007", admin_url, method_name=_method_name, class_name=_class_name)
 
+    topology_updater = TopologyUpdater(model, model_context, aliases, wlst_mode=WlstModes.ONLINE)
     try:
-        topology_updater = TopologyUpdater(model, model_context, aliases, wlst_mode=WlstModes.ONLINE)
-        topology_updater.update()
-        model_deployer.deploy_resources(model, model_context, aliases, wlst_mode=__wlst_mode)
+        topology_updater.update_machines_clusters_and_servers(delete_now=False)
+        topology_updater.warn_set_server_groups()
     except DeployException, de:
         __release_edit_session_and_disconnect()
         raise de
@@ -160,6 +160,13 @@ def __update_online(model, model_context, aliases):
     except BundleAwareException, ex:
         raise ex
 
+    try:
+        topology_updater.update()
+        model_deployer.deploy_resources(model, model_context, aliases, wlst_mode=__wlst_mode)
+    except DeployException, de:
+        __release_edit_session_and_disconnect()
+        raise de
+
     exit_code = __check_update_require_domain_restart(model_context)
     # if user requested rollback if restart required stops
 
@@ -225,10 +232,15 @@ def __update_offline(model, model_context, aliases):
     __wlst_helper.read_domain(domain_home)
 
     topology_updater = TopologyUpdater(model, model_context, aliases, wlst_mode=WlstModes.OFFLINE)
-    topology_updater.update()
+    # deleting servers that are added by templates before set server groups causes mayhem
+    topology_updater.update_machines_clusters_and_servers(delete_now=False)
+
+    __update_offline_domain()
 
     topology_updater.set_server_groups()
 
+    topology_updater.update()
+
     # Add resources after server groups are established to prevent auto-renaming
     model_deployer.deploy_model_offline(model, model_context, aliases, wlst_mode=__wlst_mode)
     if model_context.get_update_rcu_schema_pass() is True:

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

@@ -45,7 +45,7 @@ def __init__(self, model, model_context, aliases, exception_type=ExceptionType.C
         self.files_to_extract_from_archive = list()
         return
 
-    def _create_named_mbeans(self, type_name, model_nodes, base_location, log_created=False):
+    def _create_named_mbeans(self, type_name, model_nodes, base_location, log_created=False, delete_now=True):
         """
         Create the specified type of MBeans that support multiple instances in the specified location.
         :param type_name: the model folder type
@@ -71,7 +71,8 @@ def _create_named_mbeans(self, type_name, model_nodes, base_location, log_create
         for model_name in model_nodes.keys():
             name = self.wlst_helper.get_quoted_name_for_wlst(model_name)
             if model_helper.is_delete_name(name):
-                deployer_utils.delete_named_element(location, name, existing_folder_names, self.aliases)
+                if delete_now:
+                    deployer_utils.delete_named_element(location, name, existing_folder_names, self.aliases)
                 continue
 
             if token_name is not None:

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

@@ -187,7 +187,7 @@ def create(self):
         return
 
     # Override
-    def _create_named_mbeans(self, type_name, model_nodes, base_location, log_created=False):
+    def _create_named_mbeans(self, type_name, model_nodes, base_location, log_created=False, delete_now=True):
         """
         Override default behavior to create placeholders for referenced Coherence clusters.
         :param type_name: the model folder type
@@ -199,7 +199,7 @@ def _create_named_mbeans(self, type_name, model_nodes, base_location, log_create
         self.topology_helper.check_coherence_cluster_references(type_name, model_nodes)
         # continue with regular processing
 
-        Creator._create_named_mbeans(self, type_name, model_nodes, base_location, log_created=log_created)
+        Creator._create_named_mbeans(self, type_name, model_nodes, base_location, log_created=log_created, delete_now=delete_now)
 
     # Override
     def _create_mbean(self, type_name, model_nodes, base_location, log_created=False):
@@ -469,7 +469,7 @@ def __extend_domain(self, domain_home):
             self.wlst_helper.add_template(custom_template)
 
         topology_folder_list = self.aliases.get_model_topology_top_level_folder_names()
-        self.__apply_base_domain_config(topology_folder_list)
+        self.__create_machines_clusters_and_servers(delete_now=False)
         self.__configure_fmw_infra_database()
 
         if self.wls_helper.is_set_server_groups_supported():
@@ -485,6 +485,7 @@ def __extend_domain(self, domain_home):
         self.logger.info('WLSDPLY-12209', self._domain_name,
                          class_name=self.__class_name, method_name=_method_name)
 
+        self.__apply_base_domain_config(topology_folder_list)
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
         return
 
@@ -538,7 +539,11 @@ def __extend_domain_with_select_template(self, domain_home):
             self.__configure_fmw_infra_database()
             self.__configure_opss_secrets()
         topology_folder_list = self.aliases.get_model_topology_top_level_folder_names()
-        self.__apply_base_domain_config(topology_folder_list)
+
+        self.__create_security_folder()
+        topology_folder_list.remove(SECURITY)
+
+        self.__create_machines_clusters_and_servers(delete_now=False)
 
         server_groups_to_target = self._domain_typedef.get_server_groups_to_target()
         dynamic_cluster_server_groups_to_target = self._domain_typedef.get_dynamic_cluster_server_groups()
@@ -552,6 +557,8 @@ def __extend_domain_with_select_template(self, domain_home):
         if len(dynamic_assigns) > 0:
             self.target_helper.target_dynamic_server_groups(dynamic_assigns)
 
+        self.__apply_base_domain_config(topology_folder_list)
+
         self.logger.info('WLSDPLY-12205', self._domain_name, domain_home,
                          class_name=self.__class_name, method_name=_method_name)
         self.wlst_helper.write_domain(domain_home)
@@ -568,7 +575,8 @@ def __set_server_groups(self):
         if self.wls_helper.is_set_server_groups_supported():
             # 12c versions set server groups directly
             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)
+            server_assigns, dynamic_assigns = \
+                self.target_helper.target_server_groups_to_servers(server_groups_to_target)
             if len(server_assigns) > 0:
                 self.target_helper.target_server_groups(server_assigns)
 
@@ -603,26 +611,19 @@ def __apply_base_domain_config(self, topology_folder_list):
         domain_name_token = self.aliases.get_name_token(location)
         location.add_name_token(domain_name_token, self._domain_name)
 
-        self.__create_security_folder(location)
-        topology_folder_list.remove(SECURITY)
-
         topology_folder_list.remove(SECURITY_CONFIGURATION)
 
         self.__create_mbeans_used_by_topology_mbeans(location, topology_folder_list)
 
-        self.__create_machines(location)
+        self.__create_machines_clusters_and_servers()
         topology_folder_list.remove(MACHINE)
         topology_folder_list.remove(UNIX_MACHINE)
-
-        self.__create_clusters_and_servers(location)
         topology_folder_list.remove(CLUSTER)
         if SERVER_TEMPLATE in topology_folder_list:
             topology_folder_list.remove(SERVER_TEMPLATE)
         topology_folder_list.remove(SERVER)
-
-        self.__create_migratable_targets(location)
         topology_folder_list.remove(MIGRATABLE_TARGET)
-
+        #
         self.__create_other_domain_artifacts(location, topology_folder_list)
 
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
@@ -667,14 +668,16 @@ def __create_mbeans_used_by_topology_mbeans(self, location, topology_folder_list
         self.__create_xml_registry(location)
         topology_folder_list.remove(XML_REGISTRY)
 
-    def __create_security_folder(self, location):
+    def __create_security_folder(self):
         """
         Create the /Security folder objects, if any.
-        :param location: the location to use
         :raises: CreateException: if an error occurs
         """
         _method_name = '__create_security_folder'
 
+        location = LocationContext()
+        domain_name_token = self.aliases.get_name_token(location)
+        location.add_name_token(domain_name_token, self._domain_name)
         self.logger.entering(str(location), class_name=self.__class_name, method_name=_method_name)
         security_nodes = dictionary_utils.get_dictionary_element(self._topology, SECURITY)
         if len(security_nodes) > 0:
@@ -765,16 +768,20 @@ def __create_machines(self, location):
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
         return
 
-    def __create_clusters_and_servers(self, location):
+    def __create_machines_clusters_and_servers(self, delete_now=True):
         """
         Create the /Cluster, /ServerTemplate, and /Server folder objects.
-        :param location: the location to use
+        :param delete_now: Flag determing whether the delete of the elements will be delayed
         :raises: CreateException: if an error occurs
         """
-        _method_name = '__create_clusters_and_servers'
+        _method_name = '__create_machines_clusters_and_servers'
 
+        location = LocationContext()
+        domain_name_token = self.aliases.get_name_token(location)
+        location.add_name_token(domain_name_token, self._domain_name)
         self.logger.entering(str(location), class_name=self.__class_name, method_name=_method_name)
 
+        self.__create_machines(location)
         #
         # In order for source domain provisioning to work with dynamic clusters, we have to provision
         # the ServerTemplates.  There is a cyclical dependency between Server Template and Clusters so we
@@ -788,14 +795,15 @@ def __create_clusters_and_servers(self, location):
         jdbc_names = self.topology_helper.create_placeholder_jdbc_resources(resources_dict)
         cluster_nodes = dictionary_utils.get_dictionary_element(self._topology, CLUSTER)
         if len(cluster_nodes) > 0:
-            self._create_named_mbeans(CLUSTER, cluster_nodes, location, log_created=True)
+            self._create_named_mbeans(CLUSTER, cluster_nodes, location, log_created=True, delete_now=delete_now)
 
         #
         # Now, fully populate the ServerTemplates, if any.
         #
         server_template_nodes = dictionary_utils.get_dictionary_element(self._topology, SERVER_TEMPLATE)
         if len(server_template_nodes) > 0:
-            self._create_named_mbeans(SERVER_TEMPLATE, server_template_nodes, location, log_created=True)
+            self._create_named_mbeans(SERVER_TEMPLATE, server_template_nodes, location, log_created=True,
+                                      delete_now=delete_now)
 
         #
         # Finally, create/update the servers.
@@ -804,18 +812,19 @@ def __create_clusters_and_servers(self, location):
         # There may be a dependency to other servers when the server is in a cluster
         self.topology_helper.create_placeholder_servers_in_cluster(self._topology)
         if len(server_nodes) > 0:
-            self._create_named_mbeans(SERVER, server_nodes, location, log_created=True)
+            self._create_named_mbeans(SERVER, server_nodes, location, log_created=True, delete_now=delete_now)
 
         # targets may have been inadvertently assigned when clusters were added
         self.topology_helper.clear_jdbc_placeholder_targeting(jdbc_names)
-
+        self.__create_migratable_targets(location, delete_now=delete_now)
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
         return
 
-    def __create_migratable_targets(self, location):
+    def __create_migratable_targets(self, location, delete_now=True):
         """
         Create the /MigratableTarget folder objects, if any.
         :param location: the location to use
+        :param delete_now: Flag to determine if the delete of elements will be delayed
         :raises: CreateException: if an error occurs
         """
         _method_name = '__create_migratable_targets'
@@ -824,7 +833,8 @@ def __create_migratable_targets(self, location):
         migratable_target_nodes = dictionary_utils.get_dictionary_element(self._topology, MIGRATABLE_TARGET)
 
         if len(migratable_target_nodes) > 0:
-            self._create_named_mbeans(MIGRATABLE_TARGET, migratable_target_nodes, location, log_created=True)
+            self._create_named_mbeans(MIGRATABLE_TARGET, migratable_target_nodes, location, log_created=True,
+                                      delete_now=delete_now)
 
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
         return
@@ -872,7 +882,7 @@ def __set_atp_connection_property(self, root_location, property_name, property_v
 
         wlst_name, wlst_value = \
             self.aliases.get_wlst_attribute_name_and_value(root_location, DRIVER_PARAMS_PROPERTY_VALUE,
-                                                                property_value)
+                                                           property_value)
         self.wlst_helper.set(wlst_name, wlst_value)
 
         root_location.remove_name_token(property_name)
@@ -931,7 +941,7 @@ def __configure_fmw_infra_database(self):
 
                 wlst_name, wlst_value = \
                     self.aliases.get_wlst_attribute_name_and_value(location, PASSWORD_ENCRYPTED,
-                                                                        rcu_schema_pwd, masked=True)
+                                                                   rcu_schema_pwd, masked=True)
                 self.wlst_helper.set_if_needed(wlst_name, wlst_value, masked=True)
 
                 location.append_location(JDBC_DRIVER_PARAMS_PROPERTIES)
@@ -946,7 +956,7 @@ def __configure_fmw_infra_database(self):
                 stb_user = orig_user.replace('DEV', rcu_prefix)
                 wlst_name, wlst_value = \
                     self.aliases.get_wlst_attribute_name_and_value(location, DRIVER_PARAMS_PROPERTY_VALUE,
-                                                                        stb_user)
+                                                                   stb_user)
                 self.wlst_helper.set_if_needed(wlst_name, wlst_value)
 
                 # need to set other properties
@@ -993,7 +1003,7 @@ def __configure_fmw_infra_database(self):
 
             wlst_name, wlst_value = \
                 self.aliases.get_wlst_attribute_name_and_value(location, PASSWORD_ENCRYPTED,
-                                                                    rcu_schema_pwd, masked=True)
+                                                               rcu_schema_pwd, masked=True)
             self.wlst_helper.set_if_needed(wlst_name, wlst_value, masked=True)
 
             location.append_location(JDBC_DRIVER_PARAMS_PROPERTIES)
@@ -1222,7 +1232,8 @@ def __create_credential_mappings(self):
         """
         Create credential mappings from model elements.
         """
-        default_nodes = dictionary_utils.get_dictionary_element(self._domain_info, WLS_USER_PASSWORD_CREDENTIAL_MAPPINGS)
+        default_nodes = dictionary_utils.get_dictionary_element(self._domain_info,
+                                                                WLS_USER_PASSWORD_CREDENTIAL_MAPPINGS)
         if default_nodes:
             credential_map_helper = CredentialMapHelper(self.model_context, ExceptionType.CREATE)
             credential_map_helper.create_default_init_file(default_nodes)

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

@@ -55,14 +55,15 @@ def __init__(self, model, model_context, aliases, wlst_mode=WlstModes.OFFLINE):
                                                 exception_helper.ExceptionType.DEPLOY)
         return
 
-    def _add_named_elements(self, type_name, model_nodes, location):
+    def _add_named_elements(self, type_name, model_nodes, location, delete_now=True):
         """
         Add each named element from the specified nodes in WLST and set its attributes.
         Sub-folders are processed in a generic manner if present.
         It is assumed that there are no attributes or sub-folders with special processing.
         :param type_name: the type name of the child nodes
         :param model_nodes: the child nodes of a model element
         :param location: the location where elements should be added
+        :param delete_now: Flag to determine whether to delay delete of element
         """
         _method_name = '_add_named_elements'
 
@@ -80,7 +81,8 @@ def _add_named_elements(self, type_name, model_nodes, location):
         token = self.aliases.get_name_token(location)
         for name in model_nodes:
             if model_helper.is_delete_name(name):
-                deployer_utils.delete_named_element(location, name, existing_names, self.aliases)
+                if delete_now:
+                    deployer_utils.delete_named_element(location, name, existing_names, self.aliases)
                 continue
 
             is_add = name not in existing_names

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

@@ -269,6 +269,7 @@ def delete_named_element(location, delete_name, existing_names, aliases):
         type_path = aliases.get_wlst_create_path(location)
         _wlst_helper.cd(type_path)
         _wlst_helper.delete(name, type_name)
+        existing_names.remove(name)
 
 
 def ensure_no_uncommitted_changes_or_edit_sessions(ignoreEditSessionCheck=False):