Merge pull request #30 from oracle/issue#27-add-filter-capability

Issue#27 add filter capability

Author: ddsharpe

core/src/main/python/create.py

@@ -32,6 +32,7 @@
 from wlsdeploy.logging.platform_logger import PlatformLogger
 from wlsdeploy.tool.create.domain_creator import DomainCreator
 from wlsdeploy.tool.create.domain_typedef import DomainTypedef
+from wlsdeploy.tool.util import filter_helper
 from wlsdeploy.tool.validate.validator import Validator
 from wlsdeploy.util import getcreds
 from wlsdeploy.util import variables
@@ -66,6 +67,7 @@
     CommandLineArgUtil.PASSPHRASE_SWITCH
 ]
 
+
 def __process_args(args):
     """
     Process the command-line arguments and prompt the user for any missing information
@@ -95,6 +97,7 @@ def __process_args(args):
     domain_typedef.set_model_context(model_context)
     return model_context
 
+
 def __verify_required_args_present(required_arg_map):
     """
     Verify that the required args are present.
@@ -111,6 +114,7 @@ def __verify_required_args_present(required_arg_map):
             raise ex
     return
 
+
 def __process_java_home_arg(optional_arg_map):
     """
     Verify that java_home is set.  If not, set it.
@@ -132,6 +136,7 @@ def __process_java_home_arg(optional_arg_map):
         optional_arg_map[CommandLineArgUtil.JAVA_HOME_SWITCH] = java_home.getAbsolutePath()
     return
 
+
 def __process_model_args(optional_arg_map):
     """
     Verify that either the model_file or archive_file was provided and exists.
@@ -176,6 +181,7 @@ def __process_model_args(optional_arg_map):
         raise ex
     return
 
+
 def __process_rcu_args(optional_arg_map, domain_type, domain_typedef):
     """
     Determine if the RCU is needed and validate/prompt for any missing information
@@ -234,6 +240,7 @@ def __process_rcu_args(optional_arg_map, domain_type, domain_typedef):
             raise ex
     return
 
+
 def __process_encryption_args(optional_arg_map):
     """
     Determine if the user is using our encryption and if so, get the passphrase.
@@ -255,6 +262,7 @@ def __process_encryption_args(optional_arg_map):
         optional_arg_map[CommandLineArgUtil.PASSPHRASE_SWITCH] = String(passphrase)
     return
 
+
 def __clean_up_temp_files():
     """
     If a temporary directory was created to extract the model from the archive, delete the directory and its contents.
@@ -265,6 +273,28 @@ def __clean_up_temp_files():
         FileUtils.deleteDirectory(__tmp_model_dir)
         __tmp_model_dir = None
 
+
+def validate_model(model_dictionary, model_context, aliases):
+    _method_name = 'validate_model'
+
+    try:
+        validator = Validator(model_context, aliases, wlst_mode=__wlst_mode)
+
+        # no need to pass the variable file for processing, substitution has already been performed
+        return_code = validator.validate_in_tool_mode(model_dictionary, variables_file_name=None,
+                                                      archive_file_name=model_context.get_archive_file_name())
+    except ValidateException, ex:
+        __logger.severe('WLSDPLY-20000', _program_name, ex.getLocalizedMessage(), error=ex,
+                        class_name=_class_name, method_name=_method_name)
+        __clean_up_temp_files()
+        sys.exit(CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
+
+    if return_code == Validator.ReturnCode.STOP:
+        __logger.severe('WLSDPLY-20001', _program_name, class_name=_class_name, method_name=_method_name)
+        __clean_up_temp_files()
+        sys.exit(CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
+
+
 def main():
     """
     The entry point for the create domain tool.
