| Frames | No Frames |
1: /* ErrorManager.java -- 2: A class for dealing with errors that a Handler encounters 3: during logging 4: Copyright (C) 2002, 2003 Free Software Foundation, Inc. 5: 6: This file is part of GNU Classpath. 7: 8: GNU Classpath is free software; you can redistribute it and/or modify 9: it under the terms of the GNU General Public License as published by 10: the Free Software Foundation; either version 2, or (at your option) 11: any later version. 12: 13: GNU Classpath is distributed in the hope that it will be useful, but 14: WITHOUT ANY WARRANTY; without even the implied warranty of 15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16: General Public License for more details. 17: 18: You should have received a copy of the GNU General Public License 19: along with GNU Classpath; see the file COPYING. If not, write to the 20: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 21: 02110-1301 USA. 22: 23: Linking this library statically or dynamically with other modules is 24: making a combined work based on this library. Thus, the terms and 25: conditions of the GNU General Public License cover the whole 26: combination. 27: 28: As a special exception, the copyright holders of this library give you 29: permission to link this library with independent modules to produce an 30: executable, regardless of the license terms of these independent 31: modules, and to copy and distribute the resulting executable under 32: terms of your choice, provided that you also meet, for each linked 33: independent module, the terms and conditions of the license of that 34: module. An independent module is a module which is not derived from 35: or based on this library. If you modify this library, you may extend 36: this exception to your version of the library, but you are not 37: obligated to do so. If you do not wish to do so, delete this 38: exception statement from your version. */ 39: 40: 41: package java.util.logging; 42: 43: /** 44: * An <code>ErrorManager</code> deals with errors that a <code>Handler</code> 45: * encounters while logging. 46: * 47: * @see Handler#setErrorManager(ErrorManager) 48: * 49: * @author Sascha Brawer (brawer@acm.org) 50: */ 51: public class ErrorManager 52: { 53: /* The values have been taken from Sun's public J2SE 1.4 API 54: * documentation. 55: * See http://java.sun.com/j2se/1.4/docs/api/constant-values.html 56: */ 57: 58: /** 59: * Indicates that there was a failure that does not readily 60: * fall into any of the other categories. 61: */ 62: public static final int GENERIC_FAILURE = 0; 63: 64: 65: /** 66: * Indicates that there was a problem upon writing to 67: * an output stream. 68: */ 69: public static final int WRITE_FAILURE = 1; 70: 71: 72: /** 73: * Indicates that there was a problem upon flushing 74: * an output stream. 75: */ 76: public static final int FLUSH_FAILURE = 2; 77: 78: 79: /** 80: * Indicates that there was a problem upon closing 81: * an output stream. 82: */ 83: public static final int CLOSE_FAILURE = 3; 84: 85: 86: /** 87: * Indicates that there was a problem upon opening 88: * an output stream. 89: */ 90: public static final int OPEN_FAILURE = 4; 91: 92: 93: /** 94: * Indicates that there was a problem upon formatting 95: * the message of a log record. 96: */ 97: public static final int FORMAT_FAILURE = 5; 98: 99: 100: /** 101: * Indicates whether the {@link #error} method of this ErrorManager 102: * has ever been used. 103: * 104: * Declared volatile in order to correctly support the 105: * double-checked locking idiom (once the revised Java Memory Model 106: * gets adopted); see Classpath bug #2944. 107: */ 108: private volatile boolean everUsed = false; 109: 110: 111: public ErrorManager() 112: { 113: } 114: 115: 116: /** 117: * Reports an error that occured upon logging. The default implementation 118: * emits the very first error to System.err, ignoring subsequent errors. 119: * 120: * @param message a message describing the error, or <code>null</code> if 121: * there is no suitable description. 122: * 123: * @param ex an exception, or <code>null</code> if the error is not 124: * related to an exception. 125: * 126: * @param errorCode one of the defined error codes, for example 127: * <code>ErrorManager.CLOSE_FAILURE</code>. 128: */ 129: public void error(String message, Exception ex, int errorCode) 130: { 131: if (everUsed) 132: return; 133: 134: synchronized (this) 135: { 136: /* The double check is intentional. If the first check was 137: * omitted, the monitor would have to be entered every time 138: * error() method was called. If the second check was 139: * omitted, the code below could be executed by multiple 140: * threads simultaneously. 141: * 142: * This is the 'double-checked locking' idiom, which is broken 143: * with the current version of the Java memory model. However, 144: * we assume that JVMs will have adopted a revised version of 145: * the Java Memory Model by the time GNU Classpath gains 146: * widespread acceptance. See Classpath bug #2944. 147: */ 148: if (everUsed) 149: return; 150: 151: everUsed = true; 152: } 153: 154: String codeMsg; 155: switch (errorCode) 156: { 157: case GENERIC_FAILURE: 158: codeMsg = "GENERIC_FAILURE"; 159: break; 160: 161: case WRITE_FAILURE: 162: codeMsg = "WRITE_FAILURE"; 163: break; 164: 165: case FLUSH_FAILURE: 166: codeMsg = "FLUSH_FAILURE"; 167: break; 168: 169: case CLOSE_FAILURE: 170: codeMsg = "CLOSE_FAILURE"; 171: break; 172: 173: case OPEN_FAILURE: 174: codeMsg = "OPEN_FAILURE"; 175: break; 176: 177: case FORMAT_FAILURE: 178: codeMsg = "FORMAT_FAILURE"; 179: break; 180: 181: default: 182: codeMsg = String.valueOf(errorCode); 183: break; 184: } 185: 186: System.err.println("Error upon logging: " + codeMsg); 187: if ((message != null) && (message.length() > 0)) 188: System.err.println(message); 189: 190: if (ex != null) 191: ex.printStackTrace(); 192: } 193: }