001package runwar.logging;
002
003import java.lang.reflect.Method;
004import java.util.Arrays;
005import java.util.Enumeration;
006import java.util.HashSet;
007import java.util.Properties;
008import java.util.Set;
009
010import runwar.logging.Logger;
011//import org.jboss.logging.Logger; 
012
013import runwar.Server;
014
015public class LogSubverter {
016
017    public static final Set<String> loggers = new HashSet<String>(Arrays.asList(new String[] {
018            "RunwarLogger",
019            "runwar.Start",
020            "org.jboss.logging",
021            "org.xnio.Xnio",
022            "org.xnio.nio.NioXnio",
023            "io.undertow.UndertowLogger"
024    }));
025
026    private static Logger log = Logger.getLogger("RunwarLogger");
027
028
029    public static void subvertLoggers(String level) {
030        subvertJDKLoggers(level);
031        subvertLog4jLoggers(level);
032    }
033    
034    
035    public static void subvertJDKLoggers(String level) {
036        System.setProperty("java.util.logging.ConsoleHandler.formatter", "java.util.logging.SimpleFormatter");
037        System.setProperty("java.util.logging.SimpleFormatter.format", "%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS %4$s %3$s %5$s%6$s%n");
038        java.util.logging.ConsoleHandler chandler = new java.util.logging.ConsoleHandler();
039        java.util.logging.Level LEVEL = JDKLevel.WARN;
040        if(level.trim().toUpperCase().equals("TRACE"))
041            LEVEL = JDKLevel.TRACE;
042        if(level.trim().toUpperCase().equals("WARN"))
043            LEVEL = JDKLevel.WARN;
044        if(level.trim().toUpperCase().equals("INFO"))
045            LEVEL = JDKLevel.INFO;
046        if(level.trim().toUpperCase().equals("DEBUG"))
047            LEVEL = JDKLevel.DEBUG;
048        if(level.trim().toUpperCase().equals("ERROR"))
049            LEVEL = JDKLevel.ERROR;
050        if(level.trim().toUpperCase().equals("FATAL"))
051            LEVEL = JDKLevel.FATAL;
052        chandler.setLevel(LEVEL);
053        java.util.logging.LogManager logManager = java.util.logging.LogManager.getLogManager();
054//        try {
055//            InputStream fis = Start.class.getClassLoader().getResourceAsStream("resources/logging.properties");
056//            logManager.readConfiguration(fis);
057//            fis.close();
058//            log.debug("starting myApp");
059//        } 
060//        catch(IOException e) {
061//            e.printStackTrace();
062//        }
063        
064        for(Enumeration<String> loggerNames = logManager.getLoggerNames(); loggerNames.hasMoreElements();){
065            String name = loggerNames.nextElement();
066            java.util.logging.Logger nextLogger = logManager.getLogger(name);
067            if(loggers.contains(name) && nextLogger != null) {
068                log.debugLazy("JDK loggers detected, level to "+level);
069                nextLogger.setUseParentHandlers(false);
070                nextLogger.setLevel(LEVEL);
071                if(nextLogger.getHandlers() != null) {
072                    for(java.util.logging.Handler handler : nextLogger.getHandlers()) {
073                        nextLogger.removeHandler(handler);
074                    }
075                    nextLogger.addHandler(chandler);                    
076                }
077            }
078        }
079    }
080
081    public static void subvertLog4jLoggers(String level) {
082        // sometimes log4j is in use?  TODO: sort the class loading
083        Properties log4jprops = new Properties();
084        log4jprops.put("log4j.rootLogger", level.toUpperCase()+", stdout");
085        log4jprops.put("log4j.appender.stdout", "org.apache.log4j.ConsoleAppender");
086        log4jprops.put("log4j.appender.stdout.Target", "System.out");
087        log4jprops.put("log4j.appender.stdout.layout", "org.apache.log4j.PatternLayout");
088        log4jprops.put("log4j.appender.stdout.layout.ConversionPattern", "%d{yy/MM/dd HH:mm:ss} %p %c{2}: %m%n");
089        log4jprops.put("RunwarLogger", level.toUpperCase()+", stdout");
090        log4jprops.put("org.jboss.logging", level.toUpperCase()+", stdout");
091        ClassLoader cl = Server.getClassLoader();
092        if(cl == null)
093            cl = Thread.currentThread().getContextClassLoader();
094        try{
095            Class<?> LogManager = cl.loadClass("org.apache.log4j.LogManager");
096            Method resetConfiguration = LogManager.getMethod("resetConfiguration",new Class[]{});
097            resetConfiguration.invoke(null, new Object[]{});
098            /*
099            Class<?> RootLogger = cl.loadClass("org.jboss.logging.Log4jLogger");
100            Method rootLogger = RootLogger.getMethod("getRootLogger",new Class[]{});
101            Object root = rootLogger.invoke(null, new Object[]{});
102            Method getLoggerRepository = root.getClass().getMethod("getLoggerRepository", new Class[]{});
103            Object repo = getLoggerRepository.invoke(root, new Object[]{});
104            Method resetConfiguration = repo.getClass().getMethod("resetConfiguration", new Class[]{});
105            resetConfiguration.invoke(repo, new Object[]{});
106             */
107            log.debugLazy("log4j loggers detected, configuration reset to "+level);
108        } catch (ClassNotFoundException ignored) {
109            log.debugLazy("No log4j loggers detected");
110//            ignored.printStackTrace();
111        } catch (Exception e) {
112            e.printStackTrace();
113        }
114        try{
115            Class<?> PropertyConfigurator = cl.loadClass("org.apache.log4j.PropertyConfigurator");
116            Method configure = PropertyConfigurator.getMethod("configure",new Class[]{Properties.class});
117            configure.invoke(PropertyConfigurator.getConstructor().newInstance(), new Object[]{log4jprops});
118        } catch (ClassNotFoundException ignored) {
119        } catch (Exception e) {
120            e.printStackTrace();
121        }
122        
123//        Logger rootLogger = Logger.getRootLogger();
124//        rootLogger.setLevel(org.apache.log4j.Level.DEBUG);
125////        org.apache.log4j.Logger.getRootLogger().getLoggerRepository().resetConfiguration();
126        
127//        ConsoleAppender console = new ConsoleAppender(); //create appender
128//        String PATTERN = "%d [%p|%c|%C{1}] %m%n";
129//        console.setLayout(new PatternLayout(PATTERN)); 
130//        console.setThreshold(Level.ALL);
131//        console.activateOptions();
132//        org.apache.log4j.Logger.getRootLogger().addAppender(console);
133//
134//        Enumeration currentLoggers = LogManager.getCurrentLoggers();
135//        while(currentLoggers.hasMoreElements()) {
136//            org.apache.log4j.Logger logger = (org.apache.log4j.Logger)currentLoggers.nextElement();
137//            System.err.println(logger.getName());
138//            org.apache.log4j.Logger l = LogManager.getLogger(logger.getName());
139//            l.setLevel(org.apache.log4j.Level.DEBUG);
140//        }
141        
142        
143    }
144    
145    public static java.util.logging.Level translate(final org.jboss.logging.Logger.Level level) {
146        if (level != null) switch (level) {
147            case FATAL: return JDKLevel.FATAL;
148            case ERROR: return JDKLevel.ERROR;
149            case WARN:  return JDKLevel.WARN;
150            case INFO:  return JDKLevel.INFO;
151            case DEBUG: return JDKLevel.DEBUG;
152            case TRACE: return JDKLevel.TRACE;
153        }
154        return JDKLevel.ALL;
155    }
156
157
158
159}