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