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.
*
- * 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.
- *
- * 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.
+ *
+ * If "java.util.logging.config.class" system property is not 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.
+ *
*
* 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.
+ *
+ * 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 {
*
* 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.
+ *
+ *
* Any {@linkplain #addConfigurationListener registered configuration
* listener} will be invoked after the properties are read.
*
- * 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.
+ *
+ * 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 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 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 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 {
+ final IdentityHashMap visited;
+ private VisitedLoggers(IdentityHashMap 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.
+ *
+ * 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.
+ *
The default configuration is typically loaded from the
+ * properties file "{@code conf/logging.properties}" in the
+ * Java installation directory.
+ *
+ * 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 k and returns a function f(o,n) whose returned
+ * value will be applied to the resulting configuration. The
+ * function f may return {@code null} to indicate that the property
+ * k will not be added to the resulting configuration.
+ *
+ * If {@code mapper} is {@code null} then {@code (k) -> ((o, n) -> n)} is
+ * assumed.
+ *
+ * For each k, the mapped function f will
+ * be invoked with the value associated with k in the old
+ * configuration (i.e o) and the value associated with
+ * k in the new configuration (i.e. n).
+ *
A {@code null} value for o or n indicates that no
+ * value was present for k 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> 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.
+ *
+ * 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,
+ * f(o,n), 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.
+ *
Let k be a configuration key in the old or new configuration,
+ * o be the old value (i.e. the value associated
+ * with k in the old configuration), n be the
+ * new value (i.e. the value associated with k in the new
+ * configuration), and f be the function returned
+ * by {@code mapper.apply(}k{@code )}: then v = f(o,n) is the
+ * resulting value. If v is not {@code null}, then a property
+ * k with value v will be added to the resulting configuration.
+ * Otherwise, it will be omitted.
+ *
A {@code null} value may be passed to function
+ * f to indicate that the corresponding configuration has no
+ * configuration key k.
+ * The function f may return {@code null} to indicate that
+ * there will be no value associated with k in the resulting
+ * configuration.
+ *
+ * If {@code mapper} is {@code null}, then v will be set to
+ * n.
+ *
+ * LogManager {@linkplain #getProperty(java.lang.String) properties} are
+ * updated with the resulting value in the resulting configuration.
+ *
+ * The registered {@linkplain #addConfigurationListener configuration
+ * listeners} will be invoked after the configuration is successfully updated.
+ *
+ *
+ *
+ * | Property |
+ * Resulting Behavior |
+ *
+ *
+ * | {@code .level} |
+ *
+ *
+ * - 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.
+ *
+ * - 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}.
+ *
+ *
+ * |
+ *
+ * | {@code .useParentHandlers} |
+ *
+ *
+ * - 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.
+ *
+ *
+ * |
+ *
+ *
+ * | {@code .handlers} |
+ *
+ *
+ * - 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.
+ *
+ * - 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.
+ *
+ * - 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.
+ *
+ *
+ * |
+ *
+ *
+ * | {@code .*} |
+ *
+ *
+ * - 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.
+ *
+ *
+ * |
+ *
+ *
+ * | {@code config} and any other property |
+ *
+ *
+ * - The resulting value for these property will be stored in the
+ * LogManager properties, but {@code updateConfiguration} will not parse
+ * or process their values.
+ *
+ *
+ * |
+ *
+ *
+ *
+ * Example mapper functions:
+ *
+ *
+ *
+ * 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 k and returns a function f(o,n) whose returned
+ * value will be applied to the resulting configuration. The
+ * function f may return {@code null} to indicate that the property
+ * k will not be added to the resulting configuration.
+ *
+ * If {@code mapper} is {@code null} then {@code (k) -> ((o, n) -> n)} is
+ * assumed.
+ *
+ * For each k, the mapped function f will
+ * be invoked with the value associated with k in the old
+ * configuration (i.e o) and the value associated with
+ * k in the new configuration (i.e. n).
+ *
A {@code null} value for o or n indicates that no
+ * value was present for k 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> mapper)
+ throws IOException {
+ checkPermission();
+ ensureLogManagerInitialized();
+ drainLoggerRefQueueBounded();
+
+ final Properties previous;
+ final Set updatePropertyNames;
+ List 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 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> loggerConfigs =
+ allKeys.collect(Collectors.groupingBy(ConfigProperty::getLoggerName,
+ TreeMap::new,
+ Collectors.toCollection(TreeSet::new)));
+
+ if (!loggerConfigs.isEmpty()) {
+ cxs = contexts();
+ }
+ final List loggers = cxs.isEmpty()
+ ? Collections.emptyList() : new ArrayList<>(cxs.size());
+ for (Map.Entry> 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 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 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 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.
diff --git a/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/HandlersOnComplexResetUpdate.java b/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/HandlersOnComplexResetUpdate.java
new file mode 100644
index 00000000000..f4817d864db
--- /dev/null
+++ b/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/HandlersOnComplexResetUpdate.java
@@ -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) 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;
+ 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.
+ *
+ * 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.
+ *
+ * Finally releases the child logger after all configurations have been
+ * applied.
+ *
+ * @param name
+ * @param properties
+ * @throws Exception
+ */
+ static void test(String name, List 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 queue = new ReferenceQueue();
+ WeakReference 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 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 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 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 allowAll = new ThreadLocal() {
+ @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> 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 callPrivileged(Callable 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 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 allowAll; // actually: this should be in a thread locale
+ public SimplePolicy(TestCase test, ThreadLocal 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();
+ }
+ }
+
+}
diff --git a/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/HandlersOnComplexUpdate.java b/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/HandlersOnComplexUpdate.java
new file mode 100644
index 00000000000..8a9fb21a4c5
--- /dev/null
+++ b/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/HandlersOnComplexUpdate.java
@@ -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) 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;
+ 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.
+ *
+ * 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.
+ *
+ * Finally releases the child logger after all configurations have been
+ * applied.
+ *
+ * @param name
+ * @param properties
+ * @throws Exception
+ */
+ static void test(String name, List 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 queue = new ReferenceQueue();
+ WeakReference 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 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 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 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 allowAll = new ThreadLocal() {
+ @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> 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 callPrivileged(Callable 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 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 allowAll; // actually: this should be in a thread locale
+ public SimplePolicy(TestCase test, ThreadLocal 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();
+ }
+ }
+
+}
diff --git a/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/SimpleUpdateConfigWithInputStreamTest.java b/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/SimpleUpdateConfigWithInputStreamTest.java
new file mode 100644
index 00000000000..2ba535e508a
--- /dev/null
+++ b/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/SimpleUpdateConfigWithInputStreamTest.java
@@ -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.
+ *
+ * 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> 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 granter) {
+ final boolean old = granter.get().getAndSet(true);
+ try {
+ run.run();
+ } finally {
+ granter.get().set(old);
+ }
+ }
+ static T callPrivileged(Callable call,
+ ThreadLocal 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 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 allowAll =
+ new ThreadLocal() {
+ @Override
+ protected AtomicBoolean initialValue() {
+ return new AtomicBoolean();
+ }
+ };
+ public final static ThreadLocal allowControl =
+ new ThreadLocal() {
+ @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();
+ }
+ }
+
+}
diff --git a/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/SimpleUpdateConfigurationTest.java b/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/SimpleUpdateConfigurationTest.java
new file mode 100644
index 00000000000..342f58b0780
--- /dev/null
+++ b/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/SimpleUpdateConfigurationTest.java
@@ -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.
+ *
+ * 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> 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 granter) {
+ final boolean old = granter.get().getAndSet(true);
+ try {
+ run.run();
+ } finally {
+ granter.get().set(old);
+ }
+ }
+ static T callPrivileged(Callable call,
+ ThreadLocal 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 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 allowAll =
+ new ThreadLocal() {
+ @Override
+ protected AtomicBoolean initialValue() {
+ return new AtomicBoolean();
+ }
+ };
+ public final static ThreadLocal allowControl =
+ new ThreadLocal() {
+ @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();
+ }
+ }
+
+}
diff --git a/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/UpdateConfigurationTest.java b/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/UpdateConfigurationTest.java
new file mode 100644
index 00000000000..fd33de326ec
--- /dev/null
+++ b/jdk/test/java/util/logging/LogManager/Configuration/updateConfiguration/UpdateConfigurationTest.java
@@ -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> 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;
+ 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.
+ *
+ * This is the main test method (the rest is infrastructure).
+ *
+ * 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.
+ *
+ * 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 queue = new ReferenceQueue();
+ WeakReference 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 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 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 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 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 {
+ // 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 allowAll = new ThreadLocal() {
+ @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> 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 callPrivileged(Callable 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 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 allowAll; // actually: this should be in a thread locale
+ public SimplePolicy(TestCase test, ThreadLocal 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();
+ }
+ }
+
+}