Add wlst_mode to the folder level and change NMProperties to offline folder

Author: CarolynRountree

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

@@ -1105,6 +1105,18 @@ def __apply_wlst_context_changes(self, path_name, alias_dict, parent_dict):
                 _logger.throwing(ex, class_name=_class_name, method_name=_method_name)
                 raise ex
 
+        if WLST_MODE in alias_dict:
+            dict_wlst_mode = alias_dict[WLST_MODE]
+            mode =  WlstModes.from_value(self._wlst_mode)
+            if not self.__wlst_mode_matches(dict_wlst_mode):
+                _logger.finer('WLSDPLY-08132', path_name, dict_wlst_mode, mode, class_name=_class_name,
+                              method_name=_method_name)
+                if UNRESOLVED_FOLDERS_MAP not in parent_dict:
+                    parent_dict[UNRESOLVED_FOLDERS_MAP] = dict()
+                alias_dict_folder_name = alias_utils.compute_folder_name_from_path(path_name)
+                parent_dict[UNRESOLVED_FOLDERS_MAP][alias_dict_folder_name] = mode
+                return None
+
         result = dict()
         if FOLDERS in alias_dict:
             result_folders = dict()

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

@@ -343,78 +343,84 @@ def get_wlst_attribute_name_and_value(self, location, model_attribute_name, mode
         wlst_attribute_value = None
 
         module_folder = self._alias_entries.get_dictionary_for_location(location)
-        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
-
-        if model_attribute_name not in module_folder[ATTRIBUTES]:
-            ex = exception_helper.create_alias_exception('WLSDPLY-08401', model_attribute_name,
-                                                         location.get_folder_path())
-            self._logger.throwing(ex, class_name=self._class_name, method_name=_method_name)
-            raise ex
-
-        attribute_info = module_folder[ATTRIBUTES][model_attribute_name]
-
-        if attribute_info and not self.__is_model_attribute_read_only(location, attribute_info):
-            password_attribute_name = \
-                password_utils.get_wlst_attribute_name(attribute_info, model_attribute_value, self._wlst_mode)
+        if not module_folder:
+            self._logger.fine('WLSDPLY-08410', location.get_current_model_folder(), location.get_parent_folder_path(),
+                              WlstModes.from_value(self._wlst_mode), self._wls_version)
+        else:
+            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
 
-            if password_attribute_name is not None:
-                wlst_attribute_name = password_attribute_name
-            else:
-                wlst_attribute_name = attribute_info[WLST_NAME]
+            if model_attribute_name not in module_folder[ATTRIBUTES]:
+                ex = exception_helper.create_alias_exception('WLSDPLY-08401', model_attribute_name,
+                                                             location.get_folder_path())
+                self._logger.throwing(ex, class_name=self._class_name, method_name=_method_name)
+                raise ex
 
-            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)
+            attribute_info = module_folder[ATTRIBUTES][model_attribute_name]
 
