Merge pull request #156 from oracle/alias-integration

System test for aliases

Author: ddsharpe

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

@@ -19,6 +19,7 @@
 MERGE = 'merge'
 MODEL_NAME = 'model_name'
 NAME_VALUE = 'name_value'
+PASSWORD_TOKEN = "--FIX ME--"
 PREFERRED_MODEL_TYPE = 'preferred_model_type'
 RESTART_REQUIRED = 'restart_required'
 SET_MBEAN_TYPE = 'set_mbean_type'
@@ -73,13 +74,22 @@
 JAVA_LANG_BOOLEAN = 'java.lang.Boolean'
 LIST = 'list'
 LONG = 'long'
+OBJECT = 'object'
 PASSWORD = 'password'
 PATH_SEPARATOR_DELIMITED_STRING = 'delimited_string[path_separator]'
 PROPERTIES = 'properties'
 SEMI_COLON_DELIMITED_STRING = 'delimited_string[semicolon]'
 SPACE_DELIMITED_STRING = 'delimited_string[space]'
 STRING = 'string'
 
+ALIAS_DELIMITED_TYPES = [
+    COMMA_DELIMITED_STRING,
+    DELIMITED_STRING,
+    PATH_SEPARATOR_DELIMITED_STRING,
+    SEMI_COLON_DELIMITED_STRING,
+    SPACE_DELIMITED_STRING
+]
+
 ALIAS_LIST_TYPES = [
     COMMA_DELIMITED_STRING,
     DELIMITED_STRING,

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

@@ -52,7 +52,6 @@
 from wlsdeploy.aliases.alias_constants import WLST_SUBFOLDERS_PATH
 from wlsdeploy.aliases.alias_constants import WLST_TYPE
 
-IGNORE_FOR_MODEL_LIST = ['DynamicallyCreated', 'Id', 'Tag', 'Tags', 'Type', 'Name']
 _class_name = 'AliasEntries'
 _logger = PlatformLogger('wlsdeploy.aliases')
 
@@ -66,6 +65,8 @@ class AliasEntries(object):
     This class is intended only for use by aliases.py.  Other uses of this class violate
     encapsulation and should be avoided.
     """
+    IGNORE_FOR_MODEL_LIST = ['DynamicallyCreated', 'Id', 'Tag', 'Tags', 'Type', 'Name', 'Parent']
+
     __category_modules_dir_name = 'oracle/weblogic/deploy/aliases/category_modules/'
     __domain_category = 'Domain'
 
@@ -744,7 +745,7 @@ def get_alias_attribute_entry_by_wlst_name(self, location, wlst_attribute_name):
                 else:
                     _logger.warning('WLSDPLY-08110', wlst_attribute_name, location.get_folder_path(), WLST_PATH)
             else:
-                if wlst_attribute_name not in IGNORE_FOR_MODEL_LIST:
+                if wlst_attribute_name not in self.IGNORE_FOR_MODEL_LIST:
                     ex = exception_helper.create_alias_exception('WLSDPLY-08111', location.get_folder_path(),
                                                                  wlst_attribute_name)
                     _logger.throwing(ex, class_name=_class_name, method_name=_method_name)

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

@@ -36,6 +36,8 @@
 from wlsdeploy.aliases.alias_constants import MBEAN
 from wlsdeploy.aliases.alias_constants import MERGE
 from wlsdeploy.aliases.alias_constants import MODEL_NAME
+from wlsdeploy.aliases.alias_constants import PASSWORD
+from wlsdeploy.aliases.alias_constants import PASSWORD_TOKEN
 from wlsdeploy.aliases.alias_constants import PREFERRED_MODEL_TYPE
 from wlsdeploy.aliases.alias_constants import PROPERTIES
 from wlsdeploy.aliases.alias_constants import RESTART_REQUIRED
@@ -77,6 +79,20 @@ def __init__(self, model_context, wlst_mode=WlstModes.OFFLINE, wls_version=None,
     #              Model folder navigation-related methods                    #
     ###########################################################################
 
+    def get_mode_string(self):
+        """
+        Return WlstModes ONLINE or OFFLINE in string representation for this Aliases.
+        :return: 'ONLINE' or 'OFFLINE'
+        """
+        return WlstModes.from_value(self._wlst_mode)
+
+    def get_mode_enum(self):
+        """
+        Return the WlstModes enum value for this Aliases.
+        :return: WlstModes.ONLINE or WlstModes.OFFLINE
+        """
+        return self._wlst_mode
+
     def get_model_top_level_folder_names(self):
         """
         Returns a list of the recognized top-level model folders corresponding to the known WLST top-level folders.
@@ -349,7 +365,7 @@ def get_wlst_attribute_name_and_value(self, location, model_attribute_name, mode
             else:
                 wlst_attribute_name = attribute_info[WLST_NAME]
 
-            if 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]
@@ -387,7 +403,6 @@ def get_wlst_attribute_name_and_value(self, location, model_attribute_name, mode
                     else:
                         merged_value = model_attribute_value
 
-
                     if data_type == JARRAY:
                         subtype = 'java.lang.String'
                         if SET_MBEAN_TYPE in attribute_info:
@@ -774,6 +789,28 @@ def get_model_merge_required_attribute_names(self, location):
 
         return model_attribute_names
 
+    def get_model_password_attribute_names(self, location):
+        """
+        Get the list of attribute names for the current location that are marked as password.
+        :param location: current location context
+        :return: list of password attributes
+        """
+        _method_name = 'get_model_password_attribute_names'
+
+        model_attribute_names = list()
+        module_folder = self._alias_entries.get_dictionary_for_location(location, resolve=False)
+
+        if ATTRIBUTES not in module_folder:
+            ex = exception_helper.create_alias_exception('WLSDPLY-08400', location.get_folder_path())
+            self._logger.throwing(ex, class_name=self._class_name, method_name=_method_name)
+            raise ex
+
+        for key, value in module_folder[ATTRIBUTES].iteritems():
+            if WLST_TYPE in value and value[WLST_TYPE] == PASSWORD:
+                model_attribute_names.append(key)
+
+        return model_attribute_names
+
     def get_model_uses_path_tokens_attribute_names(self, location):
         """
         Get the list of attribute names that "use path tokens" (i.e., ones whose values are file system paths).
@@ -821,7 +858,7 @@ def get_model_attribute_name_and_value(self, location, wlst_attribute_name, wlst
         if attribute_info is not None and not self.__is_model_attribute_read_only(location, attribute_info):
             data_type, preferred_type, delimiter = \
                 alias_utils.compute_read_data_type_for_wlst_and_delimiter_from_attribute_info(attribute_info,
-                                                                                     wlst_attribute_value)
+                                                                                              wlst_attribute_value)
 
             converted_value = alias_utils.convert_from_type(data_type, wlst_attribute_value, delimiter=delimiter,
                                                             preferred=preferred_type)
@@ -843,7 +880,7 @@ def get_model_attribute_name_and_value(self, location, wlst_attribute_name, wlst
                 if string_utils.is_empty(wlst_attribute_value) or converted_value == default_value:
                     model_attribute_value = None
                 else:
-                    model_attribute_value = "--FIX ME--"
+                    model_attribute_value = PASSWORD_TOKEN
             elif data_type == 'boolean':
                 wlst_val = alias_utils.convert_boolean(converted_value)
                 default_val = alias_utils.convert_boolean(default_value)
@@ -860,21 +897,20 @@ def get_model_attribute_name_and_value(self, location, wlst_attribute_name, wlst
                     model_attribute_value = None
                 else:
                     model_attribute_value = converted_value
-                    if USES_PATH_TOKENS in attribute_info:
+                    if self._model_context and USES_PATH_TOKENS in attribute_info:
                         model_attribute_value = self._model_context.tokenize_path(model_attribute_value)
         self._logger.exiting(class_name=self._class_name, method_name=_method_name,
                              result={model_attribute_name: model_attribute_value})
         return model_attribute_name, model_attribute_value
 
     def get_model_attribute_name(self, location, wlst_attribute_name):
         """
-        Returns the model attribute name for the specified WLST attribute name and value.
+        Returns the model attribute name for the specified WLST attribute name and value. If the model attribute name
+        is not valid for the version or the attribute is marked as read-only, return None
 
-        model_attribute_value will be set to None, if value assigned to wlst_attribute_value arg
-        is the default value for model_attribute_name.
         :param location: the location
         :param wlst_attribute_name: the WLST attribute name
-        :return: the name and value
+        :return: matching model attribute name
         :raises: AliasException: if an error occurs
         """
         _method_name = 'get_model_attribute_name'
@@ -884,7 +920,7 @@ def get_model_attribute_name(self, location, wlst_attribute_name):
         model_attribute_name = None
 
         attribute_info = self._alias_entries.get_alias_attribute_entry_by_wlst_name(location, wlst_attribute_name)
-        if attribute_info is not None:
+        if attribute_info is not None and not self.__is_model_attribute_read_only(location, attribute_info):
             model_attribute_name = attribute_info[MODEL_NAME]
 
         self._logger.exiting(class_name=self._class_name, method_name=_method_name,
@@ -964,8 +1000,8 @@ def attribute_values_are_equal(self, location, model_attribute_name, model_attri
             if key == model_attribute_name:
                 attribute_info = module_folder[ATTRIBUTES][key]
                 if attribute_info and VALUE in attribute_info and DEFAULT in attribute_info[VALUE]:
-                    result = (model_attribute_value == wlst_attribute_value
-                              and model_attribute_value == attribute_info[VALUE][DEFAULT])
+                    result = (model_attribute_value == wlst_attribute_value and
+                              model_attribute_value == attribute_info[VALUE][DEFAULT])
 
         return result
 
@@ -1037,6 +1073,27 @@ def get_model_attribute_default_value(self, location, model_attribute_name):
         self._logger.exiting(class_name=self._class_name, method_name=_method_name, result=default_value)
         return default_value
 
+    def get_model_attribute_type(self, location, model_attribute_name):
+        """
+        Get the wlst_type for the model attribute name at the specified location
+        :param location:
+        :param model_attribute_name:
+        :return:
+        """
+        wlst_type = None
+        attribute_info = self._alias_entries.get_alias_attribute_entry_by_model_name(location, model_attribute_name)
+        if attribute_info is not None:
+            wlst_type = attribute_info[WLST_TYPE]
+        return wlst_type
+
+    def get_ignore_attribute_names(self):
+        """
+        Return the list of attribute names that are ignored by the aliases and not defined in the alias category
+        json files.
+        :return: list of ignored attribute
+        """
+        return self._alias_entries.IGNORE_FOR_MODEL_LIST
+
     ####################################################################################
     #
     # Private methods, private inner classes and static methods only, beyond here please
@@ -1051,7 +1108,7 @@ def __decrypt_password(self, text):
         :raises EncryptionException: if an error occurs while decrypting the password
         """
         if text is None or len(str(text)) == 0 or \
-                not self._model_context.is_using_encryption() or\
+                (self._model_context and not self._model_context.is_using_encryption()) or\
                 not EncryptionUtils.isEncryptedString(text):
 
             rtnval = text

core/src/main/python/wlsdeploy/tool/discover/discoverer.py

@@ -86,6 +86,7 @@ def _populate_model_parameters(self, dictionary, location):
                                         pe.getLocalizedMessage(), class_name=_class_name, method_name=_method_name)
                         continue
                 else:
+                    _logger.finer('WLSDPLY-06131', wlst_param, class_name=_class_name, method_name=_method_name)
                     wlst_value = wlst_params[wlst_param]
 
                 # if type(wlst_value) == str and len(wlst_value) == 0:

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

@@ -514,18 +514,18 @@ def tokenize_path(self, path):
         cwd = path_utils.fixup_path(os.path.dirname(os.path.abspath(__file__)))
 
         # decide later what is required to be in context home for appropriate exception prevention
-        if self.get_wl_home() and my_path.startswith(self.get_wl_home()):
-            result = my_path.replace(self.get_wl_home(), self.__WL_HOME_TOKEN)
-        elif self.get_domain_home() and  my_path.startswith(self.get_domain_home()):
-            result = my_path.replace(self.get_domain_home(), self.__DOMAIN_HOME_TOKEN)
-        elif self.get_oracle_home() and my_path.startswith(self.get_oracle_home()):
-            result = my_path.replace(self.get_oracle_home(), self.__ORACLE_HOME_TOKEN)
-        elif my_path.startswith(cwd):
-            result = my_path.replace(cwd, self.__CURRENT_DIRECTORY_TOKEN)
-        elif my_path.startswith(tmp_dir):
-            result = my_path.replace(tmp_dir, self.__TEMP_DIRECTORY_TOKEN)
-        else:
-            result = my_path
+        result = my_path
+        if my_path:
+            if self.get_wl_home() and my_path.startswith(self.get_wl_home()):
+                result = my_path.replace(self.get_wl_home(), self.__WL_HOME_TOKEN)
+            elif self.get_domain_home() and  my_path.startswith(self.get_domain_home()):
+                result = my_path.replace(self.get_domain_home(), self.__DOMAIN_HOME_TOKEN)
+            elif self.get_oracle_home() and my_path.startswith(self.get_oracle_home()):
+                result = my_path.replace(self.get_oracle_home(), self.__ORACLE_HOME_TOKEN)
+            elif my_path.startswith(cwd):
+                result = my_path.replace(cwd, self.__CURRENT_DIRECTORY_TOKEN)
+            elif my_path.startswith(tmp_dir):
+                result = my_path.replace(tmp_dir, self.__TEMP_DIRECTORY_TOKEN)
 
         return result
 

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

@@ -239,19 +239,20 @@ def lsa(path=None, log_throwing=True):
     """
     _method_name = 'lsa'
     result = _ls(_method_name, 'a', path, log_throwing)
-    if wlst.WLS_ON.isConnected() and result and len(result) > 1:
-        make_dict = dict()
+    make_dict = dict()
+    if result and len(result) > 1:
         for entry in result.entrySet():
             key = entry.getKey()
             value = entry.getValue()
-            if value is not None and type(value) is str:
+            if value and type(value) is str:
                 new_value = value.rstrip()
                 if new_value == 'null' or new_value == 'none':
                     make_dict[key] = None
                 else:
                     make_dict[key] = new_value
-        result = make_dict
-    return result
+            else:
+                make_dict[key] = value
+    return make_dict
 
 
 def lsc(path=None, log_throwing=True):

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

@@ -456,6 +456,7 @@ WLSDPLY-06126=Locate model name for MBean interface {0} for {1}
 WLSDPLY-06127=Unable to discover the wlst attribute {0} value at location {1} : {2}
 WLSDPLY-06130=Unexpected exception attempting to discover MBean entries at {0} will prevent the discovery \
   of attributes at this location : {1}
+WLSDPLY-06131=Attribute {0} retrieved from lsa() map
 WLSDPLY-06140=Unable to cd to the expected path {0} constructed from location context {1}; the current folder \
   and its sub-folders cannot be discovered : {2}
 
@@ -944,7 +945,7 @@ WLSDPLY-12229=Changing the administration server name from {0} to {1}
 WLSDPLY-12230=Creating placeholder for Coherence cluster {0}
 
 # domain_typedef.py
-WLSDPLY-12300=={0} got the domain type {1} but the domain type definition file {2} was not valid: {3}
+WLSDPLY-12300={0} got the domain type {1} but the domain type definition file {2} was not valid: {3}
 WLSDPLY-12301={0} failed to load the definition for domain type {1} from {2} due to a parsing error: {3}
 WLSDPLY-12302=Domain typedef class not properly initialized with the model context
 WLSDPLY-12303=Domain type {0} type definition in file {1} contains type definition {2} that does not \