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

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