opendaylight/config/logback-config/src/main/java/org/opendaylight/controller/config/yang/logback/config/ContextSetterImpl.java

   1 /**
   2  * Generated file
   3
   4  * Generated from: yang module name: config-test  yang module local name: testing
   5  * Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
   6  * Generated at: Fri Sep 27 14:06:33 CEST 2013
   7  *
   8  * Do not modify this file unless it is present under src/main directory
   9  */
  10 package org.opendaylight.controller.config.yang.logback.config;
  11
  12 import java.io.Closeable;
  13 import java.io.IOException;
  14 import java.util.HashMap;
  15 import java.util.Iterator;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.Set;
  19
  20 import org.slf4j.LoggerFactory;
  21
  22 import ch.qos.logback.classic.Level;
  23 import ch.qos.logback.classic.LoggerContext;
  24 import ch.qos.logback.classic.encoder.PatternLayoutEncoder;
  25 import ch.qos.logback.classic.filter.ThresholdFilter;
  26 import ch.qos.logback.classic.spi.ILoggingEvent;
  27 import ch.qos.logback.core.Appender;
  28 import ch.qos.logback.core.rolling.FixedWindowRollingPolicy;
  29 import ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy;
  30 import ch.qos.logback.core.rolling.TimeBasedRollingPolicy;
  31
  32 import com.google.common.base.Optional;
  33 import com.google.common.base.Preconditions;
  34 import com.google.common.collect.Sets;
  35
  36 /**
  37  * Implementation of {@link ContextSetter}. Resets running logback
  38  * configuration.
  39  */
  40 public class ContextSetterImpl implements ContextSetter, Closeable {
  41
  42     private final LogbackStatusListener statusListener;
  43     private static final org.slf4j.Logger classLogger = LoggerFactory.getLogger(ContextSetterImpl.class);
  44
  45     public ContextSetterImpl(LogbackRuntimeRegistrator rootRuntimeBeanRegistratorWrapper) {
  46         statusListener = new LogbackStatusListener(rootRuntimeBeanRegistratorWrapper);
  47         statusListener.register();
  48     }
  49
  50     public void updateContext(LogbackModule module) {
  51         LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
  52
  53         List<ch.qos.logback.classic.Logger> loggersBefore = context.getLoggerList();
  54
  55         createLoggers(context, module, Sets.newHashSet(loggersBefore));
  56     }
  57
  58     private Map<String, Appender<ILoggingEvent>> createConsoleAppenders(LoggerContext context, LogbackModule module) {
  59         Map<String, Appender<ILoggingEvent>> appendersMap = new HashMap<>();
  60         for (ConsoleAppenderTO appender : module.getConsoleAppenderTO()) {
  61             Preconditions.checkState(appendersMap.containsKey(appender.getName()) == false,
  62                     "Duplicate appender name %s", appender.getName());
  63             ch.qos.logback.core.ConsoleAppender app = new ch.qos.logback.core.ConsoleAppender();
  64             app.setContext(context);
  65             PatternLayoutEncoder encoder = new PatternLayoutEncoder();
  66             encoder.setContext(context);
  67             encoder.setPattern(appender.getEncoderPattern());
  68             encoder.start();
  69             app.setEncoder(encoder);
  70             ThresholdFilter filter = new ThresholdFilter();
  71             filter.setContext(context);
  72             filter.setLevel(appender.getThresholdFilter());
  73             filter.start();
  74             app.getCopyOfAttachedFiltersList().add(filter);
  75             app.setName(appender.getName());
  76             app.start();
  77             appendersMap.put(app.getName(), app);
  78         }
  79         return appendersMap;
  80     }
  81
  82     private void createLoggers(LoggerContext context, LogbackModule module,
  83             Set<ch.qos.logback.classic.Logger> loggersBefore) {
  84
  85         Map<String, Appender<ILoggingEvent>> appendersMap = getAppenders(module, context);
  86
  87         for (LoggerTO logger : module.getLoggerTO()) {
  88             classLogger.trace("Setting configuration for logger {}", logger.getLoggerName());
  89             final ch.qos.logback.classic.Logger logbackLogger = context.getLogger(logger.getLoggerName());
  90
  91             Optional<Set<Appender<ILoggingEvent>>> appendersBefore = getAppendersBefore(loggersBefore, logbackLogger);
  92             classLogger.trace("Logger {}: Appenders registered before: {}", logger.getLoggerName(),
  93                     appendersBefore.isPresent() ? appendersBefore.get() : "NO APPENDERS BEFORE");
  94
  95             logbackLogger.setLevel(Level.toLevel(logger.getLevel()));
  96
  97             addNewAppenders(appendersMap, logger, logbackLogger, appendersBefore);
  98             removeBeforeAppenders(loggersBefore, logger, logbackLogger, appendersBefore);
  99         }
 100     }
 101
 102     private void addNewAppenders(Map<String, Appender<ILoggingEvent>> appendersMap, LoggerTO logger,
 103             ch.qos.logback.classic.Logger logbackLogger, Optional<Set<Appender<ILoggingEvent>>> appendersBefore) {
 104         if (logger.getAppenders() != null) {
 105             for (String appenderName : logger.getAppenders()) {
 106                 if (appendersMap.containsKey(appenderName)) {
 107                     logbackLogger.addAppender(appendersMap.get(appenderName));
 108                     classLogger.trace("Logger {}: Adding new appender: {}", logger.getLoggerName(), appenderName);
 109                 } else {
 110                     throw new IllegalStateException("No appender " + appenderName
 111                             + " found. This error should have been discovered by validation");
 112                 }
 113             }
 114         }
 115     }
 116
 117     private void removeBeforeAppenders(Set<ch.qos.logback.classic.Logger> loggersBefore, LoggerTO logger,
 118             ch.qos.logback.classic.Logger logbackLogger, Optional<Set<Appender<ILoggingEvent>>> appendersBefore) {
 119         if (appendersBefore.isPresent()) {
 120             for (Appender<ILoggingEvent> appenderBefore : appendersBefore.get()) {
 121                 logbackLogger.detachAppender(appenderBefore);
 122                 appenderBefore.stop();
 123                 classLogger.trace("Logger {}: Removing old appender: {}", logger.getLoggerName(),
 124                         appenderBefore.getName());
 125             }
 126             loggersBefore.remove(logbackLogger);
 127         }
 128     }
 129
 130     private Optional<Set<Appender<ILoggingEvent>>> getAppendersBefore(Set<ch.qos.logback.classic.Logger> loggersBefore,
 131             ch.qos.logback.classic.Logger logbackLogger) {
 132         if (loggersBefore.contains(logbackLogger)) {
 133             Iterator<Appender<ILoggingEvent>> appenderIt = logbackLogger.iteratorForAppenders();
 134             Set<Appender<ILoggingEvent>> appendersBefore = Sets.newHashSet();
 135             while (appenderIt.hasNext()) {
 136                 appendersBefore.add(appenderIt.next());
 137             }
 138             return Optional.of(appendersBefore);
 139         } else
 140             return Optional.absent();
 141
 142     }
 143
 144     private Map<String, Appender<ILoggingEvent>> getAppenders(LogbackModule module, LoggerContext context) {
 145         Map<String, Appender<ILoggingEvent>> appendersMap = new HashMap<>();
 146         addAllAppenders(appendersMap, createRollingAppenders(context, module));
 147         addAllAppenders(appendersMap, createFileAppenders(context, module));
 148         addAllAppenders(appendersMap, createConsoleAppenders(context, module));
 149
 150         return appendersMap;
 151     }
 152
 153     private void addAllAppenders(Map<String, Appender<ILoggingEvent>> allAppenders,
 154             Map<String, Appender<ILoggingEvent>> appendersToAdd) {
 155         for (String appenderName : appendersToAdd.keySet()) {
 156             Preconditions.checkState(allAppenders.containsKey(appenderName) == false, "Duplicate appender name %s",
 157                     appenderName);
 158             allAppenders.put(appenderName, appendersToAdd.get(appenderName));
 159         }
 160     }
 161
 162     private Map<String, Appender<ILoggingEvent>> createFileAppenders(LoggerContext context, LogbackModule module) {
 163         Map<String, Appender<ILoggingEvent>> appendersMap = new HashMap<>();
 164         for (FileAppenderTO appender : module.getFileAppenderTO()) {
 165             Preconditions.checkState(appendersMap.containsKey(appender.getName()) == false,
 166                     "Duplicate appender name %s", appender.getName());
 167             ch.qos.logback.core.FileAppender app = new ch.qos.logback.core.FileAppender<>();
 168             app.setAppend(appender.getAppend());
 169             app.setContext(context);
 170             PatternLayoutEncoder encoder = new PatternLayoutEncoder();
 171             encoder.setContext(context);
 172             encoder.setPattern(appender.getEncoderPattern());
 173             encoder.start();
 174             app.setEncoder(encoder);
 175             app.setFile(appender.getFileName());
 176             app.setName(appender.getName());
 177             app.start();
 178             appendersMap.put(app.getName(), app);
 179         }
 180
 181         return appendersMap;
 182     }
 183
 184     private Map<String, Appender<ILoggingEvent>> createRollingAppenders(LoggerContext context, LogbackModule module) {
 185         Map<String, Appender<ILoggingEvent>> appendersMap = new HashMap<>();
 186         for (RollingFileAppenderTO appender : module.getRollingFileAppenderTO()) {
 187             Preconditions.checkState(appendersMap.containsKey(appender.getName()) == false,
 188                     "Duplicate appender name %s", appender.getName());
 189             ch.qos.logback.core.rolling.RollingFileAppender app = new ch.qos.logback.core.rolling.RollingFileAppender<>();
 190             app.setAppend(appender.getAppend());
 191             app.setContext(context);
 192             PatternLayoutEncoder encoder = new PatternLayoutEncoder();
 193             encoder.setContext(context);
 194             encoder.setPattern(appender.getEncoderPattern());
 195             encoder.start();
 196             app.setEncoder(encoder);
 197             app.setFile(appender.getFileName());
 198             if (appender.getRollingPolicyType().equals("FixedWindowRollingPolicy")) {
 199                 FixedWindowRollingPolicy policy = new FixedWindowRollingPolicy();
 200                 policy.setContext(context);
 201                 policy.setMaxIndex(appender.getMaxIndex());
 202                 policy.setMinIndex(appender.getMinIndex());
 203                 policy.setFileNamePattern(appender.getFileNamePattern());
 204                 policy.setParent(app);
 205                 policy.start();
 206                 app.setRollingPolicy(policy);
 207             } else if (appender.getRollingPolicyType().equals("TimeBasedRollingPolicy")) {
 208                 TimeBasedRollingPolicy policy = new TimeBasedRollingPolicy();
 209                 policy.setContext(context);
 210                 policy.setMaxHistory(appender.getMaxHistory());
 211                 if (appender.getCleanHistoryOnStart() != null) {
 212                     policy.setCleanHistoryOnStart(appender.getCleanHistoryOnStart());
 213                 }
 214                 policy.setFileNamePattern(appender.getFileNamePattern());
 215                 policy.setParent(app);
 216                 policy.start();
 217                 app.setRollingPolicy(policy);
 218             }
 219             SizeBasedTriggeringPolicy triggeringPolicy = new SizeBasedTriggeringPolicy();
 220             triggeringPolicy.setContext(context);
 221             triggeringPolicy.setMaxFileSize(appender.getMaxFileSize());
 222             triggeringPolicy.start();
 223             app.setTriggeringPolicy(triggeringPolicy);
 224             app.setName(appender.getName());
 225             app.start();
 226             appendersMap.put(app.getName(), app);
 227         }
 228         return appendersMap;
 229     }
 230
 231     @Override
 232     public void close() throws IOException {
 233         statusListener.close();
 234     }
 235 }