| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache license, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the license for the specific language governing permissions and |
| * limitations under the license. |
| */ |
| package org.apache.logging.log4j.core.config.composite; |
| |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| |
| import org.apache.logging.log4j.Level; |
| import org.apache.logging.log4j.core.Filter; |
| import org.apache.logging.log4j.core.config.AbstractConfiguration; |
| import org.apache.logging.log4j.core.config.Node; |
| import org.apache.logging.log4j.core.config.plugins.util.PluginManager; |
| import org.apache.logging.log4j.core.config.plugins.util.PluginType; |
| import org.apache.logging.log4j.core.filter.CompositeFilter; |
| |
| /** |
| * The default merge strategy for composite configurations. |
| * <p> |
| * The default merge strategy performs the merge according to the following rules: |
| * <ol> |
| * <li>Aggregates the global configuration attributes with those in later configurations replacing those in previous |
| * configurations with the exception that the highest status level and the lowest monitorInterval greater than 0 will |
| * be used.</li> |
| * <li>Properties from all configurations are aggregated. Duplicate properties replace those in previous |
| * configurations.</li> |
| * <li>Filters are aggregated under a CompositeFilter if more than one Filter is defined. Since Filters are not named |
| * duplicates may be present.</li> |
| * <li>Scripts and ScriptFile references are aggregated. Duplicate definiations replace those in previous |
| * configurations.</li> |
| * <li>Appenders are aggregated. Appenders with the same name are replaced by those in later configurations, including |
| * all of the Appender's subcomponents.</li> |
| * <li>Loggers are all aggregated. Logger attributes are individually merged with duplicates being replaced by those |
| * in later configurations. Appender references on a Logger are aggregated with duplicates being replaced by those in |
| * later configurations. Filters on a Logger are aggregated under a CompositeFilter if more than one Filter is defined. |
| * Since Filters are not named duplicates may be present. Filters under Appender references included or discarded |
| * depending on whether their parent Appender reference is kept or discarded.</li> |
| * </ol> |
| */ |
| public class DefaultMergeStrategy implements MergeStrategy { |
| |
| private static final String APPENDERS = "appenders"; |
| private static final String PROPERTIES = "properties"; |
| private static final String LOGGERS = "loggers"; |
| private static final String SCRIPTS = "scripts"; |
| private static final String FILTERS = "filters"; |
| private static final String STATUS = "status"; |
| private static final String NAME = "name"; |
| private static final String REF = "ref"; |
| |
| /** |
| * Merge the root properties. |
| * @param rootNode The composite root node. |
| * @param configuration The configuration to merge. |
| */ |
| @Override |
| public void mergeRootProperties(final Node rootNode, final AbstractConfiguration configuration) { |
| for (final Map.Entry<String, String> attribute : configuration.getRootNode().getAttributes().entrySet()) { |
| boolean isFound = false; |
| for (final Map.Entry<String, String> targetAttribute : rootNode.getAttributes().entrySet()) { |
| if (targetAttribute.getKey().equalsIgnoreCase(attribute.getKey())) { |
| if (attribute.getKey().equalsIgnoreCase(STATUS)) { |
| final Level targetLevel = Level.getLevel(targetAttribute.getValue().toUpperCase()); |
| final Level sourceLevel = Level.getLevel(attribute.getValue().toUpperCase()); |
| if (targetLevel != null && sourceLevel != null) { |
| if (sourceLevel.isLessSpecificThan(targetLevel)) { |
| targetAttribute.setValue(attribute.getValue()); |
| } |
| } else |
| if (sourceLevel != null) { |
| targetAttribute.setValue(attribute.getValue()); |
| } |
| } else { |
| if (attribute.getKey().equalsIgnoreCase("monitorInterval")) { |
| final int sourceInterval = Integer.parseInt(attribute.getValue()); |
| final int targetInterval = Integer.parseInt(targetAttribute.getValue()); |
| if (targetInterval == 0 || sourceInterval < targetInterval) { |
| targetAttribute.setValue(attribute.getValue()); |
| } |
| } else { |
| targetAttribute.setValue(attribute.getValue()); |
| } |
| } |
| isFound = true; |
| } |
| } |
| if (!isFound) { |
| rootNode.getAttributes().put(attribute.getKey(), attribute.getValue()); |
| } |
| } |
| } |
| |
| /** |
| * Merge the source Configuration into the target Configuration. |
| * |
| * @param target The target node to merge into. |
| * @param source The source node. |
| * @param pluginManager The PluginManager. |
| */ |
| @Override |
| public void mergConfigurations(final Node target, final Node source, final PluginManager pluginManager) { |
| for (final Node sourceChildNode : source.getChildren()) { |
| final boolean isFilter = isFilterNode(sourceChildNode); |
| boolean isMerged = false; |
| for (final Node targetChildNode : target.getChildren()) { |
| if (isFilter) { |
| if (isFilterNode(targetChildNode)) { |
| updateFilterNode(target, targetChildNode, sourceChildNode, pluginManager); |
| isMerged = true; |
| break; |
| } |
| continue; |
| } |
| |
| if (!targetChildNode.getName().equalsIgnoreCase(sourceChildNode.getName())) { |
| continue; |
| } |
| |
| switch (targetChildNode.getName().toLowerCase()) { |
| case PROPERTIES: |
| case SCRIPTS: |
| case APPENDERS: { |
| for (final Node node : sourceChildNode.getChildren()) { |
| for (final Node targetNode : targetChildNode.getChildren()) { |
| if (Objects.equals(targetNode.getAttributes().get(NAME), node.getAttributes().get(NAME))) { |
| targetChildNode.getChildren().remove(targetNode); |
| break; |
| } |
| } |
| targetChildNode.getChildren().add(node); |
| } |
| isMerged = true; |
| break; |
| } |
| case LOGGERS: { |
| final Map<String, Node> targetLoggers = new HashMap<>(); |
| for (final Node node : targetChildNode.getChildren()) { |
| targetLoggers.put(node.getName(), node); |
| } |
| for (final Node node : sourceChildNode.getChildren()) { |
| final Node targetNode = getLoggerNode(targetChildNode, node.getAttributes().get(NAME)); |
| final Node loggerNode = new Node(targetChildNode, node.getName(), node.getType()); |
| if (targetNode != null) { |
| targetNode.getAttributes().putAll(node.getAttributes()); |
| for (final Node sourceLoggerChild : node.getChildren()) { |
| if (isFilterNode(sourceLoggerChild)) { |
| boolean foundFilter = false; |
| for (final Node targetChild : targetNode.getChildren()) { |
| if (isFilterNode(targetChild)) { |
| updateFilterNode(loggerNode, targetChild, sourceLoggerChild, |
| pluginManager); |
| foundFilter = true; |
| break; |
| } |
| } |
| if (!foundFilter) { |
| final Node childNode = new Node(loggerNode, sourceLoggerChild.getName(), |
| sourceLoggerChild.getType()); |
| childNode.getAttributes().putAll(sourceLoggerChild.getAttributes()); |
| childNode.getChildren().addAll(sourceLoggerChild.getChildren()); |
| targetNode.getChildren().add(childNode); |
| } |
| } else { |
| final Node childNode = new Node(loggerNode, sourceLoggerChild.getName(), |
| sourceLoggerChild.getType()); |
| childNode.getAttributes().putAll(sourceLoggerChild.getAttributes()); |
| childNode.getChildren().addAll(sourceLoggerChild.getChildren()); |
| if (childNode.getName().equalsIgnoreCase("AppenderRef")) { |
| for (final Node targetChild : targetNode.getChildren()) { |
| if (isSameReference(targetChild, childNode)) { |
| targetNode.getChildren().remove(targetChild); |
| break; |
| } |
| } |
| } else { |
| for (final Node targetChild : targetNode.getChildren()) { |
| if (isSameName(targetChild, childNode)) { |
| targetNode.getChildren().remove(targetChild); |
| break; |
| } |
| } |
| } |
| |
| targetNode.getChildren().add(childNode); |
| } |
| } |
| } else { |
| loggerNode.getAttributes().putAll(node.getAttributes()); |
| loggerNode.getChildren().addAll(node.getChildren()); |
| targetChildNode.getChildren().add(loggerNode); |
| } |
| } |
| isMerged = true; |
| break; |
| } |
| default: { |
| targetChildNode.getChildren().addAll(sourceChildNode.getChildren()); |
| isMerged = true; |
| break; |
| } |
| |
| } |
| } |
| if (!isMerged) { |
| if (sourceChildNode.getName().equalsIgnoreCase("Properties")) { |
| target.getChildren().add(0, sourceChildNode); |
| } else { |
| target.getChildren().add(sourceChildNode); |
| } |
| } |
| } |
| } |
| |
| private Node getLoggerNode(final Node parentNode, final String name) { |
| for (final Node node : parentNode.getChildren()) { |
| final String nodeName = node.getAttributes().get(NAME); |
| if (name == null && nodeName == null) { |
| return node; |
| } |
| if (nodeName != null && nodeName.equals(name)) { |
| return node; |
| } |
| } |
| return null; |
| } |
| |
| private void updateFilterNode(final Node target, final Node targetChildNode, final Node sourceChildNode, |
| final PluginManager pluginManager) { |
| if (CompositeFilter.class.isAssignableFrom(targetChildNode.getType().getPluginClass())) { |
| final Node node = new Node(targetChildNode, sourceChildNode.getName(), sourceChildNode.getType()); |
| node.getChildren().addAll(sourceChildNode.getChildren()); |
| node.getAttributes().putAll(sourceChildNode.getAttributes()); |
| targetChildNode.getChildren().add(node); |
| } else { |
| final PluginType pluginType = pluginManager.getPluginType(FILTERS); |
| final Node filtersNode = new Node(targetChildNode, FILTERS, pluginType); |
| final Node node = new Node(filtersNode, sourceChildNode.getName(), sourceChildNode.getType()); |
| node.getAttributes().putAll(sourceChildNode.getAttributes()); |
| final List<Node> children = filtersNode.getChildren(); |
| children.add(targetChildNode); |
| children.add(node); |
| final List<Node> nodes = target.getChildren(); |
| nodes.remove(targetChildNode); |
| nodes.add(filtersNode); |
| } |
| } |
| |
| private boolean isFilterNode(final Node node) { |
| return Filter.class.isAssignableFrom(node.getType().getPluginClass()); |
| } |
| |
| private boolean isSameName(final Node node1, final Node node2) { |
| final String value = node1.getAttributes().get(NAME); |
| return value != null && value.toLowerCase().equals(node2.getAttributes().get(NAME).toLowerCase()); |
| } |
| |
| private boolean isSameReference(final Node node1, final Node node2) { |
| final String value = node1.getAttributes().get(REF); |
| return value != null && value.toLowerCase().equals(node2.getAttributes().get(REF).toLowerCase()); |
| } |
| } |
