JIRA WDT-61 redesign the concept

Author: CarolynRountree

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

@@ -18,7 +18,6 @@
 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--"
@@ -60,7 +59,6 @@
 GET = 'GET'
 LSA = 'LSA'
 NONE = 'NONE'
-NAMES = 'NAMES'
 
 # set_method values
 MBEAN = 'MBEAN'

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

@@ -429,21 +429,6 @@ 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?
@@ -1138,9 +1123,6 @@ 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()

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

@@ -35,9 +35,7 @@
 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
@@ -260,24 +258,6 @@ 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?

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

@@ -16,8 +16,6 @@
 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,9 +48,9 @@ def __init__(self, model_context, base_location, wlst_mode, aliases=None):
             self._aliases = Aliases(self._model_context, wlst_mode=self._wlst_mode)
         self._alias_helper = AliasHelper(self._aliases, _logger, ExceptionType.DISCOVER)
         self._att_handler_map = OrderedDict()
-        self._wls_version = WebLogicHelper(_logger).get_actual_weblogic_version()
+        self._weblogic_helper = WebLogicHelper(_logger)
+        self._wls_version = self._weblogic_helper.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
 
@@ -103,7 +101,7 @@ def _populate_model_parameters(self, dictionary, location):
                                                                                                 wlst_value)
                 except AliasException, de:
                     _logger.info('WLSDPLY-06106', wlst_param, wlst_path, de.getLocalizedMessage(),
-                                    class_name=_class_name, method_name=_method_name)
+                                 class_name=_class_name, method_name=_method_name)
                     continue
 
                 attr_dict[model_param] = wlst_value
@@ -170,7 +168,7 @@ def _is_defined_attribute(self, location, wlst_name):
         try:
             if self._aliases.get_model_attribute_name(location, wlst_name):
                 attribute = True
-        except AliasException, ae:
+        except AliasException:
             pass
         return attribute
 
@@ -190,22 +188,6 @@ 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
@@ -258,13 +240,7 @@ 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)
-                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()
+                names = self._wlst_helper.lsc()
                 _logger.finest('WLSDPLY-06146', names, location, class_name=_class_name, method_name=_method_name)
         return names
 
@@ -387,19 +363,19 @@ 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)
+                massaged = self._inspect_artificial_folder_name(name, location)
+                location.add_name_token(name_token, massaged)
                 artificial = self._get_artificial_type(location)
                 if artificial is None:
                     _logger.warning('WLSDPLY-06123', self._alias_helper.get_model_folder_path(location),
                                     class_name=_class_name, method_name=_method_name)
                 else:
