/hg/release/icedtea7-forest-2.1/jdk: 4 new changesets
andrew at icedtea.classpath.org
andrew at icedtea.classpath.org
Mon Feb 11 15:05:48 PST 2013
changeset 090b35175a91 in /hg/release/icedtea7-forest-2.1/jdk
details: http://icedtea.classpath.org/hg/release/icedtea7-forest-2.1/jdk?cmd=changeset;node=090b35175a91
author: denis
date: Tue Dec 11 14:19:16 2012 +0400
8004341: Two JCK tests fails with 7u11 b06
Reviewed-by: serb, skoivu
changeset 6cf8ac775489 in /hg/release/icedtea7-forest-2.1/jdk
details: http://icedtea.classpath.org/hg/release/icedtea7-forest-2.1/jdk?cmd=changeset;node=6cf8ac775489
author: mchung
date: Thu Jan 10 10:52:39 2013 -0800
8005615: Java Logger fails to load tomcat logger implementation (JULI)
Reviewed-by: alanb, ahgross
changeset 1240b063ab95 in /hg/release/icedtea7-forest-2.1/jdk
details: http://icedtea.classpath.org/hg/release/icedtea7-forest-2.1/jdk?cmd=changeset;node=1240b063ab95
author: andrew
date: Mon Feb 11 23:04:41 2013 +0000
Removed tag icedtea-2.1.5
changeset 833c87b29994 in /hg/release/icedtea7-forest-2.1/jdk
details: http://icedtea.classpath.org/hg/release/icedtea7-forest-2.1/jdk?cmd=changeset;node=833c87b29994
author: andrew
date: Mon Feb 11 23:04:45 2013 +0000
Added tag icedtea-2.1.5 for changeset 1240b063ab95
diffstat:
.hgtags | 4 +
src/share/classes/java/awt/Dialog.java | 3 +-
src/share/classes/java/util/logging/LogManager.java | 259 ++++++++++---------
src/share/classes/java/util/logging/Logger.java | 37 +-
test/java/util/logging/CustomLogManager.java | 177 +++++++++++++
test/java/util/logging/CustomLogManagerTest.java | 63 ++++
test/java/util/logging/SimpleLogManager.java | 113 ++++++++
7 files changed, 515 insertions(+), 141 deletions(-)
diffs (truncated from 918 to 500 lines):
diff -r 52029bcc00e1 -r 833c87b29994 .hgtags
--- a/.hgtags Tue Feb 05 11:08:18 2013 +0000
+++ b/.hgtags Mon Feb 11 23:04:45 2013 +0000
@@ -156,3 +156,7 @@
8c49c024c920982eb4a99b5960f260b9210eb363 icedtea-2.1.3
d119038320a3133018f0b968a4e0a9d93ccef76c icedtea-2.1.4
73455df094cba27f0f9d2b23b8666936b3100683 icedtea-2.1.5
+73455df094cba27f0f9d2b23b8666936b3100683 icedtea-2.1.5
+0000000000000000000000000000000000000000 icedtea-2.1.5
+0000000000000000000000000000000000000000 icedtea-2.1.5
+1240b063ab952404906155b9703e2fa472933d47 icedtea-2.1.5
diff -r 52029bcc00e1 -r 833c87b29994 src/share/classes/java/awt/Dialog.java
--- a/src/share/classes/java/awt/Dialog.java Tue Feb 05 11:08:18 2013 +0000
+++ b/src/share/classes/java/awt/Dialog.java Mon Feb 11 23:04:45 2013 +0000
@@ -1631,12 +1631,13 @@
if (localModalityType == null) {
this.modal = fields.get("modal", false);
setModal(modal);
+ } else {
+ this.modalityType = localModalityType;
}
this.resizable = fields.get("resizable", true);
this.undecorated = fields.get("undecorated", false);
this.title = (String)fields.get("title", "");
- this.modalityType = localModalityType;
blockedWindows = new IdentityArrayList();
diff -r 52029bcc00e1 -r 833c87b29994 src/share/classes/java/util/logging/LogManager.java
--- a/src/share/classes/java/util/logging/LogManager.java Tue Feb 05 11:08:18 2013 +0000
+++ b/src/share/classes/java/util/logging/LogManager.java Mon Feb 11 23:04:45 2013 +0000
@@ -159,7 +159,7 @@
// LoggerContext for system loggers and user loggers
private final LoggerContext systemContext = new SystemLoggerContext();
- private final LoggerContext userContext = new UserLoggerContext();
+ private final LoggerContext userContext = new LoggerContext();
private Logger rootLogger;
// Have we done the primordial reading of the configuration file?
@@ -197,13 +197,13 @@
// Create and retain Logger for the root of the namespace.
manager.rootLogger = manager.new RootLogger();
- manager.systemContext.addLogger(manager.rootLogger);
- manager.userContext.addLogger(manager.rootLogger);
+ manager.addLogger(manager.rootLogger);
+ manager.systemContext.addLocalLogger(manager.rootLogger);
// Adding the global Logger. Doing so in the Logger.<clinit>
// would deadlock with the LogManager.<clinit>.
Logger.global.setLogManager(manager);
- manager.systemContext.addLogger(Logger.global);
+ manager.addLogger(Logger.global);
// We don't call readConfiguration() here, as we may be running
// very early in the JVM startup sequence. Instead readConfiguration
@@ -341,7 +341,7 @@
// Returns the LoggerContext for the user code (i.e. application or AppContext).
// Loggers are isolated from each AppContext.
- LoggerContext getUserContext() {
+ private LoggerContext getUserContext() {
LoggerContext context = null;
SecurityManager sm = System.getSecurityManager();
@@ -362,8 +362,8 @@
if (javaAwtAccess.isMainAppContext()) {
context = userContext;
} else {
- context = new UserLoggerContext();
- context.addLogger(manager.rootLogger);
+ context = new LoggerContext();
+ context.addLocalLogger(manager.rootLogger);
}
javaAwtAccess.put(ecx, LoggerContext.class, context);
}
@@ -374,10 +374,6 @@
return context;
}
- LoggerContext getSystemContext() {
- return systemContext;
- }
-
private List<LoggerContext> contexts() {
List<LoggerContext> cxs = new ArrayList<>();
cxs.add(systemContext);
@@ -385,6 +381,58 @@
return cxs;
}
+ // Find or create a specified logger instance. If a logger has
+ // already been created with the given name it is returned.
+ // Otherwise a new logger instance is created and registered
+ // in the LogManager global namespace.
+ // This method will always return a non-null Logger object.
+ // Synchronization is not required here. All synchronization for
+ // adding a new Logger object is handled by addLogger().
+ //
+ // This method must delegate to the LogManager implementation to
+ // add a new Logger or return the one that has been added previously
+ // as a LogManager subclass may override the addLogger, getLogger,
+ // readConfiguration, and other methods.
+ Logger demandLogger(String name, String resourceBundleName) {
+ Logger result = getLogger(name);
+ if (result == null) {
+ // only allocate the new logger once
+ Logger newLogger = new Logger(name, resourceBundleName);
+ do {
+ if (addLogger(newLogger)) {
+ // We successfully added the new Logger that we
+ // created above so return it without refetching.
+ return newLogger;
+ }
+
+ // We didn't add the new Logger that we created above
+ // because another thread added a Logger with the same
+ // name after our null check above and before our call
+ // to addLogger(). We have to refetch the Logger because
+ // addLogger() returns a boolean instead of the Logger
+ // reference itself. However, if the thread that created
+ // the other Logger is not holding a strong reference to
+ // the other Logger, then it is possible for the other
+ // Logger to be GC'ed after we saw it in addLogger() and
+ // before we can refetch it. If it has been GC'ed then
+ // we'll just loop around and try again.
+ result = getLogger(name);
+ } while (result == null);
+ }
+ return result;
+ }
+
+ Logger demandSystemLogger(String name, String resourceBundleName) {
+ return systemContext.demandLogger(name, resourceBundleName);
+ }
+
+ // LoggerContext maintains the logger namespace per context.
+ // The default LogManager implementation has one system context and user
+ // context. The system context is used to maintain the namespace for
+ // all system loggers and is queried by the system code. If a system logger
+ // doesn't exist in the user context, it'll also be added to the user context.
+ // The user context is queried by the user code and all other loggers are
+ // added in the user context.
static class LoggerContext {
// Table of named Loggers that maps names to Loggers.
private final Hashtable<String,LoggerWeakRef> namedLoggers = new Hashtable<>();
@@ -395,6 +443,12 @@
this.root = new LogNode(null, this);
}
+ Logger demandLogger(String name, String resourceBundleName) {
+ // a LogManager subclass may have its own implementation to add and
+ // get a Logger. So delegate to the LogManager to do the work.
+ return manager.demandLogger(name, resourceBundleName);
+ }
+
synchronized Logger findLogger(String name) {
LoggerWeakRef ref = namedLoggers.get(name);
if (ref == null) {
@@ -409,7 +463,9 @@
return logger;
}
- synchronized boolean addLogger(Logger logger) {
+ // Add a logger to this context. This method will only set its level
+ // and process parent loggers. It doesn't set its handlers.
+ synchronized boolean addLocalLogger(Logger logger) {
final String name = logger.getName();
if (name == null) {
throw new NullPointerException();
@@ -442,9 +498,6 @@
doSetLevel(logger, level);
}
- // Do we have a per logger handler too?
- // Note: this will add a 200ms penalty
- manager.loadLoggerHandlers(logger, name, name + ".handlers");
processParentHandlers(logger, name);
// Find the new node and its parent.
@@ -481,50 +534,21 @@
return namedLoggers.keys();
}
- Logger demandLogger(String name) {
- return demandLogger(name, null);
- }
-
- // Find or create a specified logger instance. If a logger has
- // already been created with the given name it is returned.
- // Otherwise a new logger instance is created and registered
- // in the LogManager global namespace.
-
- // This method will always return a non-null Logger object.
- // Synchronization is not required here. All synchronization for
- // adding a new Logger object is handled by addLogger().
- Logger demandLogger(String name, String resourceBundleName) {
- Logger result = findLogger(name);
- if (result == null) {
- // only allocate the new logger once
- Logger newLogger = new Logger(name, resourceBundleName);
- do {
- if (addLogger(newLogger)) {
- // We successfully added the new Logger that we
- // created above so return it without refetching.
- return newLogger;
- }
-
- // We didn't add the new Logger that we created above
- // because another thread added a Logger with the same
- // name after our null check above and before our call
- // to addLogger(). We have to refetch the Logger because
- // addLogger() returns a boolean instead of the Logger
- // reference itself. However, if the thread that created
- // the other Logger is not holding a strong reference to
- // the other Logger, then it is possible for the other
- // Logger to be GC'ed after we saw it in addLogger() and
- // before we can refetch it. If it has been GC'ed then
- // we'll just loop around and try again.
- result = findLogger(name);
- } while (result == null);
- }
- return result;
- }
-
// If logger.getUseParentHandlers() returns 'true' and any of the logger's
// parents have levels or handlers defined, make sure they are instantiated.
- private void processParentHandlers(Logger logger, String name) {
+ private void processParentHandlers(final Logger logger, final String name) {
+ AccessController.doPrivileged(new PrivilegedAction<Void>() {
+ public Void run() {
+ if (logger != manager.rootLogger) {
+ boolean useParent = manager.getBooleanProperty(name + ".useParentHandlers", true);
+ if (!useParent) {
+ logger.setUseParentHandlers(false);
+ }
+ }
+ return null;
+ }
+ });
+
int ix = 1;
for (;;) {
int ix2 = name.indexOf(".", ix);
@@ -532,12 +556,11 @@
break;
}
String pname = name.substring(0, ix2);
-
if (manager.getProperty(pname + ".level") != null ||
manager.getProperty(pname + ".handlers") != null) {
// This pname has a level/handlers definition.
// Make sure it exists.
- demandLogger(pname);
+ demandLogger(pname, null);
}
ix = ix2+1;
}
@@ -575,53 +598,51 @@
}
static class SystemLoggerContext extends LoggerContext {
- // Default resource bundle for all system loggers
- Logger demandLogger(String name) {
- // default to use the system logger's resource bundle
- return super.demandLogger(name, Logger.SYSTEM_LOGGER_RB_NAME);
- }
- }
-
- static class UserLoggerContext extends LoggerContext {
- /**
- * Returns a Logger of the given name if there is one registered
- * in this context. Otherwise, it will return the one registered
- * in the system context if there is one. The returned Logger
- * instance may be initialized with a different resourceBundleName.
- * If no such logger exists, a new Logger instance will be created
- * and registered in this context.
- */
+ // Add a system logger in the system context's namespace as well as
+ // in the LogManager's namespace if not exist so that there is only
+ // one single logger of the given name. System loggers are visible
+ // to applications unless a logger of the same name has been added.
Logger demandLogger(String name, String resourceBundleName) {
Logger result = findLogger(name);
if (result == null) {
- // use the system logger if exists; or allocate a new logger.
- // The system logger is added to the app logger context so that
- // any child logger created in the app logger context can have
- // a system logger as its parent if already exist.
- Logger logger = manager.systemContext.findLogger(name);
- Logger newLogger =
- logger != null ? logger : new Logger(name, resourceBundleName);
+ // only allocate the new system logger once
+ Logger newLogger = new Logger(name, resourceBundleName);
do {
- if (addLogger(newLogger)) {
+ if (addLocalLogger(newLogger)) {
// We successfully added the new Logger that we
// created above so return it without refetching.
- return newLogger;
+ result = newLogger;
+ } else {
+ // We didn't add the new Logger that we created above
+ // because another thread added a Logger with the same
+ // name after our null check above and before our call
+ // to addLogger(). We have to refetch the Logger because
+ // addLogger() returns a boolean instead of the Logger
+ // reference itself. However, if the thread that created
+ // the other Logger is not holding a strong reference to
+ // the other Logger, then it is possible for the other
+ // Logger to be GC'ed after we saw it in addLogger() and
+ // before we can refetch it. If it has been GC'ed then
+ // we'll just loop around and try again.
+ result = findLogger(name);
}
-
- // We didn't add the new Logger that we created above
- // because another thread added a Logger with the same
- // name after our null check above and before our call
- // to addLogger(). We have to refetch the Logger because
- // addLogger() returns a boolean instead of the Logger
- // reference itself. However, if the thread that created
- // the other Logger is not holding a strong reference to
- // the other Logger, then it is possible for the other
- // Logger to be GC'ed after we saw it in addLogger() and
- // before we can refetch it. If it has been GC'ed then
- // we'll just loop around and try again.
- result = findLogger(name);
} while (result == null);
}
+ // Add the system logger to the LogManager's namespace if not exists
+ // The LogManager will set its handlers via the LogManager.addLogger method.
+ if (!manager.addLogger(result) && result.getHandlers().length == 0) {
+ // if logger already exists but handlers not set
+ final Logger l = manager.getLogger(name);
+ final Logger logger = result;
+ AccessController.doPrivileged(new PrivilegedAction<Void>() {
+ public Void run() {
+ for (Handler hdl : l.getHandlers()) {
+ logger.addHandler(hdl);
+ }
+ return null;
+ }
+ });
+ }
return result;
}
}
@@ -631,22 +652,16 @@
// be made based on the logging configuration, which can
// only be modified by trusted code.
private void loadLoggerHandlers(final Logger logger, final String name,
- final String handlersPropertyName) {
+ final String handlersPropertyName)
+ {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
- if (logger != rootLogger) {
- boolean useParent = getBooleanProperty(name + ".useParentHandlers", true);
- if (!useParent) {
- logger.setUseParentHandlers(false);
- }
- }
-
String names[] = parseClassNames(handlersPropertyName);
for (int i = 0; i < names.length; i++) {
String word = names[i];
try {
Class clz = ClassLoader.getSystemClassLoader().loadClass(word);
- Handler hdl = (Handler) clz.newInstance();
+ Handler hdl = (Handler) clz.newInstance();
// Check if there is a property defining the
// this handler's level.
String levs = getProperty(word + ".level");
@@ -668,7 +683,8 @@
}
}
return null;
- }});
+ }
+ });
}
@@ -807,13 +823,17 @@
if (name == null) {
throw new NullPointerException();
}
- if (systemContext.findLogger(name) != null) {
+ LoggerContext cx = getUserContext();
+ if (cx.addLocalLogger(logger)) {
+ // Do we have a per logger handler too?
+ // Note: this will add a 200ms penalty
+ loadLoggerHandlers(logger, name, name + ".handlers");
+ return true;
+ } else {
return false;
}
- return getUserContext().addLogger(logger);
}
-
// Private method to set a level on a logger.
// If necessary, we raise privilege before doing the call.
private static void doSetLevel(final Logger logger, final Level level) {
@@ -832,8 +852,6 @@
}});
}
-
-
// Private method to set a parent on a logger.
// If necessary, we raise privilege before doing the setParent call.
private static void doSetParent(final Logger logger, final Logger parent) {
@@ -868,15 +886,7 @@
* @return matching logger or null if none is found
*/
public Logger getLogger(String name) {
- // return the first logger added
- //
- // once a system logger is added in the system context, no one can
- // adds a logger with the same name in the global context
- // (see LogManager.addLogger). So if there is a logger in the global
- // context with the same name as one in the system context, it must be
- // added before the system logger was created.
- Logger logger = getUserContext().findLogger(name);
- return logger != null ? logger : systemContext.findLogger(name);
+ return getUserContext().findLogger(name);
}
/**
@@ -896,10 +906,7 @@
* @return enumeration of logger name strings
*/
public Enumeration<String> getLoggerNames() {
- // only return unique names
- Set<String> names = new HashSet<>(Collections.list(systemContext.getLoggerNames()));
- names.addAll(Collections.list(getUserContext().getLoggerNames()));
- return Collections.enumeration(names);
+ return getUserContext().getLoggerNames();
}
/**
@@ -1221,7 +1228,6 @@
loadLoggerHandlers(rootLogger, null, "handlers");
}
-
private final Permission controlPermission = new LoggingPermission("control", null);
void checkPermission() {
@@ -1280,7 +1286,6 @@
// that we only instantiate the global handlers when they
// are first needed.
private class RootLogger extends Logger {
-
private RootLogger() {
super("", null);
setLevel(defaultLevel);
diff -r 52029bcc00e1 -r 833c87b29994 src/share/classes/java/util/logging/Logger.java
--- a/src/share/classes/java/util/logging/Logger.java Tue Feb 05 11:08:18 2013 +0000
+++ b/src/share/classes/java/util/logging/Logger.java Mon Feb 11 23:04:45 2013 +0000
@@ -30,7 +30,6 @@
import java.util.concurrent.CopyOnWriteArrayList;
import java.security.*;
import java.lang.ref.WeakReference;
-import java.util.logging.LogManager.LoggerContext;
/**
* A Logger object is used to log messages for a specific
@@ -290,18 +289,32 @@
//
// As an interim solution, if the immediate caller whose caller loader is
// null, we assume it's a system logger and add it to the system context.
- private static LoggerContext getLoggerContext() {
+ // These system loggers only set the resource bundle to the given
+ // resource bundle name (rather than the default system resource bundle).
+ private static class SystemLoggerHelper {
+ static boolean disableCallerCheck = getBooleanProperty("sun.util.logging.disableCallerCheck");
+ private static boolean getBooleanProperty(final String key) {
+ String s = AccessController.doPrivileged(new PrivilegedAction<String>() {
+ public String run() {
+ return System.getProperty(key);
+ }
+ });
+ return Boolean.valueOf(s);
+ }
+ }
+
+ private static Logger demandLogger(String name, String resourceBundleName) {
LogManager manager = LogManager.getLogManager();
SecurityManager sm = System.getSecurityManager();
- if (sm != null) {
- // 0: Reflection 1: Logger.getLoggerContext 2: Logger.getLogger 3: caller
+ if (sm != null && !SystemLoggerHelper.disableCallerCheck) {
+ // 0: Reflection 1: Logger.demandLogger 2: Logger.getLogger 3: caller
final int SKIP_FRAMES = 3;
Class<?> caller = sun.reflect.Reflection.getCallerClass(SKIP_FRAMES);
More information about the distro-pkg-dev
mailing list