applyJRF to apply resources to servers

Author: CarolynRountree

core/src/main/python/create.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
 
 The main module for the WLSDeploy tool to create empty domains.
@@ -38,12 +38,15 @@
 from wlsdeploy.util import getcreds
 from wlsdeploy.util import tool_exit
 from wlsdeploy.util import variables
+from wlsdeploy.util import wlst_extended
 from wlsdeploy.util import wlst_helper
 from wlsdeploy.util.cla_utils import CommandLineArgUtil
 from wlsdeploy.util.model_context import ModelContext
 from wlsdeploy.util.model_translator import FileToPython
 from wlsdeploy.util.weblogic_helper import WebLogicHelper
 
+wlst_extended.wlst_functions = globals()
+
 _program_name = 'createDomain'
 _class_name = 'create'
 __logger = PlatformLogger('wlsdeploy.create')

core/src/main/python/wlsdeploy/tool/create/domain_creator.py

@@ -321,6 +321,7 @@ def __extend_domain(self, domain_home):
 
         self.logger.info('WLSDPLY-12207', self._domain_name, domain_home,
                          class_name=self.__class_name, method_name=_method_name)
+        # we might want to replace this later to extend a domain in update
         self.wlst_helper.read_domain(domain_home)
         self.__set_app_dir()
 
@@ -331,13 +332,21 @@ def __extend_domain(self, domain_home):
 
         self.__configure_fmw_infra_database()
 
-        server_groups_to_target = self._domain_typedef.get_server_groups_to_target()
-        self.target_helper.target_server_groups_to_servers(server_groups_to_target)
+        if self.wls_helper.is_set_server_groups_supported():
+            server_groups_to_target = self._domain_typedef.get_server_groups_to_target()
+            self.target_helper.target_server_groups_to_servers(server_groups_to_target)
+        else:
+            # need to update this before can target it
+            # might want to replace this later with
+            # self.wlst_helper.update_domain()
+            # self.wlst_helper.close_domain()
+            # # we might want to replace this later to extend a domain in update
+            # self.wlst_helper.read_domain(domain_home)
+            self.target_helper.target_jrf_groups_to_clusters_servers(domain_home)
+
 
         self.logger.info('WLSDPLY-12209', self._domain_name,
                          class_name=self.__class_name, method_name=_method_name)
-        self.wlst_helper.update_domain()
-        self.wlst_helper.close_domain()
 
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
         return
@@ -700,7 +709,7 @@ def __configure_fmw_infra_database(self):
 
         stb_user = self.wls_helper.get_stb_user_name(rcu_prefix)
         self.logger.fine('WLSDPLY-12222', stb_user, class_name=self.__class_name, method_name=_method_name)
-
+        #
         wlst_path = self.alias_helper.get_wlst_attributes_path(location)
         self.wlst_helper.cd(wlst_path)
         wlst_name, wlst_value = \
@@ -709,7 +718,8 @@ def __configure_fmw_infra_database(self):
                                        JDBC_DRIVER_PARAMS_PROPERTIES, DRIVER_PARAMS_USER_PROPERTY)
 
         self.logger.info('WLSDPLY-12223', class_name=self.__class_name, method_name=_method_name)
-        self.wlst_helper.get_database_defaults()
+        if self._domain_typedef.is_get_database_defaults():
+            self.wlst_helper.get_database_defaults()
 
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
         return

core/src/main/python/wlsdeploy/tool/util/target_helper.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
 """
 
@@ -38,85 +38,128 @@ def __init__(self, model, model_context, aliases, exception_type, logger):
         else:
             self._admin_server_name = DEFAULT_ADMIN_SERVER_NAME
 
-    def target_server_groups_to_servers(self, server_groups_to_target):
+    def target_jrf_groups_to_clusters_servers(self, domain_home):
         """
