/*

 * Copyright (c) 2000, 2014, 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 java.util.logging;

import java.io.*;

import java.util.*;

import java.security.*;

import java.lang.ref.ReferenceQueue;

import java.lang.ref.WeakReference;

import java.util.concurrent.CopyOnWriteArrayList;

import sun.misc.JavaAWTAccess;

import sun.misc.SharedSecrets;

/**

 * There is a single global LogManager object that is used to

 * maintain a set of shared state about Loggers and log services.

 * <p>

 * This LogManager object:

 * <ul>

 * <li> Manages a hierarchical namespace of Logger objects.  All

 *      named Loggers are stored in this namespace.

 * <li> Manages a set of logging control properties.  These are

 *      simple key-value pairs that can be used by Handlers and

 *      other logging objects to configure themselves.

 * </ul>

 * <p>

 * The global LogManager object can be retrieved using LogManager.getLogManager().

 * The LogManager object is created during class initialization and

 * cannot subsequently be changed.

 * <p>

 * At startup the LogManager class is located using the

 * java.util.logging.manager system property.

 * <p>

 * The LogManager defines two optional system properties that allow control over

 * the initial configuration:

 * <ul>

 * <li>"java.util.logging.config.class"

 * <li>"java.util.logging.config.file"

 * </ul>

 * These two properties may be specified on the command line to the "java"

 * command, or as system property definitions passed to JNI_CreateJavaVM.

 * <p>

 * If the "java.util.logging.config.class" property is set, then the

 * property value is treated as a class name.  The given class will be

 * loaded, an object will be instantiated, and that object's constructor

 * is responsible for reading in the initial configuration.  (That object

 * may use other system properties to control its configuration.)  The

 * alternate configuration class can use <tt>readConfiguration(InputStream)</tt>

 * to define properties in the LogManager.

 * <p>

 * If "java.util.logging.config.class" property is <b>not</b> set,

 * then the "java.util.logging.config.file" system property can be used

 * to specify a properties file (in java.util.Properties format). The

 * initial logging configuration will be read from this file.

 * <p>

 * If neither of these properties is defined then the LogManager uses its

 * default configuration. The default configuration is typically loaded from the

 * properties file "{@code conf/logging.properties}" in the Java installation

 * directory.

 * <p>

 * The properties for loggers and Handlers will have names starting

 * with the dot-separated name for the handler or logger.

 * <p>

 * The global logging properties may include:

 * <ul>

 * <li>A property "handlers".  This defines a whitespace or comma separated

 * list of class names for handler classes to load and register as

 * handlers on the root Logger (the Logger named "").  Each class

 * name must be for a Handler class which has a default constructor.

 * Note that these Handlers may be created lazily, when they are

 * first used.

 *

 * <li>A property "&lt;logger&gt;.handlers". This defines a whitespace or

 * comma separated list of class names for handlers classes to

 * load and register as handlers to the specified logger. Each class

 * name must be for a Handler class which has a default constructor.

 * Note that these Handlers may be created lazily, when they are

 * first used.

 *

 * <li>A property "&lt;logger&gt;.handlers.ensureCloseOnReset". This defines a

 * a boolean value. If "<logger>.handlers" is not defined or is empty,

 * this property is ignored. Otherwise it defaults to {@code true}. When the

 * value is {@code true}, the handlers associated with the logger are guaranteed

 * to be closed on {@linkplain #reset} and shutdown. This can be turned off

 * by explicitly setting "<logger>.handlers.ensureCloseOnReset=false" in

 * the configuration. Note that turning this property off causes the risk of

 * introducing a resource leak, as the logger may get garbage collected before

 * {@code reset()} is called, thus preventing its handlers from being closed

 * on {@code reset()}. In that case it is the responsibility of the application

 * to ensure that the handlers are closed before the logger is garbage

 * collected.

 *

 * <li>A property "&lt;logger&gt;.useParentHandlers". This defines a boolean

 * value. By default every logger calls its parent in addition to

 * handling the logging message itself, this often result in messages

 * being handled by the root logger as well. When setting this property

 * to false a Handler needs to be configured for this logger otherwise

 * no logging messages are delivered.

 *

 * <li>A property "config".  This property is intended to allow

 * arbitrary configuration code to be run.  The property defines a

 * whitespace or comma separated list of class names.  A new instance will be

 * created for each named class.  The default constructor of each class

 * may execute arbitrary code to update the logging configuration, such as

 * setting logger levels, adding handlers, adding filters, etc.

 * </ul>

 * <p>

 * Note that all classes loaded during LogManager configuration are

 * first searched on the system class path before any user class path.

 * That includes the LogManager class, any config classes, and any

 * handler classes.

 * <p>

 * Loggers are organized into a naming hierarchy based on their

 * dot separated names.  Thus "a.b.c" is a child of "a.b", but

 * "a.b1" and a.b2" are peers.

 * <p>

 * All properties whose names end with ".level" are assumed to define

 * log levels for Loggers.  Thus "foo.level" defines a log level for

 * the logger called "foo" and (recursively) for any of its children

 * in the naming hierarchy.  Log Levels are applied in the order they

 * are defined in the properties file.  Thus level settings for child

 * nodes in the tree should come after settings for their parents.

 * The property name ".level" can be used to set the level for the

 * root of the tree.

 * <p>

 * All methods on the LogManager object are multi-thread safe.

 *

 * @since 1.4

*/

