WDT_CUSTOM_CONFIG variable, alternate config dir (#638)

* Issue #371 - Allow alternate configuration dir for typedefs

* Issue #371 - Allow alternate configuration dir for model filters definition; log when custom file is used

* Issue #371 - Allow alternate configuration dir for injectors; modify unit test to use WDT_CUSTOM_CONFIG variable

* Issue #371 - Clarify which injector files are used at INFO logging level

* Issue #371 - Use custom configuration dir for target model filters; fixed error checks and messages

* Issue #371 - Use custom configuration dir for target configuration file

Author: rakillen

core/src/main/python/discover.py

@@ -44,6 +44,7 @@
 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
@@ -105,12 +106,11 @@ def __process_target_arg(optional_arg_map):
 
     if CommandLineArgUtil.TARGET_SWITCH in optional_arg_map:
         # if -target is specified -output_dir is required
-        output_dir = optional_arg_map[CommandLineArgUtil.OUTPUT_DIR_SWITCH]
-        if output_dir is None or os.path.isdir(output_dir) is False:
-            if 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
+        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
 

core/src/main/python/variable_inject.py

@@ -33,9 +33,6 @@
 _class_name = 'variable_inject'
 __logger = PlatformLogger('wlsdeploy.tool.util')
 __wlst_mode = WlstModes.OFFLINE
-__kwargs = dict()
-__inserted = False
-__tmp_model_dir = None
 
 __required_arguments = [
     CommandLineArgUtil.ORACLE_HOME_SWITCH
@@ -64,50 +61,25 @@ def __process_args(args):
 
     # determine if the model file was passed separately or requires extraction from the archive.
     cla_helper.validate_model_present(_program_name, argument_map)
-    __process_injector_file(argument_map)
-    __process_keywords_file(argument_map)
-    __process_properties_file(argument_map)
 
     return model_context_helper.create_context(_program_name, argument_map)
 
 
-def __process_injector_file(optional_arg_map):
-    _method_name = '__process_injector_file'
-    if CommandLineArgUtil.VARIABLE_INJECTOR_FILE_SWITCH in optional_arg_map:
-        injector = optional_arg_map[CommandLineArgUtil.VARIABLE_INJECTOR_FILE_SWITCH]
-        __logger.fine('WLSDPLY-19600', injector, class_name=_class_name, method_name=_method_name)
-        __kwargs[variable_injector.VARIABLE_INJECTOR_FILE_NAME_ARG] = injector
-
-
-def __process_keywords_file(optional_arg_map):
-    _method_name = '__process_keywords_file'
-    if CommandLineArgUtil.VARIABLE_KEYWORDS_FILE_SWITCH in optional_arg_map:
-        keywords = optional_arg_map[CommandLineArgUtil.VARIABLE_KEYWORDS_FILE_SWITCH]
-        __logger.fine('WLSDPLY-19601', keywords, class_name=_class_name, method_name=_method_name)
-        __kwargs[variable_injector.VARIABLE_KEYWORDS_FILE_NAME_ARG] = keywords
-
-
-def __process_properties_file(optional_arg_map):
-    _method_name = '__process_properties_file'
-    if CommandLineArgUtil.VARIABLE_PROPERTIES_FILE_SWITCH in optional_arg_map:
-        properties = optional_arg_map[CommandLineArgUtil.VARIABLE_PROPERTIES_FILE_SWITCH]
-        __logger.fine('WLSDPLY-19602', properties, class_name=_class_name, method_name=_method_name)
-        __kwargs[variable_injector.VARIABLE_FILE_NAME_ARG] = properties
-
-
 def __inject(model, model_context):
     """
     Inject variables into the model file that is loaded into the model_context.
     :param model_context: the model context
     :return: True if variables were inserted into model: The updated model
     """
-    __kwargs[variable_injector.VARIABLE_FILE_APPEND_ARG] = variable_injector.VARIABLE_FILE_UPDATE
-    inserted, variable_model, variable_file_name = VariableInjector(_program_name, model, model_context,
-                                                                    WebLogicHelper(
-                                                                        __logger).get_actual_weblogic_version()). \
-        inject_variables_keyword_file(**__kwargs)
+    version = WebLogicHelper(__logger).get_actual_weblogic_version()
+    injector = VariableInjector(_program_name, model, model_context, version)
+
+    inserted, variable_model, variable_file_name =\
+        injector.inject_variables_keyword_file(append_option=variable_injector.VARIABLE_FILE_UPDATE)
+
     if inserted:
         model = Model(variable_model)
+
     return inserted, model
 
 

core/src/main/python/wlsdeploy/tool/create/domain_typedef.py

@@ -1,5 +1,5 @@
 """
-Copyright (c) 2017, 2019, Oracle Corporation and/or its affiliates.  All rights reserved.
+Copyright (c) 2017, 2020, Oracle Corporation and/or its affiliates.  All rights reserved.
 Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
 """
 import os
@@ -13,6 +13,7 @@
 from wlsdeploy.json.json_translator import JsonToPython
 from wlsdeploy.logging.platform_logger import PlatformLogger
 from wlsdeploy.tool.util.targeting_types import TargetingType
+from wlsdeploy.util import path_utils
 from wlsdeploy.util.cla_utils import CommandLineArgUtil
 from wlsdeploy.util.weblogic_helper import WebLogicHelper
 
@@ -27,7 +28,6 @@ class DomainTypedef(object):
     """
     __class_name = 'DomainTypedef'
 
-    __domain_typedefs_location = os.path.join(os.environ.get('WLSDEPLOY_HOME'), 'lib', 'typedefs')
     __domain_typedef_extension = '.json'
 
     JRF_TEMPLATE_REGEX = "^(.*jrf_template[0-9._]*\\.jar)|(Oracle JRF WebServices Asynchronous services)$"
@@ -47,8 +47,9 @@ def __init__(self, program_name, domain_type):
         self._domain_type = domain_type
         self.wls_helper = WebLogicHelper(self._logger)
 
-        self._domain_typedef_filename = \
-            os.path.join(self.__domain_typedefs_location, domain_type + self.__domain_typedef_extension)
+        file_name = domain_type + self.__domain_typedef_extension
+        self._domain_typedef_filename = path_utils.find_config_path(os.path.join('typedefs', file_name))
+
         # No need to explicitly validate the filename since the JsonToPython constructor does that...
         try:
             json_parser = JsonToPython(self._domain_typedef_filename)
@@ -360,7 +361,7 @@ def __resolve_paths(self):
                 self._domain_typedef['serverGroupsToTarget'] = []
 
             if 'dynamicClusterServerGroupsToTarget' not in self._domain_typedef:
-                self._domain_typedef['dynamicClusterServerGroupsToTarget'] = [ ]
+                self._domain_typedef['dynamicClusterServerGroupsToTarget'] = []
 
             if 'rcuSchemas' not in self._domain_typedef:
                 self._domain_typedef['rcuSchemas'] = []

core/src/main/python/wlsdeploy/tool/util/filter_helper.py

@@ -8,11 +8,13 @@
 
 from wlsdeploy.logging.platform_logger import PlatformLogger
 from wlsdeploy.util import dictionary_utils
+from wlsdeploy.util import path_utils
 from wlsdeploy.util.model_translator import FileToPython
 
 __class_name = 'filter_helper'
 __logger = PlatformLogger('wlsdeploy.tool.util')
-__filter_file_location = os.path.join(os.environ.get('WLSDEPLOY_HOME', ''), 'lib', 'model_filters.json')
+
+TARGET_CONFIG_TOKEN = '@@TARGET_CONFIG_DIR@@'
 
 __id_filter_map = {
     # 'filterId': filter_method
@@ -24,29 +26,36 @@ def apply_filters(model, tool_type, model_context=None):
     Apply any filters configured for the specified tool type to the specified model.
     :param model: the model to be filtered
     :param tool_type: the name of the filter tool type
+    :param model_context: optional, used to find target filters
     :return: True if any filter was applied, False otherwise
     :raises: BundleAwareException of the specified type: if an error occurs
     """
     _method_name = 'apply_filters'
+    global __filter_file_location
 
+    __filter_file_location = path_utils.find_config_path('model_filters.json')
     filter_applied = False
-    configuration = None
-
+    target_configuration = None
 
     try:
-        if model_context:
-            configuration = model_context.get_target_configuration()
         filters_dictionary = {}
-        if configuration and 'model_filters' in configuration:
-            filters_dictionary = configuration['model_filters']
-            target_filter_path =  os.path.join(os.environ.get('WLSDEPLOY_HOME', ''), 'lib', 'targets',
-                                               model_context.get_target())
+
+        # if target specified in model context, use the filters from target config
+        if model_context:
+            target_configuration = model_context.get_target_configuration()
+
+        if target_configuration and 'model_filters' in target_configuration:
+            filters_dictionary = target_configuration['model_filters']
+            target_path = os.path.join('targets', model_context.get_target())
+
             # Fix the tokenized path in the filter path
             for filter_list in filters_dictionary:
                 for current_filter in filters_dictionary[filter_list]:
-                    if 'path' in current_filter and current_filter['path'].startswith("@@TARGET_CONFIG_DIR@@/"):
-                        current_filter['path'] = current_filter['path'].replace("@@TARGET_CONFIG_DIR@@",
-                                                                                target_filter_path)
+                    filter_path = dictionary_utils.get_element(current_filter, 'path')
+                    if (filter_path is not None) and filter_path.startswith(TARGET_CONFIG_TOKEN):
+                        filter_path = target_path + filter_path.replace(TARGET_CONFIG_TOKEN, '')
+                        current_filter['path'] = path_utils.find_config_path(filter_path)
+
         elif os.path.isfile(__filter_file_location):
             filters_dictionary = FileToPython(__filter_file_location).parse()
         else:
@@ -70,11 +79,13 @@ def _apply_filter(model, the_filter):
     """
     Apply the specified filter to the specified model.
     :param model: the model to be filtered
-    :param filter: a dictionary containing the filter parameters
+    :param the_filter: a dictionary containing the filter parameters
     :return: True if the specified filter was applied, False otherwise
     :raises: BundleAwareException of the specified type: if an error occurs
     """
     _method_name = '_apply_filter'
+    global __filter_file_location
+
     id = dictionary_utils.get_element(the_filter, 'id')
     if id is not None:
         return _apply_id_filter(model, id)