Include appDeployments in model traverse base class; refactor to simplify recursion

Author: rakillen

core/src/main/python/wlsdeploy/tool/util/filters/model_traverse.py

@@ -3,6 +3,7 @@
 
 from wlsdeploy.aliases.aliases import Aliases
 from wlsdeploy.aliases.location_context import LocationContext
+from wlsdeploy.aliases.model_constants import APP_DEPLOYMENTS
 from wlsdeploy.aliases.model_constants import DOMAIN_INFO
 from wlsdeploy.aliases.model_constants import RESOURCES
 from wlsdeploy.aliases.model_constants import TOPOLOGY
@@ -21,45 +22,29 @@ def __init__(self, model_context, wlst_mode, exception_type):
         self._logger = PlatformLogger('wlsdeploy.model_traverse')
 
     def traverse_model(self, root_dict):
-        section_names = [DOMAIN_INFO, TOPOLOGY, RESOURCES]
+        section_names = [DOMAIN_INFO, TOPOLOGY, RESOURCES, APP_DEPLOYMENTS]
         for section_name in section_names:
-            self.traverse_section(section_name, root_dict,
-                                  self._aliases.get_model_section_top_level_folder_names(section_name))
+            self.traverse_section(root_dict, section_name)
 
-    def traverse_section(self, model_section_key, model_dict, valid_section_folders):
-        if model_section_key not in model_dict.keys():
+    def traverse_section(self, model_dict, section_name):
+        if section_name not in model_dict.keys():
             return
 
         # only specific top-level sections have attributes
-        attribute_location = self._aliases.get_model_section_attribute_location(model_section_key)
-        valid_attr_infos = []
-
+        valid_attribute_names = []
+        attribute_location = self._aliases.get_model_section_attribute_location(section_name)
         if attribute_location is not None:
-            valid_attr_infos = self._aliases.get_model_attribute_names_and_types(attribute_location)
-
-        model_section_dict = model_dict[model_section_key]
-        # use items(), not iteritems(), to avoid ConcurrentModificationException if dict is modified
-        for section_dict_key, section_dict_value in model_section_dict.items():
-            # section_dict_key is the name of a folder or attribute in the section.
-
-            if section_dict_key in valid_attr_infos:
-                # section_dict_key is the name of an attribute in the section
-                self.traverse_attribute(model_section_dict, section_dict_key, attribute_location)
+            valid_attribute_names = self._aliases.get_model_attribute_names_and_types(attribute_location)
 
-            elif section_dict_key in valid_section_folders:
-                # section_dict_key is a folder under the model section
-
-                # Append section_dict_key to location context
-                model_location = LocationContext()
-                model_location.append_location(section_dict_key)
-
-                # Call self.traverse_folder() passing in section_dict_value as the model_node to process
-                self.traverse_folder(section_dict_value, model_location)
+        model_location = LocationContext()
+        model_section_dict = model_dict[section_name]
+        valid_folder_names = self._aliases.get_model_section_top_level_folder_names(section_name)
+        self.traverse_node_elements(model_section_dict, model_location, valid_folder_names, valid_attribute_names)
 
     def traverse_folder(self, model_node, model_location):
         """
         Traverse a folder that may have named sub-folders (such as Server), artificial named sub-folders (such
-        as a security provider type), or its own sub-folders and attributes (such as .
+        as a security provider type), or its own sub-folders and attributes (such as JTA).
         """
 
         # avoid checking folder type if is_artificial_type_folder
@@ -86,19 +71,22 @@ def traverse_folder(self, model_node, model_location):
             self.traverse_node(model_node, model_location)
 
     def traverse_node(self, model_node, model_location):
+        valid_folder_names = self._aliases.get_model_subfolder_names(model_location)
+        valid_attribute_names = self._aliases.get_model_attribute_names(model_location)
+        self.traverse_node_elements(model_node, model_location, valid_folder_names, valid_attribute_names)
+
+    def traverse_node_elements(self, model_node, model_location, valid_folder_names, valid_attribute_names):
         """
         Traverse a node that contains only attributes, non-named sub-folders, and artificial type folders.
         """
-        valid_folder_keys = self._aliases.get_model_subfolder_names(model_location)
-        valid_attr_infos = self._aliases.get_model_attribute_names_and_types(model_location)
 
         # use items(), not iteritems(), to avoid ConcurrentModificationException if node is modified
         for key, value in model_node.items():
-            if key in valid_folder_keys:
+            if key in valid_folder_names:
                 new_location = LocationContext(model_location).append_location(key)
                 self.traverse_folder(value, new_location)
 
-            elif key in valid_attr_infos:
+            elif key in valid_attribute_names:
                 self.traverse_attribute(model_node, key, model_location)
 
             else: