Merge pull request #251 from oracle/Issue#168-Arrays-needed-to-version-folders

Issue#168 arrays needed to version folders

Author: rakillen

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

@@ -1084,6 +1084,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
 
@@ -1234,7 +1235,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
@@ -1251,6 +1252,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:
         """
@@ -1272,7 +1276,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

@@ -283,6 +283,18 @@ def is_custom_folder_allowed(self, location):
         return self._alias_entries.is_location_child_folder_type(location,
                                                                  ChildFoldersTypes.MULTIPLE_WITH_TYPE_SUBFOLDER)
 
+    def is_security_provider_type(self, location):
+        """
+        Returns true if the specified location is a security provider type, such as AuthenticationProvider.
+        This currently corresponds to all MULTIPLE_WITH_TYPE_SUBFOLDER entries.
+        This will need to be refined if new custom types are added, or additional distinctions are required.
+        :param location: the location to be checked
+        :return: True if the location is a security provider type, False otherwise
+        :raises: AliasException: if an error occurs while getting the folder for the location
+        """
+        return self._alias_entries.is_location_child_folder_type(location,
+                                                                 ChildFoldersTypes.MULTIPLE_WITH_TYPE_SUBFOLDER)
+
     ###########################################################################
     #                     WLST Folder create-related methods                  #
     ###########################################################################
@@ -383,7 +395,8 @@ def get_wlst_attribute_name_and_value(self, location, model_attribute_name, mode
             else:
                 wlst_attribute_name = attribute_info[WLST_NAME]
 
-            if self._model_context and USES_PATH_TOKENS in attribute_info and string_utils.to_boolean(attribute_info[USES_PATH_TOKENS]):
+            if self._model_context and USES_PATH_TOKENS in attribute_info and \
+                    string_utils.to_boolean(attribute_info[USES_PATH_TOKENS]):
                 model_attribute_value = self._model_context.replace_token_string(model_attribute_value)
 
             data_type = attribute_info[WLST_TYPE]
@@ -524,7 +537,7 @@ def get_wlst_get_returns_mbean_attribute_names_and_types(self, 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

@@ -48,7 +48,8 @@ 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)
 
     # methods for use only by the subclasses
@@ -100,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
@@ -167,15 +168,15 @@ 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
 
     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 = []
@@ -240,6 +241,7 @@ def _find_names_in_folder(self, location):
             if wlst_helper.path_exists(folder_path):
                 self.wlst_cd(folder_path, location)
                 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 +270,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,18 +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:
-                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)
@@ -411,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)
@@ -631,6 +636,27 @@ def wlst_cd(self, path, location):
                             method_name=_method_name)
         return result
 
+    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 clunky - Some security providers in 11g offline have the name "Provider", and cannot be discovered.
+        # If found, log and throw an exception here, and the SecurityConfiguration will be omitted from the model.
+
+        if (not self._weblogic_helper.is_version_in_12c()) and self._wlst_mode == WlstModes.OFFLINE and \
+                self._alias_helper.is_security_provider_type(location) and 'Provider' == folder_name:
+            raise exception_helper.create_discover_exception('WLSDPLY-06201', folder_name, location.get_folder_path())
+
+        _logger.fine('version {0} mode {1} type? {2} provider {3}', not self._weblogic_helper.is_version_in_12c(),
+                     self._wlst_mode == WlstModes.OFFLINE, self._alias_helper.is_security_provider_type(location),
+                     'Provider' == folder_name)
+        return folder_name
+
 
 def add_to_model_if_not_empty(dictionary, entry_name, entry_value):
     """
@@ -640,7 +666,7 @@ 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:
+    if entry_value and len(entry_value):
         dictionary[entry_name] = entry_value
         return True
     return False
@@ -694,7 +720,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
@@ -289,8 +290,14 @@ def discover_security_configuration(self):
         security_configuration = self._find_singleton_name_in_folder(location)
         if security_configuration is not None:
             _logger.info('WLSDPLY-06622', class_name=_class_name, method_name=_method_name)
+            location.add_name_token(self._alias_helper.get_name_token(location), security_configuration)
             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

@@ -293,6 +293,24 @@ def is_custom_folder_allowed(self, location):
             raise ex
         return result
 
+    def is_security_provider_type(self, location):
+        """
+        Returns true if the specified location is a security provider type.
+        :param location: the location to be checked
+        :return: True, if the location is a security provider type, False otherwise
+        :raises: BundleAwareException of the specified type: if an error occurs
+        """
+        _method_name = 'is_security_provider_type'
+
+        try:
+            result = self.__aliases.is_security_provider_type(location)
+        except AliasException, ae:
+            ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-19036', str(location),
+                                                   ae.getLocalizedMessage(), error=ae)
+            self.__logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
+            raise ex
+        return result
+
     def get_wlst_mbean_name(self, location):
         """
         Get the MBean name to use to create it for the specified location.

core/src/main/python/wlsdeploy/util/weblogic_helper.py

@@ -130,6 +130,13 @@ def get_default_security_realm_name(self):
         """
         return 'myrealm'
 
+    def is_version_in_12c(self):
+        """
+        Is the weblogic version a 12c version?
+        :return: True if the version is 12c
+        """
+        return self.is_weblogic_version_or_above('12.1.2')
+
     # This method should be deleted once all of the old code is converted to the new model.
     def get_wlst_exception_content(self, message):
         """

core/src/main/resources/oracle/weblogic/deploy/aliases/category_modules/SecurityConfiguration.json

@@ -88,7 +88,6 @@
                             "wlst_paths": {
                                 "WP001": "/SecurityConfiguration/%SEC_CONFIG%/Realm${:s}/%REALM%/Adjudicator/%PROVIDER%"
                             }
-
                         }
                     },
                     "attributes" : { },

core/src/main/resources/oracle/weblogic/deploy/messages/wlsdeploy_rb.properties

@@ -469,6 +469,12 @@ WLSDPLY-06145=Subfolder list {0} at location {1} does not match the mbi containm
 WLSDPLY-06146=Discovered WLST MBean names {0} at location {1}
 WLSDPLY-06147=Call method {0} to get the value for wlst attribute {1} at wlst path {2}
 
+# mbean_getter.py, attribute_getter.py specific to discover
+WLSDPLY-06200=Unable to get the Security Realm Provider name in version {0} with offline wlst. \
+  The SecurityConfiguration will not be added to the model. The work-around is to \
+  manually add the Security Configuration to the model or to discover the domain in online mode : {1}.
+WLSDPLY-06201=Invalid Security Provider name "{0}" found for provider type at location {1}
+
 # resources_discoverer.py
 WLSDPLY-06300=Discovering domain model resources
 
@@ -1113,6 +1119,7 @@ WLSDPLY-19033=Failed to determine if location ({0}) is version valid, or not
 WLSDPLY-19034=Failed to get the model attribute list that require a special processing via a method for model \
   folder ({0}) at location ({1}): {2}
 WLSDPLY-19035=Failed to determine if the location ({0}) allows custom folder types: {1}
+WLSDPLY-19036=Failed to determine if the location ({0}) is a security provider: {1}
 
 # wlsdeploy/tool/util/wlst_helper.py
 WLSDPLY-19100=Failed to change to the WLST directory {0}: {1}