Combine alias helper into aliases class (#687)

* Jira WDT-312 - Merge AliasHelper into Aliases; remove unused methods, rename variables throughout

Author: rakillen

core/src/main/python/compare_model.py

@@ -32,7 +32,6 @@
 from wlsdeploy.exception import exception_helper
 
 from wlsdeploy.logging.platform_logger import PlatformLogger
-from wlsdeploy.tool.util.alias_helper import AliasHelper
 from wlsdeploy.util import cla_helper
 from wlsdeploy.util import variables
 from wlsdeploy.util.model_translator import FileToPython
@@ -252,10 +251,9 @@ def _is_alias_folder(self, path):
         debug("DEBUG: Entering is_alias_folder %s", path)
         path_tokens = path.split(PATH_TOKEN)
         model_context = ModelContext("test", { })
-        aliases = Aliases(model_context=model_context, wlst_mode=WlstModes.OFFLINE)
         location = LocationContext()
         last_token = path_tokens[-1]
-        alias_helper = AliasHelper(aliases, _logger, ExceptionType.COMPARE)
+        aliases = Aliases(model_context, wlst_mode=WlstModes.OFFLINE, exception_type=ExceptionType.COMPARE)
 
         found = True
         name_token_next = False
@@ -268,8 +266,8 @@ def _is_alias_folder(self, path):
                 location.append_location(path_token)
                 if last_token == path_token:
                     break
-                name_token_next = alias_helper.supports_multiple_mbean_instances(location)
-            attrib_names = alias_helper.get_model_attribute_names(location)
+                name_token_next = aliases.supports_multiple_mbean_instances(location)
+            attrib_names = aliases.get_model_attribute_names(location)
             if last_token in attrib_names:
                 found = False
 

core/src/main/python/create.py

@@ -33,7 +33,6 @@
 from wlsdeploy.tool.create.domain_creator import DomainCreator
 from wlsdeploy.tool.create.domain_typedef import CREATE_DOMAIN
 from wlsdeploy.tool.util import model_context_helper
-from wlsdeploy.tool.util.alias_helper import AliasHelper
 from wlsdeploy.tool.util.archive_helper import ArchiveHelper
 from wlsdeploy.tool.util.wlst_helper import WlstHelper
 from wlsdeploy.tool.util import wlst_helper
@@ -230,14 +229,14 @@ def __process_opss_args(optional_arg_map):
     return
 
 
-def validate_rcu_args_and_model(model_context, model, archive_helper, alias_helper):
+def validate_rcu_args_and_model(model_context, model, archive_helper, aliases):
     _method_name = 'validate_rcu_args_and_model'
 
     has_atpdbinfo = 0
     domain_info = model[model_constants.DOMAIN_INFO]
     if domain_info is not None:
         if model_constants.RCU_DB_INFO in domain_info:
-            rcu_db_info = RcuDbInfo(model_context, alias_helper, domain_info[model_constants.RCU_DB_INFO])
+            rcu_db_info = RcuDbInfo(model_context, aliases, domain_info[model_constants.RCU_DB_INFO])
             has_tns_admin = rcu_db_info.has_tns_admin()
             has_regular_db = rcu_db_info.is_regular_db()
             has_atpdbinfo = rcu_db_info.has_atpdbinfo()
@@ -316,7 +315,7 @@ def main(args):
         model_context = model_context_helper.create_exit_context(_program_name)
         tool_exit.end(model_context, exit_code)
 
-    aliases = Aliases(model_context, wlst_mode=__wlst_mode)
+    aliases = Aliases(model_context, wlst_mode=__wlst_mode, exception_type=ExceptionType.CREATE)
 
     model_dictionary = cla_helper.load_model(_program_name, model_context, aliases, "create", __wlst_mode)
 
@@ -327,8 +326,7 @@ def main(args):
             domain_path = _get_domain_path(model_context, model_dictionary)
             archive_helper = ArchiveHelper(archive_file_name, domain_path, __logger, ExceptionType.CREATE)
 
-        alias_helper = AliasHelper(aliases, __logger, ExceptionType.CREATE)
-        has_atp = validate_rcu_args_and_model(model_context, model_dictionary, archive_helper, alias_helper)
+        has_atp = validate_rcu_args_and_model(model_context, model_dictionary, archive_helper, aliases)
 
         # check if there is an atpwallet and extract in the domain dir
         # it is to support non JRF domain but user wants to use ATP database
@@ -340,7 +338,7 @@ def main(args):
 
         if has_atp:
             rcu_properties_map = model_dictionary[model_constants.DOMAIN_INFO][model_constants.RCU_DB_INFO]
-            rcu_db_info = RcuDbInfo(model_context, alias_helper, rcu_properties_map)
+            rcu_db_info = RcuDbInfo(model_context, aliases, rcu_properties_map)
             atp_helper.fix_jps_config(rcu_db_info, model_context)
 
     except WLSDeployArchiveIOException, ex:

core/src/main/python/deploy.py

@@ -269,7 +269,7 @@ def main(args):
         model_context = model_context_helper.create_exit_context(_program_name)
         tool_exit.end(model_context, exit_code)
 
-    aliases = Aliases(model_context, wlst_mode=__wlst_mode)
+    aliases = Aliases(model_context, wlst_mode=__wlst_mode, exception_type=ExceptionType.DEPLOY)
 
     model_dictionary = cla_helper.load_model(_program_name, model_context, aliases, "deploy", __wlst_mode)
 

core/src/main/python/discover.py

@@ -488,7 +488,7 @@ def main(args):
                         ex.getLocalizedMessage(), error=ex, class_name=_class_name, method_name=_method_name)
         __log_and_exit(model_context, CommandLineArgUtil.PROG_ERROR_EXIT_CODE, _class_name, _method_name)
 
