WDT-853 Fixing SSH Update of structured applications

Author: robertpatrick

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

@@ -500,10 +500,7 @@ def __build_app_deploy_strategy(self, location, model_apps, existing_app_refs, s
 
                 model_src_path = dictionary_utils.get_element(app_dict, SOURCE_PATH)
                 # determine the versioned name of the library from the application's MANIFEST
-                # FIXME - why is from_archive always set to True???
-                versioned_name = \
-                    self.version_helper.get_application_versioned_name(model_src_path, app, from_archive=True)
-
+                versioned_name = self.version_helper.get_application_versioned_name(model_src_path, app)
                 existing_app_ref = dictionary_utils.get_dictionary_element(existing_app_refs, versioned_name)
 
                 # remove deleted targets from the model and the existing app targets
@@ -818,7 +815,6 @@ def __deploy_model_deployments(self, deployments, deployments_location, deployme
             for deployment_name in deploy_ordered_keys:
                 if not model_helper.is_delete_name(deployment_name):
                     deployment_dict = deployments[deployment_name]
-                    src_path = dictionary_utils.get_element(deployment_dict, SOURCE_PATH)
                     stage_mode = dictionary_utils.get_element(deployment_dict, STAGE_MODE)
                     targets = dictionary_utils.get_element(deployment_dict, TARGET)
 
@@ -833,41 +829,43 @@ def __deploy_model_deployments(self, deployments, deployments_location, deployme
                             self._fixup_structured_app_plan_file_config_root(deployment_dict)
 
                     model_source_path = dictionary_utils.get_element(deployment_dict, SOURCE_PATH)
+                    source_path = self.__get_online_deployment_path(deployment_name, deployment_type, SOURCE_PATH, model_source_path)
                     combined_plan_path = self._get_combined_model_plan_path(deployment_dict)
-                    deploy_path = self.__get_online_deployment_path(model_source_path)
-                    plan_path = self.__get_online_deployment_path(combined_plan_path)
+                    plan_path = self.__get_online_deployment_path(deployment_name, deployment_type, PLAN_PATH, combined_plan_path)
 
                     location.add_name_token(token_name, deployment_name)
                     resource_group_template_name, resource_group_name, partition_name = \
                         self._get_mt_names_from_location(location)
 
                     module_type = dictionary_utils.get_element(deployment_dict, MODULE_TYPE)
 
-                    new_name = self.__deploy_app_or_library(deployment_name, deploy_path, targets, plan=plan_path,
-                                                            stage_mode=stage_mode, partition=partition_name,
+                    new_name = self.__deploy_app_or_library(deployment_name, model_source_path, source_path, targets,
+                                                            plan=plan_path, stage_mode=stage_mode,
+                                                            partition=partition_name,
                                                             resource_group=resource_group_name,
                                                             resource_group_template=resource_group_template_name,
                                                             module_type=module_type,
                                                             sub_module_targets=sub_module_targets,
                                                             options=options)
 
                     deployed_names.append(new_name)
-                    self._substitute_appmodule_token(src_path, module_type)
+                    self._substitute_appmodule_token(model_source_path, module_type)
 
                     location.remove_name_token(token_name)
 
         self.logger.exiting(class_name=self._class_name, method_name=_method_name)
         return deployed_names
 
-    def __deploy_app_or_library(self, application_name, source_path, targets, stage_mode=None, plan=None, partition=None,
-                                resource_group=None, resource_group_template=None, sub_module_targets=None,
-                                module_type = None, options=None):
+    def __deploy_app_or_library(self, application_name, model_source_path, deploy_source_path, targets, stage_mode=None,
+                                plan=None, partition=None, resource_group=None, resource_group_template=None,
+                                sub_module_targets=None, module_type = None, options=None):
         """
         Deploy an application or shared library in online mode.
         :param application_name: the name of the app or library from the model
-        :param source_path: the source path of the app or library
+        :param model_source_path: the model source path of the app or library
+        :param deploy_source_path: the full source path of the app or library
         :param targets: the intended targets
-        :param plan: optional, the path to the plan
+        :param plan: optional, the full path to the plan file
         :param partition: optional, the partition
         :param resource_group: optional, the resource group
         :param resource_group_template: optional, the resource group template
@@ -887,42 +885,39 @@ def __deploy_app_or_library(self, application_name, source_path, targets, stage_
 
         real_domain_home = self.model_context.get_domain_home()
 
-        if string_utils.is_empty(source_path):
+        if string_utils.is_empty(model_source_path):
             ex = exception_helper.create_deploy_exception('WLSDPLY-09317', type_name, application_name, SOURCE_PATH)
             self.logger.throwing(ex, class_name=self._class_name, method_name=_method_name)
             raise ex
 
-        full_source_path = source_path
-
-        if self.path_helper.is_relative_local_path(full_source_path):
-            full_source_path = self.path_helper.local_join(real_domain_home, source_path)
-
-        if self.path_helper.is_absolute_local_path(full_source_path) and not self.model_context.is_ssh() \
-                and not os.path.exists(full_source_path):
+        if not self.model_context.is_ssh() and self.path_helper.is_absolute_local_path(deploy_source_path) and \
+                not os.path.exists(deploy_source_path):
             ex = exception_helper.create_deploy_exception('WLSDPLY-09318', type_name, application_name,
-                                                          str_helper.to_string(full_source_path))
+                                                          str_helper.to_string(deploy_source_path))
             self.logger.throwing(ex, class_name=self._class_name, method_name=_method_name)
             raise ex
 
         if is_library:
-            computed_name = self.version_helper.get_library_versioned_name(source_path, application_name,
-                                                                           from_archive=(self.model_context.is_remote() or self.model_context.is_ssh()))
+            computed_name = self.version_helper.get_library_versioned_name(model_source_path, application_name)
         else:
-            computed_name = self.version_helper.get_application_versioned_name(source_path, application_name,
-                                                                               module_type=module_type,
-                                                                               from_archive=(self.model_context.is_remote() or self.model_context.is_ssh()))
+            computed_name = self.version_helper.get_application_versioned_name(model_source_path, application_name,
+                                                                               module_type=module_type)
 
         application_name = computed_name
 
         # build the dictionary of named arguments to pass to the deploy_application method
         args = list()
-        kwargs = {'path': str_helper.to_string(full_source_path), 'targets': str_helper.to_string(targets)}
+        kwargs = {'path': str_helper.to_string(deploy_source_path), 'targets': str_helper.to_string(targets)}
+        if options is not None:
+            is_remote = dictionary_utils.get_element(options, 'remote') == 'true'
+        else:
+            is_remote = False
 
         if plan is not None:
             if self.path_helper.is_relative_local_path(plan):
                 plan = self.path_helper.local_join(real_domain_home, plan)
 
-            if not os.path.exists(plan):
+            if not is_remote and not os.path.exists(plan):
                 ex = exception_helper.create_deploy_exception('WLSDPLY-09319', type_name, application_name, plan)
                 self.logger.throwing(ex, class_name=self._class_name, method_name=_method_name)
                 raise ex
@@ -1165,19 +1160,25 @@ def _replace_deployments_path_tokens(self, deployment_type, deployments_dict):
 
         self.logger.exiting(class_name=self._class_name, method_name=_method_name)
 
-    def __get_online_deployment_path(self, model_path):
+    def __get_online_deployment_path(self, model_name, model_type, attribute_name, attribute_value):
         _method_name = '__get_online_deployment_path'
-        self.logger.entering(model_path, class_name=self._class_name, method_name=_method_name)
+        self.logger.entering(model_name, model_type, attribute_name, attribute_value,
+                             class_name=self._class_name, method_name=_method_name)
 
-        result = model_path
-        if not string_utils.is_empty(model_path):
-            if self.archive_helper and self.archive_helper.is_path_into_archive(model_path):
+        result = attribute_value
+        if not string_utils.is_empty(attribute_value):
+            if self.archive_helper and self.archive_helper.is_path_into_archive(attribute_value):
                 if self.model_context.is_remote():
-                    result = self.path_helper.local_join(self.upload_temporary_dir, model_path)
+                    result = self.path_helper.local_join(self.upload_temporary_dir, attribute_value)
                 elif self.model_context.is_ssh():
-                    result = self.path_helper.remote_join(self.model_context.get_domain_home(), model_path)
+                    result = self.path_helper.remote_join(self.model_context.get_domain_home(), attribute_value)
                 else:
-                    result = self.path_helper.local_join(self.model_context.get_domain_home(), model_path)
+                    result = self.path_helper.local_join(self.model_context.get_domain_home(), attribute_value)
+            elif self.path_helper.is_relative_path(attribute_value):
+                ex = exception_helper.create_deploy_exception('WLSDPLY-09351', model_type, model_name,
+                                                              attribute_name, attribute_value)
+                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=result)
         return result

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

@@ -37,7 +37,7 @@ def __init__(self, model_context, archive_helper):
         self.archive_helper = archive_helper
         self.logger = PlatformLogger('wlsdeploy.deploy')
 
-    def get_library_versioned_name(self, source_path, model_name, from_archive=False):
+    def get_library_versioned_name(self, source_path, model_name):
         """
         Get the proper name of the deployable library that WLST requires in the target domain.  This method is
         primarily needed for shared libraries in the Oracle Home where the implementation version may have
@@ -57,7 +57,7 @@ def get_library_versioned_name(self, source_path, model_name, from_archive=False
             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)
+                manifest = self.__get_manifest(source_path)
                 if manifest is not None:
                     attributes = manifest.getMainAttributes()
 
@@ -86,26 +86,27 @@ def get_library_versioned_name(self, source_path, model_name, from_archive=False
         self.logger.exiting(class_name=self._class_name, method_name=_method_name, result=versioned_name)
         return versioned_name
 
-    def get_application_versioned_name(self, source_path, model_name, from_archive=False, module_type=None):
+    def get_application_versioned_name(self, source_path, model_name, module_type=None):
         """
         Get the proper name of the deployable application that WLST requires in the target domain.
         This method is needed for the case where the application is explicitly versioned in its ear/war manifest.
         Rather than requiring the modeller to have to know/adjust the application name, we extract
         the information from the application's archive file (e.g., war file) and compute the correct name.
         :param source_path: the SourcePath value of the application
         :param model_name: the model name of the application
-        :param from_archive: if True, use the manifest from the archive, otherwise from the file system
+        :param module_type: optional argument to specify the module type being deployed
         :return: the updated application name for the target environment
         :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)
+        self.logger.entering(source_path, model_name, module_type,
+                             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 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)
+                manifest = self.__get_manifest(source_path)
 
                 if manifest is not None:
                     attributes = manifest.getMainAttributes()
@@ -133,12 +134,11 @@ def is_module_type_app_module(self, module_type):
         else:
             return False
 
-    def __get_manifest(self, source_path, from_archive):
+    def __get_manifest(self, source_path):
         """
         Returns the manifest object for the specified path.
         The source path may be a jar, or an exploded path.
         :param source_path: the source path to be checked
-        :param from_archive: if True, use the manifest from the archive, otherwise from the file system
         :return: the manifest, or None if it is not present
         :raises: IOException: if there are problems reading an existing manifest
         """
@@ -148,7 +148,7 @@ def __get_manifest(self, source_path, from_archive):
 
         source_path = self.model_context.replace_token_string(source_path)
 
-        if from_archive and deployer_utils.is_path_into_archive(source_path):
+        if deployer_utils.is_path_into_archive(source_path):
             return self.archive_helper.get_manifest(source_path)
 
         else:

core/src/main/resources/oracle/weblogic/deploy/messages/wlsdeploy_rb.properties

@@ -1438,6 +1438,7 @@ WLSDPLY-09348=Model application {0} is missing the SourcePath attribute but no e
   name of application or add the SourcePath.
 WLSDPLY-09349=Cannot deploy structured application {0} with installation directory {1} with '-remote' option
 WLSDPLY-09350={0} {1} cannot be deployed using the -remote options since the SourcePath {2} and combined PlanDir and PlanPath {3} are not both absolute paths
+WLSDPLY-09351={0} {1} has attribute {2} with a relative path that is not referencing an archive file so the absolute path to the file is not well-defined.
 
 # wlsdeploy/tool/deploy/common_resources_deployer.py
 WLSDPLY-09400=ResourceGroup was specified in the test file but are not supported in WebLogic Server version {0}

integration-tests/apps/pom.xml

@@ -21,5 +21,6 @@
         <module>simple-app-archive</module>
         <module>simple-app-updated-archive</module>
         <module>structured-app</module>
+        <module>versioned-app</module>
     </modules>
 </project>

integration-tests/apps/versioned-app/pom.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Copyright (c) 2024, Oracle and/or its affiliates.
+    Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>weblogic-deploy-system-test-apps-versioned-app</artifactId>
+    <packaging>pom</packaging>
+
+    <parent>
+        <artifactId>weblogic-deploy-system-test-apps</artifactId>
+        <groupId>com.oracle.weblogic.lifecycle</groupId>
+        <version>4.0.0-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+
+    <modules>
+        <module>versioned-app-war</module>
+        <module>versioned-app-archive</module>
+        <module>versioned-app-updated-war</module>
+        <module>versioned-app-updated-archive</module>
+    </modules>
+</project>