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