JIRA WDT-378 Use alias files for domain info folders and attributes (#496)

* JIRA WDT-378 - Create aliases for domainInfo sections, use for print-usage

* JIRA WDT-378 - Use domain info aliases for model encryption

* JIRA WDT-378 - Flag domainBin and domainLibraries to use path tokens, for validation against archive

* JIRA WDT-378 - Use domain info aliases for model validation, fixed top-level attribute validation

* JIRA WDT-378 - Removed unused methods for domainInfo fields

* JIRA WDT-378 - Corrected property name in example

Author: rakillen

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

@@ -12,20 +12,9 @@
 
 import wlsdeploy.aliases.alias_utils as alias_utils
 from wlsdeploy.aliases import password_utils
-from wlsdeploy.aliases.alias_constants import ChildFoldersTypes
-from wlsdeploy.aliases.location_context import LocationContext
-from wlsdeploy.aliases.model_constants import APPLICATION
-from wlsdeploy.aliases.model_constants import ODL_CONFIGURATION
-from wlsdeploy.aliases.model_constants import RESOURCE_MANAGER
-from wlsdeploy.aliases.validation_codes import ValidationCodes
-from wlsdeploy.aliases.wlst_modes import WlstModes
-from wlsdeploy.exception import exception_helper
-from wlsdeploy.logging.platform_logger import PlatformLogger
-from wlsdeploy.util import dictionary_utils
-from wlsdeploy.util.weblogic_helper import WebLogicHelper
-
 from wlsdeploy.aliases.alias_constants import ATTRIBUTES
 from wlsdeploy.aliases.alias_constants import CHILD_FOLDERS_TYPE
+from wlsdeploy.aliases.alias_constants import ChildFoldersTypes
 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
@@ -43,7 +32,6 @@
 from wlsdeploy.aliases.alias_constants import SINGLE
 from wlsdeploy.aliases.alias_constants import UNRESOLVED_ATTRIBUTES_MAP
 from wlsdeploy.aliases.alias_constants import UNRESOLVED_FOLDERS_MAP
-from wlsdeploy.aliases.alias_constants import VERSION
 from wlsdeploy.aliases.alias_constants import VERSION_RANGE
 from wlsdeploy.aliases.alias_constants import WLST_ATTRIBUTES_PATH
 from wlsdeploy.aliases.alias_constants import WLST_CREATE_PATH
@@ -56,6 +44,19 @@
 from wlsdeploy.aliases.alias_constants import WLST_SKIP_NAMES
 from wlsdeploy.aliases.alias_constants import WLST_SUBFOLDERS_PATH
 from wlsdeploy.aliases.alias_constants import WLST_TYPE
+from wlsdeploy.aliases.location_context import LocationContext
+from wlsdeploy.aliases.model_constants import APPLICATION
+from wlsdeploy.aliases.model_constants import RCU_DB_INFO
+from wlsdeploy.aliases.model_constants import WLS_ROLES
+from wlsdeploy.aliases.model_constants import ODL_CONFIGURATION
+from wlsdeploy.aliases.model_constants import DOMAIN_INFO_ALIAS
+from wlsdeploy.aliases.model_constants import RESOURCE_MANAGER
+from wlsdeploy.aliases.validation_codes import ValidationCodes
+from wlsdeploy.aliases.wlst_modes import WlstModes
+from wlsdeploy.exception import exception_helper
+from wlsdeploy.logging.platform_logger import PlatformLogger
+from wlsdeploy.util import dictionary_utils
+from wlsdeploy.util.weblogic_helper import WebLogicHelper
 
 _class_name = 'AliasEntries'
 _logger = PlatformLogger('wlsdeploy.aliases')
@@ -131,23 +132,12 @@ class AliasEntries(object):
         'Library'
     ]
 
-    __all_model_categories = []
+    __domain_info_top_level_folders = [
+        RCU_DB_INFO,
+        WLS_ROLES
+    ]
 
