Create validation mode for WKTUI (#1019)

* Use VariableConfiguration object methods; list all token failures; improve logging

* Revised file token regexes and error checking

* Use constant to set validation mode

* Renumbered and re-ordered bundled messages

* Throw a single exception for multiple variable substitution errors

* Throw a single exception for substitution errors

* Always show issue summary for validateModel

* Refined logging messages

* Renamed validation check methods; add wktui validation mode; check result of substitute_value

* Use PlatformLogger in KubernetesValidator

* Enable/disable archive reference checks in validate configuration

* Revised test for validate with missing archive to expect error exit code

* Log info or severe messages for missing archive entries

* Correction to allow unresolved archive references for lax validation

Author: rakillen

core/src/main/python/compare_model.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020, 2021, Oracle and/or its affiliates.
+# Copyright (c) 2020, 2022, Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
 #
 # ------------
@@ -40,6 +40,7 @@
 from wlsdeploy.tool.compare.model_comparer import ModelComparer
 from wlsdeploy.tool.validate.validator import Validator
 from wlsdeploy.util import cla_helper
+from wlsdeploy.util import validate_configuration
 from wlsdeploy.util import variables
 from wlsdeploy.util.cla_utils import CommandLineArgUtil
 from wlsdeploy.util.model_context import ModelContext
@@ -75,9 +76,7 @@ def __process_args(args):
     cla_util = CommandLineArgUtil(_program_name, __required_arguments, __optional_arguments)
     argument_map = cla_util.process_args(args, trailing_arg_count=2)
 
-    model_context = ModelContext(_program_name, argument_map)
-    model_context.set_ignore_missing_archive_entries(True)
-    return model_context
+    return ModelContext(_program_name, argument_map)
 
 
 class ModelFileDiffer:
@@ -111,7 +110,8 @@ def compare(self):
                 model_file_name = self.past_dict_file
                 FileToPython(model_file_name, True).parse()
 
-            self.model_context.set_validation_method('lax')
+            # allow unresolved tokens and archive entries
+            self.model_context.set_validation_method(validate_configuration.LAX_METHOD)
 
             aliases = Aliases(model_context=self.model_context, wlst_mode=WlstModes.OFFLINE,
                               exception_type=ExceptionType.COMPARE)

core/src/main/python/discover.py

@@ -1,5 +1,5 @@
 """
-Copyright (c) 2017, 2021, Oracle Corporation and/or its affiliates.
+Copyright (c) 2017, 2022, Oracle Corporation and/or its affiliates.
 Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
 
 The entry point for the discoverDomain tool.
@@ -434,11 +434,6 @@ def __check_and_customize_model(model, model_context, aliases, credential_inject
     # target config always present in model context, default config if not declared
     target_configuration = model_context.get_target_configuration()
 
-    # if target config declared, use the validation method it contains (lax, etc.)
-    if model_context.is_targetted_config():
-        validation_method = target_configuration.get_validation_method()
-        model_context.set_validation_method(validation_method)
-
     credential_cache = None
     if credential_injector is not None:
         # filter variables or secrets that are no longer in the model

core/src/main/python/extract_resource.py

@@ -1,5 +1,5 @@
 """
-Copyright (c) 2020, 2021, Oracle and/or its affiliates.
+Copyright (c) 2020, 2022, Oracle and/or its affiliates.
 Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
 
 The entry point for the extractDomainResource tool.
@@ -20,6 +20,7 @@
 from wlsdeploy.tool.util import model_context_helper
 from wlsdeploy.util import cla_helper
 from wlsdeploy.util import tool_exit
+from wlsdeploy.util import validate_configuration
 from wlsdeploy.util.cla_utils import CommandLineArgUtil
 from wlsdeploy.util.cla_utils import TOOL_TYPE_EXTRACT
 from wlsdeploy.util.model import Model
@@ -67,10 +68,9 @@ def __process_args(args):
     cla_helper.validate_variable_file_exists(_program_name, argument_map)
     cla_helper.process_encryption_args(argument_map)
 
-    argument_map[CommandLineArgUtil.VALIDATION_METHOD] = CommandLineArgUtil.LAX_VALIDATION_METHOD
-    model_context = model_context_helper.create_context(_program_name, argument_map)
-    model_context.set_ignore_missing_archive_entries(True)
-    return model_context
+    # allow unresolved tokens and archive entries
+    argument_map[CommandLineArgUtil.VALIDATION_METHOD] = validate_configuration.LAX_METHOD
+    return model_context_helper.create_context(_program_name, argument_map)
 
 
 def __extract_resource(model, model_context):

core/src/main/python/prepare_model.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020, 2021, Oracle and/or its affiliates.
+# Copyright (c) 2020, 2022, Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
 #
 # ------------
@@ -55,7 +55,8 @@ def __process_args(args):
     target_configuration_helper.process_target_arguments(argument_map)
 
     model_context = ModelContext(_program_name, argument_map)
-    model_context.set_ignore_missing_archive_entries(True)
+    # override this check, since archive file is not supplied here
+    model_context.get_validate_configuration().set_allow_unresolved_archive_references(True)
     return model_context
 
 

core/src/main/python/validate.py

@@ -1,5 +1,5 @@
 """
-Copyright (c) 2017, 2021, Oracle Corporation and/or its affiliates.
+Copyright (c) 2017, 2022, Oracle Corporation and/or its affiliates.
 Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
 
 The WLS Deploy tooling entry point for the validateModel tool.
@@ -28,6 +28,7 @@
 from wlsdeploy.util import cla_helper
 from wlsdeploy.util import dictionary_utils
 from wlsdeploy.util import tool_exit
+from wlsdeploy.util import validate_configuration
 from wlsdeploy.util import variables
 from wlsdeploy.util.cla_utils import CommandLineArgUtil
 from wlsdeploy.util.weblogic_helper import WebLogicHelper
@@ -84,7 +85,7 @@ def __process_model_args(argument_map):
     except CLAException, ce:
         # in lax validation mode, if no model is found, log at INFO and exit
         method = dictionary_utils.get_element(argument_map, CommandLineArgUtil.VALIDATION_METHOD)
-        if method == CommandLineArgUtil.LAX_VALIDATION_METHOD:
+        if method == validate_configuration.LAX_METHOD:
             __logger.info('WLSDPLY-20032', _program_name, class_name=_class_name, method_name=_method_name)
             model_context = model_context_helper.create_exit_context(_program_name)
             tool_exit.end(model_context, CommandLineArgUtil.PROG_OK_EXIT_CODE)
@@ -131,8 +132,6 @@ def __perform_model_file_validation(model_file_name, model_context):
                                                         model_context.get_archive_file_name())
 
     except (TranslateException, VariableException), te:
-        __logger.severe('WLSDPLY-20009', _program_name, model_file_name, te.getLocalizedMessage(),
-                        error=te, class_name=_class_name, method_name=_method_name)
         ex = exception_helper.create_validate_exception(te.getLocalizedMessage(), error=te)
         __logger.throwing(ex, class_name=_class_name, method_name=_method_name)
         raise ex
@@ -167,9 +166,9 @@ def main(args):
         model_context = model_context_helper.create_exit_context(_program_name)
         tool_exit.end(model_context, exit_code)
 
-    try:
-        model_file_name = model_context.get_model_file()
+    model_file_name = model_context.get_model_file()
 
+    try:
         if model_file_name is not None:
             __perform_model_file_validation(model_file_name, model_context)
 
@@ -182,10 +181,9 @@ def main(args):
                     exit_code = CommandLineArgUtil.PROG_WARNING_EXIT_CODE
 
     except ValidateException, ve:
+        exit_code = CommandLineArgUtil.PROG_ERROR_EXIT_CODE
         __logger.severe('WLSDPLY-20000', _program_name, ve.getLocalizedMessage(), error=ve,
                         class_name=_class_name, method_name=_method_name)
-        cla_helper.clean_up_temp_files()
-        sys.exit(CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
 
     cla_helper.clean_up_temp_files()
 

core/src/main/python/wlsdeploy/tool/prepare/model_preparer.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2021, Oracle and/or its affiliates.
+# Copyright (c) 2021, 2022, Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
 
 import os
@@ -199,8 +199,8 @@ def fix_property_secrets(self):
         credential_caches = self.credential_injector.get_variable_cache()
         for key in credential_caches:
             if variables.is_variable_string(credential_caches[key]):
-                credential_caches[key] = variables._substitute(credential_caches[key],
-                                                               original_variables, self.model_context)
+                credential_caches[key] = variables.substitute_value(credential_caches[key],
+                                                                    original_variables, self.model_context)
 
     def _apply_filter_and_inject_variable(self, model_dict, model_context):
         """

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

@@ -1,12 +1,12 @@
 """
-Copyright (c) 2020, 2021, Oracle and/or its affiliates.
+Copyright (c) 2020, 2022, Oracle and/or its affiliates.
 Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
 """
 
 from wlsdeploy.aliases.model_constants import KUBERNETES
 from wlsdeploy.exception.expection_types import ExceptionType
+from wlsdeploy.logging.platform_logger import PlatformLogger
 from wlsdeploy.tool.extract import wko_schema_helper
-from wlsdeploy.tool.validate.validator_logger import ValidatorLogger
 from wlsdeploy.util import dictionary_utils
 
 
@@ -15,7 +15,7 @@ class KubernetesValidator(object):
     Class for validating the kubernetes section of a model file
     """
     _class_name = 'KubernetesValidator'
-    _logger = ValidatorLogger('wlsdeploy.validate')
+    _logger = PlatformLogger('wlsdeploy.validate')
 
     def __init__(self, model_context):
         self._model_context = model_context

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

@@ -1,5 +1,5 @@
 """
-Copyright (c) 2017, 2020, Oracle Corporation and/or its affiliates.
+Copyright (c) 2017, 2022, Oracle Corporation and/or its affiliates.
 Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
 """
 import os
@@ -62,6 +62,7 @@ class Validator(object):
 
     def __init__(self, model_context, aliases=None, logger=None, wlst_mode=None, domain_name='base_domain'):
         self._model_context = model_context
+        self._validate_configuration = model_context.get_validate_configuration()
 
         if logger is None:
             # No logger specified, so use the one declared at the module level
@@ -761,9 +762,9 @@ def __validate_variable_substitution(self, tokenized_value, model_folder_path):
                     # FIXME(mwooten) - the cla_utils should be fixing all windows paths to use forward slashes already
                     # assuming that the value is not None
 
-                    logger_method = self._logger.info
-                    if self._model_context.get_validation_method() == 'strict':
-                        logger_method = self._logger.warning
+                    logger_method = self._logger.warning
+                    if self._validate_configuration.allow_unresolved_variable_tokens():
+                        logger_method = _info_logger.info
 
                     variables_file_name = self._model_context.get_variable_file()
                     if variables_file_name is None:
@@ -821,23 +822,21 @@ def __validate_single_path_in_archive(self, path, attribute_name, model_folder_p
         #     token to make that explicit in the model.
         #
         if WLSDeployArchive.isPathIntoArchive(path):
+            # If the validate configuration allows unresolved archive references,
+            # log INFO messages identifying missing entries, and allow validation to succeed.
+            # Otherwise, log SEVERE messages that will cause validation to fail.
+            log_method = self._logger.severe
+            if self._validate_configuration.allow_unresolved_archive_references():
+                log_method = _info_logger.info
+
             if self._archive_helper is not None:
                 archive_has_file = self._archive_helper.contains_file_or_path(path)
                 if not archive_has_file:
-                    self._logger.severe('WLSDPLY-05024', attribute_name, model_folder_path, path,
-                                        self._archive_file_name, class_name=_class_name, method_name=_method_name)
+                    log_method('WLSDPLY-05024', attribute_name, model_folder_path, path,
+                               self._archive_file_name, class_name=_class_name, method_name=_method_name)
             else:
-                # If running in STANDALONE mode, or configured to ignore missing archive entries,
-                # log an INFO message identifying missing entries, and allow validation to succeed.
-                # In TOOL mode, unless the ignore flag is set, log a SEVERE message that will cause
-                # validation to fail.
-                ignore_missing_entries = self._model_context.get_ignore_missing_archive_entries()
-                if self._validation_mode == _ValidationModes.STANDALONE or ignore_missing_entries:
-                    self._logger.info('WLSDPLY-05025', attribute_name, model_folder_path, path,
-                                      class_name=_class_name, method_name=_method_name)
-                elif self._validation_mode == _ValidationModes.TOOL:
-                    self._logger.severe('WLSDPLY-05025', attribute_name, model_folder_path, path,
-                                        class_name=_class_name, method_name=_method_name)
+                log_method('WLSDPLY-05025', attribute_name, model_folder_path, path,
+                           class_name=_class_name, method_name=_method_name)
         else:
             tokens = validation_utils.extract_path_tokens(path)
             self._logger.finest('tokens={0}', str(tokens), class_name=_class_name, method_name=_method_name)
@@ -937,14 +936,9 @@ def _report_unsupported_variable_usage(self, tokenized_value, model_folder_path)
     def _log_version_invalid(self, message, method_name):
         """
         Log a message indicating that an attribute is not valid for the current WLS version and WLST mode.
-        Log INFO if validation method is "lax", otherwise log WARNING.
+        Log INFO or WARNING, depending on validation mode.
         """
-        if self._model_context.is_targetted_config():
-            validation_method = self._model_context.get_target_configuration().get_validation_method()
-        else:
-            validation_method = self._model_context.get_validation_method()
-
         log_method = self._logger.warning
-        if validation_method == 'lax':
+        if self._validate_configuration.allow_version_invalid_attributes():
             log_method = _info_logger.info
         log_method('WLSDPLY-05027', message, class_name=_class_name, method_name=method_name)

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

@@ -1,5 +1,5 @@
 """
-Copyright (c) 2017, 2021, Oracle Corporation and/or its affiliates.
+Copyright (c) 2017, 2022, Oracle Corporation and/or its affiliates.
 Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
 
 Module that handles command-line argument parsing and common validation.
@@ -20,17 +20,19 @@
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.logging.platform_logger import PlatformLogger
 from wlsdeploy.util import path_utils
+from wlsdeploy.util import validate_configuration
 from wlsdeploy.util.target_configuration import CREDENTIALS_METHOD
 from wlsdeploy.util.target_configuration import CREDENTIALS_METHODS
 from wlsdeploy.util.target_configuration import TargetConfiguration
+from wlsdeploy.util.target_configuration import VALIDATION_METHOD
+from wlsdeploy.util.validate_configuration import VALIDATION_METHODS
 
 # tool type may indicate variations in argument processing
 TOOL_TYPE_CREATE = "create"
 TOOL_TYPE_DEFAULT = "default"
 TOOL_TYPE_EXTRACT = "extract"
 
 
-
 class CommandLineArgUtil(object):
     """
     Class that handles command-line argument parsing and common validation.
@@ -120,10 +122,6 @@ class CommandLineArgUtil(object):
     ARCHIVE_FILES_SEPARATOR = ','
     MODEL_FILES_SEPARATOR = ','
 
-    LAX_VALIDATION_METHOD = 'lax'
-    STRICT_VALIDATION_METHOD = 'strict'
-    VALIDATION_METHODS = [LAX_VALIDATION_METHOD, STRICT_VALIDATION_METHOD]
-
     HELP_EXIT_CODE                 = 100
     USAGE_ERROR_EXIT_CODE          = 99
     ARG_VALIDATION_ERROR_EXIT_CODE = 98
@@ -844,8 +842,8 @@ def _validate_validate_method_arg(self, value):
             ex.setExitCode(self.ARG_VALIDATION_ERROR_EXIT_CODE)
             self._logger.throwing(ex, class_name=self._class_name, method_name=method_name)
             raise ex
-        elif value not in self.VALIDATION_METHODS:
-            ex = exception_helper.create_cla_exception('WLSDPLY-20030', value, self.VALIDATION_METHODS)
+        elif value not in VALIDATION_METHODS:
+            ex = exception_helper.create_cla_exception('WLSDPLY-20030', value, VALIDATION_METHODS)
             ex.setExitCode(self.ARG_VALIDATION_ERROR_EXIT_CODE)
             self._logger.throwing(ex, class_name=self._class_name, method_name=method_name)
             raise ex
@@ -1163,8 +1161,11 @@ def _validate_target_arg(self, value):
                 config_dictionary = eval(file_handle.read())
                 target_configuration = TargetConfiguration(config_dictionary)
                 validation_method = target_configuration.get_validation_method()
-                if (validation_method is not None) and (validation_method not in self.VALIDATION_METHODS):
-                    ex = exception_helper.create_cla_exception('WLSDPLY-01645', target_configuration_file)
+                if (validation_method is not None) and \
+                        (validation_method not in validate_configuration.VALIDATION_METHODS):
+                    ex = exception_helper.create_cla_exception('WLSDPLY-01648', target_configuration_file,
+                                                               validation_method, VALIDATION_METHOD,
+                                                               ', '.join(validate_configuration.VALIDATION_METHODS))
                     ex.setExitCode(self.ARG_VALIDATION_ERROR_EXIT_CODE)
                     self._logger.throwing(ex, class_name=self._class_name, method_name=method_name)
                     raise ex