-            data_type = attribute_info[WLST_TYPE]
-            if data_type == 'password':
-                try:
-                    wlst_attribute_value = self.__decrypt_password(model_attribute_value)
-                except EncryptionException, ee:
-                    ex = exception_helper.create_alias_exception('WLSDPLY-08402', model_attribute_name,
-                                                                 location.get_folder_path(),
-                                                                 ee.getLocalizedMessage(), error=ee)
-                    self._logger.throwing(ex, class_name=self._class_name, method_name=_method_name)
-                    raise ex
-            else:
-                if data_type in ALIAS_LIST_TYPES or data_type in ALIAS_MAP_TYPES:
-                    merge = True
-                    if MERGE in attribute_info:
-                        merge = alias_utils.convert_boolean(attribute_info[MERGE])
-
-                    if merge and data_type in ALIAS_MAP_TYPES:
-                        model_val = TypeUtils.convertToType(PROPERTIES, model_attribute_value)
-                        existing_val = TypeUtils.convertToType(PROPERTIES, existing_wlst_value)
-                        merged_value = alias_utils.merge_model_and_existing_properties(model_val, existing_val)
-                    elif merge and alias_utils.is_attribute_server_start_arguments(location, model_attribute_name):
-                        merged_value = \
-                            alias_utils.merge_server_start_argument_values(model_attribute_value, existing_wlst_value)
-                    elif merge and existing_wlst_value is not None and len(existing_wlst_value) > 0:
-                        model_val = alias_utils.convert_to_type(LIST, model_attribute_value,
-                                                                delimiter=MODEL_LIST_DELIMITER)
-
-                        _read_type, read_delimiter = \
-                            alias_utils.compute_read_data_type_and_delimiter_from_attribute_info(attribute_info,
-                                                                                                 existing_wlst_value)
-                        existing_val = alias_utils.convert_to_type(LIST, existing_wlst_value, delimiter=read_delimiter)
-                        merged_value = alias_utils.merge_model_and_existing_lists(model_val, existing_val)
-                    else:
-                        merged_value = model_attribute_value
+            if attribute_info and not self.__is_model_attribute_read_only(location, attribute_info):
+                password_attribute_name = \
+                    password_utils.get_wlst_attribute_name(attribute_info, model_attribute_value, self._wlst_mode)
 
-                    if data_type == JARRAY:
-                        subtype = 'java.lang.String'
-                        if SET_MBEAN_TYPE in attribute_info:
-                            subtype = attribute_info[SET_MBEAN_TYPE]
-                        wlst_attribute_value = alias_utils.convert_to_type(data_type, merged_value, subtype=subtype,
-                                                                           delimiter=MODEL_LIST_DELIMITER)
+                if password_attribute_name is not None:
+                    wlst_attribute_name = password_attribute_name
+                else:
+                    wlst_attribute_name = attribute_info[WLST_NAME]
+
+                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]
+                if data_type == 'password':
+                    try:
+                        wlst_attribute_value = self.__decrypt_password(model_attribute_value)
+                    except EncryptionException, ee:
+                        ex = exception_helper.create_alias_exception('WLSDPLY-08402', model_attribute_name,
+                                                                     location.get_folder_path(),
+                                                                     ee.getLocalizedMessage(), error=ee)
+                        self._logger.throwing(ex, class_name=self._class_name, method_name=_method_name)
+                        raise ex
+                else:
+                    if data_type in ALIAS_LIST_TYPES or data_type in ALIAS_MAP_TYPES:
+                        merge = True
+                        if MERGE in attribute_info:
+                            merge = alias_utils.convert_boolean(attribute_info[MERGE])
+
+                        if merge and data_type in ALIAS_MAP_TYPES:
+                            model_val = TypeUtils.convertToType(PROPERTIES, model_attribute_value)
+                            existing_val = TypeUtils.convertToType(PROPERTIES, existing_wlst_value)
+                            merged_value = alias_utils.merge_model_and_existing_properties(model_val, existing_val)
+                        elif merge and alias_utils.is_attribute_server_start_arguments(location, model_attribute_name):
+                            merged_value = alias_utils.merge_server_start_argument_values(model_attribute_value,
+                                                                                          existing_wlst_value)
+                        elif merge and existing_wlst_value is not None and len(existing_wlst_value) > 0:
+                            model_val = alias_utils.convert_to_type(LIST, model_attribute_value,
+                                                                    delimiter=MODEL_LIST_DELIMITER)
+
+                            _read_type, read_delimiter = \
+                                alias_utils.compute_read_data_type_and_delimiter_from_attribute_info(attribute_info,
+                                                                                                     existing_wlst_value)
+                            existing_val = alias_utils.convert_to_type(LIST, existing_wlst_value,
+                                                                       delimiter=read_delimiter)
+                            merged_value = alias_utils.merge_model_and_existing_lists(model_val, existing_val)
+                        else:
+                            merged_value = model_attribute_value
+
+                        if data_type == JARRAY:
+                            subtype = 'java.lang.String'
+                            if SET_MBEAN_TYPE in attribute_info:
+                                subtype = attribute_info[SET_MBEAN_TYPE]
+                            wlst_attribute_value = alias_utils.convert_to_type(data_type, merged_value, subtype=subtype,
+                                                                               delimiter=MODEL_LIST_DELIMITER)
+                        else:
+                            wlst_attribute_value = alias_utils.convert_to_type(data_type, merged_value,
+                                                                               delimiter=MODEL_LIST_DELIMITER)
                     else:
