Add target option for Verrazzano to WDT (#659)

* Enable new target v8o with filter; refactored shared code; removed unused methods

* Move k8s operator filter into target directory; remove explicit copy

* Updated scripts to reflect additional options for -target

* Revisions to scripts

* Allow additional output types to be specified in the target configuration; fixed logger errors

* Fixed comment typo

* JIRA WDT-426 Build resource config files from templates, perform simple substitutions; improve exception handling

* JIRA WDT-426 Break out substitution module; use substitution blocks for databases, clusters

* JIRA WDT-426 Renaming to use vz throughout

* JIRA WDT-426 Revised model and binding templates

* JIRA WDT-426 Match secret name to script; use aliases for name resolution

* JIRA WDT-426 Use domain UID consistently in VZ config and secrets script

* JIRA WDT-426 Use a secret for AdminUserName, use DOMAIN_UID environment variable consistently

* JIRA WDT-426 Define secret model tokens and references consistently

* JIRA WDT-426 Use JDBC secret name for vz config; refactor format_variable_name() into variable_injector_functions.py

* JIRA WDT-426 Create additional output in discover before variables have been inserted

* JIRA WDT-426 Use shared method to calculate server count for clusters

* JIRA WDT-426 Remove unused method

* JIRA WDT-426 Check credential secret flag before updating model; fixed problem with prepareModel properties

* JIRA WDT-426 Revise secrets scripts to support paired secrets; added comments

* JIRA WDT-426 Use object for target configuration

* JIRA WDT-426 Just create secrets in prepareModel; corrected admin secret name

* JIRA WDT-426 Changed name to target configuration throughout

* JIRA WDT-426 Check before creating secrets script; add config_override_secrets flag

* JIRA WDT-426 Use ".password" for paired secret password fields

* JIRA WDT-426 Fixed problem when no target

* JIRA WDT-426 Use password placeholder in model for config_override_secrets

* JIRA WDT-426 Added comments, changed parameter name, for __check_and_customize_model()

* JIRA WDT-426 Corrected method name

* JIRA WDT-426 Use credentials_method property to determine handling

* JIRA WDT-426 Leave credential fields unchanged if credential method not specified

* JIRA WDT-426 Change admin user and password secret names to 'username' and 'password'

* JIRA WDT-426 Leave credential fields unchanged if credential method not specified

* add vz required fields for models
update component name in binding file
update discovery where url may have '&' and needs to be encoded back

* change default logHome location

* update logHome location and remove default channel ports

* JIRA WDT-426 Don't XML encode JDBC URL

* JIRA WDT-426 Use "password" key for all secrets, improve script comments

* JIRA WDT-426 Use "credentials_method" in doc and comments

* JIRA WDT-426 Remove "replicas" from binding model

Co-authored-by: Johnny Shum <cbdream99@gmail.com>

Author: rakillen

core/pom.xml

@@ -85,6 +85,7 @@
                 <includes>
                     <include>oracle/**/*.json</include>
                     <include>oracle/**/*.properties</include>
+                    <include>oracle/**/*.yaml</include>
                 </includes>
                 <filtering>false</filtering>
             </resource>

core/src/main/python/discover.py

@@ -1,5 +1,5 @@
 """
-Copyright (c) 2017, 2020, Oracle Corporation and/or its affiliates.  All rights reserved.
+Copyright (c) 2017, 2020, 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.
@@ -44,7 +44,6 @@
 from wlsdeploy.tool.util.wlst_helper import WlstHelper
 from wlsdeploy.tool.validate.validator import Validator
 from wlsdeploy.util import cla_helper
-from wlsdeploy.util import dictionary_utils
 from wlsdeploy.util import model_translator
 from wlsdeploy.util import path_utils
 from wlsdeploy.util import tool_exit
@@ -93,30 +92,13 @@ def __process_args(args):
     argument_map = cla_util.process_args(args)
 
     __wlst_mode = cla_helper.process_online_args(argument_map)
-    __process_target_arg(argument_map)
+    target_configuration_helper.process_target_arguments(argument_map)
     __process_archive_filename_arg(argument_map)
     __process_variable_filename_arg(argument_map)
     __process_java_home(argument_map)
 
     return model_context_helper.create_context(_program_name, argument_map)
 
-def __process_target_arg(optional_arg_map):
-
-    _method_name = '__process_target_arg'
-
-    if CommandLineArgUtil.TARGET_SWITCH in optional_arg_map:
-        # if -target is specified -output_dir is required
-        output_dir = dictionary_utils.get_element(optional_arg_map, CommandLineArgUtil.OUTPUT_DIR_SWITCH)
-        if (output_dir is None) or (not os.path.isdir(output_dir)):
-            ex = exception_helper.create_cla_exception('WLSDPLY-01642', output_dir)
-            __logger.throwing(ex, class_name=_class_name, method_name=_method_name)
-            raise ex
-
-        # Set the -variable_file parameter if not present with default
-
-        if CommandLineArgUtil.VARIABLE_FILE_SWITCH not in optional_arg_map:
-            optional_arg_map[CommandLineArgUtil.VARIABLE_FILE_SWITCH] = os.path.join(output_dir,
-                                                                                     "k8s_variable.properties")
 
 def __process_archive_filename_arg(required_arg_map):
     """
@@ -409,11 +391,14 @@ def __persist_model(model, model_context):
     return
 
 
-def __check_and_customize_model(model, model_context, aliases, injector):
+def __check_and_customize_model(model, model_context, aliases, password_injector):
     """
     Customize the model dictionary before persisting. Validate the model after customization for informational
     purposes. Any validation errors will not stop the discovered model to be persisted.
-    :param model: completely discovered model
+    :param model: completely discovered model, before any tokenization
+    :param model_context: configuration from command-line
+    :param aliases: used for validation if model changes are made
+    :param password_injector: injector created to collect and tokenize passwords, possibly None
     """
     _method_name = '__check_and_customize_model'
     __logger.entering(class_name=_class_name, method_name=_method_name)
@@ -422,20 +407,24 @@ def __check_and_customize_model(model, model_context, aliases, injector):
         __logger.info('WLSDPLY-06014', _class_name=_class_name, method_name=_method_name)
 
     cache = None
-    if injector is not None:
-        cache = injector.get_variable_cache()
-        # Generate k8s create secret script, after that clear the dictionary to avoid showing up in the variable file
+    if password_injector is not None:
+        cache = password_injector.get_variable_cache()
+
+        # Generate k8s create secret script, possibly using lax validation method
         if model_context.is_targetted_config():
-            validation_method = model_context.get_target_configuration()['validation_method']
+            validation_method = model_context.get_target_configuration().get_validation_method()
             model_context.set_validation_method(validation_method)
-            target_configuration_helper.generate_k8s_script(model_context.get_kubernetes_variable_file(), cache)
-            cache.clear()
+            target_configuration_helper.generate_k8s_script(model_context, cache, model.get_model())
 
+            # if target handles password substitution, clear property cache to keep out of variables file.
+            if model_context.get_target_configuration().manages_credentials():
+                cache.clear()
+
+    # Apply the injectors specified in model_variable_injector.json, or in the target configuration
     variable_injector = VariableInjector(_program_name, model.get_model(), model_context,
-                     WebLogicHelper(__logger).get_actual_weblogic_version(), cache)
+                                         WebLogicHelper(__logger).get_actual_weblogic_version(), cache)
 
