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

   1 /**
   2  * Generated file
   3
   4  * Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
   5  * Generated at: Wed Jul 17 15:26:45 CEST 2013
   6  *
   7  * Do not modifiy this file unless it is present under src/main directory
   8  */
   9 package org.opendaylight.controller.config.yang.logback.config;
  10
  11 import java.util.*;
  12 import java.util.Map.Entry;
  13
  14 import org.apache.commons.lang3.StringUtils;
  15 import org.opendaylight.controller.config.api.DependencyResolver;
  16 import org.opendaylight.controller.config.api.ModuleIdentifier;
  17 import org.slf4j.LoggerFactory;
  18
  19 import ch.qos.logback.classic.Logger;
  20 import ch.qos.logback.classic.LoggerContext;
  21 import ch.qos.logback.classic.encoder.PatternLayoutEncoder;
  22 import ch.qos.logback.classic.spi.ILoggingEvent;
  23 import ch.qos.logback.classic.spi.LoggerComparator;
  24 import ch.qos.logback.core.Appender;
  25 import ch.qos.logback.core.rolling.FixedWindowRollingPolicy;
  26 import ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy;
  27
  28 import com.google.common.base.Preconditions;
  29 import com.google.common.collect.Lists;
  30
  31 /**
  32 *
  33 */
  34 public class LogbackModuleFactory
  35         extends
  36         org.opendaylight.controller.config.yang.logback.config.AbstractLogbackModuleFactory {
  37
  38     private static final String INSTANCE_NAME = "singleton";
  39     private Map<String, LoggerTO> loggersDTOs;
  40     private Map<String, RollingFileAppenderTO> rollingDTOs;
  41     private Map<String, ConsoleAppenderTO> consoleDTOs;
  42
  43     @Override
  44     public LogbackModule instantiateModule(String instanceName,
  45             DependencyResolver dependencyResolver) {
  46         Preconditions.checkArgument(instanceName.equals(INSTANCE_NAME),
  47                 "There should be just one instance of logback, named "
  48                         + INSTANCE_NAME);
  49         prepareDTOs();
  50         LogbackModule module = new LogbackModule(new ModuleIdentifier(
  51                 getImplementationName(), INSTANCE_NAME), dependencyResolver);
  52         module.setConsoleAppenderTO(Lists.newArrayList(consoleDTOs.values()));
  53         module.setRollingFileAppenderTO(Lists.newArrayList(rollingDTOs.values()));
  54         module.setLoggerTO(Lists.newArrayList(loggersDTOs.values()));
  55         return module;
  56     }
  57
  58     @Override
  59     public LogbackModule instantiateModule(String instanceName,
  60             DependencyResolver dependencyResolver, LogbackModule oldModule,
  61             AutoCloseable oldInstance) {
  62         Preconditions.checkArgument(instanceName.equals(INSTANCE_NAME),
  63                 "There should be just one instance of logback, named "
  64                         + INSTANCE_NAME);
  65         prepareDTOs();
  66         LogbackModule module = new LogbackModule(new ModuleIdentifier(
  67                 getImplementationName(), INSTANCE_NAME), dependencyResolver,
  68                 oldModule, oldInstance);
  69         module.setConsoleAppenderTO(Lists.newArrayList(consoleDTOs.values()));
  70         /*
  71          * module.setJCloudsAppender(Lists.newArrayList(jcloudsDTOs.values()));
  72          */
  73         module.setRollingFileAppenderTO(Lists.newArrayList(rollingDTOs.values()));
  74         module.setLoggerTO(Lists.newArrayList(loggersDTOs.values()));
  75         return module;
  76     }
  77
  78     private void prepareDTOs() {
  79         LoggerContext context = (LoggerContext) LoggerFactory
  80                 .getILoggerFactory();
  81         this.loggersDTOs = prepareLoggersDTOs(context);
  82         prepareAppendersDTOs(context);
  83     }
  84
  85     private void prepareAppendersDTOs(LoggerContext context) {
  86         this.rollingDTOs = new HashMap<>();
  87         this.consoleDTOs = new HashMap<>();
  88         ch.qos.logback.core.rolling.RollingFileAppender<ILoggingEvent> rollingApp;
  89         ch.qos.logback.core.ConsoleAppender<ILoggingEvent> consoleApp;
  90         Map<Logger, List<Appender<ILoggingEvent>>> appendersAll = new HashMap<>();
  91         for (Logger log : context.getLoggerList()) {
  92             List<Appender<ILoggingEvent>> appenders = new ArrayList<>();
  93             Iterator<Appender<ILoggingEvent>> iter = log.iteratorForAppenders();
  94             while (iter.hasNext()) {
  95                 Appender<ILoggingEvent> element = iter.next();
  96                 appenders.add(element);
  97             }
  98             appendersAll.put(log, appenders);
  99         }
 100         for (List<ch.qos.logback.core.Appender<ILoggingEvent>> appEntry : appendersAll.values()) {
 101             for (ch.qos.logback.core.Appender<ILoggingEvent> appender : appEntry) {
 102                 if (appender instanceof ch.qos.logback.core.rolling.RollingFileAppender<?>) {
 103                     RollingFileAppenderTO app = new RollingFileAppenderTO();
 104                     rollingApp = (ch.qos.logback.core.rolling.RollingFileAppender< ILoggingEvent >) appender;
 105                     app.setAppend(rollingApp.isAppend());
 106                     PatternLayoutEncoder encoder = (PatternLayoutEncoder) rollingApp
 107                             .getEncoder();
 108                     app.setEncoderPattern(encoder.getPattern());
 109                     app.setFileName(rollingApp.getFile());
 110                     FixedWindowRollingPolicy rollingPolicy = (FixedWindowRollingPolicy) rollingApp
 111                             .getRollingPolicy();
 112                     app.setMaxIndex(rollingPolicy.getMaxIndex());
 113                     app.setMinIndex(rollingPolicy.getMinIndex());
 114                     SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = (SizeBasedTriggeringPolicy<ILoggingEvent>) rollingApp
 115                             .getTriggeringPolicy();
 116                     app.setMaxFileSize(triggeringPolicy.getMaxFileSize());
 117                     app.setFileNamePattern(rollingPolicy.getFileNamePattern());
 118                     app.setName(rollingApp.getName());
 119                     this.rollingDTOs.put(rollingApp.getName(), app);
 120                 }
 121                 if (appender instanceof ch.qos.logback.core.ConsoleAppender<?>) {
 122                     ConsoleAppenderTO app = new ConsoleAppenderTO();
 123                     consoleApp = (ch.qos.logback.core.ConsoleAppender<ILoggingEvent>) appender;
 124                     consoleApp.getCopyOfAttachedFiltersList();
 125                     PatternLayoutEncoder encoder = (PatternLayoutEncoder) consoleApp
 126                             .getEncoder();
 127                     app.setEncoderPattern(encoder.getPattern());
 128                     app.setName(consoleApp.getName());
 129                     app.setThresholdFilter(context.getLogger(
 130                             Logger.ROOT_LOGGER_NAME).getEffectiveLevel().levelStr);
 131                     this.consoleDTOs.put(consoleApp.getName(), app);
 132                 }
 133             }
 134         }
 135     }
 136
 137     private Map<String, LoggerTO> prepareLoggersDTOs(
 138             LoggerContext context) {
 139         Map<String, LoggerTO> DTOs = new HashMap<>();
 140         List<String> appenders = new ArrayList<>();
 141         List<org.slf4j.Logger> loggersToBeAdd = removeUnusableLoggers(
 142                 context.getLoggerList(),
 143                 context.getLogger(Logger.ROOT_LOGGER_NAME));
 144         for (org.slf4j.Logger log : loggersToBeAdd) {
 145             LoggerTO logger = new LoggerTO();
 146             if (((Logger) log).getLevel() != null)
 147                 logger.setLevel(((Logger) log).getLevel().levelStr);
 148             else
 149                 logger.setLevel(((Logger) log).getEffectiveLevel().levelStr);
 150             logger.setLoggerName(log.getName());
 151             Iterator<Appender<ILoggingEvent>> iter = ((Logger) log)
 152                     .iteratorForAppenders();
 153             while (iter.hasNext()) {
 154                 Appender<ILoggingEvent> element = iter.next();
 155                 appenders.add(element.getName());
 156             }
 157             logger.setAppenders(appenders);
 158             DTOs.put(log.getName(), logger);
 159             appenders = new ArrayList<>();
 160
 161         }
 162         return DTOs;
 163     }
 164
 165     private List<org.slf4j.Logger> removeUnusableLoggers(
 166             List<Logger> loggerList, Logger rootLogger) {
 167         Collections.sort(loggerList, new LoggerComparator());
 168         Map<String, org.slf4j.Logger> loggersToReturn = new HashMap<>();
 169
 170         for (org.slf4j.Logger log : loggerList) {
 171             boolean shouldAdd = true;
 172             for (Entry<String, org.slf4j.Logger> entry : loggersToReturn
 173                     .entrySet()) {
 174                 if (StringUtils.contains(log.getName(), entry.getKey())) {
 175                     if (((Logger) log).getLevel() != null
 176                             && ((Logger) log).getLevel().equals(
 177                                     ((Logger) entry.getValue()).getLevel())
 178                             && !((Logger) log).iteratorForAppenders().hasNext()) {
 179                         shouldAdd = false;
 180                         break;
 181                     }
 182                     if (((Logger) log).getLevel() == null
 183                             && ((Logger) log).getEffectiveLevel().equals(
 184                                     ((Logger) entry.getValue())
 185                                             .getEffectiveLevel())
 186                             && !((Logger) log).iteratorForAppenders().hasNext()) {
 187                         shouldAdd = false;
 188                         break;
 189                     }
 190                 }
 191                 if (((Logger) log).getLevel() != null
 192                         && ((Logger) log).getLevel().equals(
 193                                 rootLogger.getLevel())
 194                         && !((Logger) log).iteratorForAppenders().hasNext()) {
 195                     shouldAdd = false;
 196                     break;
 197                 }
 198                 if (((Logger) log).getLevel() == null
 199                         && ((Logger) log).getEffectiveLevel().equals(
 200                                 rootLogger.getEffectiveLevel())
 201                         && !((Logger) log).iteratorForAppenders().hasNext()) {
 202                     shouldAdd = false;
 203                     break;
 204                 }
 205             }
 206             if (shouldAdd) {
 207                 loggersToReturn.put(log.getName(), log);
 208             }
 209         }
 210         return Lists.newArrayList(loggersToReturn.values());
 211     }
 212
 213 }