Adding common code to detect the structured app install root directory

Author: robertpatrick

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

@@ -27,10 +27,12 @@
 from wlsdeploy.aliases.model_constants import SOURCE_PATH
 from wlsdeploy.aliases.wlst_modes import WlstModes
 from wlsdeploy.exception import exception_helper
+from wlsdeploy.exception.exception_types import ExceptionType
 from wlsdeploy.tool.deploy import deployer_utils
 from wlsdeploy.tool.deploy.applications_version_helper import ApplicationsVersionHelper
 from wlsdeploy.tool.deploy.deployer import Deployer
 from wlsdeploy.tool.util import appmodule_helper
+from wlsdeploy.tool.util import structured_apps_helper
 from wlsdeploy.util import dictionary_utils
 from wlsdeploy.util import model_helper
 from wlsdeploy.util import string_utils
@@ -182,16 +184,17 @@ def _fixup_structured_app_plan_file_config_root(self, structured_app_dict):
                         # best effort only...
                         pass
 
-    def _is_structured_app(self, app_dict):
+    def _is_structured_app(self, app_name, app_dict):
         """
         Is the application represented by the dictionary a structured application?  It is the caller's responsibility
         to only call this method for applications and not shared libraries!
 
+        :param app_name: the application name
         :param app_dict: the model dictionary representing the application
         :return: True, structured_app_dir if the application is a structured application; False, None otherwise
         """
         _method_name = 'is_structured_app'
-        self.logger.entering(app_dict, class_name=self._class_name, method_name=_method_name)
+        self.logger.entering(app_name, app_dict, class_name=self._class_name, method_name=_method_name)
 
         result = False
         structured_app_dir = None
@@ -203,7 +206,7 @@ def _is_structured_app(self, app_dict):
 
             if not result:
                 result, structured_app_dir = \
-                    self.__is_external_structured_app(model_source_path, combined_plan_path)
+                    self.__is_external_structured_app(app_name, model_source_path, combined_plan_path)
 
         self.logger.exiting(class_name=self._class_name, method_name=_method_name, result=[result, structured_app_dir])
         return result, structured_app_dir
