Filter out Provider string in 1036 and 1211

Author: CarolynRountree

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

@@ -18,6 +18,7 @@
 GET_MBEAN_TYPE = 'get_mbean_type'
 GET_METHOD = 'get_method'
 MERGE = 'merge'
+METHOD = 'METHOD'
 MODEL_NAME = 'model_name'
 NAME_VALUE = 'name_value'
 PASSWORD_TOKEN = "--FIX ME--"
@@ -59,6 +60,7 @@
 GET = 'GET'
 LSA = 'LSA'
 NONE = 'NONE'
+NAMES = 'NAMES'
 
 # set_method values
 MBEAN = 'MBEAN'

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

@@ -429,6 +429,21 @@ def get_wlst_create_path_for_location(self, location):
         _logger.exiting(class_name=_class_name, method_name=_method_name, result=result)
         return result
 
+    def get_folder_get_method_for_location(self, location):
+        """
+        Return the value of the folder get_method attribute if present.
+        :param location: current location context of the folder
+        :return: String value, or None if not present
+        """
+        _method_name = 'get_folder_get_method_for_location'
+        _logger.entering(str(location), class_name=_class_name, method_name=_method_name)
+        folder_dict = self.__get_dictionary_for_location(location, False)
+        get_method = None
+        if folder_dict is not None and GET_METHOD in folder_dict and len(folder_dict[GET_METHOD]) > 0:
+            get_method = folder_dict[GET_METHOD]
+        _logger.exiting(class_name=_class_name, method_name=_method_name, result=get_method)
+        return get_method
+
     def is_location_child_folder_type(self, location, child_folders_type):
         """
         Does the location folder have the specified child_folders_type?
@@ -1092,6 +1107,7 @@ def __apply_wlst_context_changes(self, path_name, alias_dict, parent_dict):
         #
         # First, determine if this dictionary is even relevant to the current WLS version.
         #
+        self.__resolve_folder_params(path_name, alias_dict)
         if not self.__use_alias_dict(path_name, alias_dict, parent_dict):
             return None
 
@@ -1122,6 +1138,9 @@ def __apply_wlst_context_changes(self, path_name, alias_dict, parent_dict):
         if DEFAULT_NAME_VALUE in alias_dict:
             result[DEFAULT_NAME_VALUE] = self._resolve_curly_braces(alias_dict[DEFAULT_NAME_VALUE])
 
+        if GET_METHOD in alias_dict:
+            result[GET_METHOD] = self._resolve_curly_braces(alias_dict[GET_METHOD])
+
         if WLST_PATHS in alias_dict:
             wlst_paths = alias_dict[WLST_PATHS]
             result_wlst_paths = dict()
@@ -1242,7 +1261,7 @@ def __test_dictionary(self, path_name, alias_dict):
         return self.__is_version(path_name, alias_dict) and self.__is_wlst_mode(path_name, alias_dict)
 
     def __use_alias_dict(self, path_name, alias_dict, parent_dict):
-        self.__resolve_folder_params(path_name, alias_dict)
+
         if not self.__is_version(path_name, alias_dict):
             _add_to_unresolved_folders(path_name, parent_dict, alias_utils.get_dictionary_version(alias_dict))
             return False
@@ -1259,6 +1278,9 @@ def __resolve_folder_params(self, path_name, alias_dict):
         contain folder parameters that are different depending on the combination. Once
         a folder parameter version has been selected, then all the folder parameters in the
         valid entry are added to the alias_dict dictionary parameters.
+
+        Do not add attributes or folders from the folder_params to the folder. These are not allowed.
+        Resolve the folder params curly braces
         :param alias_dict:
         :return:
         """
@@ -1280,7 +1302,11 @@ def __resolve_folder_params(self, path_name, alias_dict):
                         add_entry = folder_set
                         break
                 for key, value in add_entry.iteritems():
