Use hyphenated lists when extracting domain resource from model

Author: rakillen

core/src/main/python/wlsdeploy/json/json_translator.py

@@ -1,5 +1,5 @@
 """
-Copyright (c) 2017, 2020, Oracle Corporation and/or its affiliates.
+Copyright (c) 2017, 2021, Oracle Corporation and/or its affiliates.
 Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
 
 This model provider translation classes that convert between JSON and Python Dictionaries.
@@ -18,6 +18,7 @@
 import oracle.weblogic.deploy.json.JsonTranslator as JJsonTranslator
 
 from wlsdeploy.logging.platform_logger import PlatformLogger
+from wlsdeploy.util.boolean_value import BooleanValue
 import wlsdeploy.exception.exception_helper as exception_helper
 
 # Unlike with yaml files, JSON files do not allow comments. remove from file
@@ -202,7 +203,7 @@ def _write_list_to_json_file(self, alist, writer, indent=''):
             writer.println()
             if isinstance(value, dict):
                 writer.write(list_indent)
-                self._write_dictionary_to_json_file(value, writer, indent)
+                self._write_dictionary_to_json_file(value, writer, list_indent)
             else:
                 writer.write(list_indent)
                 writer.write(_format_json_value(value))
@@ -239,6 +240,8 @@ def _format_json_value(value):
     builder = StringBuilder()
     if type(value) == bool:
         builder.append(JBoolean.toString(value))
+    elif isinstance(value, BooleanValue):
+        builder.append(value.get_string_value())
     elif isinstance(value, types.StringTypes):
         builder.append('"').append(_escape_text(value.strip())).append('"')
     else:

core/src/main/python/wlsdeploy/tool/extract/domain_resource_extractor.py

@@ -11,14 +11,14 @@
 from wlsdeploy.aliases.alias_constants import PASSWORD_TOKEN
 from wlsdeploy.aliases.model_constants import CLUSTER
 from wlsdeploy.aliases.model_constants import DEFAULT_WLS_DOMAIN_NAME
-from wlsdeploy.aliases.model_constants import KUBERNETES
 from wlsdeploy.aliases.model_constants import MODEL_LIST_DELIMITER
 from wlsdeploy.aliases.model_constants import NAME
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.exception.expection_types import ExceptionType
 from wlsdeploy.tool.extract import wko_schema_helper
 from wlsdeploy.tool.util import k8s_helper
 from wlsdeploy.util import dictionary_utils
+from wlsdeploy.util.boolean_value import BooleanValue
 from wlsdeploy.util.model_translator import PythonToFile
 
 API_VERSION = 'apiVersion'
@@ -93,7 +93,6 @@ def extract(self):
 
         # write the resource file structure to the output file
         writer = PythonToFile(resource_dict)
-        writer.set_yaml_hyphenate_yaml_lists(True)
         writer.write_to_file(resource_file)
         return
 
@@ -108,18 +107,16 @@ def _create_domain_resource_dictionary(self):
 
         schema = wko_schema_helper.get_domain_resource_schema(ExceptionType.DEPLOY)
 
-        model_path = KUBERNETES + ":"
-        self._process_folder(kubernetes_map, schema, resource_dict, None, model_path)
+        self._process_folder(kubernetes_map, schema, resource_dict, None)
         return resource_dict
 
-    def _process_folder(self, model_dict, schema_folder, target_dict, schema_path, model_path):
+    def _process_folder(self, model_dict, schema_folder, target_dict, schema_path):
         """
         Transfer folders and attributes from the model dictionary to the target domain resource dictionary.
         :param model_dict: the source model dictionary
         :param schema_folder: the schema for this folder
         :param target_dict: the target dictionary for the domain resource file.
         :param schema_path: the path of schema elements (no multi-element names), used for supported check
