Add attribute to type definition to apply JRF, 11g only (#374)

rakillen · web-flow · commit 50976e2892e5 · 2019-05-09T16:46:16.000-05:00
* JIRA WDT-336 - Create minimal model context for summary logging after CLA exception

* JIRA WDT-371 - Create flag in type definition to apply JRF explicitly

* JIRA WDT-371 - Update readme to describe APPLY_JRF targeting; broke out type definition page

* JIRA WDT-371 - Refinements to typedef readme
diff --git a/core/src/main/python/create.py b/core/src/main/python/create.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:
diff --git a/core/src/main/python/deploy.py b/core/src/main/python/deploy.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:
diff --git a/core/src/main/python/discover.py b/core/src/main/python/discover.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)
diff --git a/core/src/main/python/update.py b/core/src/main/python/update.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:
diff --git a/core/src/main/python/wlsdeploy/tool/create/domain_creator.py b/core/src/main/python/wlsdeploy/tool/create/domain_creator.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
@@ -416,12 +417,18 @@ def __extend_domain(self, domain_home):
         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()
diff --git a/core/src/main/python/wlsdeploy/tool/create/domain_typedef.py b/core/src/main/python/wlsdeploy/tool/create/domain_typedef.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:
@@ -185,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.
@@ -409,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]
diff --git a/core/src/main/python/wlsdeploy/tool/util/targeting_types.py b/core/src/main/python/wlsdeploy/tool/util/targeting_types.py
@@ -0,0 +1,9 @@
+"""
+Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+The Universal Permissive License (UPL), Version 1.0
+"""
+from wlsdeploy.util.enum import Enum
+
+TargetingType = Enum([
+    'APPLY_JRF'
+])
diff --git a/core/src/main/python/wlsdeploy/util/enum.py b/core/src/main/python/wlsdeploy/util/enum.py
@@ -1,5 +1,5 @@
 """
-Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.
+Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
 The Universal Permissive License (UPL), Version 1.0
 """
 from oracle.weblogic.deploy.exception import ExceptionHelper
@@ -30,6 +30,12 @@ def __str__(self):
     def __iter__(self):
         return self
 
+    def __contains__(self, name):
+        return name in self.enum_list
+
+    def __getitem__(self, name):
+        return self.enum_list.index(name)
+
     def next(self):
         if self.current < len(self.enum_list):
             result = self.enum_list[self.current]
diff --git a/core/src/main/resources/oracle/weblogic/deploy/messages/wlsdeploy_rb.properties b/core/src/main/resources/oracle/weblogic/deploy/messages/wlsdeploy_rb.properties
@@ -1068,6 +1068,8 @@ WLSDPLY-12308=Domain type {0} type definition in file {1} contained version {2}
   matches WebLogic version {3}
 WLSDPLY-12309=Domain type {0} type definition in file {1} did not contain a version that matched WebLogic version {2}
 WLSDPLY-12310=Version {0} returned from the domain home
+WLSDPLY-12311=Targeting type "{0}" in type definition file {1} is not allowed for WebLogic version {2}
+WLSDPLY-12312=Targeting type "{0}" in type definition file {1} is not valid
 
 # create.py
 WLSDPLY-12400={0} got the JAVA_HOME {1} from the environment variable but it was not a valid location: {2}
diff --git a/site/create.md b/site/create.md
@@ -21,217 +21,6 @@ To have the Create Domain Tool run RCU, simply add the `-run_rcu` argument to th
 
 It is also possible to specify the connection information in the model instead of using the command-line arguments.  This is especially easier for databases that require complex database connection string and extra parameters, such as RAC or Oracle Autonomous Transaction Processing Cloud Service database.  For information on how to use it, refer to [Specifying RCU connection information in the model](rcuinfo.md)
 