-                    alias_dict[key] = value
+                    if key not in [ ATTRIBUTES, FOLDERS ]:
+                        alias_dict[key] = value
+                    else:
+                        _logger.fine('WLSDPLY-08136', path_name, value, class_name=_class_name,
+                                     method_name=_method_name)
 
     def __resolve_attribute_by_wlst_context(self, path_name, attr_name, attrs_dict):
         """

core/src/main/python/wlsdeploy/aliases/aliases.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 java.lang import String
@@ -35,7 +35,9 @@
 from wlsdeploy.aliases.alias_constants import LSA
 from wlsdeploy.aliases.alias_constants import MBEAN
 from wlsdeploy.aliases.alias_constants import MERGE
+from wlsdeploy.aliases.alias_constants import METHOD
 from wlsdeploy.aliases.alias_constants import MODEL_NAME
+from wlsdeploy.aliases.alias_constants import NAMES
 from wlsdeploy.aliases.alias_constants import PASSWORD
 from wlsdeploy.aliases.alias_constants import PASSWORD_TOKEN
 from wlsdeploy.aliases.alias_constants import PREFERRED_MODEL_TYPE
@@ -93,6 +95,13 @@ def get_mode_enum(self):
         """
         return self._wlst_mode
 
+    def get_version(self):
+        """
+        Get the version instance
+        :return: version of this aliases instance
+        """
+        return self._wls_version
+
     def get_model_top_level_folder_names(self):
         """
         Returns a list of the recognized top-level model folders corresponding to the known WLST top-level folders.
@@ -251,6 +260,24 @@ def requires_artificial_type_subfolder_handling(self, location):
         return self._alias_entries.is_location_child_folder_type(location,
                                                                  ChildFoldersTypes.MULTIPLE_WITH_TYPE_SUBFOLDER)
 
+    def get_folder_names_method(self, location):
+        """
+        Return the method_name from the folder get_method attribute.
+        None if not present for the folder. The get_method must start
+        with "NAMES." or None is returned. The "NAMES." prefix is
+        stripped from the method name. The NAMES method returns a
+        list of mbean names at the current location.
+        :param location: current location context
+        :return: method name if NAMES method is defined for the folder
+        """
+        names_method = None
+        get_method = self._alias_entries.get_folder_get_method_for_location(location)
+        method_type = NAMES + '.'
+        if get_method and get_method.startswith(method_type):
+            names_method = get_method[len(method_type):]
+
+        return names_method
+
     def supports_single_mbean_instance(self, location):
         """
         Does the location folder specified support only a single MBean instance of the parent node type?
@@ -500,14 +527,42 @@ def get_wlst_lsa_required_attribute_names(self, location):
 
         return wlst_attribute_names
 
+    def get_wlst_method_required_attribute_names(self, location):
+        """
+        Get the list of attribute names that have special methods that will get the attribute
+        value using wlst.
+        :param location: the location
+        :return: map[string=string]: the map of attribute names and the get method to invoke
+        :raises: AliasException: if an error occurs due to a bad location or bad alias data
+        """
+        _method_name = 'get_wlst_method_required_attribute_names'
+
+        wlst_attribute_names = dict()
+
+        module_folder = self._alias_entries.get_dictionary_for_location(location)
+
+        if ATTRIBUTES not in module_folder:
+            ex = exception_helper.create_alias_exception('WLSDPLY-08400', location.get_folder_path())
+            self._logger.throwing(ex, class_name=self._class_name, method_name=_method_name)
+            raise ex
+
+        for key, value in module_folder[ATTRIBUTES].iteritems():
+            if GET_METHOD in value and value[GET_METHOD].startswith(METHOD):
+                get_method_value_components = value[GET_METHOD].split('.')
+                if len(get_method_value_components) == 2:
+                    attr_get_method_name = get_method_value_components[1]
+                    wlst_attribute_names[value[WLST_NAME]] = attr_get_method_name
+
+        return wlst_attribute_names
+
     def get_wlst_get_returns_mbean_attribute_names_and_types(self, location):
         """
         Get the dictionary of attribute names and types that have their get_mbean_type specified.
         :param location: the location
         :return: dictionary: a dictionary with the attribute names as keys and the MBean types as values
         :raises: AliasException: if an error occurs due to a bad location or bad alias data
         """
