Source for java.lang.management.ManagementFactory

   1: /* ManagementFactory.java - Factory for obtaining system beans.
   2:    Copyright (C) 2006 Free Software Foundation
   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 java.lang.management;
  39: 
  40: import gnu.classpath.SystemProperties;
  41: 
  42: import gnu.java.lang.management.ClassLoadingMXBeanImpl;
  43: import gnu.java.lang.management.CompilationMXBeanImpl;
  44: import gnu.java.lang.management.GarbageCollectorMXBeanImpl;
  45: import gnu.java.lang.management.OperatingSystemMXBeanImpl;
  46: import gnu.java.lang.management.MemoryMXBeanImpl;
  47: import gnu.java.lang.management.MemoryManagerMXBeanImpl;
  48: import gnu.java.lang.management.MemoryPoolMXBeanImpl;
  49: import gnu.java.lang.management.RuntimeMXBeanImpl;
  50: import gnu.java.lang.management.ThreadMXBeanImpl;
  51: 
  52: import java.io.IOException;
  53: 
  54: import java.lang.reflect.InvocationHandler;
  55: import java.lang.reflect.Method;
  56: import java.lang.reflect.Proxy;
  57: 
  58: import java.util.ArrayList;
  59: import java.util.HashMap;
  60: import java.util.Iterator;
  61: import java.util.List;
  62: import java.util.Map;
  63: 
  64: import java.util.logging.LogManager;
  65: 
  66: import javax.management.Attribute;
  67: import javax.management.InstanceAlreadyExistsException;
  68: import javax.management.MBeanRegistrationException;
  69: import javax.management.MBeanServer;
  70: import javax.management.MBeanServerConnection;
  71: import javax.management.MBeanServerFactory;
  72: import javax.management.MalformedObjectNameException;
  73: import javax.management.NotCompliantMBeanException;
  74: import javax.management.NotificationEmitter;
  75: import javax.management.NotificationFilter;
  76: import javax.management.NotificationListener;
  77: import javax.management.ObjectName;
  78: 
  79: import javax.management.openmbean.CompositeData;
  80: import javax.management.openmbean.TabularData;
  81: 
  82: /**
  83:  * <p>
  84:  * Provides access to the system's management beans via a series
  85:  * of static methods.  
  86:  * </p>
  87:  * <p>
  88:  * An instance of a system management bean can be obtained by
  89:  * using one of the following methods:
  90:  * </p>
  91:  * <ol>
  92:  * <li>Calling the appropriate static method of this factory.
  93:  * </li>
  94:  * <li>Using the platform {@link javax.management.MBeanServer}
  95:  * to access the beans locally, or an
  96:  * {@link javax.management.MBeanServerConnection} for remote
  97:  * access.  The attributes and operations use the limited
  98:  * range of data types specified below.</li>
  99:  * </ol>
 100:  * <h2>Open Data Types</h2>
 101:  * <p>
 102:  * The data types used by the management beans are restricted
 103:  * to <emph>open</emph> data types to aid interoperability.  This
 104:  * allows the beans to be accessed remotely, including from non-Java
 105:  * clients.  Below is a table which lists the types used by the beans
 106:  * on the left, and the types they are converted to when returned via
 107:  * a bean server on the right.  Type information is provided for each
 108:  * bean by obtaining its instance of {@link javax.management.MBeanInfo}.
 109:  * </p>
 110:  * <table>
 111:  * <th><td>Data Type Used</td><td>Data Type Returned</td></th>
 112:  * <tr>
 113:  * <td>Primitive types (<code>int</code>, <code>char</code>, etc.)</td>
 114:  * <td>Same</td>
 115:  * </tr><tr>
 116:  * <td>Wrapper classes ({@link{java.lang.Integer},
 117:  * @link{java.lang.Character}, etc.)</td>
 118:  * <td>Same</td>
 119:  * </tr><tr>
 120:  * <td>An {@link java.lang.Enum}</td>
 121:  * <td>The <code>name</code> of the enumeration constant</td>
 122:  * </tr><tr>
 123:  * <td>An array of type <code>E</code></td>
 124:  * <td>An array of the same dimensions with this mapping applied
 125:  * to <code>E</code>.</td>
 126:  * </tr><tr>
 127:  * <td>A class with `getter' methods and a
 128:  * <code>from({@link javax.management.openmbean.CompositeData})</code>
 129:  * method.</td>
 130:  * <td>The equivalent {@link javax.management.openmbean.CompositeData}
 131:  * instance, specified by the <code>from</code> method.</td>
 132:  * </tr><tr>
 133:  * <td>A map with keys of type <code>K</code> and values of
 134:  * type <code>V</code>.</td>
 135:  * <td>A {@link javax.management.openmbean.TabularData} instance,
 136:  * with the row type containing two items, <code>"key"</code> and
 137:  * <code>"value"</code> with the types <code>K</code> and <code>V</code>
 138:  * respectively (with translation applied).</td>
 139:  * </tr><tr>
 140:  * <td>A list of type <code>E</code>.</td>
 141:  * <td>An array with this mapping applied to <code>E</code>.</td>
 142:  * </tr></table>
 143:  *
 144:  * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
 145:  * @since 1.5
 146:  */
 147: public class ManagementFactory
 148: {
 149: 
 150:   /**
 151:    * The object name for the class loading bean.
 152:    */
 153:   public static final String CLASS_LOADING_MXBEAN_NAME =
 154:     "java.lang:type=ClassLoading";
 155: 
 156:   /**
 157:    * The object name for the compilation bean.
 158:    */
 159:   public static final String COMPILATION_MXBEAN_NAME =
 160:     "java.lang:type=Compilation";
 161: 
 162:   /**
 163:    * The domain for the garbage collecting beans.
 164:    */
 165:   public static final String GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE =
 166:     "java.lang:type=GarbageCollector";
 167: 
 168:   /**
 169:    * The domain for the memory manager beans.
 170:    */
 171:   public static final String MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE =
 172:     "java.lang:type=MemoryManager";
 173: 
 174:   /**
 175:    * The object name for the memory bean.
 176:    */
 177:   public static final String MEMORY_MXBEAN_NAME =
 178:     "java.lang:type=Memory";
 179: 
 180:   /**
 181:    * The domain for the memory pool beans.
 182:    */
 183:   public static final String MEMORY_POOL_MXBEAN_DOMAIN_TYPE =
 184:     "java.lang:type=MemoryPool";
 185: 
 186:   /**
 187:    * The object name for the operating system bean.
 188:    */
 189:   public static final String OPERATING_SYSTEM_MXBEAN_NAME =
 190:     "java.lang:type=OperatingSystem";
 191: 
 192:   /**
 193:    * The object name for the runtime bean.
 194:    */
 195:   public static final String RUNTIME_MXBEAN_NAME =
 196:     "java.lang:type=Runtime";
 197: 
 198:   /**
 199:    * The object name for the threading bean.
 200:    */
 201:   public static final String THREAD_MXBEAN_NAME =
 202:     "java.lang:type=Threading";
 203: 
 204:   /**
 205:    * The operating system management bean.
 206:    */
 207:   private static OperatingSystemMXBean osBean;
 208: 
 209:   /**
 210:    * The runtime management bean.
 211:    */
 212:   private static RuntimeMXBean runtimeBean;
 213: 
 214:   /**
 215:    * The class loading management bean.
 216:    */
 217:   private static ClassLoadingMXBean classLoadingBean;
 218: 
 219:   /**
 220:    * The thread bean.
 221:    */
 222:   private static ThreadMXBean threadBean;
 223: 
 224:   /**
 225:    * The memory bean.
 226:    */
 227:   private static MemoryMXBean memoryBean;
 228: 
 229:   /**
 230:    * The compilation bean (may remain null).
 231:    */
 232:   private static CompilationMXBean compilationBean;
 233: 
 234:   /**
 235:    * The platform server.
 236:    */
 237:   private static MBeanServer platformServer;
 238: 
 239:   /**
 240:    * Private constructor to prevent instance creation.
 241:    */
 242:   private ManagementFactory() {}
 243: 
 244:   /**
 245:    * Returns the operating system management bean for the
 246:    * operating system on which the virtual machine is running.
 247:    *
 248:    * @return an instance of {@link OperatingSystemMXBean} for
 249:    *         the underlying operating system.
 250:    */
 251:   public static OperatingSystemMXBean getOperatingSystemMXBean()
 252:   {
 253:     if (osBean == null)
 254:       try 
 255:     {
 256:       osBean = new OperatingSystemMXBeanImpl();
 257:     }
 258:       catch (NotCompliantMBeanException e)
 259:     {
 260:       throw new InternalError("The GNU implementation of the " +
 261:                   "operating system bean is not a " +
 262:                   "compliant management bean.");
 263:     }
 264:     return osBean;
 265:   }
 266: 
 267:   /**
 268:    * Returns the runtime management bean for the
 269:    * running virtual machine.
 270:    *
 271:    * @return an instance of {@link RuntimeMXBean} for
 272:    *         this virtual machine.
 273:    */
 274:   public static RuntimeMXBean getRuntimeMXBean()
 275:   {
 276:     if (runtimeBean == null)
 277:       try
 278:     {
 279:       runtimeBean = new RuntimeMXBeanImpl();
 280:     }
 281:       catch (NotCompliantMBeanException e)
 282:     {
 283:       throw new InternalError("The GNU implementation of the " +
 284:                   "runtime bean is not a compliant " +
 285:                   "management bean.");
 286:     }
 287:     return runtimeBean;
 288:   }
 289: 
 290:   /**
 291:    * Returns the class loading management bean for the
 292:    * running virtual machine.
 293:    *
 294:    * @return an instance of {@link ClassLoadingMXBean} for
 295:    *         this virtual machine.
 296:    */
 297:   public static ClassLoadingMXBean getClassLoadingMXBean()
 298:   {
 299:     if (classLoadingBean == null)
 300:       try
 301:     {
 302:       classLoadingBean = new ClassLoadingMXBeanImpl();
 303:     }
 304:       catch (NotCompliantMBeanException e)
 305:     {
 306:       throw new InternalError("The GNU implementation of the " +
 307:                   "class loading bean is not a " +
 308:                   "compliant management bean.");
 309:     }
 310:     return classLoadingBean;
 311:   }
 312: 
 313:   /**
 314:    * Returns the thread management bean for the running
 315:    * virtual machine.
 316:    *
 317:    * @return an instance of {@link ThreadMXBean} for
 318:    *         this virtual machine.
 319:    */
 320:   public static ThreadMXBean getThreadMXBean()
 321:   {
 322:     if (threadBean == null)
 323:       try
 324:     {
 325:       threadBean = new ThreadMXBeanImpl();
 326:     }
 327:       catch (NotCompliantMBeanException e)
 328:     {
 329:       throw new InternalError("The GNU implementation of the " +
 330:                   "thread bean is not a compliant " +
 331:                   "management bean.");
 332:     }
 333:     return threadBean;
 334:   }
 335: 
 336:   /**
 337:    * Returns the memory management bean for the running
 338:    * virtual machine.
 339:    *
 340:    * @return an instance of {@link MemoryMXBean} for
 341:    *         this virtual machine.
 342:    */
 343:   public static MemoryMXBean getMemoryMXBean()
 344:   {
 345:     if (memoryBean == null)
 346:       try
 347:     {
 348:       memoryBean = new MemoryMXBeanImpl();
 349:     }
 350:       catch (NotCompliantMBeanException e)
 351:     {
 352:       throw new InternalError("The GNU implementation of the " +
 353:                   "memory bean is not a compliant " +
 354:                   "management bean.");
 355:     }
 356:     return memoryBean;
 357:   }
 358: 
 359:   /**
 360:    * Returns the compilation bean for the running
 361:    * virtual machine, if supported.  Otherwise,
 362:    * it returns <code>null</code>.
 363:    *
 364:    * @return an instance of {@link CompilationMXBean} for
 365:    *         this virtual machine, or <code>null</code>
 366:    *         if the virtual machine doesn't include
 367:    *         a Just-In-Time (JIT) compiler.
 368:    */
 369:   public static CompilationMXBean getCompilationMXBean()
 370:   {
 371:     if (compilationBean == null &&
 372:     SystemProperties.getProperty("gnu.java.compiler.name") != null)
 373:       try
 374:     {
 375:       compilationBean = new CompilationMXBeanImpl();
 376:     }
 377:       catch (NotCompliantMBeanException e)
 378:     {
 379:       throw new InternalError("The GNU implementation of the " +
 380:                   "compilation bean is not a compliant " +
 381:                   "management bean.");
 382:     }
 383:     return compilationBean;
 384:   }
 385: 
 386:   /**
 387:    * Returns the memory pool beans for the running
 388:    * virtual machine.  These may change during the course
 389:    * of execution.
 390:    *
 391:    * @return a list of memory pool beans, one for each pool.
 392:    */
 393:   public static List<MemoryPoolMXBean> getMemoryPoolMXBeans()
 394:   {
 395:     List<MemoryPoolMXBean> poolBeans =
 396:       new ArrayList<MemoryPoolMXBean>();
 397:     String[] names = VMManagementFactory.getMemoryPoolNames();
 398:     for (int a = 0; a < names.length; ++a)
 399:       try
 400:     {
 401:       poolBeans.add(new MemoryPoolMXBeanImpl(names[a]));
 402:     }
 403:       catch (NotCompliantMBeanException e)
 404:     {
 405:       throw new InternalError("The GNU implementation of the " +
 406:                   "memory pool bean, " + a + ", is " +
 407:                   "not a compliant management bean.");
 408:     }
 409:     return poolBeans;
 410:   }
 411: 
 412:   /**
 413:    * Returns the memory manager beans for the running
 414:    * virtual machine.  These may change during the course
 415:    * of execution.
 416:    *
 417:    * @return a list of memory manager beans, one for each manager.
 418:    */
 419:   public static List<MemoryManagerMXBean> getMemoryManagerMXBeans()
 420:   {
 421:     List<MemoryManagerMXBean> managerBeans =
 422:       new ArrayList<MemoryManagerMXBean>();
 423:     String[] names = VMManagementFactory.getMemoryManagerNames();
 424:     for (int a = 0; a < names.length; ++a)
 425:       try
 426:     {
 427:       managerBeans.add(new MemoryManagerMXBeanImpl(names[a]));
 428:     }
 429:       catch (NotCompliantMBeanException e)
 430:     {
 431:       throw new InternalError("The GNU implementation of the " +
 432:                   "memory manager bean, " + a + ", is " +
 433:                   "not a compliant management bean.");
 434:     }
 435:     managerBeans.addAll(getGarbageCollectorMXBeans());
 436:     return managerBeans;
 437:   }
 438: 
 439:   /**
 440:    * Returns the garbage collector beans for the running
 441:    * virtual machine.  These may change during the course
 442:    * of execution.
 443:    *
 444:    * @return a list of garbage collector beans, one for each pool.
 445:    */
 446:   public static List<GarbageCollectorMXBean> getGarbageCollectorMXBeans()
 447:   {
 448:     List<GarbageCollectorMXBean> gcBeans =
 449:       new ArrayList<GarbageCollectorMXBean>();
 450:     String[] names = VMManagementFactory.getGarbageCollectorNames();
 451:     for (int a = 0; a < names.length; ++a)
 452:       try
 453:     {
 454:       gcBeans.add(new GarbageCollectorMXBeanImpl(names[a]));
 455:     }
 456:       catch (NotCompliantMBeanException e)
 457:     {
 458:       throw new InternalError("The GNU implementation of the " +
 459:                   "garbage collector bean, " + a + 
 460:                   ", is not a compliant management " +
 461:                   "bean.");
 462:     }
 463:     return gcBeans;
 464:   }
 465: 
 466:   /**
 467:    * <p>
 468:    * Returns the platform {@link javax.management.MBeanServer}.  On the
 469:    * first call to this method, a server instance is retrieved from
 470:    * the {@link javax.management.MBeanServerFactory} and each of the
 471:    * beans are registered with it.  Subsequent calls return the existing
 472:    * instance.  If the property <code>javax.management.builder.initial</code>
 473:    * is set, its value will be used as the name of the class which is used
 474:    * to provide the server instance.
 475:    * </p>
 476:    * <p>
 477:    * It is recommended that the platform server is used for other beans as
 478:    * well, in order to simplify their discovery and publication.  Name conflicts
 479:    * should be avoided.
 480:    * </p>
 481:    *
 482:    * @return the platform {@link javax.management.MBeanServer}
 483:    * @throws SecurityException if a security manager exists and the
 484:    *                           caller's permissions don't imply {@link
 485:    *                           MBeanServerPermission(String)}("createMBeanServer")
 486:    * @see javax.management.MBeanServerFactory
 487:    * @see javax.management.MBeanServerFactory#createMBeanServer()
 488:    */
 489:   public static MBeanServer getPlatformMBeanServer()
 490:   {
 491:     if (platformServer == null)
 492:       {
 493:     platformServer = MBeanServerFactory.createMBeanServer();
 494:     try
 495:       {
 496:         platformServer.registerMBean(getOperatingSystemMXBean(),
 497:                      new ObjectName(OPERATING_SYSTEM_MXBEAN_NAME));
 498:         platformServer.registerMBean(getRuntimeMXBean(),
 499:                      new ObjectName(RUNTIME_MXBEAN_NAME));
 500:         platformServer.registerMBean(getClassLoadingMXBean(),
 501:                      new ObjectName(CLASS_LOADING_MXBEAN_NAME));
 502:         platformServer.registerMBean(getThreadMXBean(),
 503:                      new ObjectName(THREAD_MXBEAN_NAME));
 504:         platformServer.registerMBean(getMemoryMXBean(),
 505:                      new ObjectName(MEMORY_MXBEAN_NAME));
 506:         CompilationMXBean compBean = getCompilationMXBean();
 507:         if (compBean != null)
 508:           platformServer.registerMBean(compBean,
 509:                        new ObjectName(COMPILATION_MXBEAN_NAME));
 510:         Iterator beans = getMemoryPoolMXBeans().iterator();
 511:         while (beans.hasNext())
 512:           {
 513:         MemoryPoolMXBean bean = (MemoryPoolMXBean) beans.next();
 514:         platformServer.registerMBean(bean,
 515:                          new ObjectName(MEMORY_POOL_MXBEAN_DOMAIN_TYPE +
 516:                                 ",name=" +
 517:                                 bean.getName()));
 518:           }
 519:         beans = getMemoryManagerMXBeans().iterator();
 520:         while (beans.hasNext())
 521:           {
 522:         MemoryManagerMXBean bean = (MemoryManagerMXBean) beans.next();
 523:         platformServer.registerMBean(bean,
 524:                          new ObjectName(MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE +
 525:                                 ",name=" +
 526:                                 bean.getName()));
 527:           }
 528:         beans = getGarbageCollectorMXBeans().iterator();
 529:         while (beans.hasNext())
 530:           {
 531:         GarbageCollectorMXBean bean = (GarbageCollectorMXBean) beans.next();
 532:         platformServer.registerMBean(bean,
 533:                          new ObjectName(GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE +
 534:                                 ",name=" +
 535:                                 bean.getName()));
 536:           }
 537:         platformServer.registerMBean(LogManager.getLoggingMXBean(),
 538:                      new ObjectName(LogManager.LOGGING_MXBEAN_NAME));
 539:       }
 540:     catch (InstanceAlreadyExistsException e)
 541:       {
 542:         throw (Error) 
 543:           (new InternalError("One of the management beans is " +
 544:                  "already registered.").initCause(e));
 545:       }
 546:     catch (MBeanRegistrationException e)
 547:       {
 548:         throw (Error) 
 549:           (new InternalError("One of the management beans' preRegister " +
 550:                  "methods threw an exception.").initCause(e));
 551:       }
 552:     catch (NotCompliantMBeanException e)
 553:       {
 554:         throw (Error) 
 555:           (new InternalError("One of the management beans is " +
 556:                  "not compliant.").initCause(e));
 557:       }
 558:     catch (MalformedObjectNameException e)
 559:       {
 560:         throw (Error) 
 561:           (new InternalError("The object name of a management bean is " +
 562:                  "not compliant.").initCause(e));
 563:       }
 564:       }
 565:     return platformServer;
 566:   }
 567: 
 568:   /**
 569:    * <p>
 570:    * Returns a proxy for the specified platform bean.  A proxy object is created
 571:    * using <code>Proxy.newProxyInstance(mxbeanInterface.getClassLoader(),
 572:    * new Class[] { mxbeanInterface }, handler)</code>.  The
 573:    * {@link javax.management.NotificationEmitter} class is also added to the
 574:    * array if the bean provides notifications.  <code>handler</code> refers
 575:    * to the invocation handler which forwards calls to the connection, and
 576:    * also provides translation between the Java data types used in the
 577:    * bean interfaces and the open data types, as specified in the description
 578:    * of this class.  It is this translation that makes the
 579:    * usual {@link javax.management.MBeanServerInvocationHandler} inappropriate
 580:    * for providing such a proxy.
 581:    * </p>
 582:    * <p>
 583:    * <strong>Note</strong>: use of the proxy may result in
 584:    * {@link java.io.IOException}s from the underlying {@link MBeanServerConnection}
 585:    * and a {@link java.io.InvalidObjectException} if enum constants
 586:    * used on the client and the server don't match.
 587:    * </p>
 588:    *
 589:    * @param connection the server connection to use to access the bean.
 590:    * @param mxbeanName the {@link javax.management.ObjectName} of the
 591:    *                   bean to provide a proxy for.
 592:    * @param mxbeanInterface the interface for the bean being proxied.
 593:    * @return a proxy for the specified bean.
 594:    * @throws IllegalArgumentException if <code>mxbeanName</code> is not a valid
 595:    *                                  {@link javax.management.ObjectName},
 596:    *                                  the interface and name do not match the
 597:    *                                  same bean, the name does not refer to a
 598:    *                                  platform bean or the bean is not registered
 599:    *                                  with the server accessed by <code>connection</code>.
 600:    * @throws IOException if the connection throws one.
 601:    */
 602:   public static <T> T newPlatformMXBeanProxy(MBeanServerConnection connection,
 603:                          String mxbeanName,
 604:                          Class<T> mxbeanInterface)
 605:     throws IOException
 606:   {
 607:     if (!(mxbeanName.equals(CLASS_LOADING_MXBEAN_NAME) ||
 608:       mxbeanName.equals(COMPILATION_MXBEAN_NAME) ||
 609:       mxbeanName.startsWith(GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE) ||
 610:       mxbeanName.startsWith(MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE) ||
 611:       mxbeanName.equals(MEMORY_MXBEAN_NAME) ||
 612:       mxbeanName.startsWith(MEMORY_POOL_MXBEAN_DOMAIN_TYPE) ||
 613:       mxbeanName.equals(OPERATING_SYSTEM_MXBEAN_NAME) ||
 614:       mxbeanName.equals(RUNTIME_MXBEAN_NAME) ||
 615:       mxbeanName.equals(THREAD_MXBEAN_NAME)))
 616:       {
 617:     throw new IllegalArgumentException("The named bean, " + mxbeanName +
 618:                        ", is not a platform name.");
 619:       }
 620:     if ((mxbeanName.equals(CLASS_LOADING_MXBEAN_NAME) &&
 621:      mxbeanInterface != ClassLoadingMXBean.class) ||
 622:     (mxbeanName.equals(COMPILATION_MXBEAN_NAME) &&
 623:      mxbeanInterface != CompilationMXBean.class) ||
 624:     (mxbeanName.startsWith(GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE) &&
 625:      mxbeanInterface != GarbageCollectorMXBean.class) ||
 626:     (mxbeanName.startsWith(MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE) &&
 627:      mxbeanInterface != MemoryManagerMXBean.class) ||
 628:     (mxbeanName.equals(MEMORY_MXBEAN_NAME) &&
 629:      mxbeanInterface != MemoryMXBean.class) ||
 630:     (mxbeanName.startsWith(MEMORY_POOL_MXBEAN_DOMAIN_TYPE) &&
 631:      mxbeanInterface != MemoryPoolMXBean.class) ||
 632:     (mxbeanName.equals(OPERATING_SYSTEM_MXBEAN_NAME) &&
 633:      mxbeanInterface != OperatingSystemMXBean.class) ||
 634:     (mxbeanName.equals(RUNTIME_MXBEAN_NAME) &&
 635:      mxbeanInterface != RuntimeMXBean.class) ||
 636:     (mxbeanName.equals(THREAD_MXBEAN_NAME) &&
 637:      mxbeanInterface != ThreadMXBean.class))
 638:       throw new IllegalArgumentException("The interface, " + mxbeanInterface +
 639:                      ", does not match the bean, " + mxbeanName);
 640:     ObjectName bean;
 641:     try
 642:       {
 643:     bean = new ObjectName(mxbeanName);
 644:       }
 645:     catch (MalformedObjectNameException e)
 646:       {
 647:     throw new IllegalArgumentException("The named bean is invalid.");
 648:       }
 649:     if (!(connection.isRegistered(bean)))
 650:       throw new IllegalArgumentException("The bean is not registered on this connection.");
 651:     Class[] interfaces;
 652:     if (mxbeanName.equals(MEMORY_MXBEAN_NAME))
 653:       interfaces = new Class[] { mxbeanInterface, NotificationEmitter.class };
 654:     else
 655:       interfaces = new Class[] { mxbeanInterface };
 656:     return (T) Proxy.newProxyInstance(mxbeanInterface.getClassLoader(),
 657:                       interfaces,
 658:                       new ManagementInvocationHandler(connection, bean));
 659:   }
 660: 
 661:   /**
 662:    * This invocation handler provides method calls for a platform bean
 663:    * by forwarding them to a {@link MBeanServerConnection}.  Translation from
 664:    * Java data types to open data types is performed as specified above.
 665:    *
 666:    * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
 667:    * @since 1.5
 668:    */
 669:   private static class ManagementInvocationHandler
 670:     implements InvocationHandler
 671:   {
 672: 
 673:     /**
 674:      * The encapsulated connection.
 675:      */
 676:     private MBeanServerConnection conn;
 677: 
 678:     /**
 679:      * The bean being proxied.
 680:      */
 681:     private ObjectName bean;
 682: 
 683:     /**
 684:      * Constructs a new {@link InvocationHandler} which proxies
 685:      * for the specified bean using the supplied connection.
 686:      *
 687:      * @param conn the connection on which to forward method calls.
 688:      * @param bean the bean to proxy.
 689:      */
 690:     public ManagementInvocationHandler(MBeanServerConnection conn,
 691:                        ObjectName bean)
 692:       throws IOException
 693:     {
 694:       this.conn = conn;
 695:       this.bean = bean;
 696:     }
 697: 
 698:     /**
 699:      * Called by the proxy class whenever a method is called.  The method
 700:      * is emulated by retrieving an attribute from, setting an attribute on
 701:      * or invoking a method on the server connection as required.  Translation
 702:      * between the Java data types supplied as arguments to the open types used
 703:      * by the bean is provided, as well as translation of the return value back
 704:      * in to the appropriate Java type.
 705:      *
 706:      * @param proxy the proxy on which the method was called.
 707:      * @param method the method which was called.
 708:      * @param args the arguments supplied to the method.
 709:      * @return the return value from the method.
 710:      * @throws Throwable if an exception is thrown in performing the
 711:      *                   method emulation.
 712:      */
 713:     public Object invoke(Object proxy, Method method, Object[] args)
 714:       throws Throwable
 715:     {
 716:       String name = method.getName();
 717:       if (name.equals("toString"))
 718:     return "Proxy for " + bean + " using " + conn;
 719:       if (name.equals("addNotificationListener"))
 720:     {
 721:       conn.addNotificationListener(bean,
 722:                        (NotificationListener) args[0],
 723:                        (NotificationFilter) args[1],
 724:                        args[2]);
 725:       return null;
 726:     }
 727:       if (name.equals("getNotificationInfo"))
 728:     return conn.getMBeanInfo(bean).getNotifications();
 729:       if (name.equals("removeNotificationListener"))
 730:     {
 731:       if (args.length == 1)
 732:         conn.removeNotificationListener(bean, 
 733:                         (NotificationListener)
 734:                         args[0]);
 735:       else
 736:         conn.removeNotificationListener(bean, 
 737:                         (NotificationListener)
 738:                         args[0],
 739:                         (NotificationFilter)
 740:                         args[1], args[2]);
 741:       return null;
 742:     }
 743:       String attrib = null;
 744:       if (name.startsWith("get"))
 745:     attrib = name.substring(3);
 746:       else if (name.startsWith("is"))
 747:     attrib = name.substring(2);
 748:       if (attrib != null)
 749:     return translate(conn.getAttribute(bean, attrib), method);
 750:       else if (name.startsWith("set"))
 751:     {
 752:       conn.setAttribute(bean, new Attribute(name.substring(3),
 753:                         args[0]));
 754:       return null;
 755:     }
 756:       else
 757:     return translate(conn.invoke(bean, name, args, null), method);
 758:     }
 759: 
 760:     /**
 761:      * Translates the returned open data type to the value
 762:      * required by the interface.
 763:      *
 764:      * @param otype the open type returned by the method call.
 765:      * @param method the method that was called.
 766:      * @return the equivalent return type required by the interface.
 767:      * @throws Throwable if an exception is thrown in performing the
 768:      *                   conversion.
 769:      */
 770:     private final Object translate(Object otype, Method method)
 771:       throws Throwable
 772:     {
 773:       Class<?> returnType = method.getReturnType();
 774:       if (returnType.isEnum())
 775:     {
 776:       String ename = (String) otype;
 777:       Enum[] constants = (Enum[]) returnType.getEnumConstants();
 778:       for (Enum c : constants)
 779:         if (c.name().equals(ename))
 780:           return c;
 781:     }
 782:       if (List.class.isAssignableFrom(returnType))
 783:     {
 784:       Object[] elems = (Object[]) otype;
 785:       List l = new ArrayList(elems.length);
 786:       for (Object elem : elems)
 787:         l.add(elem);
 788:       return l;
 789:     }
 790:       if (Map.class.isAssignableFrom(returnType))
 791:     {
 792:       TabularData data = (TabularData) otype;
 793:       Map m = new HashMap(data.size());
 794:       for (Object val : data.values())
 795:         {
 796:           CompositeData vals = (CompositeData) val;
 797:           m.put(vals.get("key"), vals.get("value"));
 798:         }
 799:       return m;
 800:     }
 801:       try
 802:     {
 803:       Method m = returnType.getMethod("from",
 804:                       new Class[]
 805:         { CompositeData.class });
 806:       return m.invoke(null, (CompositeData) otype);
 807:     }
 808:       catch (NoSuchMethodException e)
 809:     {
 810:       /* Ignored; we expect this if this
 811:          isn't a from(CompositeData) class */
 812:     }
 813:       return otype;
 814:     }
 815: 
 816:   }
 817: }