libjava/classpath/javax/management/MBeanServerFactory.java

   1 /* MBeanServerFactory.java -- Manages server instances.
   2    Copyright (C) 2006 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 package javax.management;
  39
  40 import gnu.classpath.SystemProperties;
  41
  42 import java.util.ArrayList;
  43 import java.util.HashMap;
  44 import java.util.Iterator;
  45 import java.util.Map;
  46
  47 import javax.management.loading.ClassLoaderRepository;
  48
  49 /**
  50  * <p>
  51  * Creates and maintains a set of {@link MBeanServer} instances.
  52  * Server instances, as of JMX 1.2, are created using a subclass
  53  * of {@link MBeanServerBuilder}.  The exact class used is controlled
  54  * by the property <code>javax.management.builder.initial</code>,
  55  * and allows the instances created by {@link MBeanServerBuilder}
  56  * to be wrapped, thus providing additional functionality.
  57  * </p>
  58  * <p>
  59  * The property is used as follows:
  60  * </p>
  61  * <ol>
  62  * <li>If the property has no value, then an instance of
  63  * {@link MBeanServerBuilder} is used.</li>
  64  * <li>If a value is given, then:
  65  * <ol>
  66  * <li>The class is loaded using
  67  * <code>Thread.currentThread().getContextClassLoader()</code>, or,
  68  * if this is <code>null</code>, by <code>Class.forName()</code>.</li>
  69  * <li><code>Class.newInstance()</code> is used to create an instance
  70  * of the class.  The class must be public and have a public empty
  71  * constructor.  If an exception is thrown, it is propogated as
  72  * a {@link JMRuntimeException} and no new server instances may be
  73  * created until the property is set to a valid value.</li>
  74  * </ol></li>
  75  * <li>The value is checked on each successive request for a server.
  76  * If it differs from the class of the existing instance of
  77  * {@link MBeanServerBuilder}, then the value is used to create
  78  * a new instance.</li>
  79  * </ol>
  80  */
  81 public class MBeanServerFactory
  82 {
  83
  84   /**
  85    * The last builder instance.
  86    */
  87   private static MBeanServerBuilder builder;
  88
  89   /**
  90    * The map of registered servers (identifiers to servers).
  91    */
  92   private static final Map<Object,MBeanServer> servers =
  93     new HashMap<Object,MBeanServer>();
  94
  95   /**
  96    * Private constructor to prevent instance creation.
  97    */
  98   private MBeanServerFactory() {}
  99
 100   /**
 101    * Returns a server implementation using the default domain name
 102    * of <code>"DefaultDomain"</code>.  The default domain name is
 103    * used when the domain name specified by the user is <code>null</code.
 104    * A reference to the created server is retained, so that it can
 105    * be retrieved at a later date using {@link #findMBeanServer}.
 106    * Calling this method is equivalent to calling
 107    * {@link createMBeanServer(String)} with a <code>null</code> value.
 108    *
 109    * @return a new {@link MBeanServer} instance.
 110    * @throws SecurityException if a security manager exists and the
 111    *                           caller's permissions don't imply {@link
 112    *                           MBeanServerPermission(String)}("createMBeanServer")
 113    * @throws JMRuntimeException if the property
 114    *                     <code>javax.management.builder.initial</code>
 115    *                     exists but names a class which either can not be
 116    *                     instantiated or provides an implementation that returns
 117    *                     <code>null</code> from either
 118    *                     {@link MBeanServerBuilder#newMBeanServerDelegate()}
 119    *                     or {@link MBeanServerBuilder#newMBeanServer()}
 120    * @throws ClassCastException if the property
 121    *                     <code>javax.management.builder.initial</code>
 122    *                     exists but names a class which is not a subclass
 123    *                     of {@link MBeanServerBuilder}.
 124    * @see #createMBeanServer(String)
 125    */
 126   public static MBeanServer createMBeanServer()
 127   {
 128     return createMBeanServer(null);
 129   }
 130
 131   /**
 132    * Returns a server implementation using the default domain name
 133    * given, or <code>"DefaultDomain"</code> if this is <code>null</code>.
 134    * The default domain name is used when the domain name specified by
 135    * the user is <code>null</code.  A reference to the created server is
 136    * retained, so that it can be retrieved at a later date using
 137    * {@link #findMBeanServer}.
 138    *
 139    * @param domain the default domain name of the server.
 140    * @return a new {@link MBeanServer} instance.
 141    * @throws SecurityException if a security manager exists and the
 142    *                           caller's permissions don't imply {@link
 143    *                           MBeanServerPermission(String)}("createMBeanServer")
 144    * @throws JMRuntimeException if the property
 145    *                     <code>javax.management.builder.initial</code>
 146    *                     exists but names a class which either can not be
 147    *                     instantiated or provides an implementation that returns
 148    *                     <code>null</code> from either
 149    *                     {@link MBeanServerBuilder#newMBeanServerDelegate()}
 150    *                     or {@link MBeanServerBuilder#newMBeanServer()}
 151    * @throws ClassCastException if the property
 152    *                     <code>javax.management.builder.initial</code>
 153    *                     exists but names a class which is not a subclass
 154    *                     of {@link MBeanServerBuilder}.
 155    */
 156   public static MBeanServer createMBeanServer(String domain)
 157   {
 158     SecurityManager sm = System.getSecurityManager();
 159     if (sm != null)
 160       sm.checkPermission(new MBeanServerPermission("createMBeanServer"));
 161     MBeanServer server = createServer(domain);
 162     try
 163       {
 164         ObjectName dn = new
 165           ObjectName("JMImplementation:type=MBeanServerDelegate");
 166         servers.put(server.getAttribute(dn, "MBeanServerId"), server);
 167       }
 168     catch (MalformedObjectNameException e)
 169       {
 170         throw (Error)
 171           (new InternalError("Malformed delegate bean name.").initCause(e));
 172       }
 173     catch (MBeanException e)
 174       {
 175         throw (Error)
 176           (new InternalError("Exception in getMBeanServerId().").initCause(e));
 177       }
 178     catch (AttributeNotFoundException e)
 179       {
 180         throw (Error)
 181           (new InternalError("Could not find MBeanServerId attribute.").initCause(e));
 182       }
 183     catch (InstanceNotFoundException e)
 184       {
 185         throw (Error)
 186           (new InternalError("Could not find the delegate bean.").initCause(e));
 187       }
 188     catch (ReflectionException e)
 189       {
 190         throw (Error)
 191           (new InternalError("Could not call getMBeanServerId().").initCause(e));
 192       }
 193     return server;
 194   }
 195
 196   /**
 197    * Returns the specified server, or, if <code>id</code> is <code>null</code>,
 198    * a list of all registered servers.  A registered server is one that
 199    * was created using {@link #createMBeanServer()} or
 200    * {@link #createMBeanServer(String)} and has not yet been released
 201    * using {@link releaseMBeanServer(MBeanServer)}.
 202    *
 203    * @param id the id of the server to retrieve, or <code>null</code>
 204    *           to return all servers.
 205    * @return a list of {@link MBeanServer}s.
 206    * @throws SecurityException if a security manager exists and the
 207    *                           caller's permissions don't imply {@link
 208    *                           MBeanServerPermission(String)}("findMBeanServer")
 209    */
 210   public static ArrayList<MBeanServer> findMBeanServer(String id)
 211   {
 212     SecurityManager sm = System.getSecurityManager();
 213     if (sm != null)
 214       sm.checkPermission(new MBeanServerPermission("findMBeanServer"));
 215     if (id == null)
 216       return new ArrayList<MBeanServer>(servers.values());
 217     ArrayList<MBeanServer> list = new ArrayList<MBeanServer>();
 218     MBeanServer server = servers.get(id);
 219     if (server != null)
 220       list.add(servers.get(id));
 221     return list;
 222   }
 223
 224   /**
 225    * Returns the class loader repository used by the specified server.
 226    * This is equivalent to calling {@link MBeanServer#getClassLoaderRepository()}
 227    * on the given server.
 228    *
 229    * @param server the server whose class loader repository should be
 230    *               retrieved.
 231    * @throws NullPointerException if <code>server</code> is <code>null</code>.
 232    * @throws SecurityException if a security manager exists and the
 233    *                           caller's permissions don't imply {@link
 234    *                           MBeanPermission(String,String,ObjectName,String)
 235    *                           <code>MBeanPermission(null, null, null,
 236    *                           "getClassLoaderRepository")</code>
 237    */
 238   public static ClassLoaderRepository getClassLoaderRepository(MBeanServer server)
 239   {
 240     return server.getClassLoaderRepository();
 241   }
 242
 243   /**
 244    * Returns a server implementation using the default domain name
 245    * of <code>"DefaultDomain"</code>.  The default domain name is
 246    * used when the domain name specified by the user is <code>null</code.
 247    * No reference to the created server is retained, so the server is
 248    * garbage collected when it is no longer used, but it can not be
 249    * retrieved at a later date using {@link #findMBeanServer}.
 250    * Calling this method is equivalent to calling
 251    * {@link newMBeanServer(String)} with a <code>null</code> value.
 252    *
 253    * @return a new {@link MBeanServer} instance.
 254    * @throws SecurityException if a security manager exists and the
 255    *                           caller's permissions don't imply {@link
 256    *                           MBeanServerPermission(String)}("newMBeanServer")
 257    * @throws JMRuntimeException if the property
 258    *                     <code>javax.management.builder.initial</code>
 259    *                     exists but names a class which either can not be
 260    *                     instantiated or provides an implementation that returns
 261    *                     <code>null</code> from either
 262    *                     {@link MBeanServerBuilder#newMBeanServerDelegate()}
 263    *                     or {@link MBeanServerBuilder#newMBeanServer()}
 264    * @throws ClassCastException if the property
 265    *                     <code>javax.management.builder.initial</code>
 266    *                     exists but names a class which is not a subclass
 267    *                     of {@link MBeanServerBuilder}.
 268    * @see #newMBeanServer(String)
 269    */
 270   public static MBeanServer newMBeanServer()
 271   {
 272     return newMBeanServer(null);
 273   }
 274
 275   /**
 276    * Returns a server implementation using the default domain name
 277    * given, or <code>"DefaultDomain"</code> if this is <code>null</code>.
 278    * The default domain name is used when the domain name specified by
 279    * the user is <code>null</code.  No reference to the created server is
 280    * retained, so the server is garbage collected when it is no longer
 281    * used, but it can not be retrieved at a later date using
 282    * {@link #findMBeanServer}.
 283    *
 284    * @param domain the default domain name of the server.
 285    * @return a new {@link MBeanServer} instance.
 286    * @throws SecurityException if a security manager exists and the
 287    *                           caller's permissions don't imply {@link
 288    *                           MBeanServerPermission(String)}("newMBeanServer")
 289    * @throws JMRuntimeException if the property
 290    *                     <code>javax.management.builder.initial</code>
 291    *                     exists but names a class which either can not be
 292    *                     instantiated or provides an implementation that returns
 293    *                     <code>null</code> from either
 294    *                     {@link MBeanServerBuilder#newMBeanServerDelegate()}
 295    *                     or {@link MBeanServerBuilder#newMBeanServer()}
 296    * @throws ClassCastException if the property
 297    *                     <code>javax.management.builder.initial</code>
 298    *                     exists but names a class which is not a subclass
 299    *                     of {@link MBeanServerBuilder}.
 300    */
 301   public static MBeanServer newMBeanServer(String domain)
 302   {
 303     SecurityManager sm = System.getSecurityManager();
 304     if (sm != null)
 305       sm.checkPermission(new MBeanServerPermission("newMBeanServer"));
 306     return createServer(domain);
 307   }
 308
 309   /**
 310    * Common method to create a server for the {@link #createMBeanServer(String)}
 311    * and {@link #newMBeanServer(String)} methods above.
 312    *
 313    * @param domain the default domain name of the server.
 314    * @throws JMRuntimeException if the property
 315    *                     <code>javax.management.builder.initial</code>
 316    *                     exists but names a class which either can not be
 317    *                     instantiated or provides an implementation that returns
 318    *                     <code>null</code> from either
 319    *                     {@link MBeanServerBuilder#newMBeanServerDelegate()}
 320    *                     or {@link MBeanServerBuilder#newMBeanServer()}
 321    * @throws ClassCastException if the property
 322    *                     <code>javax.management.builder.initial</code>
 323    *                     exists but names a class which is not a subclass
 324    *                     of {@link MBeanServerBuilder}.
 325    */
 326   private static MBeanServer createServer(String domain)
 327     {
 328     if (domain == null)
 329       domain = "DefaultDomain";
 330     String builderClass =
 331       SystemProperties.getProperty("javax.management.builder.initial");
 332     if (builderClass == null)
 333       {
 334         if (builder == null ||
 335             builder.getClass() != MBeanServerBuilder.class)
 336           builder = new MBeanServerBuilder();
 337       }
 338     else if (!(builder != null &&
 339                builderClass.equals(builder.getClass().getName())))
 340       {
 341         ClassLoader cl = Thread.currentThread().getContextClassLoader();
 342         if (cl == null)
 343           cl = MBeanServerFactory.class.getClassLoader();
 344         try
 345           {
 346             Class<?> bClass = Class.forName(builderClass, true, cl);
 347             builder = (MBeanServerBuilder) bClass.newInstance();
 348           }
 349         catch (ClassNotFoundException e)
 350           {
 351             throw (JMRuntimeException) (new JMRuntimeException("The builder class, "
 352                                                                + builderClass +
 353                                                                ", could not be found."))
 354               .initCause(e);
 355           }
 356         catch (InstantiationException e)
 357           {
 358             throw (JMRuntimeException) (new JMRuntimeException("The builder class, "
 359                                                                + builderClass +
 360                                                                ", could not be instantiated."))
 361               .initCause(e);
 362           }
 363         catch (IllegalAccessException e)
 364           {
 365             throw (JMRuntimeException) (new JMRuntimeException("The builder class, "
 366                                                                + builderClass +
 367                                                                ", could not be accessed."))
 368               .initCause(e);
 369           }
 370       }
 371     MBeanServerDelegate delegate = builder.newMBeanServerDelegate();
 372     if (delegate == null)
 373       throw new JMRuntimeException("A delegate could not be created.");
 374     MBeanServer server = builder.newMBeanServer(domain, null, delegate);
 375     if (server == null)
 376       throw new JMRuntimeException("A server could not be created.");
 377     return server;
 378   }
 379
 380   /**
 381    * Removes the reference to the specified server, thus allowing it to
 382    * be garbage collected.
 383    *
 384    * @param server the server to remove.
 385    * @throws IllegalArgumentException if a reference to the server is not
 386    *                                  held (i.e. it wasn't created by
 387    *                                  {@link #createMBeanServer(String)}
 388    *                                  or this method has already been called
 389    *                                  on it.
 390    * @throws SecurityException if a security manager exists and the
 391    *                           caller's permissions don't imply {@link
 392    *                           MBeanServerPermission(String)}("releaseMBeanServer")
 393    */
 394   public static void releaseMBeanServer(MBeanServer server)
 395   {
 396     SecurityManager sm = System.getSecurityManager();
 397     if (sm != null)
 398       sm.checkPermission(new MBeanServerPermission("releaseMBeanServer"));
 399     Iterator<MBeanServer> i = servers.values().iterator();
 400     while (i.hasNext())
 401       {
 402         MBeanServer s = i.next();
 403         if (server == s)
 404           {
 405             i.remove();
 406             return;
 407           }
 408       }
 409     throw new IllegalArgumentException("The server given is not referenced.");
 410   }
 411
 412
 413 }