Merge branch 'app_lib_deploy_rewrite' into 'develop-4.0'

App, lib deploy rewrite

See merge request weblogic-cloud/weblogic-deploy-tooling!1641

Author: robertpatrick

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

@@ -50,37 +50,38 @@ def get_library_versioned_name(self, source_path, model_name, from_archive=False
         :raises: DeployException: if an error occurs
         """
         _method_name = 'get_library_versioned_name'
-
         self.logger.entering(source_path, model_name, class_name=self._class_name, method_name=_method_name)
 
-        old_name_tuple = deployer_utils.get_library_name_components(model_name)
-        try:
-            versioned_name = old_name_tuple[self._EXTENSION_INDEX]
-            manifest = self.__get_manifest(source_path, from_archive)
-            if manifest is not None:
-                attributes = manifest.getMainAttributes()
-
-                extension_name = attributes.getValue(EXTENSION_NAME)
-                if not string_utils.is_empty(extension_name):
-                    versioned_name = extension_name
-
-                specification_version = attributes.getValue(SPECIFICATION_VERSION)
-                if not string_utils.is_empty(specification_version):
-                    versioned_name += '#' + specification_version
-
-                    # Cannot specify an impl version without a spec version
-                    implementation_version = attributes.getValue(IMPLEMENTATION_VERSION)
-                    if not string_utils.is_empty(implementation_version):
-                        versioned_name += '@' + implementation_version
-
-                self.logger.info('WLSDPLY-09324', model_name, versioned_name,
-                                 class_name=self._class_name, method_name=_method_name)
-
-        except (IOException, FileNotFoundException, ZipException, IllegalStateException), e:
-            ex = exception_helper.create_deploy_exception('WLSDPLY-09325', model_name, source_path,
-                                                          str_helper.to_string(e), error=e)
-            self.logger.throwing(ex, class_name=self._class_name, method_name=_method_name)
-            raise ex
+        versioned_name = model_name
+        if not string_utils.is_empty(model_name):
+            old_name_tuple = deployer_utils.get_library_name_components(model_name)
+            try:
+                versioned_name = old_name_tuple[self._EXTENSION_INDEX]
+                manifest = self.__get_manifest(source_path, from_archive)
+                if manifest is not None:
+                    attributes = manifest.getMainAttributes()
+
+                    extension_name = attributes.getValue(EXTENSION_NAME)
+                    if not string_utils.is_empty(extension_name):
+                        versioned_name = extension_name
+
+                    specification_version = attributes.getValue(SPECIFICATION_VERSION)
+                    if not string_utils.is_empty(specification_version):
+                        versioned_name += '#' + specification_version
+
+                        # Cannot specify an impl version without a spec version
+                        implementation_version = attributes.getValue(IMPLEMENTATION_VERSION)
+                        if not string_utils.is_empty(implementation_version):
+                            versioned_name += '@' + implementation_version
+
+                    self.logger.info('WLSDPLY-09324', model_name, versioned_name,
+                                     class_name=self._class_name, method_name=_method_name)
+
+            except (IOException, FileNotFoundException, ZipException, IllegalStateException), e:
+                ex = exception_helper.create_deploy_exception('WLSDPLY-09325', model_name, source_path,
+                                                              str_helper.to_string(e), error=e)
+                self.logger.throwing(ex, class_name=self._class_name, method_name=_method_name)
+                raise ex
 
         self.logger.exiting(class_name=self._class_name, method_name=_method_name, result=versioned_name)
         return versioned_name
@@ -98,32 +99,30 @@ def get_application_versioned_name(self, source_path, model_name, from_archive=F
         :raises: DeployException: if an error occurs
         """
         _method_name = 'get_application_versioned_name'
-
         self.logger.entering(source_path, model_name, class_name=self._class_name, method_name=_method_name)
 
         # if no manifest version is found, leave the original name unchanged
         versioned_name = model_name
-        if self.is_module_type_app_module(module_type):
-            return model_name
-        try:
-            manifest = self.__get_manifest(source_path, from_archive)
-
-            if manifest is not None:
-                attributes = manifest.getMainAttributes()
-                application_version = attributes.getValue(self._APP_VERSION_MANIFEST_KEY)
-                if application_version is not None:
-                    # replace any version information in the model name
-                    model_name_tuple = deployer_utils.get_library_name_components(model_name)
-                    versioned_name = model_name_tuple[self._EXTENSION_INDEX]
-                    versioned_name = versioned_name + '#' + application_version
-                    self.logger.info('WLSDPLY-09328', model_name, versioned_name, class_name=self._class_name,
-                                     method_name=_method_name)
-
-        except (IOException, FileNotFoundException, ZipException, IllegalStateException), e:
-            ex = exception_helper.create_deploy_exception('WLSDPLY-09329', model_name, source_path,
-                                                          str_helper.to_string(e), error=e)
-            self.logger.throwing(ex, class_name=self._class_name, method_name=_method_name)
-            raise ex
+        if not self.is_module_type_app_module(module_type) and not string_utils.is_empty(source_path):
+            try:
+                manifest = self.__get_manifest(source_path, from_archive)
+
+                if manifest is not None:
+                    attributes = manifest.getMainAttributes()
+                    application_version = attributes.getValue(self._APP_VERSION_MANIFEST_KEY)
+                    if application_version is not None:
+                        # replace any version information in the model name
+                        model_name_tuple = deployer_utils.get_library_name_components(model_name)
+                        versioned_name = model_name_tuple[self._EXTENSION_INDEX]
+                        versioned_name = versioned_name + '#' + application_version
+                        self.logger.info('WLSDPLY-09328', model_name, versioned_name,
+                                         class_name=self._class_name, method_name=_method_name)
+
+            except (IOException, FileNotFoundException, ZipException, IllegalStateException), e:
+                ex = exception_helper.create_deploy_exception('WLSDPLY-09329', model_name, source_path,
+                                                              str_helper.to_string(e), error=e)
+                self.logger.throwing(ex, class_name=self._class_name, method_name=_method_name)
+                raise ex
 
         self.logger.exiting(class_name=self._class_name, method_name=_method_name, result=versioned_name)
         return versioned_name

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

@@ -50,6 +50,8 @@
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.exception.exception_types import ExceptionType
 from wlsdeploy.logging import platform_logger
+from wlsdeploy.tool.deploy.applications_offline_deployer import OfflineApplicationsDeployer
+from wlsdeploy.tool.deploy.applications_online_deployer import OnlineApplicationsDeployer
 from wlsdeploy.tool.util import results_file
 from wlsdeploy.tool.util.string_output_stream import StringOutputStream
 from wlsdeploy.tool.util.wlst_helper import WlstHelper
@@ -66,6 +68,14 @@
 _wlst_helper = WlstHelper(ExceptionType.DEPLOY)
 
 
+def get_applications_deployer(model, model_context, aliases, wlst_mode=WlstModes.OFFLINE, location=LocationContext()):
+    if wlst_mode == WlstModes.OFFLINE:
+        app_deployer = OfflineApplicationsDeployer(model, model_context, aliases, base_location=location)
+    else:
+        app_deployer = OnlineApplicationsDeployer(model, model_context, aliases, base_location=location)
+    return app_deployer
+
+
 def get_existing_object_list(location, aliases):
     """
     Get a list of the existing names at the specified location.

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

@@ -12,7 +12,6 @@
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.logging.platform_logger import PlatformLogger
 from wlsdeploy.tool.deploy import deployer_utils
-from wlsdeploy.tool.deploy.applications_deployer import ApplicationsDeployer
 from wlsdeploy.tool.deploy.deployer import Deployer
 from wlsdeploy.tool.deploy.resources_deployer import ResourcesDeployer
 
@@ -29,7 +28,8 @@ class ModelDeployer(Deployer):
     def __init__(self, model, model_context, aliases, wlst_mode=WlstModes.OFFLINE):
         Deployer.__init__(self, model, model_context, aliases, wlst_mode)
         self.resources_deployer = ResourcesDeployer(model, model_context, aliases, wlst_mode=wlst_mode)
-        self.applications_deployer = ApplicationsDeployer(model, model_context, aliases, wlst_mode=wlst_mode)
+        self.applications_deployer = \
+            deployer_utils.get_applications_deployer(model, model_context, aliases, wlst_mode=wlst_mode)
 
     def deploy_resources(self):
         """

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

@@ -10,7 +10,7 @@
 from wlsdeploy.aliases.model_constants import RESOURCE_GROUP
 from wlsdeploy.aliases.model_constants import RESOURCE_GROUP_TEMPLATE
 from wlsdeploy.aliases.model_constants import RESOURCE_MANAGEMENT
-from wlsdeploy.tool.deploy.applications_deployer import ApplicationsDeployer
+from wlsdeploy.tool.deploy import deployer_utils
 from wlsdeploy.tool.deploy.coherence_resources_deployer import CoherenceResourcesDeployer
 from wlsdeploy.tool.deploy.common_resources_deployer import CommonResourcesDeployer
 from wlsdeploy.tool.deploy.datasource_deployer import DatasourceDeployer
@@ -121,8 +121,8 @@ def _add_resource_group_resources(self, parent_dict, location):
         coherence_deployer = CoherenceResourcesDeployer(self.model, self.model_context, self.aliases, self.wlst_mode)
         coherence_deployer.add_coherence_cluster_system_resources(parent_dict, location)
 
-        applications_deployer = \
-            ApplicationsDeployer(self.model, self.model_context, self.aliases, self.wlst_mode, location)
+        applications_deployer = deployer_utils.get_applications_deployer(self.model, self.model_context, self.aliases,
+                                                                         self.wlst_mode, location)
         applications_deployer.deploy()
 
     def _add_partition_work_managers(self, parent_dict, location):

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

@@ -226,6 +226,7 @@ def get_applications(self):
         """
         _method_name = 'get_applications'
         _logger.entering(class_name=_class_name, method_name=_method_name)
+
         result = OrderedDict()
         model_top_folder_name = model_constants.APPLICATION
         location = LocationContext(self._base_location)
@@ -418,12 +419,10 @@ def _add_structured_application_to_archive(self, application_name, application_d
             else:
                 _logger.info('WLSDPLY-06393', application_name, class_name=_class_name, method_name=_method_name)
 
-
         _logger.exiting(class_name=_class_name, method_name=_method_name)
 
     def _is_structured_app(self, application_name, application_dict):
         _method_name = '_is_structured_app'
-
         _logger.entering(application_dict, class_name=_class_name, method_name=_method_name)
 
         source_path = None
@@ -437,29 +436,45 @@ def _is_structured_app(self, application_name, application_dict):
         if 'PlanPath' in application_dict:
             plan_path = application_dict['PlanPath']
 
+        _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:
             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 or plan_dir is None:
+        if plan_path is None:
             _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)
-        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)
 
         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
 
-        install_root_dir = self._get_app_install_root(source_path_parent, plan_dir)
+        # _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)
         if install_root_dir is not None:
             _logger.exiting(class_name=_class_name, method_name=_method_name,
                             result=[True, install_root_dir])

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

@@ -119,28 +119,35 @@ def _populate_model_parameters(self, dictionary, location):
         :return: dictionary of model attribute name and wlst value
         """
         _method_name = '_populate_model_parameters'
+        _logger.entering(dictionary, str_helper.to_string(location),
+                              class_name=_class_name, method_name=_method_name)
+
         wlst_path = self._aliases.get_wlst_attributes_path(location)
         _logger.finer('WLSDPLY-06100', wlst_path, class_name=_class_name, method_name=_method_name)
 
         if not self.wlst_cd(wlst_path, location):
+            _logger.exiting(class_name=_class_name, method_name=_method_name, result=None)
             return
 
         wlst_lsa_params = self._get_attributes_for_current_location(location)
         wlst_did_get = list()
-        _logger.finest('WLSDPLY-06102', self._wlst_helper.get_pwd(), wlst_lsa_params, class_name=_class_name,
-                       method_name=_method_name)
+        _logger.finest('WLSDPLY-06102', self._wlst_helper.get_pwd(), wlst_lsa_params,
+                       class_name=_class_name, method_name=_method_name)
         wlst_get_params = self._get_required_attributes(location)
         _logger.finest('WLSDPLY-06103', str_helper.to_string(location), wlst_get_params,
                        class_name=_class_name, method_name=_method_name)
         if wlst_lsa_params is not None:
             for wlst_lsa_param in wlst_lsa_params:
                 if wlst_lsa_param in wlst_get_params:
+                    _logger.finest('WLSDPLY-06132', wlst_lsa_param,
+                                   class_name=_class_name, method_name=_method_name)
                     success, wlst_value = self._get_attribute_value_with_get(wlst_lsa_param, wlst_path)
                     wlst_did_get.append(wlst_lsa_param)
                     if not success:
                         continue
                 else:
-                    _logger.finer('WLSDPLY-06131', wlst_lsa_param, class_name=_class_name, method_name=_method_name)
+                    _logger.finest('WLSDPLY-06131', wlst_lsa_param,
+                                   class_name=_class_name, method_name=_method_name)
                     wlst_value = wlst_lsa_params[wlst_lsa_param]
 
                 # if attribute was never set (online only), don't add to the model
@@ -160,10 +167,14 @@ def _populate_model_parameters(self, dictionary, location):
         # Find the attributes that are not in the LSA wlst map but are in the alias definitions with GET access
         get_attributes = [get_param for get_param in wlst_get_params if not get_param in wlst_did_get]
         for get_attribute in get_attributes:
+            _logger.finest('WLSDPLY-06133', get_attribute,
+                           class_name=_class_name, method_name=_method_name)
             success, wlst_value = self._get_attribute_value_with_get(get_attribute, wlst_path)
             if success:
                 self._add_to_dictionary(dictionary, location, get_attribute, wlst_value, wlst_path)
 
+        _logger.exiting(class_name=_class_name, method_name=_method_name)
+
     def _omit_from_model(self, location, wlst_lsa_param):
         """
         Determine if the specified attribute should be omitted from the model.

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

@@ -783,8 +783,8 @@ def __validate_path_tokens_attribute(self, attribute_name, attribute_value, mode
         self._logger.finest('value_data_type={0}', value_data_type,
                             class_name=_class_name, method_name=_method_name)
 
-        valid_valus_data_types = ['list', 'string', 'unicode']
-        if value_data_type not in valid_valus_data_types:
+        valid_value_data_types = ['list', 'string', 'unicode']
+        if value_data_type not in valid_value_data_types:
             self._logger.severe('WLSDPLY-05023', attribute_name, model_folder_path, value_data_type,
                                 class_name=_class_name, method_name=_method_name)
         else:
@@ -803,6 +803,8 @@ def __validate_path_tokens_attribute(self, attribute_name, attribute_value, mode
             for item_path in attr_values:
                 self.__validate_single_path_in_archive(item_path.strip(), attribute_name, model_folder_path)
 
+        self._logger.exiting(class_name=_class_name, method_name=_method_name)
+
     def __validate_single_path_in_archive(self, path, attribute_name, model_folder_path):
         _method_name = '__validate_single_path_in_archive'