@@ -328,7 +331,7 @@ def _extract_deployment_from_archive(self, deployment_name, deployment_type, dep
             is_structured_app = False
             structured_app_dir = None
             if deployment_type == APPLICATION:
-                is_structured_app, structured_app_dir = self._is_structured_app(deployment_dict)
+                is_structured_app, structured_app_dir = self._is_structured_app(deployment_name, deployment_dict)
 
             if is_structured_app:
                 # is_structured_app() only returns true if both the app and the plan have similar paths.
@@ -515,33 +518,18 @@ def __is_archived_structured_app(self, model_source_path, combined_plan_path):
         self.logger.exiting(class_name=self._class_name, method_name=_method_name, result=[result, structured_app_dir])
         return result, structured_app_dir
 
-    def __is_external_structured_app(self, model_source_path, combined_plan_path):
+    def __is_external_structured_app(self, app_name, model_source_path, combined_plan_path):
         _method_name = '__is_external_structured_app'
-        self.logger.entering(model_source_path, combined_plan_path,
+        self.logger.entering(app_name, model_source_path, combined_plan_path,
                              class_name=self._class_name, method_name=_method_name)
 
-        result = False
         structured_app_dir = None
         if not string_utils.is_empty(model_source_path) and not string_utils.is_empty(combined_plan_path) \
                 and not WLSDeployArchive.isPathIntoArchive(model_source_path):
-
-            source_path_to_compare = model_source_path.replace('\\', '/')
-            plan_path_to_compare = combined_plan_path.replace('\\', '/')
-
-            # Try to determine the structured application_directory as best we can.
-            source_path_elements = source_path_to_compare.split('/')
-            app_dir_index = -1
-            for idx, source_path_element in enumerate(source_path_elements):
-                # Search the entire list since the path could include multiple directories named 'app'
-                # and we always want the last one.
-                if source_path_element.lower() == 'app':
-                    app_dir_index = idx
-
-            if app_dir_index > 0:
-                fake_str_app_dir = '/'.join(source_path_elements[0:app_dir_index])
-                if plan_path_to_compare.startswith(fake_str_app_dir + '/'):
-                    result = True
-                    structured_app_dir = model_source_path[0:len(fake_str_app_dir)]
+            structured_app_dir = \
+                structured_apps_helper.get_structured_app_install_root(app_name, model_source_path, combined_plan_path,
+                                                                       ExceptionType.DEPLOY)
+        result = not string_utils.is_empty(structured_app_dir)
 
         self.logger.exiting(class_name=self._class_name, method_name=_method_name, result=[result, structured_app_dir])
         return result, structured_app_dir

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

@@ -128,7 +128,7 @@ def __deploy_applications(self):
                 self._set_attributes_and_add_subfolders(application_location, application)
 
                 self._substitute_appmodule_token(app_source_path, module_type)
-                is_structured_app, __ = self._is_structured_app(application)
+                is_structured_app, __ = self._is_structured_app(application_name, application)
                 if is_structured_app:
                     self._fixup_structured_app_plan_file_config_root(application)
 

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

@@ -824,7 +824,7 @@ def __deploy_model_deployments(self, deployments, deployments_location, deployme
                     self._extract_deployment_from_archive(deployment_name, deployment_type, deployment_dict)
 
                     if deployment_type == APPLICATION:
-                        is_structured_app, _ = self._is_structured_app(deployment_dict)
+                        is_structured_app, _ = self._is_structured_app(deployment_name, deployment_dict)
                         if is_structured_app:
                             self._fixup_structured_app_plan_file_config_root(deployment_dict)
 

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

@@ -26,11 +26,14 @@
 from wlsdeploy.aliases.model_constants import SOURCE_PATH
 from wlsdeploy.aliases.wlst_modes import WlstModes
 from wlsdeploy.exception import exception_helper
+from wlsdeploy.exception.exception_types import ExceptionType
 from wlsdeploy.logging.platform_logger import PlatformLogger
 from wlsdeploy.tool.discover import discoverer
 from wlsdeploy.tool.discover.discoverer import Discoverer
+from wlsdeploy.tool.util import structured_apps_helper
 from wlsdeploy.util import dictionary_utils
 from wlsdeploy.util import path_helper
+from wlsdeploy.util import string_utils
 
 _class_name = 'DeploymentsDiscoverer'
 _logger = PlatformLogger(discoverer.get_discover_logger_name())
@@ -442,45 +445,17 @@ def _is_structured_app(self, application_name, application_dict):
         _logger.finer('WLSDPLY-06405', application_name, source_path, plan_dir, plan_path,
                       class_name=_class_name, method_name=_method_name)
 
-        if source_path is None:
+        if string_utils.is_empty(source_path):
             de = exception_helper.create_discover_exception('WLSDPLY-06404', application_name)
             _logger.throwing(class_name=_class_name, method_name=_method_name, error=de)
             raise de
-        if plan_path is None:
+        if string_utils.is_empty(plan_path):
             _logger.exiting(class_name=_class_name, method_name=_method_name, result=[False, None])
             return False, None
 
-        if self.path_helper.is_relative_path(source_path):
-            source_path = self.path_helper.join(self._model_context.get_domain_home(), source_path)
-            source_path = self.path_helper.get_canonical_path(source_path)
-
-        source_path_parent = self.path_helper.get_parent_directory(source_path)
-        _logger.finer('WLSDPLY-06406', application_name, source_path_parent,
-                      class_name=_class_name, method_name=_method_name)
-        if source_path_parent is None or \
-                self.path_helper.basename(source_path_parent) != 'app' or \
-                self.path_helper.get_parent_directory(source_path_parent) == source_path_parent:
-            _logger.exiting(class_name=_class_name, method_name=_method_name, result=[False, None])
-            return False, None
-
-        # _get_app_install_root() only needs a path to either the PlanDir or the PlanPath to determine
-        # if this application is a structured app.
-        #
-        if plan_dir is None:
-            if self.path_helper.is_relative_path(plan_path):
-                plan_path = self.path_helper.join(self._model_context.get_domain_home(), plan_path)
-                plan_path = self.path_helper.get_canonical_path(plan_path)
-            effective_plan = plan_path
-        else:
-            if self.path_helper.is_relative_path(plan_dir):
-                plan_dir = self.path_helper.join(self._model_context.get_domain_home(), plan_dir)
-                plan_dir = self.path_helper.get_canonical_path(plan_dir)
-            effective_plan = plan_dir
-
-        install_root_dir = self._get_app_install_root(source_path_parent, effective_plan)
+        install_root_dir = self._get_structured_app_install_root(application_name, source_path, plan_dir, plan_path)
         if install_root_dir is not None:
-            _logger.exiting(class_name=_class_name, method_name=_method_name,
-                            result=[True, install_root_dir])
+            _logger.exiting(class_name=_class_name, method_name=_method_name, result=[True, install_root_dir])
             return True, install_root_dir
 
         _logger.exiting(class_name=_class_name, method_name=_method_name, result=[False, None])
@@ -671,15 +646,39 @@ def _resolve_deployment_plan_path(self, plan_dir, plan_path):
             return self.path_helper.get_canonical_path(plan_path, relative_to=relative_to)
         return plan_path
 
-    def _get_app_install_root(self, app_dir, plan_dir):
-        _method_name = '_get_app_install_root'
-        _logger.entering(app_dir, plan_dir, class_name=_class_name, method_name=_method_name)
+    def _get_structured_app_install_root(self, app_name, source_path, plan_dir, plan_path):
+        """
+        This method tries to determine if this is a structured application and if so, returns the
+        install root directory.
+
+        :param app_name:    The application name
+        :param source_path: The application source path (already validated as not None)
+        :param plan_dir:    The application plan directory, if set
+        :param plan_path:   The application plan path (already validated as not None)
+        :return: The structured application install root directory or None, if it is not a structured application
+        """
+        _method_name = '_get_structured_app_install_root'
+        _logger.entering(app_name, source_path, plan_dir, plan_path,
+                         class_name=_class_name, method_name=_method_name)
+
+        full_source_path = source_path
+        if self.path_helper.is_relative_path(source_path):
+            full_source_path = self.path_helper.join(self._model_context.get_domain_home(), source_path)
+            full_source_path = self.path_helper.get_canonical_path(full_source_path)
 
-        app_install_root = self.path_helper.get_parent_directory(app_dir)
-        if plan_dir.startswith(app_install_root):
-            install_root = app_install_root
+        full_plan_path = plan_path
+        if string_utils.is_empty(plan_dir):
+            if self.path_helper.is_relative_path(plan_path):
+                full_plan_path = self.path_helper.join(self._model_context.get_domain_home(), plan_path)
+                full_plan_path = self.path_helper.get_canonical_path(full_plan_path)
         else:
-            install_root = None
+            full_plan_path = self.path_helper.join(plan_dir, plan_path)
+            if self.path_helper.is_relative_path(full_plan_path):
+                full_plan_path = self.path_helper.join(self._model_context.get_domain_home(), full_plan_path)
+                full_plan_path = self.path_helper.get_canonical_path(full_plan_path)
+
+        install_root = structured_apps_helper.get_structured_app_install_root(app_name, full_source_path,
+                                                                              full_plan_path, ExceptionType.DISCOVER)
 
         _logger.exiting(class_name=_class_name, method_name=_method_name, result=install_root)
         return install_root
@@ -695,6 +694,7 @@ def _get_dictionary_attribute_with_path_tokens_replaced(self, model_dict, attrib
         _logger.exiting(class_name=_class_name, method_name=_method_name, result=result)
         return result
 
+
 def _generate_new_plan_name(binary_path, plan_path):
     """
     Generate a new plan name from the plan path and binary path.