Wdt 462 security configuration defaults (#721)

* WDT remove SecurityConfiguration defaults from model

* Clean up SecurityConfiguration for online

Author: CarolynRountree

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

@@ -14,6 +14,7 @@
 DEFAULT_NAME_VALUE = 'default_name_value'
 FLATTENED_FOLDER_DATA = 'flattened_folder_data'
 FOLDERS = 'folders'
+FOLDER_ORDER = 'folder_order'
 FOLDER_PARAMS = 'folder_params'
 GET_MBEAN_TYPE = 'get_mbean_type'
 GET_METHOD = 'get_method'

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

@@ -18,6 +18,7 @@
 from wlsdeploy.aliases.alias_constants import CONTAINS
 from wlsdeploy.aliases.alias_constants import DEFAULT_NAME_VALUE
 from wlsdeploy.aliases.alias_constants import FLATTENED_FOLDER_DATA
+from wlsdeploy.aliases.alias_constants import FOLDER_ORDER
 from wlsdeploy.aliases.alias_constants import FOLDER_PARAMS
 from wlsdeploy.aliases.alias_constants import FOLDERS
 from wlsdeploy.aliases.alias_constants import GET_MBEAN_TYPE
@@ -903,6 +904,47 @@ def is_model_location_valid(self, location):
                 return False
         return True
 
+    def get_folders_in_order_for_location(self, location):
+        """
+        Find the folders that are ordered (greater than zero) at the specified location and
+        return the list in order of the 
+        :param location:
+        :return:
+        """
+        _method_name = 'get_folders_in_order_for_location'
+        holder = dict()
+        for subfolder in self.get_model_subfolder_names_for_location(location):
+            result = self.get_folder_order_for_location(location, subfolder)
+            if result > 0:
+                if result in holder:
+                    ex = exception_helper.create_alias_exception('WLSDPLY-08137', subfolder, holder[result])
+                    _logger.throwing(ex, class_name=_class_name, method_name=_method_name)
+                    raise ex
+                holder[result] = subfolder
+
+        result = list()
+        keys = holder.keys()
+        keys.sort()
+        for key in keys:
+            result.append(holder[key])
+
+        return result
+
+    def get_folder_order_for_location(self, parent_location, subfolder_name):
+        """
+        Get the order for the subfolder named under the provided location.
+        :param parent_location: location of the subfolder
+        :param subfolder_name: name of the subfolder
+        :return: folder order of the subfolder or 0 if not ordered
+        """
+        location = LocationContext(parent_location)
+        location.append_location(subfolder_name)
+        folder_dict = self.__get_dictionary_for_location(location, False)
+        result = 0
+        if FOLDER_ORDER in folder_dict:
+            result = int(folder_dict[FOLDER_ORDER])
+        return result
+
     def get_folder_short_name_for_location(self, location):
         """
         Retrieve the shortened name for the model folder at the provided location.
@@ -1176,6 +1218,9 @@ def __apply_wlst_context_changes(self, path_name, alias_dict, parent_dict):
         if SHORT_NAME in alias_dict:
             result[SHORT_NAME] = alias_dict[SHORT_NAME]
 
+        if FOLDER_ORDER in alias_dict:
+            result[FOLDER_ORDER] = alias_dict[FOLDER_ORDER]
+
         if WLST_PATHS in alias_dict:
             wlst_paths = alias_dict[WLST_PATHS]
             result_wlst_paths = dict()

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

@@ -307,6 +307,19 @@ def supports_multiple_mbean_instances(self, location):
         except AliasException, ae:
             self._raise_exception(ae, _method_name, 'WLSDPLY-19008', str(location), ae.getLocalizedMessage())
 
+    def get_subfolders_in_order(self, location):
+        """
+        Return the sub-folder names that have an order in the order defined.
+        :param location: location of the ordered sub-folders
+        :return: list of sub-folder names in order
+        """
+        _method_name = 'get_subfolders_in_order'
+        try:
+            return self._alias_entries.get_folders_in_order_for_location(location)
+        except AliasException, ae:
+            self._raise_exception(ae, _method_name, 'WLSDPLY-19044',
+                                  location.get_folder_path(), ae.getLocalizedMessage())
+
     def requires_artificial_type_subfolder_handling(self, location):
         """
         Does the location folder specified both support multiple MBean instances of the parent node type

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

@@ -386,7 +386,7 @@ def _discover_subfolder_with_single_name(self, model_subfolder_name, location, n
         _logger.exiting(class_name=_class_name, method_name=_method_name)
         return result
 
-    def _discover_artificial_folder(self, model_subfolder_type, location, name_token):
+    def _discover_artificial_folder(self, model_subfolder_type, location, name_token, check_order=False):
         """
         Discover the subfolder that has an artificial connection; the subfolder contains multiple different types
         under one MBean. The model must contain the subfolder type, the artificial type that specifies which it is,
@@ -395,13 +395,17 @@ def _discover_artificial_folder(self, model_subfolder_type, location, name_token
         :param model_subfolder_type: type of the model subfolder
         :param location: context containing the current location information
         :param name_token: for use in the location to contain the folder name
+        :param check_order: if true, check the subfolders for order
         :return: dictionary containing the discovered folder attributes
         """
         _method_name = '_discover_artifical_folder'
         _logger.entering(model_subfolder_type, str(location), name_token, class_name=_class_name,
                          method_name=_method_name)
         subfolder_result = OrderedDict()
         names = self._find_names_in_folder(location)
+        required_order = self._aliases.get_subfolders_in_order(location)
+        attr_map = dict()
+        default_list = list()
         if names is not None:
             for name in names:
                 massaged = self._inspect_artificial_folder_name(name, location)
@@ -411,6 +415,9 @@ def _discover_artificial_folder(self, model_subfolder_type, location, name_token
                     if self._aliases.is_custom_folder_allowed(location):
                         _logger.fine('WLSDPLY-06148', model_subfolder_type, massaged, location.get_folder_path(),
                                      class_name=_class_name, method_name=_method_name)
+                        # doesn't matter how many parameters, it is automatically a non-default name
+                        default_list.append(massaged)
+                        attr_map[massaged] = 0
                         subfolder_result.update(
                             self._custom_folder.discover_custom_mbean(location, model_subfolder_type, massaged))
                     else:
@@ -423,8 +430,23 @@ def _discover_artificial_folder(self, model_subfolder_type, location, name_token
                     subfolder_result[massaged] = OrderedDict()
                     subfolder_result[massaged][artificial] = OrderedDict()
                     self._populate_model_parameters(subfolder_result[massaged][artificial], location)
+                    default_list.append(artificial)
+                    attr_map[artificial] = len(subfolder_result[massaged][artificial])
                     location.pop_location()
                 location.remove_name_token(name_token)
+
+        # check to see if the order and number of the subfolder list is same as required order
+        is_default = False
+        if check_order and len(required_order) == len(default_list):
+            is_default = True
+            idx = 0
+            while idx < len(required_order):
+                if  required_order[idx] != default_list[idx] or attr_map[default_list[idx]] > 0:
+                    is_default = False
+                    break
+                idx += 1
+        if is_default:
+            subfolder_result = None
         _logger.exiting(class_name=_class_name, method_name=_method_name, result=subfolder_result)
         return subfolder_result
 
@@ -458,12 +480,13 @@ def _discover_subfolder_with_names(self, model_subfolder_name, location, name_to
         _logger.exiting(class_name=_class_name, method_name=_method_name)
         return subfolder_result
 
-    def _discover_subfolder(self, model_subfolder_name, location, result=None):
+    def _discover_subfolder(self, model_subfolder_name, location, result=None, check_order=False):
         """
         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 model_subfolder_name: Name of the model subfolder
         :param location: context containing the current subfolder information
+        :param check_order: does the folder need to be checked for order
         :return: discovered dictionary
         """
         _method_name = '_discover_subfolder'
@@ -485,22 +508,29 @@ def _discover_subfolder(self, model_subfolder_name, location, result=None):
                 subfolder_result = self._discover_subfolder_with_single_name(model_subfolder_name, location,
                                                                              name_token)
             elif self._aliases.requires_artificial_type_subfolder_handling(location):
-                subfolder_result = self._discover_artificial_folder(model_subfolder_name, location, name_token)
+                subfolder_result = self._discover_artificial_folder(
+                    model_subfolder_name, location, name_token, check_order)
             else:
                 subfolder_result = self._discover_subfolder_with_names(model_subfolder_name, location,
                                                                        name_token)
         else:
             subfolder_result = self._discover_subfolder_singleton(model_subfolder_name, location)
-        add_to_model_if_not_empty(result, model_subfolder_name, subfolder_result)
+        # this is a really special case. Empty means not-default it is empty
+        if self._aliases.requires_artificial_type_subfolder_handling(location):
+            if subfolder_result is not None:
+                add_to_model(result, model_subfolder_name, subfolder_result)
+        else:
+            add_to_model_if_not_empty(result, model_subfolder_name, subfolder_result)
         location.pop_location()
         _logger.exiting(class_name=_class_name, method_name=_method_name, result=result)
         return result
 
-    def _discover_subfolders(self, result, location):
+    def _discover_subfolders(self, result, location, check_order=False):
         """
         Discover the rest of the mbean hierarchy at the current location.
         :param result: dictionary where to store the discovered subfolders
         :param location: context containing current location information
+        :param check_order: True if artificial folder has an order to check
         :return: populated dictionary
         """
         _method_name = '_discover_subfolders'
@@ -511,7 +541,7 @@ def _discover_subfolders(self, result, location):
                 model_subfolder_name = self._get_model_name(location, wlst_subfolder)
                 # will return a None if subfolder not in current wls version
                 if model_subfolder_name is not None:
-                    result = self._discover_subfolder(model_subfolder_name, location, result)
+                    result = self._discover_subfolder(model_subfolder_name, location, result, check_order)
         _logger.finest('WLSDPLY-06114', str(location), class_name=_class_name, method_name=_method_name)
         _logger.exiting(class_name=_class_name, method_name=_method_name, result=result)
         return result
@@ -790,6 +820,15 @@ def add_to_model_if_not_empty(dictionary, entry_name, entry_value):
     return False
 
 
+def add_to_model(dictionary, entry_name, entry_value):
+    """
+    Add this to the model even if empty
+    :param dictionary: to add the value
+    :param entry_name: name of the key
+    :param entry_value: dictionary to add
+    """
+    dictionary[entry_name] = entry_value
+
 def convert_to_absolute_path(relative_to, file_name):
     """
     Transform the path by joining the relative_to before the file_name and converting the resulting path name to

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

@@ -24,6 +24,7 @@
 from wlsdeploy.tool.discover.discoverer import Discoverer
 from wlsdeploy.tool.util.variable_injector import VARIABLE_SEP
 from wlsdeploy.tool.util.wlst_helper import WlstHelper
+from wlsdeploy.util import dictionary_utils
 from wlsdeploy.util import string_utils
 from wlsdeploy.util import variables
 
@@ -323,14 +324,43 @@ def discover_security_configuration(self):
             location.add_name_token(self._aliases.get_name_token(location), security_configuration)
             self._populate_model_parameters(result, location)
             self._massage_security_credential(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
+            location.append_location(model_constants.REALM)
+            result[model_constants.REALM] = OrderedDict()
+            realms = self._find_names_in_folder(location)
+            for realm in realms:
+                name_token = self._aliases.get_name_token(location)
+                location.add_name_token(name_token, realm)
+                result[model_constants.REALM][realm] = OrderedDict()
+                self._populate_model_parameters(result[model_constants.REALM][realm], location)
+                if realm == 'myrealm':
+                    check_order=True
+                else:
+                    check_order=False
+                try:
+                    self._discover_subfolders(result[model_constants.REALM][realm], location, check_order)
+                    location.remove_name_token(name_token)
+                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, result=model_top_folder_name)
+        return model_top_folder_name, self._slim_security_config(result)
+
+    def _slim_security_config(self, sc_dict):
+        """
+        Check the default realm 'myrealm' for any customization. Remove the parts of the SecurityConfiguration that
+        are defaulted to the way installed by the WLS template. If the entire SecurityConfiguration is the default,
+        remove the SecurityConfiguration section.
+        :param sc_dict: SecurityConfiguration section of model
+        :return: converted_dictionary with defaults removed
+        """
+        realm_dict = dictionary_utils.get_dictionary_element(sc_dict, model_constants.REALM)
+        if 'myrealm' in realm_dict and dictionary_utils.is_empty_dictionary_element(realm_dict, 'myrealm'):
+            del sc_dict[model_constants.REALM]['myrealm']
+        if dictionary_utils.is_empty_dictionary_element(sc_dict, model_constants.REALM):
+            del sc_dict[model_constants.REALM]
+        return sc_dict
 
     def get_embedded_ldap_configuration(self):
         """