-                        wlst_attribute_value = alias_utils.convert_to_type(data_type, merged_value,
+                        wlst_attribute_value = alias_utils.convert_to_type(data_type, model_attribute_value,
                                                                            delimiter=MODEL_LIST_DELIMITER)
-                else:
-                    wlst_attribute_value = alias_utils.convert_to_type(data_type, model_attribute_value,
-                                                                       delimiter=MODEL_LIST_DELIMITER)
 
         return wlst_attribute_name, wlst_attribute_value
 

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

@@ -105,6 +105,22 @@ def get_current_model_folder(self):
             model_folder = model_folder_list[-1]
         return model_folder
 
+    def get_parent_folder_path(self):
+        """
+        Return the parent folder path for the location. This is the parent of the last folder or None if no parent.
+        :return: return the parent folder path
+        """
+        result = None
+        model_folder_list = self.get_model_folders()
+        if model_folder_list:
+            result = ''
+            if len(model_folder_list) > 1:
+                for folder in model_folder_list[-2]:
+                    result += '/' + folder
+            if len(result) == 0:
+                result = '/'
+        return result
+
     def get_name_tokens(self):
         """
         Copy constructor for ``name_tokens`` dictionary of location context.

core/src/main/resources/oracle/weblogic/deploy/aliases/category_modules/NMProperties.json

@@ -2,6 +2,7 @@
     "copyright": "Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.",
     "license": "The Universal Permissive License (UPL), Version 1.0",
     "wlst_type": "NMProperties",
+    "wlst_mode": "offline",
     "folders": {},
     "attributes": {
         "AuthenticationEnabled":               [ {"version": "[12.1.2,)",         "wlst_mode": "offline",    "wlst_name": "AuthenticationEnabled",                       "wlst_path": "WP001", "value": {"default": "true"  }, "wlst_type": "boolean"} ],

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

@@ -683,6 +683,7 @@ WLSDPLY-08130=Unable to compute the name token for folder {0} because the folder
   WebLogic Server version {1}: {2}
 WLSDPLY-08131=Unable to compute the name token for folder {0} because the folder is not valid in \
   WebLogic Server version {1}
+WLSDPLY-08132=Folder {0} present only for {1} mode is not relevant for WLST in {2} mode
 #
 # Empty slots to fill up...
 #
@@ -749,6 +750,7 @@ WLSDPLY-08406={0} WLST attribute name is not associated with a model attribute n
 WLSDPLY-08407=Attribute {0} in folder {1} is supported in WebLogic version {2}
 WLSDPLY-08408=Attribute {0} in folder {1} is not supported in WebLogic version {2}
 WLSDPLY-08409=Access for attribute {0} in folder {1} is read-only or validation-only in WLST {2} mode
+WLSDPLY-08410={0} model folder at location {1} is not supported for WLST {2} mode WebLogic version {3}
 
 # oracle.weblogic.deploy.aliases.TypeUtils.java
 WLSDPLY-08500=Unable to convert type due to an unknown type {0}

core/src/test/python/alias_json_file_test.py

@@ -70,6 +70,7 @@ class ListTestCase(unittest.TestCase):
         VERSION,
         WLST_CREATE_PATH,
         WLST_LIST_PATH,
+        WLST_MODE,
         WLST_SUBFOLDERS_PATH
     ]
 
@@ -276,6 +277,7 @@ def _verify_folder_wlst_paths_attribute_type(self, folder_name, attribute_value)
             result.append(self._get_invalid_dictionary_type_message(folder_name, WLST_PATHS, attribute_value))
         return result
 
+
     def _verify_folder_wlst_type_attribute_type(self, folder_name, attribute_value):
         result = []
         if type(attribute_value) is not str:
@@ -341,6 +343,19 @@ def _verify_folder_version_attribute_value(self, folder_name, attribute_value):
             result.append(self._get_invalid_string_type_message(folder_name, VERSION, attribute_value))
         return result
 
+    def _verify_folder_wlst_mode_attribute_value(self, folder_name, attribute_value):
+        result = []
+        if type(attribute_value) is not str:
+            message = self._get_invalid_attribute_string_type_message(folder_name, folder_name,
+                                                                      WLST_MODE, attribute_value)
+            result.append(message)
+        else:
+            # curly braces not allowed in wlst_mode
+            if attribute_value not in self._known_wlst_mode_attribute_values:
+                message = self._get_invalid_wlst_mode_message(folder_name, attribute_value)
+                result.append(message)
+        return result
+
     def _verify_folder_wlst_create_path_attribute_value(self, folder_name, attribute_value):
         result = []
         if type(attribute_value) is not str:
@@ -653,6 +668,12 @@ def _get_invalid_attribute_boolean_string_value_message(self, folder_name, attri
 
         return  text % (folder_name, attribute_name, alias_attribute_name, alias_attribute_value)
 
+
+    def _get_invalid_wlst_mode_message(self, folder_name, alias_attribute_name):
+        text = 'Folder at path %s has invalid wlst mode type of %s'
+        result = text %(folder_name, alias_attribute_name)
+        return result
+
     def _get_empty_constrained_value_message(self, folder_name, attribute_name, alias_attribute_name, wlst_mode=None):
         if wlst_mode is None:
             text = 'Folder at path %s has a defined attribute %s with alias attribute %s whose value was empty'
@@ -673,4 +694,4 @@ def _get_invalid_alias_attribute_value_message(self, folder_name, attribute_name
                                                    wlst_mode, alias_attribute_value, cause):
         text = 'Folder at path %s has a defined attribute %s with alias attribute %s whose ' \
                '%s value %s was not valid because %s'
-        return text % (folder_name, attribute_name, alias_attribute_name, wlst_mode, alias_attribute_value, cause)
+        return text % (folder_name, attribute_name, alias_attribute_name, wlst_mode, alias_attribute_value, cause)

core/src/test/python/aliases_test.py

@@ -13,6 +13,7 @@
 from oracle.weblogic.deploy.aliases import TypeUtils
 
 from wlsdeploy.aliases.aliases import Aliases
+from wlsdeploy.aliases.alias_constants import ATTRIBUTES
 from wlsdeploy.aliases.location_context import LocationContext
 import wlsdeploy.aliases.model_constants as FOLDERS
 from wlsdeploy.aliases.validation_codes import ValidationCodes
@@ -1234,10 +1235,16 @@ def testIssue91Fix(self):
         wlst_list_path = self.aliases.get_wlst_list_path(location)
         self.assertEqual(wlst_list_path, expected)
 
-        # All the attributes in FOLDERS.NM_PROPERTIES have 'wlst_mode':'offline", so
-        # the default value should be None
+        # NMProperties is an offline only folder and the get_model_attribute_default_value will throw and exception
+        model_attribute_name = 'weblogic.StartScriptName'
+
+        self.assertRaises(AliasException, getattr(self.online_aliases, 'get_model_attribute_default_value'),
+                          location, model_attribute_name)
+
+        # this method will not return an exception but should return a None
+        default_name, default_value = \
+            self.online_aliases.get_wlst_attribute_name_and_value(location, model_attribute_name, 'script')
         expected = None
-        default_value = self.online_aliases.get_model_attribute_default_value(location, 'weblogic.StartScriptName')
         self.assertEqual(default_value, expected)
 
         return