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

Merge

Browse Source
This commit is contained in:
Sean Mullan 2017-01-20 14:13:11 -05:00
commit 700a9548b6
38 changed files with 1500 additions and 1716 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
jdk/src/java.management/share/classes/com/sun/jmx/defaults/JmxProperties.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2017, 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
@ -25,7 +25,7 @@
package com.sun.jmx.defaults;
import java.util.logging.Logger;
import java.lang.System.Logger;
/**
* This contains the property list defined for this
@ -120,7 +120,7 @@ public class JmxProperties {
* Logger for MBean Server information.
*/
public static final Logger MBEANSERVER_LOGGER =
Logger.getLogger(MBEANSERVER_LOGGER_NAME);
System.getLogger(MBEANSERVER_LOGGER_NAME);
/**
* Logger name for MLet service information.
@ -132,7 +132,7 @@ public class JmxProperties {
* Logger for MLet service information.
*/
public static final Logger MLET_LOGGER =
Logger.getLogger(MLET_LOGGER_NAME);
System.getLogger(MLET_LOGGER_NAME);
/**
* Logger name for Monitor information.
@ -144,7 +144,7 @@ public class JmxProperties {
* Logger for Monitor information.
*/
public static final Logger MONITOR_LOGGER =
Logger.getLogger(MONITOR_LOGGER_NAME);
System.getLogger(MONITOR_LOGGER_NAME);
/**
* Logger name for Timer information.
@ -156,7 +156,7 @@ public class JmxProperties {
* Logger for Timer information.
*/
public static final Logger TIMER_LOGGER =
Logger.getLogger(TIMER_LOGGER_NAME);
System.getLogger(TIMER_LOGGER_NAME);
/**
* Logger name for Event Management information.
@ -168,7 +168,7 @@ public class JmxProperties {
* Logger for Event Management information.
*/
public static final Logger NOTIFICATION_LOGGER =
Logger.getLogger(NOTIFICATION_LOGGER_NAME);
System.getLogger(NOTIFICATION_LOGGER_NAME);
/**
* Logger name for Relation Service.
@ -180,7 +180,7 @@ public class JmxProperties {
* Logger for Relation Service.
*/
public static final Logger RELATION_LOGGER =
Logger.getLogger(RELATION_LOGGER_NAME);
System.getLogger(RELATION_LOGGER_NAME);
/**
* Logger name for Model MBean.
@ -192,7 +192,7 @@ public class JmxProperties {
* Logger for Model MBean.
*/
public static final Logger MODELMBEAN_LOGGER =
Logger.getLogger(MODELMBEAN_LOGGER_NAME);
System.getLogger(MODELMBEAN_LOGGER_NAME);
/**
* Logger name for all other JMX classes.
@ -204,5 +204,5 @@ public class JmxProperties {
* Logger for all other JMX classes.
*/
public static final Logger MISC_LOGGER =
Logger.getLogger(MISC_LOGGER_NAME);
System.getLogger(MISC_LOGGER_NAME);
}

127
jdk/src/java.management/share/classes/com/sun/jmx/interceptor/DefaultMBeanServerInterceptor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2017, 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
@ -50,7 +50,7 @@ import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.WeakHashMap;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
// JMX import
import javax.management.Attribute;
@ -258,19 +258,16 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
/* Load the appropriate class. */
if (withDefaultLoaderRepository) {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"createMBean",
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
"ClassName = " + className + ", ObjectName = " + name);
}
theClass =
instantiator.findClassWithDefaultLoaderRepository(className);
} else if (loaderName == null) {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"createMBean", "ClassName = " + className +
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
"ClassName = " + className +
", ObjectName = " + name + ", Loader name = null");
}
@ -279,10 +276,9 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
} else {
loaderName = nonDefaultDomain(loaderName);
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"createMBean", "ClassName = " + className +
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
"ClassName = " + className +
", ObjectName = " + name +
", Loader name = " + loaderName);
}
@ -633,10 +629,8 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
name = nonDefaultDomain(name);
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"getAttribute",
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
"Attribute = " + attribute + ", ObjectName = " + name);
}
@ -670,10 +664,8 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
name = nonDefaultDomain(name);
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"getAttributes", "ObjectName = " + name);
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE, "ObjectName = " + name);
}
final DynamicMBean instance = getMBean(name);
@ -732,10 +724,8 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
name = nonDefaultDomain(name);
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"setAttribute", "ObjectName = " + name +
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE, "ObjectName = " + name +
", Attribute = " + attribute.getName());
}
@ -910,10 +900,9 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
name = nonDefaultDomain(name);
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"registerMBean", "ObjectName = " + name);
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
"ObjectName = " + name);
}
ObjectName logicalName = preRegister(mbean, server, name);
@ -1023,14 +1012,14 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
if (mbean instanceof MBeanRegistration)
((MBeanRegistration) mbean).postRegister(registrationDone);
} catch (RuntimeException e) {
MBEANSERVER_LOGGER.fine("While registering MBean ["+logicalName+
MBEANSERVER_LOGGER.log(Level.DEBUG, "While registering MBean ["+logicalName+
"]: " + "Exception thrown by postRegister: " +
"rethrowing <"+e+">, but keeping the MBean registered");
throw new RuntimeMBeanException(e,
"RuntimeException thrown in postRegister method: "+
"rethrowing <"+e+">, but keeping the MBean registered");
} catch (Error er) {
MBEANSERVER_LOGGER.fine("While registering MBean ["+logicalName+
MBEANSERVER_LOGGER.log(Level.DEBUG, "While registering MBean ["+logicalName+
"]: " + "Error thrown by postRegister: " +
"rethrowing <"+er+">, but keeping the MBean registered");
throw new RuntimeErrorException(er,
@ -1053,7 +1042,7 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
try {
moi.postDeregister();
} catch (RuntimeException e) {
MBEANSERVER_LOGGER.fine("While unregistering MBean ["+mbean+
MBEANSERVER_LOGGER.log(Level.DEBUG, "While unregistering MBean ["+mbean+
"]: " + "Exception thrown by postDeregister: " +
"rethrowing <"+e+">, although the MBean is succesfully " +
"unregistered");
@ -1062,7 +1051,7 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
"rethrowing <"+e+
">, although the MBean is sucessfully unregistered");
} catch (Error er) {
MBEANSERVER_LOGGER.fine("While unregistering MBean ["+mbean+
MBEANSERVER_LOGGER.log(Level.DEBUG, "While unregistering MBean ["+mbean+
"]: " + "Error thrown by postDeregister: " +
"rethrowing <"+er+">, although the MBean is succesfully " +
"unregistered");
@ -1087,10 +1076,9 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
}
DynamicMBean obj = repository.retrieve(name);
if (obj == null) {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"getMBean", name + " : Found no object");
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
name + " : Found no object");
}
throw new InstanceNotFoundException(name.toString());
}
@ -1176,10 +1164,8 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
// ------------------------------
// ------------------------------
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"addNotificationListener", "ObjectName = " + name);
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE, "ObjectName = " + name);
}
DynamicMBean instance = getMBean(name);
@ -1226,10 +1212,8 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
// ----------------
// Add a listener on an MBean
// ----------------
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"addNotificationListener",
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
"ObjectName = " + name + ", Listener = " + listener);
}
server.addNotificationListener(name,(NotificationListener) resource,
@ -1255,10 +1239,8 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
throws InstanceNotFoundException, ListenerNotFoundException {
NotificationListener instance = getListener(listener);
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"removeNotificationListener",
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
"ObjectName = " + name + ", Listener = " + listener);
}
server.removeNotificationListener(name, instance);
@ -1272,10 +1254,8 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
NotificationListener instance = getListener(listener);
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"removeNotificationListener",
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
"ObjectName = " + name + ", Listener = " + listener);
}
server.removeNotificationListener(name, instance, filter, handback);
@ -1313,10 +1293,8 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
boolean removeAll)
throws InstanceNotFoundException, ListenerNotFoundException {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"removeNotificationListener", "ObjectName = " + name);
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE, "ObjectName = " + name);
}
DynamicMBean instance = getMBean(name);
@ -1421,10 +1399,9 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
return classNameClass.isAssignableFrom(resourceClass);
} catch (Exception x) {
/* Could be SecurityException or ClassNotFoundException */
if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
MBEANSERVER_LOGGER.logp(Level.FINEST,
DefaultMBeanServerInterceptor.class.getName(),
"isInstanceOf", "Exception calling isInstanceOf", x);
if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
MBEANSERVER_LOGGER.log(Level.DEBUG,
"Exception calling isInstanceOf", x);
}
return false;
}
@ -1489,10 +1466,8 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
MBeanServerNotification notif = new MBeanServerNotification(
NotifType,MBeanServerDelegate.DELEGATE_NAME,0,name);
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"sendNotification", NotifType + " " + name);
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE, NotifType + " " + name);
}
delegate.sendNotification(notif);
@ -1594,10 +1569,8 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
try {
return getClassName(mbean);
} catch (Exception e) {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
MBEANSERVER_LOGGER.logp(Level.FINEST,
DefaultMBeanServerInterceptor.class.getName(),
"safeGetClassName",
if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
MBEANSERVER_LOGGER.log(Level.DEBUG,
"Exception getting MBean class name", e);
}
return null;
@ -1885,10 +1858,9 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
// ---------------------
// Send create event
// ---------------------
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"addObject", "Send create notification of object " +
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
"Send create notification of object " +
logicalName.getCanonicalName());
}
@ -1926,10 +1898,9 @@ public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
// ---------------------
// Send deletion event
// ---------------------
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
DefaultMBeanServerInterceptor.class.getName(),
"unregisterMBean", "Send delete notification of object " +
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
"Send delete notification of object " +
logicalName.getCanonicalName());
}

43
jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/ClassLoaderRepositorySupport.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2002, 2017, 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
@ -33,7 +33,7 @@ import java.util.Arrays;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.MBeanPermission;
import javax.management.ObjectName;
@ -148,10 +148,9 @@ final class ClassLoaderRepositorySupport
// from javax.management.loading.DefaultLoaderRepository
public final Class<?> loadClassWithout(ClassLoader without, String className)
throws ClassNotFoundException {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
ClassLoaderRepositorySupport.class.getName(),
"loadClassWithout", className + " without " + without);
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
className + " without " + without);
}
// without is null => just behave as loadClass
@ -172,10 +171,9 @@ final class ClassLoaderRepositorySupport
public final Class<?> loadClassBefore(ClassLoader stop, String className)
throws ClassNotFoundException {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
ClassLoaderRepositorySupport.class.getName(),
"loadClassBefore", className + " before " + stop);
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
className + " before " + stop);
}
if (stop == null)
@ -206,10 +204,8 @@ final class ClassLoaderRepositorySupport
continue;
if (cl == stop)
break;
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
ClassLoaderRepositorySupport.class.getName(),
"loadClass", "Trying loader = " + cl);
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE, "Trying loader = " + cl);
}
/* We used to have a special case for "instanceof
MLet" here, where we invoked the method
@ -239,10 +235,9 @@ final class ClassLoaderRepositorySupport
//
List<ClassLoader> excluded = search.get(className);
if ((excluded!= null) && (excluded.contains(aloader))) {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
ClassLoaderRepositorySupport.class.getName(),
"startValidSearch", "Already requested loader = " +
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
"Already requested loader = " +
aloader + " class = " + className);
}
throw new ClassNotFoundException(className);
@ -255,10 +250,8 @@ final class ClassLoaderRepositorySupport
search.put(className, excluded);
}
excluded.add(aloader);
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
ClassLoaderRepositorySupport.class.getName(),
"startValidSearch",
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
"loader = " + aloader + " class = " + className);
}
}
@ -271,10 +264,8 @@ final class ClassLoaderRepositorySupport
List<ClassLoader> excluded = search.get(className);
if (excluded != null) {
excluded.remove(aloader);
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER,
ClassLoaderRepositorySupport.class.getName(),
"stopValidSearch",
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
"loader = " + aloader + " class = " + className);
}
}

14
jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/JmxMBeanServer.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2017, 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
@ -36,7 +36,7 @@ import java.security.PrivilegedAction;
import java.security.PrivilegedExceptionAction;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.Attribute;
import javax.management.AttributeList;
@ -1229,16 +1229,14 @@ public final class JmxMBeanServer
}
});
} catch (SecurityException e) {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
MBEANSERVER_LOGGER.logp(Level.FINEST,
JmxMBeanServer.class.getName(), "initialize",
if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
MBEANSERVER_LOGGER.log(Level.DEBUG,
"Unexpected security exception occurred", e);
}
throw e;
} catch (Exception e) {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
MBEANSERVER_LOGGER.logp(Level.FINEST,
JmxMBeanServer.class.getName(), "initialize",
if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
MBEANSERVER_LOGGER.log(Level.DEBUG,
"Unexpected exception occurred", e);
}
throw new

28
jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/MBeanInstantiator.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2017, 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
@ -40,7 +40,7 @@ import java.security.Permissions;
import java.security.PrivilegedAction;
import java.security.ProtectionDomain;
import java.util.Map;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.InstanceNotFoundException;
import javax.management.MBeanException;
@ -186,19 +186,15 @@ public class MBeanInstantiator {
}
}
} catch (ClassNotFoundException e) {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
MBEANSERVER_LOGGER.logp(Level.FINEST,
MBeanInstantiator.class.getName(),
"findSignatureClasses",
if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
MBEANSERVER_LOGGER.log(Level.DEBUG,
"The parameter class could not be found", e);
}
throw new ReflectionException(e,
"The parameter class could not be found");
} catch (RuntimeException e) {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
MBEANSERVER_LOGGER.logp(Level.FINEST,
MBeanInstantiator.class.getName(),
"findSignatureClasses",
if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
MBEANSERVER_LOGGER.log(Level.DEBUG,
"Unexpected exception", e);
}
throw e;
@ -696,19 +692,15 @@ public class MBeanInstantiator {
tab[i] = Class.forName(signature[i], false, aLoader);
}
} catch (ClassNotFoundException e) {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
MBEANSERVER_LOGGER.logp(Level.FINEST,
MBeanInstantiator.class.getName(),
"findSignatureClasses",
if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
MBEANSERVER_LOGGER.log(Level.DEBUG,
"The parameter class could not be found", e);
}
throw new ReflectionException(e,
"The parameter class could not be found");
} catch (RuntimeException e) {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
MBEANSERVER_LOGGER.logp(Level.FINEST,
MBeanInstantiator.class.getName(),
"findSignatureClasses",
if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
MBEANSERVER_LOGGER.log(Level.DEBUG,
"Unexpected exception", e);
}
throw e;

10
jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/MBeanServerDelegateImpl.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2002, 2006, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2002, 2017, 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
@ -24,7 +24,7 @@
*/
package com.sun.jmx.mbeanserver;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.Attribute;
import javax.management.AttributeList;
@ -244,10 +244,8 @@ final class MBeanServerDelegateImpl
} catch (Exception x) {
// Skip the attribute that couldn't be obtained.
//
if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
MBEANSERVER_LOGGER.logp(Level.FINEST,
MBeanServerDelegateImpl.class.getName(),
"getAttributes",
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE,
"Attribute " + attn[i] + " not found");
}
}

