1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
/* * @(#)LogStream.java 1.21 05/11/17 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.rmi.server; import java.io.*; import java.util.*; /** * <code>LogStream</code> provides a mechanism for logging errors that are * of possible interest to those monitoring a system. * * @version 1.21, 11/17/05 * @author Ann Wollrath (lots of code stolen from Ken Arnold) * @since JDK1.1 * @deprecated no replacement */ @Deprecated public class LogStream extends PrintStream { /** table mapping known log names to log stream objects */ private static Hashtable known = new Hashtable(5); /** default output stream for new logs */ private static PrintStream defaultStream = System.err; /** log name for this log */ private String name; /** stream where output of this log is sent to */ private OutputStream logOut; /** string writer for writing message prefixes to log stream */ private OutputStreamWriter logWriter; /** string buffer used for constructing log message prefixes */ private StringBuffer buffer = new StringBuffer(); /** stream used for buffering lines */ private ByteArrayOutputStream bufOut; /** * Create a new LogStream object. Since this only constructor is * private, users must have a LogStream created through the "log" * method. * @param name string identifying messages from this log * @out output stream that log messages will be sent to * @since JDK1.1 * @deprecated no replacement */ @Deprecated private LogStream(String name, OutputStream out) { super(new ByteArrayOutputStream()); bufOut = (ByteArrayOutputStream) super.out; this.name = name; setOutputStream(out); } /** * Return the LogStream identified by the given name. If * a log corresponding to "name" does not exist, a log using * the default stream is created. * @param name name identifying the desired LogStream * @return log associated with given name * @since JDK1.1 * @deprecated no replacement */ @Deprecated public static LogStream log(String name) { LogStream stream; synchronized (known) { stream = (LogStream)known.get(name); if (stream == null) { stream = new LogStream(name, defaultStream); } known.put(name, stream); } return stream; } /** * Return the current default stream for new logs. * @return default log stream * @see #setDefaultStream * @since JDK1.1 * @deprecated no replacement */ @Deprecated public static synchronized PrintStream getDefaultStream() { return defaultStream; } /** * Set the default stream for new logs. * @param newDefault new default log stream * @see #getDefaultStream * @since JDK1.1 * @deprecated no replacement */ @Deprecated public static synchronized void setDefaultStream(PrintStream newDefault) { defaultStream = newDefault; } /** * Return the current stream to which output from this log is sent. * @return output stream for this log * @see #setOutputStream * @since JDK1.1 * @deprecated no replacement */ @Deprecated public synchronized OutputStream getOutputStream() { return logOut; } /** * Set the stream to which output from this log is sent. * @param out new output stream for this log * @see #getOutputStream * @since JDK1.1 * @deprecated no replacement */ @Deprecated public synchronized void setOutputStream(OutputStream out) { logOut = out; // Maintain an OutputStreamWriter with default CharToByteConvertor // (just like new PrintStream) for writing log message prefixes. logWriter = new OutputStreamWriter(logOut); } /** * Write a byte of data to the stream. If it is not a newline, then * the byte is appended to the internal buffer. If it is a newline, * then the currently buffered line is sent to the log's output * stream, prefixed with the appropriate logging information. * @since JDK1.1 * @deprecated no replacement */ @Deprecated public void write(int b) { if (b == '\n') { // synchronize on "this" first to avoid potential deadlock synchronized (this) { synchronized (logOut) { // construct prefix for log messages: buffer.setLength(0);; buffer.append( // date/time stamp... (new Date()).toString()); buffer.append(':'); buffer.append(name); // ...log name... buffer.append(':'); buffer.append(Thread.currentThread().getName()); buffer.append(':'); // ...and thread name try { // write prefix through to underlying byte stream logWriter.write(buffer.toString()); logWriter.flush(); // finally, write the already converted bytes of // the log message bufOut.writeTo(logOut); logOut.write(b); logOut.flush(); } catch (IOException e) { setError(); } finally { bufOut.reset(); } } } } else super.write(b); } /** * Write a subarray of bytes. Pass each through write byte method. * @since JDK1.1 * @deprecated no replacement */ @Deprecated public void write(byte b[], int off, int len) { if (len < 0) throw new ArrayIndexOutOfBoundsException(len); for (int i = 0; i < len; ++ i) write(b[off + i]); } /** * Return log name as string representation. * @return log name * @since JDK1.1 * @deprecated no replacement */ @Deprecated public String toString() { return name; } /** log level constant (no logging). */ public static final int SILENT = 0; /** log level constant (brief logging). */ public static final int BRIEF = 10; /** log level constant (verbose logging). */ public static final int VERBOSE = 20; /** * Convert a string name of a logging level to its internal * integer representation. * @param s name of logging level (e.g., 'SILENT', 'BRIEF', 'VERBOSE') * @return corresponding integer log level * @since JDK1.1 * @deprecated no replacement */ @Deprecated public static int parseLevel(String s) { if ((s == null) || (s.length() < 1)) return -1; try { return Integer.parseInt(s); } catch (NumberFormatException e) { } if (s.length() < 1) return -1; if ("SILENT".startsWith(s.toUpperCase())) return SILENT; else if ("BRIEF".startsWith(s.toUpperCase())) return BRIEF; else if ("VERBOSE".startsWith(s.toUpperCase())) return VERBOSE; return -1; } }