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