26
jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/Repository.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2017, 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
@ -34,7 +34,7 @@ import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import java.util.Map;
import java.util.Set;
import javax.management.DynamicMBean;
@ -264,7 +264,7 @@ public class Repository {
context.unregistered();
} catch (Exception x) {
// shouldn't come here...
MBEANSERVER_LOGGER.log(Level.FINE,
MBEANSERVER_LOGGER.log(Level.DEBUG,
"Unexpected exception while unregistering "+name,
x);
}
@ -385,9 +385,8 @@ public class Repository {
final RegistrationContext context)
throws InstanceAlreadyExistsException {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER, Repository.class.getName(),
"addMBean", "name = " + name);
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE, "name = " + name);
}
// Extract the domain name.
@ -456,9 +455,8 @@ public class Repository {
* false otherwise.
*/
public boolean contains(ObjectName name) {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER, Repository.class.getName(),
"contains", " name = " + name);
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE, "name = " + name);
}
lock.readLock().lock();
try {
@ -478,9 +476,8 @@ public class Repository {
* null otherwise.
*/
public DynamicMBean retrieve(ObjectName name) {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER, Repository.class.getName(),
"retrieve", "name = " + name);
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE, "name = " + name);
}
// Calls internal retrieve method to get the named object
@ -609,9 +606,8 @@ public class Repository {
throws InstanceNotFoundException {
// Debugging stuff
if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
MBEANSERVER_LOGGER.logp(Level.FINER, Repository.class.getName(),
"remove", "name = " + name);
if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
MBEANSERVER_LOGGER.log(Level.TRACE, "name = " + name);
}
// Extract domain name.

160
jdk/src/java.management/share/classes/com/sun/jmx/remote/util/ClassLogger.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2017, 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
@ -25,222 +25,188 @@
package com.sun.jmx.remote.util;
import java.util.logging.Logger;
import java.lang.System.Logger;
import java.lang.System.Logger.Level;
import java.util.ResourceBundle;
public class ClassLogger {
public class ClassLogger implements System.Logger {
private static final boolean ok;
private final String className;
private final Logger logger;
static {
/* We attempt to work even if we are running in J2SE 1.3, where
there is no java.util.logging. The technique we use here is
not strictly portable, but it does work with Sun's J2SE 1.3
at least. This is just a best effort: the Right Thing is for
people to use at least J2SE 1.4. */
boolean loaded = false;
try {
Class<?> c = java.util.logging.Logger.class;
loaded = true;
} catch (Error e) {
// OK.
// java.util.logger package is not available in this jvm.
}
ok = loaded;
}
public ClassLogger(String subsystem, String className) {
if (ok)
logger = Logger.getLogger(subsystem);
else
logger = null;
logger = System.getLogger(subsystem);
this.className = className;
}
public final boolean traceOn() {
return finerOn();
return logger.isLoggable(Level.TRACE);
}
public final boolean debugOn() {
return finestOn();
return logger.isLoggable(Level.DEBUG);
}
public final boolean warningOn() {
return ok && logger.isLoggable(java.util.logging.Level.WARNING);
return logger.isLoggable(Level.WARNING);
}
public final boolean infoOn() {
return ok && logger.isLoggable(java.util.logging.Level.INFO);
return logger.isLoggable(Level.INFO);
}
public final boolean configOn() {
return ok && logger.isLoggable(java.util.logging.Level.CONFIG);
return logger.isLoggable(Level.DEBUG);
}
public final boolean fineOn() {
return ok && logger.isLoggable(java.util.logging.Level.FINE);
return logger.isLoggable(Level.DEBUG);
}
public final boolean finerOn() {
return ok && logger.isLoggable(java.util.logging.Level.FINER);
return logger.isLoggable(Level.TRACE);
}
public final boolean finestOn() {
return ok && logger.isLoggable(java.util.logging.Level.FINEST);
return logger.isLoggable(Level.TRACE);
}
public final void debug(String func, String msg) {
finest(func,msg);
logger.log(Level.DEBUG, msg);
}
public final void debug(String func, Throwable t) {
finest(func,t);
logger.log(Level.DEBUG, className + "::" + func, t);
}
public final void debug(String func, String msg, Throwable t) {
finest(func,msg,t);
logger.log(Level.DEBUG, msg, t);
}
public final void trace(String func, String msg) {
finer(func,msg);
logger.log(Level.TRACE, msg);
}
public final void trace(String func, Throwable t) {
finer(func,t);
logger.log(Level.TRACE, className + "::" + func, t);
}
public final void trace(String func, String msg, Throwable t) {
finer(func,msg,t);
logger.log(Level.TRACE, msg, t);
}
public final void error(String func, String msg) {
severe(func,msg);
logger.log(Level.ERROR, msg);
}
public final void error(String func, Throwable t) {
severe(func,t);
logger.log(Level.ERROR, className + "::" + func, t);
}
public final void error(String func, String msg, Throwable t) {
severe(func,msg,t);
logger.log(Level.ERROR, msg, t);
}
public final void finest(String func, String msg) {
if (ok)
logger.logp(java.util.logging.Level.FINEST, className, func, msg);
logger.log(Level.TRACE, msg);
}
public final void finest(String func, Throwable t) {
if (ok)
logger.logp(java.util.logging.Level.FINEST, className, func,
t.toString(), t);
logger.log(Level.TRACE, className + "::" + func, t);
}
public final void finest(String func, String msg, Throwable t) {
if (ok)
logger.logp(java.util.logging.Level.FINEST, className, func, msg,
t);
logger.log(Level.TRACE, msg, t);
}
public final void finer(String func, String msg) {
if (ok)
logger.logp(java.util.logging.Level.FINER, className, func, msg);
logger.log(Level.TRACE, msg);
}
public final void finer(String func, Throwable t) {
if (ok)
logger.logp(java.util.logging.Level.FINER, className, func,
t.toString(), t);
logger.log(Level.TRACE, className + "::" + func, t);
}
public final void finer(String func, String msg, Throwable t) {
if (ok)
logger.logp(java.util.logging.Level.FINER, className, func, msg,t);
logger.log(Level.DEBUG, msg, t);
}
public final void fine(String func, String msg) {
if (ok)
logger.logp(java.util.logging.Level.FINE, className, func, msg);
logger.log(Level.DEBUG, msg);
}
public final void fine(String func, Throwable t) {
if (ok)
logger.logp(java.util.logging.Level.FINE, className, func,
t.toString(), t);
logger.log(Level.DEBUG, className + "::" + func, t);
}
public final void fine(String func, String msg, Throwable t) {
if (ok)
logger.logp(java.util.logging.Level.FINE, className, func, msg,
t);
logger.log(Level.DEBUG, msg, t);
}
public final void config(String func, String msg) {
if (ok)
logger.logp(java.util.logging.Level.CONFIG, className, func, msg);
logger.log(Level.DEBUG, msg);
}
public final void config(String func, Throwable t) {
if (ok)
logger.logp(java.util.logging.Level.CONFIG, className, func,
t.toString(), t);
logger.log(Level.DEBUG, className + "::" + func, t);
}
public final void config(String func, String msg, Throwable t) {
if (ok)
logger.logp(java.util.logging.Level.CONFIG, className, func, msg,
t);
logger.log(Level.DEBUG, msg, t);
}
public final void info(String func, String msg) {
if (ok)
logger.logp(java.util.logging.Level.INFO, className, func, msg);
logger.log(Level.INFO, msg);
}
public final void info(String func, Throwable t) {
if (ok)
logger.logp(java.util.logging.Level.INFO, className, func,
t.toString(), t);
logger.log(Level.INFO, className + "::" + func, t);
}
public final void info(String func, String msg, Throwable t) {
if (ok)
logger.logp(java.util.logging.Level.INFO, className, func, msg,
t);
logger.log(Level.INFO, msg, t);
}
public final void warning(String func, String msg) {
if (ok)
logger.logp(java.util.logging.Level.WARNING, className, func, msg);
logger.log(Level.WARNING, msg);
}
public final void warning(String func, Throwable t) {
if (ok)
logger.logp(java.util.logging.Level.WARNING, className, func,
t.toString(), t);
logger.log(Level.WARNING, className + "::" + func, t);
}
public final void warning(String func, String msg, Throwable t) {
if (ok)
logger.logp(java.util.logging.Level.WARNING, className, func, msg,
t);
logger.log(Level.WARNING, msg, t);
}
public final void severe(String func, String msg) {
if (ok)
logger.logp(java.util.logging.Level.SEVERE, className, func, msg);
logger.log(Level.ERROR, msg);
}
public final void severe(String func, Throwable t) {
if (ok)
logger.logp(java.util.logging.Level.SEVERE, className, func,
t.toString(), t);
logger.log(Level.ERROR, className + "::" + func, t);
}
public final void severe(String func, String msg, Throwable t) {
if (ok)
logger.logp(java.util.logging.Level.SEVERE, className, func, msg,
t);
logger.log(Level.ERROR, msg, t);
}
public final String getName() {
return logger.getName();
}
public final boolean isLoggable(Level level) {
return logger.isLoggable(level);
}
public final void log(Level level, ResourceBundle bundle, String msg,
Throwable thrown) {
logger.log(level, bundle, msg, thrown);
}
public final void log(Level level, ResourceBundle bundle, String format,
Object... params) {
logger.log(level, bundle, format, params);
}
}

6
jdk/src/java.management/share/classes/javax/management/MBeanServerDelegate.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2017, 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
@ -25,6 +25,7 @@
package javax.management;
import java.lang.System.Logger.Level;
import com.sun.jmx.defaults.JmxProperties;
import com.sun.jmx.defaults.ServiceName;
import com.sun.jmx.mbeanserver.Util;
@ -84,7 +85,8 @@ public class MBeanServerDelegate implements MBeanServerDelegateMBean,
try {
localHost = java.net.InetAddress.getLocalHost().getHostName();
} catch (java.net.UnknownHostException e) {
JmxProperties.MISC_LOGGER.finest("Can't get local host name, " +
JmxProperties.MISC_LOGGER.log(Level.TRACE,
"Can't get local host name, " +
"using \"localhost\" instead. Cause is: "+e);
localHost = "localhost";
}

17
jdk/src/java.management/share/classes/javax/management/MBeanServerFactory.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2017, 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
@ -32,7 +32,7 @@ import com.sun.jmx.mbeanserver.GetPropertyAction;
import java.security.AccessController;
import java.security.Permission;
import java.util.ArrayList;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.loading.ClassLoaderRepository;
import sun.reflect.misc.ReflectUtil;
@ -399,7 +399,7 @@ public class MBeanServerFactory {
return (String) mbs.getAttribute(MBeanServerDelegate.DELEGATE_NAME,
"MBeanServerId");
} catch (JMException e) {
JmxProperties.MISC_LOGGER.finest(
JmxProperties.MISC_LOGGER.log(Level.TRACE,
"Ignoring exception while getting MBeanServerId: "+e);
return null;
}
@ -421,9 +421,7 @@ public class MBeanServerFactory {
private static synchronized void removeMBeanServer(MBeanServer mbs) {
boolean removed = mBeanServerList.remove(mbs);
if (!removed) {
MBEANSERVER_LOGGER.logp(Level.FINER,
MBeanServerFactory.class.getName(),
"removeMBeanServer(MBeanServer)",
MBEANSERVER_LOGGER.log(Level.TRACE,
"MBeanServer was not in list!");
throw new IllegalArgumentException("MBeanServer was not in list!");
}
@ -504,15 +502,12 @@ public class MBeanServerFactory {
throw new JMRuntimeException(msg, x);
}
} catch (RuntimeException x) {
if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
StringBuilder strb = new StringBuilder()
.append("Failed to instantiate MBeanServerBuilder: ").append(x)
.append("\n\t\tCheck the value of the ")
.append(JMX_INITIAL_BUILDER).append(" property.");
MBEANSERVER_LOGGER.logp(Level.FINEST,
MBeanServerFactory.class.getName(),
"checkMBeanServerBuilder",
strb.toString());
MBEANSERVER_LOGGER.log(Level.DEBUG, strb::toString);
}
throw x;
}

19
jdk/src/java.management/share/classes/javax/management/StandardMBean.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2002, 2008, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2002, 2017, 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
@ -38,7 +38,7 @@ import java.security.PrivilegedAction;
import java.util.HashMap;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.openmbean.OpenMBeanAttributeInfo;
import javax.management.openmbean.OpenMBeanAttributeInfoSupport;
import javax.management.openmbean.OpenMBeanConstructorInfo;
@ -432,16 +432,14 @@ public class StandardMBean implements DynamicMBean, MBeanRegistration {
final MBeanInfo cached = getCachedMBeanInfo();
if (cached != null) return cached;
} catch (RuntimeException x) {
if (MISC_LOGGER.isLoggable(Level.FINEST)) {
MISC_LOGGER.logp(Level.FINEST,
MBeanServerFactory.class.getName(), "getMBeanInfo",
if (MISC_LOGGER.isLoggable(Level.DEBUG)) {
MISC_LOGGER.log(Level.DEBUG,
"Failed to get cached MBeanInfo", x);
}
}
if (MISC_LOGGER.isLoggable(Level.FINER)) {
MISC_LOGGER.logp(Level.FINER,
MBeanServerFactory.class.getName(), "getMBeanInfo",
if (MISC_LOGGER.isLoggable(Level.TRACE)) {
MISC_LOGGER.log(Level.TRACE,
"Building MBeanInfo for " +
getImplementationClass().getName());
}
@ -465,9 +463,8 @@ public class StandardMBean implements DynamicMBean, MBeanRegistration {
try {
cacheMBeanInfo(nmbi);
} catch (RuntimeException x) {
if (MISC_LOGGER.isLoggable(Level.FINEST)) {
MISC_LOGGER.logp(Level.FINEST,
MBeanServerFactory.class.getName(), "getMBeanInfo",
if (MISC_LOGGER.isLoggable(Level.DEBUG)) {
MISC_LOGGER.log(Level.DEBUG,
"Failed to cache MBeanInfo", x);
}
}

12
jdk/src/java.management/share/classes/javax/management/loading/DefaultLoaderRepository.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2008, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2017, 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
@ -28,7 +28,7 @@ package javax.management.loading;
import static com.sun.jmx.defaults.JmxProperties.MBEANSERVER_LOGGER;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.MBeanServer;
import javax.management.MBeanServerFactory;
@ -71,9 +71,7 @@ public class DefaultLoaderRepository {
*/
public static Class<?> loadClass(String className)
throws ClassNotFoundException {
MBEANSERVER_LOGGER.logp(Level.FINEST,
DefaultLoaderRepository.class.getName(),
"loadClass", className);
MBEANSERVER_LOGGER.log(Level.TRACE, className);
return load(null, className);
}
@ -96,9 +94,7 @@ public class DefaultLoaderRepository {
public static Class<?> loadClassWithout(ClassLoader loader,
String className)
throws ClassNotFoundException {
MBEANSERVER_LOGGER.logp(Level.FINEST,
DefaultLoaderRepository.class.getName(),
"loadClassWithout", className);
MBEANSERVER_LOGGER.log(Level.TRACE, className);
return load(loader, className);
}

167
jdk/src/java.management/share/classes/javax/management/loading/MLet.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2017, 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
@ -52,7 +52,7 @@ import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
@ -412,9 +412,8 @@ public class MLet extends java.net.URLClassLoader
if (!Arrays.asList(getURLs()).contains(ur))
super.addURL(ur);
} catch (MalformedURLException e) {
if (MLET_LOGGER.isLoggable(Level.FINEST)) {
MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
"addUrl", "Malformed URL: " + url, e);
if (MLET_LOGGER.isLoggable(Level.DEBUG)) {
MLET_LOGGER.log(Level.DEBUG, "Malformed URL: " + url, e);
}
throw new
ServiceNotFoundException("The specified URL is malformed");
@ -481,23 +480,19 @@ public class MLet extends java.net.URLClassLoader
public Set<Object> getMBeansFromURL(String url)
throws ServiceNotFoundException {
String mth = "getMBeansFromURL";
if (server == null) {
throw new IllegalStateException("This MLet MBean is not " +
"registered with an MBeanServer.");
}
// Parse arguments
if (url == null) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
mth, "URL is null");
MLET_LOGGER.log(Level.TRACE, "URL is null");
throw new ServiceNotFoundException("The specified URL is null");
} else {
url = url.replace(File.separatorChar,'/');
}
if (MLET_LOGGER.isLoggable(Level.FINER)) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
mth, "<URL = " + url + ">");
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
MLET_LOGGER.log(Level.TRACE, "<URL = " + url + ">");
}
// Parse URL
@ -508,7 +503,7 @@ public class MLet extends java.net.URLClassLoader
final String msg =
"Problems while parsing URL [" + url +
"], got exception [" + e.toString() + "]";
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth, msg);
MLET_LOGGER.log(Level.TRACE, msg);
throw EnvHelp.initCause(new ServiceNotFoundException(msg), e);
}
@ -516,7 +511,7 @@ public class MLet extends java.net.URLClassLoader
if (mletList.size() == 0) {
final String msg =
"File " + url + " not found or MLET tag not defined in file";
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth, msg);
MLET_LOGGER.log(Level.TRACE, msg);
throw new ServiceNotFoundException(msg);
}
@ -538,7 +533,7 @@ public class MLet extends java.net.URLClassLoader
URL documentBase = elmt.getDocumentBase();
// Display debug information
if (MLET_LOGGER.isLoggable(Level.FINER)) {
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
final StringBuilder strb = new StringBuilder()
.append("\n\tMLET TAG = ").append(elmt.getAttributes())
.append("\n\tCODEBASE = ").append(codebase)
@ -548,16 +543,15 @@ public class MLet extends java.net.URLClassLoader
.append("\n\tNAME = ").append(name)
.append("\n\tVERSION = ").append(version)
.append("\n\tDOCUMENT URL = ").append(documentBase);
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
mth, strb.toString());
MLET_LOGGER.log(Level.TRACE, strb::toString);
}
// Load classes from JAR files
StringTokenizer st = new StringTokenizer(jarFiles, ",", false);
while (st.hasMoreTokens()) {
String tok = st.nextToken().trim();
if (MLET_LOGGER.isLoggable(Level.FINER)) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
MLET_LOGGER.log(Level.TRACE,
"Load archive for codebase <" + codebase +
">, file <" + tok + ">");
}
@ -570,8 +564,8 @@ public class MLet extends java.net.URLClassLoader
try {
codebase = check(version, codebase, tok, elmt);
} catch (Exception ex) {
MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
mth, "Got unexpected exception", ex);
MLET_LOGGER.log(Level.DEBUG,
"Got unexpected exception", ex);
mbeans.add(ex);
continue;
}
@ -599,7 +593,7 @@ public class MLet extends java.net.URLClassLoader
final String msg =
"CODE and OBJECT parameters cannot be specified at the " +
"same time in tag MLET";
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth, msg);
MLET_LOGGER.log(Level.TRACE, msg);
mbeans.add(new Error(msg));
continue;
}
@ -607,7 +601,7 @@ public class MLet extends java.net.URLClassLoader
final String msg =
"Either CODE or OBJECT parameter must be specified in " +
"tag MLET";
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth, msg);
MLET_LOGGER.log(Level.TRACE, msg);
mbeans.add(new Error(msg));
continue;
}
@ -635,7 +629,7 @@ public class MLet extends java.net.URLClassLoader
Object[] parms = objectPars.toArray();
String[] signature = new String[signat.size()];
signat.toArray(signature);
if (MLET_LOGGER.isLoggable(Level.FINEST)) {
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
final StringBuilder strb = new StringBuilder();
for (int i = 0; i < signature.length; i++) {
strb.append("\n\tSignature = ")
@ -643,9 +637,7 @@ public class MLet extends java.net.URLClassLoader
.append("\t\nParams = ")
.append(parms[i]);
}
MLET_LOGGER.logp(Level.FINEST,
MLet.class.getName(),
mth, strb.toString());
MLET_LOGGER.log(Level.TRACE, strb::toString);
}
if (name == null) {
objInst =
@ -668,53 +660,46 @@ public class MLet extends java.net.URLClassLoader
objInst = new ObjectInstance(name, o.getClass().getName());
}
} catch (ReflectionException ex) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
"ReflectionException", ex);
MLET_LOGGER.log(Level.TRACE, "ReflectionException", ex);
mbeans.add(ex);
continue;
} catch (InstanceAlreadyExistsException ex) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
MLET_LOGGER.log(Level.TRACE,
"InstanceAlreadyExistsException", ex);
mbeans.add(ex);
continue;
} catch (MBeanRegistrationException ex) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
"MBeanRegistrationException", ex);
MLET_LOGGER.log(Level.TRACE, "MBeanRegistrationException", ex);
mbeans.add(ex);
continue;
} catch (MBeanException ex) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
"MBeanException", ex);
MLET_LOGGER.log(Level.TRACE, "MBeanException", ex);
mbeans.add(ex);
continue;
} catch (NotCompliantMBeanException ex) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
MLET_LOGGER.log(Level.TRACE,
"NotCompliantMBeanException", ex);
mbeans.add(ex);
continue;
} catch (InstanceNotFoundException ex) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
MLET_LOGGER.log(Level.TRACE,
"InstanceNotFoundException", ex);
mbeans.add(ex);
continue;
} catch (IOException ex) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
"IOException", ex);
MLET_LOGGER.log(Level.TRACE, "IOException", ex);
mbeans.add(ex);
continue;
} catch (SecurityException ex) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
"SecurityException", ex);
MLET_LOGGER.log(Level.TRACE, "SecurityException", ex);
mbeans.add(ex);
continue;
} catch (Exception ex) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
"Exception", ex);
MLET_LOGGER.log(Level.TRACE, "Exception", ex);
mbeans.add(ex);
continue;
} catch (Error ex) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
"Error", ex);
MLET_LOGGER.log(Level.TRACE, "Error", ex);
mbeans.add(ex);
continue;
}
@ -937,20 +922,18 @@ public class MLet extends java.net.URLClassLoader
Class<?> findClass(String name, ClassLoaderRepository clr)
throws ClassNotFoundException {
Class<?> c = null;
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), "findClass", name);
MLET_LOGGER.log(Level.TRACE, name);
// Try looking in the JAR:
try {
c = super.findClass(name);
if (MLET_LOGGER.isLoggable(Level.FINER)) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
"findClass",
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
MLET_LOGGER.log(Level.TRACE,
"Class " + name + " loaded through MLet classloader");
}
} catch (ClassNotFoundException e) {
// Drop through
if (MLET_LOGGER.isLoggable(Level.FINEST)) {
MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
"findClass",
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
MLET_LOGGER.log(Level.TRACE,
"Class " + name + " not found locally");
}
}
@ -959,32 +942,28 @@ public class MLet extends java.net.URLClassLoader
// Try the classloader repository:
//
try {
if (MLET_LOGGER.isLoggable(Level.FINEST)) {
MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
"findClass",
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
MLET_LOGGER.log(Level.TRACE,
"Class " + name + " : looking in CLR");
}
c = clr.loadClassBefore(this, name);
// The loadClassBefore method never returns null.
// If the class is not found we get an exception.
if (MLET_LOGGER.isLoggable(Level.FINER)) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
"findClass",
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
MLET_LOGGER.log(Level.TRACE,
"Class " + name + " loaded through " +
"the default classloader repository");
}
} catch (ClassNotFoundException e) {
// Drop through
if (MLET_LOGGER.isLoggable(Level.FINEST)) {
MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
"findClass",
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
MLET_LOGGER.log(Level.TRACE,
"Class " + name + " not found in CLR");
}
}
}
if (c == null) {
MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
"findClass", "Failed to load class " + name);
MLET_LOGGER.log(Level.TRACE, "Failed to load class " + name);
throw new ClassNotFoundException(name);
}
return c;
@ -1041,8 +1020,8 @@ public class MLet extends java.net.URLClassLoader
//
// See if the native library is accessible as a resource through the JAR file.
//
if (MLET_LOGGER.isLoggable(Level.FINER)) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
MLET_LOGGER.log(Level.TRACE,
"Search " + libname + " in all JAR files");
}
@ -1051,14 +1030,14 @@ public class MLet extends java.net.URLClassLoader
// for "foo" on Solaris SPARC 5.7 we try to load "libfoo.so"
// from the JAR file.
//
if (MLET_LOGGER.isLoggable(Level.FINER)) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
MLET_LOGGER.log(Level.TRACE,
"loadLibraryAsResource(" + nativelibname + ")");
}
abs_path = loadLibraryAsResource(nativelibname);
if (abs_path != null) {
if (MLET_LOGGER.isLoggable(Level.FINER)) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
MLET_LOGGER.log(Level.TRACE,
nativelibname + " loaded, absolute path = " + abs_path);
}
return abs_path;
@ -1073,15 +1052,15 @@ public class MLet extends java.net.URLClassLoader
removeSpace(System.getProperty("os.arch")) + File.separator +
removeSpace(System.getProperty("os.version")) + File.separator +
"lib" + File.separator + nativelibname;
if (MLET_LOGGER.isLoggable(Level.FINER)) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
MLET_LOGGER.log(Level.TRACE,
"loadLibraryAsResource(" + nativelibname + ")");
}
abs_path = loadLibraryAsResource(nativelibname);
if (abs_path != null) {
if (MLET_LOGGER.isLoggable(Level.FINER)) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
MLET_LOGGER.log(Level.TRACE,
nativelibname + " loaded, absolute path = " + abs_path);
}
return abs_path;
@ -1091,10 +1070,10 @@ public class MLet extends java.net.URLClassLoader
// All paths exhausted, library not found in JAR file.
//
if (MLET_LOGGER.isLoggable(Level.FINER)) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
MLET_LOGGER.log(Level.TRACE,
libname + " not found in any JAR file");
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
MLET_LOGGER.log(Level.TRACE,
"Search " + libname + " along the path " +
"specified as the java.library.path property");
}
@ -1127,8 +1106,8 @@ public class MLet extends java.net.URLClassLoader
if (tmpDirFile == null) return null;
return tmpDirFile.getAbsolutePath();
} catch (Exception x) {
MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
"getTmpDir", "Failed to determine system temporary dir");
MLET_LOGGER.log(Level.DEBUG,
"Failed to determine system temporary dir");
return null;
} finally {
// Cleanup ...
@ -1136,12 +1115,12 @@ public class MLet extends java.net.URLClassLoader
try {
boolean deleted = tmpFile.delete();
if (!deleted) {
MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
"getTmpDir", "Failed to delete temp file");
MLET_LOGGER.log(Level.DEBUG,
"Failed to delete temp file");
}
} catch (Exception x) {
MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
"getTmpDir", "Failed to delete temporary file", x);
MLET_LOGGER.log(Level.DEBUG,
"Failed to delete temporary file", x);
}
}
}
@ -1183,8 +1162,7 @@ public class MLet extends java.net.URLClassLoader
}
}
} catch (Exception e) {
MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
"loadLibraryAsResource",
MLET_LOGGER.log(Level.DEBUG,
"Failed to load library : " + libname, e);
return null;
}
@ -1248,9 +1226,8 @@ public class MLet extends java.net.URLClassLoader
if (filename != null) {
filename = filename.replace(File.separatorChar,'/');
}
if (MLET_LOGGER.isLoggable(Level.FINER)) {
MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
"loadSerializedObject", codebase.toString() + filename);
if (MLET_LOGGER.isLoggable(Level.TRACE)) {
MLET_LOGGER.log(Level.TRACE, codebase.toString() + filename);
}
InputStream is = getResourceAsStream(filename);
if (is != null) {
@ -1260,24 +1237,21 @@ public class MLet extends java.net.URLClassLoader
ois.close();
return serObject;
} catch (IOException e) {
if (MLET_LOGGER.isLoggable(Level.FINEST)) {
MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
"loadSerializedObject",
if (MLET_LOGGER.isLoggable(Level.DEBUG)) {
MLET_LOGGER.log(Level.DEBUG,
"Exception while deserializing " + filename, e);
}
throw e;
} catch (ClassNotFoundException e) {
if (MLET_LOGGER.isLoggable(Level.FINEST)) {
MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
"loadSerializedObject",
if (MLET_LOGGER.isLoggable(Level.DEBUG)) {
MLET_LOGGER.log(Level.DEBUG,
"Exception while deserializing " + filename, e);
}
throw e;
}
} else {
if (MLET_LOGGER.isLoggable(Level.FINEST)) {
MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
"loadSerializedObject", "Error: File " + filename +
if (MLET_LOGGER.isLoggable(Level.DEBUG)) {
MLET_LOGGER.log(Level.DEBUG, "Error: File " + filename +
" containing serialized object not found");
}
throw new Error("File " + filename + " containing serialized object not found");
@ -1300,8 +1274,7 @@ public class MLet extends java.net.URLClassLoader
return(cons.newInstance(oo));
} catch (Exception e) {
MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
"constructParameter", "Got unexpected exception", e);
MLET_LOGGER.log(Level.DEBUG, "Got unexpected exception", e);
}
}
if (type.compareTo("java.lang.Boolean") == 0)

