Merge branch 'master' into wdt_issue_246

Author: gosurya-oracle

core/src/__init__.py

@@ -404,7 +404,10 @@ def main(args):
             __logger.severe('WLSDPLY-20008', _program_name, ex.getLocalizedMessage(), error=ex,
                             class_name=_class_name, method_name=_method_name)
         __clean_up_temp_files()
-        tool_exit.end(None, exit_code)
+
+        # create a minimal model for summary logging
+        model_context = ModelContext(_program_name, dict())
+        tool_exit.end(model_context, exit_code)
 
     model_file = model_context.get_model_file()
     try:

core/src/main/__init__.py

@@ -446,7 +446,10 @@ def main(args):
             __logger.severe('WLSDPLY-20008', _program_name, ex.getLocalizedMessage(), error=ex,
                             class_name=_class_name, method_name=_method_name)
         __clean_up_temp_files()
-        tool_exit.end(None, exit_code)
+
+        # create a minimal model for summary logging
+        model_context = ModelContext(_program_name, dict())
+        tool_exit.end(model_context, exit_code)
 
     model_file = model_context.get_model_file()
     try:

core/src/main/python/create.py

@@ -489,7 +489,10 @@ def main(args):
         if exit_code != CommandLineArgUtil.HELP_EXIT_CODE:
             __logger.severe('WLSDPLY-20008', _program_name, ex.getLocalizedMessage(), error=ex,
                             class_name=_class_name, method_name=_method_name)
-        __log_and_exit(None, exit_code, _class_name, _method_name)
+
+        # create a minimal model for summary logging
+        model_context = ModelContext(_program_name, dict())
+        __log_and_exit(model_context, exit_code, _class_name, _method_name)
 
     try:
         __clear_archive_file(model_context)

core/src/main/python/deploy.py

@@ -465,7 +465,10 @@ def main(args):
             __logger.severe('WLSDPLY-20008', _program_name, ex.getLocalizedMessage(), error=ex,
                             class_name=_class_name, method_name=_method_name)
         __clean_up_temp_files()
-        tool_exit.end(None, exit_code)
+
+        # create a minimal model for summary logging
+        model_context = ModelContext(_program_name, dict())
+        tool_exit.end(model_context, exit_code)
 
     model_file = model_context.get_model_file()
     try:

core/src/main/python/discover.py

@@ -76,6 +76,7 @@
 from wlsdeploy.tool.util.archive_helper import ArchiveHelper
 from wlsdeploy.tool.util.library_helper import LibraryHelper
 from wlsdeploy.tool.util.target_helper import TargetHelper
+from wlsdeploy.tool.util.targeting_types import TargetingType
 from wlsdeploy.tool.util.topology_helper import TopologyHelper
 from wlsdeploy.util import dictionary_utils
 from wlsdeploy.util import model as model_helper
@@ -394,7 +395,8 @@ def __extend_domain(self, domain_home):
 
         self.logger.entering(domain_home, class_name=self.__class_name, method_name=_method_name)
         extension_templates = self._domain_typedef.get_extension_templates()
-        if len(extension_templates) == 0:
+        custom_templates = self._domain_typedef.get_custom_extension_templates()
+        if (len(extension_templates) == 0) and (len(custom_templates) == 0):
             return
 
         self.logger.info('WLSDPLY-12207', self._domain_name, domain_home,
@@ -407,15 +409,28 @@ def __extend_domain(self, domain_home):
                              class_name=self.__class_name, method_name=_method_name)
             self.wlst_helper.add_template(extension_template)
 
+        for custom_template in custom_templates:
+            self.logger.info('WLSDPLY-12246', custom_template,
+                             class_name=self.__class_name, method_name=_method_name)
+            self.wlst_helper.add_template(custom_template)
+
         self.__configure_fmw_infra_database()
 
         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()
             self.target_helper.target_server_groups_to_servers(server_groups_to_target)
             self.wlst_helper.update_domain()
-        elif self._domain_typedef.is_jrf_domain_type():
+
+        elif self._domain_typedef.is_jrf_domain_type() or \
+                (self._domain_typedef.get_targeting() == TargetingType.APPLY_JRF):
+            # for 11g, if template list includes JRF, or if specified in domain typedef, use applyJRF
             self.target_helper.target_jrf_groups_to_clusters_servers(domain_home)
 
+        else:
+            # for 11g, if no targeting was needed, just update the domain
+            self.wlst_helper.update_domain()
+
         self.wlst_helper.close_domain()
         self.logger.info('WLSDPLY-12209', self._domain_name,
                          class_name=self.__class_name, method_name=_method_name)
@@ -444,6 +459,12 @@ def __create_domain_with_select_template(self, domain_home):
                              class_name=self.__class_name, method_name=_method_name)
             self.wlst_helper.select_template(extension_template)
 
+        custom_templates = self._domain_typedef.get_custom_extension_templates()
+        for custom_template in custom_templates:
+            self.logger.info('WLSDPLY-12245', custom_template,
+                             class_name=self.__class_name, method_name=_method_name)
+            self.wlst_helper.select_custom_template(custom_template)
+
         self.logger.info('WLSDPLY-12212', class_name=self.__class_name, method_name=_method_name)
         self.wlst_helper.load_templates()
 

core/src/main/python/update.py

@@ -12,6 +12,7 @@
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.json.json_translator import JsonToPython
 from wlsdeploy.logging.platform_logger import PlatformLogger
+from wlsdeploy.tool.util.targeting_types import TargetingType
 from wlsdeploy.util.cla_utils import CommandLineArgUtil
 from wlsdeploy.util.weblogic_helper import WebLogicHelper
 
@@ -70,6 +71,8 @@ def __init__(self, program_name, domain_type):
         self._model_context = None
         self._version_typedef_name = None
 
+        self._targeting_type = self._resolve_targeting_type()
+
         if 'system-elements' in self._domain_typedefs_dict:
             self._system_elements = self._domain_typedefs_dict['system-elements']
         else:
@@ -149,6 +152,15 @@ def get_extension_templates(self):
         self.__resolve_paths()
         return list(self._domain_typedef['extensionTemplates'])
 
+    def get_custom_extension_templates(self):
+        """
+        Get the list of custom extension templates to apply when create/extending the domain.
+        :return: the list of custom extension templates, or an empty list if no extension templates are needed.
+        :raises: CreateException: if an error occurs resolving the paths
+        """
+        self.__resolve_paths()
+        return list(self._domain_typedef['customExtensionTemplates'])
+
     def get_server_groups_to_target(self):
         """
         Get the list of server groups to target to the managed servers in the domain.
@@ -176,6 +188,13 @@ def required_rcu(self):
         # resolution for create.py argument processing.
         return 'rcuSchemas' in self._domain_typedef and len(self._domain_typedef['rcuSchemas']) > 0
 
+    def get_targeting(self):
+        """
+        Get the targeting type for the domain, or None if not specified.
+        :return: the TargetingType enum value for the domain, or None
+        """
+        return self._targeting_type
+
     def is_system_app(self, name):
         """
         Determine if the specified name matches a WLS system application.
@@ -313,6 +332,15 @@ def __resolve_paths(self):
             else:
                 self._domain_typedef['extensionTemplates'] = []
 
+            if 'customExtensionTemplates' in self._domain_typedef:
+                extension_templates = self._domain_typedef['customExtensionTemplates']
+                resolved_templates = []
+                for extension_template in extension_templates:
+                    resolved_templates.append(self._model_context.replace_token_string(extension_template))
+                self._domain_typedef['customExtensionTemplates'] = resolved_templates
+            else:
+                self._domain_typedef['customExtensionTemplates'] = []
+
             if 'serverGroupsToTarget' not in self._domain_typedef:
                 self._domain_typedef['serverGroupsToTarget'] = []
 
@@ -391,3 +419,32 @@ def __match_version_typedef(self, versions_dict):
                 raise ex
         self._logger.exiting(self.__class_name, _method_name, result)
         return result
+
+    def _resolve_targeting_type(self):
+        """
+        Determine the targeting type based on the value in the definition.
+        Check for problems or incompatibilities.
+        :return: the matching TargetType enum value
+        :raises: ClaException: if there are problems or incompatibilities
+        """
+        _method_name = '_resolve_targeting_type'
+
+        if 'targeting' not in self._domain_typedef:
+            return None
+
+        targeting_text = self._domain_typedef['targeting']
+
+        # there are no valid targeting types for version 12c and up
+        if self.wls_helper.is_set_server_groups_supported():
+            ex = exception_helper.create_cla_exception('WLSDPLY-12311', targeting_text, self._domain_typedef_filename,
+                                                       self.wls_helper.get_weblogic_version())
+            self._logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
+            raise ex
+
+        # if specified, targeting must be one of the known types
+        if targeting_text not in TargetingType:
+            ex = exception_helper.create_cla_exception('WLSDPLY-12312', targeting_text, self._domain_typedef_filename)
+            self._logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
+            raise ex
+
+        return TargetingType[targeting_text]