-                    _logger.finer('WLSDPLY-06120', artificial, name, model_subfolder_name, class_name=_class_name,
+                    _logger.finer('WLSDPLY-06120', artificial, massaged, model_subfolder_name, class_name=_class_name,
                                   method_name=_method_name)
                     location.append_location(artificial)
-                    subfolder_result[name] = OrderedDict()
-                    subfolder_result[name][artificial] = OrderedDict()
-                    self._populate_model_parameters(subfolder_result[name][artificial], location)
+                    subfolder_result[massaged] = OrderedDict()
+                    subfolder_result[massaged][artificial] = OrderedDict()
+                    self._populate_model_parameters(subfolder_result[massaged][artificial], location)
                     location.pop_location()
                 location.remove_name_token(name_token)
         _logger.exiting(class_name=_class_name, method_name=_method_name, result=subfolder_result)
@@ -439,12 +415,13 @@ def _discover_subfolder(self, model_subfolder_name, location, result=None):
         """
         Discover the subfolder indicated by the model subfolder name. Append the model subfolder to the
         current location context, and pop that location before return
-        :param result: dictionary to store the discovered information
+        :param model_subfolder_name: Name of the model subfolder
         :param location: context containing the current subfolder information
         :return: discovered dictionary
         """
         _method_name = '_discover_subfolder'
-        _logger.entering(model_subfolder_name, class_name=_class_name, method_name=_method_name)
+        _logger.entering(model_subfolder_name, location.get_folder_path(), class_name=_class_name,
+                         method_name=_method_name)
         location.append_location(model_subfolder_name)
         _logger.finer('WLSDPLY-06115', model_subfolder_name, self._alias_helper.get_model_folder_path(location),
                       class_name=_class_name, method_name=_method_name)
@@ -641,22 +618,6 @@ 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
@@ -675,21 +636,23 @@ 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 _inspect_artificial_folder_name(self, folder_name, location):
+        """
+        Perform any special handling for the folder or folder names.
+        :param location: current context of location
+        :return: Original name or processed name value
+        """
+        return self._inspect_security_folder_name(folder_name, location)
+
+    def _inspect_security_folder_name(self, folder_name, location):
+        # This is so clunky. My alias definition change was rejected.
+        if (not self._weblogic_helper.is_version_in_12c()) and self._wlst_mode == WlstModes.OFFLINE and \
+                'SecurityConfiguration' in location.get_folder_path() and 'Provider' == folder_name:
+            raise exception_helper.create_discover_exception('WLSDPLY-06201', folder_name, location.get_folder_path())
+        _logger.info('version {0} mode {1} folder {2} provider {3}', not self._weblogic_helper.is_version_in_12c(),
+                     self._wlst_mode == WlstModes.OFFLINE, 'SecurityConfiguration' in location.get_folder_path(),
+                     'Provider' == folder_name)
+        return folder_name
 
 
 def add_to_model_if_not_empty(dictionary, entry_name, entry_value):
@@ -700,7 +663,8 @@ def add_to_model_if_not_empty(dictionary, entry_name, entry_value):
     :param entry_value: to add to dictionary
     :return: True if the value was not empty and added to the dictionary
     """
-    if entry_value:
+    _logger.info('name {0} and value {1}', entry_name, entry_value)
+    if entry_value and len(entry_value):
         dictionary[entry_name] = entry_value
         return True
     return False
@@ -754,7 +718,7 @@ def _is_attribute_type(attribute_info):
     _method_name = '_is_attribute_type'
     if not attribute_info.isWritable() and _is_deprecated(attribute_info):
         _logger.finer('WLSDPLY-06143', attribute_info.getName(), wlst_helper.get_pwd(),
-                       class_name=_class_name, method_name=_method_name)
+                      class_name=_class_name, method_name=_method_name)
     return attribute_info.getDescriptor().getFieldValue(
         'descriptorType') == 'Attribute' and attribute_info.getDescriptor().getFieldValue(
         'com.bea.relationship') is None and (attribute_info.isWritable() or not _is_deprecated(attribute_info))

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

@@ -5,6 +5,7 @@
 from java.io import File
 from java.lang import IllegalArgumentException
 
+from oracle.weblogic.deploy.discover import DiscoverException
 from oracle.weblogic.deploy.util import PyOrderedDict as OrderedDict
 from oracle.weblogic.deploy.util import PyWLSTException
 from oracle.weblogic.deploy.util import StringUtils
@@ -290,7 +291,12 @@ def discover_security_configuration(self):
         if security_configuration is not None:
             _logger.info('WLSDPLY-06622', class_name=_class_name, method_name=_method_name)
             self._populate_model_parameters(result, location)
-            self._discover_subfolders(result, location)
+            try:
+                self._discover_subfolders(result, location)
+            except DiscoverException, de:
+                _logger.warning('WLSDPLY-06200', self._wls_version, de.getLocalizedMessage(),
+                                 class_name=_class_name, method_name=_method_name)
+                result = OrderedDict()
         _logger.exiting(class_name=_class_name, method_name=_method_name)
         return model_top_folder_name, result
 

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

@@ -1,5 +1,5 @@
 """
-Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
+Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.
 The Universal Permissive License (UPL), Version 1.0
 """
 from oracle.weblogic.deploy.aliases import AliasException
@@ -610,25 +610,6 @@ 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.
@@ -707,24 +688,6 @@ 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                            #
     ###########################################################################