29
jdk/src/java.management/share/classes/javax/management/loading/MLetParser.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2017, 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
@ -39,7 +39,7 @@ import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
/**
* This class is used for parsing URLs.
@ -153,7 +153,6 @@ class MLetParser {
* Scan an html file for {@literal <mlet>} tags.
*/
public List<MLetContent> parse(URL url) throws IOException {
String mth = "parse";
// Warning Messages
String requiresTypeWarning = "<arg type=... value=...> tag requires type parameter.";
String requiresValueWarning = "<arg type=... value=...> tag requires value parameter.";
@ -204,33 +203,25 @@ class MLetParser {
Map<String,String> t = scanTag(in);
String att = t.get("type");
if (att == null) {
MLET_LOGGER.logp(Level.FINER,
MLetParser.class.getName(),
mth, requiresTypeWarning);
MLET_LOGGER.log(Level.TRACE, requiresTypeWarning);
throw new IOException(requiresTypeWarning);
} else {
if (atts != null) {
types.add(att);
} else {
MLET_LOGGER.logp(Level.FINER,
MLetParser.class.getName(),
mth, paramOutsideWarning);
MLET_LOGGER.log(Level.TRACE, paramOutsideWarning);
throw new IOException(paramOutsideWarning);
}
}
String val = t.get("value");
if (val == null) {
MLET_LOGGER.logp(Level.FINER,
MLetParser.class.getName(),
mth, requiresValueWarning);
MLET_LOGGER.log(Level.TRACE, requiresValueWarning);
throw new IOException(requiresValueWarning);
} else {
if (atts != null) {
values.add(val);
} else {
MLET_LOGGER.logp(Level.FINER,
MLetParser.class.getName(),
mth, paramOutsideWarning);
MLET_LOGGER.log(Level.TRACE, paramOutsideWarning);
throw new IOException(paramOutsideWarning);
}
}
@ -238,15 +229,11 @@ class MLetParser {
if (nm.equalsIgnoreCase(tag)) {
atts = scanTag(in);
if (atts.get("code") == null && atts.get("object") == null) {
MLET_LOGGER.logp(Level.FINER,
MLetParser.class.getName(),
mth, requiresCodeWarning);
MLET_LOGGER.log(Level.TRACE, requiresCodeWarning);
throw new IOException(requiresCodeWarning);
}
if (atts.get("archive") == null) {
MLET_LOGGER.logp(Level.FINER,
MLetParser.class.getName(),
mth, requiresJarsWarning);
MLET_LOGGER.log(Level.TRACE, requiresJarsWarning);
throw new IOException(requiresJarsWarning);
}
}

282
jdk/src/java.management/share/classes/javax/management/modelmbean/DescriptorSupport.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2017, 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
@ -51,7 +51,7 @@ import java.util.Set;
import java.util.SortedMap;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.Descriptor;
import javax.management.ImmutableDescriptor;
@ -164,10 +164,8 @@ public class DescriptorSupport
* (the method {@link #isValid isValid} returns <CODE>false</CODE>)
*/
public DescriptorSupport() {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"DescriptorSupport()" , "Constructor");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Constructor");
}
init(null);
}
@ -188,17 +186,14 @@ public class DescriptorSupport
*/
public DescriptorSupport(int initNumFields)
throws MBeanException, RuntimeOperationsException {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"Descriptor(initNumFields = " + initNumFields + ")",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Descriptor(initNumFields = " + initNumFields + ") " +
"Constructor");
}
if (initNumFields <= 0) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"Descriptor(initNumFields)",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Illegal arguments: initNumFields <= 0");
}
final String msg =
@ -219,10 +214,9 @@ public class DescriptorSupport
* fields, an empty Descriptor will be created.
*/
public DescriptorSupport(DescriptorSupport inDescr) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"Descriptor(Descriptor)", "Constructor");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Descriptor(Descriptor) Constructor");
}
if (inDescr == null)
init(null);
@ -268,16 +262,14 @@ public class DescriptorSupport
XMLParseException {
/* parse an XML-formatted string and populate internal
* structure with it */
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"Descriptor(String = '" + inStr + "')", "Constructor");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Descriptor(String = '" + inStr + "') Constructor");
}
if (inStr == null) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"Descriptor(String = null)", "Illegal arguments");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Descriptor(String = null) Illegal arguments");
}
final String msg = "String in parameter is null";
final RuntimeException iae = new IllegalArgumentException(msg);
@ -350,10 +342,9 @@ public class DescriptorSupport
}
}
} // while tokens
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"Descriptor(XMLString)", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Descriptor(XMLString) Exit");
}
}
@ -380,19 +371,17 @@ public class DescriptorSupport
*/
public DescriptorSupport(String[] fieldNames, Object[] fieldValues)
throws RuntimeOperationsException {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"Descriptor(fieldNames,fieldObjects)", "Constructor");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Descriptor(fieldNames,fieldObjects) Constructor");
}
if ((fieldNames == null) || (fieldValues == null) ||
(fieldNames.length != fieldValues.length)) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"Descriptor(fieldNames,fieldObjects)",
"Illegal arguments");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Descriptor(fieldNames,fieldObjects)" +
" Illegal arguments");
}
final String msg =
@ -408,10 +397,9 @@ public class DescriptorSupport
// the fieldName and fieldValue will be validated in setField.
setField(fieldNames[i], fieldValues[i]);
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"Descriptor(fieldNames,fieldObjects)", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Descriptor(fieldNames,fieldObjects) Exit");
}
}
@ -444,10 +432,9 @@ public class DescriptorSupport
*/
public DescriptorSupport(String... fields)
{
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"Descriptor(String... fields)", "Constructor");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Descriptor(String... fields) Constructor");
}
init(null);
if (( fields == null ) || ( fields.length == 0))
@ -462,10 +449,9 @@ public class DescriptorSupport
int eq_separator = fields[i].indexOf('=');
if (eq_separator < 0) {
// illegal if no = or is first character
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"Descriptor(String... fields)",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Descriptor(String... fields) " +
"Illegal arguments: field does not have " +
"'=' as a name and value separator");
}
@ -482,10 +468,9 @@ public class DescriptorSupport
}
if (fieldName.equals("")) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"Descriptor(String... fields)",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Descriptor(String... fields) " +
"Illegal arguments: fieldName is empty");
}
@ -496,10 +481,9 @@ public class DescriptorSupport
setField(fieldName,fieldValue);
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"Descriptor(String... fields)", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Descriptor(String... fields) Exit");
}
}
@ -517,10 +501,8 @@ public class DescriptorSupport
throws RuntimeOperationsException {
if ((fieldName == null) || (fieldName.equals(""))) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"getFieldValue(String fieldName)",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Illegal arguments: null field name");
}
final String msg = "Fieldname requested is null";
@ -528,10 +510,9 @@ public class DescriptorSupport
throw new RuntimeOperationsException(iae, msg);
}
Object retValue = descriptorMap.get(fieldName);
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"getFieldValue(String fieldName = " + fieldName + ")",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"getFieldValue(String fieldName = " + fieldName + ") " +
"Returns '" + retValue + "'");
}
return(retValue);
@ -542,10 +523,8 @@ public class DescriptorSupport
// field name cannot be null or empty
if ((fieldName == null) || (fieldName.equals(""))) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"setField(fieldName,fieldValue)",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Illegal arguments: null or empty field name");
}
@ -555,10 +534,8 @@ public class DescriptorSupport
}
if (!validateField(fieldName, fieldValue)) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"setField(fieldName,fieldValue)",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Illegal arguments");
}
@ -568,10 +545,8 @@ public class DescriptorSupport
throw new RuntimeOperationsException(iae, msg);
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"setField(fieldName,fieldValue)", "Entry: setting '"
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry: setting '"
+ fieldName + "' to '" + fieldValue + "'");
}
@ -582,10 +557,8 @@ public class DescriptorSupport
}
public synchronized String[] getFields() {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"getFields()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
int numberOfEntries = descriptorMap.size();
@ -594,20 +567,18 @@ public class DescriptorSupport
int i = 0;
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"getFields()", "Returning " + numberOfEntries + " fields");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Returning " + numberOfEntries + " fields");
}
for (Iterator<Map.Entry<String, Object>> iter = returnedSet.iterator();
iter.hasNext(); i++) {
Map.Entry<String, Object> currElement = iter.next();
if (currElement == null) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"getFields()", "Element is null");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Element is null");
}
} else {
Object currValue = currElement.getValue();
@ -626,20 +597,16 @@ public class DescriptorSupport
}
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"getFields()", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
}
return responseFields;
}
public synchronized String[] getFieldNames() {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"getFieldNames()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
int numberOfEntries = descriptorMap.size();
@ -648,10 +615,8 @@ public class DescriptorSupport
int i = 0;
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"getFieldNames()",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Returning " + numberOfEntries + " fields");
}
@ -660,20 +625,16 @@ public class DescriptorSupport
Map.Entry<String, Object> currElement = iter.next();
if (( currElement == null ) || (currElement.getKey() == null)) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"getFieldNames()", "Field is null");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Field is null");
}
} else {
responseFields[i] = currElement.getKey().toString();
}
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"getFieldNames()", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
}
return responseFields;
@ -681,10 +642,8 @@ public class DescriptorSupport
public synchronized Object[] getFieldValues(String... fieldNames) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"getFieldValues(String... fieldNames)", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
// if fieldNames == null return all values
// if fieldNames is String[0] return no values
@ -695,10 +654,8 @@ public class DescriptorSupport
int i = 0;
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"getFieldValues(String... fieldNames)",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Returning " + numberOfEntries + " fields");
}
@ -715,10 +672,8 @@ public class DescriptorSupport
}
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"getFieldValues(String... fieldNames)", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
}
return responseFields;
@ -728,18 +683,14 @@ public class DescriptorSupport
Object[] fieldValues)
throws RuntimeOperationsException {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"setFields(fieldNames,fieldValues)", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
if ((fieldNames == null) || (fieldValues == null) ||
(fieldNames.length != fieldValues.length)) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"setFields(fieldNames,fieldValues)",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Illegal arguments");
}
@ -750,10 +701,8 @@ public class DescriptorSupport
for (int i=0; i < fieldNames.length; i++) {
if (( fieldNames[i] == null) || (fieldNames[i].equals(""))) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"setFields(fieldNames,fieldValues)",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Null field name encountered at element " + i);
}
final String msg = "fieldNames is null or invalid";
@ -762,10 +711,8 @@ public class DescriptorSupport
}
setField(fieldNames[i], fieldValues[i]);
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"setFields(fieldNames,fieldValues)", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
}
}
@ -779,10 +726,8 @@ public class DescriptorSupport
@Override
public synchronized Object clone() throws RuntimeOperationsException {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"clone()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
return(new DescriptorSupport(this));
}
@ -898,20 +843,17 @@ public class DescriptorSupport
*/
public synchronized boolean isValid() throws RuntimeOperationsException {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"isValid()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
// verify that the descriptor is valid, by iterating over each field...
Set<Map.Entry<String, Object>> returnedSet = descriptorMap.entrySet();
if (returnedSet == null) { // null descriptor, not valid
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"isValid()", "Returns false (null set)");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"isValid() Returns false (null set)");
}
return false;
}
@ -934,10 +876,8 @@ public class DescriptorSupport
(currElement.getValue()).toString())) {
continue;
} else {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"isValid()",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Field " + currElement.getKey() + "=" +
currElement.getValue() + " is not valid");
}
@ -948,10 +888,9 @@ public class DescriptorSupport
}
// fell through, all fields OK
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"isValid()", "Returns true");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"isValid() Returns true");
}
return true;
}
@ -1287,28 +1226,23 @@ public class DescriptorSupport
*/
@Override
public synchronized String toString() {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"toString()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
String respStr = "";
String[] fields = getFields();
if ((fields == null) || (fields.length == 0)) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"toString()", "Empty Descriptor");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Empty Descriptor");
}
return respStr;
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"toString()", "Printing " + fields.length + " fields");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Printing " + fields.length + " fields");
}
for (int i=0; i < fields.length; i++) {
@ -1319,10 +1253,8 @@ public class DescriptorSupport
}
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
MODELMBEAN_LOGGER.logp(Level.FINEST,
DescriptorSupport.class.getName(),
"toString()", "Exit returning " + respStr);
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Exit returning " + respStr);
}
return respStr;

