1 /*
   2  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package jdk.internal.logger;
  27 
  28 import java.lang.ref.Reference;
  29 import java.lang.ref.WeakReference;
  30 import java.util.HashMap;
  31 import java.util.Map;
  32 import java.util.function.Function;
  33 import java.lang.System.LoggerFinder;
  34 import java.lang.System.Logger;
  35 import java.lang.ref.ReferenceQueue;
  36 import java.lang.reflect.Module;
  37 import java.security.AccessController;
  38 import java.security.PrivilegedAction;
  39 import java.util.Collection;
  40 import java.util.ResourceBundle;
  41 
  42 /**
  43  * Internal Service Provider Interface (SPI) that makes it possible to use
  44  * {@code java.util.logging} as backend when the {@link
  45  * sun.util.logging.internal.LoggingProviderImpl
  46  * sun.util.logging.internal.LoggingProviderImpl} is present.
  47  * <p>
  48  * The JDK default implementation of the {@link LoggerFinder} will
  49  * attempt to locate and load an {@linkplain
  50  * java.util.ServiceLoader#loadInstalled(java.lang.Class) installed}
  51  * implementation of the {@code DefaultLoggerFinder}. If {@code java.util.logging}
  52  * is present, this will usually resolve to an instance of {@link
  53  * sun.util.logging.internal.LoggingProviderImpl sun.util.logging.internal.LoggingProviderImpl}.
  54  * Otherwise, if no concrete service provider is declared for
  55  * {@code DefaultLoggerFinder}, the default implementation provided by this class
  56  * will be used.
  57  * <p>
  58  * When the {@link sun.util.logging.internal.LoggingProviderImpl
  59  * sun.util.logging.internal.LoggingProviderImpl} is not present then the
  60  * default implementation provided by this class is to use a simple logger
  61  * that will log messages whose level is INFO and above to the console.
  62  * These simple loggers are not configurable.
  63  * <p>
  64  * When configuration is needed, an application should either link with
  65  * {@code java.util.logging} - and use the {@code java.util.logging} for
  66  * configuration, or link with {@link LoggerFinder another implementation}
  67  * of the {@link LoggerFinder}
  68  * that provides the necessary configuration.
  69  *
  70  * @apiNote Programmers are not expected to call this class directly.
  71  * Instead they should rely on the static methods defined by {@link
  72  * java.lang.System java.lang.System} or {@link sun.util.logging.PlatformLogger
  73  * sun.util.logging.PlatformLogger}.
  74  *
  75  * @see java.lang.System.LoggerFinder
  76  * @see jdk.internal.logger
  77  * @see sun.util.logging.internal
  78  *
  79  */
  80 public class DefaultLoggerFinder extends LoggerFinder {
  81 
  82     static final RuntimePermission LOGGERFINDER_PERMISSION =
  83                 new RuntimePermission("loggerFinder");
  84 
  85     /**
  86      * Creates a new instance of DefaultLoggerFinder.
  87      * @throws SecurityException if the calling code does not have the
  88      * {@code RuntimePermission("loggerFinder")}
  89      */
  90     protected DefaultLoggerFinder() {
  91         this(checkPermission());
  92     }
  93 
  94     private DefaultLoggerFinder(Void unused) {
  95         // nothing to do.
  96     }
  97 
  98     private static Void checkPermission() {
  99         final SecurityManager sm = System.getSecurityManager();
 100         if (sm != null) {
 101             sm.checkPermission(LOGGERFINDER_PERMISSION);
 102         }
 103         return null;
 104     }
 105 
 106     // SharedLoggers is a default cache of loggers used when JUL is not
 107     // present - in that case we use instances of SimpleConsoleLogger which
 108     // cannot be directly configure through public APIs.
 109     //
 110     // We can therefore afford to simply maintain two domains - one for the
 111     // system, and one for the application.
 112     //
 113     static final class SharedLoggers {
 114         private final Map<String, Reference<Logger>> loggers =
 115                 new HashMap<>();
 116         private final ReferenceQueue<Logger> queue = new ReferenceQueue<>();
 117 
 118         synchronized Logger get(Function<String, Logger> loggerSupplier, final String name) {
 119             Reference<? extends Logger> ref = loggers.get(name);
 120             Logger w = ref == null ? null :  ref.get();
 121             if (w == null) {
 122                 w = loggerSupplier.apply(name);
 123                 loggers.put(name, new WeakReference<>(w, queue));
 124             }
 125 
 126             // Remove stale mapping...
 127             Collection<Reference<Logger>> values = null;
 128             while ((ref = queue.poll()) != null) {
 129                 if (values == null) values = loggers.values();
 130                 values.remove(ref);
 131             }
 132             return w;
 133         }
 134 
 135         final static SharedLoggers system = new SharedLoggers();
 136         final static SharedLoggers application = new SharedLoggers();
 137     }
 138 
 139     public static boolean isSystem(Module m) {
 140         ClassLoader cl = AccessController.doPrivileged(new PrivilegedAction<>() {
 141             @Override
 142             public ClassLoader run() {
 143                 return m.getClassLoader();
 144             }
 145         });
 146         return cl == null;
 147     }
 148 
 149     @Override
 150     public final Logger getLogger(String name,  Module module) {
 151         checkPermission();
 152         return demandLoggerFor(name, module);
 153     }
 154 
 155     @Override
 156     public final Logger getLocalizedLogger(String name, ResourceBundle bundle,
 157                                            Module module) {
 158         return super.getLocalizedLogger(name, bundle, module);
 159     }
 160 
 161     /**
 162      * Returns a {@link Logger logger} suitable for use within the
 163      * given {@code module}.
 164      *
 165      * @implSpec The default implementation for this method is to return a
 166      *    simple logger that will print all messages of INFO level and above
 167      *    to the console. That simple logger is not configurable.
 168      *
 169      * @param name The name of the logger.
 170      * @param module The module on behalf of which the logger is created.
 171      * @return A {@link Logger logger} suitable for the application usage.
 172      * @throws SecurityException if the calling code does not have the
 173      * {@code RuntimePermission("loggerFinder")}.
 174      */
 175     protected Logger demandLoggerFor(String name, Module module) {
 176         checkPermission();
 177         if (isSystem(module)) {
 178             return SharedLoggers.system.get(SimpleConsoleLogger::makeSimpleLogger, name);
 179         } else {
 180             return SharedLoggers.application.get(SimpleConsoleLogger::makeSimpleLogger, name);
 181         }
 182     }
 183 
 184 }