-        Target the server groups to the servers.
-        :param server_groups_to_target: the list of server groups to target
-        :raises: BundleAwareException of the specified type: if an error occurs
+        Use the apply_jrf only for those versions of wlst that do not have server groups.
+        This assigns the JRF resources to all managed servers. If the managed server is in a
+        cluster, this method assigns the JRF resources are assigned to the cluster. Else, if
+        the managed server is stand-alone, the resources are assigned to the managed server.
+        :param domain_home: the directory for the domain_home
         """
-        _method_name = '__target_server_groups_to_servers'
+        _method_name = 'target_jrf_groups_to_clusters_servers'
 
-        self.logger.entering(server_groups_to_target, class_name=self.__class_name, method_name=_method_name)
-        if len(server_groups_to_target) == 0:
-            return
+        self.logger.entering(domain_home, class_name=self.__class_name, method_name=_method_name)
 
         location = LocationContext()
         root_path = self.alias_helper.get_wlst_attributes_path(location)
         self.wlst_helper.cd(root_path)
+        admin_server_name = self.wlst_helper.get(ADMIN_SERVER_NAME)
 
         # We need to get the effective list of servers for the domain.  Since any servers
         # referenced in the model have already been created but the templates may have
         # defined new servers not listed in the model, get the list from WLST.
-        server_names = self._get_existing_server_names()
+        server_names = self.get_existing_server_names()
+        if admin_server_name in server_names:
+            server_names.remove(admin_server_name)
 
         # Get the clusters and and their members
-        cluster_map = self._get_clusters_and_members_map()
+        cluster_map = self.get_clusters_and_members_map()
+        self.wlst_helper.update_domain()
+        self.wlst_helper.close_domain()
 
-        # Get any limits that may have been defined in the model
-        domain_info = self.model.get_model_domain_info()
-        server_group_targeting_limits = \
-            dictionary_utils.get_dictionary_element(domain_info, SERVER_GROUP_TARGETING_LIMITS)
-        if len(server_group_targeting_limits) > 0:
-            server_group_targeting_limits = \
-                self._get_server_group_targeting_limits(server_group_targeting_limits, cluster_map)
-
-        # Get the map of server names to server groups to target
-        server_to_server_groups_map =\
-            self._get_server_to_server_groups_map(self._admin_server_name,
-                                                  server_names,
-                                                  server_groups_to_target,
-                                                  server_group_targeting_limits)  # type: dict
-
-        if len(server_names) > 1:
-            for server, server_groups in server_to_server_groups_map.iteritems():
-                if len(server_groups) > 0:
-                    server_name = self.wlst_helper.get_quoted_name_for_wlst(server)
-                    self.logger.info('WLSDPLY-12224', str(server_groups), server_name,
-                                     class_name=self.__class_name, method_name=_method_name)
-                    self.wlst_helper.set_server_groups(server_name, server_groups)
-
-        elif len(server_group_targeting_limits) == 0:
-            #
-            # Domain has no managed servers and there were not targeting limits specified to target
-            # server groups to the admin server so make sure that the server groups are targeted to
-            # the admin server.
-            #
-            # This is really a best effort attempt.  It works for JRF domains but it is certainly possible
-            # that it may cause problems with other custom domain types.  Of course, creating a domain with
-            # no managed servers is not a primary use case of this tool so do it and hope for the best...
-            #
-            server_name = self.wlst_helper.get_quoted_name_for_wlst(server_names[0])
-            self.wlst_helper.set_server_groups(server_name, server_groups_to_target)
+        # Get the clusters and and their members
+        for cluster_name, cluster_servers in cluster_map.iteritems():
+            self.logger.info('WLSDPLY-12232', 'Cluster', cluster_name, class_name=self.__class_name,
+                             method_name=_method_name)
+            self.wlst_helper.apply_jrf(cluster_name, domain_home, should_update=True)
+            for member in cluster_servers:
+                if member in server_names:
+                    server_names.remove(member)
+        for ms_name in server_names:
+            self.logger.info('WLSDPLY-12232', 'Managed Server', ms_name, class_name=self.__class_name,
+                             method_name=_method_name)
+            self.wlst_helper.apply_jrf(ms_name, domain_home, should_update=True)
 
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
         return
 
-    def _get_existing_server_names(self):
+    def target_server_groups_to_servers(self, domain_home, server_groups_to_target):
         """