-    __domain_info_attributes_and_types = {
-        'AdminUserName': 'string',
-        'AdminPassword': 'password',
-        'ServerStartMode': 'string',
-        'domainBin': 'list',
-        'domainLibraries': 'list',
-        # A map of Server Group names to the list of servers/clusters to which they should
-        # be targeted.  The ServerGroup must appear in the domain typedef definition.  If
-        # the ServerGroup is not listed in this map, it will be targeted to all managed
-        # servers in the domain.
-        'ServerGroupTargetingLimits': 'dict',
-        'RCUDbInfo': 'dict',
-        'OPSSSecrets': 'password',
-        'WLSRoles': 'dict'
-    }
+    __all_model_categories = []
 
     __domain_name_token = 'DOMAIN'
 
@@ -169,8 +159,13 @@ def __init__(self, wlst_mode=WlstModes.OFFLINE, wls_version=None):
         self.__all_model_categories.extend(self.__topology_top_level_folders)
         self.__all_model_categories.extend(self.__resources_top_level_folders)
         self.__all_model_categories.extend(self.__app_deployments_top_level_folders)
+        self.__all_model_categories.extend(self.__domain_info_top_level_folders)
+
+        # ResourceManager is not a top-level folder, it's contained by ResourceManagement
         self.__all_model_categories.append(RESOURCE_MANAGER)
 
+        # DomainInfo is not a top-level folder, it defines domainInfo top-level attributes
+        self.__all_model_categories.append(DOMAIN_INFO_ALIAS)
         return
 
     def get_dictionary_for_location(self, location, resolve=True):
@@ -249,8 +244,12 @@ def get_model_app_deployments_subfolder_names(self):
         """
         return list(self.__app_deployments_top_level_folders)
 
-    def get_domain_info_attribute_names_and_types(self):
-        return dict(self.__domain_info_attributes_and_types)
+    def get_model_domain_info_subfolder_names(self):
+        """
+        Get the top-level model folder names underneath the domain info section.
+        :return: a list of the folder names
+        """
+        return list(self.__domain_info_top_level_folders)
 
     def get_model_subfolder_names_for_location(self, location):
         """

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

@@ -125,6 +125,14 @@ def get_model_app_deployments_top_level_folder_names(self):
         """
         return self._alias_entries.get_model_app_deployments_subfolder_names()
 
+    def get_model_domain_info_top_level_folder_names(self):
+        """
+        Returns a list of the recognized top-level model folders in the domainInfo section corresponding to the
+        known WLST top-level folders.
+        :return: a list of the recognized top-level model folder names
+        """
+        return self._alias_entries.get_model_domain_info_subfolder_names()
+
     def get_model_subfolder_names(self, location):
         """
         Get the list of model folder names for subfolders of the specified location.
@@ -1037,13 +1045,6 @@ def get_model_attribute_names_and_types(self, location):
         self._logger.exiting(class_name=self._class_name, method_name=_method_name, result=result)
         return result
 