-The Create Domain Tool has an extensible domain type system.  The three built-in domain types (`WLS`, `RestrictedJRF`, and `JRF`) are defined in JSON files of the same name in the `WLSDEPLOY_HOME/lib/typedefs` directory.  For example, the `JRF` domain type is defined in the `WLSDEPLOY_HOME/lib/typedefs/JRF.json` file whose contents look like those shown below.
-
-```json
-{
-    "copyright": "Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.",
-    "license": "The Universal Permissive License (UPL), Version 1.0",
-    "name": "JRF",
-    "description": "JRF type domain definitions",
-    "versions": {
-        "12.1.2": "JRF_1212",
-        "12.1.3": "JRF_1213",
-        "12.2.1": "JRF_12CR2",
-        "12.2.1.3": "JRF_12213"
-    },
-    "definitions": {
-        "JRF_1212" : {
-            "baseTemplate": "@@WL_HOME@@/common/templates/wls/wls.jar",
-            "extensionTemplates": [
-                "@@ORACLE_HOME@@/oracle_common/common/templates/wls/oracle.jrf_template_12.1.2.jar",
-                "@@ORACLE_HOME@@/oracle_common/common/templates/wls/oracle.jrf.ws.async_template_12.1.2.jar",
-                "@@ORACLE_HOME@@/oracle_common/common/templates/wls/oracle.wsmpm_template_12.1.2.jar",
-                "@@ORACLE_HOME@@/em/common/templates/wls/oracle.em_wls_template_12.1.2.jar"
-            ],
-            "serverGroupsToTarget" : [ "JRF-MAN-SVR", "WSMPM-MAN-SVR" ],
-            "rcuSchemas": [ "MDS", "IAU", "IAU_VIEWER", "IAU_APPEND", "OPSS" ]
-        },
-        "JRF_1213" : {
-            "baseTemplate": "@@WL_HOME@@/common/templates/wls/wls.jar",
-            "extensionTemplates": [
-                "@@ORACLE_HOME@@/oracle_common/common/templates/wls/oracle.jrf_template_12.1.3.jar",
-                "@@ORACLE_HOME@@/oracle_common/common/templates/wls/oracle.jrf.ws.async_template_12.1.3.jar",
-                "@@ORACLE_HOME@@/oracle_common/common/templates/wls/oracle.wsmpm_template_12.1.3.jar",
-                "@@ORACLE_HOME@@/em/common/templates/wls/oracle.em_wls_template_12.1.3.jar"
-            ],
-            "serverGroupsToTarget" : [ "JRF-MAN-SVR", "WSMPM-MAN-SVR" ],
-            "rcuSchemas": [ "MDS", "IAU", "IAU_VIEWER", "IAU_APPEND", "OPSS" ]
-        },
-        "JRF_12CR2": {
-            "baseTemplate": "Basic WebLogic Server Domain",
-            "extensionTemplates": [
-                "Oracle JRF WebServices Asynchronous services",
-                "Oracle WSM Policy Manager",
-                "Oracle Enterprise Manager"
-            ],
-            "serverGroupsToTarget": [ "JRF-MAN-SVR", "WSMPM-MAN-SVR" ],
-            "rcuSchemas": [ "MDS", "IAU", "IAU_VIEWER", "IAU_APPEND", "OPSS" ]
-        },
-        "JRF_12213": {
-            "baseTemplate": "Basic WebLogic Server Domain",
-            "extensionTemplates": [
-                "Oracle JRF WebServices Asynchronous services",
-                "Oracle WSM Policy Manager",
-                "Oracle Enterprise Manager"
-            ],
-            "serverGroupsToTarget": [ "JRF-MAN-SVR", "WSMPM-MAN-SVR" ],
-            "rcuSchemas": [ "WLS", "MDS", "IAU", "IAU_VIEWER", "IAU_APPEND", "OPSS" ]
-        }
-    }
-}
-```
-
-This file tells the Create Domain Tool which templates to use to create the domain, which server groups to target, and even which RCU schemas to create, all based on the version of WebLogic Server installed.  New domain types can be defined by creating a new JSON file with the same structure in the `WLSDEPLOY_HOME/lib/typedefs` directory.  For example, to define a `SOA` domain type for 12.2.1.3, add the `WLSDEPLOY_HOME/lib/typedefs/SOA.json` file with contents like those shown below.
-
-```json
-{
-    "name": "SOA",
-    "description": "SOA type domain definitions",
-    "versions": {
-        "12.2.1.3": "SOA_12213"
-    },
-    "definitions": {
-        "SOA_12213": {
-            "baseTemplate": "Basic WebLogic Server Domain",
-            "extensionTemplates": [
-                "Oracle SOA Suite"
-            ],
-            "serverGroupsToTarget": [ "JRF-MAN-SVR", "WSMPM-MAN-SVR",  "SOA-MGD-SVRS" ],
-            "rcuSchemas": [ "STB", "WLS", "MDS", "IAU", "IAU_VIEWER", "IAU_APPEND", "OPSS", "UCSUMS", "SOAINFRA" ]
-        }
-    }
-}
-```
-
-After the new domain `typedef` file exists, simply specify the new domain type name to the `createDomain` script, being sure to reference an Oracle Home with the required components installed.  For pre-12.2.1 versions, the `-wlst_path` argument must be used to point to the product home where the appropriate WLST shell script exists; for example, for SOA 12.1.3, add `-wlst_path <ORACLE_HOME>/soa` so that the tool uses the WLST shell script with the proper environment for SOA domains.  In 12.2.1 and later, this is no longer necessary because the WLST shell script in the standard `<ORACLE_HOME>oracle_common/common/bin` directory will automatically load all components in the Oracle Home.  Using the new domain type, simply run the following command to run RCU and create the SOA domain with all of its resources and applications deployed.
-
-    weblogic-deploy\bin\createDomain.cmd -oracle_home d:\SOA12213 -domain_type SOA -domain_parent d:\demo\domains -model_file DemoDomain.yaml -archive_file DemoDomain.zip -variable_file DemoDomain.properties -run_rcu -rcu_db mydb.example.com:1539/PDBORCL -rcu_prefix DEMO
-
-To create more complex domains with clusters of different types, it is necessary to control the targeting of server groups to managed servers.  By default, all server groups in the domain type definition are targeted to all managed servers.  To create a SOA domain with SOA and OSB clusters, simply add the OSB template and server group to the SOA domain definition, as shown below.
-
-```json
-{
-    "name": "SOA",
-    "description": "SOA type domain definitions",
-    "versions": {
-        "12.2.1.3": "SOA_12213"
-    },
-    "definitions": {
-        "SOA_12213": {
-            "baseTemplate": "Basic WebLogic Server Domain",
-            "extensionTemplates": [
-                "Oracle SOA Suite",
-                "Oracle Service Bus"
-            ],
-            "serverGroupsToTarget": [ "JRF-MAN-SVR", "WSMPM-MAN-SVR",  "SOA-MGD-SVRS",  "OSB-MGD-SVRS-COMBINED" ],
-            "rcuSchemas": [ "STB", "WLS", "MDS", "IAU", "IAU_VIEWER", "IAU_APPEND", "OPSS", "UCSUMS", "SOAINFRA" ]
-        }
-    }
-}
-```
-
-Then, use the `ServerGroupTargetingLimits` map in the `domainInfo` section to limit the targeting of the Web Services Manager, SOA, and OSB server groups to the `soa_cluster` or `osb_cluster`, as appropriate.  In the example below, notice that the `JRF-MAN-SVR` server group is not listed; therefore, it will use the default targeting and be targeted to all managed servers.  The value of each element in this section is a logical list of server and/or cluster names.  As shown in the example, the value for each server group can be specified as a list, a comma-separated string, or a single-valued string.  There is no semantic difference between listing a cluster's member server names versus using the cluster name; the example uses these simply to show what is possible.
-
-```yaml
-domainInfo:
-    AdminUserName: weblogic
-    AdminPassword: welcome1
-    ServerStartMode: prod
-    ServerGroupTargetingLimits:
-        'WSMPM-MAN-SVR': soa_cluster
-        'SOA-MGD-SVRS': 'soa_server1,soa_server2'
-        'OSB-MGD-SVRS-COMBINED': [ osb_server1, osb_server2 ]
-
-topology:
-    Name: soa_domain
-    AdminServerName: AdminServer
-    Cluster:
-        soa_cluster:
-        osb_cluster:
-    Server:
-        AdminServer:
-            ListenAddress: myadmin.example.com
-            ListenPort: 7001
-            Machine: machine1
-            SSL:
-                Enabled: true
-                ListenPort: 7002
-        soa_server1:
-            ListenAddress: managed1.example.com
-            ListenPort: 8001
-            Cluster: soa_cluster
-            Machine: machine2
-            SSL:
-                Enabled: true
-                ListenPort: 8002
-        soa_server2:
-            ListenAddress: managed2.example.com
-            ListenPort: 8001
-            Cluster: soa_cluster
-            Machine: machine3
-            SSL:
-                Enabled: true
-                ListenPort: 8002
-        osb_server1:
-            ListenAddress: managed1.example.com
-            ListenPort: 9001
-            Cluster: osb_cluster
-            Machine: machine2
-            SSL:
-                Enabled: true
-                ListenPort: 9002
-        osb_server2:
-            ListenAddress: managed2.example.com
-            ListenPort: 9001
-            Cluster: osb_cluster
-            Machine: machine3
-            SSL:
-                Enabled: true
-                ListenPort: 9002
-    UnixMachine:
-        machine1:
-            NodeManager:
-                ListenAddress: myadmin.example.com
-                ListenPort: 5556
-        machine2:
-            NodeManager:
-                ListenAddress: managed1.example.com
-                ListenPort: 5556
-        machine3:
-            NodeManager:
-                ListenAddress: managed2.example.com
-                ListenPort: 5556
-    SecurityConfiguration:
-        NodeManagerUsername: weblogic
-        NodeManagerPasswordEncrypted: welcome1
-```
-
-The `customExtensionTemplates` attribute can be used to specify custom extension templates to be applied to the domain. These should be specified as absolute file paths, and can use tokens.  
-
-```json
-{
-    "name": "MyCustom",
-    "description": "My custom type domain definitions",
-    "versions": {
-        "12.2.1.3": "My_12213"
-    },
-    "definitions": {
-        "My_12213": {
-            "baseTemplate": "Basic WebLogic Server Domain",
-            "extensionTemplates": [ ],
-            "customExtensionTemplates": [
-                "/user/me/templates/my-template.jar",
-                "@@ORACLE_HOME@@/user_templates/other-template.jar"
-            ],
-            "serverGroupsToTarget": [ "MY-MAN-SVR" ],
-            "rcuSchemas": [ ]
-        }
-    }
-}
-```
-
-If there are any server groups in the custom template that should be targeted to managed servers, they should be specified in the `serverGroupsToTarget` attribute, similar to `MY_MAN_SVR` in the example above.
+To create more complex domains, it may be necessary to create a custom domain type. This is useful for cases where the domain has custom templates, or templates for other Oracle products. For more information, refer to [Domain Type Definitions](type_def.md).
 
 One last note is that if the model or variables file contains encrypted passwords, add the `-use_encryption` flag to the command line to tell the Create Domain Tool that encryption is being used and to prompt for the encryption passphrase.  As with the database passwords, the tool can also read the passphrase from standard input (for example, `stdin`) to allow the tool to run without any user input.
-
diff --git a/site/type_def.md b/site/type_def.md
