1 /*
2 * Copyright 2000-2007 Sun Microsystems, Inc. All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Sun designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Sun in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22 * CA 95054 USA or visit www.sun.com if you need additional information or
23 * have any questions.
24 */
25
26
27 package java.util.logging;
28
29 import java.io;
30 import java.util;
31 import java.security;
32 import java.lang.ref.WeakReference;
33 import java.beans.PropertyChangeListener;
34 import java.beans.PropertyChangeSupport;
35 import java.net.URL;
36 import sun.security.action.GetPropertyAction;
37
38 /**
39 * There is a single global LogManager object that is used to
40 * maintain a set of shared state about Loggers and log services.
41 * <p>
42 * This LogManager object:
43 * <ul>
44 * <li> Manages a hierarchical namespace of Logger objects. All
45 * named Loggers are stored in this namespace.
46 * <li> Manages a set of logging control properties. These are
47 * simple key-value pairs that can be used by Handlers and
48 * other logging objects to configure themselves.
49 * </ul>
50 * <p>
51 * The global LogManager object can be retrieved using LogManager.getLogManager().
52 * The LogManager object is created during class initialization and
53 * cannot subsequently be changed.
54 * <p>
55 * At startup the LogManager class is located using the
56 * java.util.logging.manager system property.
57 * <p>
58 * By default, the LogManager reads its initial configuration from
59 * a properties file "lib/logging.properties" in the JRE directory.
60 * If you edit that property file you can change the default logging
61 * configuration for all uses of that JRE.
62 * <p>
63 * In addition, the LogManager uses two optional system properties that
64 * allow more control over reading the initial configuration:
65 * <ul>
66 * <li>"java.util.logging.config.class"
67 * <li>"java.util.logging.config.file"
68 * </ul>
69 * These two properties may be set via the Preferences API, or as
70 * command line property definitions to the "java" command, or as
71 * system property definitions passed to JNI_CreateJavaVM.
72 * <p>
73 * If the "java.util.logging.config.class" property is set, then the
74 * property value is treated as a class name. The given class will be
75 * loaded, an object will be instantiated, and that object's constructor
76 * is responsible for reading in the initial configuration. (That object
77 * may use other system properties to control its configuration.) The
78 * alternate configuration class can use <tt>readConfiguration(InputStream)</tt>
79 * to define properties in the LogManager.
80 * <p>
81 * If "java.util.logging.config.class" property is <b>not</b> set,
82 * then the "java.util.logging.config.file" system property can be used
83 * to specify a properties file (in java.util.Properties format). The
84 * initial logging configuration will be read from this file.
85 * <p>
86 * If neither of these properties is defined then, as described
87 * above, the LogManager will read its initial configuration from
88 * a properties file "lib/logging.properties" in the JRE directory.
89 * <p>
90 * The properties for loggers and Handlers will have names starting
91 * with the dot-separated name for the handler or logger.
92 * <p>
93 * The global logging properties may include:
94 * <ul>
95 * <li>A property "handlers". This defines a whitespace or comma separated
96 * list of class names for handler classes to load and register as
97 * handlers on the root Logger (the Logger named ""). Each class
98 * name must be for a Handler class which has a default constructor.
99 * Note that these Handlers may be created lazily, when they are
100 * first used.
101 *
102 * <li>A property "<logger>.handlers". This defines a whitespace or
103 * comma separated list of class names for handlers classes to
104 * load and register as handlers to the specified logger. Each class
105 * name must be for a Handler class which has a default constructor.
106 * Note that these Handlers may be created lazily, when they are
107 * first used.
108 *
109 * <li>A property "<logger>.useParentHandlers". This defines a boolean
110 * value. By default every logger calls its parent in addition to
111 * handling the logging message itself, this often result in messages
112 * being handled by the root logger as well. When setting this property
113 * to false a Handler needs to be configured for this logger otherwise
114 * no logging messages are delivered.
115 *
116 * <li>A property "config". This property is intended to allow
117 * arbitrary configuration code to be run. The property defines a
118 * whitespace or comma separated list of class names. A new instance will be
119 * created for each named class. The default constructor of each class
120 * may execute arbitrary code to update the logging configuration, such as
121 * setting logger levels, adding handlers, adding filters, etc.
122 * </ul>
123 * <p>
124 * Note that all classes loaded during LogManager configuration are
125 * first searched on the system class path before any user class path.
126 * That includes the LogManager class, any config classes, and any
127 * handler classes.
128 * <p>
129 * Loggers are organized into a naming hierarchy based on their
130 * dot separated names. Thus "a.b.c" is a child of "a.b", but
131 * "a.b1" and a.b2" are peers.
132 * <p>
133 * All properties whose names end with ".level" are assumed to define
134 * log levels for Loggers. Thus "foo.level" defines a log level for
135 * the logger called "foo" and (recursively) for any of its children
136 * in the naming hierarchy. Log Levels are applied in the order they
137 * are defined in the properties file. Thus level settings for child
138 * nodes in the tree should come after settings for their parents.
139 * The property name ".level" can be used to set the level for the
140 * root of the tree.
141 * <p>
142 * All methods on the LogManager object are multi-thread safe.
143 *
144 * @since 1.4
145 */
146
147 public class LogManager {
148 // The global LogManager object
149 private static LogManager manager;
150
151 private final static Handler[] emptyHandlers = { };
152 private Properties props = new Properties();
153 private PropertyChangeSupport changes
154 = new PropertyChangeSupport(LogManager.class);
155 private final static Level defaultLevel = Level.INFO;
156
157 // Table of known loggers. Maps names to Loggers.
158 private Hashtable<String,WeakReference<Logger>> loggers =
159 new Hashtable<String,WeakReference<Logger>>();
160 // Tree of known loggers
161 private LogNode root = new LogNode(null);
162 private Logger rootLogger;
163
164 // Have we done the primordial reading of the configuration file?
165 // (Must be done after a suitable amount of java.lang.System
166 // initialization has been done)
167 private volatile boolean readPrimordialConfiguration;
168 // Have we initialized global (root) handlers yet?
169 // This gets set to false in readConfiguration
170 private boolean initializedGlobalHandlers = true;
171 // True if JVM death is imminent and the exit hook has been called.
172 private boolean deathImminent;
173
174 static {
175 AccessController.doPrivileged(new PrivilegedAction<Object>() {
176 public Object run() {
177 String cname = null;
178 try {
179 cname = System.getProperty("java.util.logging.manager");
180 if (cname != null) {
181 try {
182 Class clz = ClassLoader.getSystemClassLoader().loadClass(cname);
183 manager = (LogManager) clz.newInstance();
184 } catch (ClassNotFoundException ex) {
185 Class clz = Thread.currentThread().getContextClassLoader().loadClass(cname);
186 manager = (LogManager) clz.newInstance();
187 }
188 }
189 } catch (Exception ex) {
190 System.err.println("Could not load Logmanager \"" + cname + "\"");
191 ex.printStackTrace();
192 }
193 if (manager == null) {
194 manager = new LogManager();
195 }
196
197 // Create and retain Logger for the root of the namespace.
198 manager.rootLogger = manager.new RootLogger();
199 manager.addLogger(manager.rootLogger);
200
201 // Adding the global Logger. Doing so in the Logger.<clinit>
202 // would deadlock with the LogManager.<clinit>.
203 Logger.global.setLogManager(manager);
204 manager.addLogger(Logger.global);
205
206 // We don't call readConfiguration() here, as we may be running
207 // very early in the JVM startup sequence. Instead readConfiguration
208 // will be called lazily in getLogManager().
209 return null;
210 }
211 });
212 }
213
214
215 // This private class is used as a shutdown hook.
216 // It does a "reset" to close all open handlers.
217 private class Cleaner extends Thread {
218 public void run() {
219 // This is to ensure the LogManager.<clinit> is completed
220 // before synchronized block. Otherwise deadlocks are possible.
221 LogManager mgr = manager;
222
223 // If the global handlers haven't been initialized yet, we
224 // don't want to initialize them just so we can close them!
225 synchronized (LogManager.this) {
226 // Note that death is imminent.
227 deathImminent = true;
228 initializedGlobalHandlers = true;
229 }
230
231 // Do a reset to close all active handlers.
232 reset();
233 }
234 }
235
236
237 /**
238 * Protected constructor. This is protected so that container applications
239 * (such as J2EE containers) can subclass the object. It is non-public as
240 * it is intended that there only be one LogManager object, whose value is
241 * retrieved by calling Logmanager.getLogManager.
242 */
243 protected LogManager() {
244 // Add a shutdown hook to close the global handlers.
245 try {
246 Runtime.getRuntime().addShutdownHook(new Cleaner());
247 } catch (IllegalStateException e) {
248 // If the VM is already shutting down,
249 // We do not need to register shutdownHook.
250 }
251 }
252
253 /**
254 * Return the global LogManager object.
255 */
256 public static LogManager getLogManager() {
257 if (manager != null) {
258 manager.readPrimordialConfiguration();
259 }
260 return manager;
261 }
262
263 private void readPrimordialConfiguration() {
264 if (!readPrimordialConfiguration) {
265 synchronized (this) {
266 if (!readPrimordialConfiguration) {
267 // If System.in/out/err are null, it's a good
268 // indication that we're still in the
269 // bootstrapping phase
270 if (System.out == null) {
271 return;
272 }
273 readPrimordialConfiguration = true;
274 try {
275 AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
276 public Object run() throws Exception {
277 readConfiguration();
278 return null;
279 }
280 });
281 } catch (Exception ex) {
282 // System.err.println("Can't read logging configuration:");
283 // ex.printStackTrace();
284 }
285 }
286 }
287 }
288 }
289
290 /**
291 * Adds an event listener to be invoked when the logging
292 * properties are re-read. Adding multiple instances of
293 * the same event Listener results in multiple entries
294 * in the property event listener table.
295 *
296 * @param l event listener
297 * @exception SecurityException if a security manager exists and if
298 * the caller does not have LoggingPermission("control").
299 * @exception NullPointerException if the PropertyChangeListener is null.
300 */
301 public void addPropertyChangeListener(PropertyChangeListener l) throws SecurityException {
302 if (l == null) {
303 throw new NullPointerException();
304 }
305 checkAccess();
306 changes.addPropertyChangeListener(l);
307 }
308
309 /**
310 * Removes an event listener for property change events.
311 * If the same listener instance has been added to the listener table
312 * through multiple invocations of <CODE>addPropertyChangeListener</CODE>,
313 * then an equivalent number of
314 * <CODE>removePropertyChangeListener</CODE> invocations are required to remove
315 * all instances of that listener from the listener table.
316 * <P>
317 * Returns silently if the given listener is not found.
318 *
319 * @param l event listener (can be null)
320 * @exception SecurityException if a security manager exists and if
321 * the caller does not have LoggingPermission("control").
322 */
323 public void removePropertyChangeListener(PropertyChangeListener l) throws SecurityException {
324 checkAccess();
325 changes.removePropertyChangeListener(l);
326 }
327
328 // Package-level method.
329 // Find or create a specified logger instance. If a logger has
330 // already been created with the given name it is returned.
331 // Otherwise a new logger instance is created and registered
332 // in the LogManager global namespace.
333 synchronized Logger demandLogger(String name) {
334 Logger result = getLogger(name);
335 if (result == null) {
336 result = new Logger(name, null);
337 addLogger(result);
338 result = getLogger(name);
339 }
340 return result;
341 }
342
343 // If logger.getUseParentHandlers() returns 'true' and any of the logger's
344 // parents have levels or handlers defined, make sure they are instantiated.
345 private void processParentHandlers(Logger logger, String name) {
346 int ix = 1;
347 for (;;) {
348 int ix2 = name.indexOf(".", ix);
349 if (ix2 < 0) {
350 break;
351 }
352 String pname = name.substring(0,ix2);
353
354 if (getProperty(pname+".level") != null ||
355 getProperty(pname+".handlers") != null) {
356 // This pname has a level/handlers definition.
357 // Make sure it exists.
358 demandLogger(pname);
359 }
360 ix = ix2+1;
361 }
362 }
363
364 // Add new per logger handlers.
365 // We need to raise privilege here. All our decisions will
366 // be made based on the logging configuration, which can
367 // only be modified by trusted code.
368 private void loadLoggerHandlers(final Logger logger, final String name,
369 final String handlersPropertyName) {
370 AccessController.doPrivileged(new PrivilegedAction<Object>() {
371 public Object run() {
372 if (logger != rootLogger) {
373 boolean useParent = getBooleanProperty(name + ".useParentHandlers", true);
374 if (!useParent) {
375 logger.setUseParentHandlers(false);
376 }
377 }
378
379 String names[] = parseClassNames(handlersPropertyName);
380 for (int i = 0; i < names.length; i++) {
381 String word = names[i];
382 try {
383 Class clz = ClassLoader.getSystemClassLoader().loadClass(word);
384 Handler hdl = (Handler) clz.newInstance();
385 try {
386 // Check if there is a property defining the
387 // this handler's level.
388 String levs = getProperty(word + ".level");
389 if (levs != null) {
390 hdl.setLevel(Level.parse(levs));
391 }
392 } catch (Exception ex) {
393 System.err.println("Can't set level for " + word);
394 // Probably a bad level. Drop through.
395 }
396 // Add this Handler to the logger
397 logger.addHandler(hdl);
398 } catch (Exception ex) {
399 System.err.println("Can't load log handler \"" + word + "\"");
400 System.err.println("" + ex);
401 ex.printStackTrace();
402 }
403 }
404 return null;
405 }});
406 }
407
408 /**
409 * Add a named logger. This does nothing and returns false if a logger
410 * with the same name is already registered.
411 * <p>
412 * The Logger factory methods call this method to register each
413 * newly created Logger.
414 * <p>
415 * The application should retain its own reference to the Logger
416 * object to avoid it being garbage collected. The LogManager
417 * may only retain a weak reference.
418 *
419 * @param logger the new logger.
420 * @return true if the argument logger was registered successfully,
421 * false if a logger of that name already exists.
422 * @exception NullPointerException if the logger name is null.
423 */
424 public synchronized boolean addLogger(Logger logger) {
425 final String name = logger.getName();
426 if (name == null) {
427 throw new NullPointerException();
428 }
429
430 WeakReference<Logger> ref = loggers.get(name);
431 if (ref != null) {
432 if (ref.get() == null) {
433 // Hashtable holds stale weak reference
434 // to a logger which has been GC-ed.
435 // Allow to register new one.
436 loggers.remove(name);
437 } else {
438 // We already have a registered logger with the given name.
439 return false;
440 }
441 }
442
443 // We're adding a new logger.
444 // Note that we are creating a weak reference here.
445 loggers.put(name, new WeakReference<Logger>(logger));
446
447 // Apply any initial level defined for the new logger.
448 Level level = getLevelProperty(name+".level", null);
449 if (level != null) {
450 doSetLevel(logger, level);
451 }
452
453 // Do we have a per logger handler too?
454 // Note: this will add a 200ms penalty
455 loadLoggerHandlers(logger, name, name+".handlers");
456 processParentHandlers(logger, name);
457
458 // Find the new node and its parent.
459 LogNode node = findNode(name);
460 node.loggerRef = new WeakReference<Logger>(logger);
461 Logger parent = null;
462 LogNode nodep = node.parent;
463 while (nodep != null) {
464 WeakReference<Logger> nodeRef = nodep.loggerRef;
465 if (nodeRef != null) {
466 parent = nodeRef.get();
467 if (parent != null) {
468 break;
469 }
470 }
471 nodep = nodep.parent;
472 }
473
474 if (parent != null) {
475 doSetParent(logger, parent);
476 }
477 // Walk over the children and tell them we are their new parent.
478 node.walkAndSetParent(logger);
479
480 return true;
481 }
482
483
484 // Private method to set a level on a logger.
485 // If necessary, we raise privilege before doing the call.
486 private static void doSetLevel(final Logger logger, final Level level) {
487 SecurityManager sm = System.getSecurityManager();
488 if (sm == null) {
489 // There is no security manager, so things are easy.
490 logger.setLevel(level);
491 return;
492 }
493 // There is a security manager. Raise privilege before
494 // calling setLevel.
495 AccessController.doPrivileged(new PrivilegedAction<Object>() {
496 public Object run() {
497 logger.setLevel(level);
498 return null;
499 }});
500 }
501
502
503
504 // Private method to set a parent on a logger.
505 // If necessary, we raise privilege before doing the setParent call.
506 private static void doSetParent(final Logger logger, final Logger parent) {
507 SecurityManager sm = System.getSecurityManager();
508 if (sm == null) {
509 // There is no security manager, so things are easy.
510 logger.setParent(parent);
511 return;
512 }
513 // There is a security manager. Raise privilege before
514 // calling setParent.
515 AccessController.doPrivileged(new PrivilegedAction<Object>() {
516 public Object run() {
517 logger.setParent(parent);
518 return null;
519 }});
520 }
521
522 // Find a node in our tree of logger nodes.
523 // If necessary, create it.
524 private LogNode findNode(String name) {
525 if (name == null || name.equals("")) {
526 return root;
527 }
528 LogNode node = root;
529 while (name.length() > 0) {
530 int ix = name.indexOf(".");
531 String head;
532 if (ix > 0) {
533 head = name.substring(0,ix);
534 name = name.substring(ix+1);
535 } else {
536 head = name;
537 name = "";
538 }
539 if (node.children == null) {
540 node.children = new HashMap<String,LogNode>();
541 }
542 LogNode child = node.children.get(head);
543 if (child == null) {
544 child = new LogNode(node);
545 node.children.put(head, child);
546 }
547 node = child;
548 }
549 return node;
550 }
551
552 /**
553 * Method to find a named logger.
554 * <p>
555 * Note that since untrusted code may create loggers with
556 * arbitrary names this method should not be relied on to
557 * find Loggers for security sensitive logging.
558 * <p>
559 * @param name name of the logger
560 * @return matching logger or null if none is found
561 */
562 public synchronized Logger getLogger(String name) {
563 WeakReference<Logger> ref = loggers.get(name);
564 if (ref == null) {
565 return null;
566 }
567 Logger logger = ref.get();
568 if (logger == null) {
569 // Hashtable holds stale weak reference
570 // to a logger which has been GC-ed.
571 loggers.remove(name);
572 }
573 return logger;
574 }
575
576 /**
577 * Get an enumeration of known logger names.
578 * <p>
579 * Note: Loggers may be added dynamically as new classes are loaded.
580 * This method only reports on the loggers that are currently registered.
581 * <p>
582 * @return enumeration of logger name strings
583 */
584 public synchronized Enumeration<String> getLoggerNames() {
585 return loggers.keys();
586 }
587
588 /**
589 * Reinitialize the logging properties and reread the logging configuration.
590 * <p>
591 * The same rules are used for locating the configuration properties
592 * as are used at startup. So normally the logging properties will
593 * be re-read from the same file that was used at startup.
594 * <P>
595 * Any log level definitions in the new configuration file will be
596 * applied using Logger.setLevel(), if the target Logger exists.
597 * <p>
598 * A PropertyChangeEvent will be fired after the properties are read.
599 *
600 * @exception SecurityException if a security manager exists and if
601 * the caller does not have LoggingPermission("control").
602 * @exception IOException if there are IO problems reading the configuration.
603 */
604 public void readConfiguration() throws IOException, SecurityException {
605 checkAccess();
606
607 // if a configuration class is specified, load it and use it.
608 String cname = System.getProperty("java.util.logging.config.class");
609 if (cname != null) {
610 try {
611 // Instantiate the named class. It is its constructor's
612 // responsibility to initialize the logging configuration, by
613 // calling readConfiguration(InputStream) with a suitable stream.
614 try {
615 Class clz = ClassLoader.getSystemClassLoader().loadClass(cname);
616 clz.newInstance();
617 return;
618 } catch (ClassNotFoundException ex) {
619 Class clz = Thread.currentThread().getContextClassLoader().loadClass(cname);
620 clz.newInstance();
621 return;
622 }
623 } catch (Exception ex) {
624 System.err.println("Logging configuration class \"" + cname + "\" failed");
625 System.err.println("" + ex);
626 // keep going and useful config file.
627 }
628 }
629
630 String fname = System.getProperty("java.util.logging.config.file");
631 if (fname == null) {
632 fname = System.getProperty("java.home");
633 if (fname == null) {
634 throw new Error("Can't find java.home ??");
635 }
636 File f = new File(fname, "lib");
637 f = new File(f, "logging.properties");
638 fname = f.getCanonicalPath();
639 }
640 InputStream in = new FileInputStream(fname);
641 BufferedInputStream bin = new BufferedInputStream(in);
642 try {
643 readConfiguration(bin);
644 } finally {
645 if (in != null) {
646 in.close();
647 }
648 }
649 }
650
651 /**
652 * Reset the logging configuration.
653 * <p>
654 * For all named loggers, the reset operation removes and closes
655 * all Handlers and (except for the root logger) sets the level
656 * to null. The root logger's level is set to Level.INFO.
657 *
658 * @exception SecurityException if a security manager exists and if
659 * the caller does not have LoggingPermission("control").
660 */
661
662 public void reset() throws SecurityException {
663 checkAccess();
664 synchronized (this) {
665 props = new Properties();
666 // Since we are doing a reset we no longer want to initialize
667 // the global handlers, if they haven't been initialized yet.
668 initializedGlobalHandlers = true;
669 }
670 Enumeration enum_ = getLoggerNames();
671 while (enum_.hasMoreElements()) {
672 String name = (String)enum_.nextElement();
673 resetLogger(name);
674 }
675 }
676
677
678 // Private method to reset an individual target logger.
679 private void resetLogger(String name) {
680 Logger logger = getLogger(name);
681 if (logger == null) {
682 return;
683 }
684 // Close all the Logger's handlers.
685 Handler[] targets = logger.getHandlers();
686 for (int i = 0; i < targets.length; i++) {
687 Handler h = targets[i];
688 logger.removeHandler(h);
689 try {
690 h.close();
691 } catch (Exception ex) {
692 // Problems closing a handler? Keep going...
693 }
694 }
695 if (name != null && name.equals("")) {
696 // This is the root logger.
697 logger.setLevel(defaultLevel);
698 } else {
699 logger.setLevel(null);
700 }
701 }
702
703 // get a list of whitespace separated classnames from a property.
704 private String[] parseClassNames(String propertyName) {
705 String hands = getProperty(propertyName);
706 if (hands == null) {
707 return new String[0];
708 }
709 hands = hands.trim();
710 int ix = 0;
711 Vector<String> result = new Vector<String>();
712 while (ix < hands.length()) {
713 int end = ix;
714 while (end < hands.length()) {
715 if (Character.isWhitespace(hands.charAt(end))) {
716 break;
717 }
718 if (hands.charAt(end) == ',') {
719 break;
720 }
721 end++;
722 }
723 String word = hands.substring(ix, end);
724 ix = end+1;
725 word = word.trim();
726 if (word.length() == 0) {
727 continue;
728 }
729 result.add(word);
730 }
731 return result.toArray(new String[result.size()]);
732 }
733
734 /**
735 * Reinitialize the logging properties and reread the logging configuration
736 * from the given stream, which should be in java.util.Properties format.
737 * A PropertyChangeEvent will be fired after the properties are read.
738 * <p>
739 * Any log level definitions in the new configuration file will be
740 * applied using Logger.setLevel(), if the target Logger exists.
741 *
742 * @param ins stream to read properties from
743 * @exception SecurityException if a security manager exists and if
744 * the caller does not have LoggingPermission("control").
745 * @exception IOException if there are problems reading from the stream.
746 */
747 public void readConfiguration(InputStream ins) throws IOException, SecurityException {
748 checkAccess();
749 reset();
750
751 // Load the properties
752 props.load(ins);
753 // Instantiate new configuration objects.
754 String names[] = parseClassNames("config");
755
756 for (int i = 0; i < names.length; i++) {
757 String word = names[i];
758 try {
759 Class clz = ClassLoader.getSystemClassLoader().loadClass(word);
760 clz.newInstance();
761 } catch (Exception ex) {
762 System.err.println("Can't load config class \"" + word + "\"");
763 System.err.println("" + ex);
764 // ex.printStackTrace();
765 }
766 }
767
768 // Set levels on any pre-existing loggers, based on the new properties.
769 setLevelsOnExistingLoggers();
770
771 // Notify any interested parties that our properties have changed.
772 changes.firePropertyChange(null, null, null);
773
774 // Note that we need to reinitialize global handles when
775 // they are first referenced.
776 synchronized (this) {
777 initializedGlobalHandlers = false;
778 }
779 }
780
781 /**
782 * Get the value of a logging property.
783 * The method returns null if the property is not found.
784 * @param name property name
785 * @return property value
786 */
787 public String getProperty(String name) {
788 return props.getProperty(name);
789 }
790
791 // Package private method to get a String property.
792 // If the property is not defined we return the given
793 // default value.
794 String getStringProperty(String name, String defaultValue) {
795 String val = getProperty(name);
796 if (val == null) {
797 return defaultValue;
798 }
799 return val.trim();
800 }
801
802 // Package private method to get an integer property.
803 // If the property is not defined or cannot be parsed
804 // we return the given default value.
805 int getIntProperty(String name, int defaultValue) {
806 String val = getProperty(name);
807 if (val == null) {
808 return defaultValue;
809 }
810 try {
811 return Integer.parseInt(val.trim());
812 } catch (Exception ex) {
813 return defaultValue;
814 }
815 }
816
817 // Package private method to get a boolean property.
818 // If the property is not defined or cannot be parsed
819 // we return the given default value.
820 boolean getBooleanProperty(String name, boolean defaultValue) {
821 String val = getProperty(name);
822 if (val == null) {
823 return defaultValue;
824 }
825 val = val.toLowerCase();
826 if (val.equals("true") || val.equals("1")) {
827 return true;
828 } else if (val.equals("false") || val.equals("0")) {
829 return false;
830 }
831 return defaultValue;
832 }
833
834 // Package private method to get a Level property.
835 // If the property is not defined or cannot be parsed
836 // we return the given default value.
837 Level getLevelProperty(String name, Level defaultValue) {
838 String val = getProperty(name);
839 if (val == null) {
840 return defaultValue;
841 }
842 try {
843 return Level.parse(val.trim());
844 } catch (Exception ex) {
845 return defaultValue;
846 }
847 }
848
849 // Package private method to get a filter property.
850 // We return an instance of the class named by the "name"
851 // property. If the property is not defined or has problems
852 // we return the defaultValue.
853 Filter getFilterProperty(String name, Filter defaultValue) {
854 String val = getProperty(name);
855 try {
856 if (val != null) {
857 Class clz = ClassLoader.getSystemClassLoader().loadClass(val);
858 return (Filter) clz.newInstance();
859 }
860 } catch (Exception ex) {
861 // We got one of a variety of exceptions in creating the
862 // class or creating an instance.
863 // Drop through.
864 }
865 // We got an exception. Return the defaultValue.
866 return defaultValue;
867 }
868
869
870 // Package private method to get a formatter property.
871 // We return an instance of the class named by the "name"
872 // property. If the property is not defined or has problems
873 // we return the defaultValue.
874 Formatter getFormatterProperty(String name, Formatter defaultValue) {
875 String val = getProperty(name);
876 try {
877 if (val != null) {
878 Class clz = ClassLoader.getSystemClassLoader().loadClass(val);
879 return (Formatter) clz.newInstance();
880 }
881 } catch (Exception ex) {
882 // We got one of a variety of exceptions in creating the
883 // class or creating an instance.
884 // Drop through.
885 }
886 // We got an exception. Return the defaultValue.
887 return defaultValue;
888 }
889
890 // Private method to load the global handlers.
891 // We do the real work lazily, when the global handlers
892 // are first used.
893 private synchronized void initializeGlobalHandlers() {
894 if (initializedGlobalHandlers) {
895 return;
896 }
897
898 initializedGlobalHandlers = true;
899
900 if (deathImminent) {
901 // Aaargh...
902 // The VM is shutting down and our exit hook has been called.
903 // Avoid allocating global handlers.
904 return;
905 }
906 loadLoggerHandlers(rootLogger, null, "handlers");
907 }
908
909
910 private Permission ourPermission = new LoggingPermission("control", null);
911
912 /**
913 * Check that the current context is trusted to modify the logging
914 * configuration. This requires LoggingPermission("control").
915 * <p>
916 * If the check fails we throw a SecurityException, otherwise
917 * we return normally.
918 *
919 * @exception SecurityException if a security manager exists and if
920 * the caller does not have LoggingPermission("control").
921 */
922 public void checkAccess() throws SecurityException {
923 SecurityManager sm = System.getSecurityManager();
924 if (sm == null) {
925 return;
926 }
927 sm.checkPermission(ourPermission);
928 }
929
930 // Nested class to represent a node in our tree of named loggers.
931 private static class LogNode {
932 HashMap<String,LogNode> children;
933 WeakReference<Logger> loggerRef;
934 LogNode parent;
935
936 LogNode(LogNode parent) {
937 this.parent = parent;
938 }
939
940 // Recursive method to walk the tree below a node and set
941 // a new parent logger.
942 void walkAndSetParent(Logger parent) {
943 if (children == null) {
944 return;
945 }
946 Iterator<LogNode> values = children.values().iterator();
947 while (values.hasNext()) {
948 LogNode node = values.next();
949 WeakReference<Logger> ref = node.loggerRef;
950 Logger logger = (ref == null) ? null : ref.get();
951 if (logger == null) {
952 node.walkAndSetParent(parent);
953 } else {
954 doSetParent(logger, parent);
955 }
956 }
957 }
958 }
959
960 // We use a subclass of Logger for the root logger, so
961 // that we only instantiate the global handlers when they
962 // are first needed.
963 private class RootLogger extends Logger {
964
965 private RootLogger() {
966 super("", null);
967 setLevel(defaultLevel);
968 }
969
970 public void log(LogRecord record) {
971 // Make sure that the global handlers have been instantiated.
972 initializeGlobalHandlers();
973 super.log(record);
974 }
975
976 public void addHandler(Handler h) {
977 initializeGlobalHandlers();
978 super.addHandler(h);
979 }
980
981 public void removeHandler(Handler h) {
982 initializeGlobalHandlers();
983 super.removeHandler(h);
984 }
985
986 public Handler[] getHandlers() {
987 initializeGlobalHandlers();
988 return super.getHandlers();
989 }
990 }
991
992
993 // Private method to be called when the configuration has
994 // changed to apply any level settings to any pre-existing loggers.
995 synchronized private void setLevelsOnExistingLoggers() {
996 Enumeration enum_ = props.propertyNames();
997 while (enum_.hasMoreElements()) {
998 String key = (String)enum_.nextElement();
999 if (!key.endsWith(".level")) {
1000 // Not a level definition.
1001 continue;
1002 }
1003 int ix = key.length() - 6;
1004 String name = key.substring(0, ix);
1005 Level level = getLevelProperty(key, null);
1006 if (level == null) {
1007 System.err.println("Bad level value for property: " + key);
1008 continue;
1009 }
1010 Logger l = getLogger(name);
1011 if (l == null) {
1012 continue;
1013 }
1014 l.setLevel(level);
1015 }
1016 }
1017
1018 // Management Support
1019 private static LoggingMXBean loggingMXBean = null;
1020 /**
1021 * String representation of the
1022 * {@link javax.management.ObjectName} for {@link LoggingMXBean}.
1023 * @since 1.5
1024 */
1025 public final static String LOGGING_MXBEAN_NAME
1026 = "java.util.logging:type=Logging";
1027
1028 /**
1029 * Returns <tt>LoggingMXBean</tt> for managing loggers.
1030 * The <tt>LoggingMXBean</tt> can also obtained from the
1031 * {@link java.lang.management.ManagementFactory#getPlatformMBeanServer
1032 * platform <tt>MBeanServer</tt>} method.
1033 *
1034 * @return a {@link LoggingMXBean} object.
1035 *
1036 * @see java.lang.management.ManagementFactory
1037 * @since 1.5
1038 */
1039 public static synchronized LoggingMXBean getLoggingMXBean() {
1040 if (loggingMXBean == null) {
1041 loggingMXBean = new Logging();
1042 }
1043 return loggingMXBean;
1044 }
1045
1046 }
Save This Page