-    def get_model_domain_info_attribute_names_and_types(self):
-        """
-        Get the attribute names and types for the domainInfo section of the model
-        :return: a dictionary keyed on model attribute names with the type as the value
-        """
-        return self._alias_entries.get_domain_info_attribute_names_and_types()
-
     def attribute_values_are_equal(self, location, model_attribute_name, model_attribute_value, wlst_attribute_value):
         """
         Returns whether or not the model and WLST values for a given model attribute,

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

@@ -94,6 +94,7 @@
 DOMAIN = 'Domain'
 DOMAIN_NAME = 'Name'
 DOMAIN_INFO = 'domainInfo'
+DOMAIN_INFO_ALIAS = 'DomainInfo'
 DOMAIN_LIBRARIES = 'domainLibraries'
 DOMAIN_SCRIPTS = 'domainBin'
 DYNAMIC_SERVERS = 'DynamicServers'

core/src/main/python/wlsdeploy/tool/encrypt/encryption_utils.py

@@ -7,11 +7,7 @@
 
 from wlsdeploy.aliases.location_context import LocationContext
 from wlsdeploy.aliases.model_constants import DOMAIN_INFO
-from wlsdeploy.aliases.model_constants import DRIVER_PARAMS_KEYSTOREPWD_PROPERTY
-from wlsdeploy.aliases.model_constants import DRIVER_PARAMS_TRUSTSTOREPWD_PROPERTY
-from wlsdeploy.aliases.model_constants import RCU_ADMIN_PASSWORD
-from wlsdeploy.aliases.model_constants import RCU_DB_INFO
-from wlsdeploy.aliases.model_constants import RCU_SCHEMA_PASSWORD
+from wlsdeploy.aliases.model_constants import DOMAIN_INFO_ALIAS
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.logging.platform_logger import PlatformLogger
 from wlsdeploy.util import model
@@ -27,15 +23,6 @@ class _ModelEncrypter(object):
     _class_name = '_ModelEncrypter'
     _logger = PlatformLogger('wlsdeploy.encrypt')
 
-    # these elements in the domainInfo/RCUDbInfo section are passwords,
-    # and may need to be encrypted.
-    _rcu_password_attributes = [
-        RCU_ADMIN_PASSWORD,
-        RCU_SCHEMA_PASSWORD,
-        DRIVER_PARAMS_KEYSTOREPWD_PROPERTY,
-        DRIVER_PARAMS_TRUSTSTOREPWD_PROPERTY
-    ]
-
     def __init__(self, passphrase, alias_helper, variables=None):
         """
         Initialize variables for use throughout.
@@ -59,9 +46,8 @@ def encrypt_model_dictionary(self, model_dict):
         """
 
         if model.get_model_domain_info_key() in model_dict:
-            info_name_map = self.alias_helper.get_model_domain_info_attribute_names_and_types()
             domain_info_dict = model_dict[model.get_model_domain_info_key()]
-            self._encrypt_info_nodes(domain_info_dict, info_name_map)
+            self._encrypt_info_nodes(domain_info_dict)
 
         if model.get_model_topology_key() in model_dict:
             top_folder_names = self.alias_helper.get_model_topology_top_level_folder_names()
@@ -83,24 +69,24 @@ def encrypt_model_dictionary(self, model_dict):
 
         return self.model_changes, len(self.variables_changed)
 
-    def _encrypt_info_nodes(self, info_nodes, info_name_map):
+    def _encrypt_info_nodes(self, info_nodes):
         """
         Encrypt a set of nodes from the domainInfo section of the model.
         :param info_nodes: the model nodes
-        :param info_name_map: a map of model key names to type
         """
-        for key in info_nodes:
-            if key in info_name_map:
-                attribute_type = info_name_map[key]
-                if attribute_type == 'password':
-                    self._encrypt_attribute(DOMAIN_INFO, info_nodes, key)
-
-        if RCU_DB_INFO in info_nodes:
-            rcu_nodes = info_nodes[RCU_DB_INFO]
-            folder_name = DOMAIN_INFO + '/' + RCU_DB_INFO
-            for key in rcu_nodes:
-                if key in self._rcu_password_attributes:
-                    self._encrypt_attribute(folder_name, rcu_nodes, key)
+        info_location = LocationContext().append_location(DOMAIN_INFO_ALIAS)
+        password_attribute_names = self.alias_helper.get_model_password_type_attribute_names(info_location)
+
+        subfolder_names = self.alias_helper.get_model_domain_info_top_level_folder_names()
+
+        for node in info_nodes:
+            if node in subfolder_names:
+                child_location = LocationContext().append_location(node)
+                child_nodes = info_nodes[node]
+                self._encrypt_nodes(child_location, child_nodes)
+
+            elif node in password_attribute_names:
+                self._encrypt_attribute(DOMAIN_INFO, info_nodes, node)
 
     def _encrypt_nodes(self, location, model_nodes, subfolder_names=None):
         """

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