-        Get the list of server names from WLST.
-        :return: the list of server names
-        :raises: BundleAwareException of the specified type: is an error occurs reading from the aliases or WLST
+        Target the server groups to the servers.
+        :param server_groups_to_target: the list of server groups to target
+        :raises: BundleAwareException of the specified type: if an error occurs
         """
-        _method_name = '_get_existing_server_names'
+        _method_name = '__target_server_groups_to_servers'
 
-        self.logger.entering(class_name=self.__class_name, method_name=_method_name)
-        server_location = LocationContext().append_location(SERVER)
-        server_list_path = self.alias_helper.get_wlst_list_path(server_location)
-        result = self.wlst_helper.get_existing_object_list(server_list_path)
-        self.logger.exiting(class_name=self.__class_name, method_name=_method_name, result=result)
-        return result
+        self.logger.entering(server_groups_to_target, class_name=self.__class_name, method_name=_method_name)
+        if len(server_groups_to_target) > 0:
+            location = LocationContext()
+            root_path = self.alias_helper.get_wlst_attributes_path(location)
+            self.wlst_helper.cd(root_path)
+
+            # We need to get the effective list of servers for the domain.  Since any servers
+            # referenced in the model have already been created but the templates may have
+            # defined new servers not listed in the model, get the list from WLST.
+            server_names = self.get_existing_server_names()
+
+            # Get the clusters and and their members
+            cluster_map = self.get_clusters_and_members_map()
+
+            location = LocationContext()
+            root_path = self.alias_helper.get_wlst_attributes_path(location)
+            self.wlst_helper.cd(root_path)
 
-    def _get_clusters_and_members_map(self):
+            # We need to get the effective list of servers for the domain.  Since any servers
+            # referenced in the model have already been created but the templates may have
+            # defined new servers not listed in the model, get the list from WLST.
+            server_names = self.get_existing_server_names()
+
+            # Get the clusters and and their members
+            cluster_map = self.get_clusters_and_members_map()
+
+            # Get any limits that may have been defined in the model
+            domain_info = self.model.get_model_domain_info()
+            server_group_targeting_limits = \
+                dictionary_utils.get_dictionary_element(domain_info, SERVER_GROUP_TARGETING_LIMITS)
+            if len(server_group_targeting_limits) > 0:
+                server_group_targeting_limits = \
+                    self._get_server_group_targeting_limits(server_group_targeting_limits, cluster_map)
+
+            # Get the map of server names to server groups to target
+            server_to_server_groups_map =\
+                self._get_server_to_server_groups_map(self._admin_server_name,
+                                                      server_names,
+                                                      server_groups_to_target,
+                                                      server_group_targeting_limits)  # type: dict
+
+            if len(server_names) > 1:
+                for server, server_groups in server_to_server_groups_map.iteritems():
+                    if len(server_groups) > 0:
+                        server_name = self.wlst_helper.get_quoted_name_for_wlst(server)
+                        self.logger.info('WLSDPLY-12224', str(server_groups), server_name,
+                                         class_name=self.__class_name, method_name=_method_name)
+                        self.wlst_helper.set_server_groups(server_name, server_groups)
+
+            elif len(server_group_targeting_limits) == 0:
+                #
+                # Domain has no managed servers and there were not targeting limits specified to target
+                # server groups to the admin server so make sure that the server groups are targeted to
+                # the admin server.
+                #
+                # This is really a best effort attempt.  It works for JRF domains but it is certainly possible
+                # that it may cause problems with other custom domain types.  Of course, creating a domain with
+                # no managed servers is not a primary use case of this tool so do it and hope for the best...
+                #
+                server_name = self.wlst_helper.get_quoted_name_for_wlst(server_names[0])
+                self.wlst_helper.set_server_groups(server_name, server_groups_to_target)
+
+        # might want to replace this later with
+        self.wlst_helper.update_domain()
+        self.wlst_helper.close_domain()
+        self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
+        return
+
+    def get_clusters_and_members_map(self):
         """
         Get a map keyed by cluster name with values that are a list of member server names
         :return: the cluster name to member server names map
