001package runwar.logging;
002
003import java.util.ArrayList;
004import java.util.HashMap;
005
006import runwar.Server;
007
008public class Logger {
009    private static boolean loggingIsInitialized = false;
010    private static org.jboss.logging.Logger logger;
011    private static String loggerName;
012    private static ArrayList<HashMap<String, Object>> lazyMessages;
013    private static org.jboss.logging.Logger.Level logLevel = org.jboss.logging.Logger.Level.WARN;
014
015    public Logger(String name) {
016        loggerName = name;
017        lazyMessages = new ArrayList<HashMap<String, Object>>();
018    }
019    public void debug(Object message) {
020        log(org.jboss.logging.Logger.Level.DEBUG, message);
021    }
022    public void debug(String string, Exception e) {
023        log(org.jboss.logging.Logger.Level.DEBUG, string, e);
024    }
025    public void debugf(String format, Object... object) {
026        logf(org.jboss.logging.Logger.Level.DEBUG,format,object);
027    }
028    public void debugLazy(Object message) {
029        HashMap<String, Object> lazyMessage = new HashMap<String, Object>();
030        lazyMessage.put("level",org.jboss.logging.Logger.Level.DEBUG);
031        lazyMessage.put("message",message);
032        lazyMessages.add(lazyMessage);
033    }
034
035    public void trace(Object message) {
036        log(org.jboss.logging.Logger.Level.TRACE, message);
037    }
038    public void trace(String string, Exception e) {
039        log(org.jboss.logging.Logger.Level.TRACE, string, e);
040    }
041    public void tracef(String format, Object object) {
042        logf(org.jboss.logging.Logger.Level.TRACE,format,object);
043    }
044    
045    public void error(Object object) {
046        log(org.jboss.logging.Logger.Level.ERROR, object);
047    }
048    public void error(String string, Exception e) {
049        log(org.jboss.logging.Logger.Level.ERROR, string, e);
050    }
051    public void errorf(String format, Object object) {
052        logf(org.jboss.logging.Logger.Level.ERROR,format,object);
053    }
054
055    public void warn(Object object) {
056        log(org.jboss.logging.Logger.Level.WARN, object);
057    }
058    public void warn(String string, Exception e) {
059        log(org.jboss.logging.Logger.Level.WARN, string, e);
060    }
061    public void warnf(String format, Object object) {
062        logf(org.jboss.logging.Logger.Level.WARN,format,object);
063    }
064
065    
066    public void info(Object object) {
067        log(org.jboss.logging.Logger.Level.INFO, object);
068    }
069    public void info(String string, Exception e) {
070        log(org.jboss.logging.Logger.Level.INFO, string, e);
071    }
072    public void info(String format, Object object) {
073        logf(org.jboss.logging.Logger.Level.INFO,format,object);
074    }
075    
076    public void fatal(Object object) {
077        log(org.jboss.logging.Logger.Level.FATAL, object);
078    }
079    public void fatal(String string, Exception e) {
080        log(org.jboss.logging.Logger.Level.FATAL, string, e);
081    }
082    public void fatal(String format, Object object) {
083        logf(org.jboss.logging.Logger.Level.FATAL,format,object);
084    }
085    
086    private static void log(org.jboss.logging.Logger.Level level, Object object) {
087        if(!loggingIsInitialized)
088            initLogging();
089        
090        switch(level) {
091        case DEBUG:
092            logger.debug(object);
093            break;
094        case WARN:
095            logger.warn(object);
096            break;
097        case INFO:
098            logger.info(object);
099            break;
100        case TRACE:
101            logger.trace(object);
102            break;
103        case FATAL:
104            logger.fatal(object);
105            break;
106        default:
107            logger.debug(object);
108            break;
109        }
110    }
111    
112    private static void logf(org.jboss.logging.Logger.Level level, String format, Object... object) {
113        if(!loggingIsInitialized)
114            initLogging();
115        
116        switch(level) {
117        case DEBUG:
118            logger.debugf(format,object);
119            break;
120        case WARN:
121            logger.warnf(format,object);
122            break;
123        case INFO:
124            logger.infof(format,object);
125            break;
126        case TRACE:
127            logger.tracef(format,object);
128            break;
129        case FATAL:
130            logger.fatalf(format,object);
131            break;
132        default:
133            logger.debugf(format,object);
134            break;
135        }
136    }
137        
138    private static void log(org.jboss.logging.Logger.Level level, String message, Exception exception) {
139        if(!loggingIsInitialized)
140            initLogging();
141        
142        switch(level) {
143        case DEBUG:
144            logger.debug(message,exception);
145            break;
146        case WARN:
147            logger.warn(message,exception);
148            break;
149        case INFO:
150            logger.info(message,exception);
151            break;
152        case TRACE:
153            logger.trace(message,exception);
154            break;
155        case FATAL:
156            logger.fatal(message,exception);
157            break;
158        default:
159            logger.debug(message,exception);
160            break;
161        }
162    }
163    
164    // log4j logging is lazily constructed; it gets initialized
165    // the first time the invoking app calls a log method
166    private static void initLogging() {
167        logger = org.jboss.logging.Logger.getLogger("RunwarLogger");
168        if(Server.getServerOptions() != null) {
169                logLevel = org.jboss.logging.Logger.Level.valueOf(Server.getServerOptions().getLoglevel());
170                loggingIsInitialized = true;
171                if(logLevel == null) {
172                logLevel = org.jboss.logging.Logger.Level.valueOf("WARN");
173                }
174                LogSubverter.subvertLoggers(logLevel.toString());
175                for(HashMap<String, Object> lm : lazyMessages) {
176                        org.jboss.logging.Logger.Level level = (org.jboss.logging.Logger.Level)lm.get("level");
177                        log(level,loggerName + lm.get("message"));
178                }
179                //org.apache.log4j.Logger debugLogger = org.apache.log4j.LoggerFactory.getLogger("DebugLogger");
180                //debugLogger.addAppender(someConfiguredFileAppender);
181        }
182    }
183    
184    public static Logger getLogger(String string) {
185        return new Logger(string);
186    }
187}
188
189final class JDKLevel extends java.util.logging.Level {
190
191    private static final long serialVersionUID = 1L;
192
193    protected JDKLevel(final String name, final int value) {
194        super(name, value);
195    }
196
197    protected JDKLevel(final String name, final int value, final String resourceBundleName) {
198        super(name, value, resourceBundleName);
199    }
200
201    public static final JDKLevel FATAL = new JDKLevel("FATAL", 1100);
202    public static final JDKLevel ERROR = new JDKLevel("ERROR", 1000);
203    public static final JDKLevel WARN = new JDKLevel("WARN", 900);
204    public static final JDKLevel INFO = new JDKLevel("INFO", 800);
205    public static final JDKLevel DEBUG = new JDKLevel("DEBUG", 500);
206    public static final JDKLevel TRACE = new JDKLevel("TRACE", 400);
207}