@@ -306,26 +336,12 @@ def main():
             __clean_up_temp_files()
             sys.exit(CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
 
-    try:
-        aliases = Aliases(model_context, wlst_mode=__wlst_mode)
-        validator = Validator(model_context, aliases, wlst_mode=__wlst_mode)
+    aliases = Aliases(model_context, wlst_mode=__wlst_mode)
+    validate_model(model, model_context, aliases)
 
-        # Since the have already performed all variable substitution,
-        # no need to pass the variable file for processing.
-        #
-        return_code = validator.validate_in_tool_mode(model,
-                                                      variables_file_name=None,
-                                                      archive_file_name=model_context.get_archive_file_name())
-    except ValidateException, ex:
-        __logger.severe('WLSDPLY-20000', _program_name, ex.getLocalizedMessage(), error=ex,
-                        class_name=_class_name, method_name=_method_name)
-        __clean_up_temp_files()
-        sys.exit(CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
-
-    if return_code == Validator.ReturnCode.STOP:
-        __logger.severe('WLSDPLY-20001', _program_name, class_name=_class_name, method_name=_method_name)
-        __clean_up_temp_files()
-        sys.exit(CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
+    if filter_helper.apply_filters(model, "create"):
+        # if any filters were applied, re-validate the model
+        validate_model(model, model_context, aliases)
 
     try:
         creator = DomainCreator(model, model_context, aliases)

core/src/main/python/deploy.py

@@ -35,6 +35,7 @@
 from wlsdeploy.tool.deploy import deployer_utils
 from wlsdeploy.tool.deploy import model_deployer
 from wlsdeploy.tool.validate.validator import Validator
+from wlsdeploy.tool.util import filter_helper
 from wlsdeploy.tool.util.wlst_helper import WlstHelper
 from wlsdeploy.util import getcreds
 from wlsdeploy.util import variables
@@ -392,6 +393,27 @@ def __clean_up_temp_files():
         __tmp_model_dir = None
 
 
+def validate_model(model_dictionary, model_context, aliases):
+    _method_name = 'validate_model'
+
+    try:
+        validator = Validator(model_context, aliases, wlst_mode=__wlst_mode)
+
+        # no need to pass the variable file for processing, substitution has already been performed
+        return_code = validator.validate_in_tool_mode(model_dictionary, variables_file_name=None,
+                                                      archive_file_name=model_context.get_archive_file_name())
+    except ValidateException, ex:
+        __logger.severe('WLSDPLY-20000', _program_name, ex.getLocalizedMessage(), error=ex,
+                        class_name=_class_name, method_name=_method_name)
+        __clean_up_temp_files()
+        sys.exit(CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
+
+    if return_code == Validator.ReturnCode.STOP:
+        __logger.severe('WLSDPLY-20001', _program_name, class_name=_class_name, method_name=_method_name)
+        __clean_up_temp_files()
+        sys.exit(CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
+
+
 def main():
     """
     The python entry point for deployApps.
@@ -433,25 +455,12 @@ def main():
             __clean_up_temp_files()
             sys.exit(CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
 
-    try:
-        aliases = Aliases(model_context, wlst_mode=__wlst_mode)
-        validator = Validator(model_context, aliases, wlst_mode=__wlst_mode)
-
-        # Since the have already performed all variable substitution,
-        # no need to pass the variable file for processing.
-        #
-        return_code = validator.validate_in_tool_mode(model_dictionary, variables_file_name=None,
-                                                      archive_file_name=model_context.get_archive_file_name())
-    except ValidateException, ex:
-        __logger.severe('WLSDPLY-20000', _program_name, ex.getLocalizedMessage(), error=ex,
-                        class_name=_class_name, method_name=_method_name)
-        __clean_up_temp_files()
-        sys.exit(CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
+    aliases = Aliases(model_context, wlst_mode=__wlst_mode)
+    validate_model(model_dictionary, model_context, aliases)
 
-    if return_code == Validator.ReturnCode.STOP:
-        __logger.severe('WLSDPLY-20001', _program_name, class_name=_class_name, method_name=_method_name)
-        __clean_up_temp_files()
-        sys.exit(CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
+    if filter_helper.apply_filters(model_dictionary, "deploy"):
+        # if any filters were applied, re-validate the model
+        validate_model(model_dictionary, model_context, aliases)
 
     try:
         model = Model(model_dictionary)

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

@@ -0,0 +1,122 @@
+"""
+Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.
+The Universal Permissive License (UPL), Version 1.0
+"""
+import imp
+import javaos as os
+import sys
+
+from wlsdeploy.logging.platform_logger import PlatformLogger
+from wlsdeploy.util import dictionary_utils
+from wlsdeploy.util.model_translator import FileToPython
+
+__class_name = 'filter_helper'
+__logger = PlatformLogger('wlsdeploy.wlst')
+__filter_file_location = os.path.join(os.environ.get('WLSDEPLOY_HOME'), 'lib', 'model_filters.json')
+
+__id_filter_map = {
+    # 'filterId': filter_method
+}
+
+
+def apply_filters(model, tool_type):
+    """
+    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
+    :return: True if any filter was applied, False otherwise
+    :raises: BundleAwareException of the specified type: if an error occurs
+    """
+    _method_name = 'apply_filters'
+
+    filter_applied = False
+
+    try:
+        if os.path.isfile(__filter_file_location):
+            filters_dictionary = FileToPython(__filter_file_location).parse()
+
+            if tool_type in filters_dictionary:
+                filter_list = filters_dictionary[tool_type]
+                for filter in filter_list:
+                    filter_applied = _apply_filter(model, filter) or filter_applied
+            else:
+                __logger.info('WLSDPLY-20016', tool_type, __filter_file_location, class_name=__class_name,
+                              method_name=_method_name)
+        else:
+            __logger.info('WLSDPLY-20017', __filter_file_location, class_name=__class_name, method_name=_method_name)
+    except Exception, ex:
+        __logger.severe('WLSDPLY-20018', str(ex), error=ex, class_name=__class_name, method_name=_method_name)
+
+    return filter_applied
+
+
+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
+    :return: True if the specified filter was applied, False otherwise
+    :raises: BundleAwareException of the specified type: if an error occurs
+    """
+    _method_name = '_apply_filter'
+    id = dictionary_utils.get_element(the_filter, 'id')
+    if id is not None:
+        return _apply_id_filter(model, id)
+
+    path = dictionary_utils.get_element(the_filter, 'path')
+    if path is not None:
+        return _apply_path_filter(model, path)
+
+    __logger.severe('WLSDPLY-20019', str(__filter_file_location), class_name=__class_name, method_name=_method_name)
+    return False
+
+
+def _apply_id_filter(model, id):
+    """
+    Apply the specified ID filter to the specified model.
+    :param model: the model to be filtered
+    :param id: the ID of the filter to be applied
+    :return: True if the specified filter was applied, False otherwise
+    :raises: BundleAwareException of the specified type: if an error occurs
+    """
+    _method_name = '_apply_id_filter'
+
+    filter_method = dictionary_utils.get_element(__id_filter_map, id)
+    if filter_method is None:
+        __logger.severe('WLSDPLY-20020', str(id), class_name=__class_name, method_name=_method_name)
+        return False
+    else:
+        filter_method(model)
+        return True
+
+
+def _apply_path_filter(model, script_path):
+    """
+    Apply the specified path filter to the specified model.
+    :param model: the model to be filtered
+    :param script_path: the path of the filter to be applied
+    :return: True if the specified filter was applied, False otherwise
+    :raises: BundleAwareException of the specified type: if an error occurs
+    """
+    _method_name = '_apply_path_filter'
+
+    if not os.path.isfile(script_path):
+        __logger.severe('WLSDPLY-20021', str(script_path), class_name=__class_name, method_name=_method_name)
+        return False
+
+    python_path = os.path.dirname(script_path)
+    path_present = python_path in sys.path
+    if not path_present:
+        sys.path.insert(0, python_path)
+
+    try:
+        module = imp.load_source('filter_script', script_path)
+        module.filter_model(model)
+        if not path_present:
+            sys.path.remove(python_path)
+        return True
+
+    except Exception, ex:
+        __logger.severe('WLSDPLY-20022', str(script_path), error=ex, class_name=__class_name, method_name=_method_name)
+
+    return False

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

@@ -1107,3 +1107,10 @@ WLSDPLY-20012=No WLST value for model attribute {0} value {1}
 WLSDPLY-20013=Updating {0}
 WLSDPLY-20014={0} requires the archive file argument {1} to be an existing file: {2}
 WLSDPLY-20015={0} requires a model file to run but neither the {1} or {2} argument were provided
+WLSDPLY-20016=No filters of type {0} found in filter configuration file {1}
+WLSDPLY-20017=No filter configuration file {0}
+WLSDPLY-20018=Error applying filter configuration: {0}
+WLSDPLY-20019=Filter entry in {0} has neither ID or path
+WLSDPLY-20020=Filter ID {0} is invalid
+WLSDPLY-20021=Filter path {0} does not exist
+WLSDPLY-20022=Error loading filter path {0}