public class LogManager {

    // The global LogManager object

    private static final LogManager manager;

    // 'props' is assigned within a lock but accessed without it.

    // Declaring it volatile makes sure that another thread will not

    // be able to see a partially constructed 'props' object.

    // (seeing a partially constructed 'props' object can result in

    // NPE being thrown in Hashtable.get(), because it leaves the door

    // open for props.getProperties() to be called before the construcor

    // of Hashtable is actually completed).

    private volatile Properties props = new Properties();

    private final static Level defaultLevel = Level.INFO;

    // LoggerContext for system loggers and user loggers

    private final LoggerContext systemContext = new SystemLoggerContext();

    private final LoggerContext userContext = new LoggerContext();

    // non final field - make it volatile to make sure that other threads

    // will see the new value once ensureLogManagerInitialized() has finished

    // executing.

    private volatile Logger rootLogger;

    // Have we done the primordial reading of the configuration file?

    // (Must be done after a suitable amount of java.lang.System

    // initialization has been done)

    private volatile boolean readPrimordialConfiguration;

    // Have we initialized global (root) handlers yet?

    // This gets set to false in readConfiguration

    private boolean initializedGlobalHandlers = true;

    // True if JVM death is imminent and the exit hook has been called.

    private boolean deathImminent;

    // This list contains the loggers for which some handlers have been

    // explicitly configured in the configuration file.

    // It prevents these loggers from being arbitrarily garbage collected.

    private static final class CloseOnReset {

        private final Logger logger;

        private CloseOnReset(Logger ref) {

            this.logger = Objects.requireNonNull(ref);

        }

        @Override

        public boolean equals(Object other) {

            return (other instanceof CloseOnReset) && ((CloseOnReset)other).logger == logger;

        }

        @Override

        public int hashCode() {

            return System.identityHashCode(logger);

        }

        public Logger get() {

            return logger;

        }

        public static CloseOnReset create(Logger logger) {

            return new CloseOnReset(logger);

        }

    }

    private final CopyOnWriteArrayList<CloseOnReset> closeOnResetLoggers =

            new CopyOnWriteArrayList<>();

    private final Map<Object, Runnable> listeners =

            Collections.synchronizedMap(new IdentityHashMap<>());

    static {

        manager = AccessController.doPrivileged(new PrivilegedAction<LogManager>() {

            @Override

            public LogManager run() {

                LogManager mgr = null;

                String cname = null;

                try {

                    cname = System.getProperty("java.util.logging.manager");

                    if (cname != null) {

                        try {

                            Class<?> clz = ClassLoader.getSystemClassLoader()

                                    .loadClass(cname);

                            mgr = (LogManager) clz.newInstance();

                        } catch (ClassNotFoundException ex) {

                            Class<?> clz = Thread.currentThread()

                                    .getContextClassLoader().loadClass(cname);

                            mgr = (LogManager) clz.newInstance();

                        }

                    }

                } catch (Exception ex) {

                    System.err.println("Could not load Logmanager \"" + cname + "\"");

                    ex.printStackTrace();

                }

                if (mgr == null) {

                    mgr = new LogManager();

                }

                return mgr;

            }

        });

    }