-    aliases = Aliases(model_context, wlst_mode=__wlst_mode)
+    aliases = Aliases(model_context, wlst_mode=__wlst_mode, exception_type=ExceptionType.DISCOVER)
     model = None
     discover_injector = None
     if model_context.get_variable_file() is not None:

core/src/main/python/encrypt.py

@@ -4,16 +4,13 @@
 
 The main module for the WLSDeploy tool to encrypt passwords.
 """
-import os
 import sys
 
 from java.io import IOException
-from java.lang import IllegalArgumentException
 from java.lang import String, System
 
 from oracle.weblogic.deploy.encrypt import EncryptionException
 from oracle.weblogic.deploy.util import CLAException
-from oracle.weblogic.deploy.util import FileUtils
 from oracle.weblogic.deploy.util import TranslateException
 from oracle.weblogic.deploy.util import VariableException
 from oracle.weblogic.deploy.util import WebLogicDeployToolingVersion
@@ -27,7 +24,6 @@
 from wlsdeploy.exception.expection_types import ExceptionType
 from wlsdeploy.logging.platform_logger import PlatformLogger
 from wlsdeploy.tool.encrypt import encryption_utils
-from wlsdeploy.tool.util.alias_helper import AliasHelper
 from wlsdeploy.util import cla_utils
 from wlsdeploy.util import getcreds
 from wlsdeploy.util import variables as variable_helper
@@ -165,14 +161,13 @@ def __encrypt_model_and_variables(model_context):
                             class_name=_class_name, method_name=_method_name)
             return CommandLineArgUtil.PROG_ERROR_EXIT_CODE
 
-    aliases = Aliases(model_context, wlst_mode=WlstModes.OFFLINE)
-    alias_helper = AliasHelper(aliases, __logger, ExceptionType.ENCRYPTION)
+    aliases = Aliases(model_context, wlst_mode=WlstModes.OFFLINE, exception_type=ExceptionType.ENCRYPTION)
 
     for model_file, model in models.iteritems():
         try:
             passphrase = model_context.get_encryption_passphrase()
             model_change_count, variable_change_count = \
-                encryption_utils.encrypt_model_dictionary(passphrase, model, alias_helper, variables)
+                encryption_utils.encrypt_model_dictionary(passphrase, model, aliases, variables)
         except EncryptionException, ee:
             __logger.severe('WLSDPLY-04208', _program_name, ee.getLocalizedMessage(), error=ee,
                             class_name=_class_name, method_name=_method_name)

core/src/main/python/prepare_model.py

@@ -40,7 +40,6 @@
 from wlsdeploy.tool.util import filter_helper
 from wlsdeploy.tool.util import model_context_helper
 from wlsdeploy.tool.util import variable_injector_functions
-from wlsdeploy.tool.util.alias_helper import AliasHelper
 from wlsdeploy.tool.util.variable_injector import VariableInjector
 from wlsdeploy.tool.validate import validation_utils
 from wlsdeploy.tool.validate.validator import Validator
@@ -108,8 +107,8 @@ def __init__(self, model_files, model_context, logger, output_dir=None):
         self.model_files = model_files
         self.output_dir = output_dir
         self.model_context = model_context
-        self._aliases = Aliases(model_context=model_context, wlst_mode=WlstModes.OFFLINE)
-        self._alias_helper = AliasHelper(self._aliases, logger, ExceptionType.COMPARE)
+        self._aliases = Aliases(model_context=model_context, wlst_mode=WlstModes.OFFLINE,
+                                exception_type=ExceptionType.COMPARE)
         self._logger = logger
         self._name_tokens_location = LocationContext()
         self._name_tokens_location.add_name_token('DOMAIN', "testdomain")
@@ -124,14 +123,14 @@ def __walk_model_section(self, model_section_key, model_dict, valid_section_fold
             return
 
         # only specific top-level sections have attributes
-        attribute_location = self._alias_helper.get_model_section_attribute_location(model_section_key)
+        attribute_location = self._aliases.get_model_section_attribute_location(model_section_key)
 
         valid_attr_infos = []
         path_tokens_attr_keys = []
 
         if attribute_location is not None:
-            valid_attr_infos = self._alias_helper.get_model_attribute_names_and_types(attribute_location)
-            path_tokens_attr_keys = self._alias_helper.get_model_uses_path_tokens_attribute_names(attribute_location)
+            valid_attr_infos = self._aliases.get_model_attribute_names_and_types(attribute_location)
+            path_tokens_attr_keys = self._aliases.get_model_uses_path_tokens_attribute_names(attribute_location)
 
         model_section_dict = model_dict[model_section_key]
         for section_dict_key, section_dict_value in model_section_dict.iteritems():
@@ -158,16 +157,16 @@ def __walk_model_section(self, model_section_key, model_dict, valid_section_fold
     def __walk_section_folder(self, model_node, validation_location):
         _method_name = '__validate_section_folder'
 
-        model_folder_path = self._alias_helper.get_model_folder_path(validation_location)
+        model_folder_path = self._aliases.get_model_folder_path(validation_location)
 
-        if self._alias_helper.supports_multiple_mbean_instances(validation_location):
+        if self._aliases.supports_multiple_mbean_instances(validation_location):
 
             for name in model_node:
                 expanded_name = name
 
                 new_location = LocationContext(validation_location)
 
-                name_token = self._alias_helper.get_name_token(new_location)
+                name_token = self._aliases.get_name_token(new_location)
 
                 if name_token is not None:
                     new_location.add_name_token(name_token, expanded_name)
@@ -176,14 +175,14 @@ def __walk_section_folder(self, model_node, validation_location):
 
                 self.__walk_model_node(value_dict, new_location)
 
-        elif self._alias_helper.requires_artificial_type_subfolder_handling(validation_location):
+        elif self._aliases.requires_artificial_type_subfolder_handling(validation_location):
 
             for name in model_node:
                 expanded_name = name
 
                 new_location = LocationContext(validation_location)
 
-                name_token = self._alias_helper.get_name_token(new_location)
+                name_token = self._aliases.get_name_token(new_location)
 
                 if name_token is not None:
                     new_location.add_name_token(name_token, expanded_name)
@@ -193,7 +192,7 @@ def __walk_section_folder(self, model_node, validation_location):
                 self.__walk_model_node(value_dict, new_location)
 
         else:
-            name_token = self._alias_helper.get_name_token(validation_location)
+            name_token = self._aliases.get_name_token(validation_location)
 
             if name_token is not None:
                 name = self._name_tokens_location.get_name_for_token(name_token)
@@ -208,18 +207,18 @@ def __walk_section_folder(self, model_node, validation_location):
     def __walk_model_node(self, model_node, validation_location):
         _method_name = '__process_model_node'
 
-        valid_folder_keys = self._alias_helper.get_model_subfolder_names(validation_location)
-        valid_attr_infos = self._alias_helper.get_model_attribute_names_and_types(validation_location)
-        model_folder_path = self._alias_helper.get_model_folder_path(validation_location)
+        valid_folder_keys = self._aliases.get_model_subfolder_names(validation_location)
+        valid_attr_infos = self._aliases.get_model_attribute_names_and_types(validation_location)
+        model_folder_path = self._aliases.get_model_folder_path(validation_location)
 
         for key, value in model_node.iteritems():
 
             if key in valid_folder_keys:
                 new_location = LocationContext(validation_location).append_location(key)
 
-                if self._alias_helper.is_artificial_type_folder(new_location):
+                if self._aliases.is_artificial_type_folder(new_location):
                     # key is an ARTIFICIAL_TYPE folder
-                    valid_attr_infos = self._alias_helper.get_model_attribute_names_and_types(new_location)
+                    valid_attr_infos = self._aliases.get_model_attribute_names_and_types(new_location)
 
                     self.__walk_attributes(value, valid_attr_infos, new_location)
                 else:
@@ -237,17 +236,17 @@ def __walk_model_node(self, model_node, validation_location):
 
                 else:
                     path_tokens_attr_keys = \
-                        self._alias_helper.get_model_uses_path_tokens_attribute_names(validation_location)
+                        self._aliases.get_model_uses_path_tokens_attribute_names(validation_location)
 
                     self.__walk_attribute(key, value, valid_attr_infos, path_tokens_attr_keys, model_folder_path,
                                           validation_location)
 
     def __walk_attributes(self, attributes_dict, valid_attr_infos, validation_location):
         _method_name = '__validate_attributes'
 
-        path_tokens_attr_keys = self._alias_helper.get_model_uses_path_tokens_attribute_names(validation_location)
+        path_tokens_attr_keys = self._aliases.get_model_uses_path_tokens_attribute_names(validation_location)
 
-        model_folder_path = self._alias_helper.get_model_folder_path(validation_location)
+        model_folder_path = self._aliases.get_model_folder_path(validation_location)
 
         for attribute_name, attribute_value in attributes_dict.iteritems():
             self.__walk_attribute(attribute_name, attribute_value, valid_attr_infos, path_tokens_attr_keys,
@@ -399,14 +398,14 @@ def walk(self):
                 self.cache[key] = ''
 
             # use a merged, substituted, filtered model to get domain name and create additional target output.
-            full_model_dictionary = cla_helper.load_model(_program_name, self.model_context, self._alias_helper,
+            full_model_dictionary = cla_helper.load_model(_program_name, self.model_context, self._aliases,
                                                           "discover", WlstModes.OFFLINE)
 
             target_configuration_helper.generate_k8s_script(self.model_context, self.cache, full_model_dictionary)
 
             # create any additional outputs from full model dictionary
             target_configuration_helper.create_additional_output(Model(full_model_dictionary), self.model_context,
-                                                                 self._alias_helper, ExceptionType.VALIDATE)
+                                                                 self._aliases, ExceptionType.VALIDATE)
 
         except ValidateException, te:
             self._logger.severe('WLSDPLY-20009', _program_name, model_file_name, te.getLocalizedMessage(),

core/src/main/python/update.py

@@ -312,7 +312,7 @@ def main(args):
         model_context = model_context_helper.create_exit_context(_program_name)
         tool_exit.end(model_context, exit_code)
 
-    aliases = Aliases(model_context, wlst_mode=__wlst_mode)
+    aliases = Aliases(model_context, wlst_mode=__wlst_mode, exception_type=ExceptionType.DEPLOY)
 
     model_dictionary = cla_helper.load_model(_program_name, model_context, aliases, "update", __wlst_mode)