JIRA WDT-534 - Remove app/library targets during edit session; factor out online_check_save_activate() (#816)

Author: rakillen

core/src/main/python/deploy.py

@@ -7,10 +7,6 @@
 import os
 import sys
 
-from java.io import PrintStream
-from java.lang import System
-
-
 from oracle.weblogic.deploy.deploy import DeployException
 from oracle.weblogic.deploy.exception import BundleAwareException
 from oracle.weblogic.deploy.util import CLAException
@@ -26,7 +22,6 @@
 from wlsdeploy.tool.deploy import deployer_utils
 from wlsdeploy.tool.deploy import model_deployer
 from wlsdeploy.tool.util import model_context_helper
-from wlsdeploy.tool.util.string_output_stream import StringOutputStream
 from wlsdeploy.tool.util import wlst_helper
 from wlsdeploy.tool.util.wlst_helper import WlstHelper
 from wlsdeploy.util import cla_helper
@@ -136,39 +131,15 @@ def __deploy_online(model, model_context, aliases):
 
     try:
         model_deployer.deploy_resources(model, model_context, aliases, wlst_mode=__wlst_mode)
+        deployer_utils.delete_online_deployment_targets(model, aliases, __wlst_mode)
     except DeployException, de:
-        __release_edit_session_and_disconnect()
+        deployer_utils.release_edit_session_and_disconnect()
         raise de
 
-    exit_code = 0
+    exit_code = deployer_utils.online_check_save_activate(model_context)
 
-    try:
-        # First we enable the stdout again and then redirect the stdoout to a string output stream
-        # call isRestartRequired to get the output, capture the string and then silence wlst output again
-        #
-        __wlst_helper.enable_stdout()
-        sostream = StringOutputStream()
-        System.setOut(PrintStream(sostream))
-        restart_required = __wlst_helper.is_restart_required()
-        is_restartreq_output = sostream.get_string()
-        __wlst_helper.silence()
-        if model_context.is_cancel_changes_if_restart_required() and restart_required:
-            __wlst_helper.cancel_edit()
-            __logger.warning('WLSDPLY_09015', is_restartreq_output)
-            exit_code = CommandLineArgUtil.PROG_CANCEL_CHANGES_IF_RESTART_EXIT_CODE
-            deployer_utils.list_non_dynamic_changes(model_context, is_restartreq_output)
-        else:
-            __wlst_helper.save()
-            __wlst_helper.activate(model_context.get_model_config().get_activate_timeout())
-            if restart_required:
-                deployer_utils.list_non_dynamic_changes(model_context, is_restartreq_output)
-                exit_code = CommandLineArgUtil.PROG_RESTART_REQUIRED
-                exit_code = deployer_utils.list_restarts(model_context, exit_code)
-    except BundleAwareException, ex:
-        __release_edit_session_and_disconnect()
-        raise ex
-
-    model_deployer.deploy_applications(model, model_context, aliases, wlst_mode=__wlst_mode)
+    if exit_code != CommandLineArgUtil.PROG_CANCEL_CHANGES_IF_RESTART_EXIT_CODE:
+        model_deployer.deploy_applications(model, model_context, aliases, wlst_mode=__wlst_mode)
 
     try:
         __wlst_helper.disconnect()
@@ -215,23 +186,6 @@ def __deploy_offline(model, model_context, aliases):
     return 0
 
 
-def __release_edit_session_and_disconnect():
-    """
-    An online error recovery method.
-    """
-    _method_name = '__release_edit_session_and_disconnect'
-    try:
-        __wlst_helper.undo()
-        __wlst_helper.stop_edit()
-        __wlst_helper.disconnect()
-    except BundleAwareException, ex:
-        # This method is only used for cleanup after an error so don't mask
-        # the original problem by throwing yet another exception...
-        __logger.warning('WLSDPLY-09012', ex.getLocalizedMessage(), error=ex,
-                         class_name=_class_name, method_name=_method_name)
-    return
-
-
 def __close_domain_on_error():
     """
     An offline error recovery method.

core/src/main/python/update.py

@@ -7,9 +7,6 @@
 import os
 import sys
 
-from java.io import PrintStream
-from java.lang import System
-
 from oracle.weblogic.deploy.deploy import DeployException
 from oracle.weblogic.deploy.exception import BundleAwareException
 from oracle.weblogic.deploy.util import CLAException
@@ -30,7 +27,6 @@
 from wlsdeploy.tool.util import wlst_helper
 from wlsdeploy.tool.util.wlst_helper import WlstHelper
 from wlsdeploy.tool.util.rcu_helper import RCUHelper
-from wlsdeploy.tool.util.string_output_stream import StringOutputStream
 from wlsdeploy.util import cla_helper
 from wlsdeploy.util import tool_exit
 from wlsdeploy.util.cla_utils import CommandLineArgUtil
@@ -143,7 +139,7 @@ def __update_online(model, model_context, aliases):
         topology_updater.update_machines_clusters_and_servers(delete_now=False)
         topology_updater.warn_set_server_groups()
     except DeployException, de:
-        __release_edit_session_and_disconnect()
+        deployer_utils.release_edit_session_and_disconnect()
         raise de
 
     # Server or Cluster may be added, this is to make sure they are targeted properly
@@ -163,11 +159,12 @@ def __update_online(model, model_context, aliases):
     try:
         topology_updater.update()
         model_deployer.deploy_resources(model, model_context, aliases, wlst_mode=__wlst_mode)
+        deployer_utils.delete_online_deployment_targets(model, aliases, __wlst_mode)
     except DeployException, de:
-        __release_edit_session_and_disconnect()
+        deployer_utils.release_edit_session_and_disconnect()
         raise de
 
-    exit_code = __check_update_require_domain_restart(model_context)
+    exit_code = deployer_utils.online_check_save_activate(model_context)
     # if user requested cancel changes if restart required stops
 
     if exit_code != CommandLineArgUtil.PROG_CANCEL_CHANGES_IF_RESTART_EXIT_CODE:
@@ -183,40 +180,6 @@ def __update_online(model, model_context, aliases):
     return exit_code
 
 
-def __check_update_require_domain_restart(model_context):
-    _method_name = '__check_update_require_domain_restart'
-    exit_code = 0
-    try:
-        # First we enable the stdout again and then redirect the stdoout to a string output stream
-        # call isRestartRequired to get the output, capture the string and then silence wlst output again
-        #
-
-        __wlst_helper.enable_stdout()
-        sostream = StringOutputStream()
-        System.setOut(PrintStream(sostream))
-        restart_required = __wlst_helper.is_restart_required()
-        is_restartreq_output = sostream.get_string()
-        __wlst_helper.silence()
-        if model_context.is_cancel_changes_if_restart_required() and restart_required:
-            __wlst_helper.cancel_edit()
-            __logger.warning('WLSDPLY_09015', is_restartreq_output)
-            exit_code = CommandLineArgUtil.PROG_CANCEL_CHANGES_IF_RESTART_EXIT_CODE
-            deployer_utils.list_non_dynamic_changes(model_context, is_restartreq_output)
-        else:
-            __wlst_helper.save()
-            __wlst_helper.activate(model_context.get_model_config().get_activate_timeout())
-            if restart_required:
-                exit_code = CommandLineArgUtil.PROG_RESTART_REQUIRED
-                deployer_utils.list_non_dynamic_changes(model_context, is_restartreq_output)
-                exit_code = deployer_utils.list_restarts(model_context, exit_code)
-
-    except BundleAwareException, ex:
-        __release_edit_session_and_disconnect()
-        raise ex
-
-    return exit_code
-
-
 def __update_offline(model, model_context, aliases):
     """
     Offline update orchestration
@@ -271,23 +234,6 @@ def __update_offline_domain():
         raise ex
 
 
-def __release_edit_session_and_disconnect():
-    """
-    An online error recovery method.
-    """
-    _method_name = '__release_edit_session_and_disconnect'
-    try:
-        __wlst_helper.undo()
-        __wlst_helper.stop_edit()
-        __wlst_helper.disconnect()
-    except BundleAwareException, ex:
-        # This method is only used for cleanup after an error so don't mask
-        # the original problem by throwing yet another exception...
-        __logger.warning('WLSDPLY-09012', ex.getLocalizedMessage(), error=ex,
-                         class_name=_class_name, method_name=_method_name)
-    return
-
-
 def __close_domain_on_error():
     """
     An offline error recovery method.

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

@@ -232,23 +232,16 @@ def __online_deploy_apps_and_libs(self, base_location):
         # libraries to be undeployed
         update_library_list = list()
 
-        # app targets to be deleted
-        app_delete_targets = dict()
-
-        # library targets to be deleted
-        lib_delete_targets = dict()
-
         lib_location = LocationContext(base_location).append_location(LIBRARY)
         # Go through the model libraries and find existing libraries that are referenced
         # by applications and compute a processing strategy for each library.
         self.__build_library_deploy_strategy(lib_location, model_shared_libraries, existing_lib_refs,
-                                             stop_app_list, update_library_list, stop_and_undeploy_app_list,
-                                             lib_delete_targets)
+                                             stop_app_list, update_library_list, stop_and_undeploy_app_list)
 
         # Go through the model applications and compute the processing strategy for each application.
         app_location = LocationContext(base_location).append_location(APPLICATION)
         self.__build_app_deploy_strategy(app_location, model_applications, existing_app_refs,
-                                         stop_and_undeploy_app_list, app_delete_targets)
+                                         stop_and_undeploy_app_list)
 
         # deployed_app_list is list of apps that has been deployed and stareted again
         # redeploy_app_list is list of apps that needs to be redeplyed
@@ -268,18 +261,6 @@ def __online_deploy_apps_and_libs(self, base_location):
             self.__stop_app(app)
             self.__undeploy_app(app)
 
-        # targets were deleted from an app, so undeploy for those specific targets
-        for app in app_delete_targets:
-            delete_targets = app_delete_targets[app]
-            if delete_targets:
-                self.__undeploy_app(app, targets=delete_targets)
-
-        # targets were deleted from a library, so undeploy for those specific targets
-        for lib in lib_delete_targets:
-            delete_targets = lib_delete_targets[lib]
-            if delete_targets:
-                self.__undeploy_app(lib, library_module='true', targets=delete_targets)
-
         # library is updated, it must be undeployed first
         for lib in update_library_list:
             self.__undeploy_app(lib, library_module='true')
@@ -521,7 +502,7 @@ def __get_library_references(self, base_location):
         return existing_libraries
 
     def __build_library_deploy_strategy(self, location, model_libs, existing_lib_refs, stop_app_list,
-                                        update_library_list, stop_and_undeploy_app_list, lib_delete_targets):
+                                        update_library_list, stop_and_undeploy_app_list):
         """
         Update maps and lists to control re-deployment processing.
         :param location: the location of the libraries
@@ -530,7 +511,6 @@ def __build_library_deploy_strategy(self, location, model_libs, existing_lib_ref
         :param stop_app_list: a list to update with dependent apps to be stopped and undeployed
         :param update_library_list: a list to update with libraries to be stopped before deploying
         :param stop_and_undeploy_app_list: a list to update with libraries to be stopped and undeployed
-        :param lib_delete_targets: a map to update with delete targets for libraries
         """
         _method_name = '__build_library_deploy_strategy'
 
@@ -563,9 +543,8 @@ def __build_library_deploy_strategy(self, location, model_libs, existing_lib_ref
 
                 existing_lib_ref = dictionary_utils.get_dictionary_element(existing_lib_refs, versioned_name)
 
-                # collect the delete targets, and remove them from the model and existing targets
-                lib_delete_targets[versioned_name] = \
-                    self.__extract_delete_targets(lib_dict, existing_lib_ref, location, lib)
+                # remove deleted targets from the model and the existing library targets
+                self.__remove_delete_targets(lib_dict, existing_lib_ref)
 
                 if versioned_name in existing_libs:
                     # skipping absolute path libraries if they are the same
@@ -628,15 +607,13 @@ def __build_library_deploy_strategy(self, location, model_libs, existing_lib_ref
                                 lib_dict['SourcePath'] = existing_src_path
         return
 
-    def __build_app_deploy_strategy(self, location, model_apps, existing_app_refs, stop_and_undeploy_app_list,
-                                    app_delete_targets):
+    def __build_app_deploy_strategy(self, location, model_apps, existing_app_refs, stop_and_undeploy_app_list):
         """
         Update maps and lists to control re-deployment processing.
         :param location: the location of the applications
         :param model_apps: a copy of applications from the model, attributes may be revised
         :param existing_app_refs: map of information about each existing app
         :param stop_and_undeploy_app_list: a list to update with apps to be stopped and undeployed
-        :param app_delete_targets: a map to update with delete targets for applications
         """
         _method_name = '__build_app_deploy_strategy'
 
@@ -665,9 +642,8 @@ def __build_app_deploy_strategy(self, location, model_apps, existing_app_refs, s
 
                 existing_app_ref = dictionary_utils.get_dictionary_element(existing_app_refs, versioned_name)
 
-                # collect the delete targets, and remove them from the model and existing targets
-                app_delete_targets[versioned_name] = \
-                    self.__extract_delete_targets(app_dict, existing_app_ref, location, app)
+                # remove deleted targets from the model and the existing app targets
+                self.__remove_delete_targets(app_dict, existing_app_ref)
 
                 if versioned_name in existing_apps:
                     # Compare the hashes of the domain's existing apps to the model's apps.
@@ -719,17 +695,13 @@ def __build_app_deploy_strategy(self, location, model_apps, existing_app_refs, s
                         stop_and_undeploy_app_list.append(versioned_name)
         return
 
-    def __extract_delete_targets(self, model_dict, existing_ref, location, name):
+    def __remove_delete_targets(self, model_dict, existing_ref):
         """
-        Create a comma-separated list of targets to be deleted for an app or library.
-        Remove those targets from the model and existing target dictionaries.
+        Remove deleted targets from the model and existing target dictionaries.
         :param model_dict: the model dictionary for the app or library, may be modified
         :param existing_ref: the existing dictionary for the app or library, may be modified
-        :param location: the location of the app or library, for logging
-        :param name: the name of the app or library, for logging
-        :return: a comma-separated list of targets to be removed, empty string for no targets
         """
-        _method_name = '__extract_delete_targets'
+        _method_name = '__remove_delete_targets'
 
         model_targets = dictionary_utils.get_element(model_dict, TARGET)
         model_targets = alias_utils.create_list(model_targets, 'WLSDPLY-08000')
@@ -738,23 +710,15 @@ def __extract_delete_targets(self, model_dict, existing_ref, location, name):
         if not existing_targets:
             existing_targets = list()
 
-        delete_targets = []
         model_targets_iterator = list(model_targets)
         for model_target in model_targets_iterator:
             if model_helper.is_delete_name(model_target):
                 model_targets.remove(model_target)
                 target_name = model_helper.get_delete_item_name(model_target)
                 if target_name in existing_targets:
                     existing_targets.remove(target_name)
-                    delete_targets.append(target_name)
-                else:
-                    location.add_name_token(self.aliases.get_name_token(location), name)
-                    location_path = self.aliases.get_model_folder_path(location)
-                    self.logger.warning('WLSDPLY-08022', model_target, TARGET, location_path,
-                                        class_name=self._class_name, method_name=_method_name)
 
         model_dict[TARGET] = ",".join(model_targets)
-        return ",".join(delete_targets)
 
     def __verify_delete_versioned_app(self, app, existing_apps, type='app'):
         """