infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-02-26 10:10:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

8033661: readConfiguration does not cleanly reinitialize the logging system

Browse Source 
Two new updateConfiguration methods have been added to LogManager: call updateConfiguration to update a configuration *after* the LogManager is initialized.

Reviewed-by: mchung
This commit is contained in:
Daniel Fuchs 2015-10-12 20:13:22 +02:00
parent b14bbfc3da
commit bd69fa0635
6 changed files with 3892 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

872
jdk/src/java.logging/share/classes/java/util/logging/LogManager.java
View File

@ -32,8 +32,14 @@ import java.security.*;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.concurrent.ConcurrentHashMap;
import java.nio.file.Paths;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import jdk.internal.misc.JavaAWTAccess;
import jdk.internal.misc.SharedSecrets;
import sun.misc.ManagedLocalsThread;
@ -57,37 +63,28 @@ import sun.misc.ManagedLocalsThread;
* <p>
* At startup the LogManager class is located using the
* java.util.logging.manager system property.
*
* <h3>LogManager Configuration</h3>
*
* A LogManager initializes the logging configuration via
* the {@link #readConfiguration()} method during LogManager initialization.
* By default, LogManager default configuration is used.
* The logging configuration read by LogManager must be in the
* {@linkplain Properties properties file} format.
* <p>
* The LogManager defines two optional system properties that allow control over
* the initial configuration:
* the initial configuration, as specified in the {@link #readConfiguration()}
* method:
* <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"
* <p>
* These two system 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 {@code readConfiguration(InputStream)}
* 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 {@linkplain Properties properties} for loggers and Handlers will have
* names starting with the dot-separated name for the handler or logger.<br>
* The global logging properties may include:
* <ul>
* <li>A property "handlers". This defines a whitespace or comma separated
@ -788,7 +785,7 @@ public class LogManager {
// instantiation of the handler is done in the LogManager.addLogger
// implementation as a handler class may be only visible to LogManager
// subclass for the custom log manager case
processParentHandlers(logger, name);
processParentHandlers(logger, name, VisitedLoggers.NEVER);
// Find the new node and its parent.
LogNode node = getNode(name);
@ -836,7 +833,8 @@ public class LogManager {
// If logger.getUseParentHandlers() returns 'true' and any of the logger's
// parents have levels or handlers defined, make sure they are instantiated.
private void processParentHandlers(final Logger logger, final String name) {
private void processParentHandlers(final Logger logger, final String name,
Predicate<Logger> visited) {
final LogManager owner = getOwner();
AccessController.doPrivileged(new PrivilegedAction<Void>() {
@Override
@ -862,7 +860,9 @@ public class LogManager {
owner.getProperty(pname + ".handlers") != null) {
// This pname has a level/handlers definition.
// Make sure it exists.
demandLogger(pname, null, null);
if (visited.test(demandLogger(pname, null, null))) {
break;
}
}
ix = ix2+1;
}
@ -942,48 +942,64 @@ public class LogManager {
private void loadLoggerHandlers(final Logger logger, final String name,
final String handlersPropertyName)
{
AccessController.doPrivileged(new PrivilegedAction<Object>() {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
@Override
public Object run() {
String names[] = parseClassNames(handlersPropertyName);
final boolean ensureCloseOnReset = names.length > 0
&& getBooleanProperty(handlersPropertyName + ".ensureCloseOnReset",true);
int count = 0;
for (String type : names) {
try {
Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(type);
Handler hdl = (Handler) clz.newInstance();
// Check if there is a property defining the
// this handler's level.
String levs = getProperty(type + ".level");
if (levs != null) {
Level l = Level.findLevel(levs);
if (l != null) {
hdl.setLevel(l);
} else {
// Probably a bad level. Drop through.
System.err.println("Can't set level for " + type);
}
}
// Add this Handler to the logger
logger.addHandler(hdl);
if (++count == 1 && ensureCloseOnReset) {
// add this logger to the closeOnResetLoggers list.
closeOnResetLoggers.addIfAbsent(CloseOnReset.create(logger));
}
} catch (Exception ex) {
System.err.println("Can't load log handler \"" + type + "\"");
System.err.println("" + ex);
ex.printStackTrace();
}
}
public Void run() {
setLoggerHandlers(logger, name, handlersPropertyName,
createLoggerHandlers(name, handlersPropertyName));
return null;
}
});
}
private void setLoggerHandlers(final Logger logger, final String name,
final String handlersPropertyName,
List<Handler> handlers)
{
final boolean ensureCloseOnReset = ! handlers.isEmpty()
&& getBooleanProperty(handlersPropertyName + ".ensureCloseOnReset",true);
int count = 0;
for (Handler hdl : handlers) {
logger.addHandler(hdl);
if (++count == 1 && ensureCloseOnReset) {
// add this logger to the closeOnResetLoggers list.
closeOnResetLoggers.addIfAbsent(CloseOnReset.create(logger));
}
}
}
private List<Handler> createLoggerHandlers(final String name, final String handlersPropertyName)
{
String names[] = parseClassNames(handlersPropertyName);
List<Handler> handlers = new ArrayList<>(names.length);
for (String type : names) {
try {
Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(type);
Handler hdl = (Handler) clz.newInstance();
// Check if there is a property defining the
// this handler's level.
String levs = getProperty(type + ".level");
if (levs != null) {
Level l = Level.findLevel(levs);
if (l != null) {
hdl.setLevel(l);
} else {
// Probably a bad level. Drop through.
System.err.println("Can't set level for " + type);
}
}
// Add this Handler to the logger
handlers.add(hdl);
} catch (Exception ex) {
System.err.println("Can't load log handler \"" + type + "\"");
System.err.println("" + ex);
ex.printStackTrace();
}
}
return handlers;
}
// loggerRefQueue holds LoggerWeakRef objects for Logger objects
// that have been GC'ed.
@ -1242,21 +1258,48 @@ public class LogManager {
}
/**
* Reinitialize the logging properties and reread the logging configuration.
* Reads and initializes the logging configuration.
* <p>
* The same rules are used for locating the configuration properties
* as are used at startup. So normally the logging properties will
* be re-read from the same file that was used at startup.
* <P>
* Any log level definitions in the new configuration file will be
* applied using Logger.setLevel(), if the target Logger exists.
* If the "java.util.logging.config.class" system 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 {@code readConfiguration(InputStream)}
* to define properties in the LogManager.
* <p>
* If "java.util.logging.config.class" system property is <b>not</b> set,
* then this method will read the initial configuration from a properties
* file and calls the {@link #readConfiguration(InputStream)} method to initialize
* the configuration. The "java.util.logging.config.file" system property can be used
* to specify the properties file that will be read as the initial configuration;
* if not set, then the LogManager default configuration is used.
* The default configuration is typically loaded from the
* properties file "{@code conf/logging.properties}" in the Java installation
* directory.
*
* <p>
* Any {@linkplain #addConfigurationListener registered configuration
* listener} will be invoked after the properties are read.
*
* @exception SecurityException if a security manager exists and if
* the caller does not have LoggingPermission("control").
* @exception IOException if there are IO problems reading the configuration.
* @apiNote This {@code readConfiguration} method should only be used for
* initializing the configuration during LogManager initialization or
* used with the "java.util.logging.config.class" property.
* When this method is called after loggers have been created, and
* the "java.util.logging.config.class" system property is not set, all
* existing loggers will be {@linkplain #reset() reset}. Then any
* existing loggers that have a level property specified in the new
* configuration stream will be {@linkplain
* Logger#setLevel(java.util.logging.Level) set} to the specified log level.
* <p>
* To properly update the logging configuration, use the
* {@link #updateConfiguration(java.util.function.Function)} or
* {@link #updateConfiguration(java.io.InputStream, java.util.function.Function)}
* methods instead.
*
* @throws SecurityException if a security manager exists and if
* the caller does not have LoggingPermission("control").
* @throws IOException if there are IO problems reading the configuration.
*/
public void readConfiguration() throws IOException, SecurityException {
checkPermission();
@ -1284,20 +1327,24 @@ public class LogManager {
}
}
String fname = getConfigurationFileName();
try (final InputStream in = new FileInputStream(fname)) {
final BufferedInputStream bin = new BufferedInputStream(in);
readConfiguration(bin);
}
}
String getConfigurationFileName() throws IOException {
String fname = System.getProperty("java.util.logging.config.file");
if (fname == null) {
fname = System.getProperty("java.home");
if (fname == null) {
throw new Error("Can't find java.home ??");
}
File f = new File(fname, "conf");
f = new File(f, "logging.properties");
fname = f.getCanonicalPath();
}
try (final InputStream in = new FileInputStream(fname)) {
final BufferedInputStream bin = new BufferedInputStream(in);
readConfiguration(bin);
fname = Paths.get(fname, "conf", "logging.properties")
.toAbsolutePath().normalize().toString();
}
return fname;
}
/**
@ -1305,9 +1352,17 @@ public class LogManager {
* <p>
* For all named loggers, the reset operation removes and closes
* all Handlers and (except for the root logger) sets the level
* to null. The root logger's level is set to Level.INFO.
* to {@code null}. The root logger's level is set to {@code Level.INFO}.
*
* @exception SecurityException if a security manager exists and if
* @apiNote Calling this method also clears the LogManager {@linkplain
* #getProperty(java.lang.String) properties}. The {@link
* #updateConfiguration(java.util.function.Function)
* updateConfiguration(Function)} or
* {@link #updateConfiguration(java.io.InputStream, java.util.function.Function)
* updateConfiguration(InputStream, Function)} method can be used to
* properly update to a new configuration.
*
* @throws SecurityException if a security manager exists and if
* the caller does not have LoggingPermission("control").
*/
@ -1421,18 +1476,32 @@ public class LogManager {
}
/**
* Reinitialize the logging properties and reread the logging configuration
* from the given stream, which should be in java.util.Properties format.
* Reads and initializes the logging configuration from the given input stream.
*
* <p>
* Any {@linkplain #addConfigurationListener registered configuration
* listener} will be invoked after the properties are read.
* <p>
* Any log level definitions in the new configuration file will be
* applied using Logger.setLevel(), if the target Logger exists.
* @apiNote This {@code readConfiguration} method should only be used for
* initializing the configuration during LogManager initialization or
* used with the "java.util.logging.config.class" property.
* When this method is called after loggers have been created, all
* existing loggers will be {@linkplain #reset() reset}. Then any
* existing loggers that have a level property specified in the
* given input stream will be {@linkplain
* Logger#setLevel(java.util.logging.Level) set} to the specified log level.
* <p>
* To properly update the logging configuration, use the
* {@link #updateConfiguration(java.util.function.Function)} or
* {@link #updateConfiguration(java.io.InputStream, java.util.function.Function)}
* method instead.
*
* @param ins stream to read properties from
* @exception SecurityException if a security manager exists and if
* @param ins stream to read properties from
* @throws SecurityException if a security manager exists and if
* the caller does not have LoggingPermission("control").
* @exception IOException if there are problems reading from the stream.
* @throws IOException if there are problems reading from the stream,
* or the given stream is not in the
* {@linkplain java.util.Properties properties file} format.
*/
public void readConfiguration(InputStream ins) throws IOException, SecurityException {
checkPermission();
@ -1506,6 +1575,633 @@ public class LogManager {
invokeConfigurationListeners();
}
// This enum enumerate the configuration properties that will be
// updated on existing loggers when the configuration is updated
// with LogManager.updateConfiguration().
//
// Note that this works properly only for the global LogManager - as
// Handler and its subclasses get their configuration from
// LogManager.getLogManager().
//
static enum ConfigProperty {
LEVEL(".level"), HANDLERS(".handlers"), USEPARENT(".useParentHandlers");
final String suffix;
final int length;
private ConfigProperty(String suffix) {
this.suffix = Objects.requireNonNull(suffix);
length = suffix.length();
}
public boolean handleKey(String key) {
if (this == HANDLERS && suffix.substring(1).equals(key)) return true;
if (this == HANDLERS && suffix.equals(key)) return false;
return key.endsWith(suffix);
}
String key(String loggerName) {
if (this == HANDLERS && (loggerName == null || loggerName.isEmpty())) {
return suffix.substring(1);
}
return loggerName + suffix;
}
String loggerName(String key) {
assert key.equals(suffix.substring(1)) && this == HANDLERS || key.endsWith(suffix);
if (this == HANDLERS && suffix.substring(1).equals(key)) return "";
return key.substring(0, key.length() - length);
}
/**
* If the property is one that should be updated on existing loggers by
* updateConfiguration, returns the name of the logger for which the
* property is configured. Otherwise, returns null.
* @param property a property key in 'props'
* @return the name of the logger on which the property is to be set,
* if the property is one that should be updated on existing
* loggers, {@code null} otherwise.
*/
static String getLoggerName(String property) {
for (ConfigProperty p : ConfigProperty.ALL) {
if (p.handleKey(property)) {
return p.loggerName(property);
}
}
return null; // Not a property that should be updated.
}
/**
* Find the ConfigProperty corresponding to the given
* property key (may find none).
* @param property a property key in 'props'
* @return An optional containing a ConfigProperty object,
* if the property is one that should be updated on existing
* loggers, empty otherwise.
*/
static Optional<ConfigProperty> find(String property) {
return ConfigProperty.ALL.stream()
.filter(p -> p.handleKey(property))
.findFirst();
}
/**
* Returns true if the given property is one that should be updated
* on existing loggers.
* Used to filter property name streams.
* @param property a property key from the configuration.
* @return true if this property is of interest for updateConfiguration.
*/
static boolean matches(String property) {
return find(property).isPresent();
}
/**
* Returns true if the new property value is different from the old,
* and therefore needs to be updated on existing loggers.
* @param k a property key in the configuration
* @param previous the old configuration
* @param next the new configuration
* @return true if the property is changing value between the two
* configurations.
*/
static boolean needsUpdating(String k, Properties previous, Properties next) {
final String p = trim(previous.getProperty(k, null));
final String n = trim(next.getProperty(k, null));
return ! Objects.equals(p,n);
}
/**
* Applies the mapping function for the given key to the next
* configuration.
* If the mapping function is null then this method does nothing.
* Otherwise, it calls the mapping function to compute the value
* that should be associated with {@code key} in the resulting
* configuration, and applies it to {@code next}.
* If the mapping function returns {@code null} the key is removed
* from {@code next}.
*
* @param k a property key in the configuration
* @param previous the old configuration
* @param next the new configuration (modified by this function)
* @param remappingFunction the mapping function.
*/
static void merge(String k, Properties previous, Properties next,
BiFunction<String, String, String> mappingFunction) {
String p = trim(previous.getProperty(k, null));
String n = trim(next.getProperty(k, null));
String mapped = trim(mappingFunction.apply(p,n));
if (!Objects.equals(n, mapped)) {
if (mapped == null) {
next.remove(k);
} else {
next.setProperty(k, mapped);
}
}
}
private static final EnumSet<ConfigProperty> ALL =
EnumSet.allOf(ConfigProperty.class);
}
// trim the value if not null.
private static String trim(String value) {
return value == null ? null : value.trim();
}
/**
* An object that keep track of loggers we have already visited.
* Used when updating configuration, to avoid processing the same logger
* twice.
*/
static final class VisitedLoggers implements Predicate<Logger> {
final IdentityHashMap<Logger,Boolean> visited;
private VisitedLoggers(IdentityHashMap<Logger,Boolean> visited) {
this.visited = visited;
}
VisitedLoggers() {
this(new IdentityHashMap<>());
}
@Override
public boolean test(Logger logger) {
return visited != null && visited.put(logger, Boolean.TRUE) != null;
}
public void clear() {
if (visited != null) visited.clear();
}
// An object that considers that no logger has ever been visited.
// This is used when processParentHandlers is called from
// LoggerContext.addLocalLogger
static final VisitedLoggers NEVER = new VisitedLoggers(null);
}
/**
* Type of the modification for a given property. One of SAME, ADDED, CHANGED,
* or REMOVED.
*/
static enum ModType {
SAME, // property had no value in the old and new conf, or had the
// same value in both.
ADDED, // property had no value in the old conf, but has one in the new.
CHANGED, // property has a different value in the old conf and the new conf.
REMOVED; // property has no value in the new conf, but had one in the old.
static ModType of(String previous, String next) {
if (previous == null && next != null) {
return ADDED;
}
if (next == null && previous != null) {
return REMOVED;
}
if (!Objects.equals(trim(previous), trim(next))) {
return CHANGED;
}
return SAME;
}
}
/**
* Updates the logging configuration.
* <p>
* If the "java.util.logging.config.file" system property is set,
* then the property value specifies the properties file to be read
* as the new configuration. Otherwise, the LogManager default
* configuration is used.
* <br>The default configuration is typically loaded from the
* properties file "{@code conf/logging.properties}" in the
* Java installation directory.
* <p>
* This method reads the new configuration and calls the {@link
* #updateConfiguration(java.io.InputStream, java.util.function.Function)
* updateConfiguration(ins, mapper)} method to
* update the configuration.
*
* @apiNote
* This method updates the logging configuration from reading
* a properties file and ignores the "java.util.logging.config.class"
* system property. The "java.util.logging.config.class" property is
* only used by the {@link #readConfiguration()} method to load a custom
* configuration class as an initial configuration.
*
* @param mapper a functional interface that takes a configuration
* key <i>k</i> and returns a function <i>f(o,n)</i> whose returned
* value will be applied to the resulting configuration. The
* function <i>f</i> may return {@code null} to indicate that the property
* <i>k</i> will not be added to the resulting configuration.
* <br>
* If {@code mapper} is {@code null} then {@code (k) -> ((o, n) -> n)} is
* assumed.
* <br>
* For each <i>k</i>, the mapped function <i>f</i> will
* be invoked with the value associated with <i>k</i> in the old
* configuration (i.e <i>o</i>) and the value associated with
* <i>k</i> in the new configuration (i.e. <i>n</i>).
* <br>A {@code null} value for <i>o</i> or <i>n</i> indicates that no
* value was present for <i>k</i> in the corresponding configuration.
*
* @throws SecurityException if a security manager exists and if
* the caller does not have LoggingPermission("control"), or
* does not have the permissions required to set up the
* configuration (e.g. open file specified for FileHandlers
* etc...)
*
* @throws NullPointerException if {@code mapper} returns a {@code null}
* function when invoked.
*
* @throws IOException if there are problems reading from the
* logging configuration file.
*
* @see #updateConfiguration(java.io.InputStream, java.util.function.Function)
*/
public void updateConfiguration(Function<String, BiFunction<String,String,String>> mapper)
throws IOException {
checkPermission();
ensureLogManagerInitialized();
drainLoggerRefQueueBounded();
String fname = getConfigurationFileName();
try (final InputStream in = new FileInputStream(fname)) {
final BufferedInputStream bin = new BufferedInputStream(in);
updateConfiguration(bin, mapper);
}
}
/**
* Updates the logging configuration.
* <p>
* For each configuration key in the {@linkplain
* #getProperty(java.lang.String) existing configuration} and
* the given input stream configuration, the given {@code mapper} function
* is invoked to map from the configuration key to a function,
* <i>f(o,n)</i>, that takes the old value and new value and returns
* the resulting value to be applied in the resulting configuration,
* as specified in the table below.
* <p>Let <i>k</i> be a configuration key in the old or new configuration,
* <i>o</i> be the old value (i.e. the value associated
* with <i>k</i> in the old configuration), <i>n</i> be the
* new value (i.e. the value associated with <i>k</i> in the new
* configuration), and <i>f</i> be the function returned
* by {@code mapper.apply(}<i>k</i>{@code )}: then <i>v = f(o,n)</i> is the
* resulting value. If <i>v</i> is not {@code null}, then a property
* <i>k</i> with value <i>v</i> will be added to the resulting configuration.
* Otherwise, it will be omitted.
* <br>A {@code null} value may be passed to function
* <i>f</i> to indicate that the corresponding configuration has no
* configuration key <i>k</i>.
* The function <i>f</i> may return {@code null} to indicate that
* there will be no value associated with <i>k</i> in the resulting
* configuration.
* <p>
* If {@code mapper} is {@code null}, then <i>v</i> will be set to
* <i>n</i>.
* <p>
* LogManager {@linkplain #getProperty(java.lang.String) properties} are
* updated with the resulting value in the resulting configuration.
* <p>
* The registered {@linkplain #addConfigurationListener configuration
* listeners} will be invoked after the configuration is successfully updated.
* <br><br>
* <table summary="Updating configuration properties">
* <tr>
* <th>Property</th>
* <th>Resulting Behavior</th>
* </tr>
* <tr>
* <td valign="top">{@code <logger>.level}</td>
* <td>
* <ul>
* <li>If the resulting configuration defines a level for a logger and
* if the resulting level is different than the level specified in the
* the old configuration, or not specified in
* the old configuration, then if the logger exists or if children for
* that logger exist, the level for that logger will be updated,
* and the change propagated to any existing logger children.
* This may cause the logger to be created, if necessary.
* </li>
* <li>If the old configuration defined a level for a logger, and the
* resulting configuration doesn't, then this change will not be
* propagated to existing loggers, if any.
* To completely replace a configuration - the caller should therefore
* call {@link #reset() reset} to empty the current configuration,
* before calling {@code updateConfiguration}.
* </li>
* </ul>
* </td>
* <tr>
* <td valign="top">{@code <logger>.useParentHandlers}</td>
* <td>
* <ul>
* <li>If either the resulting or the old value for the useParentHandlers
* property is not null, then if the logger exists or if children for
* that logger exist, that logger will be updated to the resulting
* value.
* The value of the useParentHandlers property is the value specified
* in the configuration; if not specified, the default is true.
* </li>
* </ul>
* </td>
* </tr>
* <tr>
* <td valign="top">{@code <logger>.handlers}</td>
* <td>
* <ul>
* <li>If the resulting configuration defines a list of handlers for a
* logger, and if the resulting list is different than the list
* specified in the old configuration for that logger (that could be
* empty), then if the logger exists or its children exist, the
* handlers associated with that logger are closed and removed and
* the new handlers will be created per the resulting configuration
* and added to that logger, creating that logger if necessary.
* </li>
* <li>If the old configuration defined some handlers for a logger, and
* the resulting configuration doesn't, if that logger exists,
* its handlers will be removed and closed.
* </li>
* <li>Changing the list of handlers on an existing logger will cause all
* its previous handlers to be removed and closed, regardless of whether
* they had been created from the configuration or programmatically.
* The old handlers will be replaced by new handlers, if any.
* </li>
* </ul>
* </td>
* </tr>
* <tr>
* <td valign="top">{@code <handler-name>.*}</td>
* <td>
* <ul>
* <li>Properties configured/changed on handler classes will only affect
* newly created handlers. If a node is configured with the same list
* of handlers in the old and the resulting configuration, then these
* handlers will remain unchanged.
* </li>
* </ul>
* </td>
* </tr>
* <tr>
* <td valign="top">{@code config} and any other property</td>
* <td>
* <ul>
* <li>The resulting value for these property will be stored in the
* LogManager properties, but {@code updateConfiguration} will not parse
* or process their values.
* </li>
* </ul>
* </td>
* </tr>
* </table>
* <p>
* <em>Example mapper functions:</em>
* <br><br>
* <ul>
* <li>Replace all logging properties with the new configuration:
* <br><br>{@code (k) -> ((o, n) -> n)}:
* <br><br>this is equivalent to passing a null {@code mapper} parameter.
* </li>
* <li>Merge the new configuration and old configuration and use the
* new value if <i>k</i> exists in the new configuration:
* <br><br>{@code (k) -> ((o, n) -> n == null ? o : n)}:
* <br><br>as if merging two collections as follows:
* {@code result.putAll(oldc); result.putAll(newc)}.<br></li>
* <li>Merge the new configuration and old configuration and use the old
* value if <i>k</i> exists in the old configuration:
* <br><br>{@code (k) -> ((o, n) -> o == null ? n : o)}:
* <br><br>as if merging two collections as follows:
* {@code result.putAll(newc); result.putAll(oldc)}.<br></li>
* <li>Replace all properties with the new configuration except the handler
* property to configure Logger's handler that is not root logger:
* <br>
* <pre>{@code (k) -> k.endsWith(".handlers")}
* {@code ? ((o, n) -> (o == null ? n : o))}
* {@code : ((o, n) -> n)}</pre>
* </li>
* </ul>
* <p>
* To completely reinitialize a configuration, an application can first call
* {@link #reset() reset} to fully remove the old configuration, followed by
* {@code updateConfiguration} to initialize the new configuration.
*
* @param ins a stream to read properties from
* @param mapper a functional interface that takes a configuration
* key <i>k</i> and returns a function <i>f(o,n)</i> whose returned
* value will be applied to the resulting configuration. The
* function <i>f</i> may return {@code null} to indicate that the property
* <i>k</i> will not be added to the resulting configuration.
* <br>
* If {@code mapper} is {@code null} then {@code (k) -> ((o, n) -> n)} is
* assumed.
* <br>
* For each <i>k</i>, the mapped function <i>f</i> will
* be invoked with the value associated with <i>k</i> in the old
* configuration (i.e <i>o</i>) and the value associated with
* <i>k</i> in the new configuration (i.e. <i>n</i>).
* <br>A {@code null} value for <i>o</i> or <i>n</i> indicates that no
* value was present for <i>k</i> in the corresponding configuration.
*
* @throws SecurityException if a security manager exists and if
* the caller does not have LoggingPermission("control"), or
* does not have the permissions required to set up the
* configuration (e.g. open files specified for FileHandlers)
*
* @throws NullPointerException if {@code ins} is null or if
* {@code mapper} returns a null function when invoked.
*
* @throws IOException if there are problems reading from the stream,
* or the given stream is not in the
* {@linkplain java.util.Properties properties file} format.
*/
public void updateConfiguration(InputStream ins,
Function<String, BiFunction<String,String,String>> mapper)
throws IOException {
checkPermission();
ensureLogManagerInitialized();
drainLoggerRefQueueBounded();
final Properties previous;
final Set<String> updatePropertyNames;
List<LoggerContext> cxs = Collections.emptyList();
final VisitedLoggers visited = new VisitedLoggers();
final Properties next = new Properties();
try {
// Load the properties
next.load(ins);
} catch (IllegalArgumentException x) {
// props.load may throw an IllegalArgumentException if the stream
// contains malformed Unicode escape sequences.
// We wrap that in an IOException as updateConfiguration is
// specified to throw IOException if there are problems reading
// from the stream.
// Note: new IOException(x.getMessage(), x) allow us to get a more
// concise error message than new IOException(x);
throw new IOException(x.getMessage(), x);
}
if (globalHandlersState == STATE_SHUTDOWN) return;
// exclusive lock: readConfiguration/reset/updateConfiguration can't
// run concurrently.
// configurationLock.writeLock().lock();
configurationLock.lock();
try {
if (globalHandlersState == STATE_SHUTDOWN) return;
previous = props;
// Builds a TreeSet of all (old and new) property names.
updatePropertyNames =
Stream.concat(previous.stringPropertyNames().stream(),
next.stringPropertyNames().stream())
.collect(Collectors.toCollection(TreeSet::new));
if (mapper != null) {
// mapper will potentially modify the content of
// 'next', so we need to call it before affecting props=next.
// give a chance to the mapper to control all
// properties - not just those we will reset.
updatePropertyNames.stream()
.forEachOrdered(k -> ConfigProperty
.merge(k, previous, next,
Objects.requireNonNull(mapper.apply(k))));
}
props = next;
// allKeys will contain all keys:
// - which correspond to a configuration property we are interested in
// (first filter)
// - whose value needs to be updated (because it's new, removed, or
// different) in the resulting configuration (second filter)
final Stream<String> allKeys = updatePropertyNames.stream()
.filter(ConfigProperty::matches)
.filter(k -> ConfigProperty.needsUpdating(k, previous, next));
// Group configuration properties by logger name
// We use a TreeMap so that parent loggers will be visited before
// child loggers.
final Map<String, TreeSet<String>> loggerConfigs =
allKeys.collect(Collectors.groupingBy(ConfigProperty::getLoggerName,
TreeMap::new,
Collectors.toCollection(TreeSet::new)));
if (!loggerConfigs.isEmpty()) {
cxs = contexts();
}
final List<Logger> loggers = cxs.isEmpty()
? Collections.emptyList() : new ArrayList<>(cxs.size());
for (Map.Entry<String, TreeSet<String>> e : loggerConfigs.entrySet()) {
// This can be a logger name, or something else...
// The only thing we know is that we found a property
// we are interested in.
// For instance, if we found x.y.z.level, then x.y.z could be
// a logger, but it could also be a handler class...
// Anyway...
final String name = e.getKey();
final Set<String> properties = e.getValue();
loggers.clear();
for (LoggerContext cx : cxs) {
Logger l = cx.findLogger(name);
if (l != null && !visited.test(l)) {
loggers.add(l);
}
}
if (loggers.isEmpty()) continue;
for (String pk : properties) {
ConfigProperty cp = ConfigProperty.find(pk).get();
String p = previous.getProperty(pk, null);
String n = next.getProperty(pk, null);
// Determines the type of modification.
ModType mod = ModType.of(p, n);
// mod == SAME means that the two values are equals, there
// is nothing to do. Usually, this should not happen as such
// properties should have been filtered above.
// It could happen however if the properties had
// trailing/leading whitespaces.
if (mod == ModType.SAME) continue;
switch (cp) {
case LEVEL:
if (mod == ModType.REMOVED) continue;
Level level = Level.findLevel(trim(n));
if (level != null) {
if (name.isEmpty()) {
rootLogger.setLevel(level);
}
for (Logger l : loggers) {
if (!name.isEmpty() || l != rootLogger) {
l.setLevel(level);
}
}
}
break;
case USEPARENT:
if (!name.isEmpty()) {
boolean useParent = getBooleanProperty(pk, true);
if (n != null || p != null) {
// reset the flag only if the previous value
// or the new value are not null.
for (Logger l : loggers) {
l.setUseParentHandlers(useParent);
}
}
}
break;
case HANDLERS:
List<Handler> hdls = null;
if (name.isEmpty()) {
// special handling for the root logger.
globalHandlersState = STATE_READING_CONFIG;
try {
closeHandlers(rootLogger);
globalHandlersState = STATE_UNINITIALIZED;
} catch (Throwable t) {
globalHandlersState = STATE_INITIALIZED;
throw t;
}
}
for (Logger l : loggers) {
if (l == rootLogger) continue;
closeHandlers(l);
if (mod == ModType.REMOVED) {
closeOnResetLoggers.removeIf(c -> c.logger == l);
continue;
}
if (hdls == null) {
hdls = name.isEmpty()
? Arrays.asList(rootLogger.getHandlers())
: createLoggerHandlers(name, pk);
}
setLoggerHandlers(l, name, pk, hdls);
}
break;
default: break;
}
}
}
} finally {
configurationLock.unlock();
visited.clear();
}
// Now ensure that if an existing logger has acquired a new parent
// in the configuration, this new parent will be created - if needed,
// and added to the context of the existing child.
//
drainLoggerRefQueueBounded();
for (LoggerContext cx : cxs) {
for (Enumeration<String> names = cx.getLoggerNames() ; names.hasMoreElements();) {
String name = names.nextElement();
if (name.isEmpty()) continue; // don't need to process parents on root.
Logger l = cx.findLogger(name);
if (l != null && !visited.test(l)) {
// should pass visited here to cut the processing when
// reaching a logger already visited.
cx.processParentHandlers(l, name, visited);
}
}
}
// We changed the configuration: invoke configuration listeners
invokeConfigurationListeners();
}
/**
* Get the value of a logging property.
* The method returns null if the property is not found.

548
jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/HandlersOnComplexResetUpdate.java Normal file
View File

@ -0,0 +1,548 @@
/*
* 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.
*
* 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.
*/
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FilePermission;
import java.io.IOException;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.CodeSource;
import java.security.Permission;
import java.security.PermissionCollection;
import java.security.Permissions;
import java.security.Policy;
import java.security.ProtectionDomain;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
import java.util.UUID;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.logging.FileHandler;
import java.util.logging.LogManager;
import java.util.logging.Logger;
import java.util.logging.LoggingPermission;
/**
* @test
* @bug 8033661
* @summary tests that FileHandlers configured on abstract nodes in logging.properties
* will be closed on reset and reopened on updateConfiguration().
* Test a complex reconfiguration where a logger with handlers
* suddenly appears in the hierarchy between a child logger and the
* root logger.
* @run main/othervm HandlersOnComplexResetUpdate UNSECURE
* @run main/othervm HandlersOnComplexResetUpdate SECURE
* @author danielfuchs
*/
public class HandlersOnComplexResetUpdate {
/**
* We will test the handling of abstract logger nodes with file handlers in
* two configurations:
* UNSECURE: No security manager.
* SECURE: With the security manager present - and the required
* permissions granted.
*/
public static enum TestCase {
UNSECURE, SECURE;
public void run(List<Properties> properties) throws Exception {
System.out.println("Running test case: " + name());
Configure.setUp(this, properties.get(0));
test(this.name(), properties);
}
}
private static final String PREFIX =
"FileHandler-" + UUID.randomUUID() + ".log";
private static final String userDir = System.getProperty("user.dir", ".");
private static final boolean userDirWritable = Files.isWritable(Paths.get(userDir));
private static final List<Properties> properties;
static {
// The test will call reset() and updateConfiguration() with each of these
// properties in sequence. The child logger is not released between each
// configuration. What is interesting here is mostly what happens between
// props4 and props5:
//
// In step 4 (props4) the configuration defines a handler for the
// logger com.foo (the direct parent of com.foo.child - which is the
// logger we hold on to).
//
// In step 5 (props5) the configuration has nothing concerning
// 'com.foo', but the handler has been migrated to 'com'.
// Since there doesn't exist any logger for 'com' (the previous
// configuration didn't have any configuration for 'com'), then
// 'com' will not be found when we process the existing loggers named
// in the configuration.
//
// So if we didn't also process the existing loggers not named in the
// configuration (such as com.foo.child) then no logger for 'com'
// would be created, which means that com.foo.child would not be
// able to inherit its configuration for 'com' until someone explicitely
// creates a logger for 'com'.
//
// This test check that a logger for 'com' will be created because
// 'com.foo.child' still exists when updateConfiguration() is called.
Properties props1 = new Properties();
props1.setProperty("test.name", "parent logger with handler");
props1.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
props1.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
props1.setProperty(FileHandler.class.getName() + ".level", "ALL");
props1.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
props1.setProperty("com.foo.handlers", FileHandler.class.getName());
props1.setProperty("test.checkHandlersOnParent", "true");
props1.setProperty("test.checkHandlersOn", "com.foo");
props1.setProperty("com.bar.level", "FINEST");
Properties props2 = new Properties();
props2.setProperty("java.util.logging.LogManager.reconfigureHandlers", "true");
props2.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
props2.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
props2.setProperty(FileHandler.class.getName() + ".level", "ALL");
props2.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
props2.setProperty("com.foo.handlers", FileHandler.class.getName());
props2.setProperty("test.checkHandlersOnParent", "true");
props2.setProperty("test.checkHandlersOn", "com.foo");
props2.setProperty("com.bar.level", "FINEST");
Properties props3 = new Properties();
props3.setProperty("test.name", "parent logger with handler");
props3.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
props3.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
props3.setProperty(FileHandler.class.getName() + ".level", "ALL");
props3.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
props3.setProperty("com.foo.handlers", FileHandler.class.getName());
props3.setProperty("test.checkHandlersOnParent", "true");
props3.setProperty("test.checkHandlersOn", "com.foo");
props3.setProperty("com.bar.level", "FINEST");
Properties props4 = new Properties();
props4.setProperty("java.util.logging.LogManager.reconfigureHandlers", "true");
props4.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
props4.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
props4.setProperty(FileHandler.class.getName() + ".level", "ALL");
props4.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
props4.setProperty("test.checkHandlersOnParent", "true");
props4.setProperty("test.checkHandlersOn", "com.foo");
props4.setProperty("com.foo.handlers", FileHandler.class.getName());
Properties props5 = new Properties();
props5.setProperty("test.name", "parent logger with handler");
props5.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
props5.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
props5.setProperty(FileHandler.class.getName() + ".level", "ALL");
props5.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
props5.setProperty("test.checkHandlersOnParent", "false");
props5.setProperty("test.checkHandlersOn", "com");
props5.setProperty("com.handlers", FileHandler.class.getName());
properties = Collections.unmodifiableList(Arrays.asList(
props1, props2, props3, props4, props5));
}
/**
* This is the main test method. The rest is infrastructure.
* Creates a child of the 'com.foo' logger (com.foo.child) and holds on to
* it.
* <p>
* Then applies all given configurations in sequence and verifies assumptions
* about the handlers that com.foo should have, or not have.
* In the last configuration (props5) it also verifies that the
* logger 'com' has been created and has now the expected handler.
* <p>
* Finally releases the child logger after all configurations have been
* applied.
*
* @param name
* @param properties
* @throws Exception
*/
static void test(String name, List<Properties> properties)
throws Exception {
System.out.println("\nTesting: " + name);
if (!userDirWritable) {
throw new RuntimeException("Not writable: "+userDir);
}
// Then create a child of the com.foo logger.
Logger fooChild = Logger.getLogger("com.foo.child");
fooChild.info("hello world");
Logger barChild = Logger.getLogger("com.bar.child");
barChild.info("hello world");
ReferenceQueue<Logger> queue = new ReferenceQueue();
WeakReference<Logger> fooRef = new WeakReference<>(Logger.getLogger("com.foo"), queue);
if (fooRef.get() != fooChild.getParent()) {
throw new RuntimeException("Unexpected parent logger: "
+ fooChild.getParent() +"\n\texpected: " + fooRef.get());
}
WeakReference<Logger> barRef = new WeakReference<>(Logger.getLogger("com.bar"), queue);
if (barRef.get() != barChild.getParent()) {
throw new RuntimeException("Unexpected parent logger: "
+ barChild.getParent() +"\n\texpected: " + barRef.get());
}
Reference<? extends Logger> ref2;
int max = 3;
barChild = null;
while ((ref2 = queue.poll()) == null) {
System.gc();
Thread.sleep(100);
if (--max == 0) break;
}
Throwable failed = null;
try {
if (ref2 != null) {
String refName = ref2 == fooRef ? "fooRef" : ref2 == barRef ? "barRef" : "unknown";
if (ref2 != barRef) {
throw new RuntimeException("Unexpected logger reference cleared: " + refName);
} else {
System.out.println("Reference " + refName + " cleared as expected");
}
} else if (ref2 == null) {
throw new RuntimeException("Expected 'barRef' to be cleared");
}
// Now lets try to reset, check that ref2 has no handlers, and
// attempt to configure again.
Properties previousProps = properties.get(0);
int expectedHandlersCount = 1;
boolean checkHandlersOnParent = Boolean.parseBoolean(
previousProps.getProperty("test.checkHandlersOnParent", "true"));
String checkHandlersOn = previousProps.getProperty("test.checkHandlersOn", null);
for (int i=1; i<properties.size(); i++) {
System.out.println("\n*** Reconfiguration with properties["+i+"]\n");
Properties nextProps = properties.get(i);
boolean reconfigureHandlers = true;
if (checkHandlersOnParent) {
assertEquals(expectedHandlersCount,
fooChild.getParent().getHandlers().length,
"fooChild.getParent().getHandlers().length");
}
if (checkHandlersOn != null) {
Logger loggerWithHandlers = LogManager.getLogManager().getLogger(checkHandlersOn);
if (loggerWithHandlers == null) {
throw new RuntimeException("Logger with handlers not found: " + checkHandlersOn);
}
assertEquals(expectedHandlersCount,
loggerWithHandlers.getHandlers().length,
checkHandlersOn + ".getHandlers().length");
}
// Reset
Configure.doPrivileged(() -> LogManager.getLogManager().reset());
assertEquals(0, fooChild.getParent().getHandlers().length, "fooChild.getParent().getHandlers().length");
if (checkHandlersOn != null) {
Logger loggerWithHandlers = LogManager.getLogManager().getLogger(checkHandlersOn);
if (loggerWithHandlers == null) {
throw new RuntimeException("Logger with handlers not found: " + checkHandlersOn);
}
assertEquals(0, loggerWithHandlers.getHandlers().length,
checkHandlersOn + ".getHandlers().length");
}
if (i == 4) {
System.out.println("Last configuration...");
}
// Read configuration
Configure.doPrivileged(() -> Configure.updateConfigurationWith(nextProps, false));
expectedHandlersCount = reconfigureHandlers ? 1 : 0;
checkHandlersOnParent = Boolean.parseBoolean(
nextProps.getProperty("test.checkHandlersOnParent", "true"));
checkHandlersOn = nextProps.getProperty("test.checkHandlersOn", null);
if (checkHandlersOnParent) {
assertEquals(expectedHandlersCount,
fooChild.getParent().getHandlers().length,
"fooChild.getParent().getHandlers().length");
} else {
assertEquals(0,
fooChild.getParent().getHandlers().length,
"fooChild.getParent().getHandlers().length");
}
if (checkHandlersOn != null) {
Logger loggerWithHandlers = LogManager.getLogManager().getLogger(checkHandlersOn);
if (loggerWithHandlers == null) {
throw new RuntimeException("Logger with handlers not found: " + checkHandlersOn);
}
assertEquals(expectedHandlersCount,
loggerWithHandlers.getHandlers().length,
checkHandlersOn + ".getHandlers().length");
}
}
} catch (Throwable t) {
failed = t;
} finally {
final Throwable suppressed = failed;
Configure.doPrivileged(() -> LogManager.getLogManager().reset());
Configure.doPrivileged(() -> {
try {
StringBuilder builder = new StringBuilder();
Files.list(Paths.get(userDir))
.filter((f) -> f.toString().contains(PREFIX))
.filter((f) -> f.toString().endsWith(".lck"))
.forEach((f) -> {
builder.append(f.toString()).append('\n');
});
if (!builder.toString().isEmpty()) {
throw new RuntimeException("Lock files not cleaned:\n"
+ builder.toString());
}
} catch(RuntimeException | Error x) {
if (suppressed != null) x.addSuppressed(suppressed);
throw x;
} catch(Exception x) {
if (suppressed != null) x.addSuppressed(suppressed);
throw new RuntimeException(x);
}
});
fooChild = null;
System.out.println("Setting fooChild to: " + fooChild);
while ((ref2 = queue.poll()) == null) {
System.gc();
Thread.sleep(1000);
}
if (ref2 != fooRef) {
throw new RuntimeException("Unexpected reference: "
+ ref2 +"\n\texpected: " + fooRef);
}
if (ref2.get() != null) {
throw new RuntimeException("Referent not cleared: " + ref2.get());
}
System.out.println("Got fooRef after reset(), fooChild is " + fooChild);
}
if (failed != null) {
// should rarely happen...
throw new RuntimeException(failed);
}
}
public static void main(String... args) throws Exception {
if (args == null || args.length == 0) {
args = new String[] {
TestCase.UNSECURE.name(),
TestCase.SECURE.name(),
};
}
try {
for (String testName : args) {
TestCase test = TestCase.valueOf(testName);
test.run(properties);
}
} finally {
if (userDirWritable) {
Configure.doPrivileged(() -> {
// cleanup - delete files that have been created
try {
Files.list(Paths.get(userDir))
.filter((f) -> f.toString().contains(PREFIX))
.forEach((f) -> {
try {
System.out.println("deleting " + f);
Files.delete(f);
} catch(Throwable t) {
System.err.println("Failed to delete " + f + ": " + t);
}
});
} catch(Throwable t) {
System.err.println("Cleanup failed to list files: " + t);
t.printStackTrace();
}
});
}
}
}
static class Configure {
static Policy policy = null;
static final ThreadLocal<AtomicBoolean> allowAll = new ThreadLocal<AtomicBoolean>() {
@Override
protected AtomicBoolean initialValue() {
return new AtomicBoolean(false);
}
};
static void setUp(TestCase test, Properties propertyFile) {
switch (test) {
case SECURE:
if (policy == null && System.getSecurityManager() != null) {
throw new IllegalStateException("SecurityManager already set");
} else if (policy == null) {
policy = new SimplePolicy(TestCase.SECURE, allowAll);
Policy.setPolicy(policy);
System.setSecurityManager(new SecurityManager());
}
if (System.getSecurityManager() == null) {
throw new IllegalStateException("No SecurityManager.");
}
if (policy == null) {
throw new IllegalStateException("policy not configured");
}
break;
case UNSECURE:
if (System.getSecurityManager() != null) {
throw new IllegalStateException("SecurityManager already set");
}
break;
default:
new InternalError("No such testcase: " + test);
}
doPrivileged(() -> {
updateConfigurationWith(propertyFile, false);
});
}
static void updateConfigurationWith(Properties propertyFile, boolean append) {
try {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
propertyFile.store(bytes, propertyFile.getProperty("test.name"));
ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());
Function<String, BiFunction<String,String,String>> remapper =
append ? (x) -> ((o, n) -> n == null ? o : n)
: (x) -> ((o, n) -> n);
LogManager.getLogManager().updateConfiguration(bais, remapper);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
static void doPrivileged(Runnable run) {
final boolean old = allowAll.get().getAndSet(true);
try {
run.run();
} finally {
allowAll.get().set(old);
}
}
static <T> T callPrivileged(Callable<T> call) throws Exception {
final boolean old = allowAll.get().getAndSet(true);
try {
return call.call();
} finally {
allowAll.get().set(old);
}
}
}
@FunctionalInterface
public static interface FileHandlerSupplier {
public FileHandler test() throws Exception;
}
static final class TestAssertException extends RuntimeException {
TestAssertException(String msg) {
super(msg);
}
}
private static void assertEquals(long expected, long received, String msg) {
if (expected != received) {
throw new TestAssertException("Unexpected result for " + msg
+ ".\n\texpected: " + expected
+ "\n\tactual: " + received);
} else {
System.out.println("Got expected " + msg + ": " + received);
}
}
final static class PermissionsBuilder {
final Permissions perms;
public PermissionsBuilder() {
this(new Permissions());
}
public PermissionsBuilder(Permissions perms) {
this.perms = perms;
}
public PermissionsBuilder add(Permission p) {
perms.add(p);
return this;
}
public PermissionsBuilder addAll(PermissionCollection col) {
if (col != null) {
for (Enumeration<Permission> e = col.elements(); e.hasMoreElements(); ) {
perms.add(e.nextElement());
}
}
return this;
}
public Permissions toPermissions() {
final PermissionsBuilder builder = new PermissionsBuilder();
builder.addAll(perms);
return builder.perms;
}
}
public static class SimplePolicy extends Policy {
final Permissions permissions;
final Permissions allPermissions;
final ThreadLocal<AtomicBoolean> allowAll; // actually: this should be in a thread locale
public SimplePolicy(TestCase test, ThreadLocal<AtomicBoolean> allowAll) {
this.allowAll = allowAll;
permissions = new Permissions();
permissions.add(new LoggingPermission("control", null));
permissions.add(new FilePermission(PREFIX+".lck", "read,write,delete"));
permissions.add(new FilePermission(PREFIX, "read,write"));
// these are used for configuring the test itself...
allPermissions = new Permissions();
allPermissions.add(new java.security.AllPermission());
}
@Override
public boolean implies(ProtectionDomain domain, Permission permission) {
if (allowAll.get().get()) return allPermissions.implies(permission);
return permissions.implies(permission);
}
@Override
public PermissionCollection getPermissions(CodeSource codesource) {
return new PermissionsBuilder().addAll(allowAll.get().get()
? allPermissions : permissions).toPermissions();
}
@Override
public PermissionCollection getPermissions(ProtectionDomain domain) {
return new PermissionsBuilder().addAll(allowAll.get().get()
? allPermissions : permissions).toPermissions();
}
}
}

547
jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/HandlersOnComplexUpdate.java Normal file
View File

@ -0,0 +1,547 @@
/*
* 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.
*
* 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.
*/
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FilePermission;
import java.io.IOException;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.CodeSource;
import java.security.Permission;
import java.security.PermissionCollection;
import java.security.Permissions;
import java.security.Policy;
import java.security.ProtectionDomain;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
import java.util.UUID;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.logging.FileHandler;
import java.util.logging.LogManager;
import java.util.logging.Logger;
import java.util.logging.LoggingPermission;
/**
* @test
* @bug 8033661
* @summary tests that FileHandlers configured on abstract nodes in logging.properties
* will be properly closed and reopened on updateConfiguration().
* Test a complex reconfiguration where a logger with handlers
* suddenly appears in the hierarchy between a child logger and the
* root logger.
* @run main/othervm HandlersOnComplexUpdate UNSECURE
* @run main/othervm HandlersOnComplexUpdate SECURE
* @author danielfuchs
*/
public class HandlersOnComplexUpdate {
/**
* We will test the handling of abstract logger nodes with file handlers in
* two configurations:
* UNSECURE: No security manager.
* SECURE: With the security manager present - and the required
* permissions granted.
*/
public static enum TestCase {
UNSECURE, SECURE;
public void run(List<Properties> properties) throws Exception {
System.out.println("Running test case: " + name());
Configure.setUp(this, properties.get(0));
test(this.name(), properties);
}
}
private static final String PREFIX =
"FileHandler-" + UUID.randomUUID() + ".log";
private static final String userDir = System.getProperty("user.dir", ".");
private static final boolean userDirWritable = Files.isWritable(Paths.get(userDir));
private static final List<Properties> properties;
static {
// The test will call updateConfiguration() with each of these
// properties in sequence. The child logger is not released between each
// configuration. What is interesting here is mostly what happens between
// props4 and props5:
//
// In step 4 (props4) the configuration defines a handler for the
// logger com.foo (the direct parent of com.foo.child - which is the
// logger we hold on to).
//
// In step 5 (props5) the configuration has nothing concerning
// 'com.foo', but the handler has been migrated to 'com'.
// Since there doesn't exist any logger for 'com' (the previous
// configuration didn't have any configuration for 'com'), then
// 'com' will not be found when we process the existing loggers named
// in the configuration.
//
// So if we didn't also process the existing loggers not named in the
// configuration (such as com.foo.child) then no logger for 'com'
// would be created, which means that com.foo.child would not be
// able to inherit its configuration for 'com' until someone explicitely
// creates a logger for 'com'.
//
// This test check that a logger for 'com' will be created because
// 'com.foo.child' still exists when updateConfiguration() is called.
Properties props1 = new Properties();
props1.setProperty("test.name", "parent logger with handler");
props1.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
props1.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
props1.setProperty(FileHandler.class.getName() + ".level", "ALL");
props1.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
props1.setProperty("com.foo.handlers", FileHandler.class.getName());
props1.setProperty("test.checkHandlersOnParent", "true");
props1.setProperty("test.checkHandlersOn", "com.foo");
props1.setProperty("com.bar.level", "FINEST");
Properties props2 = new Properties();
props2.setProperty("test.name", "parent logger with handler");
props2.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
props2.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
props2.setProperty(FileHandler.class.getName() + ".level", "ALL");
props2.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
props2.setProperty("com.foo.handlers", FileHandler.class.getName());
props2.setProperty("test.checkHandlersOnParent", "true");
props2.setProperty("test.checkHandlersOn", "com.foo");
props2.setProperty("com.bar.level", "FINEST");
Properties props3 = new Properties();
props3.setProperty("test.name", "parent logger with handler");
props3.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
props3.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
props3.setProperty(FileHandler.class.getName() + ".level", "ALL");
props3.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
props3.setProperty("com.foo.handlers", FileHandler.class.getName());
props3.setProperty("test.checkHandlersOnParent", "true");
props3.setProperty("test.checkHandlersOn", "com.foo");
props3.setProperty("com.bar.level", "FINEST");
Properties props4 = new Properties();
props4.setProperty("test.name", "parent logger with handler");
props4.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
props4.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
props4.setProperty(FileHandler.class.getName() + ".level", "ALL");
props4.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
props4.setProperty("test.checkHandlersOnParent", "true");
props4.setProperty("test.checkHandlersOn", "com.foo");
props4.setProperty("com.foo.handlers", FileHandler.class.getName());
Properties props5 = new Properties();
props5.setProperty("test.name", "parent logger with handler");
props5.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
props5.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
props5.setProperty(FileHandler.class.getName() + ".level", "ALL");
props5.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
props5.setProperty("test.checkHandlersOnParent", "false");
props5.setProperty("test.checkHandlersOn", "com");
props5.setProperty("com.handlers", FileHandler.class.getName());
properties = Collections.unmodifiableList(Arrays.asList(
props1, props2, props3, props4, props5));
}
/**
* This is the main test method. The rest is infrastructure.
* Creates a child of the 'com.foo' logger (com.foo.child) and holds on to
* it.
* <p>
* Then applies all given configurations in sequence and verifies assumptions
* about the handlers that com.foo should have, or not have.
* In the last configuration (props5) it also verifies that the
* logger 'com' has been created and has now the expected handler.
* <p>
* Finally releases the child logger after all configurations have been
* applied.
*
* @param name
* @param properties
* @throws Exception
*/
static void test(String name, List<Properties> properties)
throws Exception {
System.out.println("\nTesting: " + name);
if (!userDirWritable) {
throw new RuntimeException("Not writable: "+userDir);
}
// Then create a child of the com.foo logger.
Logger fooChild = Logger.getLogger("com.foo.child");
fooChild.info("hello world");
Logger barChild = Logger.getLogger("com.bar.child");
barChild.info("hello world");
ReferenceQueue<Logger> queue = new ReferenceQueue();
WeakReference<Logger> fooRef = new WeakReference<>(Logger.getLogger("com.foo"), queue);
if (fooRef.get() != fooChild.getParent()) {
throw new RuntimeException("Unexpected parent logger: "
+ fooChild.getParent() +"\n\texpected: " + fooRef.get());
}
WeakReference<Logger> barRef = new WeakReference<>(Logger.getLogger("com.bar"), queue);
if (barRef.get() != barChild.getParent()) {
throw new RuntimeException("Unexpected parent logger: "
+ barChild.getParent() +"\n\texpected: " + barRef.get());
}
Reference<? extends Logger> ref2;
int max = 3;
barChild = null;
while ((ref2 = queue.poll()) == null) {
System.gc();
Thread.sleep(100);
if (--max == 0) break;
}
Throwable failed = null;
try {
if (ref2 != null) {
String refName = ref2 == fooRef ? "fooRef" : ref2 == barRef ? "barRef" : "unknown";
if (ref2 != barRef) {
throw new RuntimeException("Unexpected logger reference cleared: " + refName);
} else {
System.out.println("Reference " + refName + " cleared as expected");
}
} else if (ref2 == null) {
throw new RuntimeException("Expected 'barRef' to be cleared");
}
// Now lets try to check handlers, and
// attempt to update the configuration again.
Properties previousProps = properties.get(0);
int expectedHandlersCount = 1;
boolean checkHandlersOnParent = Boolean.parseBoolean(
previousProps.getProperty("test.checkHandlersOnParent", "true"));
String checkHandlersOn = previousProps.getProperty("test.checkHandlersOn", null);
for (int i=1; i<properties.size(); i++) {
System.out.println("\n*** Reconfiguration with properties["+i+"]\n");
Properties nextProps = properties.get(i);
boolean reconfigureHandlers = true;
if (checkHandlersOnParent) {
assertEquals(expectedHandlersCount,
fooChild.getParent().getHandlers().length,
"fooChild.getParent().getHandlers().length");
}
if (checkHandlersOn != null) {
Logger loggerWithHandlers = LogManager.getLogManager().getLogger(checkHandlersOn);
if (loggerWithHandlers == null) {
throw new RuntimeException("Logger with handlers not found: " + checkHandlersOn);
}
assertEquals(expectedHandlersCount,
loggerWithHandlers.getHandlers().length,
checkHandlersOn + ".getHandlers().length");
}
if (i == 4) {
System.out.println("Last configuration...");
}
// Read configuration
Configure.doPrivileged(() -> Configure.updateConfigurationWith(nextProps, false));
expectedHandlersCount = reconfigureHandlers ? 1 : 0;
checkHandlersOnParent = Boolean.parseBoolean(
nextProps.getProperty("test.checkHandlersOnParent", "true"));
checkHandlersOn = nextProps.getProperty("test.checkHandlersOn", null);
if (checkHandlersOnParent) {
assertEquals(expectedHandlersCount,
fooChild.getParent().getHandlers().length,
"fooChild.getParent().getHandlers().length");
} else {
assertEquals(0,
fooChild.getParent().getHandlers().length,
"fooChild.getParent().getHandlers().length");
}
if (checkHandlersOn != null) {
Logger loggerWithHandlers = LogManager.getLogManager().getLogger(checkHandlersOn);
if (loggerWithHandlers == null) {
throw new RuntimeException("Logger with handlers not found: " + checkHandlersOn);
}
assertEquals(expectedHandlersCount,
loggerWithHandlers.getHandlers().length,
checkHandlersOn + ".getHandlers().length");
}
}
} catch (Throwable t) {
failed = t;
} finally {
final Throwable suppressed = failed;
Configure.doPrivileged(() -> LogManager.getLogManager().reset());
Configure.doPrivileged(() -> {
try {
StringBuilder builder = new StringBuilder();
Files.list(Paths.get(userDir))
.filter((f) -> f.toString().contains(PREFIX))
.filter((f) -> f.toString().endsWith(".lck"))
.forEach((f) -> {
builder.append(f.toString()).append('\n');
});
if (!builder.toString().isEmpty()) {
throw new RuntimeException("Lock files not cleaned:\n"
+ builder.toString());
}
} catch(RuntimeException | Error x) {
if (suppressed != null) x.addSuppressed(suppressed);
throw x;
} catch(Exception x) {
if (suppressed != null) x.addSuppressed(suppressed);
throw new RuntimeException(x);
}
});
fooChild = null;
System.out.println("Setting fooChild to: " + fooChild);
while ((ref2 = queue.poll()) == null) {
System.gc();
Thread.sleep(1000);
}
if (ref2 != fooRef) {
throw new RuntimeException("Unexpected reference: "
+ ref2 +"\n\texpected: " + fooRef);
}
if (ref2.get() != null) {
throw new RuntimeException("Referent not cleared: " + ref2.get());
}
System.out.println("Got fooRef after reset(), fooChild is " + fooChild);
}
if (failed != null) {
// should rarely happen...
throw new RuntimeException(failed);
}
}
public static void main(String... args) throws Exception {
if (args == null || args.length == 0) {
args = new String[] {
TestCase.UNSECURE.name(),
TestCase.SECURE.name(),
};
}
try {
for (String testName : args) {
TestCase test = TestCase.valueOf(testName);
test.run(properties);
}
} finally {
if (userDirWritable) {
Configure.doPrivileged(() -> {
// cleanup - delete files that have been created
try {
Files.list(Paths.get(userDir))
.filter((f) -> f.toString().contains(PREFIX))
.forEach((f) -> {
try {
System.out.println("deleting " + f);
Files.delete(f);
} catch(Throwable t) {
System.err.println("Failed to delete " + f + ": " + t);
}
});
} catch(Throwable t) {
System.err.println("Cleanup failed to list files: " + t);
t.printStackTrace();
}
});
}
}
}
static class Configure {
static Policy policy = null;
static final ThreadLocal<AtomicBoolean> allowAll = new ThreadLocal<AtomicBoolean>() {
@Override
protected AtomicBoolean initialValue() {
return new AtomicBoolean(false);
}
};
static void setUp(TestCase test, Properties propertyFile) {
switch (test) {
case SECURE:
if (policy == null && System.getSecurityManager() != null) {
throw new IllegalStateException("SecurityManager already set");
} else if (policy == null) {
policy = new SimplePolicy(TestCase.SECURE, allowAll);
Policy.setPolicy(policy);
System.setSecurityManager(new SecurityManager());
}
if (System.getSecurityManager() == null) {
throw new IllegalStateException("No SecurityManager.");
}
if (policy == null) {
throw new IllegalStateException("policy not configured");
}
break;
case UNSECURE:
if (System.getSecurityManager() != null) {
throw new IllegalStateException("SecurityManager already set");
}
break;
default:
new InternalError("No such testcase: " + test);
}
doPrivileged(() -> {
configureWith(propertyFile);
});
}
static void configureWith(Properties propertyFile) {
try {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
propertyFile.store(bytes, propertyFile.getProperty("test.name"));
ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());
LogManager.getLogManager().readConfiguration(bais);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
static void updateConfigurationWith(Properties propertyFile, boolean append) {
try {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
propertyFile.store(bytes, propertyFile.getProperty("test.name"));
ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());
Function<String, BiFunction<String,String,String>> remapper =
append ? (x) -> ((o, n) -> n == null ? o : n)
: (x) -> ((o, n) -> n);
LogManager.getLogManager().updateConfiguration(bais, remapper);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
static void doPrivileged(Runnable run) {
final boolean old = allowAll.get().getAndSet(true);
try {
run.run();
} finally {
allowAll.get().set(old);
}
}
static <T> T callPrivileged(Callable<T> call) throws Exception {
final boolean old = allowAll.get().getAndSet(true);
try {
return call.call();
} finally {
allowAll.get().set(old);
}
}
}
@FunctionalInterface
public static interface FileHandlerSupplier {
public FileHandler test() throws Exception;
}
static final class TestAssertException extends RuntimeException {
TestAssertException(String msg) {
super(msg);
}
}
private static void assertEquals(long expected, long received, String msg) {
if (expected != received) {
throw new TestAssertException("Unexpected result for " + msg
+ ".\n\texpected: " + expected
+ "\n\tactual: " + received);
} else {
System.out.println("Got expected " + msg + ": " + received);
}
}
final static class PermissionsBuilder {
final Permissions perms;
public PermissionsBuilder() {
this(new Permissions());
}
public PermissionsBuilder(Permissions perms) {
this.perms = perms;
}
public PermissionsBuilder add(Permission p) {
perms.add(p);
return this;
}
public PermissionsBuilder addAll(PermissionCollection col) {
if (col != null) {
for (Enumeration<Permission> e = col.elements(); e.hasMoreElements(); ) {
perms.add(e.nextElement());
}
}
return this;
}
public Permissions toPermissions() {
final PermissionsBuilder builder = new PermissionsBuilder();
builder.addAll(perms);
return builder.perms;
}
}
public static class SimplePolicy extends Policy {
final Permissions permissions;
final Permissions allPermissions;
final ThreadLocal<AtomicBoolean> allowAll; // actually: this should be in a thread locale
public SimplePolicy(TestCase test, ThreadLocal<AtomicBoolean> allowAll) {
this.allowAll = allowAll;
permissions = new Permissions();
permissions.add(new LoggingPermission("control", null));
permissions.add(new FilePermission(PREFIX+".lck", "read,write,delete"));
permissions.add(new FilePermission(PREFIX, "read,write"));
// these are used for configuring the test itself...
allPermissions = new Permissions();
allPermissions.add(new java.security.AllPermission());
}
@Override
public boolean implies(ProtectionDomain domain, Permission permission) {
if (allowAll.get().get()) return allPermissions.implies(permission);
return permissions.implies(permission);
}
@Override
public PermissionCollection getPermissions(CodeSource codesource) {
return new PermissionsBuilder().addAll(allowAll.get().get()
? allPermissions : permissions).toPermissions();
}
@Override
public PermissionCollection getPermissions(ProtectionDomain domain) {
return new PermissionsBuilder().addAll(allowAll.get().get()
? allPermissions : permissions).toPermissions();
}
}
}

685
jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/SimpleUpdateConfigWithInputStreamTest.java Normal file
View File

@ -0,0 +1,685 @@
/*
* 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.
*
* 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.
*/
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.CodeSource;
import java.security.Permission;
import java.security.PermissionCollection;
import java.security.Permissions;
import java.security.Policy;
import java.security.ProtectionDomain;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Objects;
import java.util.Properties;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import java.util.logging.LoggingPermission;
/**
* @test
* @bug 8033661
* @summary tests LogManager.updateConfiguration(InputStream, Function) method
* @run main/othervm SimpleUpdateConfigWithInputStreamTest UNSECURE
* @run main/othervm SimpleUpdateConfigWithInputStreamTest SECURE
* @author danielfuchs
*/
public class SimpleUpdateConfigWithInputStreamTest {
/**
* We will test updateConfiguration in
* two configurations:
* UNSECURE: No security manager.
* SECURE: With the security manager present - and the required
* permissions granted.
*/
public static enum TestCase {
UNSECURE, SECURE;
public void execute(Runnable run) {
System.out.println("Running test case: " + name());
try {
Configure.setUp(this);
Configure.doPrivileged(run, SimplePolicy.allowControl);
} finally {
Configure.doPrivileged(() -> {
try {
setSystemProperty("java.util.logging.config.file", null);
LogManager.getLogManager().readConfiguration();
System.gc();
} catch (Exception x) {
throw new RuntimeException(x);
}
}, SimplePolicy.allowAll);
}
}
}
public static class MyHandler extends Handler {
static final AtomicLong seq = new AtomicLong();
long count = seq.incrementAndGet();
@Override
public void publish(LogRecord record) {
}
@Override
public void flush() {
}
@Override
public void close() throws SecurityException {
}
@Override
public String toString() {
return super.toString() + "("+count+")";
}
}
static String storePropertyToFile(String name, Properties props)
throws Exception {
return Configure.callPrivileged(() -> {
String scratch = System.getProperty("user.dir", ".");
Path p = Paths.get(scratch, name);
try (FileOutputStream fos = new FileOutputStream(p.toFile())) {
props.store(fos, name);
}
return p.toString();
}, SimplePolicy.allowAll);
}
static void setSystemProperty(String name, String value)
throws Exception {
Configure.doPrivileged(() -> {
if (value == null)
System.clearProperty(name);
else
System.setProperty(name, value);
}, SimplePolicy.allowAll);
}
static String trim(String value) {
return value == null ? null : value.trim();
}
/**
* Tests one of the configuration defined above.
* <p>
* This is the main test method (the rest is infrastructure).
*/
static void testUpdateConfiguration() {
try {
// manager initialized with default configuration.
LogManager manager = LogManager.getLogManager();
// Test default configuration. It should not have
// any value for "com.foo.level" and "com.foo.handlers"
assertEquals(null, manager.getProperty("com.foo.level"),
"com.foo.level in default configuration");
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in default configuration");
// Create a logging configuration file that contains
// com.foo.level=FINEST
// and set "java.util.logging.config.file" to this file.
Properties props = new Properties();
props.setProperty("com.foo.level", "FINEST");
// Update configuration with props
// then test that the new configuration has
// com.foo.level=FINEST
// and nothing for com.foo.handlers
Configure.updateConfigurationWith(props, null);
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level in " + props);
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in " + props);
// call updateConfiguration with an empty stream.
// check that the new configuration no longer has
// any value for com.foo.level, and still no value
// for com.foo.handlers
Configure.updateConfigurationWith(new Properties(), null);
assertEquals(null, manager.getProperty("com.foo.level"),
"com.foo.level in default configuration");
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in default configuration");
// creates the com.foo logger, check it has
// the default config: no level, and no handlers
final Logger logger = Logger.getLogger("com.foo");
assertEquals(null, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertDeepEquals(new Handler[0], logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
// call updateConfiguration with 'props'
// check that the configuration has
// com.foo.level=FINEST
// and nothing for com.foo.handlers
// check that the logger has now a FINEST level and still
// no handlers
Configure.updateConfigurationWith(props, null);
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level in " + props);
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertDeepEquals(new Handler[0], logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in " + props);
// Calls updateConfiguration with a lambda whose effect should
// be to set the FINER level on the "com.foo" logger.
// Check that the new configuration has
// com.foo.level=FINER
// and nothing for com.foo.handlers
// check that the logger has now a FINER level and still
// no handlers
Configure.updateConfigurationWith(props,
(k) -> ("com.foo.level".equals(k) ? (o, n) -> "FINER" : (o, n) -> n));
assertEquals("FINER", manager.getProperty("com.foo.level"),
"com.foo.level set to FINER by updateConfiguration");
assertEquals(Level.FINER, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertDeepEquals(new Handler[0], logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in " + props);
// Calls updateConfiguration with a lambda whose effect is a noop.
// This should not change the configuration, so
// check that the new configuration still has
// com.foo.level=FINER
// and nothing for com.foo.handlers
// check that the logger still has FINER level and still
// no handlers
Configure.updateConfigurationWith(props,
(k) -> ((o, n) -> o));
assertEquals("FINER", manager.getProperty("com.foo.level"),
"com.foo.level preserved by updateConfiguration");
assertEquals(Level.FINER, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertDeepEquals(new Handler[0], logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in " + props);
// Calls updateConfiguration with a lambda whose effect is to
// take all values from the new configuration.
// This should update the configuration to what is in props, so
// check that the new configuration has
// com.foo.level=FINEST
// and nothing for com.foo.handlers
// check that the logger now has FINEST level and still
// no handlers
Configure.updateConfigurationWith(props,
(k) -> ((o, n) -> n));
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level updated by updateConfiguration");
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertDeepEquals(new Handler[0], logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in " + props);
// now set a handler on the com.foo logger.
MyHandler h = new MyHandler();
logger.addHandler(h);
assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
// Calls updateConfiguration with a lambda whose effect should
// be to set the FINER level on the "com.foo" logger, and
// take the value from props for everything else.
// Check that the new configuration has
// com.foo.level=FINER
// and nothing for com.foo.handlers
// check that the logger has now a FINER level, but that its
// handlers are still present and have not been reset
// since neither the old nor new configuration defined them.
Configure.updateConfigurationWith(props,
(k) -> ("com.foo.level".equals(k) ? (o, n) -> "FINER" : (o, n) -> n));
assertEquals("FINER", manager.getProperty("com.foo.level"),
"com.foo.level set to FINER by updateConfiguration");
assertEquals(Level.FINER, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in " + props);
// now add some configuration for com.foo.handlers
props.setProperty("com.foo.handlers", MyHandler.class.getName());
// we didn't call updateConfiguration, so just changing the
// content of props should have had no effect.
assertEquals("FINER", manager.getProperty("com.foo.level"),
"com.foo.level set to FINER by updateConfiguration");
assertEquals(Level.FINER, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(null,
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
// Calls updateConfiguration with a lambda whose effect is a noop.
// This should not change the current configuration, so
// check that the new configuration still has
// com.foo.level=FINER
// and nothing for com.foo.handlers
// check that the logger still has FINER level and still
// has its handlers and that they haven't been reset.
Configure.updateConfigurationWith(props, (k) -> ((o, n) -> o));
assertEquals("FINER", manager.getProperty("com.foo.level"),
"com.foo.level set to FINER by updateConfiguration");
assertEquals(Level.FINER, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(null,
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
// Calls updateConfiguration with a lambda whose effect is to
// take all values from the new configuration.
// This should update the configuration to what is in props, so
// check that the new configuration has
// com.foo.level=FINEST
// com.foo.handlers=SimpleUpdateConfigWithInputStreamTest$MyHandler
// check that the logger now has FINEST level
// and a new handler instance, since the old config
// had no handlers for com.foo and the new config has one.
Configure.updateConfigurationWith(props, (k) -> ((o, n) -> n));
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level updated by updateConfiguration");
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(MyHandler.class.getName(),
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
Handler[] loggerHandlers = logger.getHandlers().clone();
assertEquals(1, loggerHandlers.length,
"Logger.getLogger(\"com.foo\").getHandlers().length");
assertEquals(MyHandler.class, loggerHandlers[0].getClass(),
"Logger.getLogger(\"com.foo\").getHandlers()[0].getClass()");
assertEquals(h.count + 1, ((MyHandler)logger.getHandlers()[0]).count,
"Logger.getLogger(\"com.foo\").getHandlers()[0].count");
// Calls updateConfiguration with a lambda whose effect is a noop.
// This should not change the current configuration, so
// check that the new configuration still has
// com.foo.level=FINEST
// com.foo.handlers=SimpleUpdateConfigWithInputStreamTest$MyHandler
// check that the logger still has FINEST level and still
// has its handlers and that they haven't been reset.
Configure.updateConfigurationWith(props, (k) -> ((o, n) -> o));
assertDeepEquals(loggerHandlers, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level updated by updateConfiguration");
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(MyHandler.class.getName(),
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
// Calls updateConfiguration with a lambda whose effect is to
// take all values from the new configuration.
// Because the content of the props hasn't changed, then
// it should also be a noop.
// check that the new configuration still has
// com.foo.level=FINEST
// com.foo.handlers=SimpleUpdateConfigWithInputStreamTest$MyHandler
// check that the logger still has FINEST level and still
// has its handlers and that they haven't been reset.
Configure.updateConfigurationWith(props, (k) -> ((o, n) -> n));
assertDeepEquals(loggerHandlers, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level updated by updateConfiguration");
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(MyHandler.class.getName(),
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
// Calls updateConfiguration with a null lambda, whose effect is to
// take all values from the new configuration.
// Because the content of the props hasn't changed, then
// it should also be a noop.
// check that the new configuration still has
// com.foo.level=FINEST
// com.foo.handlers=SimpleUpdateConfigWithInputStreamTest$MyHandler
// check that the logger still has FINEST level and still
// has its handlers and that they haven't been reset.
Configure.updateConfigurationWith(props, (k) -> ((o, n) -> n));
assertDeepEquals(loggerHandlers, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level updated by updateConfiguration");
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(MyHandler.class.getName(),
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
// now remove com.foo.handlers=SimpleUpdateConfigWithInputStreamTest$MyHandler
// from the configuration file.
props.remove("com.foo.handlers");
// Calls updateConfiguration with a lambda whose effect is a noop.
// This should not change the current configuration, so
// check that the new configuration still has
// com.foo.level=FINEST
// com.foo.handlers=SimpleUpdateConfigWithInputStreamTest$MyHandler
// check that the logger still has FINEST level and still
// has its handlers and that they haven't been reset.
Configure.updateConfigurationWith(props, (k) -> ((o, n) -> o));
assertDeepEquals(loggerHandlers, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level updated by updateConfiguration");
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(MyHandler.class.getName(),
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
// Calls updateConfiguration with a lambda whose effect is to
// take all values from the new configuration.
// This should update the configuration to what is in props, so
// check that the new configuration has
// com.foo.level=FINEST
// and nothing for com.foo.handlers
// check that the logger still has FINEST level
// and no handlers, since the old config
// had an handler for com.foo and the new config doesn't.
Configure.updateConfigurationWith(props, (k) -> ((o, n) -> n));
assertDeepEquals(new Handler[0], logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level updated by updateConfiguration");
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(null,
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
} catch (RuntimeException | Error r) {
throw r;
} catch (Exception x) {
throw new RuntimeException(x);
}
}
public static void main(String[] args) throws Exception {
if (args == null || args.length == 0) {
args = new String[] { "UNSECURE", "SECURE" };
}
for (String test : args) {
TestCase.valueOf(test).execute(SimpleUpdateConfigWithInputStreamTest::testUpdateConfiguration);
}
}
static class Configure {
static Policy policy = null;
static void setUp(TestCase test) {
switch (test) {
case SECURE:
if (policy == null && System.getSecurityManager() != null) {
throw new IllegalStateException("SecurityManager already set");
} else if (policy == null) {
policy = new SimplePolicy(TestCase.SECURE);
Policy.setPolicy(policy);
System.setSecurityManager(new SecurityManager());
}
if (System.getSecurityManager() == null) {
throw new IllegalStateException("No SecurityManager.");
}
if (policy == null) {
throw new IllegalStateException("policy not configured");
}
break;
case UNSECURE:
if (System.getSecurityManager() != null) {
throw new IllegalStateException("SecurityManager already set");
}
break;
default:
throw new InternalError("No such testcase: " + test);
}
}
static void updateConfigurationWith(Properties propertyFile,
Function<String,BiFunction<String,String,String>> remapper) {
try {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
propertyFile.store(bytes, propertyFile.getProperty("test.name"));
ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());
LogManager.getLogManager().updateConfiguration(bais, remapper);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
static void doPrivileged(Runnable run, ThreadLocal<AtomicBoolean> granter) {
final boolean old = granter.get().getAndSet(true);
try {
run.run();
} finally {
granter.get().set(old);
}
}
static <T> T callPrivileged(Callable<T> call,
ThreadLocal<AtomicBoolean> granter) throws Exception {
final boolean old = granter.get().getAndSet(true);
try {
return call.call();
} finally {
granter.get().set(old);
}
}
}
static final class TestAssertException extends RuntimeException {
TestAssertException(String msg) {
super(msg);
}
}
private static void assertEquals(long expected, long received, String msg) {
if (expected != received) {
throw new TestAssertException("Unexpected result for " + msg
+ ".\n\texpected: " + expected
+ "\n\tactual: " + received);
} else {
System.out.println("Got expected " + msg + ": " + received);
}
}
private static void assertEquals(String expected, String received, String msg) {
if (!Objects.equals(expected, received)) {
throw new TestAssertException("Unexpected result for " + msg
+ ".\n\texpected: " + expected
+ "\n\tactual: " + received);
} else {
System.out.println("Got expected " + msg + ": " + received);
}
}
private static void assertEquals(Object expected, Object received, String msg) {
if (!Objects.equals(expected, received)) {
throw new TestAssertException("Unexpected result for " + msg
+ ".\n\texpected: " + expected
+ "\n\tactual: " + received);
} else {
System.out.println("Got expected " + msg + ": " + received);
}
}
public static String deepToString(Object o) {
if (o == null) {
return "null";
} else if (o.getClass().isArray()) {
String s;
if (o instanceof Object[])
s = Arrays.deepToString((Object[]) o);
else if (o instanceof byte[])
s = Arrays.toString((byte[]) o);
else if (o instanceof short[])
s = Arrays.toString((short[]) o);
else if (o instanceof int[])
s = Arrays.toString((int[]) o);
else if (o instanceof long[])
s = Arrays.toString((long[]) o);
else if (o instanceof char[])
s = Arrays.toString((char[]) o);
else if (o instanceof float[])
s = Arrays.toString((float[]) o);
else if (o instanceof double[])
s = Arrays.toString((double[]) o);
else if (o instanceof boolean[])
s = Arrays.toString((boolean[]) o);
else
s = o.toString();
return s;
} else {
return o.toString();
}
}
private static void assertDeepEquals(Object expected, Object received, String msg) {
if (!Objects.deepEquals(expected, received)) {
throw new TestAssertException("Unexpected result for " + msg
+ ".\n\texpected: " + deepToString(expected)
+ "\n\tactual: " + deepToString(received));
} else {
System.out.println("Got expected " + msg + ": " + deepToString(received));
}
}
final static class PermissionsBuilder {
final Permissions perms;
public PermissionsBuilder() {
this(new Permissions());
}
public PermissionsBuilder(Permissions perms) {
this.perms = perms;
}
public PermissionsBuilder add(Permission p) {
perms.add(p);
return this;
}
public PermissionsBuilder addAll(PermissionCollection col) {
if (col != null) {
for (Enumeration<Permission> e = col.elements(); e.hasMoreElements(); ) {
perms.add(e.nextElement());
}
}
return this;
}
public Permissions toPermissions() {
final PermissionsBuilder builder = new PermissionsBuilder();
builder.addAll(perms);
return builder.perms;
}
}
public static class SimplePolicy extends Policy {
final Permissions basic;
final Permissions control;
final Permissions all;
public final static ThreadLocal<AtomicBoolean> allowAll =
new ThreadLocal<AtomicBoolean>() {
@Override
protected AtomicBoolean initialValue() {
return new AtomicBoolean();
}
};
public final static ThreadLocal<AtomicBoolean> allowControl =
new ThreadLocal<AtomicBoolean>() {
@Override
protected AtomicBoolean initialValue() {
return new AtomicBoolean();
}
};
public SimplePolicy(TestCase test) {
basic = new Permissions();
control = new Permissions();
control.add(new LoggingPermission("control", null));
// these are used for configuring the test itself...
all = new Permissions();
all.add(new java.security.AllPermission());
}
@Override
public boolean implies(ProtectionDomain domain, Permission permission) {
return getPermissions(domain).implies(permission);
}
public PermissionCollection permissions() {
PermissionsBuilder builder = new PermissionsBuilder();
if (allowAll.get().get()) {
builder.addAll(all);
} else {
builder.addAll(basic);
if (allowControl.get().get()) {
builder.addAll(control);
}
}
return builder.toPermissions();
}
@Override
public PermissionCollection getPermissions(CodeSource codesource) {
return permissions();
}
@Override
public PermissionCollection getPermissions(ProtectionDomain domain) {
return permissions();
}
}
}

720
jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/SimpleUpdateConfigurationTest.java Normal file
View File

@ -0,0 +1,720 @@
/*
* 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.
*
* 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.
*/
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.FilePermission;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.CodeSource;
import java.security.Permission;
import java.security.PermissionCollection;
import java.security.Permissions;
import java.security.Policy;
import java.security.ProtectionDomain;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Objects;
import java.util.Properties;
import java.util.PropertyPermission;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import java.util.logging.LoggingPermission;
/**
* @test
* @bug 8033661
* @summary tests LogManager.updateConfiguration(Function) method
* @run main/othervm SimpleUpdateConfigurationTest UNSECURE
* @run main/othervm SimpleUpdateConfigurationTest SECURE
* @author danielfuchs
*/
public class SimpleUpdateConfigurationTest {
/**
* We will test updateConfiguration in
* two configurations:
* UNSECURE: No security manager.
* SECURE: With the security manager present - and the required
* permissions granted.
*/
public static enum TestCase {
UNSECURE, SECURE;
public void execute(Runnable run) {
System.out.println("Running test case: " + name());
try {
Configure.setUp(this);
Configure.doPrivileged(run, SimplePolicy.allowControl);
} finally {
Configure.doPrivileged(() -> {
try {
setSystemProperty("java.util.logging.config.file", null);
LogManager.getLogManager().readConfiguration();
System.gc();
} catch (Exception x) {
throw new RuntimeException(x);
}
}, SimplePolicy.allowAll);
}
}
}
public static class MyHandler extends Handler {
static final AtomicLong seq = new AtomicLong();
long count = seq.incrementAndGet();
@Override
public void publish(LogRecord record) {
}
@Override
public void flush() {
}
@Override
public void close() throws SecurityException {
}
@Override
public String toString() {
return super.toString() + "("+count+")";
}
}
static String storePropertyToFile(String name, Properties props)
throws Exception {
return Configure.callPrivileged(() -> {
String scratch = System.getProperty("user.dir", ".");
Path p = Paths.get(scratch, name);
try (FileOutputStream fos = new FileOutputStream(p.toFile())) {
props.store(fos, name);
}
return p.toString();
}, SimplePolicy.allowAll);
}
static void setSystemProperty(String name, String value)
throws Exception {
Configure.doPrivileged(() -> {
if (value == null)
System.clearProperty(name);
else
System.setProperty(name, value);
}, SimplePolicy.allowAll);
}
static String trim(String value) {
return value == null ? null : value.trim();
}
/**
* Tests one of the configuration defined above.
* <p>
* This is the main test method (the rest is infrastructure).
*/
static void testUpdateConfiguration() {
String configFile = null;
try {
// manager initialized with default configuration.
LogManager manager = LogManager.getLogManager();
// Test default configuration. It should not have
// any value for "com.foo.level" and "com.foo.handlers"
assertEquals(null, manager.getProperty("com.foo.level"),
"com.foo.level in default configuration");
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in default configuration");
// Create a logging configuration file that contains
// com.foo.level=FINEST
// and set "java.util.logging.config.file" to this file.
Properties props = new Properties();
props.setProperty("com.foo.level", "FINEST");
configFile = storePropertyToFile("config1", props);
setSystemProperty("java.util.logging.config.file", configFile);
// Update configuration with configFile
// then test that the new configuration has
// com.foo.level=FINEST
// and nothing for com.foo.handlers
manager.updateConfiguration(null);
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level in " + configFile);
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in " + configFile);
// clear ("java.util.logging.config.file" system property,
// and call updateConfiguration again.
// check that the new configuration no longer has
// any value for com.foo.level, and still no value
// for com.foo.handlers
setSystemProperty("java.util.logging.config.file", null);
manager.updateConfiguration(null);
assertEquals(null, manager.getProperty("com.foo.level"),
"com.foo.level in default configuration");
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in default configuration");
// creates the com.foo logger, check it has
// the default config: no level, and no handlers
final Logger logger = Logger.getLogger("com.foo");
assertEquals(null, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertDeepEquals(new Handler[0], logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
// set "java.util.logging.config.file" to configFile and
// call updateConfiguration.
// check that the configuration has
// com.foo.level=FINEST
// and nothing for com.foo.handlers
// check that the logger has now a FINEST level and still
// no handlers
setSystemProperty("java.util.logging.config.file", configFile);
manager.updateConfiguration(null);
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level in " + configFile);
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertDeepEquals(new Handler[0], logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in " + configFile);
// Calls updateConfiguration with a lambda whose effect should
// be to set the FINER level on the "com.foo" logger.
// Check that the new configuration has
// com.foo.level=FINER
// and nothing for com.foo.handlers
// check that the logger has now a FINER level and still
// no handlers
manager.updateConfiguration(
(k) -> ("com.foo.level".equals(k) ? (o, n) -> "FINER" : (o, n) -> n));
assertEquals("FINER", manager.getProperty("com.foo.level"),
"com.foo.level set to FINER by updateConfiguration");
assertEquals(Level.FINER, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertDeepEquals(new Handler[0], logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in " + configFile);
// Calls updateConfiguration with a lambda whose effect is a noop.
// This should not change the configuration, so
// check that the new configuration still has
// com.foo.level=FINER
// and nothing for com.foo.handlers
// check that the logger still has FINER level and still
// no handlers
manager.updateConfiguration(
(k) -> ((o, n) -> o));
assertEquals("FINER", manager.getProperty("com.foo.level"),
"com.foo.level preserved by updateConfiguration");
assertEquals(Level.FINER, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertDeepEquals(new Handler[0], logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in " + configFile);
// Calls updateConfiguration with a lambda whose effect is to
// take all values from the new configuration.
// This should update the configuration to what is in configFile, so
// check that the new configuration has
// com.foo.level=FINEST
// and nothing for com.foo.handlers
// check that the logger now has FINEST level and still
// no handlers
manager.updateConfiguration(
(k) -> ((o, n) -> n));
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level updated by updateConfiguration");
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertDeepEquals(new Handler[0], logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in " + configFile);
// now set a handler on the com.foo logger.
MyHandler h = new MyHandler();
logger.addHandler(h);
assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
// Calls updateConfiguration with a lambda whose effect should
// be to set the FINER level on the "com.foo" logger, and
// take the value from configFile for everything else.
// Check that the new configuration has
// com.foo.level=FINER
// and nothing for com.foo.handlers
// check that the logger has now a FINER level, but that its
// handlers are still present and have not been reset
// since neither the old nor new configuration defined them.
manager.updateConfiguration(
(k) -> ("com.foo.level".equals(k) ? (o, n) -> "FINER" : (o, n) -> n));
assertEquals("FINER", manager.getProperty("com.foo.level"),
"com.foo.level set to FINER by updateConfiguration");
assertEquals(Level.FINER, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals(null, manager.getProperty("com.foo.handlers"),
"com.foo.handlers in " + configFile);
// now add some configuration for com.foo.handlers in the
// configuration file.
props.setProperty("com.foo.handlers", MyHandler.class.getName());
storePropertyToFile("config1", props);
// we didn't call updateConfiguration, so just changing the
// content of the file should have had no no effect yet.
assertEquals("FINER", manager.getProperty("com.foo.level"),
"com.foo.level set to FINER by updateConfiguration");
assertEquals(Level.FINER, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(null,
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
// Calls updateConfiguration with a lambda whose effect is a noop.
// This should not change the current configuration, so
// check that the new configuration still has
// com.foo.level=FINER
// and nothing for com.foo.handlers
// check that the logger still has FINER level and still
// has its handlers and that they haven't been reset.
manager.updateConfiguration((k) -> ((o, n) -> o));
assertEquals("FINER", manager.getProperty("com.foo.level"),
"com.foo.level set to FINER by updateConfiguration");
assertEquals(Level.FINER, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(null,
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
assertDeepEquals(new Handler[] {h}, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
// Calls updateConfiguration with a lambda whose effect is to
// take all values from the new configuration.
// This should update the configuration to what is in configFile, so
// check that the new configuration has
// com.foo.level=FINEST
// com.foo.handlers=SimpleUpdateConfigurationTest$MyHandler
// check that the logger now has FINEST level
// and a new handler instance, since the old config
// had no handlers for com.foo and the new config has one.
manager.updateConfiguration((k) -> ((o, n) -> n));
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level updated by updateConfiguration");
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(MyHandler.class.getName(),
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
Handler[] loggerHandlers = logger.getHandlers().clone();
assertEquals(1, loggerHandlers.length,
"Logger.getLogger(\"com.foo\").getHandlers().length");
assertEquals(MyHandler.class, loggerHandlers[0].getClass(),
"Logger.getLogger(\"com.foo\").getHandlers()[0].getClass()");
assertEquals(h.count + 1, ((MyHandler)logger.getHandlers()[0]).count,
"Logger.getLogger(\"com.foo\").getHandlers()[0].count");
// Calls updateConfiguration with a lambda whose effect is a noop.
// This should not change the current configuration, so
// check that the new configuration still has
// com.foo.level=FINEST
// com.foo.handlers=SimpleUpdateConfigurationTest$MyHandler
// check that the logger still has FINEST level and still
// has its handlers and that they haven't been reset.
manager.updateConfiguration((k) -> ((o, n) -> o));
assertDeepEquals(loggerHandlers, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level updated by updateConfiguration");
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(MyHandler.class.getName(),
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
// Calls updateConfiguration with a lambda whose effect is to
// take all values from the new configuration.
// Because the content of the configFile hasn't changed, then
// it should also be a noop.
// check that the new configuration still has
// com.foo.level=FINEST
// com.foo.handlers=SimpleUpdateConfigurationTest$MyHandler
// check that the logger still has FINEST level and still
// has its handlers and that they haven't been reset.
manager.updateConfiguration((k) -> ((o, n) -> n));
assertDeepEquals(loggerHandlers, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level updated by updateConfiguration");
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(MyHandler.class.getName(),
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
// Calls updateConfiguration with a null lambda, whose effect is to
// take all values from the new configuration.
// Because the content of the configFile hasn't changed, then
// it should also be a noop.
// check that the new configuration still has
// com.foo.level=FINEST
// com.foo.handlers=SimpleUpdateConfigurationTest$MyHandler
// check that the logger still has FINEST level and still
// has its handlers and that they haven't been reset.
manager.updateConfiguration((k) -> ((o, n) -> n));
assertDeepEquals(loggerHandlers, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level updated by updateConfiguration");
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(MyHandler.class.getName(),
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
// no remove com.foo.handlers=SimpleUpdateConfigurationTest$MyHandler
// from the configuration file.
props.remove("com.foo.handlers");
storePropertyToFile("config1", props);
// Calls updateConfiguration with a lambda whose effect is a noop.
// This should not change the current configuration, so
// check that the new configuration still has
// com.foo.level=FINEST
// com.foo.handlers=SimpleUpdateConfigurationTest$MyHandler
// check that the logger still has FINEST level and still
// has its handlers and that they haven't been reset.
manager.updateConfiguration((k) -> ((o, n) -> o));
assertDeepEquals(loggerHandlers, logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level updated by updateConfiguration");
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(MyHandler.class.getName(),
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
// Calls updateConfiguration with a lambda whose effect is to
// take all values from the new configuration.
// This should update the configuration to what is in configFile, so
// check that the new configuration has
// com.foo.level=FINEST
// and nothing for com.foo.handlers
// check that the logger still has FINEST level
// and no handlers, since the old config
// had an handler for com.foo and the new config doesn't.
manager.updateConfiguration((k) -> ((o, n) -> n));
assertDeepEquals(new Handler[0], logger.getHandlers(),
"Logger.getLogger(\"com.foo\").getHandlers()");
assertEquals("FINEST", manager.getProperty("com.foo.level"),
"com.foo.level updated by updateConfiguration");
assertEquals(Level.FINEST, logger.getLevel(),
"Logger.getLogger(\"com.foo\").getLevel()");
assertEquals(null,
manager.getProperty("com.foo.handlers"),
"manager.getProperty(\"com.foo.handlers\")");
} catch (RuntimeException | Error r) {
throw r;
} catch (Exception x) {
throw new RuntimeException(x);
} finally {
if (configFile != null) {
// cleanup
final String file = configFile;
Configure.doPrivileged(() -> {
try {
Files.delete(Paths.get(file));
} catch (RuntimeException | Error r) {
throw r;
} catch (Exception x) {
throw new RuntimeException(x);
}
}, SimplePolicy.allowAll);
}
}
}
public static void main(String[] args) throws Exception {
if (args == null || args.length == 0) {
args = new String[] { "UNSECURE", "SECURE" };
}
for (String test : args) {
TestCase.valueOf(test).execute(SimpleUpdateConfigurationTest::testUpdateConfiguration);
}
}
static class Configure {
static Policy policy = null;
static void setUp(TestCase test) {
switch (test) {
case SECURE:
if (policy == null && System.getSecurityManager() != null) {
throw new IllegalStateException("SecurityManager already set");
} else if (policy == null) {
policy = new SimplePolicy(TestCase.SECURE);
Policy.setPolicy(policy);
System.setSecurityManager(new SecurityManager());
}
if (System.getSecurityManager() == null) {
throw new IllegalStateException("No SecurityManager.");
}
if (policy == null) {
throw new IllegalStateException("policy not configured");
}
break;
case UNSECURE:
if (System.getSecurityManager() != null) {
throw new IllegalStateException("SecurityManager already set");
}
break;
default:
throw new InternalError("No such testcase: " + test);
}
}
static void updateConfigurationWith(Properties propertyFile,
Function<String,BiFunction<String,String,String>> remapper) {
try {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
propertyFile.store(bytes, propertyFile.getProperty("test.name"));
ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());
LogManager.getLogManager().updateConfiguration(bais, remapper);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
static void doPrivileged(Runnable run, ThreadLocal<AtomicBoolean> granter) {
final boolean old = granter.get().getAndSet(true);
try {
run.run();
} finally {
granter.get().set(old);
}
}
static <T> T callPrivileged(Callable<T> call,
ThreadLocal<AtomicBoolean> granter) throws Exception {
final boolean old = granter.get().getAndSet(true);
try {
return call.call();
} finally {
granter.get().set(old);
}
}
}
static final class TestAssertException extends RuntimeException {
TestAssertException(String msg) {
super(msg);
}
}
private static void assertEquals(long expected, long received, String msg) {
if (expected != received) {
throw new TestAssertException("Unexpected result for " + msg
+ ".\n\texpected: " + expected
+ "\n\tactual: " + received);
} else {
System.out.println("Got expected " + msg + ": " + received);
}
}
private static void assertEquals(String expected, String received, String msg) {
if (!Objects.equals(expected, received)) {
throw new TestAssertException("Unexpected result for " + msg
+ ".\n\texpected: " + expected
+ "\n\tactual: " + received);
} else {
System.out.println("Got expected " + msg + ": " + received);
}
}
private static void assertEquals(Object expected, Object received, String msg) {
if (!Objects.equals(expected, received)) {
throw new TestAssertException("Unexpected result for " + msg
+ ".\n\texpected: " + expected
+ "\n\tactual: " + received);
} else {
System.out.println("Got expected " + msg + ": " + received);
}
}
public static String deepToString(Object o) {
if (o == null) {
return "null";
} else if (o.getClass().isArray()) {
String s;
if (o instanceof Object[])
s = Arrays.deepToString((Object[]) o);
else if (o instanceof byte[])
s = Arrays.toString((byte[]) o);
else if (o instanceof short[])
s = Arrays.toString((short[]) o);
else if (o instanceof int[])
s = Arrays.toString((int[]) o);
else if (o instanceof long[])
s = Arrays.toString((long[]) o);
else if (o instanceof char[])
s = Arrays.toString((char[]) o);
else if (o instanceof float[])
s = Arrays.toString((float[]) o);
else if (o instanceof double[])
s = Arrays.toString((double[]) o);
else if (o instanceof boolean[])
s = Arrays.toString((boolean[]) o);
else
s = o.toString();
return s;
} else {
return o.toString();
}
}
private static void assertDeepEquals(Object expected, Object received, String msg) {
if (!Objects.deepEquals(expected, received)) {
throw new TestAssertException("Unexpected result for " + msg
+ ".\n\texpected: " + deepToString(expected)
+ "\n\tactual: " + deepToString(received));
} else {
System.out.println("Got expected " + msg + ": " + deepToString(received));
}
}
final static class PermissionsBuilder {
final Permissions perms;
public PermissionsBuilder() {
this(new Permissions());
}
public PermissionsBuilder(Permissions perms) {
this.perms = perms;
}
public PermissionsBuilder add(Permission p) {
perms.add(p);
return this;
}
public PermissionsBuilder addAll(PermissionCollection col) {
if (col != null) {
for (Enumeration<Permission> e = col.elements(); e.hasMoreElements(); ) {
perms.add(e.nextElement());
}
}
return this;
}
public Permissions toPermissions() {
final PermissionsBuilder builder = new PermissionsBuilder();
builder.addAll(perms);
return builder.perms;
}
}
public static class SimplePolicy extends Policy {
final Permissions basic;
final Permissions control;
final Permissions all;
public final static ThreadLocal<AtomicBoolean> allowAll =
new ThreadLocal<AtomicBoolean>() {
@Override
protected AtomicBoolean initialValue() {
return new AtomicBoolean();
}
};
public final static ThreadLocal<AtomicBoolean> allowControl =
new ThreadLocal<AtomicBoolean>() {
@Override
protected AtomicBoolean initialValue() {
return new AtomicBoolean();
}
};
public SimplePolicy(TestCase test) {
basic = new Permissions();
control = new Permissions();
control.add(new LoggingPermission("control", null));
// These permissions are required to call updateConfiguration(Function)
control.add(new PropertyPermission("java.util.logging.config.file", "read"));
control.add(new PropertyPermission("java.home", "read"));
control.add(new FilePermission(
Paths.get(System.getProperty("user.dir", "."),"-").toString(), "read"));
control.add(new FilePermission(
Paths.get(System.getProperty("java.home"),"conf","-").toString(), "read"));
// these are used for configuring the test itself...
all = new Permissions();
all.add(new java.security.AllPermission());
}
@Override
public boolean implies(ProtectionDomain domain, Permission permission) {
return getPermissions(domain).implies(permission);
}
public PermissionCollection permissions() {
PermissionsBuilder builder = new PermissionsBuilder();
if (allowAll.get().get()) {
builder.addAll(all);
} else {
builder.addAll(basic);
if (allowControl.get().get()) {
builder.addAll(control);
}
}
return builder.toPermissions();
}
@Override
public PermissionCollection getPermissions(CodeSource codesource) {
return permissions();
}
@Override
public PermissionCollection getPermissions(ProtectionDomain domain) {
return permissions();
}
}
}

608
jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/UpdateConfigurationTest.java Normal file
View File

@ -0,0 +1,608 @@
/*
* 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.
*
* 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.
*/
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FilePermission;
import java.io.IOException;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.CodeSource;
import java.security.Permission;
import java.security.PermissionCollection;
import java.security.Permissions;
import java.security.Policy;
import java.security.ProtectionDomain;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Properties;
import java.util.Set;
import java.util.TreeSet;
import java.util.UUID;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.logging.FileHandler;
import java.util.logging.LogManager;
import java.util.logging.Logger;
import java.util.logging.LoggingPermission;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @test
* @bug 8033661
* @summary tests LogManager.updateConfiguration(bin)
* @run main/othervm UpdateConfigurationTest UNSECURE
* @run main/othervm UpdateConfigurationTest SECURE
* @author danielfuchs
*/
public class UpdateConfigurationTest {
/**
* We will test the handling of abstract logger nodes with file handlers in
* two configurations:
* UNSECURE: No security manager.
* SECURE: With the security manager present - and the required
* permissions granted.
*/
public static enum TestCase {
UNSECURE, SECURE;
public void run(Properties propertyFile, boolean last) throws Exception {
System.out.println("Running test case: " + name());
Configure.setUp(this);
test(this.name() + " " + propertyFile.getProperty("test.name"),
propertyFile, last);
}
}
private static final String PREFIX =
"FileHandler-" + UUID.randomUUID() + ".log";
private static final String userDir = System.getProperty("user.dir", ".");
private static final boolean userDirWritable = Files.isWritable(Paths.get(userDir));
static enum ConfigMode { APPEND, REPLACE, DEFAULT;
boolean append() { return this == APPEND; }
Function<String, BiFunction<String,String,String>> remapper() {
switch(this) {
case APPEND:
return (k) -> ((o,n) -> (n == null ? o : n));
case REPLACE:
return (k) -> ((o,n) -> n);
}
return null;
}
}
private static final List<Properties> properties;
static {
// The test will be run with each of the configurations below.
// The 'child' logger is forgotten after each test
Properties props1 = new Properties();
props1.setProperty("test.name", "props1");
props1.setProperty("test.config.mode", ConfigMode.REPLACE.name());
props1.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
props1.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
props1.setProperty(FileHandler.class.getName() + ".level", "ALL");
props1.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
props1.setProperty("com.foo.handlers", FileHandler.class.getName());
props1.setProperty("com.bar.level", "FINEST");
Properties props2 = new Properties();
props2.setProperty("test.name", "props2");
props2.setProperty("test.config.mode", ConfigMode.DEFAULT.name());
props2.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
props2.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
props2.setProperty(FileHandler.class.getName() + ".level", "ALL");
props2.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
props2.setProperty("com.foo.handlers", FileHandler.class.getName());
props2.setProperty("com.foo.handlers.ensureCloseOnReset", "true");
props2.setProperty("com.level", "FINE");
Properties props3 = new Properties();
props3.setProperty("test.name", "props3");
props3.setProperty("test.config.mode", ConfigMode.APPEND.name());
props3.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);
props3.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));
props3.setProperty(FileHandler.class.getName() + ".level", "ALL");
props3.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");
props3.setProperty("com.foo.handlers", ""); // specify "" to override the value in the previous conf
props3.setProperty("com.foo.handlers.ensureCloseOnReset", "false");
props3.setProperty("com.bar.level", "FINER");
properties = Collections.unmodifiableList(Arrays.asList(
props1, props2, props3, props1));
}
static Properties previous;
static Properties current;
static final Field propsField;
static {
LogManager manager = LogManager.getLogManager();
try {
propsField = LogManager.class.getDeclaredField("props");
propsField.setAccessible(true);
previous = current = (Properties) propsField.get(manager);
} catch (NoSuchFieldException | IllegalAccessException ex) {
throw new ExceptionInInitializerError(ex);
}
}
static Properties getProperties() {
try {
return (Properties) propsField.get(LogManager.getLogManager());
} catch (IllegalAccessException x) {
throw new RuntimeException(x);
}
}
static String trim(String value) {
return value == null ? null : value.trim();
}
/**
* Tests one of the configuration defined above.
* <p>
* This is the main test method (the rest is infrastructure).
* <p>
* Creates a child of the com.foo logger (com.foo.child), resets
* the configuration, and verifies that com.foo has no handler.
* Then reapplies the configuration and verifies that the handler
* for com.foo has been reestablished, depending on whether
* java.util.logging.LogManager.reconfigureHandlers is present and
* true.
* <p>
* Finally releases the logger com.foo.child, so that com.foo can
* be garbage collected, and the next configuration can be
* tested.
*/
static void test(ConfigMode mode, String name, Properties props, boolean last)
throws Exception {
// Then create a child of the com.foo logger.
Logger fooChild = Logger.getLogger("com.foo.child");
fooChild.info("hello world");
Logger barChild = Logger.getLogger("com.bar.child");
barChild.info("hello world");
ReferenceQueue<Logger> queue = new ReferenceQueue();
WeakReference<Logger> fooRef = new WeakReference<>(Logger.getLogger("com.foo"), queue);
if (fooRef.get() != fooChild.getParent()) {
throw new RuntimeException("Unexpected parent logger: "
+ fooChild.getParent() +"\n\texpected: " + fooRef.get());
}
WeakReference<Logger> barRef = new WeakReference<>(Logger.getLogger("com.bar"), queue);
if (barRef.get() != barChild.getParent()) {
throw new RuntimeException("Unexpected parent logger: "
+ barChild.getParent() +"\n\texpected: " + barRef.get());
}
Reference<? extends Logger> ref2;
int max = 3;
barChild = null;
while ((ref2 = queue.poll()) == null) {
System.gc();
Thread.sleep(100);
if (--max == 0) break;
}
Throwable failed = null;
try {
if (ref2 != null) {
String refName = ref2 == fooRef ? "fooRef" : ref2 == barRef ? "barRef" : "unknown";
if (ref2 != barRef) {
throw new RuntimeException("Unexpected logger reference cleared: " + refName);
} else {
System.out.println("Reference " + refName + " cleared as expected");
}
} else if (ref2 == null) {
throw new RuntimeException("Expected 'barRef' to be cleared");
}
// Now lets try to check that ref2 has expected handlers, and
// attempt to configure again.
String p = current.getProperty("com.foo.handlers", "").trim();
assertEquals(p.isEmpty() ? 0 : 1, fooChild.getParent().getHandlers().length,
"["+name+"] fooChild.getParent().getHandlers().length");
Configure.doPrivileged(() -> Configure.updateConfigurationWith(props, mode.remapper()));
String p2 = previous.getProperty("com.foo.handlers", "").trim();
assertEquals(p, p2, "["+name+"] com.foo.handlers");
String n = trim(props.getProperty("com.foo.handlers", null));
boolean hasHandlers = mode.append()
? (n == null ? !p.isEmpty() : !n.isEmpty())
: n != null && !n.isEmpty();
assertEquals( hasHandlers ? 1 : 0,
fooChild.getParent().getHandlers().length,
"["+name+"] fooChild.getParent().getHandlers().length"
+ "[p=\""+p+"\", n=" + (n==null?null:"\""+n+"\"") + "]");
checkProperties(mode, previous, current, props);
} catch (Throwable t) {
failed = t;
} finally {
if (last || failed != null) {
final Throwable suppressed = failed;
Configure.doPrivileged(LogManager.getLogManager()::reset);
Configure.doPrivileged(() -> {
try {
StringBuilder builder = new StringBuilder();
Files.list(Paths.get(userDir))
.filter((f) -> f.toString().contains(PREFIX))
.filter((f) -> f.toString().endsWith(".lck"))
.forEach((f) -> {
builder.append(f.toString()).append('\n');
});
if (!builder.toString().isEmpty()) {
throw new RuntimeException("Lock files not cleaned:\n"
+ builder.toString());
}
} catch(RuntimeException | Error x) {
if (suppressed != null) x.addSuppressed(suppressed);
throw x;
} catch(Exception x) {
if (suppressed != null) x.addSuppressed(suppressed);
throw new RuntimeException(x);
}
});
// Now we need to forget the child, so that loggers are released,
// and so that we can run the test with the next configuration...
fooChild = null;
System.out.println("Setting fooChild to: " + fooChild);
while ((ref2 = queue.poll()) == null) {
System.gc();
Thread.sleep(1000);
}
if (ref2 != fooRef) {
throw new RuntimeException("Unexpected reference: "
+ ref2 +"\n\texpected: " + fooRef);
}
if (ref2.get() != null) {
throw new RuntimeException("Referent not cleared: " + ref2.get());
}
System.out.println("Got fooRef after reset(), fooChild is " + fooChild);
}
}
if (failed != null) {
// should rarely happen...
throw new RuntimeException(failed);
}
}
private static void checkProperties(ConfigMode mode,
Properties previous, Properties current, Properties props) {
Set<String> set = new HashSet<>();
// Check that all property names from 'props' are in current.
set.addAll(props.stringPropertyNames());
set.removeAll(current.keySet());
if (!set.isEmpty()) {
throw new RuntimeException("Missing properties in current: " + set);
}
set.clear();
set.addAll(current.stringPropertyNames());
set.removeAll(previous.keySet());
set.removeAll(props.keySet());
if (!set.isEmpty()) {
throw new RuntimeException("Superfluous properties in current: " + set);
}
set.clear();
Stream<String> allnames =
Stream.concat(
Stream.concat(previous.stringPropertyNames().stream(),
props.stringPropertyNames().stream()),
current.stringPropertyNames().stream())
.collect(Collectors.toCollection(TreeSet::new))
.stream();
if (mode.append()) {
// Check that all previous property names are in current.
set.addAll(previous.stringPropertyNames());
set.removeAll(current.keySet());
if (!set.isEmpty()) {
throw new RuntimeException("Missing properties in current: " + set
+ "\n\tprevious: " + previous
+ "\n\tcurrent: " + current
+ "\n\tprops: " + props);
}
allnames.forEach((k) -> {
String p = previous.getProperty(k, "").trim();
String n = current.getProperty(k, "").trim();
if (props.containsKey(k)) {
assertEquals(props.getProperty(k), n, k);
} else {
assertEquals(p, n, k);
}
});
} else {
// Check that only properties from 'props' are in current.
set.addAll(current.stringPropertyNames());
set.removeAll(props.keySet());
if (!set.isEmpty()) {
throw new RuntimeException("Superfluous properties in current: " + set);
}
allnames.forEach((k) -> {
String p = previous.getProperty(k, "");
String n = current.getProperty(k, "");
if (props.containsKey(k)) {
assertEquals(props.getProperty(k), n, k);
} else {
assertEquals("", n, k);
}
});
}
}
public static void main(String... args) throws Exception {
if (args == null || args.length == 0) {
args = new String[] {
TestCase.UNSECURE.name(),
TestCase.SECURE.name(),
};
}
try {
for (String testName : args) {
TestCase test = TestCase.valueOf(testName);
for (int i=0; i<properties.size();i++) {
Properties propertyFile = properties.get(i);
test.run(propertyFile, i == properties.size() - 1);
}
}
} finally {
if (userDirWritable) {
Configure.doPrivileged(() -> {
// cleanup - delete files that have been created
try {
Files.list(Paths.get(userDir))
.filter((f) -> f.toString().contains(PREFIX))
.forEach((f) -> {
try {
System.out.println("deleting " + f);
Files.delete(f);
} catch(Throwable t) {
System.err.println("Failed to delete " + f + ": " + t);
}
});
} catch(Throwable t) {
System.err.println("Cleanup failed to list files: " + t);
t.printStackTrace();
}
});
}
}
}
static class Configure {
static Policy policy = null;
static final ThreadLocal<AtomicBoolean> allowAll = new ThreadLocal<AtomicBoolean>() {
@Override
protected AtomicBoolean initialValue() {
return new AtomicBoolean(false);
}
};
static void setUp(TestCase test) {
switch (test) {
case SECURE:
if (policy == null && System.getSecurityManager() != null) {
throw new IllegalStateException("SecurityManager already set");
} else if (policy == null) {
policy = new SimplePolicy(TestCase.SECURE, allowAll);
Policy.setPolicy(policy);
System.setSecurityManager(new SecurityManager());
}
if (System.getSecurityManager() == null) {
throw new IllegalStateException("No SecurityManager.");
}
if (policy == null) {
throw new IllegalStateException("policy not configured");
}
break;
case UNSECURE:
if (System.getSecurityManager() != null) {
throw new IllegalStateException("SecurityManager already set");
}
break;
default:
new InternalError("No such testcase: " + test);
}
}
static void updateConfigurationWith(Properties propertyFile,
Function<String,BiFunction<String,String,String>> remapper) {
try {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
propertyFile.store(bytes, propertyFile.getProperty("test.name"));
ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());
LogManager.getLogManager().updateConfiguration(bais, remapper);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
static void doPrivileged(Runnable run) {
final boolean old = allowAll.get().getAndSet(true);
try {
Properties before = getProperties();
try {
run.run();
} finally {
Properties after = getProperties();
if (before != after) {
previous = before;
current = after;
}
}
} finally {
allowAll.get().set(old);
}
}
static <T> T callPrivileged(Callable<T> call) throws Exception {
final boolean old = allowAll.get().getAndSet(true);
try {
Properties before = getProperties();
try {
return call.call();
} finally {
Properties after = getProperties();
if (before != after) {
previous = before;
current = after;
}
}
} finally {
allowAll.get().set(old);
}
}
}
@FunctionalInterface
public static interface FileHandlerSupplier {
public FileHandler test() throws Exception;
}
static final class TestAssertException extends RuntimeException {
TestAssertException(String msg) {
super(msg);
}
}
private static void assertEquals(long expected, long received, String msg) {
if (expected != received) {
throw new TestAssertException("Unexpected result for " + msg
+ ".\n\texpected: " + expected
+ "\n\tactual: " + received);
} else {
System.out.println("Got expected " + msg + ": " + received);
}
}
private static void assertEquals(String expected, String received, String msg) {
if (!Objects.equals(expected, received)) {
throw new TestAssertException("Unexpected result for " + msg
+ ".\n\texpected: " + expected
+ "\n\tactual: " + received);
} else {
System.out.println("Got expected " + msg + ": " + received);
}
}
public static void test(String name, Properties props, boolean last) throws Exception {
ConfigMode configMode = ConfigMode.valueOf(props.getProperty("test.config.mode"));
System.out.println("\nTesting: " + name + " mode=" + configMode);
if (!userDirWritable) {
throw new RuntimeException("Not writable: "+userDir);
}
switch(configMode) {
case REPLACE:
case APPEND:
case DEFAULT:
test(configMode, name, props, last); break;
default:
throw new RuntimeException("Unknwown mode: " + configMode);
}
}
final static class PermissionsBuilder {
final Permissions perms;
public PermissionsBuilder() {
this(new Permissions());
}
public PermissionsBuilder(Permissions perms) {
this.perms = perms;
}
public PermissionsBuilder add(Permission p) {
perms.add(p);
return this;
}
public PermissionsBuilder addAll(PermissionCollection col) {
if (col != null) {
for (Enumeration<Permission> e = col.elements(); e.hasMoreElements(); ) {
perms.add(e.nextElement());
}
}
return this;
}
public Permissions toPermissions() {
final PermissionsBuilder builder = new PermissionsBuilder();
builder.addAll(perms);
return builder.perms;
}
}
public static class SimplePolicy extends Policy {
final Permissions permissions;
final Permissions allPermissions;
final ThreadLocal<AtomicBoolean> allowAll; // actually: this should be in a thread locale
public SimplePolicy(TestCase test, ThreadLocal<AtomicBoolean> allowAll) {
this.allowAll = allowAll;
permissions = new Permissions();
permissions.add(new LoggingPermission("control", null));
permissions.add(new FilePermission(PREFIX+".lck", "read,write,delete"));
permissions.add(new FilePermission(PREFIX, "read,write"));
// these are used for configuring the test itself...
allPermissions = new Permissions();
allPermissions.add(new java.security.AllPermission());
}
@Override
public boolean implies(ProtectionDomain domain, Permission permission) {
if (allowAll.get().get()) return allPermissions.implies(permission);
return permissions.implies(permission);
}
@Override
public PermissionCollection getPermissions(CodeSource codesource) {
return new PermissionsBuilder().addAll(allowAll.get().get()
? allPermissions : permissions).toPermissions();
}
@Override
public PermissionCollection getPermissions(ProtectionDomain domain) {
return new PermissionsBuilder().addAll(allowAll.get().get()
? allPermissions : permissions).toPermissions();
}
}
}