001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache license, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the license for the specific language governing permissions and 015 * limitations under the license. 016 */ 017package org.apache.logging.log4j.core.config.composite; 018 019import java.util.HashMap; 020import java.util.List; 021import java.util.Map; 022import java.util.Objects; 023 024import org.apache.logging.log4j.Level; 025import org.apache.logging.log4j.core.Filter; 026import org.apache.logging.log4j.core.config.AbstractConfiguration; 027import org.apache.logging.log4j.core.config.Node; 028import org.apache.logging.log4j.core.config.plugins.util.PluginManager; 029import org.apache.logging.log4j.core.config.plugins.util.PluginType; 030import org.apache.logging.log4j.core.filter.CompositeFilter; 031 032/** 033 * The default merge strategy for composite configurations. 034 * <p> 035 * The default merge strategy performs the merge according to the following rules: 036 * <ol> 037 * <li>Aggregates the global configuration attributes with those in later configurations replacing those in previous 038 * configurations with the exception that the highest status level and the lowest monitorInterval greater than 0 will 039 * be used.</li> 040 * <li>Properties from all configurations are aggregated. Duplicate properties replace those in previous 041 * configurations.</li> 042 * <li>Filters are aggregated under a CompositeFilter if more than one Filter is defined. Since Filters are not named 043 * duplicates may be present.</li> 044 * <li>Scripts and ScriptFile references are aggregated. Duplicate definiations replace those in previous 045 * configurations.</li> 046 * <li>Appenders are aggregated. Appenders with the same name are replaced by those in later configurations, including 047 * all of the Appender's subcomponents.</li> 048 * <li>Loggers are all aggregated. Logger attributes are individually merged with duplicates being replaced by those 049 * in later configurations. Appender references on a Logger are aggregated with duplicates being replaced by those in 050 * later configurations. Filters on a Logger are aggregated under a CompositeFilter if more than one Filter is defined. 051 * Since Filters are not named duplicates may be present. Filters under Appender references included or discarded 052 * depending on whether their parent Appender reference is kept or discarded.</li> 053 * </ol> 054 */ 055public class DefaultMergeStrategy implements MergeStrategy { 056 057 private static final String APPENDERS = "appenders"; 058 private static final String PROPERTIES = "properties"; 059 private static final String LOGGERS = "loggers"; 060 private static final String SCRIPTS = "scripts"; 061 private static final String FILTERS = "filters"; 062 private static final String STATUS = "status"; 063 private static final String NAME = "name"; 064 private static final String REF = "ref"; 065 066 /** 067 * Merge the root properties. 068 * @param rootNode The composite root node. 069 * @param configuration The configuration to merge. 070 */ 071 @Override 072 public void mergeRootProperties(final Node rootNode, final AbstractConfiguration configuration) { 073 for (final Map.Entry<String, String> attribute : configuration.getRootNode().getAttributes().entrySet()) { 074 boolean isFound = false; 075 for (final Map.Entry<String, String> targetAttribute : rootNode.getAttributes().entrySet()) { 076 if (targetAttribute.getKey().equalsIgnoreCase(attribute.getKey())) { 077 if (attribute.getKey().equalsIgnoreCase(STATUS)) { 078 final Level targetLevel = Level.getLevel(targetAttribute.getValue().toUpperCase()); 079 final Level sourceLevel = Level.getLevel(attribute.getValue().toUpperCase()); 080 if (targetLevel != null && sourceLevel != null) { 081 if (sourceLevel.isLessSpecificThan(targetLevel)) { 082 targetAttribute.setValue(attribute.getValue()); 083 } 084 } else 085 if (sourceLevel != null) { 086 targetAttribute.setValue(attribute.getValue()); 087 } 088 } else { 089 if (attribute.getKey().equalsIgnoreCase("monitorInterval")) { 090 final int sourceInterval = Integer.parseInt(attribute.getValue()); 091 final int targetInterval = Integer.parseInt(targetAttribute.getValue()); 092 if (targetInterval == 0 || sourceInterval < targetInterval) { 093 targetAttribute.setValue(attribute.getValue()); 094 } 095 } else { 096 targetAttribute.setValue(attribute.getValue()); 097 } 098 } 099 isFound = true; 100 } 101 } 102 if (!isFound) { 103 rootNode.getAttributes().put(attribute.getKey(), attribute.getValue()); 104 } 105 } 106 } 107 108 /** 109 * Merge the source Configuration into the target Configuration. 110 * 111 * @param target The target node to merge into. 112 * @param source The source node. 113 * @param pluginManager The PluginManager. 114 */ 115 @Override 116 public void mergConfigurations(final Node target, final Node source, final PluginManager pluginManager) { 117 for (final Node sourceChildNode : source.getChildren()) { 118 final boolean isFilter = isFilterNode(sourceChildNode); 119 boolean isMerged = false; 120 for (final Node targetChildNode : target.getChildren()) { 121 if (isFilter) { 122 if (isFilterNode(targetChildNode)) { 123 updateFilterNode(target, targetChildNode, sourceChildNode, pluginManager); 124 isMerged = true; 125 break; 126 } 127 continue; 128 } 129 130 if (!targetChildNode.getName().equalsIgnoreCase(sourceChildNode.getName())) { 131 continue; 132 } 133 134 switch (targetChildNode.getName().toLowerCase()) { 135 case PROPERTIES: 136 case SCRIPTS: 137 case APPENDERS: { 138 for (final Node node : sourceChildNode.getChildren()) { 139 for (final Node targetNode : targetChildNode.getChildren()) { 140 if (Objects.equals(targetNode.getAttributes().get(NAME), node.getAttributes().get(NAME))) { 141 targetChildNode.getChildren().remove(targetNode); 142 break; 143 } 144 } 145 targetChildNode.getChildren().add(node); 146 } 147 isMerged = true; 148 break; 149 } 150 case LOGGERS: { 151 final Map<String, Node> targetLoggers = new HashMap<>(); 152 for (final Node node : targetChildNode.getChildren()) { 153 targetLoggers.put(node.getName(), node); 154 } 155 for (final Node node : sourceChildNode.getChildren()) { 156 final Node targetNode = getLoggerNode(targetChildNode, node.getAttributes().get(NAME)); 157 final Node loggerNode = new Node(targetChildNode, node.getName(), node.getType()); 158 if (targetNode != null) { 159 targetNode.getAttributes().putAll(node.getAttributes()); 160 for (final Node sourceLoggerChild : node.getChildren()) { 161 if (isFilterNode(sourceLoggerChild)) { 162 boolean foundFilter = false; 163 for (final Node targetChild : targetNode.getChildren()) { 164 if (isFilterNode(targetChild)) { 165 updateFilterNode(loggerNode, targetChild, sourceLoggerChild, 166 pluginManager); 167 foundFilter = true; 168 break; 169 } 170 } 171 if (!foundFilter) { 172 final Node childNode = new Node(loggerNode, sourceLoggerChild.getName(), 173 sourceLoggerChild.getType()); 174 childNode.getAttributes().putAll(sourceLoggerChild.getAttributes()); 175 childNode.getChildren().addAll(sourceLoggerChild.getChildren()); 176 targetNode.getChildren().add(childNode); 177 } 178 } else { 179 final Node childNode = new Node(loggerNode, sourceLoggerChild.getName(), 180 sourceLoggerChild.getType()); 181 childNode.getAttributes().putAll(sourceLoggerChild.getAttributes()); 182 childNode.getChildren().addAll(sourceLoggerChild.getChildren()); 183 if (childNode.getName().equalsIgnoreCase("AppenderRef")) { 184 for (final Node targetChild : targetNode.getChildren()) { 185 if (isSameReference(targetChild, childNode)) { 186 targetNode.getChildren().remove(targetChild); 187 break; 188 } 189 } 190 } else { 191 for (final Node targetChild : targetNode.getChildren()) { 192 if (isSameName(targetChild, childNode)) { 193 targetNode.getChildren().remove(targetChild); 194 break; 195 } 196 } 197 } 198 199 targetNode.getChildren().add(childNode); 200 } 201 } 202 } else { 203 loggerNode.getAttributes().putAll(node.getAttributes()); 204 loggerNode.getChildren().addAll(node.getChildren()); 205 targetChildNode.getChildren().add(loggerNode); 206 } 207 } 208 isMerged = true; 209 break; 210 } 211 default: { 212 targetChildNode.getChildren().addAll(sourceChildNode.getChildren()); 213 isMerged = true; 214 break; 215 } 216 217 } 218 } 219 if (!isMerged) { 220 if (sourceChildNode.getName().equalsIgnoreCase("Properties")) { 221 target.getChildren().add(0, sourceChildNode); 222 } else { 223 target.getChildren().add(sourceChildNode); 224 } 225 } 226 } 227 } 228 229 private Node getLoggerNode(final Node parentNode, final String name) { 230 for (final Node node : parentNode.getChildren()) { 231 final String nodeName = node.getAttributes().get(NAME); 232 if (name == null && nodeName == null) { 233 return node; 234 } 235 if (nodeName != null && nodeName.equals(name)) { 236 return node; 237 } 238 } 239 return null; 240 } 241 242 private void updateFilterNode(final Node target, final Node targetChildNode, final Node sourceChildNode, 243 final PluginManager pluginManager) { 244 if (CompositeFilter.class.isAssignableFrom(targetChildNode.getType().getPluginClass())) { 245 final Node node = new Node(targetChildNode, sourceChildNode.getName(), sourceChildNode.getType()); 246 node.getChildren().addAll(sourceChildNode.getChildren()); 247 node.getAttributes().putAll(sourceChildNode.getAttributes()); 248 targetChildNode.getChildren().add(node); 249 } else { 250 final PluginType pluginType = pluginManager.getPluginType(FILTERS); 251 final Node filtersNode = new Node(targetChildNode, FILTERS, pluginType); 252 final Node node = new Node(filtersNode, sourceChildNode.getName(), sourceChildNode.getType()); 253 node.getAttributes().putAll(sourceChildNode.getAttributes()); 254 final List<Node> children = filtersNode.getChildren(); 255 children.add(targetChildNode); 256 children.add(node); 257 final List<Node> nodes = target.getChildren(); 258 nodes.remove(targetChildNode); 259 nodes.add(filtersNode); 260 } 261 } 262 263 private boolean isFilterNode(final Node node) { 264 return Filter.class.isAssignableFrom(node.getType().getPluginClass()); 265 } 266 267 private boolean isSameName(final Node node1, final Node node2) { 268 final String value = node1.getAttributes().get(NAME); 269 return value != null && value.toLowerCase().equals(node2.getAttributes().get(NAME).toLowerCase()); 270 } 271 272 private boolean isSameReference(final Node node1, final Node node2) { 273 final String value = node1.getAttributes().get(REF); 274 return value != null && value.toLowerCase().equals(node2.getAttributes().get(REF).toLowerCase()); 275 } 276}