renaming variables to make the create_security_providers method easier to understand (#1232)

Author: robertpatrick

integration-tests/alias-test/generate/src/test/python/aliastest/generate/generator_offline.py

@@ -270,6 +270,7 @@ def __get_attributes(self, mbean_instance):
 
         attribute_map = PyOrderedDict()
         lsa_map = generator_wlst.lsa_map()
+        self.__logger.finer('lsa_map = {0}', lsa_map, class_name=self.__class_name, method_name=_method_name)
         not_found_mbean_list = list()
         if len(lsa_map) > 0:
             not_found_mbean_list = lsa_map.keys()
@@ -278,11 +279,15 @@ def __get_attributes(self, mbean_instance):
         method_helper = MBeanMethodHelper(mbean_instance, mbean_path)
         methods_map = method_helper.get_attributes()
         methods_attributes = methods_map.keys()
+        self.__logger.finer('MBeanMethodHelper found attributes: {0}', methods_attributes,
+                            class_name=self.__class_name, method_name=_method_name)
 
         # As the driver it needs to have all attributes
         info_helper = MBeanInfoHelper(mbean_instance, mbean_path)
         info_map = info_helper.get_all_attributes()
         mbean_type = info_helper.get_mbean_type()
+        self.__logger.finer('MBeanInfoHelper for MBean type {0} found attributes: {1}', mbean_type, info_map,
+                            class_name=self.__class_name, method_name=_method_name)
 
         for attribute, attribute_helper in info_map.iteritems():
             method_attribute_helper = None
@@ -415,24 +420,27 @@ def __get_attributes_offline_only(self, mbean_instance):
     def create_security_type(self, mbean_type):
         folder_dict = PyOrderedDict()
         folder_dict[TYPE] = 'Provider'
-        types = self._sc_providers[mbean_type]
+        provider_sub_types = self._sc_providers[mbean_type]
 
-        singular = mbean_type
-        if singular.endswith('s'):
-            # FIXME - This doesn't seem very rigorous, e.g., directories => directory
+        singular_mbean_type = mbean_type
+        if singular_mbean_type.endswith('s'):
             lenm = len(mbean_type)-1
-            singular = mbean_type[0:lenm]
-        for item in types:
-            idx = item.rfind('.')
-            short = item[idx + 1:]
-            package = short
-            mbean_instance = generator_wlst.create_security_provider(singular, short, package)
+            singular_mbean_type = mbean_type[0:lenm]
+        for provider_sub_type in provider_sub_types:
+            # Remove the package name from the subclass.
+            idx = provider_sub_type.rfind('.')
+            shortened_provider_sub_type = provider_sub_type[idx + 1:]
+
+            mbean_name = shortened_provider_sub_type
+            mbean_instance = \
+                generator_wlst.create_security_provider(mbean_name, shortened_provider_sub_type, singular_mbean_type)
             orig = generator_wlst.current_path()
-            folder_dict[short] = PyOrderedDict()
-            folder_dict[short][ATTRIBUTES] = self.__get_attributes(mbean_instance)
+            folder_dict[shortened_provider_sub_type] = PyOrderedDict()
+            folder_dict[shortened_provider_sub_type][ATTRIBUTES] = self.__get_attributes(mbean_instance)
             generator_wlst.cd_mbean(orig)
-        return True, singular, folder_dict
+        return True, singular_mbean_type, folder_dict
 
+    # FIXME - This is dead code
     def _slim_maps_for_report(self, mbean_proxy, mbean_type, lsa_map, methods_map, mbean_info_map):
         # Unlike the slim_maps method, this report discards additional information to determine how
         # different is the usable information in LSA, versus cmo.getClass().getMethods versus
@@ -462,6 +470,7 @@ def _slim_maps_for_report(self, mbean_proxy, mbean_type, lsa_map, methods_map, m
         print(' lsa_map size ', len(lsa_map), '  methods_map size ', len(methods_map),
               ' mbean_info_size ', len(mbean_info_map))
 
+    # FIXME - This is dead code
     def _report_differences(self, mbean_proxy, mbean_type, lsa_map, methods_map, mbean_info_map):
         print('*************************************************************')
         print('Reporting on MBean ', str(mbean_proxy))

integration-tests/alias-test/generate/src/test/python/aliastest/generate/generator_online.py

@@ -315,22 +315,22 @@ def __create_any_subfolders(self):
 
     def generate_security_mbean(self, dictionary, mbean_type):
         dictionary[mbean_type][TYPE] = 'Provider'
-        types = self._sc_providers[mbean_type]
+        provider_subtypes = self._sc_providers[mbean_type]
         curr_path = generator_wlst.current_path()
         generator_wlst.cd_mbean(curr_path + '/' + mbean_type)
         existing = generator_wlst.lsc()
         generator_wlst.cd_mbean(curr_path)
-        for item in types:
-            idx = item.rfind('.')
-            short = item[idx + 1:]
+        for provider_subtype in provider_subtypes:
+            idx = provider_subtype.rfind('.')
+            name = provider_subtype[idx + 1:]
             orig = generator_wlst.current_path()
-            if short not in existing:
-                mbean_instance = generator_wlst.create_security_provider(mbean_type, short, item)
-                generator_wlst.cd_mbean(curr_path + '/' + mbean_type + '/' + short)
+            if name not in existing:
+                mbean_instance = generator_wlst.create_security_provider(name, provider_subtype, mbean_type)
+                generator_wlst.cd_mbean(curr_path + '/' + mbean_type + '/' + name)
             else:
-                mbean_instance = generator_wlst.get_mbean_proxy(curr_path + '/' + mbean_type + '/' + short)
-            dictionary[mbean_type][item] = PyOrderedDict()
-            dictionary[mbean_type][item][ATTRIBUTES] = self.__get_attributes(mbean_instance)
+                mbean_instance = generator_wlst.get_mbean_proxy(curr_path + '/' + mbean_type + '/' + name)
+            dictionary[mbean_type][provider_subtype] = PyOrderedDict()
+            dictionary[mbean_type][provider_subtype][ATTRIBUTES] = self.__get_attributes(mbean_instance)
             generator_wlst.cd_mbean(orig)
         generator_wlst.cd_mbean(curr_path)
 

integration-tests/alias-test/generate/src/test/python/aliastest/generate/generator_wlst.py

@@ -242,27 +242,29 @@ def created(mbean_type, name):
     return True
 
 
-def create_security_provider(mbean_type, name, package):
+def create_security_provider(name, mbean_subtype, mbean_type):
     """
     Create the MBean with the provided name at the current wlst location. WLST Exceptions are caught and returned
     as False from the method.
     :param mbean_type: MBean type to create
     :param name: Name of the MBean to create
-    :param package: package name of the security provider to create
+    :param mbean_subtype: the subtype of the security provider to create
     :return: True if successfully created
     """
-    _method_name = 'created'
+    _method_name = 'create_security_provider'
+    __logger.entering(name, mbean_subtype, mbean_type, class_name=__class_name, method_name=_method_name)
 
     online_wlst_exception = _load_global('WLSTException')
     result = None
     try:
         local_create = _load_global('create')
-        result = local_create(name, package, mbean_type)
+        result = local_create(name, mbean_subtype, mbean_type)
     except (online_wlst_exception, offlineWLSTException, ClassCastException, NoSuchMethodException), e:
-        __logger.fine('Unable to create MBean {0} with name {1} and provider name {2} at location {3} : {4}',
-                      mbean_type, name, package, current_path(), str(e),
+        __logger.fine('Unable to create MBean {0} with name {1} and provider subtype {2} at location {3} : {4}',
+                      mbean_type, name, mbean_subtype, current_path(), str(e),
                       class_name=__class_name, method_name=_method_name)
 
+    __logger.exiting(class_name=__class_name, method_name=_method_name, result=result)
     return result