Back to index...

	/*
	* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.rmi.runtime;

	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.PrintStream;
	import java.io.OutputStream;
	import java.rmi.server.LogStream;
	import java.util.logging.ConsoleHandler;
	import java.util.logging.Handler;
	import java.util.logging.Formatter;
	import java.util.logging.SimpleFormatter;
	import java.util.logging.StreamHandler;
	import java.util.logging.Level;
	import java.util.logging.Logger;
	import java.util.logging.LogManager;
	import java.util.logging.LogRecord;
	import java.util.logging.StreamHandler;
	import java.util.Map;
	import java.util.HashMap;

	/**
	* Utility which provides an abstract "logger" like RMI internal API
	* which can be directed to use one of two types of logging
	* infrastructure: the java.util.logging API or the
	* java.rmi.server.LogStream API. The default behavior is to use the
	* java.util.logging API. The LogStream API may be used instead by
	* setting the system property sun.rmi.log.useOld to true.
	*
	* For backwards compatibility, supports the RMI system logging
	* properties which pre-1.4 comprised the only way to configure RMI
	* logging. If the java.util.logging API is used and RMI system log
	* properties are set, the system properties override initial RMI
	* logger values as appropriate. If the java.util.logging API is
	* turned off, pre-1.4 logging behavior is used.
	*
	* @author Laird Dornin
	* @since 1.4
	*/
	@SuppressWarnings("deprecation")
	public abstract class Log {

	/** Logger re-definition of old RMI log values */
	public static final Level BRIEF = Level.FINE;
	public static final Level VERBOSE = Level.FINER;

	/* selects log implementation */
	private static final LogFactory logFactory;
	static {
	boolean useOld =
	Boolean.valueOf(java.security.AccessController.
	doPrivileged(new sun.security.action.GetPropertyAction(
	"sun.rmi.log.useOld"))).booleanValue();

	/* set factory to select the logging facility to use */
	logFactory = (useOld ? (LogFactory) new LogStreamLogFactory() :
	(LogFactory) new LoggerLogFactory());
	}

	/** "logger like" API to be used by RMI implementation */
	public abstract boolean isLoggable(Level level);
	public abstract void log(Level level, String message);
	public abstract void log(Level level, String message, Throwable thrown);

	/** get and set the RMI server call output stream */
	public abstract void setOutputStream(OutputStream stream);
	public abstract PrintStream getPrintStream();

	/** factory interface enables Logger and LogStream implementations */
	private static interface LogFactory {
	Log createLog(String loggerName, String oldLogName, Level level);
	}

	/* access log objects */

	/**
	* Access log for a tri-state system property.
	*
	* Need to first convert override value to a log level, taking
	* care to interpret a range of values between BRIEF, VERBOSE and
	* SILENT.
	*
	* An override < 0 is interpreted to mean that the logging
	* configuration should not be overridden. The level passed to the
	* factories createLog method will be null in this case.
	*
	* Note that if oldLogName is null and old logging is on, the
	* returned LogStreamLog will ignore the override parameter - the
	* log will never log messages. This permits new logs that only
	* write to Loggers to do nothing when old logging is active.
	*
	* Do not call getLog multiple times on the same logger name.
	* Since this is an internal API, no checks are made to ensure
	* that multiple logs do not exist for the same logger.
	*/
	public static Log getLog(String loggerName, String oldLogName,
	int override)
	{
	Level level;

	if (override < 0) {
	level = null;
	} else if (override == LogStream.SILENT) {
	level = Level.OFF;
	} else if ((override > LogStream.SILENT) &&
	(override <= LogStream.BRIEF)) {
	level = BRIEF;
	} else if ((override > LogStream.BRIEF) &&
	(override <= LogStream.VERBOSE))
	{
	level = VERBOSE;
	} else {
	level = Level.FINEST;
	}
	return logFactory.createLog(loggerName, oldLogName, level);
	}

	/**
	* Access logs associated with boolean properties
	*
	* Do not call getLog multiple times on the same logger name.
	* Since this is an internal API, no checks are made to ensure
	* that multiple logs do not exist for the same logger.
	*/
	public static Log getLog(String loggerName, String oldLogName,
	boolean override)
	{
	Level level = (override ? VERBOSE : null);
	return logFactory.createLog(loggerName, oldLogName, level);
	}

	/**
	* Factory to create Log objects which deliver log messages to the
	* java.util.logging API.
	*/
	private static class LoggerLogFactory implements LogFactory {
	LoggerLogFactory() {}

	/*
	* Accessor to obtain an arbitrary RMI logger with name
	* loggerName. If the level of the logger is greater than the
	* level for the system property with name, the logger level
	* will be set to the value of system property.
	*/
	public Log createLog(final String loggerName, String oldLogName,
	final Level level)
	{
	Logger logger = Logger.getLogger(loggerName);
	return new LoggerLog(logger, level);
	}
	}

	/**
	* Class specialized to log messages to the java.util.logging API
	*/
	private static class LoggerLog extends Log {

	/* alternate console handler for RMI loggers */
	private static final Handler alternateConsole =
	java.security.AccessController.doPrivileged(
	new java.security.PrivilegedAction<Handler>() {
	public Handler run() {
	InternalStreamHandler alternate =
	new InternalStreamHandler(System.err);
	alternate.setLevel(Level.ALL);
	return alternate;
	}
	});

	/** handler to which messages are copied */
	private InternalStreamHandler copyHandler = null;

	/* logger to which log messages are written */
	private final Logger logger;

	/* used as return value of RemoteServer.getLog */
	private LoggerPrintStream loggerSandwich;

	/** creates a Log which will delegate to the given logger */
	private LoggerLog(final Logger logger, final Level level) {
	this.logger = logger;

	if (level != null){
	java.security.AccessController.doPrivileged(
	new java.security.PrivilegedAction<Void>() {
	public Void run() {
	if (!logger.isLoggable(level)) {
	logger.setLevel(level);
	}
	logger.addHandler(alternateConsole);
	return null;
	}
	}
	);
	}
	}

	public boolean isLoggable(Level level) {
	return logger.isLoggable(level);
	}

	public void log(Level level, String message) {
	if (isLoggable(level)) {
	String[] source = getSource();
	logger.logp(level, source[0], source[1],
	Thread.currentThread().getName() + ": " + message);
	}
	}

	public void log(Level level, String message, Throwable thrown) {
	if (isLoggable(level)) {
	String[] source = getSource();
	logger.logp(level, source[0], source[1],
	Thread.currentThread().getName() + ": " +
	message, thrown);
	}
	}

	/**
	* Set the output stream associated with the RMI server call
	* logger.
	*
	* Calling code needs LoggingPermission "control".
	*/
	public synchronized void setOutputStream(OutputStream out) {
	if (out != null) {
	if (!logger.isLoggable(VERBOSE)) {
	logger.setLevel(VERBOSE);
	}
	copyHandler = new InternalStreamHandler(out);
	copyHandler.setLevel(Log.VERBOSE);
	logger.addHandler(copyHandler);
	} else {
	/* ensure that messages are not logged */
	if (copyHandler != null) {
	logger.removeHandler(copyHandler);
	}
	copyHandler = null;
	}
	}

	public synchronized PrintStream getPrintStream() {
	if (loggerSandwich == null) {
	loggerSandwich = new LoggerPrintStream(logger);
	}
	return loggerSandwich;
	}
	}

	/**
	* Subclass of StreamHandler for redirecting log output. flush
	* must be called in the publish and close methods.
	*/
	private static class InternalStreamHandler extends StreamHandler {
	InternalStreamHandler(OutputStream out) {
	super(out, new SimpleFormatter());
	}

	public void publish(LogRecord record) {
	super.publish(record);
	flush();
	}

	public void close() {
	flush();
	}
	}

	/**
	* PrintStream which forwards log messages to the logger. Class
	* is needed to maintain backwards compatibility with
	* RemoteServer.{set\|get}Log().
	*/
	private static class LoggerPrintStream extends PrintStream {

	/** logger where output of this log is sent */
	private final Logger logger;

	/** record the last character written to this stream */
	private int last = -1;

	/** stream used for buffering lines */
	private final ByteArrayOutputStream bufOut;

	private LoggerPrintStream(Logger logger)
	{
	super(new ByteArrayOutputStream());
	bufOut = (ByteArrayOutputStream) super.out;
	this.logger = logger;
	}

	public void write(int b) {
	if ((last == '\r') && (b == '\n')) {
	last = -1;
	return;
	} else if ((b == '\n') \|\| (b == '\r')) {
	try {
	/* write the converted bytes of the log message */
	String message =
	Thread.currentThread().getName() + ": " +
	bufOut.toString();
	logger.logp(Level.INFO, "LogStream", "print", message);
	} finally {
	bufOut.reset();
	}
	} else {
	super.write(b);
	}
	last = b;
	}

	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]);
	}
	}

	public String toString() {
	return "RMI";
	}
	}

	/**
	* Factory to create Log objects which deliver log messages to the
	* java.rmi.server.LogStream API
	*/
	private static class LogStreamLogFactory implements LogFactory {
	LogStreamLogFactory() {}

	/* create a new LogStreamLog for the specified log */
	public Log createLog(String loggerName, String oldLogName,
	Level level)
	{
	LogStream stream = null;
	if (oldLogName != null) {
	stream = LogStream.log(oldLogName);
	}
	return new LogStreamLog(stream, level);
	}
	}

	/**
	* Class specialized to log messages to the
	* java.rmi.server.LogStream API
	*/
	private static class LogStreamLog extends Log {
	/** Log stream to which log messages are written */
	private final LogStream stream;

	/** the level of the log as set by associated property */
	private int levelValue = Level.OFF.intValue();

	private LogStreamLog(LogStream stream, Level level) {
	if ((stream != null) && (level != null)) {
	/* if the stream or level is null, don't log any
	* messages
	*/
	levelValue = level.intValue();
	}
	this.stream = stream;
	}

	public synchronized boolean isLoggable(Level level) {
	return (level.intValue() >= levelValue);
	}

	public void log(Level messageLevel, String message) {
	if (isLoggable(messageLevel)) {
	String[] source = getSource();
	stream.println(unqualifiedName(source[0]) +
	"." + source[1] + ": " + message);
	}
	}

	public void log(Level level, String message, Throwable thrown) {
	if (isLoggable(level)) {
	/*
	* keep output contiguous and maintain the contract of
	* RemoteServer.getLog
	*/
	synchronized (stream) {
	String[] source = getSource();
	stream.println(unqualifiedName(source[0]) + "." +
	source[1] + ": " + message);
	thrown.printStackTrace(stream);
	}
	}
	}

	public PrintStream getPrintStream() {
	return stream;
	}

	public synchronized void setOutputStream(OutputStream out) {
	if (out != null) {
	if (VERBOSE.intValue() < levelValue) {
	levelValue = VERBOSE.intValue();
	}
	stream.setOutputStream(out);
	} else {
	/* ensure that messages are not logged */
	levelValue = Level.OFF.intValue();
	}
	}

	/*
	* Mimic old log messages that only contain unqualified names.
	*/
	private static String unqualifiedName(String name) {
	int lastDot = name.lastIndexOf(".");
	if (lastDot >= 0) {
	name = name.substring(lastDot + 1);
	}
	name = name.replace('$', '.');
	return name;
	}
	}

	/**
	* Obtain class and method names of code calling a log method.
	*/
	private static String[] getSource() {
	StackTraceElement[] trace = (new Exception()).getStackTrace();
	return new String[] {
	trace[3].getClassName(),
	trace[3].getMethodName()
	};
	}
	}

Back to index...