Back to index...

	/*
	* Copyright (c) 2015, 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 jdk.internal.logger;

	import java.io.FilePermission;
	import java.security.AccessController;
	import java.security.Permission;
	import java.security.PrivilegedAction;
	import java.util.Iterator;
	import java.util.Locale;
	import java.util.ServiceConfigurationError;
	import java.util.ServiceLoader;
	import sun.security.util.SecurityConstants;
	import sun.security.action.GetPropertyAction;

	/**
	* Helper class used to load the {@link java.lang.System.LoggerFinder}.
	*/
	public final class LoggerFinderLoader {
	private static volatile System.LoggerFinder service;
	private static final Object lock = new int[0];
	static final Permission CLASSLOADER_PERMISSION =
	SecurityConstants.GET_CLASSLOADER_PERMISSION;
	static final Permission READ_PERMISSION =
	new FilePermission("<<ALL FILES>>",
	SecurityConstants.FILE_READ_ACTION);
	public static final RuntimePermission LOGGERFINDER_PERMISSION =
	new RuntimePermission("loggerFinder");

	// This is used to control how the LoggerFinderLoader handles
	// errors when instantiating the LoggerFinder provider.
	// ERROR => throws ServiceConfigurationError
	// WARNING => Do not fail, use plain default (simple logger) implementation,
	// prints warning on console. (this is the default)
	// DEBUG => Do not fail, use plain default (simple logger) implementation,
	// prints warning and exception stack trace on console.
	// QUIET => Do not fail and stay silent.
	private static enum ErrorPolicy { ERROR, WARNING, DEBUG, QUIET };

	// This class is static and cannot be instantiated.
	private LoggerFinderLoader() {
	throw new InternalError("LoggerFinderLoader cannot be instantiated");
	}


	// Return the loaded LoggerFinder, or load it if not already loaded.
	private static System.LoggerFinder service() {
	if (service != null) return service;
	synchronized(lock) {
	if (service != null) return service;
	service = loadLoggerFinder();
	}
	// Since the LoggerFinder is already loaded - we can stop using
	// temporary loggers.
	BootstrapLogger.redirectTemporaryLoggers();
	return service;
	}

	// Get configuration error policy
	private static ErrorPolicy configurationErrorPolicy() {
	String errorPolicy =
	GetPropertyAction.privilegedGetProperty("jdk.logger.finder.error");
	if (errorPolicy == null \|\| errorPolicy.isEmpty()) {
	return ErrorPolicy.WARNING;
	}
	try {
	return ErrorPolicy.valueOf(errorPolicy.toUpperCase(Locale.ROOT));
	} catch (IllegalArgumentException x) {
	return ErrorPolicy.WARNING;
	}
	}

	// Whether multiple provider should be considered as an error.
	// This is further submitted to the configuration error policy.
	private static boolean ensureSingletonProvider() {
	return Boolean.parseBoolean(
	GetPropertyAction.privilegedGetProperty("jdk.logger.finder.singleton"));
	}

	private static Iterator<System.LoggerFinder> findLoggerFinderProviders() {
	final Iterator<System.LoggerFinder> iterator;
	if (System.getSecurityManager() == null) {
	iterator = ServiceLoader.load(System.LoggerFinder.class,
	ClassLoader.getSystemClassLoader()).iterator();
	} else {
	final PrivilegedAction<Iterator<System.LoggerFinder>> pa =
	() -> ServiceLoader.load(System.LoggerFinder.class,
	ClassLoader.getSystemClassLoader()).iterator();
	iterator = AccessController.doPrivileged(pa, null,
	LOGGERFINDER_PERMISSION, CLASSLOADER_PERMISSION,
	READ_PERMISSION);
	}
	return iterator;
	}

	// Loads the LoggerFinder using ServiceLoader. If no LoggerFinder
	// is found returns the default (possibly JUL based) implementation
	private static System.LoggerFinder loadLoggerFinder() {
	System.LoggerFinder result;
	try {
	// Iterator iterates with the access control context stored
	// at ServiceLoader creation time.
	final Iterator<System.LoggerFinder> iterator =
	findLoggerFinderProviders();
	if (iterator.hasNext()) {
	result = iterator.next();
	if (iterator.hasNext() && ensureSingletonProvider()) {
	throw new ServiceConfigurationError(
	"More than on LoggerFinder implementation");
	}
	} else {
	result = loadDefaultImplementation();
	}
	} catch (Error \| RuntimeException x) {
	// next caller will get the plain default impl (not linked
	// to java.util.logging)
	service = result = new DefaultLoggerFinder();
	ErrorPolicy errorPolicy = configurationErrorPolicy();
	if (errorPolicy == ErrorPolicy.ERROR) {
	// rethrow any exception as a ServiceConfigurationError.
	if (x instanceof Error) {
	throw x;
	} else {
	throw new ServiceConfigurationError(
	"Failed to instantiate LoggerFinder provider; Using default.", x);
	}
	} else if (errorPolicy != ErrorPolicy.QUIET) {
	// if QUIET just silently use the plain default impl
	// otherwise, log a warning, possibly adding the exception
	// stack trace (if DEBUG is specified).
	SimpleConsoleLogger logger =
	new SimpleConsoleLogger("jdk.internal.logger", false);
	logger.log(System.Logger.Level.WARNING,
	"Failed to instantiate LoggerFinder provider; Using default.");
	if (errorPolicy == ErrorPolicy.DEBUG) {
	logger.log(System.Logger.Level.WARNING,
	"Exception raised trying to instantiate LoggerFinder", x);
	}
	}
	}
	return result;
	}

	private static System.LoggerFinder loadDefaultImplementation() {
	final SecurityManager sm = System.getSecurityManager();
	final Iterator<DefaultLoggerFinder> iterator;
	if (sm == null) {
	iterator = ServiceLoader.loadInstalled(DefaultLoggerFinder.class).iterator();
	} else {
	// We use limited do privileged here - the minimum set of
	// permissions required to 'see' the META-INF/services resources
	// seems to be CLASSLOADER_PERMISSION and READ_PERMISSION.
	// Note that do privileged is required because
	// otherwise the SecurityManager will prevent the ServiceLoader
	// from seeing the installed provider.
	PrivilegedAction<Iterator<DefaultLoggerFinder>> pa = () ->
	ServiceLoader.loadInstalled(DefaultLoggerFinder.class).iterator();
	iterator = AccessController.doPrivileged(pa, null,
	LOGGERFINDER_PERMISSION, CLASSLOADER_PERMISSION,
	READ_PERMISSION);
	}
	DefaultLoggerFinder result = null;
	try {
	// Iterator iterates with the access control context stored
	// at ServiceLoader creation time.
	if (iterator.hasNext()) {
	result = iterator.next();
	}
	} catch (RuntimeException x) {
	throw new ServiceConfigurationError(
	"Failed to instantiate default LoggerFinder", x);
	}
	if (result == null) {
	result = new DefaultLoggerFinder();
	}
	return result;
	}

	public static System.LoggerFinder getLoggerFinder() {
	final SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
	sm.checkPermission(LOGGERFINDER_PERMISSION);
	}
	return service();
	}

	}

Back to index...