    // This private class is used as a shutdown hook.

    // It does a "reset" to close all open handlers.

    private class Cleaner extends Thread {

        private Cleaner() {

            /* Set context class loader to null in order to avoid

             * keeping a strong reference to an application classloader.

             */

            this.setContextClassLoader(null);

        }

        @Override

        public void run() {

            // This is to ensure the LogManager.<clinit> is completed

            // before synchronized block. Otherwise deadlocks are possible.

            LogManager mgr = manager;

            // If the global handlers haven't been initialized yet, we

            // don't want to initialize them just so we can close them!

            synchronized (LogManager.this) {

                // Note that death is imminent.

                deathImminent = true;

                initializedGlobalHandlers = true;

            }

            // Do a reset to close all active handlers.

            reset();

        }

    }

    /**

     * Protected constructor.  This is protected so that container applications

     * (such as J2EE containers) can subclass the object.  It is non-public as

     * it is intended that there only be one LogManager object, whose value is

     * retrieved by calling LogManager.getLogManager.

     */

    protected LogManager() {

        this(checkSubclassPermissions());

    }

    private LogManager(Void checked) {

        // Add a shutdown hook to close the global handlers.

        try {

            Runtime.getRuntime().addShutdownHook(new Cleaner());

        } catch (IllegalStateException e) {

            // If the VM is already shutting down,

            // We do not need to register shutdownHook.

        }

    }

    private static Void checkSubclassPermissions() {

        final SecurityManager sm = System.getSecurityManager();

        if (sm != null) {

            // These permission will be checked in the LogManager constructor,

            // in order to register the Cleaner() thread as a shutdown hook.

            // Check them here to avoid the penalty of constructing the object

            // etc...

            sm.checkPermission(new RuntimePermission("shutdownHooks"));

            sm.checkPermission(new RuntimePermission("setContextClassLoader"));

        }

        return null;

    }

    /**

     * Lazy initialization: if this instance of manager is the global

     * manager then this method will read the initial configuration and

     * add the root logger and global logger by calling addLogger().

     *

     * Note that it is subtly different from what we do in LoggerContext.

     * In LoggerContext we're patching up the logger context tree in order to add

     * the root and global logger *to the context tree*.

     *

     * For this to work, addLogger() must have already have been called

     * once on the LogManager instance for the default logger being

     * added.

     *

     * This is why ensureLogManagerInitialized() needs to be called before

     * any logger is added to any logger context.

     *

     */

    private boolean initializedCalled = false;

    private volatile boolean initializationDone = false;

    final void ensureLogManagerInitialized() {

        final LogManager owner = this;

        if (initializationDone || owner != manager) {

            // we don't want to do this twice, and we don't want to do

            // this on private manager instances.

            return;

        }

        // Maybe another thread has called ensureLogManagerInitialized()

        // before us and is still executing it. If so we will block until

        // the log manager has finished initialized, then acquire the monitor,

        // notice that initializationDone is now true and return.

        // Otherwise - we have come here first! We will acquire the monitor,

        // see that initializationDone is still false, and perform the

        // initialization.

        //

        synchronized(this) {

            // If initializedCalled is true it means that we're already in

            // the process of initializing the LogManager in this thread.

            // There has been a recursive call to ensureLogManagerInitialized().

            final boolean isRecursiveInitialization = (initializedCalled == true);

            assert initializedCalled || !initializationDone

                    : "Initialization can't be done if initialized has not been called!";

            if (isRecursiveInitialization || initializationDone) {

                // If isRecursiveInitialization is true it means that we're

                // already in the process of initializing the LogManager in

                // this thread. There has been a recursive call to

                // ensureLogManagerInitialized(). We should not proceed as

                // it would lead to infinite recursion.

                //

                // If initializationDone is true then it means the manager

                // has finished initializing; just return: we're done.

                return;

            }

            // Calling addLogger below will in turn call requiresDefaultLogger()

            // which will call ensureLogManagerInitialized().

            // We use initializedCalled to break the recursion.

            initializedCalled = true;

            try {

                AccessController.doPrivileged(new PrivilegedAction<Object>() {

                    @Override

                    public Object run() {

                        assert rootLogger == null;

                        assert initializedCalled && !initializationDone;

                        // Read configuration.

                        owner.readPrimordialConfiguration();

                        // Create and retain Logger for the root of the namespace.

                        owner.rootLogger = owner.new RootLogger();

                        owner.addLogger(owner.rootLogger);

                        if (!owner.rootLogger.isLevelInitialized()) {

                            owner.rootLogger.setLevel(defaultLevel);

                        }

                        // Adding the global Logger.

                        // Do not call Logger.getGlobal() here as this might trigger

                        // subtle inter-dependency issues.

                        @SuppressWarnings("deprecation")

                        final Logger global = Logger.global;

                        // Make sure the global logger will be registered in the

                        // global manager

                        owner.addLogger(global);

                        return null;

                    }

                });

            } finally {

                initializationDone = true;

            }

        }

    }