62
jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanAttributeInfo.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2017, 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
@ -39,7 +39,7 @@ import java.io.ObjectOutputStream;
import java.io.ObjectStreamField;
import java.lang.reflect.Method;
import java.security.AccessController;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.Descriptor;
import javax.management.DescriptorKey;
@ -201,12 +201,11 @@ public class ModelMBeanAttributeInfo
throws javax.management.IntrospectionException {
super(name, description, getter, setter);
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanAttributeInfo.class.getName(),
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanAttributeInfo(" +
"String,String,Method,Method)",
"Entry", name);
"String,String,Method,Method) " +
"Entry " + name);
}
attrDescriptor = validDescriptor(null);
@ -251,12 +250,11 @@ public class ModelMBeanAttributeInfo
super(name, description, getter, setter);
// put getter and setter methods in operations list
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanAttributeInfo.class.getName(),
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanAttributeInfo(" +
"String,String,Method,Method,Descriptor)",
"Entry", name);
"String,String,Method,Method,Descriptor) " +
"Entry " + name);
}
attrDescriptor = validDescriptor(descriptor);
}
@ -282,8 +280,8 @@ public class ModelMBeanAttributeInfo
super(name, type, description, isReadable, isWritable, isIs);
// create default descriptor
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
ModelMBeanAttributeInfo.class.getName(),
"ModelMBeanAttributeInfo(" +
"String,String,String,boolean,boolean,boolean)",
@ -321,12 +319,11 @@ public class ModelMBeanAttributeInfo
Descriptor descriptor)
{
super(name, type, description, isReadable, isWritable, isIs);
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanAttributeInfo.class.getName(),
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanAttributeInfo(String,String,String," +
"boolean,boolean,boolean,Descriptor)",
"Entry", name);
"boolean,boolean,boolean,Descriptor)" +
"Entry " + name);
}
attrDescriptor = validDescriptor(descriptor);
}
@ -347,10 +344,9 @@ public class ModelMBeanAttributeInfo
inInfo.isReadable(),
inInfo.isWritable(),
inInfo.isIs());
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanAttributeInfo.class.getName(),
"ModelMBeanAttributeInfo(ModelMBeanAttributeInfo)",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanAttributeInfo(ModelMBeanAttributeInfo) " +
"Entry");
}
Descriptor newDesc = inInfo.getDescriptor();
@ -368,10 +364,8 @@ public class ModelMBeanAttributeInfo
*/
public Descriptor getDescriptor() {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanAttributeInfo.class.getName(),
"getDescriptor()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
if (attrDescriptor == null) {
attrDescriptor = validDescriptor(null);
@ -411,10 +405,8 @@ public class ModelMBeanAttributeInfo
@Override
public Object clone()
{
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanAttributeInfo.class.getName(),
"clone()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
return(new ModelMBeanAttributeInfo(this));
}
@ -454,7 +446,7 @@ public class ModelMBeanAttributeInfo
boolean defaulted = (in == null);
if (defaulted) {
clone = new DescriptorSupport();
MODELMBEAN_LOGGER.finer("Null Descriptor, creating new.");
MODELMBEAN_LOGGER.log(Level.TRACE, "Null Descriptor, creating new.");
} else {
clone = (Descriptor) in.clone();
}
@ -462,15 +454,15 @@ public class ModelMBeanAttributeInfo
//Setting defaults.
if (defaulted && clone.getFieldValue("name")==null) {
clone.setField("name", this.getName());
MODELMBEAN_LOGGER.finer("Defaulting Descriptor name to " + this.getName());
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor name to " + this.getName());
}
if (defaulted && clone.getFieldValue("descriptorType")==null) {
clone.setField("descriptorType", "attribute");
MODELMBEAN_LOGGER.finer("Defaulting descriptorType to \"attribute\"");
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting descriptorType to \"attribute\"");
}
if (clone.getFieldValue("displayName") == null) {
clone.setField("displayName",this.getName());
MODELMBEAN_LOGGER.finer("Defaulting Descriptor displayName to " + this.getName());
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor displayName to " + this.getName());
}
//Checking validity

73
jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanConstructorInfo.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2017, 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
@ -39,7 +39,7 @@ import java.io.ObjectOutputStream;
import java.io.ObjectStreamField;
import java.lang.reflect.Constructor;
import java.security.AccessController;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.Descriptor;
import javax.management.DescriptorAccess;
@ -164,10 +164,9 @@ public class ModelMBeanConstructorInfo
Constructor<?> constructorMethod)
{
super(description, constructorMethod);
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanConstructorInfo.class.getName(),
"ModelMBeanConstructorInfo(String,Constructor)",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanConstructorInfo(String,Constructor) " +
"Entry");
}
consDescriptor = validDescriptor(null);
@ -209,11 +208,10 @@ public class ModelMBeanConstructorInfo
super(description, constructorMethod);
// put getter and setter methods in constructors list
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanConstructorInfo.class.getName(),
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanConstructorInfo(" +
"String,Constructor,Descriptor)", "Entry");
"String,Constructor,Descriptor) Entry");
}
consDescriptor = validDescriptor(descriptor);
}
@ -232,11 +230,10 @@ public class ModelMBeanConstructorInfo
super(name, description, signature);
// create default descriptor
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanConstructorInfo.class.getName(),
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanConstructorInfo(" +
"String,String,MBeanParameterInfo[])", "Entry");
"String,String,MBeanParameterInfo[]) Entry");
}
consDescriptor = validDescriptor(null);
}
@ -265,11 +262,10 @@ public class ModelMBeanConstructorInfo
Descriptor descriptor)
{
super(name, description, signature);
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanConstructorInfo.class.getName(),
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanConstructorInfo(" +
"String,String,MBeanParameterInfo[],Descriptor)",
"String,String,MBeanParameterInfo[],Descriptor) " +
"Entry");
}
consDescriptor = validDescriptor(descriptor);
@ -284,11 +280,10 @@ public class ModelMBeanConstructorInfo
ModelMBeanConstructorInfo(ModelMBeanConstructorInfo old)
{
super(old.getName(), old.getDescription(), old.getSignature());
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanConstructorInfo.class.getName(),
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanConstructorInfo(" +
"ModelMBeanConstructorInfo)", "Entry");
"ModelMBeanConstructorInfo) Entry");
}
consDescriptor = validDescriptor(consDescriptor);
}
@ -300,10 +295,8 @@ public class ModelMBeanConstructorInfo
@Override
public Object clone ()
{
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanConstructorInfo.class.getName(),
"clone()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
return(new ModelMBeanConstructorInfo(this)) ;
}
@ -321,10 +314,8 @@ public class ModelMBeanConstructorInfo
@Override
public Descriptor getDescriptor()
{
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanConstructorInfo.class.getName(),
"getDescriptor()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
if (consDescriptor == null){
consDescriptor = validDescriptor(null);
@ -356,10 +347,8 @@ public class ModelMBeanConstructorInfo
*/
public void setDescriptor(Descriptor inDescriptor)
{
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanConstructorInfo.class.getName(),
"setDescriptor()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
consDescriptor = validDescriptor(inDescriptor);
}
@ -370,10 +359,8 @@ public class ModelMBeanConstructorInfo
@Override
public String toString()
{
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanConstructorInfo.class.getName(),
"toString()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
String retStr =
"ModelMBeanConstructorInfo: " + this.getName() +
@ -408,7 +395,7 @@ public class ModelMBeanConstructorInfo
boolean defaulted = (in == null);
if (defaulted) {
clone = new DescriptorSupport();
MODELMBEAN_LOGGER.finer("Null Descriptor, creating new.");
MODELMBEAN_LOGGER.log(Level.TRACE, "Null Descriptor, creating new.");
} else {
clone = (Descriptor) in.clone();
}
@ -416,19 +403,19 @@ public class ModelMBeanConstructorInfo
//Setting defaults.
if (defaulted && clone.getFieldValue("name")==null) {
clone.setField("name", this.getName());
MODELMBEAN_LOGGER.finer("Defaulting Descriptor name to " + this.getName());
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor name to " + this.getName());
}
if (defaulted && clone.getFieldValue("descriptorType")==null) {
clone.setField("descriptorType", "operation");
MODELMBEAN_LOGGER.finer("Defaulting descriptorType to \"operation\"");
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting descriptorType to \"operation\"");
}
if (clone.getFieldValue("displayName") == null) {
clone.setField("displayName",this.getName());
MODELMBEAN_LOGGER.finer("Defaulting Descriptor displayName to " + this.getName());
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor displayName to " + this.getName());
}
if (clone.getFieldValue("role") == null) {
clone.setField("role","constructor");
MODELMBEAN_LOGGER.finer("Defaulting Descriptor role field to \"constructor\"");
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor role field to \"constructor\"");
}
//Checking validity

173
jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanInfoSupport.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2008, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2017, 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
@ -38,7 +38,7 @@ import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamField;
import java.security.AccessController;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.Descriptor;
import javax.management.MBeanAttributeInfo;
@ -231,19 +231,16 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
modelMBeanDescriptor = validDescriptor(mbeandescriptor);
} catch (MBeanException mbe) {
modelMBeanDescriptor = validDescriptor(null);
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"ModelMBeanInfo(ModelMBeanInfo)",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanInfo(ModelMBeanInfo) " +
"Could not get a valid modelMBeanDescriptor, " +
"setting a default Descriptor");
}
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"ModelMBeanInfo(ModelMBeanInfo)", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
}
}
@ -330,12 +327,11 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
modelMBeanOperations = operations;
modelMBeanNotifications = notifications;
modelMBeanDescriptor = validDescriptor(mbeandescriptor);
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanInfoSupport(String,String,ModelMBeanAttributeInfo[]," +
"ModelMBeanConstructorInfo[],ModelMBeanOperationInfo[]," +
"ModelMBeanNotificationInfo[],Descriptor)",
"ModelMBeanNotificationInfo[],Descriptor) " +
"Exit");
}
}
@ -367,10 +363,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
public Descriptor[] getDescriptors(String inDescriptorType)
throws MBeanException, RuntimeOperationsException {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"getDescriptors(String)", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
if ((inDescriptorType == null) || (inDescriptorType.equals(""))) {
@ -474,10 +468,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
" the descriptors of the MBean";
throw new RuntimeOperationsException(iae,msg);
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"getDescriptors(String)", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
}
return retList;
@ -486,10 +478,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
public void setDescriptors(Descriptor[] inDescriptors)
throws MBeanException, RuntimeOperationsException {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"setDescriptors(Descriptor[])", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
if (inDescriptors==null) {
// throw RuntimeOperationsException - invalid descriptor
@ -504,10 +494,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
for (int j=0; j < inDescriptors.length; j++) {
setDescriptor(inDescriptors[j],null);
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"setDescriptors(Descriptor[])", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
}
}
@ -530,10 +518,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
public Descriptor getDescriptor(String inDescriptorName)
throws MBeanException, RuntimeOperationsException {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"getDescriptor(String)", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
return(getDescriptor(inDescriptorName, null));
}
@ -606,10 +592,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
throws MBeanException, RuntimeOperationsException {
final String excMsg =
"Exception occurred trying to set the descriptors of the MBean";
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"setDescriptor(Descriptor,String)", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
if (inDescriptor==null) {
@ -621,10 +605,9 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
(String) inDescriptor.getFieldValue("descriptorType");
if (inDescriptorType == null) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"setDescriptor(Descriptor,String)",
"descriptorType null in both String parameter and Descriptor, defaulting to "+ MMB);
MODELMBEAN_LOGGER.log(Level.TRACE,
"descriptorType null in both String parameter " +
"and Descriptor, defaulting to "+ MMB);
inDescriptorType = MMB;
}
}
@ -632,10 +615,9 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
String inDescriptorName =
(String) inDescriptor.getFieldValue("name");
if (inDescriptorName == null) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"setDescriptor(Descriptor,String)",
"descriptor name null, defaulting to "+ this.getClassName());
MODELMBEAN_LOGGER.log(Level.TRACE,
"descriptor name null, defaulting to " +
this.getClassName());
inDescriptorName = this.getClassName();
}
boolean found = false;
@ -653,17 +635,14 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
ModelMBeanAttributeInfo mmbai =
(ModelMBeanAttributeInfo) attrList[i];
mmbai.setDescriptor(inDescriptor);
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
StringBuilder strb = new StringBuilder()
.append("Setting descriptor to ").append(inDescriptor)
.append("\t\n local: AttributeInfo descriptor is ")
.append(mmbai.getDescriptor())
.append("\t\n modelMBeanInfo: AttributeInfo descriptor is ")
.append(this.getDescriptor(inDescriptorName,"attribute"));
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"setDescriptor(Descriptor,String)",
strb.toString());
MODELMBEAN_LOGGER.log(Level.TRACE, strb::toString);
}
}
}
@ -720,10 +699,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
"; name=" + inDescriptorName);
throw new RuntimeOperationsException(iae, excMsg);
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"setDescriptor(Descriptor,String)", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
}
}
@ -732,10 +709,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
public ModelMBeanAttributeInfo getAttribute(String inName)
throws MBeanException, RuntimeOperationsException {
ModelMBeanAttributeInfo retInfo = null;
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"getAttribute(String)", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
if (inName == null) {
throw new RuntimeOperationsException(
@ -748,7 +723,7 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
if (attrList != null) numAttrs = attrList.length;
for (int i=0; (i < numAttrs) && (retInfo == null); i++) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
final StringBuilder strb = new StringBuilder()
.append("\t\n this.getAttributes() MBeanAttributeInfo Array ")
.append(i).append(":")
@ -756,18 +731,14 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
.append("\t\n this.modelMBeanAttributes MBeanAttributeInfo Array ")
.append(i).append(":")
.append(((ModelMBeanAttributeInfo)modelMBeanAttributes[i]).getDescriptor());
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"getAttribute(String)", strb.toString());
MODELMBEAN_LOGGER.log(Level.TRACE, strb::toString);
}
if (inName.equals(attrList[i].getName())) {
retInfo = ((ModelMBeanAttributeInfo)attrList[i].clone());
}
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"getAttribute(String)", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
}
return retInfo;
@ -778,10 +749,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
public ModelMBeanOperationInfo getOperation(String inName)
throws MBeanException, RuntimeOperationsException {
ModelMBeanOperationInfo retInfo = null;
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"getOperation(String)", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
if (inName == null) {
throw new RuntimeOperationsException(
@ -798,10 +767,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
retInfo = ((ModelMBeanOperationInfo) operList[i].clone());
}
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"getOperation(String)", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
}
return retInfo;
@ -824,10 +791,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
public ModelMBeanConstructorInfo getConstructor(String inName)
throws MBeanException, RuntimeOperationsException {
ModelMBeanConstructorInfo retInfo = null;
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"getConstructor(String)", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
if (inName == null) {
throw new RuntimeOperationsException(
@ -844,10 +809,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
retInfo = ((ModelMBeanConstructorInfo) consList[i].clone());
}
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"getConstructor(String)", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
}
return retInfo;
@ -857,10 +820,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
public ModelMBeanNotificationInfo getNotification(String inName)
throws MBeanException, RuntimeOperationsException {
ModelMBeanNotificationInfo retInfo = null;
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"getNotification(String)", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
if (inName == null) {
throw new RuntimeOperationsException(
@ -877,10 +838,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
retInfo = ((ModelMBeanNotificationInfo) notifList[i].clone());
}
}
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"getNotification(String)", "Exit");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
}
return retInfo;
@ -901,19 +860,15 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
}
private Descriptor getMBeanDescriptorNoException() {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"getMBeanDescriptorNoException()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
if (modelMBeanDescriptor == null)
modelMBeanDescriptor = validDescriptor(null);
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"getMBeanDescriptorNoException()",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Exit, returning: " + modelMBeanDescriptor);
}
return (Descriptor) modelMBeanDescriptor.clone();
@ -921,10 +876,8 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
public void setMBeanDescriptor(Descriptor inMBeanDescriptor)
throws MBeanException, RuntimeOperationsException {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanInfoSupport.class.getName(),
"setMBeanDescriptor(Descriptor)", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
modelMBeanDescriptor = validDescriptor(inMBeanDescriptor);
}
@ -948,7 +901,7 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
boolean defaulted = (in == null);
if (defaulted) {
clone = new DescriptorSupport();
MODELMBEAN_LOGGER.finer("Null Descriptor, creating new.");
MODELMBEAN_LOGGER.log(Level.TRACE, "Null Descriptor, creating new.");
} else {
clone = (Descriptor) in.clone();
}
@ -956,27 +909,27 @@ public class ModelMBeanInfoSupport extends MBeanInfo implements ModelMBeanInfo {
//Setting defaults.
if (defaulted && clone.getFieldValue("name")==null) {
clone.setField("name", this.getClassName());
MODELMBEAN_LOGGER.finer("Defaulting Descriptor name to " + this.getClassName());
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor name to " + this.getClassName());
}
if (defaulted && clone.getFieldValue("descriptorType")==null) {
clone.setField("descriptorType", MMB);
MODELMBEAN_LOGGER.finer("Defaulting descriptorType to \"" + MMB + "\"");
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting descriptorType to \"" + MMB + "\"");
}
if (clone.getFieldValue("displayName") == null) {
clone.setField("displayName",this.getClassName());
MODELMBEAN_LOGGER.finer("Defaulting Descriptor displayName to " + this.getClassName());
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor displayName to " + this.getClassName());
}
if (clone.getFieldValue("persistPolicy") == null) {
clone.setField("persistPolicy","never");
MODELMBEAN_LOGGER.finer("Defaulting Descriptor persistPolicy to \"never\"");
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor persistPolicy to \"never\"");
}
if (clone.getFieldValue("log") == null) {
clone.setField("log","F");
MODELMBEAN_LOGGER.finer("Defaulting Descriptor \"log\" field to \"F\"");
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor \"log\" field to \"F\"");
}
if (clone.getFieldValue("visibility") == null) {
clone.setField("visibility","1");
MODELMBEAN_LOGGER.finer("Defaulting Descriptor visibility to 1");
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor visibility to 1");
}
//Checking validity

