continued changes for alias definitions

Author: CarolynRountree

core/src/main/python/wlsdeploy/aliases/alias_entries.py

@@ -111,7 +111,10 @@ class AliasEntries(object):
         'UnixMachine': 'UnixMachine',
         'VirtualHost': 'VirtualHost',
         'VirtualTarget': 'VirtualTarget',
-        'WLDFSystemResource': 'WLDFSystemResource'
+        'WLDFSystemResource': 'WLDFSystemResource',
+        'WSReliableDeliveryPolicy': 'WSReliableDeliveryPolicy',
+        'XMLEntityCache': 'XMLEntityCache',
+        'XMLRegistry': 'XMLRegistry'
     }
 
     __topology_top_level_folders = [
@@ -130,7 +133,10 @@ class AliasEntries(object):
         'ServerTemplate',
         'UnixMachine',
         'VirtualHost',
-        'VirtualTarget'
+        'VirtualTarget',
+        'WSReliableDeliveryPolicy',
+        'XMLEntityCache',
+        'XMLRegistry'
     ]
 
     __resources_top_level_folders = [

core/src/main/python/wlsdeploy/aliases/model_constants.py

@@ -252,8 +252,11 @@
 WLDF_INSTRUMENTATION_MONITOR = "WLDFInstrumentationMonitor"
 WLDF_RESOURCE = "WLDFResource"
 WLDF_SYSTEM_RESOURCE = "WLDFSystemResource"
+WS_RELIABLE_DELIVERY_POLICY = 'WSReliableDeliveryPolicy'
 XACML_AUTHORIZER = 'XACMLAuthorizer'
 XACML_ROLE_MAPPER = 'XACMLRoleMapper'
+XML_ENTITY_CACHE = 'XMLEntityCache'
+XML_REGISTRY = 'XMLRegistry'
 
 # names of attributes, alphabetically
 

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

@@ -43,6 +43,9 @@
 from wlsdeploy.aliases.model_constants import URL
 from wlsdeploy.aliases.model_constants import USER
 from wlsdeploy.aliases.model_constants import VIRTUAL_TARGET
+from wlsdeploy.aliases.model_constants import WS_RELIABLE_DELIVERY_POLICY
+from wlsdeploy.aliases.model_constants import XML_ENTITY_CACHE
+from wlsdeploy.aliases.model_constants import XML_REGISTRY
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.exception.expection_types import ExceptionType
 from wlsdeploy.tool.create.creator import Creator
@@ -383,8 +386,7 @@ def __apply_base_domain_config(self, topology_folder_list):
         self.security_provider_creator.create_security_configuration(security_config_location)
         topology_folder_list.remove(SECURITY_CONFIGURATION)
 
-        self.__create_log_filters(location)
-        topology_folder_list.remove(LOG_FILTER)
+        self.__create_mbeans_used_by_topology_mbeans(location, topology_folder_list)
 
         self.__create_machines(location)
         topology_folder_list.remove(MACHINE)
@@ -427,6 +429,21 @@ def __set_core_domain_params(self):
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
         return
 
+    def __create_mbeans_used_by_topology_mbeans(self, location, topology_folder_list):
+        """
+        Create the entities that are referenced by domain, machine, server and server template attributes.
+        :param location: current location
+        :raises: CreateException: if an error occurs
+        """
+        self.__create_log_filters(location)
+        topology_folder_list.remove(LOG_FILTER)
+        self.__create_reliable_delivery_policy(location)
+        topology_folder_list.remove(WS_RELIABLE_DELIVERY_POLICY)
+        self.__create_xml_entity_cache(location)
+        topology_folder_list.remove(XML_ENTITY_CACHE)
+        self.__create_xml_registry(location)
+        topology_folder_list.remove(XML_REGISTRY)
+
     def __create_security_folder(self, location):
         """
         Create the /Security folder objects, if any.
@@ -458,6 +475,54 @@ def __create_log_filters(self, location):
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
         return
 
+    def __create_reliable_delivery_policy(self, location):
+        """
+        Create the /WSReliableDeliverPolicy objects if any for use by the server and server templates.
+        :param location: the location to use
+        :raises: CreateException: if an error occurs
+        """
+        _method_name = '__create_reliable_delivery_policy'
+
+        self.logger.entering(str(location), class_name=self.__class_name, method_name=_method_name)
+        policy_nodes = dictionary_utils.get_dictionary_element(self._topology, WS_RELIABLE_DELIVERY_POLICY)
+
+        if len(policy_nodes) > 0:
+            self._create_named_mbeans(WS_RELIABLE_DELIVERY_POLICY, policy_nodes, location, log_created=True)
+        self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
+        return
+
+    def __create_xml_entity_cache(self, location):
+        """
+        Create the /XMLEntityCache objects if any for use by the server and server templates.
+        :param location: the location to use
+        :raises: CreateException: if an error occurs
+        """
+        _method_name = '__create_xml_entity_cache'
+
+        self.logger.entering(str(location), class_name=self.__class_name, method_name=_method_name)
+        cache_nodes = dictionary_utils.get_dictionary_element(self._topology, XML_ENTITY_CACHE)
+
+        if len(cache_nodes) > 0:
+            self._create_named_mbeans(XML_ENTITY_CACHE, cache_nodes, location, log_created=True)
+        self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
+        return
+
+    def __create_xml_registry(self, location):
+        """
+        Create the /XMLRegistry objects if any for use by the server and server templates.
+        :param location: the location to use
+        :raises: CreateException: if an error occurs
+        """
+        _method_name = '__create_xml_registry'
+
+        self.logger.entering(str(location), class_name=self.__class_name, method_name=_method_name)
+        registry_nodes = dictionary_utils.get_dictionary_element(self._topology, XML_REGISTRY)
+
+        if len(registry_nodes) > 0:
+            self._create_named_mbeans(XML_REGISTRY, registry_nodes, location, log_created=True)
+        self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
+        return
+
     def __create_machines(self, location):
         """
         Create the /Machine and /UnixMachine folder objects, if any.

core/src/main/python/wlsdeploy/tool/discover/topology_discoverer.py

@@ -261,6 +261,12 @@ def discover_domain_parameters(self):
         discoverer.add_to_model_if_not_empty(self._dictionary, model_folder_name, folder_result)
         model_folder_name, folder_result = self._get_log_filters()
         discoverer.add_to_model_if_not_empty(self._dictionary, model_folder_name, folder_result)
+        model_folder_name, folder_result = self._get_reliable_delivery_policies()
+        discoverer.add_to_model_if_not_empty(self._dictionary, model_folder_name, folder_result)
+        model_folder_name, folder_result = self._get_xml_entity_caches()
+        discoverer.add_to_model_if_not_empty(self._dictionary, model_folder_name, folder_result)
+        model_folder_name, folder_result = self._get_xml_registries()
+        discoverer.add_to_model_if_not_empty(self._dictionary, model_folder_name, folder_result)
         model_folder_name, folder_result = self._get_domain_log()
         discoverer.add_to_model_if_not_empty(self._dictionary, model_folder_name, folder_result)
         model_folder_name, folder_result = self._get_nm_properties()
@@ -370,6 +376,81 @@ def _get_log_filters(self):
         _logger.exiting(class_name=_class_name, method_name=_method_name, result=model_top_folder_name)
         return model_top_folder_name, result
 
+    def _get_reliable_delivery_policies(self):
+        """
+        Discover the reliable delivery policies that are used for soap message delivery in the servers.
+        :return: model name for the folder: dictionary containing the discovered ws reliable delivery policies
+        """
+        _method_name = '_get_reliable_delivery_policies'
+        _logger.entering(class_name=_class_name, method_name=_method_name)
+        model_top_folder_name = model_constants.WS_RELIABLE_DELIVERY_POLICY
+        result = OrderedDict()
+        location = LocationContext(self._base_location)
+        location.append_location(model_top_folder_name)
+        policies = self._find_names_in_folder(location)
+        if policies is not None:
+            _logger.info('WLSDPLY-06630', len(policies), class_name=_class_name, method_name=_method_name)
+            name_token = self._alias_helper.get_name_token(location)
+            for policy in policies:
+                _logger.info('WLSDPLY-06631', policy, class_name=_class_name, method_name=_method_name)
+                location.add_name_token(name_token, policy)
+                result[policy] = OrderedDict()
+                self._populate_model_parameters(result[policy], location)
+                location.remove_name_token(name_token)
+
+        _logger.exiting(class_name=_class_name, method_name=_method_name, result=model_top_folder_name)
+        return model_top_folder_name, result
+
+    def _get_xml_entity_caches(self):
+        """
+        Discover the XML entity caches that are used by the servers in the domain.
+        :return: model name for the folder: dictionary containing the discovered xml entity caches
+        """
+        _method_name = '_get_xml_entity_caches'
+        _logger.entering(class_name=_class_name, method_name=_method_name)
+        model_top_folder_name = model_constants.XML_ENTITY_CACHE
+        result = OrderedDict()
+        location = LocationContext(self._base_location)
+        location.append_location(model_top_folder_name)
+        caches = self._find_names_in_folder(location)
+        if caches is not None:
+            _logger.info('WLSDPLY-06632', len(caches), class_name=_class_name, method_name=_method_name)
+            name_token = self._alias_helper.get_name_token(location)
+            for cache in caches:
+                _logger.info('WLSDPLY-06633', cache, class_name=_class_name, method_name=_method_name)
+                location.add_name_token(name_token, cache)
+                result[cache] = OrderedDict()
+                self._populate_model_parameters(result[cache], location)
+                location.remove_name_token(name_token)
+
+        _logger.exiting(class_name=_class_name, method_name=_method_name, result=model_top_folder_name)
+        return model_top_folder_name, result
+
+    def _get_xml_registries(self):
+        """
+        Discover the XML registries that are used by the servers.
+        :return: model name for the folder: dictionary containing the discovered log xml registries
+        """
+        _method_name = '_get_xml_registries'
+        _logger.entering(class_name=_class_name, method_name=_method_name)
+        model_top_folder_name = model_constants.XML_REGISTRY
+        result = OrderedDict()
+        location = LocationContext(self._base_location)
+        location.append_location(model_top_folder_name)
+        registries = self._find_names_in_folder(location)
+        if registries is not None:
+            _logger.info('WLSDPLY-06634', len(registries), class_name=_class_name, method_name=_method_name)
+            name_token = self._alias_helper.get_name_token(location)
+            for registry in registries:
+                _logger.info('WLSDPLY-06635', registry, class_name=_class_name, method_name=_method_name)
+                location.add_name_token(name_token, registry)
+                result[registry] = OrderedDict()
+                self._populate_model_parameters(result[registry], location)
+                location.remove_name_token(name_token)
+
+        _logger.exiting(class_name=_class_name, method_name=_method_name, result=model_top_folder_name)
+        return model_top_folder_name, result
+
     def _get_nm_properties(self):
         """
         Discover the NMProperties attributes.
@@ -505,11 +586,12 @@ def _add_keystore_file_to_archive(self, model_name, model_value, location):
         _method_name = '_add_keystore_file_to_archive'
         _logger.entering(model_name, str(location), class_name=_class_name, method_name=_method_name)
         server_name = self._get_server_name_from_location(location)
-        archive_file = self._model_context.get_archive_file()
         _logger.finer('WLSDPLY-06223', model_value, server_name, class_name=_class_name, method_name=_method_name)
+        archive_file = self._model_context.get_archive_file()
         file_path = self._convert_path(model_value)
         new_name = None
-        try:6
+        try:
+            archive_file.addServerKeyStoreFile(server_name, File(file_path))
         except IllegalArgumentException, iae:
             _logger.warning('WLSDPLY-06624', server_name, file_path, iae.getLocalizedMessage(),
                             class_name=_class_name, method_name=_method_name)
@@ -529,4 +611,4 @@ def _get_server_name_from_location(self, location):
         """
         temp = LocationContext()
         temp.append_location(model_constants.SERVER)
-        return location.get_name_for_token(self._alias_helper.get_name_token(temp))
+        return location.get_name_for_token(self._alias_helper.get_name_token(temp))

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

@@ -70,6 +70,9 @@
 from wlsdeploy.aliases.model_constants import UNIFORM_DISTRIBUTED_TOPIC
 from wlsdeploy.aliases.model_constants import VIRTUAL_TARGET
 from wlsdeploy.aliases.model_constants import WATCH_NOTIFICATION
+from wlsdeploy.aliases.model_constants import WS_RELIABLE_DELIVERY_POLICY
+from wlsdeploy.aliases.model_constants import XML_ENTITY_CACHE
+from wlsdeploy.aliases.model_constants import XML_REGISTRY
 
 
 class AttributeSetter(object):
@@ -395,7 +398,59 @@ def set_log_filter_mbean(self, location, key, value, wlst_value):
         :param wlst_value: the existing value of the attribute from WLST
         :raises BundleAwareException of the specified type: if store is not found
         """
-        mbean = self.__find_log_filter_mbean(location, value)
+        mbean = self.__find_in_location(LocationContext(), LOG_FILTER, value, required=True)
+        self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True)
+        return
+
+    def set_jms_server_mbean(self, location, key, value, wlst_value):
+        """
+        For those entities, such as WLSReliableDeliveryPolicy, that take a single JMS Server mbean.
+        :param location: location to look for jms server
+        :param key: the attribute name
+        :param value: the string value
+        :param wlst_value: the existing value of the attribute from WLST
+        :raises BundleAwareException of the specified type: if jms server mbean is not found.
+        """
+        mbean = self.__find_in_location(LocationContext(), JMS_SERVER, value, required=True)
+        self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True)
+        return
+
+    def set_reliable_delivery_policy_mbean(self, location, key, value, wlst_value):
+        """
+        Sets the ws soap reliable delivery policy mbean used by mbeans like Server and Server Template.
+        :param location: location to look for reliable delivery policy
+        :param key: the attribute name
+        :param value: the string value
+        :param wlst_value: the existing value of the attribute from WLST
+        :raises BundleAwareException of the specified type: if reliable delivery policy mbean is not found.
+        """
+        mbean = self.__find_in_location(LocationContext(), WS_RELIABLE_DELIVERY_POLICY, value, required=True)
+        self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True)
+        return
+
+    def set_xml_entity_cache_mbean(self, location, key, value, wlst_value):
+        """
+        Sets the XML cache mbean used by topology entities such as Server.
+        :param location: location to look for reliable delivery policy
+        :param key: the attribute name
+        :param value: the string value
+        :param wlst_value: the existing value of the attribute from WLST
+        :raises BundleAwareException of the specified type: if xml entity cache mbean is not found.
+        """
+        mbean = self.__find_in_location(LocationContext(), XML_ENTITY_CACHE, value, required=True)
+        self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True)
+        return
+
+    def set_xml_registry_mbean(self, location, key, value, wlst_value):
+        """
+        Sets the XML registry mbean used by topology entities such as Server.
+        :param location: location to look for reliable delivery policy
+        :param key: the attribute name
+        :param value: the string value
+        :param wlst_value: the existing value of the attribute from WLST
+        :raises BundleAwareException of the specified type: if xml registry mbean is not found.
+        """
+        mbean = self.__find_in_location(LocationContext(), XML_REGISTRY, value, required=True)
         self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True)
         return
 
@@ -668,25 +723,6 @@ def __find_persistent_store(self, location, store_name):
         self.__logger.throwing(class_name=self._class_name, method_name=method_name, error=ex)
         raise ex
 
-    def __find_log_filter_mbean(self, location, filter_name):
-        """
-        Find the domain level log filter with the specified name and return its WLST mbean.
-        :param location: the WLST location of the attribute
-        :param filter_name: the name of the log filter to find
-        :return: the mbean for the log filter
-        :raises BundleAwareException of the specified type: if log filter is not found
-        """
-        method_name = '__find_log_filter_mbean'
-        domain_location = self.__get_domain_location(location)
-        mbean = self.__find_in_location(domain_location, LOG_FILTER, filter_name)
-        if mbean is not None:
-            return mbean
-
-        ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-19208', filter_name,
-                                               location.get_folder_path())
-        self.__logger.throwing(class_name=self._class_name, method_name=method_name, error=ex)
-        raise ex
-
     def __find_saf_destination_mbean(self, location, destination_name):
         """
         Find the SAF destination with the specified name and return its WLST mbean.
@@ -851,7 +887,6 @@ def __get_existing_object_list(self, location):
     def __merge_existing_items(self, items, existing_value):
         """
         Merge the specified items with the items represented by existing value, and return the result.
-        :param location: the location
         :param items: the attribute name
         :param existing_value: the value representing the existing items (may be a string or list)
         :return: the merged list of items