() {
+ @Override
+ public Void run() {
+ setLevel(level);
+ setFilter(filter);
+ setFormatter(formatter);
+ try {
+ setEncoding(encoding);
+ } catch (Exception ex) {
+ try {
+ setEncoding(null);
+ } catch (Exception ex2) {
+ // doing a setEncoding with null should always work.
+ // assert false;
+ }
+ }
+ return null;
+ }
+ }, null, LogManager.controlPermission);
+ }
+
/**
* Publish a LogRecord.
*
@@ -302,12 +347,9 @@ public abstract class Handler {
}
// Package-private support method for security checks.
- // If "sealed" is true, we check that the caller has
- // appropriate security privileges to update Handler
- // state and if not throw a SecurityException.
+ // We check that the caller has appropriate security privileges
+ // to update Handler state and if not throw a SecurityException.
void checkPermission() throws SecurityException {
- if (sealed) {
- manager.checkPermission();
- }
+ manager.checkPermission();
}
}
diff --git a/jdk/src/share/classes/java/util/logging/LogManager.java b/jdk/src/share/classes/java/util/logging/LogManager.java
index 8eae5942e43..4a5778b6c80 100644
--- a/jdk/src/share/classes/java/util/logging/LogManager.java
+++ b/jdk/src/share/classes/java/util/logging/LogManager.java
@@ -1449,7 +1449,7 @@ public class LogManager {
loadLoggerHandlers(rootLogger, null, "handlers");
}
- private final Permission controlPermission = new LoggingPermission("control", null);
+ static final Permission controlPermission = new LoggingPermission("control", null);
void checkPermission() {
SecurityManager sm = System.getSecurityManager();
diff --git a/jdk/src/share/classes/java/util/logging/MemoryHandler.java b/jdk/src/share/classes/java/util/logging/MemoryHandler.java
index 684ff8f8573..4d45faa204d 100644
--- a/jdk/src/share/classes/java/util/logging/MemoryHandler.java
+++ b/jdk/src/share/classes/java/util/logging/MemoryHandler.java
@@ -94,37 +94,24 @@ public class MemoryHandler extends Handler {
private LogRecord buffer[];
int start, count;
- // Private method to configure a MemoryHandler from LogManager
- // properties and/or default values as specified in the class
- // javadoc.
- private void configure() {
- LogManager manager = LogManager.getLogManager();
- String cname = getClass().getName();
-
- pushLevel = manager.getLevelProperty(cname +".push", Level.SEVERE);
- size = manager.getIntProperty(cname + ".size", DEFAULT_SIZE);
- if (size <= 0) {
- size = DEFAULT_SIZE;
- }
- setLevel(manager.getLevelProperty(cname +".level", Level.ALL));
- setFilter(manager.getFilterProperty(cname +".filter", null));
- setFormatter(manager.getFormatterProperty(cname +".formatter", new SimpleFormatter()));
- }
-
/**
* Create a MemoryHandler and configure it based on
* LogManager configuration properties.
*/
public MemoryHandler() {
- sealed = false;
- configure();
- sealed = true;
+ // configure with specific defaults for MemoryHandler
+ super(Level.ALL, new SimpleFormatter(), null);
LogManager manager = LogManager.getLogManager();
- String handlerName = getClass().getName();
- String targetName = manager.getProperty(handlerName+".target");
+ String cname = getClass().getName();
+ pushLevel = manager.getLevelProperty(cname +".push", Level.SEVERE);
+ size = manager.getIntProperty(cname + ".size", DEFAULT_SIZE);
+ if (size <= 0) {
+ size = DEFAULT_SIZE;
+ }
+ String targetName = manager.getProperty(cname+".target");
if (targetName == null) {
- throw new RuntimeException("The handler " + handlerName
+ throw new RuntimeException("The handler " + cname
+ " does not specify a target");
}
Class clz;
@@ -158,15 +145,15 @@ public class MemoryHandler extends Handler {
* @throws IllegalArgumentException if {@code size is <= 0}
*/
public MemoryHandler(Handler target, int size, Level pushLevel) {
+ // configure with specific defaults for MemoryHandler
+ super(Level.ALL, new SimpleFormatter(), null);
+
if (target == null || pushLevel == null) {
throw new NullPointerException();
}
if (size <= 0) {
throw new IllegalArgumentException();
}
- sealed = false;
- configure();
- sealed = true;
this.target = target;
this.pushLevel = pushLevel;
this.size = size;
diff --git a/jdk/src/share/classes/java/util/logging/SocketHandler.java b/jdk/src/share/classes/java/util/logging/SocketHandler.java
index 0d7f2ceedf4..56358308612 100644
--- a/jdk/src/share/classes/java/util/logging/SocketHandler.java
+++ b/jdk/src/share/classes/java/util/logging/SocketHandler.java
@@ -83,31 +83,6 @@ public class SocketHandler extends StreamHandler {
private String host;
private int port;
- // Private method to configure a SocketHandler from LogManager
- // properties and/or default values as specified in the class
- // javadoc.
- private void configure() {
- LogManager manager = LogManager.getLogManager();
- String cname = getClass().getName();
-
- setLevel(manager.getLevelProperty(cname +".level", Level.ALL));
- setFilter(manager.getFilterProperty(cname +".filter", null));
- setFormatter(manager.getFormatterProperty(cname +".formatter", new XMLFormatter()));
- try {
- setEncoding(manager.getStringProperty(cname +".encoding", null));
- } catch (Exception ex) {
- try {
- setEncoding(null);
- } catch (Exception ex2) {
- // doing a setEncoding with null should always work.
- // assert false;
- }
- }
- port = manager.getIntProperty(cname + ".port", 0);
- host = manager.getStringProperty(cname + ".host", null);
- }
-
-
/**
* Create a SocketHandler, using only LogManager properties
* (or their defaults).
@@ -117,9 +92,13 @@ public class SocketHandler extends StreamHandler {
* host and port.
*/
public SocketHandler() throws IOException {
- // We are going to use the logging defaults.
- sealed = false;
- configure();
+ // configure with specific defaults for SocketHandler
+ super(Level.ALL, new XMLFormatter(), null);
+
+ LogManager manager = LogManager.getLogManager();
+ String cname = getClass().getName();
+ port = manager.getIntProperty(cname + ".port", 0);
+ host = manager.getStringProperty(cname + ".host", null);
try {
connect();
@@ -127,7 +106,6 @@ public class SocketHandler extends StreamHandler {
System.err.println("SocketHandler: connect failed to " + host + ":" + port);
throw ix;
}
- sealed = true;
}
/**
@@ -146,11 +124,12 @@ public class SocketHandler extends StreamHandler {
* host and port.
*/
public SocketHandler(String host, int port) throws IOException {
- sealed = false;
- configure();
- sealed = true;
+ // configure with specific defaults for SocketHandler
+ super(Level.ALL, new XMLFormatter(), null);
+
this.port = port;
this.host = host;
+
connect();
}
@@ -167,7 +146,7 @@ public class SocketHandler extends StreamHandler {
sock = new Socket(host, port);
OutputStream out = sock.getOutputStream();
BufferedOutputStream bout = new BufferedOutputStream(out);
- setOutputStream(bout);
+ setOutputStreamPrivileged(bout);
}
/**
diff --git a/jdk/src/share/classes/java/util/logging/StreamHandler.java b/jdk/src/share/classes/java/util/logging/StreamHandler.java
index b3f23743611..0ace5b224cf 100644
--- a/jdk/src/share/classes/java/util/logging/StreamHandler.java
+++ b/jdk/src/share/classes/java/util/logging/StreamHandler.java
@@ -27,6 +27,9 @@
package java.util.logging;
import java.io.*;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.Objects;
/**
* Stream based logging Handler.
@@ -77,35 +80,12 @@ public class StreamHandler extends Handler {
private boolean doneHeader;
private volatile Writer writer;
- // Private method to configure a StreamHandler from LogManager
- // properties and/or default values as specified in the class
- // javadoc.
- private void configure() {
- LogManager manager = LogManager.getLogManager();
- String cname = getClass().getName();
-
- setLevel(manager.getLevelProperty(cname +".level", Level.INFO));
- setFilter(manager.getFilterProperty(cname +".filter", null));
- setFormatter(manager.getFormatterProperty(cname +".formatter", new SimpleFormatter()));
- try {
- setEncoding(manager.getStringProperty(cname +".encoding", null));
- } catch (Exception ex) {
- try {
- setEncoding(null);
- } catch (Exception ex2) {
- // doing a setEncoding with null should always work.
- // assert false;
- }
- }
- }
-
/**
* Create a StreamHandler, with no current output stream.
*/
public StreamHandler() {
- sealed = false;
- configure();
- sealed = true;
+ // configure with specific defaults for StreamHandler
+ super(Level.INFO, new SimpleFormatter(), null);
}
/**
@@ -116,11 +96,19 @@ public class StreamHandler extends Handler {
* @param formatter Formatter to be used to format output
*/
public StreamHandler(OutputStream out, Formatter formatter) {
- sealed = false;
- configure();
- setFormatter(formatter);
- setOutputStream(out);
- sealed = true;
+ // configure with default level but use specified formatter
+ super(Level.INFO, null, Objects.requireNonNull(formatter));
+
+ setOutputStreamPrivileged(out);
+ }
+
+ /**
+ * @see Handler#Handler(Level, Formatter, Formatter)
+ */
+ StreamHandler(Level defaultLevel,
+ Formatter defaultFormatter,
+ Formatter specifiedFormatter) {
+ super(defaultLevel, defaultFormatter, specifiedFormatter);
}
/**
@@ -301,4 +289,16 @@ public class StreamHandler extends Handler {
public synchronized void close() throws SecurityException {
flushAndClose();
}
+
+ // Package-private support for setting OutputStream
+ // with elevated privilege.
+ final void setOutputStreamPrivileged(final OutputStream out) {
+ AccessController.doPrivileged(new PrivilegedAction() {
+ @Override
+ public Void run() {
+ setOutputStream(out);
+ return null;
+ }
+ }, null, LogManager.controlPermission);
+ }
}
diff --git a/jdk/test/java/util/logging/HandlersConfigTest$Configured.props b/jdk/test/java/util/logging/HandlersConfigTest$Configured.props
new file mode 100644
index 00000000000..af6e7f5cfe6
--- /dev/null
+++ b/jdk/test/java/util/logging/HandlersConfigTest$Configured.props
@@ -0,0 +1,29 @@
+# mandatory Default properties...
+
+.level= INFO
+handlers=HandlersConfigTest$ConfiguredHandler
+
+java.util.logging.MemoryHandler.target=HandlersConfigTest$ConfiguredHandler
+
+# in addition to Default, Configured adds the following...
+
+java.util.logging.MemoryHandler.level=FINE
+java.util.logging.MemoryHandler.filter=HandlersConfigTest$ConfiguredFilter
+java.util.logging.MemoryHandler.formatter=HandlersConfigTest$ConfiguredFormatter
+java.util.logging.MemoryHandler.size=123
+java.util.logging.MemoryHandler.push=FINE
+
+java.util.logging.ConsoleHandler.level=FINE
+java.util.logging.ConsoleHandler.encoding=ASCII
+java.util.logging.ConsoleHandler.filter=HandlersConfigTest$ConfiguredFilter
+java.util.logging.ConsoleHandler.formatter=HandlersConfigTest$ConfiguredFormatter
+
+java.util.logging.StreamHandler.level=FINE
+java.util.logging.StreamHandler.encoding=ASCII
+java.util.logging.StreamHandler.filter=HandlersConfigTest$ConfiguredFilter
+java.util.logging.StreamHandler.formatter=HandlersConfigTest$ConfiguredFormatter
+
+java.util.logging.SocketHandler.level=FINE
+java.util.logging.SocketHandler.encoding=ASCII
+java.util.logging.SocketHandler.filter=HandlersConfigTest$ConfiguredFilter
+java.util.logging.SocketHandler.formatter=HandlersConfigTest$ConfiguredFormatter
diff --git a/jdk/test/java/util/logging/HandlersConfigTest$Default.props b/jdk/test/java/util/logging/HandlersConfigTest$Default.props
new file mode 100644
index 00000000000..fc216319b7d
--- /dev/null
+++ b/jdk/test/java/util/logging/HandlersConfigTest$Default.props
@@ -0,0 +1,6 @@
+# mandatory Default properties...
+
+.level= INFO
+handlers=HandlersConfigTest$ConfiguredHandler
+
+java.util.logging.MemoryHandler.target=HandlersConfigTest$ConfiguredHandler
diff --git a/jdk/test/java/util/logging/HandlersConfigTest.java b/jdk/test/java/util/logging/HandlersConfigTest.java
new file mode 100644
index 00000000000..7d122cd9f86
--- /dev/null
+++ b/jdk/test/java/util/logging/HandlersConfigTest.java
@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+
+/*
+ * @test
+ * @bug 8029781 8030801
+ * @summary Test which verifies that various JDK logging Handlers are
+ * configured correctly from defaults and/or LogManager properties
+ * as specified in javadoc and that no special
+ * logging permission is required for instantiating them.
+ * @run main/othervm HandlersConfigTest default
+ * @run main/othervm HandlersConfigTest configured
+ */
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.reflect.Field;
+import java.net.ServerSocket;
+import java.net.URL;
+import java.util.Objects;
+import java.util.logging.ConsoleHandler;
+import java.util.logging.Filter;
+import java.util.logging.Formatter;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogManager;
+import java.util.logging.LogRecord;
+import java.util.logging.MemoryHandler;
+import java.util.logging.SimpleFormatter;
+import java.util.logging.SocketHandler;
+import java.util.logging.StreamHandler;
+import java.util.logging.XMLFormatter;
+
+public abstract class HandlersConfigTest implements Runnable {
+
+ public static void main(String[] args) {
+ switch (args.length == 1 ? args[0] : "usage") {
+ case "default":
+ new Default().run();
+ break;
+ case "configured":
+ new Configured().run();
+ break;
+ default:
+ System.err.println("Usage: HandlersConfigTest [default|configured]");
+ break;
+ }
+ }
+
+ static final String CONFIG_FILE_PROPERTY = "java.util.logging.config.file";
+ final Field memoryHandlerTarget, memoryHandlerSize, streamHandlerOutput;
+ final ServerSocket serverSocket;
+
+ HandlersConfigTest() {
+ // establish access to private fields
+ try {
+ memoryHandlerTarget = MemoryHandler.class.getDeclaredField("target");
+ memoryHandlerTarget.setAccessible(true);
+ memoryHandlerSize = MemoryHandler.class.getDeclaredField("size");
+ memoryHandlerSize.setAccessible(true);
+ streamHandlerOutput = StreamHandler.class.getDeclaredField("output");
+ streamHandlerOutput.setAccessible(true);
+ } catch (NoSuchFieldException e) {
+ throw new AssertionError(e);
+ }
+
+ // load logging.propertes for the test
+ String rname = getClass().getName().replace('.', '/') + ".props";
+ URL url = getClass().getClassLoader().getResource(rname);
+ if (url == null || !"file".equals(url.getProtocol())) {
+ throw new IllegalStateException("Resource: " + rname + " not found or not on file: " + url);
+ }
+ System.setProperty(CONFIG_FILE_PROPERTY, url.getFile());
+
+ // create ServerSocket as a target for SocketHandler
+ try {
+ serverSocket = new ServerSocket(0); // auto allocated port
+ } catch (IOException e) {
+ throw new AssertionError(e);
+ }
+
+ // activate security
+ System.setSecurityManager(new SecurityManager() {
+ @Override
+ public void checkConnect(String host, int port) {
+ // allow socket connections
+ }
+ });
+
+ // initialize logging system
+ LogManager.getLogManager();
+ }
+
+ // check that defaults are used as specified by javadoc
+
+ public static class Default extends HandlersConfigTest {
+ public static void main(String[] args) {
+ new Default().run();
+ }
+
+ @Override
+ public void run() {
+ // MemoryHandler
+
+ check(new MemoryHandler(),
+ Level.ALL, null, null, SimpleFormatter.class,
+ ConfiguredHandler.class, 1000, Level.SEVERE);
+
+ check(new MemoryHandler(new SpecifiedHandler(), 100, Level.WARNING),
+ Level.ALL, null, null, SimpleFormatter.class,
+ SpecifiedHandler.class, 100, Level.WARNING);
+
+ // StreamHandler
+
+ check(new StreamHandler(),
+ Level.INFO, null, null, SimpleFormatter.class,
+ null);
+
+ check(new StreamHandler(System.out, new SpecifiedFormatter()),
+ Level.INFO, null, null, SpecifiedFormatter.class,
+ System.out);
+
+ // ConsoleHandler
+
+ check(new ConsoleHandler(),
+ Level.INFO, null, null, SimpleFormatter.class,
+ System.err);
+
+ // SocketHandler (use the ServerSocket's port)
+
+ try {
+ check(new SocketHandler("localhost", serverSocket.getLocalPort()),
+ Level.ALL, null, null, XMLFormatter.class);
+ } catch (IOException e) {
+ throw new RuntimeException("Can't connect to localhost:" + serverSocket.getLocalPort(), e);
+ }
+ }
+ }
+
+ // check that LogManager properties configuration is respected
+
+ public static class Configured extends HandlersConfigTest {
+ public static void main(String[] args) {
+ new Configured().run();
+ }
+
+ @Override
+ public void run() {
+ // MemoryHandler
+
+ check(new MemoryHandler(),
+ Level.FINE, null, ConfiguredFilter.class, ConfiguredFormatter.class,
+ ConfiguredHandler.class, 123, Level.FINE);
+
+ check(new MemoryHandler(new SpecifiedHandler(), 100, Level.WARNING),
+ Level.FINE, null, ConfiguredFilter.class, ConfiguredFormatter.class,
+ SpecifiedHandler.class, 100, Level.WARNING);
+
+ // StreamHandler
+
+ check(new StreamHandler(),
+ Level.FINE, "ASCII", ConfiguredFilter.class, ConfiguredFormatter.class,
+ null);
+
+ check(new StreamHandler(System.out, new SpecifiedFormatter()),
+ Level.FINE, "ASCII", ConfiguredFilter.class, SpecifiedFormatter.class,
+ System.out);
+
+ // ConsoleHandler
+
+ check(new ConsoleHandler(),
+ Level.FINE, "ASCII", ConfiguredFilter.class, ConfiguredFormatter.class,
+ System.err);
+
+ // SocketHandler (use the ServerSocket's port)
+
+ try {
+ check(new SocketHandler("localhost", serverSocket.getLocalPort()),
+ Level.FINE, "ASCII", ConfiguredFilter.class, ConfiguredFormatter.class);
+ } catch (Exception e) {
+ throw new RuntimeException("Can't connect to localhost:" + serverSocket.getLocalPort(), e);
+ }
+ }
+ }
+
+ // test infrastructure
+
+ void check(Handler handler,
+ Level expectedLevel,
+ String expectedEncoding,
+ Class expectedFilterType,
+ Class expectedFormatterType) {
+ checkEquals(handler, "level", handler.getLevel(), expectedLevel);
+ checkEquals(handler, "encoding", handler.getEncoding(), expectedEncoding);
+ checkType(handler, "filter", handler.getFilter(), expectedFilterType);
+ checkType(handler, "formatter", handler.getFormatter(), expectedFormatterType);
+ }
+
+ void check(MemoryHandler handler,
+ Level expectedLevel,
+ String expectedEncoding,
+ Class expectedFilterType,
+ Class expectedFormatterType,
+ Class expextedTargetType,
+ int expextedSize,
+ Level expectedPushLevel) {
+ checkType(handler, "target", getTarget(handler), expextedTargetType);
+ checkEquals(handler, "size", getSize(handler), expextedSize);
+ checkEquals(handler, "pushLevel", handler.getPushLevel(), expectedPushLevel);
+ check(handler, expectedLevel, expectedEncoding, expectedFilterType, expectedFormatterType);
+ }
+
+ void check(StreamHandler handler,
+ Level expectedLevel,
+ String expectedEncoding,
+ Class expectedFilterType,
+ Class expectedFormatterType,
+ OutputStream expectedOutputStream) {
+ checkEquals(handler, "outputStream", getOutput(handler), expectedOutputStream);
+ check(handler, expectedLevel, expectedEncoding, expectedFilterType, expectedFormatterType);
+ }
+
+ void checkEquals(Handler handler, String property, T value, T expectedValue) {
+ if (!Objects.equals(value, expectedValue)) {
+ fail(handler, property + ": " + value + ", expected " + property + ": " + expectedValue);
+ }
+ }
+
+ void checkType(Handler handler, String property, T value, Class expectedType) {
+ if (!(expectedType == null && value == null || expectedType != null && expectedType.isInstance(value))) {
+ Class type = value == null ? null : value.getClass();
+ fail(handler, property + " type: " + type + ", expected " + property + " type: " + expectedType);
+ }
+ }
+
+ void fail(Handler handler, String message) {
+ throw new AssertionError("Handler: " + handler.getClass().getName() +
+ ", configured with: " + getClass().getName() +
+ ", " + message);
+ }
+
+ Handler getTarget(MemoryHandler memoryHandler) {
+ try {
+ return (Handler) memoryHandlerTarget.get(memoryHandler);
+ } catch (IllegalAccessException e) {
+ throw new IllegalAccessError(e.getMessage());
+ }
+ }
+
+ int getSize(MemoryHandler memoryHandler) {
+ try {
+ return (int) memoryHandlerSize.get(memoryHandler);
+ } catch (IllegalAccessException e) {
+ throw new IllegalAccessError(e.getMessage());
+ }
+ }
+
+ OutputStream getOutput(StreamHandler streamHandler) {
+ try {
+ return (OutputStream) streamHandlerOutput.get(streamHandler);
+ } catch (IllegalAccessException e) {
+ throw new IllegalAccessError(e.getMessage());
+ }
+ }
+
+ // various independent types of Formatters, Filters, Handlers...
+
+ public static class SpecifiedFormatter extends Formatter {
+ @Override
+ public String format(LogRecord record) {
+ return String.valueOf(record);
+ }
+ }
+
+ public static class SpecifiedHandler extends Handler {
+ @Override
+ public void publish(LogRecord record) { }
+
+ @Override
+ public void flush() { }
+
+ @Override
+ public void close() throws SecurityException { }
+ }
+
+ public static class ConfiguredFormatter extends Formatter {
+ @Override
+ public String format(LogRecord record) {
+ return String.valueOf(record);
+ }
+ }
+
+ public static class ConfiguredFilter implements Filter {
+ @Override
+ public boolean isLoggable(LogRecord record) {
+ return true;
+ }
+ }
+
+ public static class ConfiguredHandler extends Handler {
+ @Override
+ public void publish(LogRecord record) { }
+
+ @Override
+ public void flush() { }
+
+ @Override
+ public void close() throws SecurityException { }
+ }
+}