@@ -148,6 +191,21 @@ def _get_clusters_and_members_map(self):
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name, result=cluster_map)
         return cluster_map
 
+    def get_existing_server_names(self):
+        """
+        Get the list of server names from WLST.
+        :return: the list of server names
+        :raises: BundleAwareException of the specified type: is an error occurs reading from the aliases or WLST
+        """
+        _method_name = '_get_existing_server_names'
+
+        self.logger.entering(class_name=self.__class_name, method_name=_method_name)
+        server_location = LocationContext().append_location(SERVER)
+        server_list_path = self.alias_helper.get_wlst_list_path(server_location)
+        result = self.wlst_helper.get_existing_object_list(server_list_path)
+        self.logger.exiting(class_name=self.__class_name, method_name=_method_name, result=result)
+        return result
+
     def _get_server_group_targeting_limits(self, server_group_targeting_limits, clusters_map):
         """
         Get any server group targeting limits specified in the model, converting any cluster

core/src/main/python/wlsdeploy/tool/util/wlst_helper.py

@@ -1,10 +1,11 @@
 """
-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.util import PyWLSTException
 
 from wlsdeploy.exception import exception_helper
+from wlsdeploy.util import wlst_extended
 from wlsdeploy.util import wlst_helper
 
 
@@ -41,6 +42,25 @@ def assign(self, source_type, source_name, target_type, target_name):
             self.__logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
             raise ex
 
+    def apply_jrf(self, jrf_target, domain_home, should_update=False):
+        """
+        For those installs that require populating the JRF server group information to the managed servers
+        :param jrf_target: The entity to which to target the JRF applications and services
+        :param domain_home: The domain home directory
+        :param should_update: If True the applyJRF will update the domain after apply
+        :raises: Exception specific to tool type
+        """
+        _method_name = 'apply_jrf'
+
+        try:
+            wlst_extended.apply_jrf(jrf_target, domain_home, should_update)
+        except PyWLSTException, pwe:
+            ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-00071',
+                                                   jrf_target, domain_home,
+                                                   pwe.getLocalizedMessage(), error=pwe)
+            self.__logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
+            raise ex
+
     def cd(self, wlst_path):
         """
         Change WLST directories to the specified path

core/src/main/python/wlsdeploy/util/weblogic_helper.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
 """
 import java.lang.Exception as JException
@@ -74,6 +74,20 @@ def is_select_template_supported(self):
         """
         return self.is_weblogic_version_or_above('12.2.1')
 
+    def is_database_defaults_supported(self):
+        """
+        Is setDatabaseDefaults() supported by the version of JRF?
+        :return: true if use the method to prime the JRF database defaults
+        """
+        return self.is_weblogic_version_or_above('12.1.2')
+
+    def is_set_server_groups_supported(self):
+        """
+        Is setServerGroups() supported by the version of WLST?
+        :return: true if the setServerGroups() is supported
+        """
+        return self.is_weblogic_version_or_above('12.1.2')
+
     def is_dynamic_clusters_supported(self):
         """
         Is dynamic clusters supported in this version of WLS?
@@ -109,7 +123,9 @@ def get_jrf_service_table_datasource_name(self):
         Get the JRF DataSource name for the service table schema.
         :return: the JRF DataSource name
         """
-        return 'LocalSvcTblDataSource'
+        if self.is_weblogic_version_or_above('12.1.2'):
+            return 'LocalSvcTblDataSource'
+        return 'mds-owsm'
 
     def get_default_admin_username(self):
         """