51
jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanNotificationInfo.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2017, 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
@ -38,7 +38,7 @@ import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamField;
import java.security.AccessController;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.Descriptor;
import javax.management.DescriptorAccess;
@ -199,10 +199,8 @@ public class ModelMBeanNotificationInfo
String description,
Descriptor descriptor) {
super(notifTypes, name, description);
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanNotificationInfo.class.getName(),
"ModelMBeanNotificationInfo", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
notificationDescriptor = validDescriptor(descriptor);
}
@ -225,10 +223,8 @@ public class ModelMBeanNotificationInfo
* duplicate of this ModelMBeanNotificationInfo.
**/
public Object clone () {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanNotificationInfo.class.getName(),
"clone()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
return(new ModelMBeanNotificationInfo(this));
}
@ -243,18 +239,15 @@ public class ModelMBeanNotificationInfo
* @see #setDescriptor
**/
public Descriptor getDescriptor() {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanNotificationInfo.class.getName(),
"getDescriptor()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
if (notificationDescriptor == null) {
// Dead code. Should never happen.
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanNotificationInfo.class.getName(),
"getDescriptor()", "Descriptor value is null, " +
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"Descriptor value is null, " +
"setting descriptor to default values");
}
notificationDescriptor = validDescriptor(null);
@ -281,10 +274,8 @@ public class ModelMBeanNotificationInfo
* @see #getDescriptor
**/
public void setDescriptor(Descriptor inDescriptor) {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanNotificationInfo.class.getName(),
"setDescriptor(Descriptor)", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
notificationDescriptor = validDescriptor(inDescriptor);
}
@ -296,10 +287,8 @@ public class ModelMBeanNotificationInfo
* @return a string describing this object.
**/
public String toString() {
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanNotificationInfo.class.getName(),
"toString()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
final StringBuilder retStr = new StringBuilder();
@ -342,7 +331,7 @@ public class ModelMBeanNotificationInfo
boolean defaulted = (in == null);
if (defaulted) {
clone = new DescriptorSupport();
MODELMBEAN_LOGGER.finer("Null Descriptor, creating new.");
MODELMBEAN_LOGGER.log(Level.TRACE, "Null Descriptor, creating new.");
} else {
clone = (Descriptor) in.clone();
}
@ -350,19 +339,19 @@ public class ModelMBeanNotificationInfo
//Setting defaults.
if (defaulted && clone.getFieldValue("name")==null) {
clone.setField("name", this.getName());
MODELMBEAN_LOGGER.finer("Defaulting Descriptor name to " + this.getName());
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor name to " + this.getName());
}
if (defaulted && clone.getFieldValue("descriptorType")==null) {
clone.setField("descriptorType", "notification");
MODELMBEAN_LOGGER.finer("Defaulting descriptorType to \"notification\"");
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting descriptorType to \"notification\"");
}
if (clone.getFieldValue("displayName") == null) {
clone.setField("displayName",this.getName());
MODELMBEAN_LOGGER.finer("Defaulting Descriptor displayName to " + this.getName());
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor displayName to " + this.getName());
}
if (clone.getFieldValue("severity") == null) {
clone.setField("severity", "6");
MODELMBEAN_LOGGER.finer("Defaulting Descriptor severity field to 6");
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor severity field to 6");
}
//Checking validity

75
jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanOperationInfo.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2017, 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
@ -39,7 +39,7 @@ import java.io.ObjectOutputStream;
import java.io.ObjectStreamField;
import java.lang.reflect.Method;
import java.security.AccessController;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.Descriptor;
import javax.management.DescriptorAccess;
@ -185,10 +185,9 @@ public class ModelMBeanOperationInfo extends MBeanOperationInfo
{
super(description, operationMethod);
// create default descriptor
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanOperationInfo.class.getName(),
"ModelMBeanOperationInfo(String,Method)",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanOperationInfo(String,Method) " +
"Entry");
}
operationDescriptor = validDescriptor(null);
@ -228,11 +227,10 @@ public class ModelMBeanOperationInfo extends MBeanOperationInfo
{
super(description, operationMethod);
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanOperationInfo.class.getName(),
"ModelMBeanOperationInfo(String,Method,Descriptor)",
"Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanOperationInfo(String,Method,Descriptor) "
+ "Entry");
}
operationDescriptor = validDescriptor(descriptor);
}
@ -258,11 +256,10 @@ public class ModelMBeanOperationInfo extends MBeanOperationInfo
super(name, description, signature, type, impact);
// create default descriptor
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanOperationInfo.class.getName(),
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanOperationInfo(" +
"String,String,MBeanParameterInfo[],String,int)",
"String,String,MBeanParameterInfo[],String,int) " +
"Entry");
}
operationDescriptor = validDescriptor(null);
@ -302,11 +299,10 @@ public class ModelMBeanOperationInfo extends MBeanOperationInfo
Descriptor descriptor)
{
super(name, description, signature, type, impact);
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanOperationInfo.class.getName(),
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanOperationInfo(String,String," +
"MBeanParameterInfo[],String,int,Descriptor)",
"MBeanParameterInfo[],String,int,Descriptor) " +
"Entry");
}
operationDescriptor = validDescriptor(descriptor);
@ -327,10 +323,9 @@ public class ModelMBeanOperationInfo extends MBeanOperationInfo
inInfo.getSignature(),
inInfo.getReturnType(),
inInfo.getImpact());
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanOperationInfo.class.getName(),
"ModelMBeanOperationInfo(ModelMBeanOperationInfo)",
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE,
"ModelMBeanOperationInfo(ModelMBeanOperationInfo)" +
"Entry");
}
Descriptor newDesc = inInfo.getDescriptor();
@ -345,10 +340,8 @@ public class ModelMBeanOperationInfo extends MBeanOperationInfo
public Object clone ()
{
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanOperationInfo.class.getName(),
"clone()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
return(new ModelMBeanOperationInfo(this)) ;
}
@ -365,10 +358,8 @@ public class ModelMBeanOperationInfo extends MBeanOperationInfo
public Descriptor getDescriptor()
{
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanOperationInfo.class.getName(),
"getDescriptor()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
if (operationDescriptor == null) {
operationDescriptor = validDescriptor(null);
@ -396,10 +387,8 @@ public class ModelMBeanOperationInfo extends MBeanOperationInfo
*/
public void setDescriptor(Descriptor inDescriptor)
{
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanOperationInfo.class.getName(),
"setDescriptor(Descriptor)", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
operationDescriptor = validDescriptor(inDescriptor);
}
@ -410,10 +399,8 @@ public class ModelMBeanOperationInfo extends MBeanOperationInfo
*/
public String toString()
{
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
MODELMBEAN_LOGGER.logp(Level.FINER,
ModelMBeanOperationInfo.class.getName(),
"toString()", "Entry");
if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
}
String retStr =
"ModelMBeanOperationInfo: " + this.getName() +
@ -449,7 +436,7 @@ public class ModelMBeanOperationInfo extends MBeanOperationInfo
boolean defaulted = (in == null);
if (defaulted) {
clone = new DescriptorSupport();
MODELMBEAN_LOGGER.finer("Null Descriptor, creating new.");
MODELMBEAN_LOGGER.log(Level.TRACE, "Null Descriptor, creating new.");
} else {
clone = (Descriptor) in.clone();
}
@ -457,19 +444,19 @@ public class ModelMBeanOperationInfo extends MBeanOperationInfo
//Setting defaults.
if (defaulted && clone.getFieldValue("name")==null) {
clone.setField("name", this.getName());
MODELMBEAN_LOGGER.finer("Defaulting Descriptor name to " + this.getName());
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor name to " + this.getName());
}
if (defaulted && clone.getFieldValue("descriptorType")==null) {
clone.setField("descriptorType", "operation");
MODELMBEAN_LOGGER.finer("Defaulting descriptorType to \"operation\"");
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting descriptorType to \"operation\"");
}
if (clone.getFieldValue("displayName") == null) {
clone.setField("displayName",this.getName());
MODELMBEAN_LOGGER.finer("Defaulting Descriptor displayName to " + this.getName());
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor displayName to " + this.getName());
}
if (clone.getFieldValue("role") == null) {
clone.setField("role","operation");
MODELMBEAN_LOGGER.finer("Defaulting Descriptor role field to \"operation\"");
MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor role field to \"operation\"");
}
//Checking validity

567
jdk/src/java.management/share/classes/javax/management/modelmbean/RequiredModelMBean.java
View File

File diff suppressed because it is too large Load Diff

19
jdk/src/java.management/share/classes/javax/management/monitor/CounterMonitor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2017, 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
@ -26,7 +26,7 @@
package javax.management.monitor;
import static com.sun.jmx.defaults.JmxProperties.MONITOR_LOGGER;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.ObjectName;
import javax.management.MBeanNotificationInfo;
import static javax.management.monitor.Monitor.NumericalType.*;
@ -228,8 +228,7 @@ public class CounterMonitor extends Monitor implements CounterMonitorMBean {
*/
public synchronized void start() {
if (isActive()) {
MONITOR_LOGGER.logp(Level.FINER, CounterMonitor.class.getName(),
"start", "the monitor is already active");
MONITOR_LOGGER.log(Level.TRACE, "the monitor is already active");
return;
}
// Reset values.
@ -696,7 +695,7 @@ public class CounterMonitor extends Monitor implements CounterMonitorMBean {
}
}
} else {
if (MONITOR_LOGGER.isLoggable(Level.FINER)) {
if (MONITOR_LOGGER.isLoggable(Level.TRACE)) {
final StringBuilder strb = new StringBuilder()
.append("The notification:")
.append("\n\tNotification observed object = ")
@ -708,8 +707,7 @@ public class CounterMonitor extends Monitor implements CounterMonitorMBean {
.append("\n\tNotification derived gauge = ")
.append(o.getDerivedGauge())
.append("\nhas already been sent");
MONITOR_LOGGER.logp(Level.FINER, CounterMonitor.class.getName(),
"updateNotifications", strb.toString());
MONITOR_LOGGER.log(Level.TRACE, strb::toString);
}
}
@ -756,9 +754,7 @@ public class CounterMonitor extends Monitor implements CounterMonitorMBean {
break;
default:
// Should never occur...
MONITOR_LOGGER.logp(Level.FINEST,
CounterMonitor.class.getName(),
"updateThreshold",
MONITOR_LOGGER.log(Level.TRACE,
"the threshold type is invalid");
break;
}
@ -819,8 +815,7 @@ public class CounterMonitor extends Monitor implements CounterMonitorMBean {
case LONG: o.setDerivedGauge(Long.valueOf(derived)); break;
default:
// Should never occur...
MONITOR_LOGGER.logp(Level.FINEST, CounterMonitor.class.getName(),
"setDerivedGaugeWithDifference",
MONITOR_LOGGER.log(Level.TRACE,
"the threshold type is invalid");
break;
}

16
jdk/src/java.management/share/classes/javax/management/monitor/GaugeMonitor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2017, 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
@ -26,7 +26,7 @@
package javax.management.monitor;
import static com.sun.jmx.defaults.JmxProperties.MONITOR_LOGGER;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.MBeanNotificationInfo;
import javax.management.ObjectName;
import static javax.management.monitor.Monitor.NumericalType.*;
@ -224,8 +224,7 @@ public class GaugeMonitor extends Monitor implements GaugeMonitorMBean {
*/
public synchronized void start() {
if (isActive()) {
MONITOR_LOGGER.logp(Level.FINER, GaugeMonitor.class.getName(),
"start", "the monitor is already active");
MONITOR_LOGGER.log(Level.TRACE, "the monitor is already active");
return;
}
// Reset values.
@ -664,8 +663,7 @@ public class GaugeMonitor extends Monitor implements GaugeMonitorMBean {
break;
default:
// Should never occur...
MONITOR_LOGGER.logp(Level.FINEST, GaugeMonitor.class.getName(),
"setDerivedGaugeWithDifference",
MONITOR_LOGGER.log(Level.TRACE,
"the threshold type is invalid");
return;
}
@ -698,8 +696,7 @@ public class GaugeMonitor extends Monitor implements GaugeMonitorMBean {
return (greater.doubleValue() >= less.doubleValue());
default:
// Should never occur...
MONITOR_LOGGER.logp(Level.FINEST, GaugeMonitor.class.getName(),
"isFirstGreaterThanLast",
MONITOR_LOGGER.log(Level.TRACE,
"the threshold type is invalid");
return false;
}
@ -733,8 +730,7 @@ public class GaugeMonitor extends Monitor implements GaugeMonitorMBean {
}
else {
// Should never occur...
MONITOR_LOGGER.logp(Level.FINEST, GaugeMonitor.class.getName(),
"isFirstStrictlyGreaterThanLast",
MONITOR_LOGGER.log(Level.TRACE,
"the threshold type is invalid");
return false;
}

107
jdk/src/java.management/share/classes/javax/management/monitor/Monitor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2017, 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
@ -47,7 +47,7 @@ import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.AttributeNotFoundException;
import javax.management.InstanceNotFoundException;
import javax.management.IntrospectionException;
@ -205,13 +205,11 @@ public abstract class Monitor
try {
maximumPoolSizeTmp = Integer.parseInt(maximumPoolSizeStr);
} catch (NumberFormatException e) {
if (MONITOR_LOGGER.isLoggable(Level.FINER)) {
MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
"<static initializer>",
if (MONITOR_LOGGER.isLoggable(Level.TRACE)) {
MONITOR_LOGGER.log(Level.TRACE,
"Wrong value for " + maximumPoolSizeSysProp +
" system property", e);
MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
"<static initializer>",
MONITOR_LOGGER.log(Level.TRACE,
maximumPoolSizeSysProp + " defaults to 10");
}
maximumPoolSizeTmp = 10;
@ -391,8 +389,7 @@ public abstract class Monitor
public ObjectName preRegister(MBeanServer server, ObjectName name)
throws Exception {
MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
"preRegister(MBeanServer, ObjectName)",
MONITOR_LOGGER.log(Level.TRACE,
"initialize the reference on the MBean server");
this.server = server;
@ -419,8 +416,7 @@ public abstract class Monitor
*/
public void preDeregister() throws Exception {
MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
"preDeregister()", "stop the monitor");
MONITOR_LOGGER.log(Level.TRACE, "stop the monitor");
// Stop the Monitor.
//
@ -693,13 +689,11 @@ public abstract class Monitor
* Starts the monitor.
*/
void doStart() {
MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
"doStart()", "start the monitor");
MONITOR_LOGGER.log(Level.TRACE, "start the monitor");
synchronized (this) {
if (isActive()) {
MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
"doStart()", "the monitor is already active");
MONITOR_LOGGER.log(Level.TRACE, "the monitor is already active");
return;
}
@ -729,13 +723,11 @@ public abstract class Monitor
* Stops the monitor.
*/
void doStop() {
MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
"doStop()", "stop the monitor");
MONITOR_LOGGER.log(Level.TRACE, "stop the monitor");
synchronized (this) {
if (!isActive()) {
MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
"doStop()", "the monitor is not active");
MONITOR_LOGGER.log(Level.TRACE, "the monitor is not active");
return;
}
@ -1089,9 +1081,8 @@ public abstract class Monitor
if (!isActive())
return;
if (MONITOR_LOGGER.isLoggable(Level.FINER)) {
MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
"sendNotification", "send notification: " +
if (MONITOR_LOGGER.isLoggable(Level.TRACE)) {
MONITOR_LOGGER.log(Level.TRACE, "send notification: " +
"\n\tNotification observed object = " + object +
"\n\tNotification observed attribute = " + observedAttribute +
"\n\tNotification derived gauge = " + derGauge);
@ -1163,8 +1154,7 @@ public abstract class Monitor
setAlreadyNotified(
o, index, OBSERVED_ATTRIBUTE_TYPE_ERROR_NOTIFIED, an);
msg = "The observed attribute value is null.";
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", msg);
MONITOR_LOGGER.log(Level.TRACE, msg);
}
} catch (NullPointerException np_ex) {
if (isAlreadyNotified(o, RUNTIME_ERROR_NOTIFIED))
@ -1176,10 +1166,8 @@ public abstract class Monitor
"The monitor must be registered in the MBean " +
"server or an MBeanServerConnection must be " +
"explicitly supplied.";
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", msg);
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", np_ex.toString());
MONITOR_LOGGER.log(Level.TRACE, msg);
MONITOR_LOGGER.log(Level.TRACE, np_ex::toString);
}
} catch (InstanceNotFoundException inf_ex) {
if (isAlreadyNotified(o, OBSERVED_OBJECT_ERROR_NOTIFIED))
@ -1191,10 +1179,8 @@ public abstract class Monitor
msg =
"The observed object must be accessible in " +
"the MBeanServerConnection.";
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", msg);
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", inf_ex.toString());
MONITOR_LOGGER.log(Level.TRACE, msg);
MONITOR_LOGGER.log(Level.TRACE, inf_ex::toString);
}
} catch (AttributeNotFoundException anf_ex) {
if (isAlreadyNotified(o, OBSERVED_ATTRIBUTE_ERROR_NOTIFIED))
@ -1206,10 +1192,8 @@ public abstract class Monitor
msg =
"The observed attribute must be accessible in " +
"the observed object.";
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", msg);
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", anf_ex.toString());
MONITOR_LOGGER.log(Level.TRACE, msg);
MONITOR_LOGGER.log(Level.TRACE, anf_ex::toString);
}
} catch (MBeanException mb_ex) {
if (isAlreadyNotified(o, RUNTIME_ERROR_NOTIFIED))
@ -1218,10 +1202,8 @@ public abstract class Monitor
notifType = RUNTIME_ERROR;
setAlreadyNotified(o, index, RUNTIME_ERROR_NOTIFIED, an);
msg = mb_ex.getMessage() == null ? "" : mb_ex.getMessage();
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", msg);
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", mb_ex.toString());
MONITOR_LOGGER.log(Level.TRACE, msg);
MONITOR_LOGGER.log(Level.TRACE, mb_ex::toString);
}
} catch (ReflectionException ref_ex) {
if (isAlreadyNotified(o, RUNTIME_ERROR_NOTIFIED)) {
@ -1230,10 +1212,8 @@ public abstract class Monitor
notifType = RUNTIME_ERROR;
setAlreadyNotified(o, index, RUNTIME_ERROR_NOTIFIED, an);
msg = ref_ex.getMessage() == null ? "" : ref_ex.getMessage();
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", msg);
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", ref_ex.toString());
MONITOR_LOGGER.log(Level.TRACE, msg);
MONITOR_LOGGER.log(Level.TRACE, ref_ex::toString);
}
} catch (IOException io_ex) {
if (isAlreadyNotified(o, RUNTIME_ERROR_NOTIFIED))
@ -1242,10 +1222,8 @@ public abstract class Monitor
notifType = RUNTIME_ERROR;
setAlreadyNotified(o, index, RUNTIME_ERROR_NOTIFIED, an);
msg = io_ex.getMessage() == null ? "" : io_ex.getMessage();
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", msg);
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", io_ex.toString());
MONITOR_LOGGER.log(Level.TRACE, msg);
MONITOR_LOGGER.log(Level.TRACE, io_ex::toString);
}
} catch (RuntimeException rt_ex) {
if (isAlreadyNotified(o, RUNTIME_ERROR_NOTIFIED))
@ -1254,10 +1232,8 @@ public abstract class Monitor
notifType = RUNTIME_ERROR;
setAlreadyNotified(o, index, RUNTIME_ERROR_NOTIFIED, an);
msg = rt_ex.getMessage() == null ? "" : rt_ex.getMessage();
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", msg);
MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
"monitor", rt_ex.toString());
MONITOR_LOGGER.log(Level.TRACE, msg);
MONITOR_LOGGER.log(Level.TRACE, rt_ex::toString);
}
}
@ -1297,10 +1273,8 @@ public abstract class Monitor
msg =
"The observed attribute value does not " +
"implement the Comparable interface.";
MONITOR_LOGGER.logp(Level.FINEST,
Monitor.class.getName(), "monitor", msg);
MONITOR_LOGGER.logp(Level.FINEST,
Monitor.class.getName(), "monitor", e.toString());
MONITOR_LOGGER.log(Level.TRACE, msg);
MONITOR_LOGGER.log(Level.TRACE, e::toString);
}
} catch (AttributeNotFoundException e) {
if (isAlreadyNotified(o, OBSERVED_ATTRIBUTE_ERROR_NOTIFIED))
@ -1312,10 +1286,8 @@ public abstract class Monitor
msg =
"The observed attribute must be accessible in " +
"the observed object.";
MONITOR_LOGGER.logp(Level.FINEST,
Monitor.class.getName(), "monitor", msg);
MONITOR_LOGGER.logp(Level.FINEST,
Monitor.class.getName(), "monitor", e.toString());
MONITOR_LOGGER.log(Level.TRACE, msg);
MONITOR_LOGGER.log(Level.TRACE, e::toString);
}
} catch (RuntimeException e) {
if (isAlreadyNotified(o, RUNTIME_ERROR_NOTIFIED))
@ -1325,10 +1297,8 @@ public abstract class Monitor
setAlreadyNotified(o, index,
RUNTIME_ERROR_NOTIFIED, an);
msg = e.getMessage() == null ? "" : e.getMessage();
MONITOR_LOGGER.logp(Level.FINEST,
Monitor.class.getName(), "monitor", msg);
MONITOR_LOGGER.logp(Level.FINEST,
Monitor.class.getName(), "monitor", e.toString());
MONITOR_LOGGER.log(Level.TRACE, msg);
MONITOR_LOGGER.log(Level.TRACE, e::toString);
}
}
}
@ -1346,8 +1316,7 @@ public abstract class Monitor
setAlreadyNotified(o, index,
OBSERVED_ATTRIBUTE_TYPE_ERROR_NOTIFIED, an);
msg = "The observed attribute type is not valid.";
MONITOR_LOGGER.logp(Level.FINEST,
Monitor.class.getName(), "monitor", msg);
MONITOR_LOGGER.log(Level.TRACE, msg);
}
}
}
@ -1363,8 +1332,7 @@ public abstract class Monitor
setAlreadyNotified(o, index,
THRESHOLD_ERROR_NOTIFIED, an);
msg = "The threshold type is not valid.";
MONITOR_LOGGER.logp(Level.FINEST,
Monitor.class.getName(), "monitor", msg);
MONITOR_LOGGER.log(Level.TRACE, msg);
}
}
}
@ -1381,8 +1349,7 @@ public abstract class Monitor
notifType = RUNTIME_ERROR;
setAlreadyNotified(o, index,
RUNTIME_ERROR_NOTIFIED, an);
MONITOR_LOGGER.logp(Level.FINEST,
Monitor.class.getName(), "monitor", msg);
MONITOR_LOGGER.log(Level.TRACE, msg);
}
}
}