-        _method_name = 'get_wlst_get_required_attribute_names'
+        _method_name = 'get_wlst_get_returns_mbean_attribute_names_and_types'
 
         wlst_attribute_names = dict()
 

core/src/main/python/wlsdeploy/tool/discover/discoverer.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 javaos as os
@@ -16,6 +16,8 @@
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.exception.expection_types import ExceptionType
 from wlsdeploy.logging.platform_logger import PlatformLogger
+from wlsdeploy.tool.util.attribute_getter import AttributeGetter
+from wlsdeploy.tool.util.mbean_getter import MBeanGetter
 from wlsdeploy.tool.util.alias_helper import AliasHelper
 from wlsdeploy.tool.util.wlst_helper import WlstHelper
 from wlsdeploy.util import path_utils
@@ -50,6 +52,7 @@ def __init__(self, model_context, base_location, wlst_mode, aliases=None):
         self._att_handler_map = OrderedDict()
         self._wls_version = WebLogicHelper(_logger).get_actual_weblogic_version()
         self._wlst_helper = WlstHelper(_logger, ExceptionType.DISCOVER)
+        self._mbean_getter = MBeanGetter(self._aliases, ExceptionType.DISCOVER, _logger)
 
     # methods for use only by the subclasses
 
@@ -174,8 +177,8 @@ def _is_defined_attribute(self, location, wlst_name):
     def _get_required_attributes(self, location):
         """
         Use get for all online attributes, and use the attribute names in the
-        :param location:
-        :return:
+        :param location: current location context
+        :return: list of attributes that require wlst.get
         """
         _method_name = '_get_required_attributes'
         attributes = []
@@ -187,6 +190,22 @@ def _get_required_attributes(self, location):
                             class_name=_class_name, method_name=_method_name)
         return attributes
 
+    def _method_required_attributes(self, location):
+        """
+        Use a special method to get the online attribute.
+        :param location: current location context
+        :return: map of attributes that require special processing via a method
+        """
+        _method_name = '_method_required_attributes'
+        attributes = dict()
+        try:
+            attributes = self._alias_helper.get_wlst_get_required_attribute_names(location)
+        except DiscoverException, de:
+            name = location.get_model_folders()[-1]
+            _logger.warning('WLSDPLY-06109', name, location.get_folder_path(), de.getLocalizedMessage(),
+                            class_name=_class_name, method_name=_method_name)
+        return attributes
+
     def _mbean_names_exist(self, location):
         """
         Check to see if there are any configured MBeans for the current location
@@ -239,7 +258,14 @@ def _find_names_in_folder(self, location):
             _logger.finest('WLSDPLY-06111', folder_path, class_name=_class_name, method_name=_method_name)
             if wlst_helper.path_exists(folder_path):
                 self.wlst_cd(folder_path, location)
-                names = self._wlst_helper.lsc()
+                getter_method = self._alias_helper.get_folder_names_method(location)
+                if getter_method:
+                    _logger.finer('WLSDPLY-06149', getter_method, location.get_folder_path(), class_name=_class_name,
+                                  method_name=_method_name)
+                    names = self._call_method_to_get_mbean_names(location, getter_method)
+                else:
+                    names = self._wlst_helper.lsc()
+                _logger.finest('WLSDPLY-06146', names, location, class_name=_class_name, method_name=_method_name)
         return names
 
     def _find_singleton_name_in_folder(self, location):
@@ -268,6 +294,7 @@ def _find_subfolders(self, location):
             return self._find_subfolders_offline(location)
         else:
             return self._find_subfolders_online(location)
+
     def _find_subfolders_offline(self, location):
         """
         Find the subfolders of the current location.
