/*

 * 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)) {

                 * 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()

        };

    }

}