7
jdk/src/java.management/share/classes/javax/management/monitor/StringMonitor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2017, 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
@ -26,7 +26,7 @@
package javax.management.monitor;
import static com.sun.jmx.defaults.JmxProperties.MONITOR_LOGGER;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.ObjectName;
import javax.management.MBeanNotificationInfo;
import static javax.management.monitor.MonitorNotification.*;
@ -151,8 +151,7 @@ public class StringMonitor extends Monitor implements StringMonitorMBean {
*/
public synchronized void start() {
if (isActive()) {
MONITOR_LOGGER.logp(Level.FINER, StringMonitor.class.getName(),
"start", "the monitor is already active");
MONITOR_LOGGER.log(Level.TRACE, "the monitor is already active");
return;
}
// Reset values.

61
jdk/src/java.management/share/classes/javax/management/relation/MBeanServerNotificationFilter.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2008, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2017, 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
@ -45,7 +45,7 @@ import javax.management.NotificationFilterSupport;
import javax.management.ObjectName;
import java.util.List;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import java.util.Vector;
/**
@ -160,14 +160,12 @@ public class MBeanServerNotificationFilter extends NotificationFilterSupport {
public MBeanServerNotificationFilter() {
super();
RELATION_LOGGER.entering(MBeanServerNotificationFilter.class.getName(),
"MBeanServerNotificationFilter");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
enableType(MBeanServerNotification.REGISTRATION_NOTIFICATION);
enableType(MBeanServerNotification.UNREGISTRATION_NOTIFICATION);
RELATION_LOGGER.exiting(MBeanServerNotificationFilter.class.getName(),
"MBeanServerNotificationFilter");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -181,14 +179,12 @@ public class MBeanServerNotificationFilter extends NotificationFilterSupport {
*/
public synchronized void disableAllObjectNames() {
RELATION_LOGGER.entering(MBeanServerNotificationFilter.class.getName(),
"disableAllObjectNames");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
selectedNames = new Vector<ObjectName>();
deselectedNames = null;
RELATION_LOGGER.exiting(MBeanServerNotificationFilter.class.getName(),
"disableAllObjectNames");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -207,8 +203,7 @@ public class MBeanServerNotificationFilter extends NotificationFilterSupport {
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(MBeanServerNotificationFilter.class.getName(),
"disableObjectName", objectName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}" + objectName);
// Removes from selected ObjectNames, if present
if (selectedNames != null) {
@ -226,8 +221,7 @@ public class MBeanServerNotificationFilter extends NotificationFilterSupport {
}
}
RELATION_LOGGER.exiting(MBeanServerNotificationFilter.class.getName(),
"disableObjectName");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -236,14 +230,12 @@ public class MBeanServerNotificationFilter extends NotificationFilterSupport {
*/
public synchronized void enableAllObjectNames() {
RELATION_LOGGER.entering(MBeanServerNotificationFilter.class.getName(),
"enableAllObjectNames");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
selectedNames = null;
deselectedNames = new Vector<ObjectName>();
RELATION_LOGGER.exiting(MBeanServerNotificationFilter.class.getName(),
"enableAllObjectNames");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -262,8 +254,7 @@ public class MBeanServerNotificationFilter extends NotificationFilterSupport {
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(MBeanServerNotificationFilter.class.getName(),
"enableObjectName", objectName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", objectName);
// Removes from deselected ObjectNames, if present
if (deselectedNames != null) {
@ -281,8 +272,7 @@ public class MBeanServerNotificationFilter extends NotificationFilterSupport {
}
}
RELATION_LOGGER.exiting(MBeanServerNotificationFilter.class.getName(),
"enableObjectName");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -349,16 +339,13 @@ public class MBeanServerNotificationFilter extends NotificationFilterSupport {
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(MBeanServerNotificationFilter.class.getName(),
"isNotificationEnabled", notif);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", notif);
// Checks the type first
String ntfType = notif.getType();
Vector<String> enabledTypes = getEnabledTypes();
if (!(enabledTypes.contains(ntfType))) {
RELATION_LOGGER.logp(Level.FINER,
MBeanServerNotificationFilter.class.getName(),
"isNotificationEnabled",
RELATION_LOGGER.log(Level.TRACE,
"Type not selected, exiting");
return false;
}
@ -375,9 +362,7 @@ public class MBeanServerNotificationFilter extends NotificationFilterSupport {
// checks for explicit selection
if (selectedNames.size() == 0) {
// All are explicitly not selected
RELATION_LOGGER.logp(Level.FINER,
MBeanServerNotificationFilter.class.getName(),
"isNotificationEnabled",
RELATION_LOGGER.log(Level.TRACE,
"No ObjectNames selected, exiting");
return false;
}
@ -385,9 +370,7 @@ public class MBeanServerNotificationFilter extends NotificationFilterSupport {
isSelectedFlg = selectedNames.contains(objName);
if (!isSelectedFlg) {
// Not in the explicit selected list
RELATION_LOGGER.logp(Level.FINER,
MBeanServerNotificationFilter.class.getName(),
"isNotificationEnabled",
RELATION_LOGGER.log(Level.TRACE,
"ObjectName not in selected list, exiting");
return false;
}
@ -399,26 +382,20 @@ public class MBeanServerNotificationFilter extends NotificationFilterSupport {
if (deselectedNames == null) {
// All are implicitly deselected and it is not explicitly
// selected
RELATION_LOGGER.logp(Level.FINER,
MBeanServerNotificationFilter.class.getName(),
"isNotificationEnabled",
RELATION_LOGGER.log(Level.TRACE,
"ObjectName not selected, and all " +
"names deselected, exiting");
return false;
} else if (deselectedNames.contains(objName)) {
// Explicitly deselected
RELATION_LOGGER.logp(Level.FINER,
MBeanServerNotificationFilter.class.getName(),
"isNotificationEnabled",
RELATION_LOGGER.log(Level.TRACE,
"ObjectName explicitly not selected, exiting");
return false;
}
}
RELATION_LOGGER.logp(Level.FINER,
MBeanServerNotificationFilter.class.getName(),
"isNotificationEnabled",
RELATION_LOGGER.log(Level.TRACE,
"ObjectName selected, exiting");
return true;
}

322
jdk/src/java.management/share/classes/javax/management/relation/RelationService.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2017, 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
@ -36,7 +36,7 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import javax.management.Attribute;
import javax.management.AttributeNotFoundException;
@ -157,13 +157,11 @@ public class RelationService extends NotificationBroadcasterSupport
*/
public RelationService(boolean immediatePurgeFlag) {
RELATION_LOGGER.entering(RelationService.class.getName(),
"RelationService");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
setPurgeFlag(immediatePurgeFlag);
RELATION_LOGGER.exiting(RelationService.class.getName(),
"RelationService");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -286,8 +284,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"createRelationType", relationTypeName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationTypeName);
// Can throw an InvalidRelationTypeException
RelationType relType =
@ -295,8 +292,7 @@ public class RelationService extends NotificationBroadcasterSupport
addRelationTypeInt(relType);
RELATION_LOGGER.exiting(RelationService.class.getName(),
"createRelationType");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -325,8 +321,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"addRelationType");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
// Checks the role infos
List<RoleInfo> roleInfoList = relationTypeObj.getRoleInfos();
@ -346,8 +341,7 @@ public class RelationService extends NotificationBroadcasterSupport
addRelationTypeInt(relationTypeObj);
RELATION_LOGGER.exiting(RelationService.class.getName(),
"addRelationType");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -385,14 +379,12 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"getRoleInfos", relationTypeName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationTypeName);
// Can throw a RelationTypeNotFoundException
RelationType relType = getRelationType(relationTypeName);
RELATION_LOGGER.exiting(RelationService.class.getName(),
"getRoleInfos");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return relType.getRoleInfos();
}
@ -421,8 +413,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"getRoleInfo", new Object[] {relationTypeName, roleInfoName});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
relationTypeName, roleInfoName);
// Can throw a RelationTypeNotFoundException
RelationType relType = getRelationType(relationTypeName);
@ -430,8 +422,7 @@ public class RelationService extends NotificationBroadcasterSupport
// Can throw a RoleInfoNotFoundException
RoleInfo roleInfo = relType.getRoleInfo(roleInfoName);
RELATION_LOGGER.exiting(RelationService.class.getName(),
"getRoleInfo");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return roleInfo;
}
@ -461,8 +452,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"removeRelationType", relationTypeName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationTypeName);
// Checks if the relation type to be removed exists
// Can throw a RelationTypeNotFoundException
@ -504,8 +494,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"removeRelationType");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -566,9 +555,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"createRelation",
new Object[] {relationId, relationTypeName, roleList});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
relationId, relationTypeName, roleList);
// Creates RelationSupport object
// Can throw InvalidRoleValueException
@ -588,8 +576,7 @@ public class RelationService extends NotificationBroadcasterSupport
relationId,
relationTypeName,
roleList);
RELATION_LOGGER.exiting(RelationService.class.getName(),
"createRelation");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -654,8 +641,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"addRelation", relationObjectName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationObjectName);
// Can throw RelationServiceNotRegisteredException
isActive();
@ -791,8 +777,7 @@ public class RelationService extends NotificationBroadcasterSupport
newRefList.add(relationObjectName);
updateUnregistrationListener(newRefList, null);
RELATION_LOGGER.exiting(RelationService.class.getName(),
"addRelation");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -819,8 +804,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"isRelationMBean", relationId);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
// Can throw RelationNotFoundException
Object result = getRelation(relationId);
@ -850,8 +834,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"isRelation", objectName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", objectName);
String result = null;
synchronized(myRelMBeanObjName2RelIdMap) {
@ -881,8 +864,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"hasRelation", relationId);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
try {
// Can throw RelationNotFoundException
@ -933,8 +915,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"checkRoleReading", new Object[] {roleName, relationTypeName});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
roleName, relationTypeName);
Integer result;
@ -956,8 +938,7 @@ public class RelationService extends NotificationBroadcasterSupport
result = Integer.valueOf(RoleStatus.NO_ROLE_WITH_NAME);
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"checkRoleReading");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -995,9 +976,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"checkRoleWriting",
new Object[] {role, relationTypeName, initFlag});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
role, relationTypeName, initFlag);
// Can throw a RelationTypeNotFoundException
RelationType relType = getRelationType(relationTypeName);
@ -1013,8 +993,7 @@ public class RelationService extends NotificationBroadcasterSupport
try {
roleInfo = relType.getRoleInfo(roleName);
} catch (RoleInfoNotFoundException exc) {
RELATION_LOGGER.exiting(RelationService.class.getName(),
"checkRoleWriting");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return Integer.valueOf(RoleStatus.NO_ROLE_WITH_NAME);
}
@ -1024,8 +1003,7 @@ public class RelationService extends NotificationBroadcasterSupport
roleInfo,
writeChkFlag);
RELATION_LOGGER.exiting(RelationService.class.getName(),
"checkRoleWriting");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -1055,8 +1033,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"sendRelationCreationNotification", relationId);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
// Message
StringBuilder ntfMsg = new StringBuilder("Creation of relation ");
@ -1071,8 +1048,7 @@ public class RelationService extends NotificationBroadcasterSupport
null,
null);
RELATION_LOGGER.exiting(RelationService.class.getName(),
"sendRelationCreationNotification");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -1114,9 +1090,8 @@ public class RelationService extends NotificationBroadcasterSupport
if (!(oldValue instanceof ArrayList<?>))
oldValue = new ArrayList<ObjectName>(oldValue);
RELATION_LOGGER.entering(RelationService.class.getName(),
"sendRoleUpdateNotification",
new Object[] {relationId, newRole, oldValue});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
relationId, newRole, oldValue);
String roleName = newRole.getRoleName();
List<ObjectName> newRoleVal = newRole.getRoleValue();
@ -1140,8 +1115,7 @@ public class RelationService extends NotificationBroadcasterSupport
newRoleVal,
oldValue);
RELATION_LOGGER.exiting(RelationService.class.getName(),
"sendRoleUpdateNotification");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
}
/**
@ -1172,9 +1146,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"sendRelationRemovalNotification",
new Object[] {relationId, unregMBeanList});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
relationId, unregMBeanList);
// Can throw RelationNotFoundException
sendNotificationInt(3,
@ -1186,8 +1159,7 @@ public class RelationService extends NotificationBroadcasterSupport
null);
RELATION_LOGGER.exiting(RelationService.class.getName(),
"sendRelationRemovalNotification");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -1226,8 +1198,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"updateRoleMap", new Object[] {relationId, newRole, oldValue});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
relationId, newRole, oldValue);
// Can throw RelationServiceNotRegisteredException
isActive();
@ -1303,8 +1275,7 @@ public class RelationService extends NotificationBroadcasterSupport
// all ObjectNames of interest
updateUnregistrationListener(newRefList, obsRefList);
RELATION_LOGGER.exiting(RelationService.class.getName(),
"updateRoleMap");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -1338,8 +1309,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"removeRelation", relationId);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
// Checks there is a relation with this id
// Can throw RelationNotFoundException
@ -1442,8 +1412,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"removeRelation");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -1476,8 +1445,7 @@ public class RelationService extends NotificationBroadcasterSupport
public void purgeRelations()
throws RelationServiceNotRegisteredException {
RELATION_LOGGER.entering(RelationService.class.getName(),
"purgeRelations");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
// Can throw RelationServiceNotRegisteredException
isActive();
@ -1574,8 +1542,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"purgeRelations");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -1610,9 +1577,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"findReferencingRelations",
new Object[] {mbeanName, relationTypeName, roleName});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
mbeanName, relationTypeName, roleName);
Map<String,List<String>> result = new HashMap<String,List<String>>();
@ -1684,8 +1650,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"findReferencingRelations");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -1720,9 +1685,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"findAssociatedMBeans",
new Object[] {mbeanName, relationTypeName, roleName});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
mbeanName, relationTypeName, roleName);
// Retrieves the map <relation id> -> <role names> for those
// criterias
@ -1769,8 +1733,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"findAssociatedMBeans");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -1794,8 +1757,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"findRelationsOfType");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
// Can throw RelationTypeNotFoundException
RelationType relType = getRelationType(relationTypeName);
@ -1809,8 +1771,7 @@ public class RelationService extends NotificationBroadcasterSupport
result = new ArrayList<String>(result1);
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"findRelationsOfType");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -1845,8 +1806,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"getRole", new Object[] {relationId, roleName});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
relationId, roleName);
// Can throw RelationServiceNotRegisteredException
isActive();
@ -1899,7 +1860,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(), "getRole");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -1931,8 +1892,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"getRoles", relationId);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
// Can throw RelationServiceNotRegisteredException
isActive();
@ -1976,7 +1936,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(), "getRoles");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -2004,8 +1964,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"getRoles", relationId);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
// Can throw a RelationNotFoundException
Object relObj = getRelation(relationId);
@ -2028,7 +1987,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(), "getRoles");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -2055,8 +2014,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"getRoleCardinality", new Object[] {relationId, roleName});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
relationId, roleName);
// Can throw a RelationNotFoundException
Object relObj = getRelation(relationId);
@ -2098,8 +2057,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"getRoleCardinality");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -2147,8 +2105,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"setRole", new Object[] {relationId, role});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
relationId, role);
// Can throw RelationServiceNotRegisteredException
isActive();
@ -2211,7 +2169,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(), "setRole");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -2247,8 +2205,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"setRoles", new Object[] {relationId, roleList});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
relationId, roleList);
// Can throw RelationServiceNotRegisteredException
isActive();
@ -2296,7 +2254,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(), "setRoles");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -2322,8 +2280,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"getReferencedMBeans", relationId);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}",
relationId);
// Can throw a RelationNotFoundException
Object relObj = getRelation(relationId);
@ -2346,8 +2304,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"getReferencedMBeans");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -2371,8 +2328,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"getRelationTypeName", relationId);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
// Can throw a RelationNotFoundException
Object relObj = getRelation(relationId);
@ -2395,8 +2351,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"getRelationTypeName");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -2421,8 +2376,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"handleNotification", notif);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", notif);
if (notif instanceof MBeanServerNotification) {
@ -2480,8 +2434,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"handleNotification");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -2495,8 +2448,7 @@ public class RelationService extends NotificationBroadcasterSupport
*/
public MBeanNotificationInfo[] getNotificationInfo() {
RELATION_LOGGER.entering(RelationService.class.getName(),
"getNotificationInfo");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
String ntfClass = "javax.management.relation.RelationNotification";
@ -2514,8 +2466,7 @@ public class RelationService extends NotificationBroadcasterSupport
MBeanNotificationInfo ntfInfo =
new MBeanNotificationInfo(ntfTypes, ntfClass, ntfDesc);
RELATION_LOGGER.exiting(RelationService.class.getName(),
"getNotificationInfo");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return new MBeanNotificationInfo[] {ntfInfo};
}
@ -2539,8 +2490,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"addRelationTypeInt");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
String relTypeName = relationTypeObj.getRelationTypeName();
@ -2570,8 +2520,7 @@ public class RelationService extends NotificationBroadcasterSupport
((RelationTypeSupport)relationTypeObj).setRelationServiceFlag(true);
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"addRelationTypeInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -2595,8 +2544,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"getRelationType", relationTypeName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationTypeName);
// No null relation type accepted, so can use get()
RelationType relType;
@ -2611,8 +2559,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new RelationTypeNotFoundException(excMsgStrB.toString());
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"getRelationType");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return relType;
}
@ -2639,8 +2586,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"getRelation", relationId);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
// No null relation accepted, so can use get()
Object rel;
@ -2653,8 +2599,7 @@ public class RelationService extends NotificationBroadcasterSupport
throw new RelationNotFoundException(excMsg);
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"getRelation");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return rel;
}
@ -2684,9 +2629,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"addNewMBeanReference",
new Object[] {objectName, relationId, roleName});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
objectName, relationId, roleName);
boolean isNewFlag = false;
@ -2739,8 +2683,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"addNewMBeanReference");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return isNewFlag;
}
@ -2772,9 +2715,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"removeMBeanReference",
new Object[] {objectName, relationId, roleName, allRolesFlag});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3}",
objectName, relationId, roleName, allRolesFlag);
boolean noLongerRefFlag = false;
@ -2790,8 +2732,7 @@ public class RelationService extends NotificationBroadcasterSupport
if (mbeanRefMap == null) {
// The MBean is no longer referenced
RELATION_LOGGER.exiting(RelationService.class.getName(),
"removeMBeanReference");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return true;
}
@ -2824,8 +2765,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"removeMBeanReference");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return noLongerRefFlag;
}
@ -2850,9 +2790,8 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"updateUnregistrationListener",
new Object[] {newRefList, obsoleteRefList});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
newRefList, obsoleteRefList);
// Can throw RelationServiceNotRegisteredException
isActive();
@ -2936,8 +2875,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"updateUnregistrationListener");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -3003,9 +2941,10 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"addRelationInt", new Object[] {relationBaseFlag, relationObj,
relationObjName, relationId, relationTypeName, roleList});
RELATION_LOGGER.log(Level.TRACE,
"ENTRY {0} {1} {2} {3} {4} {5}",
relationBaseFlag, relationObj, relationObjName,
relationId, relationTypeName, roleList);
// Can throw RelationServiceNotRegisteredException
isActive();
@ -3144,8 +3083,7 @@ public class RelationService extends NotificationBroadcasterSupport
// OK : The Relation could not be found.
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"addRelationInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -3185,15 +3123,13 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"checkRoleInt", new Object[] {chkType, roleName,
roleValue, roleInfo, writeChkFlag});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3} {4}",
chkType, roleName, roleValue, roleInfo, writeChkFlag);
// Compares names
String expName = roleInfo.getName();
if (!(roleName.equals(expName))) {
RELATION_LOGGER.exiting(RelationService.class.getName(),
"checkRoleInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return Integer.valueOf(RoleStatus.NO_ROLE_WITH_NAME);
}
@ -3201,13 +3137,11 @@ public class RelationService extends NotificationBroadcasterSupport
if (chkType == 1) {
boolean isReadable = roleInfo.isReadable();
if (!isReadable) {
RELATION_LOGGER.exiting(RelationService.class.getName(),
"checkRoleInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return Integer.valueOf(RoleStatus.ROLE_NOT_READABLE);
} else {
// End of check :)
RELATION_LOGGER.exiting(RelationService.class.getName(),
"checkRoleInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return 0;
}
}
@ -3216,8 +3150,7 @@ public class RelationService extends NotificationBroadcasterSupport
if (writeChkFlag) {
boolean isWritable = roleInfo.isWritable();
if (!isWritable) {
RELATION_LOGGER.exiting(RelationService.class.getName(),
"checkRoleInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return RoleStatus.ROLE_NOT_WRITABLE;
}
}
@ -3227,16 +3160,14 @@ public class RelationService extends NotificationBroadcasterSupport
// Checks minimum cardinality
boolean chkMinFlag = roleInfo.checkMinDegree(refNbr);
if (!chkMinFlag) {
RELATION_LOGGER.exiting(RelationService.class.getName(),
"checkRoleInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return RoleStatus.LESS_THAN_MIN_ROLE_DEGREE;
}
// Checks maximum cardinality
boolean chkMaxFlag = roleInfo.checkMaxDegree(refNbr);
if (!chkMaxFlag) {
RELATION_LOGGER.exiting(RelationService.class.getName(),
"checkRoleInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return RoleStatus.MORE_THAN_MAX_ROLE_DEGREE;
}
@ -3252,8 +3183,7 @@ public class RelationService extends NotificationBroadcasterSupport
// Checks it is registered
if (currObjName == null) {
RELATION_LOGGER.exiting(RelationService.class.getName(),
"checkRoleInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return RoleStatus.REF_MBEAN_NOT_REGISTERED;
}
@ -3263,20 +3193,17 @@ public class RelationService extends NotificationBroadcasterSupport
boolean classSts = myMBeanServer.isInstanceOf(currObjName,
expClassName);
if (!classSts) {
RELATION_LOGGER.exiting(RelationService.class.getName(),
"checkRoleInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return RoleStatus.REF_MBEAN_OF_INCORRECT_CLASS;
}
} catch (InstanceNotFoundException exc) {
RELATION_LOGGER.exiting(RelationService.class.getName(),
"checkRoleInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return RoleStatus.REF_MBEAN_NOT_REGISTERED;
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"checkRoleInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return 0;
}
@ -3328,10 +3255,9 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"initializeMissingRoles", new Object[] {relationBaseFlag,
relationObj, relationObjName, relationId, relationTypeName,
roleInfoList});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3} {4} {5}",
relationBaseFlag, relationObj, relationObjName,
relationId, relationTypeName, roleInfoList);
// Can throw RelationServiceNotRegisteredException
isActive();
@ -3410,8 +3336,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"initializeMissingRoles");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -3528,9 +3453,9 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"sendNotificationInt", new Object[] {intNtfType, message,
relationId, unregMBeanList, roleName, roleNewValue, oldValue});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3} {4} {5} {6}",
intNtfType, message, relationId, unregMBeanList,
roleName, roleNewValue, oldValue);
// Relation type name
// Note: do not use getRelationTypeName() as if it is a relation MBean
@ -3616,8 +3541,7 @@ public class RelationService extends NotificationBroadcasterSupport
sendNotification(ntf);
RELATION_LOGGER.exiting(RelationService.class.getName(),
"sendNotificationInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -3654,9 +3578,8 @@ public class RelationService extends NotificationBroadcasterSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationService.class.getName(),
"handleReferenceUnregistration",
new Object[] {relationId, objectName, roleNameList});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
relationId, objectName, roleNameList);
// Can throw RelationServiceNotRegisteredException
isActive();
@ -3782,8 +3705,7 @@ public class RelationService extends NotificationBroadcasterSupport
}
}
RELATION_LOGGER.exiting(RelationService.class.getName(),
"handleReferenceUnregistration");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
}