@@ -360,6 +387,7 @@ def _discover_artificial_folder(self, model_subfolder_name, location, name_token
         names = self._find_names_in_folder(location)
         if names is not None:
             for name in names:
+                _logger.fine('Checking folder name {0}', name)
                 location.add_name_token(name_token, name)
                 artificial = self._get_artificial_type(location)
                 if artificial is None:
@@ -613,6 +641,22 @@ def _get_wlst_attributes(self, location):
                     continue
         return wlst_attributes
 
+    def _call_method_to_get_mbean_names(self, location, getter_method):
+        _method_name = '_call_method_to_get_mbean_names'
+        mbean_names = []
+        if getter_method is not None:
+            try:
+                _logger.finest('WLSDPLY-12124', getter_method, location.get_folder_path(),
+                               class_name=_class_name, method_name=_method_name)
+                get_method = getattr(self._mbean_getter, getter_method)
+                mbean_names = get_method(location)
+            except AttributeError, ae:
+                ex = exception_helper.create_create_exception('WLSDPLY-12125', getter_method, location.get_folder_path()
+                                                              , error=ae)
+                _logger.throwing(ex, class_name=_class_name, method_name=_method_name)
+                raise ex
+        return mbean_names
+
     def wlst_cd(self, path, location):
         """
         Change to the directory specified in the path. If the wlst.cd() fails, assume something is wrong with the
@@ -631,6 +675,22 @@ def wlst_cd(self, path, location):
                             method_name=_method_name)
         return result
 
+    def call_get_names_method(self, location, wlst_method):
+        _method_name = 'call_get_method'
+        _logger.entering(str(location), wlst_method, class_name=_class_name, method_name=_method_name)
+        try:
+            _logger.fine('WLSDPLY-06147', wlst_method, self._alias_helper.get_model_folder_path(location),
+                         class_name=_class_name, method_name=_method_name)
+            get_method = getattr(self._mbean_getter, wlst_method)
+            mbean_names = get_method(location)
+        except AttributeError, ae:
+            ex = exception_helper.create_create_exception('WLSDPLY-06148', wlst_method,
+                                                          self._alias_helper.get_model_folder_path(location), error=ae)
+            _logger.throwing(ex, class_name=_class_name, method_name=_method_name)
+            raise ex
+        _logger.exiting(class_name=_class_name, method_name=_method_name, result=mbean_names)
+        return mbean_names
+
 
 def add_to_model_if_not_empty(dictionary, entry_name, entry_value):
     """

core/src/main/python/wlsdeploy/tool/util/alias_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
 """
 from oracle.weblogic.deploy.aliases import AliasException
@@ -610,6 +610,25 @@ def get_wlst_get_required_attribute_names(self, location):
             raise ex
         return result
 
+    def get_wlst_method_required_attribute_names(self, location):
+        """
+        Get the list of attribute names that require special processing via a method
+        :param location: the location
+        :return: dict[string=string]: the dictionary of attribute names and the attribute's method
+        :raises: BundleAwareException of the specified type: if an error occurs
+        """
+        _method_name = 'get_wlst_method_required_attribute_names'
+
+        try:
+            result = self.__aliases.get_wlst_method_required_attribute_names(location)
+        except AliasException, ae:
+            ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-19034',
+                                                   location.get_current_model_folder(), location.get_folder_path(),
+                                                   ae.getLocalizedMessage(), error=ae)
+            self.__logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
+            raise ex
+        return result
+
     def get_model_subfolder_name(self, location, wlst_name):
         """
         Get the model folder name for the WLST subfolder name at the specified location.
@@ -688,6 +707,24 @@ def get_model_attribute_default_value(self, location, model_attribute_name):
             raise ex
         return result
 
+    def get_folder_names_method(self, location):
+        """
+        Get the method for retrieving the folder names for the folder at the current location
+        :param location: current location context
+        :return: method name or None if not present for the folder
+        """
+        _method_name = 'get_folder_names_method'
+
+        try:
+            getter_method = self.__aliases.get_folder_names_method(location)
+        except AliasException, ae:
+            ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-19035',
+                                                   location.get_model_folders()[-1], location.get_folder_path(),
+                                                       ae.getLocalizedMessage(), error=ae)
+            self.__logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
+            raise ex
+        return getter_method
+
     ###########################################################################
     #                          Convenience Methods                            #
     ###########################################################################