-        :param model_path: the path of model elements (including multi-element names), used for logging
         """
         folder_properties = schema_folder["properties"]
 
@@ -129,21 +126,18 @@ def _process_folder(self, model_dict, schema_folder, target_dict, schema_path, m
             if wko_schema_helper.is_single_folder(properties):
                 # single object instance
                 next_schema_path = wko_schema_helper.append_path(schema_path, key)
-                next_model_path = model_path + "/" + key
                 if not wko_schema_helper.is_unsupported_folder(next_schema_path):
                     next_target_dict = PyOrderedDict()
                     target_dict[key] = next_target_dict
-                    self._process_folder(model_value, properties, next_target_dict, next_schema_path,
-                                         next_model_path)
+                    self._process_folder(model_value, properties, next_target_dict, next_schema_path)
 
             elif wko_schema_helper.is_multiple_folder(properties):
                 # multiple object instances
                 next_schema_path = wko_schema_helper.append_path(schema_path, key)
-                next_model_path = model_path + "/" + key
                 if not wko_schema_helper.is_unsupported_folder(next_schema_path):
                     item_info = wko_schema_helper.get_array_item_info(properties)
                     target_dict[key] = \
-                        self._process_multiple_folder(model_value, item_info, next_schema_path, next_model_path)
+                        self._process_multiple_folder(model_value, item_info, next_schema_path)
 
             elif wko_schema_helper.is_simple_map(properties):
                 # map of key / value pairs
@@ -154,30 +148,19 @@ def _process_folder(self, model_dict, schema_folder, target_dict, schema_path, m
                 property_type = wko_schema_helper.get_type(properties)
                 target_dict[key] = _get_target_value(model_value, property_type)
 
-    def _process_multiple_folder(self, model_value, item_info, schema_path, model_path):
+    def _process_multiple_folder(self, model_value, item_info, schema_path):
         """
         Process a multiple-element model section.
-        There should be a dictionary of names, each containing a sub-folder.
+        There should be a list of objects, each representing a sub-folder.
         :param model_value: the model contents for a folder
         :param item_info: describes the contents of the sub-folder for each element
         :param schema_path: the path of schema elements (no multi-element names), used for supported check
-        :param model_path: the path of model elements (including multi-element names), used for logging
         """
         child_list = list()
-        for name in model_value:
-            name_map = model_value[name]
+        for name_map in model_value:
             next_target_dict = PyOrderedDict()
-            next_model_path = model_path + "/" + name
-            self._process_folder(name_map, item_info, next_target_dict, schema_path, next_model_path)
-
-            # see if the model name should become an attribute in the target dict
-            mapped_name = get_mapped_key(schema_path)
-            properties = wko_schema_helper.get_properties(item_info)
-            if (mapped_name in properties.keys()) and (mapped_name not in next_target_dict.keys()):
-                _add_to_top(next_target_dict, mapped_name, name)
-
+            self._process_folder(name_map, item_info, next_target_dict, schema_path)
             child_list.append(next_target_dict)
-
         return child_list
 
     def _update_resource_dictionary(self, resource_dict):
@@ -304,7 +287,7 @@ def _get_target_value(model_value, type_name):
     if type_name == 'boolean':
         # the model values can be true, false, 1, 0, etc.
         # target boolean values must be 'true' or 'false'
-        return alias_utils.convert_to_type('boolean', model_value)
+        return BooleanValue(model_value)
 
     if type_name == 'array':
         # the model values can be 'abc,123'.
@@ -337,21 +320,6 @@ def _add_secrets(folder, secrets, domain_uid):
                     secrets.append(secret_name)
 
 
-def get_mapped_key(schema_path):
-    """
-    Because the WDT model does not support hyphenated lists, the name of each item in a
-    multiple folder sometimes corresponds to one of its attributes, usually "name".
-    If a different attribute name is used for the path, return that name.
-    If the default 'name' is returned, caller should verify that it is an available attribute.
-    :param schema_path: the slash-delimited path of the elements (no multi-element names)
-    :return: the attribute key to be used
-    """
-    mapped_key = dictionary_utils.get_element(MULTI_KEYS, schema_path)
-    if mapped_key is not None:
-        return mapped_key
-    return 'name'
-
-
 def _add_to_top(dictionary, key, item):
     """
     Add an item to the beginning of an ordered dictionary.

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

@@ -1,5 +1,5 @@
 """
-Copyright (c) 2020, Oracle Corporation and/or its affiliates.
+Copyright (c) 2020, 2021, Oracle and/or its affiliates.
 Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
 """
 
