| Frames | No Frames |
1: /* LogManager.java -- a class for maintaining Loggers and managing 2: configuration properties 3: Copyright (C) 2002, 2005, 2006, 2007 Free Software Foundation, Inc. 4: 5: This file is part of GNU Classpath. 6: 7: GNU Classpath is free software; you can redistribute it and/or modify 8: it under the terms of the GNU General Public License as published by 9: the Free Software Foundation; either version 2, or (at your option) 10: any later version. 11: 12: GNU Classpath is distributed in the hope that it will be useful, but 13: WITHOUT ANY WARRANTY; without even the implied warranty of 14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15: General Public License for more details. 16: 17: You should have received a copy of the GNU General Public License 18: along with GNU Classpath; see the file COPYING. If not, write to the 19: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 20: 02110-1301 USA. 21: 22: Linking this library statically or dynamically with other modules is 23: making a combined work based on this library. Thus, the terms and 24: conditions of the GNU General Public License cover the whole 25: combination. 26: 27: As a special exception, the copyright holders of this library give you 28: permission to link this library with independent modules to produce an 29: executable, regardless of the license terms of these independent 30: modules, and to copy and distribute the resulting executable under 31: terms of your choice, provided that you also meet, for each linked 32: independent module, the terms and conditions of the license of that 33: module. An independent module is a module which is not derived from 34: or based on this library. If you modify this library, you may extend 35: this exception to your version of the library, but you are not 36: obligated to do so. If you do not wish to do so, delete this 37: exception statement from your version. */ 38: 39: 40: package java.util.logging; 41: 42: import gnu.classpath.SystemProperties; 43: 44: import java.beans.PropertyChangeListener; 45: import java.beans.PropertyChangeSupport; 46: import java.io.ByteArrayInputStream; 47: import java.io.IOException; 48: import java.io.InputStream; 49: import java.lang.ref.WeakReference; 50: import java.net.URL; 51: import java.util.Collections; 52: import java.util.Enumeration; 53: import java.util.HashMap; 54: import java.util.Iterator; 55: import java.util.List; 56: import java.util.Map; 57: import java.util.Properties; 58: import java.util.StringTokenizer; 59: 60: /** 61: * The <code>LogManager</code> maintains a hierarchical namespace 62: * of Logger objects and manages properties for configuring the logging 63: * framework. There exists only one single <code>LogManager</code> 64: * per virtual machine. This instance can be retrieved using the 65: * static method {@link #getLogManager()}. 66: * 67: * <p><strong>Configuration Process:</strong> The global LogManager 68: * object is created and configured when the class 69: * <code>java.util.logging.LogManager</code> is initialized. 70: * The configuration process includes the subsequent steps: 71: * 72: * <ul> 73: * <li>If the system property <code>java.util.logging.manager</code> 74: * is set to the name of a subclass of 75: * <code>java.util.logging.LogManager</code>, an instance of 76: * that subclass is created and becomes the global LogManager. 77: * Otherwise, a new instance of LogManager is created.</li> 78: * <li>The <code>LogManager</code> constructor tries to create 79: * a new instance of the class specified by the system 80: * property <code>java.util.logging.config.class</code>. 81: * Typically, the constructor of this class will call 82: * <code>LogManager.getLogManager().readConfiguration(java.io.InputStream)</code> 83: * for configuring the logging framework. 84: * The configuration process stops at this point if 85: * the system property <code>java.util.logging.config.class</code> 86: * is set (irrespective of whether the class constructor 87: * could be called or an exception was thrown).</li> 88: * 89: * <li>If the system property <code>java.util.logging.config.class</code> 90: * is <em>not</em> set, the configuration parameters are read in from 91: * a file and passed to 92: * {@link #readConfiguration(java.io.InputStream)}. 93: * The name and location of this file are specified by the system 94: * property <code>java.util.logging.config.file</code>.</li> 95: * <li>If the system property <code>java.util.logging.config.file</code> 96: * is not set, however, the contents of the URL 97: * "{gnu.classpath.home.url}/logging.properties" are passed to 98: * {@link #readConfiguration(java.io.InputStream)}. 99: * Here, "{gnu.classpath.home.url}" stands for the value of 100: * the system property <code>gnu.classpath.home.url</code>.</li> 101: * </ul> 102: * 103: * <p>The <code>LogManager</code> has a level of <code>INFO</code> by 104: * default, and this will be inherited by <code>Logger</code>s unless they 105: * override it either by properties or programmatically. 106: * 107: * @author Sascha Brawer (brawer@acm.org) 108: */ 109: public class LogManager 110: { 111: /** 112: * The object name for the logging management bean. 113: * @since 1.5 114: */ 115: public static final String LOGGING_MXBEAN_NAME 116: = "java.util.logging:type=Logging"; 117: 118: /** 119: * The singleton LogManager instance. 120: */ 121: private static LogManager logManager; 122: 123: /** 124: * The singleton logging bean. 125: */ 126: private static LoggingMXBean loggingBean; 127: 128: /** 129: * The registered named loggers; maps the name of a Logger to 130: * a WeakReference to it. 131: */ 132: private Map<String, WeakReference<Logger>> loggers; 133: 134: /** 135: * The properties for the logging framework which have been 136: * read in last. 137: */ 138: private Properties properties; 139: 140: /** 141: * A delegate object that provides support for handling 142: * PropertyChangeEvents. The API specification does not 143: * mention which bean should be the source in the distributed 144: * PropertyChangeEvents, but Mauve test code has determined that 145: * the Sun J2SE 1.4 reference implementation uses the LogManager 146: * class object. This is somewhat strange, as the class object 147: * is not the bean with which listeners have to register, but 148: * there is no reason for the GNU Classpath implementation to 149: * behave differently from the reference implementation in 150: * this case. 151: */ 152: private final PropertyChangeSupport pcs = new PropertyChangeSupport( /* source bean */ 153: LogManager.class); 154: 155: protected LogManager() 156: { 157: loggers = new HashMap(); 158: } 159: 160: /** 161: * Returns the globally shared LogManager instance. 162: */ 163: public static synchronized LogManager getLogManager() 164: { 165: if (logManager == null) 166: { 167: logManager = makeLogManager(); 168: initLogManager(); 169: } 170: return logManager; 171: } 172: 173: private static final String MANAGER_PROPERTY = "java.util.logging.manager"; 174: 175: private static LogManager makeLogManager() 176: { 177: String managerClassName = SystemProperties.getProperty(MANAGER_PROPERTY); 178: LogManager manager = (LogManager) createInstance 179: (managerClassName, LogManager.class, MANAGER_PROPERTY); 180: if (manager == null) 181: manager = new LogManager(); 182: return manager; 183: } 184: 185: private static final String CONFIG_PROPERTY = "java.util.logging.config.class"; 186: 187: private static void initLogManager() 188: { 189: LogManager manager = getLogManager(); 190: Logger.root.setLevel(Level.INFO); 191: manager.addLogger(Logger.root); 192: 193: /* The Javadoc description of the class explains 194: * what is going on here. 195: */ 196: Object configurator = createInstance(System.getProperty(CONFIG_PROPERTY), 197: /* must be instance of */ Object.class, 198: CONFIG_PROPERTY); 199: 200: try 201: { 202: if (configurator == null) 203: manager.readConfiguration(); 204: } 205: catch (IOException ex) 206: { 207: /* FIXME: Is it ok to ignore exceptions here? */ 208: } 209: } 210: 211: /** 212: * Registers a listener which will be notified when the 213: * logging properties are re-read. 214: */ 215: public synchronized void addPropertyChangeListener(PropertyChangeListener listener) 216: { 217: /* do not register null. */ 218: listener.getClass(); 219: 220: pcs.addPropertyChangeListener(listener); 221: } 222: 223: /** 224: * Unregisters a listener. 225: * 226: * If <code>listener</code> has not been registered previously, 227: * nothing happens. Also, no exception is thrown if 228: * <code>listener</code> is <code>null</code>. 229: */ 230: public synchronized void removePropertyChangeListener(PropertyChangeListener listener) 231: { 232: if (listener != null) 233: pcs.removePropertyChangeListener(listener); 234: } 235: 236: /** 237: * Adds a named logger. If a logger with the same name has 238: * already been registered, the method returns <code>false</code> 239: * without adding the logger. 240: * 241: * <p>The <code>LogManager</code> only keeps weak references 242: * to registered loggers. Therefore, names can become available 243: * after automatic garbage collection. 244: * 245: * @param logger the logger to be added. 246: * 247: * @return <code>true</code>if <code>logger</code> was added, 248: * <code>false</code> otherwise. 249: * 250: * @throws NullPointerException if <code>name</code> is 251: * <code>null</code>. 252: */ 253: public synchronized boolean addLogger(Logger logger) 254: { 255: /* To developers thinking about to remove the 'synchronized' 256: * declaration from this method: Please read the comment 257: * in java.util.logging.Logger.getLogger(String, String) 258: * and make sure that whatever you change wrt. synchronization 259: * does not endanger thread-safety of Logger.getLogger. 260: * The current implementation of Logger.getLogger assumes 261: * that LogManager does its synchronization on the globally 262: * shared instance of LogManager. 263: */ 264: String name; 265: WeakReference ref; 266: 267: /* This will throw a NullPointerException if logger is null, 268: * as required by the API specification. 269: */ 270: name = logger.getName(); 271: 272: ref = loggers.get(name); 273: if (ref != null) 274: { 275: if (ref.get() != null) 276: return false; 277: 278: /* There has been a logger under this name in the past, 279: * but it has been garbage collected. 280: */ 281: loggers.remove(ref); 282: } 283: 284: /* Adding a named logger requires a security permission. */ 285: if ((name != null) && ! name.equals("")) 286: checkAccess(); 287: 288: Logger parent = findAncestor(logger); 289: loggers.put(name, new WeakReference<Logger>(logger)); 290: if (parent != logger.getParent()) 291: logger.setParent(parent); 292: 293: // The level of the newly added logger must be specified. 294: // The easiest case is if there is a level for exactly this logger 295: // in the properties. If no such level exists the level needs to be 296: // searched along the hirachy. So if there is a new logger 'foo.blah.blub' 297: // and an existing parent logger 'foo' the properties 'foo.blah.blub.level' 298: // and 'foo.blah.level' need to be checked. If both do not exist in the 299: // properties the level of the new logger is set to 'null' (i.e. it uses the 300: // level of its parent 'foo'). 301: Level logLevel = logger.getLevel(); 302: String searchName = name; 303: String parentName = parent != null ? parent.getName() : ""; 304: while (logLevel == null && ! searchName.equals(parentName)) 305: { 306: logLevel = getLevelProperty(searchName + ".level", logLevel); 307: int index = searchName.lastIndexOf('.'); 308: if(index > -1) 309: searchName = searchName.substring(0,index); 310: else 311: searchName = ""; 312: } 313: logger.setLevel(logLevel); 314: 315: /* It can happen that existing loggers should be children of 316: * the newly added logger. For example, assume that there 317: * already exist loggers under the names "", "foo", and "foo.bar.baz". 318: * When adding "foo.bar", the logger "foo.bar.baz" should change 319: * its parent to "foo.bar". 320: */ 321: for (Iterator iter = loggers.keySet().iterator(); iter.hasNext();) 322: { 323: Logger possChild = (Logger) ((WeakReference) loggers.get(iter.next())) 324: .get(); 325: if ((possChild == null) || (possChild == logger) 326: || (possChild.getParent() != parent)) 327: continue; 328: 329: if (! possChild.getName().startsWith(name)) 330: continue; 331: 332: if (possChild.getName().charAt(name.length()) != '.') 333: continue; 334: 335: possChild.setParent(logger); 336: } 337: 338: return true; 339: } 340: 341: /** 342: * Finds the closest ancestor for a logger among the currently 343: * registered ones. For example, if the currently registered 344: * loggers have the names "", "foo", and "foo.bar", the result for 345: * "foo.bar.baz" will be the logger whose name is "foo.bar". 346: * 347: * @param child a logger for whose name no logger has been 348: * registered. 349: * 350: * @return the closest ancestor for <code>child</code>, 351: * or <code>null</code> if <code>child</code> 352: * is the root logger. 353: * 354: * @throws NullPointerException if <code>child</code> 355: * is <code>null</code>. 356: */ 357: private synchronized Logger findAncestor(Logger child) 358: { 359: String childName = child.getName(); 360: int childNameLength = childName.length(); 361: Logger best = Logger.root; 362: int bestNameLength = 0; 363: 364: Logger cand; 365: int candNameLength; 366: 367: if (child == Logger.root) 368: return null; 369: 370: for (String candName : loggers.keySet()) 371: { 372: candNameLength = candName.length(); 373: 374: if (candNameLength > bestNameLength 375: && childNameLength > candNameLength 376: && childName.startsWith(candName) 377: && childName.charAt(candNameLength) == '.') 378: { 379: cand = loggers.get(candName).get(); 380: if ((cand == null) || (cand == child)) 381: continue; 382: 383: bestNameLength = candName.length(); 384: best = cand; 385: } 386: } 387: 388: return best; 389: } 390: 391: /** 392: * Returns a Logger given its name. 393: * 394: * @param name the name of the logger. 395: * 396: * @return a named Logger, or <code>null</code> if there is no 397: * logger with that name. 398: * 399: * @throw java.lang.NullPointerException if <code>name</code> 400: * is <code>null</code>. 401: */ 402: public synchronized Logger getLogger(String name) 403: { 404: WeakReference<Logger> ref; 405: 406: /* Throw a NullPointerException if name is null. */ 407: name.getClass(); 408: 409: ref = loggers.get(name); 410: if (ref != null) 411: return ref.get(); 412: else 413: return null; 414: } 415: 416: /** 417: * Returns an Enumeration of currently registered Logger names. 418: * Since other threads can register loggers at any time, the 419: * result could be different any time this method is called. 420: * 421: * @return an Enumeration with the names of the currently 422: * registered Loggers. 423: */ 424: public synchronized Enumeration<String> getLoggerNames() 425: { 426: return Collections.enumeration(loggers.keySet()); 427: } 428: 429: /** 430: * Resets the logging configuration by removing all handlers for 431: * registered named loggers and setting their level to <code>null</code>. 432: * The level of the root logger will be set to <code>Level.INFO</code>. 433: * 434: * @throws SecurityException if a security manager exists and 435: * the caller is not granted the permission to control 436: * the logging infrastructure. 437: */ 438: public synchronized void reset() throws SecurityException 439: { 440: /* Throw a SecurityException if the caller does not have the 441: * permission to control the logging infrastructure. 442: */ 443: checkAccess(); 444: 445: properties = new Properties(); 446: 447: Iterator<WeakReference<Logger>> iter = loggers.values().iterator(); 448: while (iter.hasNext()) 449: { 450: WeakReference<Logger> ref; 451: Logger logger; 452: 453: ref = iter.next(); 454: if (ref != null) 455: { 456: logger = ref.get(); 457: 458: if (logger == null) 459: iter.remove(); 460: else if (logger != Logger.root) 461: { 462: logger.resetLogger(); 463: logger.setLevel(null); 464: } 465: } 466: } 467: 468: Logger.root.setLevel(Level.INFO); 469: Logger.root.resetLogger(); 470: } 471: 472: /** 473: * Configures the logging framework by reading a configuration file. 474: * The name and location of this file are specified by the system 475: * property <code>java.util.logging.config.file</code>. If this 476: * property is not set, the URL 477: * "{gnu.classpath.home.url}/logging.properties" is taken, where 478: * "{gnu.classpath.home.url}" stands for the value of the system 479: * property <code>gnu.classpath.home.url</code>. 480: * 481: * <p>The task of configuring the framework is then delegated to 482: * {@link #readConfiguration(java.io.InputStream)}, which will 483: * notify registered listeners after having read the properties. 484: * 485: * @throws SecurityException if a security manager exists and 486: * the caller is not granted the permission to control 487: * the logging infrastructure, or if the caller is 488: * not granted the permission to read the configuration 489: * file. 490: * 491: * @throws IOException if there is a problem reading in the 492: * configuration file. 493: */ 494: public synchronized void readConfiguration() 495: throws IOException, SecurityException 496: { 497: String path; 498: InputStream inputStream; 499: 500: path = System.getProperty("java.util.logging.config.file"); 501: if ((path == null) || (path.length() == 0)) 502: { 503: String url = (System.getProperty("gnu.classpath.home.url") 504: + "/logging.properties"); 505: try 506: { 507: inputStream = new URL(url).openStream(); 508: } 509: catch (Exception e) 510: { 511: inputStream=null; 512: } 513: 514: // If no config file could be found use a default configuration. 515: if(inputStream == null) 516: { 517: String defaultConfig = "handlers = java.util.logging.ConsoleHandler \n" 518: + ".level=INFO \n"; 519: inputStream = new ByteArrayInputStream(defaultConfig.getBytes()); 520: } 521: } 522: else 523: inputStream = new java.io.FileInputStream(path); 524: 525: try 526: { 527: readConfiguration(inputStream); 528: } 529: finally 530: { 531: // Close the stream in order to save 532: // resources such as file descriptors. 533: inputStream.close(); 534: } 535: } 536: 537: public synchronized void readConfiguration(InputStream inputStream) 538: throws IOException, SecurityException 539: { 540: Properties newProperties; 541: Enumeration keys; 542: 543: checkAccess(); 544: newProperties = new Properties(); 545: newProperties.load(inputStream); 546: reset(); 547: this.properties = newProperties; 548: keys = newProperties.propertyNames(); 549: 550: while (keys.hasMoreElements()) 551: { 552: String key = ((String) keys.nextElement()).trim(); 553: String value = newProperties.getProperty(key); 554: 555: if (value == null) 556: continue; 557: 558: value = value.trim(); 559: 560: if ("handlers".equals(key)) 561: { 562: // In Java 5 and earlier this was specified to be 563: // whitespace-separated, but in reality it also accepted 564: // commas (tomcat relied on this), and in Java 6 the 565: // documentation was updated to fit the implementation. 566: StringTokenizer tokenizer = new StringTokenizer(value, 567: " \t\n\r\f,"); 568: while (tokenizer.hasMoreTokens()) 569: { 570: String handlerName = tokenizer.nextToken(); 571: Handler handler = (Handler) 572: createInstance(handlerName, Handler.class, key); 573: // Tomcat also relies on the implementation ignoring 574: // items in 'handlers' which are not class names. 575: if (handler != null) 576: Logger.root.addHandler(handler); 577: } 578: } 579: 580: if (key.endsWith(".level")) 581: { 582: String loggerName = key.substring(0, key.length() - 6); 583: Logger logger = getLogger(loggerName); 584: 585: if (logger == null) 586: { 587: logger = Logger.getLogger(loggerName); 588: addLogger(logger); 589: } 590: Level level = null; 591: try 592: { 593: level = Level.parse(value); 594: } 595: catch (IllegalArgumentException e) 596: { 597: warn("bad level \'" + value + "\'", e); 598: } 599: if (level != null) 600: { 601: logger.setLevel(level); 602: } 603: continue; 604: } 605: } 606: 607: /* The API specification does not talk about the 608: * property name that is distributed with the 609: * PropertyChangeEvent. With test code, it could 610: * be determined that the Sun J2SE 1.4 reference 611: * implementation uses null for the property name. 612: */ 613: pcs.firePropertyChange(null, null, null); 614: } 615: 616: /** 617: * Returns the value of a configuration property as a String. 618: */ 619: public synchronized String getProperty(String name) 620: { 621: if (properties != null) 622: return properties.getProperty(name); 623: else 624: return null; 625: } 626: 627: /** 628: * Returns the value of a configuration property as an integer. 629: * This function is a helper used by the Classpath implementation 630: * of java.util.logging, it is <em>not</em> specified in the 631: * logging API. 632: * 633: * @param name the name of the configuration property. 634: * 635: * @param defaultValue the value that will be returned if the 636: * property is not defined, or if its value is not an integer 637: * number. 638: */ 639: static int getIntProperty(String name, int defaultValue) 640: { 641: try 642: { 643: return Integer.parseInt(getLogManager().getProperty(name)); 644: } 645: catch (Exception ex) 646: { 647: return defaultValue; 648: } 649: } 650: 651: /** 652: * Returns the value of a configuration property as an integer, 653: * provided it is inside the acceptable range. 654: * This function is a helper used by the Classpath implementation 655: * of java.util.logging, it is <em>not</em> specified in the 656: * logging API. 657: * 658: * @param name the name of the configuration property. 659: * 660: * @param minValue the lowest acceptable value. 661: * 662: * @param maxValue the highest acceptable value. 663: * 664: * @param defaultValue the value that will be returned if the 665: * property is not defined, or if its value is not an integer 666: * number, or if it is less than the minimum value, 667: * or if it is greater than the maximum value. 668: */ 669: static int getIntPropertyClamped(String name, int defaultValue, 670: int minValue, int maxValue) 671: { 672: int val = getIntProperty(name, defaultValue); 673: if ((val < minValue) || (val > maxValue)) 674: val = defaultValue; 675: return val; 676: } 677: 678: /** 679: * Returns the value of a configuration property as a boolean. 680: * This function is a helper used by the Classpath implementation 681: * of java.util.logging, it is <em>not</em> specified in the 682: * logging API. 683: * 684: * @param name the name of the configuration property. 685: * 686: * @param defaultValue the value that will be returned if the 687: * property is not defined, or if its value is neither 688: * <code>"true"</code> nor <code>"false"</code>. 689: */ 690: static boolean getBooleanProperty(String name, boolean defaultValue) 691: { 692: try 693: { 694: return (Boolean.valueOf(getLogManager().getProperty(name))).booleanValue(); 695: } 696: catch (Exception ex) 697: { 698: return defaultValue; 699: } 700: } 701: 702: /** 703: * Returns the value of a configuration property as a Level. 704: * This function is a helper used by the Classpath implementation 705: * of java.util.logging, it is <em>not</em> specified in the 706: * logging API. 707: * 708: * @param propertyName the name of the configuration property. 709: * 710: * @param defaultValue the value that will be returned if the 711: * property is not defined, or if 712: * {@link Level#parse(java.lang.String)} does not like 713: * the property value. 714: */ 715: static Level getLevelProperty(String propertyName, Level defaultValue) 716: { 717: try 718: { 719: String value = getLogManager().getProperty(propertyName); 720: if (value != null) 721: return Level.parse(getLogManager().getProperty(propertyName)); 722: else 723: return defaultValue; 724: } 725: catch (Exception ex) 726: { 727: return defaultValue; 728: } 729: } 730: 731: /** 732: * Returns the value of a configuration property as a Class. 733: * This function is a helper used by the Classpath implementation 734: * of java.util.logging, it is <em>not</em> specified in the 735: * logging API. 736: * 737: * @param propertyName the name of the configuration property. 738: * 739: * @param defaultValue the value that will be returned if the 740: * property is not defined, or if it does not specify 741: * the name of a loadable class. 742: */ 743: static final Class getClassProperty(String propertyName, Class defaultValue) 744: { 745: String propertyValue = logManager.getProperty(propertyName); 746: 747: if (propertyValue != null) 748: try 749: { 750: return locateClass(propertyValue); 751: } 752: catch (ClassNotFoundException e) 753: { 754: warn(propertyName + " = " + propertyValue, e); 755: } 756: 757: return defaultValue; 758: } 759: 760: static final Object getInstanceProperty(String propertyName, Class ofClass, 761: Class defaultClass) 762: { 763: Class klass = getClassProperty(propertyName, defaultClass); 764: if (klass == null) 765: return null; 766: 767: try 768: { 769: Object obj = klass.newInstance(); 770: if (ofClass.isInstance(obj)) 771: return obj; 772: } 773: catch (InstantiationException e) 774: { 775: warn(propertyName + " = " + klass.getName(), e); 776: } 777: catch (IllegalAccessException e) 778: { 779: warn(propertyName + " = " + klass.getName(), e); 780: } 781: 782: if (defaultClass == null) 783: return null; 784: 785: try 786: { 787: return defaultClass.newInstance(); 788: } 789: catch (java.lang.InstantiationException ex) 790: { 791: throw new RuntimeException(ex.getMessage()); 792: } 793: catch (java.lang.IllegalAccessException ex) 794: { 795: throw new RuntimeException(ex.getMessage()); 796: } 797: } 798: 799: /** 800: * An instance of <code>LoggingPermission("control")</code> 801: * that is shared between calls to <code>checkAccess()</code>. 802: */ 803: private static final LoggingPermission controlPermission = new LoggingPermission("control", 804: null); 805: 806: /** 807: * Checks whether the current security context allows changing 808: * the configuration of the logging framework. For the security 809: * context to be trusted, it has to be granted 810: * a LoggingPermission("control"). 811: * 812: * @throws SecurityException if a security manager exists and 813: * the caller is not granted the permission to control 814: * the logging infrastructure. 815: */ 816: public void checkAccess() throws SecurityException 817: { 818: SecurityManager sm = System.getSecurityManager(); 819: if (sm != null) 820: sm.checkPermission(controlPermission); 821: } 822: 823: /** 824: * Creates a new instance of a class specified by name and verifies 825: * that it is an instance (or subclass of) a given type. 826: * 827: * @param className the name of the class of which a new instance 828: * should be created. 829: * 830: * @param type the object created must be an instance of 831: * <code>type</code> or any subclass of <code>type</code> 832: * 833: * @param property the system property to reference in error 834: * messages 835: * 836: * @return the new instance, or <code>null</code> if 837: * <code>className</code> is <code>null</code>, if no class 838: * with that name could be found, if there was an error 839: * loading that class, or if the constructor of the class 840: * has thrown an exception. 841: */ 842: private static final Object createInstance(String className, Class type, 843: String property) 844: { 845: Class klass = null; 846: 847: if ((className == null) || (className.length() == 0)) 848: return null; 849: 850: try 851: { 852: klass = locateClass(className); 853: if (type.isAssignableFrom(klass)) 854: return klass.newInstance(); 855: warn(property, className, "not an instance of " + type.getName()); 856: } 857: catch (ClassNotFoundException e) 858: { 859: warn(property, className, "class not found", e); 860: } 861: catch (IllegalAccessException e) 862: { 863: warn(property, className, "illegal access", e); 864: } 865: catch (InstantiationException e) 866: { 867: warn(property, className, e); 868: } 869: catch (java.lang.LinkageError e) 870: { 871: warn(property, className, "linkage error", e); 872: } 873: 874: return null; 875: } 876: 877: private static final void warn(String property, String klass, Throwable t) 878: { 879: warn(property, klass, null, t); 880: } 881: 882: private static final void warn(String property, String klass, String msg) 883: { 884: warn(property, klass, msg, null); 885: } 886: 887: private static final void warn(String property, String klass, String msg, 888: Throwable t) 889: { 890: warn("error instantiating '" + klass + "' referenced by " + property + 891: (msg == null ? "" : ", " + msg), t); 892: } 893: 894: /** 895: * All debug warnings go through this method. 896: */ 897: 898: private static final void warn(String msg, Throwable t) 899: { 900: System.err.println("WARNING: " + msg); 901: if (t != null) 902: t.printStackTrace(System.err); 903: } 904: 905: /** 906: * Locates a class by first checking the system class loader and 907: * then checking the context class loader. 908: * 909: * @param name the fully qualified name of the Class to locate 910: * @return Class the located Class 911: */ 912: 913: private static Class locateClass(String name) throws ClassNotFoundException 914: { 915: // GCJ LOCAL 916: // Unfortunately this can be called during bootstrap when 917: // Thread.currentThread() will return null. 918: // See bug #27658 919: Thread t = Thread.currentThread(); 920: ClassLoader loader = (t == null) ? null : t.getContextClassLoader(); 921: try 922: { 923: return Class.forName(name, true, loader); 924: } 925: catch (ClassNotFoundException e) 926: { 927: loader = ClassLoader.getSystemClassLoader(); 928: return Class.forName(name, true, loader); 929: } 930: } 931: 932: /** 933: * Return the logging bean. There is a single logging bean per 934: * VM instance. 935: * @since 1.5 936: */ 937: public static synchronized LoggingMXBean getLoggingMXBean() 938: { 939: if (loggingBean == null) 940: { 941: loggingBean = new LoggingMXBean() 942: { 943: public String getLoggerLevel(String logger) 944: { 945: LogManager mgr = getLogManager(); 946: Logger l = mgr.getLogger(logger); 947: if (l == null) 948: return null; 949: Level lev = l.getLevel(); 950: if (lev == null) 951: return ""; 952: return lev.getName(); 953: } 954: 955: public List getLoggerNames() 956: { 957: LogManager mgr = getLogManager(); 958: // This is inefficient, but perhaps better for maintenance. 959: return Collections.list(mgr.getLoggerNames()); 960: } 961: 962: public String getParentLoggerName(String logger) 963: { 964: LogManager mgr = getLogManager(); 965: Logger l = mgr.getLogger(logger); 966: if (l == null) 967: return null; 968: l = l.getParent(); 969: if (l == null) 970: return ""; 971: return l.getName(); 972: } 973: 974: public void setLoggerLevel(String logger, String level) 975: { 976: LogManager mgr = getLogManager(); 977: Logger l = mgr.getLogger(logger); 978: if (l == null) 979: throw new IllegalArgumentException("no logger named " + logger); 980: Level newLevel; 981: if (level == null) 982: newLevel = null; 983: else 984: newLevel = Level.parse(level); 985: l.setLevel(newLevel); 986: } 987: }; 988: } 989: return loggingBean; 990: } 991: }