/*
 * 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/**
 * 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 /** 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 /** "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 /** 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 /** 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.
/**
     * 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.
/**
     * 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.
/**
     * 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
/**
     * 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 /** 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 /** 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".
/**
         * 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.
/**
     * 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().
/**
     * 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 /** logger where output of this log is sent */
        private final Logger logger;

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

        
stream used for buffering lines /** 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
/**
     * 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
/**
     * 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 /** Log stream to which log messages are written */
        private final LogStream stream;

        
the level of the log as set by associated property /** 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.
/**
     * 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()
        };
    }
}