@@ -111,14 +111,12 @@ def _validate_multiple_folder(self, model_value, property_map, schema_path, mode
         :param model_path: the path of model elements (including multi-element names), used for logging
         """
         _method_name = '_validate_multiple_folder'
-        if not isinstance(model_value, dict):
-            self._logger.severe("WLSDPLY-05039", model_path, class_name=self._class_name, method_name=_method_name)
+        if not isinstance(model_value, list):
+            self._logger.severe("WLSDPLY-05040", model_path, class_name=self._class_name, method_name=_method_name)
             return
 
-        for name in model_value:
-            name_map = model_value[name]
-            next_model_path = model_path + "/" + name
-            self.validate_folder(name_map, property_map, schema_path, next_model_path)
+        for name_map in model_value:
+            self.validate_folder(name_map, property_map, schema_path, model_path)
 
     def _validate_simple_map(self, model_value, property_name, model_path):
         _method_name = '_validate_simple_map'

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

@@ -0,0 +1,22 @@
+"""
+Copyright (c) 2021, Oracle and/or its affiliates.
+Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+
+Contains a boolean value that can be recognized by the YAML and JSON writers.
+"""
+from wlsdeploy.aliases import alias_utils
+
+
+class BooleanValue(object):
+
+    def __init__(self, value):
+        self.value = alias_utils.convert_boolean(value)
+
+    def get_value(self):
+        return self.value
+
+    def get_string_value(self):
+        if self.value:
+            return 'true'
+        else:
+            return 'false'

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

@@ -1,5 +1,5 @@
 """
-Copyright (c) 2017, 2020, Oracle Corporation and/or its affiliates.  All rights reserved.
+Copyright (c) 2017, 2021, Oracle and/or its affiliates.
 Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
 """
 import java.io.File as JFile
@@ -93,7 +93,6 @@ class PythonToFile(object):
     def __init__(self, dictionary):
         self.dictionary = dictionary
         self.logger = platform_logger.PlatformLogger('wlsdeploy.translator')
-        self._hyphenate_yaml_lists = False
 
     def write_to_file(self, file_name):
         """
@@ -114,9 +113,6 @@ def write_to_file(self, file_name):
         self.logger.exiting(class_name=self._class_name, method_name=_method_name)
         return return_file
 
-    def set_yaml_hyphenate_yaml_lists(self, hyphenate):
-        self._hyphenate_yaml_lists = hyphenate
-
     def _write_to_json_file(self, file_name):
         """
         Convert the Python dictionary to JSON and write it to a file.
@@ -147,7 +143,6 @@ def _write_to_yaml_file(self, file_name):
         self.logger.finer('WLSDPLY-01712', 'YAML', file_name, class_name=self._class_name, method_name=_method_name)
         try:
             writer = JPythonToYaml(self.dictionary)
-            writer.set_hyphenate_lists(self._hyphenate_yaml_lists)
             writer.write_to_yaml_file(file_name)
         except JYamlException, ye:
             translate_ex = exception_helper.create_translate_exception('WLSDPLY-01713', file_name,

core/src/main/python/wlsdeploy/yaml/yaml_translator.py

@@ -22,6 +22,7 @@
 
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.logging.platform_logger import PlatformLogger
+from wlsdeploy.util.boolean_value import BooleanValue
 
 
 class YamlToPython(object):
@@ -165,6 +166,8 @@ def convert_scalar_to_java_type(self, py_value):
             result = JLong(JString(str(py_value)))
         elif type(py_value) is float:
             result = JDouble(py_value)
+        elif isinstance(py_value, BooleanValue):
+            result = JBoolean(py_value.get_value())
         else:
             yaml_ex = exception_helper.create_yaml_exception('WLSDPLY-18201', type(py_value))
             self._logger.throwing(class_name=self._class_name, method_name=_method_name, error=yaml_ex)
@@ -182,8 +185,6 @@ def __init__(self, dictionary):
         # Fix error handling for None
         self._dictionary = dictionary
         self._logger = PlatformLogger('wlsdeploy.yaml')
-        # No-op
-        self._hyphenate_lists = False
         return
 
     def write_to_yaml_file(self, file_name):
@@ -223,9 +224,6 @@ def write_to_yaml_file(self, file_name):
 
         self._logger.exiting(class_name=self._class_name, method_name=_method_name)
 
-    def set_hyphenate_lists(self, hyphenate_lists):
-        self._hyphenate_lists = hyphenate_lists
-
     def _write_dictionary_to_yaml_file(self, dictionary, writer, file_name='<None>'):
         """
         Do the actual heavy lifting of converting a dictionary and writing it to the file.

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

@@ -483,6 +483,7 @@ WLSDPLY-05036=Attribute {0} in model location {1}, uses the {2} macro expression
 WLSDPLY-05037=Custom folder {0} will not be validated
 WLSDPLY-05038=Expected a section with subfolders and attributes in model location {0}
 WLSDPLY-05039=Expected a section with named subfolders in model location {0}
+WLSDPLY-05040=Expected a list of objects in model location {0}
 
 # wlsdeploy/tool/validate/kubernetes_validator.py
 WLSDPLY-05090=Model folder {0} is not supported, will be skipped