-    inserted, variable_model, variable_file_name = \
-        variable_injector.inject_variables_keyword_file()
+    inserted, variable_model, variable_file_name = variable_injector.inject_variables_keyword_file()
 
     if inserted:
         model = Model(variable_model)
@@ -509,16 +498,22 @@ def main(args):
         __logger.info('WLSDPLY-06025', class_name=_class_name, method_name=_method_name)
     else:
         __logger.info('WLSDPLY-06024', class_name=_class_name, method_name=_method_name)
+
     try:
         model = __discover(model_context, aliases, discover_injector, helper)
+
+        if model_context.is_targetted_config():
+            # do this before variables have been inserted into model
+            target_configuration_helper.create_additional_output(model, model_context, aliases, ExceptionType.DISCOVER)
+
+        model = __check_and_customize_model(model, model_context, aliases, discover_injector)
+
     except DiscoverException, ex:
         __logger.severe('WLSDPLY-06011', _program_name, model_context.get_domain_name(),
                         model_context.get_domain_home(), ex.getLocalizedMessage(),
                         error=ex, class_name=_class_name, method_name=_method_name)
         __log_and_exit(model_context, CommandLineArgUtil.PROG_ERROR_EXIT_CODE, _class_name, _method_name)
 
-    model = __check_and_customize_model(model, model_context, aliases, discover_injector)
-    
     try:
         __persist_model(model, model_context)