Merge pull request #1018 from oracle/develop-k8s-model

Support hyphenated lists in kubernetes section of WDT model

Author: robertpatrick

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'
@@ -50,7 +50,8 @@
 DEFAULT_IMAGE_PULL_SECRETS = PASSWORD_TOKEN
 DEFAULT_SOURCE_TYPE = 'Image'
 
-MULTI_KEYS = {
+# deprecated - used for "named object list" format
+OBJECT_NAME_ATTRIBUTES = {
     'spec/adminServer/adminService/channels': 'channelName',
     'spec/clusters': 'clusterName'
 }
@@ -71,9 +72,6 @@ def __init__(self, model, model_context, logger):
         return
 
     def extract(self):
-        """
-        Deploy resource model elements at the domain level, including multi-tenant elements.
-        """
         _method_name = 'extract'
 
         resource_file = self._model_context.get_domain_resource_file()
@@ -93,7 +91,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,42 +105,35 @@ 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_object(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_object(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
+        :param schema_path: the path of schema elements, used for supported check
         """
         folder_properties = schema_folder["properties"]
 
         for key, model_value in model_dict.items():
             properties = folder_properties[key]
 
-            if wko_schema_helper.is_single_folder(properties):
-                # single object instance
+            if wko_schema_helper.is_single_object(properties):
                 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_object(model_value, properties, next_target_dict, next_schema_path)
 
-            elif wko_schema_helper.is_multiple_folder(properties):
-                # multiple object instances
+            elif wko_schema_helper.is_object_array(properties):
                 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_object_array(model_value, item_info, next_schema_path)
 
             elif wko_schema_helper.is_simple_map(properties):
                 # map of key / value pairs
@@ -154,30 +144,35 @@ 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_object_array(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.
+        Process an array of objects.
         :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
+        :param schema_path: the path of schema elements, used for supported check
         """
         child_list = list()
-        for name in model_value:
-            name_map = model_value[name]
-            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)
 
+        # deprecated "named object list" format - warning was issued in validator
+        if isinstance(model_value, dict):
+            for name in model_value:
+                object_map = model_value[name]
+                next_target_dict = PyOrderedDict()
+                self._process_object(object_map, item_info, next_target_dict, schema_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)
+                child_list.append(next_target_dict)
+            return child_list
+        # end deprecated
+
+        for object_map in model_value:
+            next_target_dict = PyOrderedDict()
+            self._process_object(object_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 +299,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,16 +332,17 @@ def _add_secrets(folder, secrets, domain_uid):
                     secrets.append(secret_name)
 
 
+# deprecated
 def get_mapped_key(schema_path):
     """
-    Because the WDT model does not support hyphenated lists, the name of each item in a
+    For the deprecated "named object list format", 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)
+    mapped_key = dictionary_utils.get_element(OBJECT_NAME_ATTRIBUTES, schema_path)
     if mapped_key is not None:
         return mapped_key
     return 'name'

core/src/main/python/wlsdeploy/tool/extract/wko_schema_helper.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.
 """
 from oracle.weblogic.deploy.util import FileUtils
@@ -15,11 +15,17 @@
 DOMAIN_RESOURCE_SCHEMA_PATH = 'oracle/weblogic/deploy/wko/' + DOMAIN_RESOURCE_SCHEMA_FILE
 
 SIMPLE_TYPES = [
+    'integer',
     'number',
     'string',
     'boolean'
 ]
 
+OBJECT_TYPES = [
+    'object',
+    None
+]
+
 UNSUPPORTED_FOLDERS = [
     'status',
     'metadata/initializers',
@@ -56,32 +62,37 @@ def get_domain_resource_schema(exception_type=ExceptionType.DEPLOY):
     return schema
 
 
-def is_single_folder(schema_map):
+def is_single_object(schema_map):
     """
-    Return True if the schema map describes a single folder.
+    Return True if the schema map describes a single object.
     :param schema_map: the schema map to be examined
-    :return: True if the map identifies a single folder
+    :return: True if the map identifies a single object
     """
     property_type = get_type(schema_map)
-    if property_type == "object":
+    if property_type in OBJECT_TYPES:
         return get_map_element_type(schema_map) is None
     return False
 
 
-def is_multiple_folder(schema_map):
+def is_object_array(schema_map):
     """
-    Return True if the schema map identifies a multiple folder.
+    Return True if the schema map describes an object array.
     :param schema_map: the schema map to be examined
-    :return: True if the map identifies a multiple folder
+    :return: True if the map identifies an object array
     """
     property_type = get_type(schema_map)
     if property_type == "array":
-        return get_array_element_type(schema_map) == "object"
+        return get_array_element_type(schema_map) in OBJECT_TYPES
     return False
 
 
-def is_folder(schema_map):
-    return is_single_folder(schema_map) or is_multiple_folder(schema_map)
+def is_object_type(schema_map):
+    """
+    Return True if the schema map describes an object or object array.
+    :param schema_map: the schema map to be examined
+    :return: True if the map identifies an object or object array
+    """
+    return is_single_object(schema_map) or is_object_array(schema_map)
 
 
 def is_simple_map(schema_map):
@@ -91,7 +102,7 @@ def is_simple_map(schema_map):
     :return: True if the map identifies a simple map
     """
     property_type = get_type(schema_map)
-    if property_type == "object":
+    if property_type in OBJECT_TYPES:
         return get_map_element_type(schema_map) is not None
     return False
 
@@ -104,10 +115,20 @@ def is_simple_array(schema_map):
     """
     property_type = get_type(schema_map)
     if property_type == "array":
-        return get_array_element_type(schema_map) != "object"
+        return get_array_element_type(schema_map) not in OBJECT_TYPES
     return False
 
 
+def is_simple_type(schema_map):
+    """
+    Return True if the schema map describes a simple type.
+    :param schema_map: the schema map to be examined
+    :return: True if the map identifies a simple type
+    """
+    property_type = get_type(schema_map)
+    return property_type in SIMPLE_TYPES
+
+
 def get_array_element_type(schema_map):
     item_info = get_array_item_info(schema_map)
     return get_type(item_info)
@@ -123,7 +144,8 @@ def get_array_item_info(schema_map):
 
 
 def get_properties(schema_map):
-    return dictionary_utils.get_element(schema_map, "properties")
+    properties = dictionary_utils.get_element(schema_map, "properties")
+    return properties or {}
 
 
 def get_type(schema_map):