137
jdk/src/java.management/share/classes/javax/management/relation/RelationSupport.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2017, 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
@ -27,8 +27,8 @@ package javax.management.relation;
import java.lang.System.Logger.Level;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
@ -162,8 +162,7 @@ public class RelationSupport
super();
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"RelationSupport");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
// Can throw InvalidRoleValueException and IllegalArgumentException
initMembers(relationId,
@ -172,8 +171,7 @@ public class RelationSupport
relationTypeName,
list);
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"RelationSupport");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
}
/**
@ -239,8 +237,7 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"RelationSupport");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
// Can throw InvalidRoleValueException and
// IllegalArgumentException
@ -250,8 +247,7 @@ public class RelationSupport
relationTypeName,
list);
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"RelationSupport");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
}
//
@ -286,15 +282,14 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"getRole", roleName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", roleName);
// Can throw RoleNotFoundException and
// RelationServiceNotRegisteredException
List<ObjectName> result = cast(
getRoleInt(roleName, false, null, false));
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getRole");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -324,12 +319,12 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(), "getRoles");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
// Can throw RelationServiceNotRegisteredException
RoleResult result = getRolesInt(roleNameArray, false, null);
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getRoles");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -346,8 +341,7 @@ public class RelationSupport
public RoleResult getAllRoles()
throws RelationServiceNotRegisteredException {
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"getAllRoles");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
RoleResult result = null;
try {
@ -356,7 +350,7 @@ public class RelationSupport
// OK : Invalid parameters, ignore...
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getAllRoles");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -367,8 +361,7 @@ public class RelationSupport
*/
public RoleList retrieveAllRoles() {
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"retrieveAllRoles");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
RoleList result;
synchronized(myRoleName2ValueMap) {
@ -376,8 +369,7 @@ public class RelationSupport
new RoleList(new ArrayList<Role>(myRoleName2ValueMap.values()));
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"retrieveAllRoles");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -400,8 +392,7 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"getRoleCardinality", roleName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", roleName);
// Try to retrieve the role
Role role;
@ -426,8 +417,7 @@ public class RelationSupport
List<ObjectName> roleValue = role.getRoleValue();
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"getRoleCardinality");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return roleValue.size();
}
@ -476,13 +466,12 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"setRole", role);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", role);
// Will return null :)
Object result = setRoleInt(role, false, null, false);
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRole");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -521,12 +510,11 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"setRoles", list);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", list);
RoleResult result = setRolesInt(list, false, null);
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRoles");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -570,9 +558,7 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"handleMBeanUnregistration",
new Object[]{objectName, roleName});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}", objectName, roleName);
// Can throw RoleNotFoundException, InvalidRoleValueException,
// or RelationTypeNotFoundException
@ -581,8 +567,7 @@ public class RelationSupport
false,
null);
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"handleMBeanUnregistration");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -594,8 +579,7 @@ public class RelationSupport
*/
public Map<ObjectName,List<String>> getReferencedMBeans() {
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"getReferencedMBeans");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
Map<ObjectName,List<String>> refMBeanMap =
new HashMap<ObjectName,List<String>>();
@ -628,8 +612,7 @@ public class RelationSupport
}
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"getReferencedMBeans");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return refMBeanMap;
}
@ -779,8 +762,7 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"getRoleInt", roleName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", roleName);
int pbType = 0;
@ -885,7 +867,7 @@ public class RelationSupport
}
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getRoleInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -921,8 +903,7 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"getRolesInt");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
RoleList roleList = new RoleList();
RoleUnresolvedList roleUnresList = new RoleUnresolvedList();
@ -966,8 +947,7 @@ public class RelationSupport
}
RoleResult result = new RoleResult(roleList, roleUnresList);
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"getRolesInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -991,8 +971,7 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"getAllRolesInt");
RELATION_LOGGER.log(Level.TRACE, "ENTRY");
List<String> roleNameList;
synchronized(myRoleName2ValueMap) {
@ -1006,8 +985,7 @@ public class RelationSupport
relationServCallFlg,
relationServ);
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"getAllRolesInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -1083,9 +1061,9 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"setRoleInt", new Object[] {aRole, relationServCallFlg,
relationServ, multiRoleFlg});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3}",
aRole, relationServCallFlg, relationServ,
multiRoleFlg);
String roleName = aRole.getRoleName();
int pbType = 0;
@ -1244,7 +1222,7 @@ public class RelationSupport
}
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRoleInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -1286,9 +1264,9 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"sendRoleUpdateNotification", new Object[] {newRole,
oldRoleValue, relationServCallFlg, relationServ});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3}",
newRole, oldRoleValue, relationServCallFlg,
relationServ);
if (relationServCallFlg) {
// Direct call to the Relation Service
@ -1341,8 +1319,7 @@ public class RelationSupport
}
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"sendRoleUpdateNotification");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -1383,9 +1360,9 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"updateRelationServiceMap", new Object[] {newRole,
oldRoleValue, relationServCallFlg, relationServ});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3}",
newRole, oldRoleValue, relationServCallFlg,
relationServ);
if (relationServCallFlg) {
// Direct call to the Relation Service
@ -1433,8 +1410,7 @@ public class RelationSupport
}
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"updateRelationServiceMap");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -1484,9 +1460,8 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"setRolesInt",
new Object[] {list, relationServCallFlg, relationServ});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
list, relationServCallFlg, relationServ);
RoleList roleList = new RoleList();
RoleUnresolvedList roleUnresList = new RoleUnresolvedList();
@ -1534,7 +1509,7 @@ public class RelationSupport
RoleResult result = new RoleResult(roleList, roleUnresList);
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRolesInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -1578,9 +1553,9 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"initMembers", new Object[] {relationId, relationServiceName,
relationServiceMBeanServer, relationTypeName, list});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3} {4}",
relationId, relationServiceName,
relationServiceMBeanServer, relationTypeName, list);
myRelId = relationId;
myRelServiceName = relationServiceName;
@ -1589,7 +1564,7 @@ public class RelationSupport
// Can throw InvalidRoleValueException
initRoleMap(list);
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "initMembers");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -1608,8 +1583,7 @@ public class RelationSupport
return;
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"initRoleMap", list);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", list);
synchronized(myRoleName2ValueMap) {
@ -1632,7 +1606,7 @@ public class RelationSupport
}
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "initRoleMap");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -1692,9 +1666,9 @@ public class RelationSupport
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"handleMBeanUnregistrationInt", new Object[] {objectName,
roleName, relationServCallFlg, relationServ});
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3}",
objectName, roleName, relationServCallFlg,
relationServ);
// Retrieves current role value
Role role;
@ -1723,8 +1697,7 @@ public class RelationSupport
Object result =
setRoleInt(newRole, relationServCallFlg, relationServ, false);
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"handleMBeanUnregistrationInt");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}