@@ -612,6 +612,13 @@ def get_model_app_deployments_top_level_folder_names(self):
         """
         return self.__aliases.get_model_app_deployments_top_level_folder_names()
 
+    def get_model_domain_info_top_level_folder_names(self):
+        """
+        Get the model domain info top-level folder names.
+        :return: the list of top-level domain info folders
+        """
+        return self.__aliases.get_model_domain_info_top_level_folder_names()
+
     def get_model_attribute_names(self, location):
         """
         Get the model attribute names.
@@ -738,13 +745,6 @@ def get_model_merge_required_attribute_names(self, location):
             raise ex
         return result
 
-    def get_model_domain_info_attribute_names_and_types(self):
-        """
-        Get the attribute names and types for the domainInfo section of the model.
-        :return: a dictionary keyed on model attribute names with the type as the value
-        """
-        return self.__aliases.get_model_domain_info_attribute_names_and_types()
-
     def get_model_attribute_default_value(self, location, model_attribute_name):
         """
         Get the default value for the specified attribute.

core/src/main/python/wlsdeploy/tool/validate/usage_printer.py

@@ -77,38 +77,16 @@ def print_model_path_usage(self, model_path, control_option):
         if model_path_tokens[0] == model_constants.APP_DEPLOYMENTS:
             valid_section_folder_keys = self._aliases.get_model_app_deployments_top_level_folder_names()
 
+        if model_path_tokens[0] == model_constants.DOMAIN_INFO:
+            valid_section_folder_keys = self._aliases.get_model_domain_info_top_level_folder_names()
+
         if len(model_path_tokens) == 1:
-            if model_path_tokens[0] == model_constants.DOMAIN_INFO:
-                self.__print_domain_info_usage(model_path_tokens)
-            else:
-                self.__print_top_level_usage(top_level_key, valid_section_folder_keys, control_option)
+            self.__print_top_level_usage(top_level_key, valid_section_folder_keys, control_option)
         else:
             self.__print_model_section_usage(model_path_tokens, valid_section_folder_keys, control_option)
 
         return
 
-    def __print_domain_info_usage(self, model_path_tokens):
-        """
-        Prints out the usage for the domainInfo section of a model
-        :param model_path_tokens: A Python list of path elements built from model path
-        :return:
-        """
-
-        _method_name = '__print_domain_info_usage'
-        self._logger.finest('1 model_path_tokens={0}', str(model_path_tokens),
-                            class_name=_class_name, method_name=_method_name)
-
-        model_path = validation_utils.format_message('WLSDPLY-05103', '%s:' % model_path_tokens[0])
-
-        # Print 'Path: <model_section>' label and field
-        validation_utils.print_indent(model_path, 0)
-        validation_utils.print_blank_lines()
-
-        attr_infos = self._alias_helper.get_model_domain_info_attribute_names_and_types()
-        _print_attr_infos(attr_infos, 1)
-
-        return
-
     def __print_top_level_usage(self, top_level_key, valid_section_folder_keys, control_option):
         """
         Prints out the usage for a section of a model, when just the section_name[:[/}} is provided
@@ -132,15 +110,20 @@ def __print_top_level_usage(self, top_level_key, valid_section_folder_keys, cont
 
         # Print 'Section: <model_section>' label and field
         validation_utils.print_indent(model_section, 0)
-
-        if control_option == self.ControlOptions.ATTRIBUTES_ONLY:
-            # Doing an ATTRIBUTES_ONLY on a top level key is a no-op
-            return
+        validation_utils.print_blank_lines()
 
         validation_location = LocationContext()
 
+        # topology level has attributes, use empty location
+        if top_level_key == model_constants.TOPOLOGY:
+            self.__print_attributes_usage(validation_location, 1)
+
+        # domainInfo level has attributes, use special location
+        if top_level_key == model_constants.DOMAIN_INFO:
+            info_location = LocationContext().append_location("DomainInfo")
+            self.__print_attributes_usage(info_location, 1)
+
         if control_option == self.ControlOptions.FOLDERS_ONLY:
-            validation_utils.print_blank_lines()
             validation_utils.print_indent(validation_utils.format_message('WLSDPLY-05105'), 1)
             valid_section_folder_keys.sort()