    /**

     * Returns the global LogManager object.

     * @return the global LogManager object

     */

    public static LogManager getLogManager() {

        if (manager != null) {

            manager.ensureLogManagerInitialized();

        }

        return manager;

    }

    private void readPrimordialConfiguration() {

        if (!readPrimordialConfiguration) {

            synchronized (this) {

                if (!readPrimordialConfiguration) {

                    // If System.in/out/err are null, it's a good

                    // indication that we're still in the

                    // bootstrapping phase

                    if (System.out == null) {

                        return;

                    }

                    readPrimordialConfiguration = true;

                    try {

                        AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {

                                @Override

                                public Void run() throws Exception {

                                    readConfiguration();

                                    // Platform loggers begin to delegate to java.util.logging.Logger

                                    sun.util.logging.PlatformLogger.redirectPlatformLoggers();

                                    return null;

                                }

                            });

                    } catch (Exception ex) {

                        assert false : "Exception raised while reading logging configuration: " + ex;

                    }

                }

            }

        }

    }

    // LoggerContext maps from AppContext

    private WeakHashMap<Object, LoggerContext> contextsMap = null;

    // Returns the LoggerContext for the user code (i.e. application or AppContext).

    // Loggers are isolated from each AppContext.

    private LoggerContext getUserContext() {

        LoggerContext context = null;

        SecurityManager sm = System.getSecurityManager();

        JavaAWTAccess javaAwtAccess = SharedSecrets.getJavaAWTAccess();

        if (sm != null && javaAwtAccess != null) {

            // for each applet, it has its own LoggerContext isolated from others

            synchronized (javaAwtAccess) {

                // find the AppContext of the applet code

                // will be null if we are in the main app context.

                final Object ecx = javaAwtAccess.getAppletContext();

                if (ecx != null) {

                    if (contextsMap == null) {

                        contextsMap = new WeakHashMap<>();

                    }

                    context = contextsMap.get(ecx);

                    if (context == null) {

                        // Create a new LoggerContext for the applet.

                        context = new LoggerContext();

                        contextsMap.put(ecx, context);

                    }

                }

            }

        }

        // for standalone app, return userContext

        return context != null ? context : userContext;

    }

    // The system context.

    final LoggerContext getSystemContext() {

        return systemContext;

    }

    private List<LoggerContext> contexts() {

        List<LoggerContext> cxs = new ArrayList<>();

        cxs.add(getSystemContext());

        cxs.add(getUserContext());

        return cxs;

    }

    // Find or create a specified logger instance. If a logger has

    // already been created with the given name it is returned.

    // Otherwise a new logger instance is created and registered

    // in the LogManager global namespace.

    // This method will always return a non-null Logger object.

    // Synchronization is not required here. All synchronization for

    // adding a new Logger object is handled by addLogger().

    //

    // This method must delegate to the LogManager implementation to

    // add a new Logger or return the one that has been added previously