34
jdk/src/java.management/share/classes/javax/management/relation/RelationTypeSupport.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2006, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2017, 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
@ -42,7 +42,7 @@ import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
/**
* A RelationTypeSupport object implements the RelationType interface.
@ -173,15 +173,13 @@ public class RelationTypeSupport implements RelationType {
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
"RelationTypeSupport", relationTypeName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationTypeName);
// Can throw InvalidRelationTypeException, ClassNotFoundException
// and NotCompliantMBeanException
initMembers(relationTypeName, roleInfoArray);
RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
"RelationTypeSupport");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -199,13 +197,11 @@ public class RelationTypeSupport implements RelationType {
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
"RelationTypeSupport", relationTypeName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationTypeName);
typeName = relationTypeName;
RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
"RelationTypeSupport");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -251,8 +247,7 @@ public class RelationTypeSupport implements RelationType {
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
"getRoleInfo", roleInfoName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", roleInfoName);
// No null RoleInfo allowed, so use get()
RoleInfo result = roleName2InfoMap.get(roleInfoName);
@ -265,8 +260,7 @@ public class RelationTypeSupport implements RelationType {
throw new RoleInfoNotFoundException(excMsgStrB.toString());
}
RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
"getRoleInfo");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return result;
}
@ -297,8 +291,7 @@ public class RelationTypeSupport implements RelationType {
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
"addRoleInfo", roleInfo);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", roleInfo);
if (isInRelationService) {
// Trying to update a declared relation type
@ -319,8 +312,7 @@ public class RelationTypeSupport implements RelationType {
roleName2InfoMap.put(roleName, new RoleInfo(roleInfo));
RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
"addRoleInfo");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}
@ -351,8 +343,7 @@ public class RelationTypeSupport implements RelationType {
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
"initMembers", relationTypeName);
RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationTypeName);
typeName = relationTypeName;
@ -366,8 +357,7 @@ public class RelationTypeSupport implements RelationType {
new RoleInfo(currRoleInfo));
}
RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
"initMembers");
RELATION_LOGGER.log(Level.TRACE, "RETURN");
return;
}

76
jdk/src/java.management/share/classes/javax/management/timer/Timer.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2017, 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
@ -33,7 +33,7 @@ import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.Vector;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
// jmx imports
//
@ -221,8 +221,7 @@ public class Timer extends NotificationBroadcasterSupport
*/
public void preDeregister() throws java.lang.Exception {
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"preDeregister", "stop the timer");
TIMER_LOGGER.log(Level.TRACE, "stop the timer");
// Stop the timer.
//
@ -273,8 +272,7 @@ public class Timer extends NotificationBroadcasterSupport
*/
public synchronized void start() {
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"start", "starting the timer");
TIMER_LOGGER.log(Level.TRACE, "starting the timer");
// Start the TimerAlarmClock.
//
@ -323,11 +321,9 @@ public class Timer extends NotificationBroadcasterSupport
//
isActive = true;
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"start", "timer started");
TIMER_LOGGER.log(Level.TRACE, "timer started");
} else {
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"start", "the timer is already activated");
TIMER_LOGGER.log(Level.TRACE, "the timer is already activated");
}
}
@ -336,8 +332,7 @@ public class Timer extends NotificationBroadcasterSupport
*/
public synchronized void stop() {
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"stop", "stopping the timer");
TIMER_LOGGER.log(Level.TRACE, "stopping the timer");
// Stop the TimerAlarmClock.
//
@ -370,11 +365,9 @@ public class Timer extends NotificationBroadcasterSupport
//
isActive = false;
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"stop", "timer stopped");
TIMER_LOGGER.log(Level.TRACE, "timer stopped");
} else {
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"stop", "the timer is already deactivated");
TIMER_LOGGER.log(Level.TRACE, "the timer is already deactivated");
}
}
@ -444,9 +437,8 @@ public class Timer extends NotificationBroadcasterSupport
if (currentDate.after(date)) {
date.setTime(currentDate.getTime());
if (TIMER_LOGGER.isLoggable(Level.FINER)) {
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"addNotification",
if (TIMER_LOGGER.isLoggable(Level.TRACE)) {
TIMER_LOGGER.log(Level.TRACE,
"update timer notification to add with:" +
"\n\tNotification date = " + date);
}
@ -486,7 +478,7 @@ public class Timer extends NotificationBroadcasterSupport
obj[ALARM_CLOCK_INDEX] = (Object)alarmClock;
obj[FIXED_RATE_INDEX] = Boolean.valueOf(fixedRate);
if (TIMER_LOGGER.isLoggable(Level.FINER)) {
if (TIMER_LOGGER.isLoggable(Level.TRACE)) {
StringBuilder strb = new StringBuilder()
.append("adding timer notification:\n\t")
.append("Notification source = ")
@ -503,8 +495,7 @@ public class Timer extends NotificationBroadcasterSupport
.append(nbOccurences)
.append("\n\tNotification executes at fixed rate = ")
.append(fixedRate);
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"addNotification", strb.toString());
TIMER_LOGGER.log(Level.TRACE, strb::toString);
}
timerTable.put(notifID, obj);
@ -522,8 +513,7 @@ public class Timer extends NotificationBroadcasterSupport
}
}
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"addNotification", "timer notification added");
TIMER_LOGGER.log(Level.TRACE, "timer notification added");
return notifID;
}
@ -677,7 +667,7 @@ public class Timer extends NotificationBroadcasterSupport
// Remove the timer notification from the timer table.
//
if (TIMER_LOGGER.isLoggable(Level.FINER)) {
if (TIMER_LOGGER.isLoggable(Level.TRACE)) {
StringBuilder strb = new StringBuilder()
.append("removing timer notification:")
.append("\n\tNotification source = ")
@ -694,14 +684,12 @@ public class Timer extends NotificationBroadcasterSupport
.append(obj[TIMER_NB_OCCUR_INDEX])
.append("\n\tNotification executes at fixed rate = ")
.append(obj[FIXED_RATE_INDEX]);
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"removeNotification", strb.toString());
TIMER_LOGGER.log(Level.TRACE, strb::toString);
}
timerTable.remove(id);
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"removeNotification", "timer notification removed");
TIMER_LOGGER.log(Level.TRACE, "timer notification removed");
}
/**
@ -752,19 +740,16 @@ public class Timer extends NotificationBroadcasterSupport
}
// Remove all the timer notifications from the timer table.
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"removeAllNotifications", "removing all timer notifications");
TIMER_LOGGER.log(Level.TRACE, "removing all timer notifications");
timerTable.clear();
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"removeAllNotifications", "all timer notifications removed");
TIMER_LOGGER.log(Level.TRACE, "all timer notifications removed");
// Reset the counterID.
//
counterID = 0;
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"removeAllNotifications", "timer notification counter ID reset");
TIMER_LOGGER.log(Level.TRACE, "timer notification counter ID reset");
}
// GETTERS AND SETTERS
@ -1021,7 +1006,7 @@ public class Timer extends NotificationBroadcasterSupport
while ( (currentDate.after(date)) && (timerTable.containsKey(notifID)) ) {
if (currentFlag == true) {
if (TIMER_LOGGER.isLoggable(Level.FINER)) {
if (TIMER_LOGGER.isLoggable(Level.TRACE)) {
StringBuilder strb = new StringBuilder()
.append("sending past timer notification:")
.append("\n\tNotification source = ")
@ -1038,13 +1023,11 @@ public class Timer extends NotificationBroadcasterSupport
.append(obj[TIMER_NB_OCCUR_INDEX])
.append("\n\tNotification executes at fixed rate = ")
.append(obj[FIXED_RATE_INDEX]);
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"sendPastNotifications", strb.toString());
TIMER_LOGGER.log(Level.TRACE, strb::toString);
}
sendNotification(date, notif);
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"sendPastNotifications", "past timer notification sent");
TIMER_LOGGER.log(Level.TRACE, "past timer notification sent");
}
// Update the date and the number of occurrences of the timer notification.
@ -1107,7 +1090,7 @@ public class Timer extends NotificationBroadcasterSupport
timer.schedule(alarmClock, alarmClock.timeout);
}
}
if (TIMER_LOGGER.isLoggable(Level.FINER)) {
if (TIMER_LOGGER.isLoggable(Level.TRACE)) {
TimerNotification notif = (TimerNotification)obj[TIMER_NOTIF_INDEX];
StringBuilder strb = new StringBuilder()
.append("update timer notification with:")
@ -1125,8 +1108,7 @@ public class Timer extends NotificationBroadcasterSupport
.append(nbOccurences)
.append("\n\tNotification executes at fixed rate = ")
.append(fixedRate);
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"updateTimerTable", strb.toString());
TIMER_LOGGER.log(Level.TRACE, strb::toString);
}
}
else {
@ -1211,7 +1193,7 @@ public class Timer extends NotificationBroadcasterSupport
*/
void sendNotification(Date timeStamp, TimerNotification notification) {
if (TIMER_LOGGER.isLoggable(Level.FINER)) {
if (TIMER_LOGGER.isLoggable(Level.TRACE)) {
StringBuilder strb = new StringBuilder()
.append("sending timer notification:")
.append("\n\tNotification source = ")
@ -1222,8 +1204,7 @@ public class Timer extends NotificationBroadcasterSupport
.append(notification.getNotificationID())
.append("\n\tNotification date = ")
.append(timeStamp);
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"sendNotification", strb.toString());
TIMER_LOGGER.log(Level.TRACE, strb::toString);
}
long curSeqNumber;
synchronized(this) {
@ -1236,7 +1217,6 @@ public class Timer extends NotificationBroadcasterSupport
this.sendNotification((TimerNotification)notification.cloneTimerNotification());
}
TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
"sendNotification", "timer notification sent");
TIMER_LOGGER.log(Level.TRACE, "timer notification sent");
}
}

6
jdk/src/java.management/share/classes/javax/management/timer/TimerAlarmClock.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2017, 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
@ -26,7 +26,7 @@
package javax.management.timer;
import java.util.Date;
import java.util.logging.Level;
import java.lang.System.Logger.Level;
import static com.sun.jmx.defaults.JmxProperties.TIMER_LOGGER;
/**
@ -73,7 +73,7 @@ class TimerAlarmClock extends java.util.TimerTask {
TimerAlarmClockNotification notif = new TimerAlarmClockNotification(this);
listener.notifyAlarmClock(notif);
} catch (Exception e) {
TIMER_LOGGER.logp(Level.FINEST, Timer.class.getName(), "run",
TIMER_LOGGER.log(Level.TRACE,
"Got unexpected exception when sending a notification", e);
}
}

4
jdk/src/java.management/share/classes/module-info.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2014, 2017, 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
@ -31,7 +31,6 @@
*/
module java.management {
requires transitive java.rmi;
requires java.logging;
requires java.naming;
exports java.lang.management;
@ -55,4 +54,3 @@ module java.management {
provides javax.security.auth.spi.LoginModule
with com.sun.jmx.remote.security.FileLoginModule;
}

109
jdk/test/sun/management/LoggingTest/LoggingTest.java Normal file
View File

@ -0,0 +1,109 @@
/*
* Copyright (c) 2017, 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.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.lang.management.ManagementFactory;
import java.util.List;
import javax.management.MBeanServer;
import javax.management.ObjectName;
public class LoggingTest {
static class TestStream extends PrintStream {
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
private volatile boolean recording;
public TestStream(PrintStream wrapped) {
super(wrapped);
}
void startRecording() {
recording = true;
}
void stopRecording() {
recording = false;
}
@Override
public void write(int b) {
if (recording) {
bos.write(b);
}
super.write(b);
}
@Override
public void write(byte[] buf, int off, int len) {
if (recording) {
bos.write(buf, off, len);
}
super.write(buf, off, len);
}
@Override
public void write(byte[] buf) throws IOException {
if (recording) {
bos.write(buf);
}
super.write(buf);
}
}
public void run(TestStream ts) {
// start recording traces and trigger creation of the platform
// MBeanServer to produce some. This won't work if the platform
// MBeanServer was already initialized - so it's important to
// run this test in its own JVM.
ts.startRecording();
MBeanServer platform = ManagementFactory.getPlatformMBeanServer();
ts.stopRecording();
String printed = ts.bos.toString();
ts.bos.reset();
// Check that the Platform MBeanServer is emitting the expected
// log traces. This can be a bit fragile because debug traces
// could be changed without notice - in which case this test will
// need to be updated.
// For each registered MBean we expect to see three traces.
// If the messages logged by the MBeanServer change then these checks
// may need to be revisited.
List<String> checkTraces =
List.of("ObjectName = %s", "name = %s", "JMX.mbean.registered %s");
for (ObjectName o : platform.queryNames(ObjectName.WILDCARD, null)) {
String n = o.toString();
System.out.println("Checking log for: " + n);
for (String check : checkTraces) {
String s = String.format(check, n);
if (!printed.contains(s)) {
throw new RuntimeException("Trace not found: " + s);
}
}
}
}
}

51
jdk/test/sun/management/LoggingTest/LoggingWithJULTest.java Normal file
View File

@ -0,0 +1,51 @@
/*
* Copyright (c) 2017, 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.nio.file.Paths;
/**
* @test
* @bug 8172971
* @modules java.management java.logging
* @summary Smoke test to check that logging in java.management works as expected.
* @build LoggingTest LoggingWithJULTest
* @run main/othervm LoggingWithJULTest
* @author danielfuchs
*/
public class LoggingWithJULTest {
public static void main(String[] args) {
// Replace System.err
LoggingTest.TestStream ts = new LoggingTest.TestStream(System.err);
System.setErr(ts);
// activate the javax.management traces
String properties = Paths.get(System.getProperty("test.src", "src"),
"logging.properties").toString();
System.setProperty("java.util.logging.config.file", properties);
// run the test
new LoggingTest().run(ts);
}
}

46
jdk/test/sun/management/LoggingTest/LoggingWithLoggerFinderTest.java Normal file
View File

@ -0,0 +1,46 @@
/*
* Copyright (c) 2017, 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 8172971
* @modules java.management
* @summary Smoke test to check that logging in java.management is performed
* through System.Logger. This test installs a LoggerFinder service
* provider and verifies that it gets the traces.
* @build test.loggerfinder/test.loggerfinder.TestLoggerFinder LoggingTest LoggingWithLoggerFinderTest
* @run main/othervm --add-modules test.loggerfinder LoggingWithLoggerFinderTest
* @author danielfuchs
*/
public class LoggingWithLoggerFinderTest {
public static void main(String[] args) {
// Replace System.err
LoggingTest.TestStream ts = new LoggingTest.TestStream(System.err);
System.setErr(ts);
// run the test
new LoggingTest().run(ts);
}
}

55
jdk/test/sun/management/LoggingTest/logging.properties Normal file
View File

@ -0,0 +1,55 @@
############################################################
# Global properties
############################################################
# "handlers" specifies a comma separated list of log Handler
# classes. These handlers will be installed during VM startup.
# Note that these classes must be on the system classpath.
# By default we only configure a ConsoleHandler, which will only
# show messages at the INFO and above levels.
handlers= java.util.logging.ConsoleHandler
# To also add the FileHandler, use the following line instead.
#handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandler
# Default global logging level.
# This specifies which kinds of events are logged across
# all loggers. For any given facility this global level
# can be overriden by a facility specific level
# Note that the ConsoleHandler also has a separate level
# setting to limit messages printed to the console.
.level= INFO
############################################################
# Handler specific properties.
# Describes specific configuration info for Handlers.
############################################################
# default file output is in user's home directory.
java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
# Default number of locks FileHandler can obtain synchronously.
# This specifies maximum number of attempts to obtain lock file by FileHandler
# implemented by incrementing the unique field %u as per FileHandler API documentation.
java.util.logging.FileHandler.maxLocks = 100
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter
# Limit the message that are printed on the console to INFO and above.
java.util.logging.ConsoleHandler.level = ALL
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
# Example to customize the SimpleFormatter output format
# to print one-line log message like this:
# <level>: <log message> [<date/time>]
#
# java.util.logging.SimpleFormatter.format=%4$s: %5$s [%1$tc]%n
############################################################
# Facility specific properties.
# Provides extra control for each logger.
############################################################
# For example, set the com.xyz.foo logger to only log SEVERE
# messages:
javax.management.level = ALL

28
jdk/test/sun/management/LoggingTest/test.loggerfinder/module-info.java Normal file
View File

@ -0,0 +1,28 @@
/*
* Copyright (c) 2017, 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.
*/
module test.loggerfinder {
// Install a LoggerFinder that will direct traces directly to System.err,
// without involving java.util.logging
provides java.lang.System.LoggerFinder with test.loggerfinder.TestLoggerFinder;
}

177
jdk/test/sun/management/LoggingTest/test.loggerfinder/test/loggerfinder/TestLoggerFinder.java Normal file
View File

@ -0,0 +1,177 @@
/*
* Copyright (c) 2017, 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.
*/
package test.loggerfinder;
import java.lang.System.Logger;
import java.lang.System.Logger.Level;
import java.lang.System.LoggerFinder;
import java.lang.reflect.Module;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Optional;
import java.util.ResourceBundle;
import java.util.function.Predicate;
import java.lang.StackWalker.StackFrame;
import java.text.MessageFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
/**
* A LoggerFinder that provides System.Logger which print directly
* on System.err, without involving java.logging.
* For the purpose of the test, loggers whose name start with java.management.
* will log all messages, and other loggers will only log level > INFO.
* @author danielfuchs
*/
public class TestLoggerFinder extends LoggerFinder {
static class TestLogger implements Logger {
final String name;
public TestLogger(String name) {
this.name = name;
}
@Override
public String getName() {
return name;
}
@Override
public boolean isLoggable(Level level) {
return name.equals("javax.management")
|| name.startsWith("javax.management.")
|| level.getSeverity() >= Level.INFO.getSeverity();
}
@Override
public void log(Level level, ResourceBundle bundle, String msg, Throwable thrown) {
if (!isLoggable(level)) return;
publish(level, bundle, msg, thrown);
}
@Override
public void log(Level level, ResourceBundle bundle, String format, Object... params) {
if (!isLoggable(level)) return;
publish(level, bundle, format, params);
}
static void publish(Level level, ResourceBundle bundle, String msg, Throwable thrown) {
StackFrame sf = new CallerFinder().get().get();
if (bundle != null && msg != null) {
msg = bundle.getString(msg);
}
if (msg == null) msg = "";
LocalDateTime ldt = LocalDateTime.now();
String date = DateTimeFormatter.ISO_DATE_TIME.format(ldt);
System.err.println(date + " "
+ sf.getClassName() + " " + sf.getMethodName() + "\n"
+ String.valueOf(level) + ": " + msg);
thrown.printStackTrace(System.err);
}
static void publish(Level level, ResourceBundle bundle, String format, Object... params) {
StackFrame sf = new CallerFinder().get().get();
if (bundle != null && format != null) {
format = bundle.getString(format);
}
String msg = format(format, params);
LocalDateTime ldt = LocalDateTime.now();
String date = DateTimeFormatter.ISO_DATE_TIME.format(ldt);
System.err.println(date + " "
+ sf.getClassName() + " " + sf.getMethodName() + "\n"
+ String.valueOf(level) + ": " + msg);
}
static String format(String format, Object... args) {
if (format == null) return "";
int index = 0, len = format.length();
while ((index = format.indexOf(index, '{')) >= 0) {
if (index >= len - 2) break;
char c = format.charAt(index+1);
if (c >= '0' && c <= '9') {
return MessageFormat.format(format, args);
}
index++;
}
return format;
}
}
/*
* CallerFinder is a stateful predicate.
*/
static final class CallerFinder implements Predicate<StackWalker.StackFrame> {
private static final StackWalker WALKER;
static {
PrivilegedAction<StackWalker> pa =
() -> StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE);
WALKER = AccessController.doPrivileged(pa);
}
/**
* Returns StackFrame of the caller's frame.
* @return StackFrame of the caller's frame.
*/
Optional<StackWalker.StackFrame> get() {
return WALKER.walk((s) -> s.filter(this).findFirst());
}
private boolean lookingForLogger = true;
/**
* Returns true if we have found the caller's frame, false if the frame
* must be skipped.
*
* @param t The frame info.
* @return true if we have found the caller's frame, false if the frame
* must be skipped.
*/
@Override
public boolean test(StackWalker.StackFrame s) {
// We should skip all frames until we have found the logger,
// because these frames could be frames introduced by e.g. custom
// sub classes of Handler.
Class<?> c = s.getDeclaringClass();
boolean isLogger = System.Logger.class.isAssignableFrom(c);
if (lookingForLogger) {
// Skip all frames until we have found the first logger frame.
lookingForLogger = c != TestLogger.class;
return false;
}
// Continue walking until we've found the relevant calling frame.
// Skips logging/logger infrastructure.
return !isLogger;
}
}
@Override
public Logger getLogger(String name, Module module) {
return new TestLogger(name);
}
}