jdk-sandbox: comparison jdk/src/share/classes/javax/management/MBeanServerFactory.java

equal deleted inserted replaced

-:a9a142fcf1b5
+:bbc2d15aaf7a
 * have any questions.
 */
 package javax.management;
+import com.sun.jmx.defaults.JmxProperties;
 import static com.sun.jmx.defaults.JmxProperties.JMX_INITIAL_BUILDER;
 import static com.sun.jmx.defaults.JmxProperties.MBEANSERVER_LOGGER;
-import com.sun.jmx.interceptor.DefaultMBeanServerInterceptor;
 import com.sun.jmx.mbeanserver.GetPropertyAction;
+import com.sun.jmx.mbeanserver.Util;
 import java.security.AccessController;
 import java.security.Permission;
 import java.util.ArrayList;
+import java.util.List;
 import java.util.logging.Level;
 import javax.management.loading.ClassLoaderRepository;
 /**
 * <p>Provides MBean server references.  There are no instances of
 * this class.</p>
 *
 *
 * <p>The MBeanServerBuilder makes it possible to wrap the MBeanServers
 * returned by the default MBeanServerBuilder implementation, for the purpose
 * of e.g. adding an additional security layer.</p>
 *
+* <p id="MBeanServerName">Since version 2.0 of the JMX API, when creating
+* an MBeanServer,
+* it is possible to specify an {@linkplain #getMBeanServerName
+* MBean Server name}.
+* To create an MBean Server with a name, the MBeanServerFactory provides two
+* new methods:</p>
+* <ul><li>{@link #createNamedMBeanServer
+* createNamedMBeanServer(mbeanServerName, defaultDomain)}: creates a named
+* MBeanServer and keeps an internal reference to the created object. The
+* MBeanServer can be later retrieved using {@link #findMBeanServer
+* findMBeanServer(mbeanServerId)} or
+* {@link #findMBeanServerByName findMBeanServerByName(mbeanServerName)}, and
+* can be released through {@link
+* #releaseMBeanServer releaseMBeanServer(mbeanServer)}.</li>
+* <li>{@link #newNamedMBeanServer
+* newNamedMBeanServer(mbeanServerName, defaultDomain)}:
+* creates a named MBeanServer without keeping any internal reference to the
+* named server.</li>
+* </ul>
+* <p>The name of the MBeanServer is stored in the
+* {@linkplain MBeanServerDelegate MBean Server delegate MBean}
+* and is embedded in its {@link MBeanServerDelegate#getMBeanServerId
+* MBeanServerId} attribute.</p>
+* <p>The name of the MBeanServer is particularly useful when
+* <a href="MBeanServer.html#security">MBean permissions</a> are checked:
+* it makes it
+* possible to distinguish between an MBean named "X" in MBeanServer named
+* "M1", and another MBean of the same name "X" in another MBeanServer named
+* "M2".</p>
+* <p>When naming MBean servers it is recommended to use a name that starts
+* with a Java package name. It is also recommended that the default domain and
+* the MBeanServer name be the same.</p>
+*
 * @since 1.5
 */
 public class MBeanServerFactory {
+/**
+* The <a href="#MBeanServerName">MBean Server name</a> that will be
+* checked by a <a href="MBeanServer.html#security">permission you need</a>
+* when checking access to an MBean registered in an MBeanServer for
+* which no MBeanServer name was specified.
+*
+* @since 1.7
+*/
+public final static String DEFAULT_MBEANSERVER_NAME = "default";
 /*
 * There are no instances of this class so don't generate the
 * default public constructor.
 */
 *
 * @exception ClassCastException if the property
 * <code>javax.management.builder.initial</code> exists and can be
 * instantiated but is not assignment compatible with {@link
 * MBeanServerBuilder}.
+*
+* @see #createNamedMBeanServer
 */
 public static MBeanServer createMBeanServer(String domain)  {
-checkPermission("createMBeanServer");
+return createMBeanServer(null,domain);
+}
-final MBeanServer mBeanServer = newMBeanServer(domain);
-addMBeanServer(mBeanServer);
+/**
-return mBeanServer;
+* <p>Return a new object implementing the {@link MBeanServer}
-}
+* interface with the specified
+* <a href="#MBeanServerName">MBean Server name</a>
-/**
+* and default domain name. The given MBean server name
-* <p>Return a new object implementing the MBeanServer interface
+* is used in <a href="MBeanServer.html#security">security checks</a>, and
-* with a standard default domain name, without keeping an
+* can also be used to {@linkplain #findMBeanServerByName(java.lang.String)
-* internal reference to this new object.  The default domain name
+* find an MBeanServer by name}. The given
-* is used as the domain part in the ObjectName of MBeans when the
+* domain name is used as the domain part in the ObjectName of
-* domain is specified by the user is null.</p>
+* MBeans when the domain is specified by the user is null.</p>
 *
-* <p>The standard default domain name is
+* <p>The MBeanServer reference is internally kept. This will
-* <code>DefaultDomain</code>.</p>
+* allow <CODE>findMBeanServer</CODE> to return a reference to
-*
+* this MBeanServer object.</p>
-* <p>No reference is kept. <CODE>findMBeanServer</CODE> will not
+*
-* be able to return a reference to this MBeanServer object, but
+* @param mbeanServerName the name for the created
-* the garbage collector will be able to remove the MBeanServer
+* MBeanServer.  This is the name that will be included in the
-* object when it is no longer referenced.</p>
+* {@linkplain MBeanPermission permission you need} when checking
-*
+* <a href="MBeanServer.html#security">MBean Permissions</a> for accessing
-* <p>This method is equivalent to <code>newMBeanServer(null)</code>.</p>
+* an MBean registered in the returned MBeanServer. The characters
+* {@code ':'} (colon), {@code ';'} (semicolon), {@code '*'} (star)
+* and  {@code '?'} are not legal.
+* It is recommended that the {@code mbeanServerName}
+* be unique in the context of a JVM, and in the form of a java package
+* identifier. If {@code mbeanServerName} is {@code null} then the created
+* MBean Server has no name - and {@value #DEFAULT_MBEANSERVER_NAME} is used.
+* Calling {@code createNamedMBeanServer(null,domain)} is equivalent
+* to calling {@link #createMBeanServer(String) createMBeanServer(domain)}.
+*
+* @param domain the default domain name for the created
+* MBeanServer.  This is the value that will be returned by {@link
+* MBeanServer#getDefaultDomain}. If a non null mbeanServerName is given,
+* it is recommended to pass the same value as default domain.
 *
 * @return the newly created MBeanServer.
 *
-* @exception SecurityException if there is a SecurityManager and the
+* @exception SecurityException if there is a SecurityManager and
-* caller's permissions do not include or imply <code>{@link
+* the caller's permissions do not include or imply <code>{@link
-* MBeanServerPermission}("newMBeanServer")</code>.
+* MBeanServerPermission}("createMBeanServer")</code>.
 *
 * @exception JMRuntimeException if the property
 * <code>javax.management.builder.initial</code> exists but the
 * class it names cannot be instantiated through a public
 * no-argument constructor; or if the instantiated builder returns
 *
 * @exception ClassCastException if the property
 * <code>javax.management.builder.initial</code> exists and can be
 * instantiated but is not assignment compatible with {@link
 * MBeanServerBuilder}.
-*/
+*
-public static MBeanServer newMBeanServer() {
+* @exception IllegalArgumentException if the specified
-return newMBeanServer(null);
+* {@code mbeanServerName} is empty, or is {@code "-"}, or contains a
+* character which is not legal.
+*
+* @exception UnsupportedOperationException if the specified
+* {@code mbeanServerName} cannot be set.
+*
+* @since 1.7
+*/
+public static MBeanServer createNamedMBeanServer(String mbeanServerName,
+String domain)  {
+return createMBeanServer(mbeanServerName, domain);
 }
 /**
 * <p>Return a new object implementing the MBeanServer interface
-* with the specified default domain name, without keeping an
+* with a standard default domain name, without keeping an
-* internal reference to this new object.  The given domain name
+* internal reference to this new object.  The default domain name
 * is used as the domain part in the ObjectName of MBeans when the
 * domain is specified by the user is null.</p>
+*
+* <p>The standard default domain name is
+* <code>DefaultDomain</code>.</p>
 *
 * <p>No reference is kept. <CODE>findMBeanServer</CODE> will not
 * be able to return a reference to this MBeanServer object, but
 * the garbage collector will be able to remove the MBeanServer
 * object when it is no longer referenced.</p>
 *
-* @param domain the default domain name for the created
+* <p>This method is equivalent to <code>newMBeanServer(null)</code>.</p>
-* MBeanServer.  This is the value that will be returned by {@link
-* MBeanServer#getDefaultDomain}.
 *
 * @return the newly created MBeanServer.
 *
 * @exception SecurityException if there is a SecurityManager and the
 * caller's permissions do not include or imply <code>{@link
 * @exception ClassCastException if the property
 * <code>javax.management.builder.initial</code> exists and can be
 * instantiated but is not assignment compatible with {@link
 * MBeanServerBuilder}.
 */
+public static MBeanServer newMBeanServer() {
+return newMBeanServer(null);
+}
+/**
+* <p>Return a new object implementing the MBeanServer interface
+* with the specified default domain name, without keeping an
+* internal reference to this new object.  The given domain name
+* is used as the domain part in the ObjectName of MBeans when the
+* domain is specified by the user is null.</p>
+*
+* <p>No reference is kept. <CODE>findMBeanServer</CODE> will not
+* be able to return a reference to this MBeanServer object, but
+* the garbage collector will be able to remove the MBeanServer
+* object when it is no longer referenced.</p>
+*
+* @param domain the default domain name for the created
+* MBeanServer.  This is the value that will be returned by {@link
+* MBeanServer#getDefaultDomain}.
+*
+* @return the newly created MBeanServer.
+*
+* @exception SecurityException if there is a SecurityManager and the
+* caller's permissions do not include or imply <code>{@link
+* MBeanServerPermission}("newMBeanServer")</code>.
+*
+* @exception JMRuntimeException if the property
+* <code>javax.management.builder.initial</code> exists but the
+* class it names cannot be instantiated through a public
+* no-argument constructor; or if the instantiated builder returns
+* null from its {@link MBeanServerBuilder#newMBeanServerDelegate
+* newMBeanServerDelegate} or {@link
+* MBeanServerBuilder#newMBeanServer newMBeanServer} methods.
+*
+* @exception ClassCastException if the property
+* <code>javax.management.builder.initial</code> exists and can be
+* instantiated but is not assignment compatible with {@link
+* MBeanServerBuilder}.
+*/
 public static MBeanServer newMBeanServer(String domain)  {
+return newMBeanServer(null,domain);
+}
+/**
+* <p>Return a new object implementing the MBeanServer interface
+* with the specified <a href="#MBeanServerName">MBean server name</a>
+* and default domain name, without keeping an
+* internal reference to this new object.  The given MBean server name
+* is used in <a href="MBeanServer.html#security">security checks</a>.
+* The given domain name
+* is used as the domain part in the ObjectName of MBeans when the
+* domain is specified by the user is null.</p>
+*
+* <p>No reference is kept. <CODE>findMBeanServer</CODE> and
+* <CODE>findMBeanServerByName</CODE> will not
+* be able to return a reference to this MBeanServer object, but
+* the garbage collector will be able to remove the MBeanServer
+* object when it is no longer referenced.</p>
+*
+* @param mbeanServerName the name for the created
+* MBeanServer.  This is the name that will be included in the
+* {@linkplain MBeanPermission permission you need} when checking
+* <a href="MBeanServer.html#security">MBean Permissions</a> for accessing
+* an MBean registered in the returned MBeanServer. The characters
+* {@code ':'} (colon), {@code ';'} (semicolon), {@code '*'} (star)
+* and  {@code '?'} are not legal.
+* It is recommended that the mbeanServerName
+* be unique in the context of a JVM, and in the form of a java package
+* identifier. If {@code mbeanServerName} is {@code null} then the created
+* MBean Server has no name - and {@value #DEFAULT_MBEANSERVER_NAME} is used.
+* Calling {@code newNamedMBeanServer(null,domain)} is equivalent
+* to calling {@link #newMBeanServer(String) newMBeanServer(domain)}.
+*
+* @param domain the default domain name for the created
+* MBeanServer.  This is the value that will be returned by {@link
+* MBeanServer#getDefaultDomain}.
+*
+* @return the newly created MBeanServer.
+*
+* @exception SecurityException if there is a SecurityManager and the
+* caller's permissions do not include or imply <code>{@link
+* MBeanServerPermission}("newMBeanServer")</code>.
+*
+* @exception JMRuntimeException if the property
+* <code>javax.management.builder.initial</code> exists but the
+* class it names cannot be instantiated through a public
+* no-argument constructor; or if the instantiated builder returns
+* null from its {@link MBeanServerBuilder#newMBeanServerDelegate
+* newMBeanServerDelegate} or {@link
+* MBeanServerBuilder#newMBeanServer newMBeanServer} methods.
+*
+* @exception ClassCastException if the property
+* <code>javax.management.builder.initial</code> exists and can be
+* instantiated but is not assignment compatible with {@link
+* MBeanServerBuilder}.
+*
+* @exception IllegalArgumentException if the specified
+* {@code mbeanServerName} is empty, or is {@code "-"},
+* or contains a character which is not legal.
+*
+* @exception UnsupportedOperationException if the specified
+* {@code mbeanServerName} cannot be set.
+*
+* @since 1.7
+*/
+public static MBeanServer newNamedMBeanServer(String mbeanServerName,
+String domain)  {
+return newMBeanServer(mbeanServerName, domain);
+}
+private static MBeanServer createMBeanServer(String mbeanServerName,
+String domain)  {
+checkPermission("createMBeanServer");
+final MBeanServer mBeanServer =
+newMBeanServer(mbeanServerName,domain);
+addMBeanServer(mBeanServer);
+return mBeanServer;
+}
+private static MBeanServer newMBeanServer(String mbeanServerName,
+String domain) {
 checkPermission("newMBeanServer");
 // Get the builder. Creates a new one if necessary.
 //
 final MBeanServerBuilder mbsBuilder = getNewMBeanServerBuilder();
 // Returned value cannot be null.  NullPointerException if violated.
 synchronized(mbsBuilder) {
 final MBeanServerDelegate delegate  =
 mbsBuilder.newMBeanServerDelegate();
 if (delegate == null) {
 final String msg =
 "MBeanServerBuilder.newMBeanServerDelegate() " +
 "returned null";
 throw new JMRuntimeException(msg);
 }
+// Sets the name on the delegate. For complex backward
+// compatibility reasons it is not possible to give the
+// name to the MBeanServerDelegate constructor.
+//
+// The method setMBeanServerName() will call getMBeanServerId()
+// to check that the name is accurately set in the MBeanServerId.
+// If not (which could happen if a custom MBeanServerDelegate
+// implementation overrides getMBeanServerId() and was not updated
+// with respect to JMX 2.0 spec, this method will throw an
+// IllegalStateException...
+//
+if (!Util.isMBeanServerNameUndefined(mbeanServerName)) {
+delegate.setMBeanServerName(mbeanServerName);
+}
 final MBeanServer mbeanServer =
 mbsBuilder.newMBeanServer(domain,null,delegate);
 if (mbeanServer == null) {
 final String msg =
 "MBeanServerBuilder.newMBeanServer() returned null";
 throw new JMRuntimeException(msg);
 }
+// double check that the MBeanServer name is correctly set.
+// "*" might mean that the caller doesn't have the permission
+// to see the MBeanServer name.
+//
+final String mbsName = Util.getMBeanServerSecurityName(mbeanServer);
+if (!mbsName.equals(Util.checkServerName(mbeanServerName))
+&& !mbsName.equals("*")) {
+throw new UnsupportedOperationException(
+"can't create MBeanServer with name \""+
+mbeanServerName+"\" using "+
+builder.getClass().getName());
+}
 return mbeanServer;
 }
 }
 /**
 if (agentId == null)
 return new ArrayList<MBeanServer>(mBeanServerList);
 ArrayList<MBeanServer> result = new ArrayList<MBeanServer>();
 for (MBeanServer mbs : mBeanServerList) {
-String name = mBeanServerName(mbs);
+String name = mBeanServerId(mbs);
 if (agentId.equals(name))
 result.add(mbs);
 }
 return result;
 }
 /**
+* <p>Returns a list of registered MBeanServer objects with the given name.  A
+* registered MBeanServer object is one that was created by one of
+* the <code>createMBeanServer</code> or <code>createNamedMBeanServer</code>
+* methods and not subsequently released with <code>releaseMBeanServer</code>.</p>
+* <p>See the section about <a href="#MBeanServerName">MBean Server names</a>
+* above.</p>
+*
+* @param mbeanServerName The name of the MBeanServer to
+* retrieve.  If this parameter is null, all registered MBeanServers
+* in this JVM are returned.
+* Otherwise, only those MBeanServers that have a name
+* matching <code>mbeanServerName</code> are returned: this
+* parameter can be a pattern, where {@code '*'} matches any
+* sequence of characters and {@code '?'} matches any character.<br>
+* The name of an MBeanServer, if specified, is embedded in the
+* <code>MBeanServerId</code> attribute of its delegate MBean:
+* this method will parse the <code>MBeanServerId</code> to get the
+* MBeanServer name. If this parameter is equal to {@code "*"} then
+* all registered MBeanServers in this JVM are returned, whether they have
+* a name or not: {@code findMBeanServerByName(null)},
+* {@code findMBeanServerByName("*")} and {@code findMBeanServer(null)},
+* are equivalent. It is also possible to get all MBeanServers for which
+* no name was specified by calling <code>findMBeanServerByName({@value
+* #DEFAULT_MBEANSERVER_NAME})</code>.
+*
+* @return A list of MBeanServer objects.
+*
+* @exception SecurityException if there is a SecurityManager and the
+* caller's permissions do not include or imply <code>{@link
+* MBeanServerPermission}("findMBeanServer")</code>.
+*
+* @see #getMBeanServerName(MBeanServer)
+* @since 1.7
+*/
+public synchronized static
+List<MBeanServer> findMBeanServerByName(String mbeanServerName) {
+checkPermission("findMBeanServer");
+if (mbeanServerName==null || "*".equals(mbeanServerName))
+return new ArrayList<MBeanServer>(mBeanServerList);
+// noname=true iff we are looking for MBeanServers for which no name
+// were specified.
+ArrayList<MBeanServer> result = new ArrayList<MBeanServer>();
+for (MBeanServer mbs : mBeanServerList) {
+final String name = Util.getMBeanServerSecurityName(mbs);
+if (Util.wildmatch(name, mbeanServerName)) result.add(mbs);
+}
+return result;
+}
+/**
+* Returns the name of the MBeanServer embedded in the MBeanServerId of
+* the given {@code server}. If the given MBeanServerId doesn't contain
+* any name, {@value #DEFAULT_MBEANSERVER_NAME} is returned.
+* The MBeanServerId is expected to be of the form:
+* {@code *[;mbeanServerName=<mbeanServerName>[;*]]}
+* <br>where {@code *} denotes any sequence of characters, and {@code [ ]}
+* indicate optional parts.
+* </p>
+* <p>For instance, if an MBeanServer is created using {@link
+* #createNamedMBeanServer(java.lang.String, java.lang.String)
+* server =
+* MBeanServerFactory.createNamedMBeanServer("com.mycompany.myapp.server1",
+* null)} then {@code MBeanServerFactory.getMBeanServerName(server)}
+* will return {@code "com.mycompany.myapp.server1"} and
+* <code>server.getAttribute({@link
+* javax.management.MBeanServerDelegate#DELEGATE_NAME
+* MBeanServerDelegate.DELEGATE_NAME}, "MBeanServerId")</code> will return
+* something like
+* {@code "myhost_1213353064145;mbeanServerName=com.mycompany.myapp.server1"}.
+* </p>
+* <p>See the section about <a href="#MBeanServerName">MBean Server names</a>
+* above.</p>
+* @param  server A named (or unnamed) MBeanServer.
+* @return the name of the MBeanServer if found, or
+*         {@value #DEFAULT_MBEANSERVER_NAME} if no name is
+*         present in its MBeanServerId, or "*" if its
+*         MBeanServerId couldn't be obtained. Returning "*" means that
+*         only {@link MBeanPermission}s that allow all MBean Server names
+*         will apply to this MBean Server.
+* @see MBeanServerDelegate
+* @since 1.7
+*/
+public static String getMBeanServerName(MBeanServer server) {
+return Util.getMBeanServerSecurityName(server);
+}
+/**
 * Return the ClassLoaderRepository used by the given MBeanServer.
-* This method is equivalent to {@link MBeanServer#getClassLoaderRepository() server.getClassLoaderRepository()}.
+* This method is equivalent to {@link
+* MBeanServer#getClassLoaderRepository() server.getClassLoaderRepository()}.
 * @param server The MBeanServer under examination. Since JMX 1.2,
 * if <code>server</code> is <code>null</code>, the result is a
 * {@link NullPointerException}.  This behavior differs from what
 * was implemented in JMX 1.1 - where the possibility to use
 * <code>null</code> was deprecated.
 *
 * @exception NullPointerException if <code>server</code> is null.
 *
 **/
 public static ClassLoaderRepository getClassLoaderRepository(
 MBeanServer server) {
 return server.getClassLoaderRepository();
 }
-private static String mBeanServerName(MBeanServer mbs) {
+private static String mBeanServerId(MBeanServer mbs) {
 try {
 return (String) mbs.getAttribute(MBeanServerDelegate.DELEGATE_NAME,
 "MBeanServerId");
 } catch (JMException e) {
+JmxProperties.MISC_LOGGER.finest(
+"Ignoring exception while getting MBeanServerId: "+e);
 return null;
 }
 }
 private static void checkPermission(String action)
 throws SecurityException {
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 Permission perm = new MBeanServerPermission(action);
 sm.checkPermission(perm);
 }
 throw new IllegalArgumentException("MBeanServer was not in list!");
 }
 }
 private static final ArrayList<MBeanServer> mBeanServerList =
 new ArrayList<MBeanServer>();
 /**
 * Load the builder class through the context class loader.
 * @param builderClassName The name of the builder class.
 **/
 private static Class loadBuilderClass(String builderClassName)
 throws ClassNotFoundException {
 final ClassLoader loader =
 Thread.currentThread().getContextClassLoader();
 if (loader != null) {
 // Try with context class loader
 return loader.loadClass(builderClassName);
 }
 * If any checked exception needs to be thrown, it is embedded in
 * a JMRuntimeException.
 **/
 private static MBeanServerBuilder newBuilder(Class builderClass) {
 try {
-final Object builder = builderClass.newInstance();
+final Object abuilder = builderClass.newInstance();
-return (MBeanServerBuilder)builder;
+return (MBeanServerBuilder)abuilder;
 } catch (RuntimeException x) {
 throw x;
 } catch (Exception x) {
 final String msg =
 "Failed to instantiate a MBeanServerBuilder from " +
 builderClass + ": " + x;
 throw new JMRuntimeException(msg, x);
 }
 }
 /**
 * javax.management.builder.initial System property - if needed.
 **/
 private static synchronized void checkMBeanServerBuilder() {
 try {
 GetPropertyAction act =
 new GetPropertyAction(JMX_INITIAL_BUILDER);
 String builderClassName = AccessController.doPrivileged(act);
 try {
 final Class newBuilderClass;
 if (builderClassName == null || builderClassName.length() == 0)
 // Create a new builder
 builder = newBuilder(newBuilderClass);
 } catch (ClassNotFoundException x) {
 final String msg =
 "Failed to load MBeanServerBuilder class " +
 builderClassName + ": " + x;
 throw new JMRuntimeException(msg, x);
 }
 } catch (RuntimeException x) {
 if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
 StringBuilder strb = new StringBuilder()

changeset 1156	bbc2d15aaf7a
parent 2	90ce3da70b43
child 1247	b4c26443dee5