1 /*
   2  * Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 /*
  26  * @author    IBM Corp.
  27  *
  28  * Copyright IBM Corp. 1999-2000.  All rights reserved.
  29  */
  30 
  31 
  32 package javax.management.modelmbean;
  33 
  34 /* java imports */
  35 
  36 import static com.sun.jmx.defaults.JmxProperties.MODELMBEAN_LOGGER;
  37 import java.io.FileOutputStream;
  38 import java.io.PrintStream;
  39 import java.lang.reflect.InvocationTargetException;
  40 
  41 import java.lang.reflect.Method;
  42 import java.security.AccessControlContext;
  43 import java.security.AccessController;
  44 import java.security.PrivilegedAction;
  45 
  46 import java.util.Date;
  47 import java.util.HashMap;
  48 import java.util.HashSet;
  49 import java.lang.System.Logger.Level;
  50 import java.util.Map;
  51 import java.util.Set;
  52 
  53 import java.util.Vector;
  54 import javax.management.Attribute;
  55 import javax.management.AttributeChangeNotification;
  56 import javax.management.AttributeChangeNotificationFilter;
  57 import javax.management.AttributeList;
  58 import javax.management.AttributeNotFoundException;
  59 import javax.management.Descriptor;
  60 import javax.management.InstanceNotFoundException;
  61 import javax.management.InvalidAttributeValueException;
  62 import javax.management.ListenerNotFoundException;
  63 import javax.management.MBeanAttributeInfo;
  64 import javax.management.MBeanConstructorInfo;
  65 import javax.management.MBeanException;
  66 import javax.management.MBeanInfo;
  67 import javax.management.MBeanNotificationInfo;
  68 import javax.management.MBeanOperationInfo;
  69 import javax.management.MBeanRegistration;
  70 import javax.management.MBeanServer;
  71 import javax.management.MBeanServerFactory;
  72 import javax.management.Notification;
  73 import javax.management.NotificationBroadcasterSupport;
  74 import javax.management.NotificationEmitter;
  75 import javax.management.NotificationFilter;
  76 import javax.management.NotificationListener;
  77 import javax.management.ObjectName;
  78 import javax.management.ReflectionException;
  79 import javax.management.RuntimeErrorException;
  80 import javax.management.RuntimeOperationsException;
  81 import javax.management.ServiceNotFoundException;
  82 import javax.management.loading.ClassLoaderRepository;
  83 import jdk.internal.access.JavaSecurityAccess;
  84 import jdk.internal.access.SharedSecrets;
  85 
  86 import sun.reflect.misc.MethodUtil;
  87 import sun.reflect.misc.ReflectUtil;
  88 
  89 /**
  90  * This class is the implementation of a ModelMBean. An appropriate
  91  * implementation of a ModelMBean must be shipped with every JMX Agent
  92  * and the class must be named RequiredModelMBean.
  93  * <P>
  94  * Java resources wishing to be manageable instantiate the
  95  * RequiredModelMBean using the MBeanServer's createMBean method.
  96  * The resource then sets the MBeanInfo and Descriptors for the
  97  * RequiredModelMBean instance. The attributes and operations exposed
  98  * via the ModelMBeanInfo for the ModelMBean are accessible
  99  * from MBeans, connectors/adaptors like other MBeans. Through the
 100  * Descriptors, values and methods in the managed application can be
 101  * defined and mapped to attributes and operations of the ModelMBean.
 102  * This mapping can be defined in an XML formatted file or dynamically and
 103  * programmatically at runtime.
 104  * <P>
 105  * Every RequiredModelMBean which is instantiated in the MBeanServer
 106  * becomes manageable:<br>
 107  * its attributes and operations become remotely accessible through the
 108  * connectors/adaptors connected to that MBeanServer.
 109  * <P>
 110  * A Java object cannot be registered in the MBeanServer unless it is a
 111  * JMX compliant MBean. By instantiating a RequiredModelMBean, resources
 112  * are guaranteed that the MBean is valid.
 113  *
 114  * MBeanException and RuntimeOperationsException must be thrown on every
 115  * public method.  This allows for wrapping exceptions from distributed
 116  * communications (RMI, EJB, etc.)
 117  *
 118  * @since 1.5
 119  */
 120 
 121 public class RequiredModelMBean
 122     implements ModelMBean, MBeanRegistration, NotificationEmitter {
 123 
 124     /*************************************/
 125     /* attributes                        */
 126     /*************************************/
 127     ModelMBeanInfo modelMBeanInfo;
 128 
 129     /* Notification broadcaster for any notification to be sent
 130      * from the application through the RequiredModelMBean.  */
 131     private NotificationBroadcasterSupport generalBroadcaster = null;
 132 
 133     /* Notification broadcaster for attribute change notifications */
 134     private NotificationBroadcasterSupport attributeBroadcaster = null;
 135 
 136     /* handle, name, or reference for instance on which the actual invoke
 137      * and operations will be executed */
 138     private Object managedResource = null;
 139 
 140 
 141     /* records the registering in MBeanServer */
 142     private boolean registered = false;
 143     private transient MBeanServer server = null;
 144 
 145     private final static JavaSecurityAccess javaSecurityAccess = SharedSecrets.getJavaSecurityAccess();
 146     final private AccessControlContext acc = AccessController.getContext();
 147 
 148     /*************************************/
 149     /* constructors                      */
 150     /*************************************/
 151 
 152     /**
 153      * Constructs an <CODE>RequiredModelMBean</CODE> with an empty
 154      * ModelMBeanInfo.
 155      * <P>
 156      * The RequiredModelMBean's MBeanInfo and Descriptors
 157      * can be customized using the {@link #setModelMBeanInfo} method.
 158      * After the RequiredModelMBean's MBeanInfo and Descriptors are
 159      * customized, the RequiredModelMBean can be registered with
 160      * the MBeanServer.
 161      *
 162      * @exception MBeanException Wraps a distributed communication Exception.
 163      *
 164      * @exception RuntimeOperationsException Wraps a {@link
 165      * RuntimeException} during the construction of the object.
 166      **/
 167     public RequiredModelMBean()
 168         throws MBeanException, RuntimeOperationsException {
 169         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 170             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
 171         }
 172         modelMBeanInfo = createDefaultModelMBeanInfo();
 173         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 174             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
 175         }
 176     }
 177 
 178     /**
 179      * Constructs a RequiredModelMBean object using ModelMBeanInfo passed in.
 180      * As long as the RequiredModelMBean is not registered
 181      * with the MBeanServer yet, the RequiredModelMBean's MBeanInfo and
 182      * Descriptors can be customized using the {@link #setModelMBeanInfo}
 183      * method.
 184      * After the RequiredModelMBean's MBeanInfo and Descriptors are
 185      * customized, the RequiredModelMBean can be registered with the
 186      * MBeanServer.
 187      *
 188      * @param mbi The ModelMBeanInfo object to be used by the
 189      *            RequiredModelMBean. The given ModelMBeanInfo is cloned
 190      *            and modified as specified by {@link #setModelMBeanInfo}
 191      *
 192      * @exception MBeanException Wraps a distributed communication Exception.
 193      * @exception RuntimeOperationsException Wraps an
 194      *    {link java.lang.IllegalArgumentException}:
 195      *          The MBeanInfo passed in parameter is null.
 196      *
 197      **/
 198     public RequiredModelMBean(ModelMBeanInfo mbi)
 199         throws MBeanException, RuntimeOperationsException {
 200 
 201         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 202             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
 203         }
 204         setModelMBeanInfo(mbi);
 205 
 206         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 207             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
 208         }
 209     }
 210 
 211 
 212     /*************************************/
 213     /* initializers                      */
 214     /*************************************/
 215 
 216     /**
 217      * Initializes a ModelMBean object using ModelMBeanInfo passed in.
 218      * This method makes it possible to set a customized ModelMBeanInfo on
 219      * the ModelMBean as long as it is not registered with the MBeanServer.
 220      * <br>
 221      * Once the ModelMBean's ModelMBeanInfo (with Descriptors) are
 222      * customized and set on the ModelMBean, the  ModelMBean be
 223      * registered with the MBeanServer.
 224      * <P>
 225      * If the ModelMBean is currently registered, this method throws
 226      * a {@link javax.management.RuntimeOperationsException} wrapping an
 227      * {@link IllegalStateException}
 228      * <P>
 229      * If the given <var>inModelMBeanInfo</var> does not contain any
 230      * {@link ModelMBeanNotificationInfo} for the <code>GENERIC</code>
 231      * or <code>ATTRIBUTE_CHANGE</code> notifications, then the
 232      * RequiredModelMBean will supply its own default
 233      * {@link ModelMBeanNotificationInfo ModelMBeanNotificationInfo}s for
 234      * those missing notifications.
 235      *
 236      * @param mbi The ModelMBeanInfo object to be used
 237      *        by the ModelMBean.
 238      *
 239      * @exception MBeanException Wraps a distributed communication
 240      *        Exception.
 241      * @exception RuntimeOperationsException
 242      * <ul><li>Wraps an {@link IllegalArgumentException} if
 243      *         the MBeanInfo passed in parameter is null.</li>
 244      *     <li>Wraps an {@link IllegalStateException} if the ModelMBean
 245      *         is currently registered in the MBeanServer.</li>
 246      * </ul>
 247      *
 248      **/
 249     public void setModelMBeanInfo(ModelMBeanInfo mbi)
 250         throws MBeanException, RuntimeOperationsException {
 251 
 252         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 253             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
 254         }
 255 
 256         if (mbi == null) {
 257             if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 258                 MODELMBEAN_LOGGER.log(Level.TRACE,
 259                     "ModelMBeanInfo is null: Raising exception.");
 260             }
 261             final RuntimeException x = new
 262                 IllegalArgumentException("ModelMBeanInfo must not be null");
 263             final String exceptionText =
 264                 "Exception occurred trying to initialize the " +
 265                 "ModelMBeanInfo of the RequiredModelMBean";
 266             throw new RuntimeOperationsException(x,exceptionText);
 267         }
 268 
 269         if (registered) {
 270             if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 271                 MODELMBEAN_LOGGER.log(Level.TRACE,
 272                     "RequiredMBean is registered: Raising exception.");
 273             }
 274             final String exceptionText =
 275                 "Exception occurred trying to set the " +
 276                 "ModelMBeanInfo of the RequiredModelMBean";
 277             final RuntimeException x = new IllegalStateException(
 278              "cannot call setModelMBeanInfo while ModelMBean is registered");
 279             throw new RuntimeOperationsException(x,exceptionText);
 280         }
 281 
 282         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 283             MODELMBEAN_LOGGER.log(Level.TRACE,
 284                 "Setting ModelMBeanInfo to " + printModelMBeanInfo(mbi));
 285             int noOfNotifications = 0;
 286             if (mbi.getNotifications() != null) {
 287                 noOfNotifications = mbi.getNotifications().length;
 288             }
 289             MODELMBEAN_LOGGER.log(Level.TRACE,
 290                 "ModelMBeanInfo notifications has " +
 291                 noOfNotifications + " elements");
 292         }
 293 
 294         modelMBeanInfo = (ModelMBeanInfo)mbi.clone();
 295 
 296         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 297             MODELMBEAN_LOGGER.log(Level.TRACE, "set mbeanInfo to: "+
 298                  printModelMBeanInfo(modelMBeanInfo));
 299             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
 300         }
 301     }
 302 
 303 
 304     /**
 305      * Sets the instance handle of the object against which to
 306      * execute all methods in this ModelMBean management interface
 307      * (MBeanInfo and Descriptors).
 308      *
 309      * @param mr Object that is the managed resource
 310      * @param mr_type The type of reference for the managed resource.
 311      *     <br>Can be: "ObjectReference", "Handle", "IOR", "EJBHandle",
 312      *         or "RMIReference".
 313      *     <br>In this implementation only "ObjectReference" is supported.
 314      *
 315      * @exception MBeanException The initializer of the object has
 316      *            thrown an exception.
 317      * @exception InstanceNotFoundException The managed resource
 318      *            object could not be found
 319      * @exception InvalidTargetObjectTypeException The managed
 320      *            resource type should be "ObjectReference".
 321      * @exception RuntimeOperationsException Wraps a {@link
 322      *            RuntimeException} when setting the resource.
 323      **/
 324     public void setManagedResource(Object mr, String mr_type)
 325         throws MBeanException, RuntimeOperationsException,
 326                InstanceNotFoundException, InvalidTargetObjectTypeException {
 327         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 328             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
 329         }
 330 
 331         // check that the mr_type is supported by this JMXAgent
 332         // only "objectReference" is supported
 333         if ((mr_type == null) ||
 334             (! mr_type.equalsIgnoreCase("objectReference"))) {
 335             if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 336                 MODELMBEAN_LOGGER.log(Level.TRACE,
 337                     "Managed Resource Type is not supported: " + mr_type);
 338             }
 339             throw new InvalidTargetObjectTypeException(mr_type);
 340         }
 341 
 342         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 343             MODELMBEAN_LOGGER.log(Level.TRACE,
 344                 "Managed Resource is valid");
 345         }
 346         managedResource = mr;
 347 
 348         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 349             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
 350         }
 351     }
 352 
 353     /**
 354      * <p>Instantiates this MBean instance with the data found for
 355      * the MBean in the persistent store.  The data loaded could include
 356      * attribute and operation values.</p>
 357      *
 358      * <p>This method should be called during construction or
 359      * initialization of this instance, and before the MBean is
 360      * registered with the MBeanServer.</p>
 361      *
 362      * <p>If the implementation of this class does not support
 363      * persistence, an {@link MBeanException} wrapping a {@link
 364      * ServiceNotFoundException} is thrown.</p>
 365      *
 366      * @exception MBeanException Wraps another exception, or
 367      * persistence is not supported
 368      * @exception RuntimeOperationsException Wraps exceptions from the
 369      * persistence mechanism
 370      * @exception InstanceNotFoundException Could not find or load
 371      * this MBean from persistent storage
 372      */
 373     public void load()
 374         throws MBeanException, RuntimeOperationsException,
 375                InstanceNotFoundException {
 376         final ServiceNotFoundException x = new ServiceNotFoundException(
 377                                 "Persistence not supported for this MBean");
 378         throw new MBeanException(x, x.getMessage());
 379     }
 380 
 381         /**
 382      * <p>Captures the current state of this MBean instance and writes
 383      * it out to the persistent store.  The state stored could include
 384      * attribute and operation values.</p>
 385      *
 386      * <p>If the implementation of this class does not support
 387      * persistence, an {@link MBeanException} wrapping a {@link
 388      * ServiceNotFoundException} is thrown.</p>
 389      *
 390      * <p>Persistence policy from the MBean and attribute descriptor
 391      * is used to guide execution of this method. The MBean should be
 392      * stored if 'persistPolicy' field is:</p>
 393      *
 394      * <PRE>{@literal  != "never"
 395      *   = "always"
 396      *   = "onTimer" and now > 'lastPersistTime' + 'persistPeriod'
 397      *   = "NoMoreOftenThan" and now > 'lastPersistTime' + 'persistPeriod'
 398      *   = "onUnregister"
 399      * }</PRE>
 400      *
 401      * <p>Do not store the MBean if 'persistPolicy' field is:</p>
 402      * <PRE>{@literal
 403      *    = "never"
 404      *    = "onUpdate"
 405      *    = "onTimer" && now < 'lastPersistTime' + 'persistPeriod'
 406      * }</PRE>
 407      *
 408      * @exception MBeanException Wraps another exception, or
 409      * persistence is not supported
 410      * @exception RuntimeOperationsException Wraps exceptions from the
 411      * persistence mechanism
 412      * @exception InstanceNotFoundException Could not find/access the
 413      * persistent store
 414      */
 415     public void store()
 416         throws MBeanException, RuntimeOperationsException,
 417                InstanceNotFoundException {
 418         final ServiceNotFoundException x = new ServiceNotFoundException(
 419                                 "Persistence not supported for this MBean");
 420         throw new MBeanException(x, x.getMessage());
 421     }
 422 
 423     /*************************************/
 424     /* DynamicMBean Interface            */
 425     /*************************************/
 426 
 427     /**
 428      * The resolveForCacheValue method checks the descriptor passed in to
 429      * see if there is a valid cached value in the descriptor.
 430      * The valid value will be in the 'value' field if there is one.
 431      * If the 'currencyTimeLimit' field in the descriptor is:
 432      * <ul>
 433      *   <li><b>&lt;0</b> Then the value is not cached and is never valid.
 434      *         Null is returned. The 'value' and 'lastUpdatedTimeStamp'
 435      *         fields are cleared.</li>
 436      *   <li><b>=0</b> Then the value is always cached and always valid.
 437      *         The 'value' field is returned.
 438      *         The 'lastUpdatedTimeStamp' field is not checked.</li>
 439      *   <li><b>&gt;0</b> Represents the number of seconds that the
 440      *         'value' field is valid.
 441      *         The 'value' field is no longer valid when
 442      *         'lastUpdatedTimeStamp' + 'currencyTimeLimit' &gt; Now.
 443      *       <ul>
 444      *       <li>When 'value' is valid, 'valid' is returned.</li>
 445      *       <li>When 'value' is no longer valid then null is returned and
 446      *           'value' and 'lastUpdatedTimeStamp' fields are cleared.</li>
 447      *       </ul>
 448      *   </li>
 449      * </ul>
 450      *
 451      **/
 452     private Object resolveForCacheValue(Descriptor descr)
 453         throws MBeanException, RuntimeOperationsException {
 454 
 455         final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.TRACE);
 456         if (tracing) {
 457             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
 458         }
 459 
 460         Object response = null;
 461         boolean resetValue = false, returnCachedValue = true;
 462         long currencyPeriod = 0;
 463 
 464         if (descr == null) {
 465             if (tracing) {
 466                 MODELMBEAN_LOGGER.log(Level.TRACE,
 467                     "Input Descriptor is null");
 468             }
 469             return response;
 470         }
 471 
 472         if (tracing) {
 473             MODELMBEAN_LOGGER.log(Level.TRACE,
 474                     "descriptor is " + descr);
 475         }
 476 
 477         final Descriptor mmbDescr = modelMBeanInfo.getMBeanDescriptor();
 478         if (mmbDescr == null) {
 479             if (tracing) {
 480                 MODELMBEAN_LOGGER.log(Level.TRACE,
 481                         "MBean Descriptor is null");
 482             }
 483             //return response;
 484         }
 485 
 486         Object objExpTime = descr.getFieldValue("currencyTimeLimit");
 487 
 488         String expTime;
 489         if (objExpTime != null) {
 490             expTime = objExpTime.toString();
 491         } else {
 492             expTime = null;
 493         }
 494 
 495         if ((expTime == null) && (mmbDescr != null)) {
 496             objExpTime = mmbDescr.getFieldValue("currencyTimeLimit");
 497             if (objExpTime != null) {
 498                 expTime = objExpTime.toString();
 499             } else {
 500                 expTime = null;
 501             }
 502         }
 503 
 504         if (expTime != null) {
 505             if (tracing) {
 506                 MODELMBEAN_LOGGER.log(Level.TRACE,
 507                         "currencyTimeLimit: " + expTime);
 508             }
 509 
 510             // convert seconds to milliseconds for time comparison
 511             currencyPeriod = Long.parseLong(expTime) * 1000;
 512             if (currencyPeriod < 0) {
 513                 /* if currencyTimeLimit is -1 then value is never cached */
 514                 returnCachedValue = false;
 515                 resetValue = true;
 516                 if (tracing) {
 517                     MODELMBEAN_LOGGER.log(Level.TRACE,
 518                         currencyPeriod + ": never Cached");
 519                 }
 520             } else if (currencyPeriod == 0) {
 521                 /* if currencyTimeLimit is 0 then value is always cached */
 522                 returnCachedValue = true;
 523                 resetValue = false;
 524                 if (tracing) {
 525                     MODELMBEAN_LOGGER.log(Level.TRACE, "always valid Cache");
 526                 }
 527             } else {
 528                 Object objtStamp =
 529                     descr.getFieldValue("lastUpdatedTimeStamp");
 530 
 531                 String tStamp;
 532                 if (objtStamp != null) tStamp = objtStamp.toString();
 533                 else tStamp = null;
 534 
 535                 if (tracing) {
 536                     MODELMBEAN_LOGGER.log(Level.TRACE,
 537                         "lastUpdatedTimeStamp: " + tStamp);
 538                 }
 539 
 540                 if (tStamp == null)
 541                     tStamp = "0";
 542 
 543                 long lastTime = Long.parseLong(tStamp);
 544 
 545                 if (tracing) {
 546                     MODELMBEAN_LOGGER.log(Level.TRACE,
 547                         "currencyPeriod:" + currencyPeriod +
 548                         " lastUpdatedTimeStamp:" + lastTime);
 549                 }
 550 
 551                 long now = (new Date()).getTime();
 552 
 553                 if (now < (lastTime + currencyPeriod)) {
 554                     returnCachedValue = true;
 555                     resetValue = false;
 556                     if (tracing) {
 557                         MODELMBEAN_LOGGER.log(Level.TRACE,
 558                             " timed valid Cache for " + now + " < " +
 559                             (lastTime + currencyPeriod));
 560                     }
 561                 } else { /* value is expired */
 562                     returnCachedValue = false;
 563                     resetValue = true;
 564                     if (tracing) {
 565                         MODELMBEAN_LOGGER.log(Level.TRACE,
 566                             "timed expired cache for " + now + " > " +
 567                             (lastTime + currencyPeriod));
 568                     }
 569                 }
 570             }
 571             if (tracing) {
 572                 MODELMBEAN_LOGGER.log(Level.TRACE,
 573                     "returnCachedValue:" + returnCachedValue +
 574                     " resetValue: " + resetValue);
 575             }
 576 
 577             if (returnCachedValue == true) {
 578                 Object currValue = descr.getFieldValue("value");
 579                 if (currValue != null) {
 580                     /* error/validity check return value here */
 581                     response = currValue;
 582                     /* need to cast string cached value to type */
 583                     if (tracing) {
 584                         MODELMBEAN_LOGGER.log(Level.TRACE,
 585                             "valid Cache value: " + currValue);
 586                     }
 587 
 588                 } else {
 589                     response = null;
 590                     if (tracing) {
 591                         MODELMBEAN_LOGGER.log(Level.TRACE,
 592                                  "no Cached value");
 593                     }
 594                 }
 595             }
 596 
 597             if (resetValue == true) {
 598                 /* value is not current, so remove it */
 599                 descr.removeField("lastUpdatedTimeStamp");
 600                 descr.removeField("value");
 601                 response = null;
 602                 modelMBeanInfo.setDescriptor(descr,null);
 603                 if (tracing) {
 604                     MODELMBEAN_LOGGER.log(Level.TRACE,
 605                         "reset cached value to null");
 606                 }
 607             }
 608         }
 609 
 610         if (tracing) {
 611             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
 612         }
 613 
 614         return response;
 615     }
 616 
 617     /**
 618      * Returns the attributes, operations, constructors and notifications
 619      * that this RequiredModelMBean exposes for management.
 620      *
 621      * @return  An instance of ModelMBeanInfo allowing retrieval all
 622      *          attributes, operations, and Notifications of this MBean.
 623      *
 624      **/
 625     public MBeanInfo getMBeanInfo() {
 626 
 627         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 628             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
 629         }
 630 
 631         if (modelMBeanInfo == null) {
 632             if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 633                 MODELMBEAN_LOGGER.log(Level.TRACE, "modelMBeanInfo is null");
 634             }
 635             modelMBeanInfo = createDefaultModelMBeanInfo();
 636             //return new ModelMBeanInfo(" ", "", null, null, null, null);
 637         }
 638 
 639         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 640             MODELMBEAN_LOGGER.log(Level.TRACE, "ModelMBeanInfo is " +
 641                   modelMBeanInfo.getClassName() + " for " +
 642                   modelMBeanInfo.getDescription());
 643             MODELMBEAN_LOGGER.log(Level.TRACE,
 644                     printModelMBeanInfo(modelMBeanInfo));
 645         }
 646 
 647         return((MBeanInfo) modelMBeanInfo.clone());
 648     }
 649 
 650     private String printModelMBeanInfo(ModelMBeanInfo info) {
 651         final StringBuilder retStr = new StringBuilder();
 652         if (info == null) {
 653             if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
 654                 MODELMBEAN_LOGGER.log(Level.TRACE,
 655                         "ModelMBeanInfo to print is null, " +
 656                         "printing local ModelMBeanInfo");
 657             }
 658             info = modelMBeanInfo;
 659         }
 660 
 661         retStr.append("\nMBeanInfo for ModelMBean is:");
 662         retStr.append("\nCLASSNAME: \t").append(info.getClassName());
 663         retStr.append("\nDESCRIPTION: \t").append(info.getDescription());
 664 
 665 
 666         try {
 667             retStr.append("\nMBEAN DESCRIPTOR: \t").append(info.getMBeanDescriptor());
 668         } catch (Exception e) {
 669             retStr.append("\nMBEAN DESCRIPTOR: \t  is invalid");
 670         }
 671 
 672         retStr.append("\nATTRIBUTES");
 673 
 674         final MBeanAttributeInfo[] attrInfo = info.getAttributes();
 675         if ((attrInfo != null) && (attrInfo.length>0)) {
 676             for (int i=0; i<attrInfo.length; i++) {
 677                 final ModelMBeanAttributeInfo attInfo =
 678                     (ModelMBeanAttributeInfo)attrInfo[i];
 679                 retStr.append(" ** NAME: \t").append(attInfo.getName());
 680                 retStr.append("    DESCR: \t").append(attInfo.getDescription());
 681                 retStr.append("    TYPE: \t").append(attInfo.getType())
 682                         .append("    READ: \t").append(attInfo.isReadable())
 683                         .append("    WRITE: \t").append(attInfo.isWritable());
 684                 retStr.append("    DESCRIPTOR: ").append(attInfo.getDescriptor());
 685             }
 686         } else {
 687             retStr.append(" ** No attributes **");
 688         }
 689 
 690         retStr.append("\nCONSTRUCTORS");
 691         final MBeanConstructorInfo[] constrInfo = info.getConstructors();
 692         if ((constrInfo != null) && (constrInfo.length > 0 )) {
 693             for (int i=0; i<constrInfo.length; i++) {
 694                 final ModelMBeanConstructorInfo ctorInfo =
 695                     (ModelMBeanConstructorInfo)constrInfo[i];
 696                 retStr.append(" ** NAME: \t").append(ctorInfo.getName());
 697                 retStr.append("    DESCR: \t").append(ctorInfo.getDescription());
 698                 retStr.append("    PARAM: \t")
 699                         .append(ctorInfo.getSignature().length)
 700                         .append(" parameter(s)");
 701                 retStr.append("    DESCRIPTOR: ").append(
 702                         ctorInfo.getDescriptor());
 703             }
 704         } else {
 705             retStr.append(" ** No Constructors **");
 706         }
 707 
 708         retStr.append("\nOPERATIONS");
 709         final MBeanOperationInfo[] opsInfo = info.getOperations();
 710         if ((opsInfo != null) && (opsInfo.length>0)) {
 711             for (int i=0; i<opsInfo.length; i++) {
 712                 final ModelMBeanOperationInfo operInfo =
 713                     (ModelMBeanOperationInfo)opsInfo[i];
 714                 retStr.append(" ** NAME: \t").append(operInfo.getName());
 715                 retStr.append("    DESCR: \t").append(operInfo.getDescription());
 716                 retStr.append("    PARAM: \t")
 717                         .append(operInfo.getSignature().length)
 718                         .append(" parameter(s)");
 719                 retStr.append("    DESCRIPTOR: ").append(operInfo.getDescriptor());
 720             }
 721         } else {
 722             retStr.append(" ** No operations ** ");
 723         }
 724 
 725         retStr.append("\nNOTIFICATIONS");
 726 
 727         MBeanNotificationInfo[] notifInfo = info.getNotifications();
 728         if ((notifInfo != null) && (notifInfo.length>0)) {
 729             for (int i=0; i<notifInfo.length; i++) {
 730                 final ModelMBeanNotificationInfo nInfo =
 731                     (ModelMBeanNotificationInfo)notifInfo[i];
 732                 retStr.append(" ** NAME: \t").append(nInfo.getName());
 733                 retStr.append("    DESCR: \t").append(nInfo.getDescription());
 734                 retStr.append("    DESCRIPTOR: ").append(nInfo.getDescriptor());
 735             }
 736         } else {
 737             retStr.append(" ** No notifications **");
 738         }
 739 
 740         retStr.append(" ** ModelMBean: End of MBeanInfo ** ");
 741 
 742         return retStr.toString();
 743     }
 744 
 745     /**
 746      * Invokes a method on or through a RequiredModelMBean and returns
 747      * the result of the method execution.
 748      * <P>
 749      * If the given method to be invoked, together with the provided
 750      * signature, matches one of RequiredModelMbean
 751      * accessible methods, this one will be call. Otherwise the call to
 752      * the given method will be tried on the managed resource.
 753      * <P>
 754      * The last value returned by an operation may be cached in
 755      * the operation's descriptor which
 756      * is in the ModelMBeanOperationInfo's descriptor.
 757      * The valid value will be in the 'value' field if there is one.
 758      * If the 'currencyTimeLimit' field in the descriptor is:
 759      * <UL>
 760      * <LI><b>&lt;0</b> Then the value is not cached and is never valid.
 761      *      The operation method is invoked.
 762      *      The 'value' and 'lastUpdatedTimeStamp' fields are cleared.</LI>
 763      * <LI><b>=0</b> Then the value is always cached and always valid.
 764      *      The 'value' field is returned. If there is no 'value' field
 765      *      then the operation method is invoked for the attribute.
 766      *      The 'lastUpdatedTimeStamp' field and `value' fields are set to
 767      *      the operation's return value and the current time stamp.</LI>
 768      * <LI><b>&gt;0</b> Represents the number of seconds that the 'value'
 769      *      field is valid.
 770      *      The 'value' field is no longer valid when
 771      *      'lastUpdatedTimeStamp' + 'currencyTimeLimit' &gt; Now.
 772      *      <UL>
 773      *         <LI>When 'value' is valid, 'value' is returned.</LI>
 774      *         <LI>When 'value' is no longer valid then the operation
 775      *             method is invoked. The 'lastUpdatedTimeStamp' field
 776      *             and `value' fields are updated.</lI>
 777      *      </UL>
 778      * </LI>
 779      * </UL>
 780      *
 781      * <p><b>Note:</b> because of inconsistencies in previous versions of
 782      * this specification, it is recommended not to use negative or zero
 783      * values for <code>currencyTimeLimit</code>.  To indicate that a
 784      * cached value is never valid, omit the
 785      * <code>currencyTimeLimit</code> field.  To indicate that it is
 786      * always valid, use a very large number for this field.</p>
 787      *
 788      * @param opName The name of the method to be invoked. The
 789      *     name can be the fully qualified method name including the
 790      *     classname, or just the method name if the classname is
 791      *     defined in the 'class' field of the operation descriptor.
 792      * @param opArgs An array containing the parameters to be set
 793      *     when the operation is invoked
 794      * @param sig An array containing the signature of the
 795      *     operation. The class objects will be loaded using the same
 796      *     class loader as the one used for loading the MBean on which
 797      *     the operation was invoked.
 798      *
 799      * @return  The object returned by the method, which represents the
 800      *     result of invoking the method on the specified managed resource.
 801      *
 802      * @exception MBeanException  Wraps one of the following Exceptions:
 803      * <UL>
 804      * <LI> An Exception thrown by the managed object's invoked method.</LI>
 805      * <LI> {@link ServiceNotFoundException}: No ModelMBeanOperationInfo or
 806      *      no descriptor defined for the specified operation or the managed
 807      *      resource is null.</LI>
 808      * <LI> {@link InvalidTargetObjectTypeException}: The 'targetType'
 809      *      field value is not 'objectReference'.</LI>
 810      * </UL>
 811      * @exception ReflectionException  Wraps an {@link java.lang.Exception}
 812      *      thrown while trying to invoke the method.
 813      * @exception RuntimeOperationsException Wraps an
 814      *      {@link IllegalArgumentException} Method name is null.
 815      *
 816      **/
 817     /*
 818       The requirement to be able to invoke methods on the
 819       RequiredModelMBean class itself makes this method considerably
 820       more complicated than it might otherwise be.  Note that, unlike
 821       earlier versions, we do not allow you to invoke such methods if
 822       they are not explicitly mentioned in the ModelMBeanInfo.  Doing
 823       so was potentially a security problem, and certainly very
 824       surprising.
 825 
 826       We do not look for the method in the RequiredModelMBean class
 827       itself if:
 828       (a) there is a "targetObject" field in the Descriptor for the
 829       operation; or
 830       (b) there is a "class" field in the Descriptor for the operation
 831       and the named class is not RequiredModelMBean or one of its
 832       superinterfaces; or
 833       (c) the name of the operation is not the name of a method in
 834       RequiredModelMBean (this is just an optimization).
 835 
 836       In cases (a) and (b), if you have gone to the trouble of adding
 837       those fields specifically for this operation then presumably you
 838       do not want RequiredModelMBean's methods to be called.
 839 
 840       We have to pay attention to class loading issues.  If the
 841       "class" field is present, the named class has to be resolved
 842       relative to RequiredModelMBean's class loader to test the
 843       condition (b) above, and relative to the managed resource's
 844       class loader to ensure that the managed resource is in fact of
 845       the named class (or a subclass).  The class names in the sig
 846       array likewise have to be resolved, first against
 847       RequiredModelMBean's class loader, then against the managed
 848       resource's class loader.  There is no point in using any other
 849       loader because when we call Method.invoke we must call it on
 850       a Method that is implemented by the target object.
 851      */
 852     public Object invoke(String opName, Object[] opArgs, String[] sig)
 853             throws MBeanException, ReflectionException {
 854 
 855         final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.TRACE);
 856 
 857         if (tracing) {
 858             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
 859         }
 860 
 861         if (opName == null) {
 862             final RuntimeException x =
 863                 new IllegalArgumentException("Method name must not be null");
 864             throw new RuntimeOperationsException(x,
 865                       "An exception occurred while trying to " +
 866                       "invoke a method on a RequiredModelMBean");
 867         }
 868 
 869         String opClassName = null;
 870         String opMethodName;
 871 
 872         // Parse for class name and method
 873         int opSplitter = opName.lastIndexOf('.');
 874         if (opSplitter > 0) {
 875             opClassName = opName.substring(0,opSplitter);
 876             opMethodName = opName.substring(opSplitter+1);
 877         } else
 878             opMethodName = opName;
 879 
 880         /* Ignore anything after a left paren.  We keep this for
 881            compatibility but it isn't specified.  */
 882         opSplitter = opMethodName.indexOf('(');
 883         if (opSplitter > 0)
 884             opMethodName = opMethodName.substring(0,opSplitter);
 885 
 886         if (tracing) {
 887             MODELMBEAN_LOGGER.log(Level.TRACE,
 888                     "Finding operation " + opName + " as " + opMethodName);
 889         }
 890 
 891         ModelMBeanOperationInfo opInfo =
 892             modelMBeanInfo.getOperation(opMethodName);
 893         if (opInfo == null) {
 894             final String msg =
 895                 "Operation " + opName + " not in ModelMBeanInfo";
 896             throw new MBeanException(new ServiceNotFoundException(msg), msg);
 897         }
 898 
 899         final Descriptor opDescr = opInfo.getDescriptor();
 900         if (opDescr == null) {
 901             final String msg = "Operation descriptor null";
 902             throw new MBeanException(new ServiceNotFoundException(msg), msg);
 903         }
 904 
 905         final Object cached = resolveForCacheValue(opDescr);
 906         if (cached != null) {
 907             if (tracing) {
 908                 MODELMBEAN_LOGGER.log(Level.TRACE, "Returning cached value");
 909             }
 910             return cached;
 911         }
 912 
 913         if (opClassName == null)
 914             opClassName = (String) opDescr.getFieldValue("class");
 915         // may still be null now
 916 
 917         opMethodName = (String) opDescr.getFieldValue("name");
 918         if (opMethodName == null) {
 919             final String msg =
 920                 "Method descriptor must include `name' field";
 921             throw new MBeanException(new ServiceNotFoundException(msg), msg);
 922         }
 923 
 924         final String targetTypeField = (String)
 925             opDescr.getFieldValue("targetType");
 926         if (targetTypeField != null
 927             && !targetTypeField.equalsIgnoreCase("objectReference")) {
 928             final String msg =
 929                 "Target type must be objectReference: " + targetTypeField;
 930             throw new MBeanException(new InvalidTargetObjectTypeException(msg),
 931                                      msg);
 932         }
 933 
 934         final Object targetObjectField = opDescr.getFieldValue("targetObject");
 935         if (tracing && targetObjectField != null)
 936                 MODELMBEAN_LOGGER.log(Level.TRACE,
 937                         "Found target object in descriptor");
 938 
 939         /* Now look for the method, either in RequiredModelMBean itself
 940            or in the target object.  Set "method" and "targetObject"
 941            appropriately.  */
 942         Method method;
 943         Object targetObject;
 944 
 945         method = findRMMBMethod(opMethodName, targetObjectField,
 946                                 opClassName, sig);
 947 
 948         if (method != null)
 949             targetObject = this;
 950         else {
 951             if (tracing) {
 952                 MODELMBEAN_LOGGER.log(Level.TRACE,
 953                         "looking for method in managedResource class");
 954             }
 955             if (targetObjectField != null)
 956                 targetObject = targetObjectField;
 957             else {
 958                 targetObject = managedResource;
 959                 if (targetObject == null) {
 960                     final String msg =
 961                         "managedResource for invoke " + opName +
 962                         " is null";
 963                     Exception snfe = new ServiceNotFoundException(msg);
 964                     throw new MBeanException(snfe);
 965                 }
 966             }
 967 
 968             final Class<?> targetClass;
 969 
 970             if (opClassName != null) {
 971                 try {
 972                     AccessControlContext stack = AccessController.getContext();
 973                     final Object obj = targetObject;
 974                     final String className = opClassName;
 975                     final ClassNotFoundException[] caughtException = new ClassNotFoundException[1];
 976 
 977                     targetClass = javaSecurityAccess.doIntersectionPrivilege(new PrivilegedAction<Class<?>>() {
 978 
 979                         @Override
 980                         public Class<?> run() {
 981                             try {
 982                                 ReflectUtil.checkPackageAccess(className);
 983                                 final ClassLoader targetClassLoader =
 984                                     obj.getClass().getClassLoader();
 985                                 return Class.forName(className, false,
 986                                                             targetClassLoader);
 987                             } catch (ClassNotFoundException e) {
 988                                 caughtException[0] = e;
 989                             }
 990                             return null;
 991                         }
 992                     }, stack, acc);
 993 
 994                     if (caughtException[0] != null) {
 995                         throw caughtException[0];
 996                     }
 997                 } catch (ClassNotFoundException e) {
 998                     final String msg =
 999                         "class for invoke " + opName + " not found";
1000                     throw new ReflectionException(e, msg);
1001                 }
1002             } else
1003                 targetClass = targetObject.getClass();
1004 
1005             method = resolveMethod(targetClass, opMethodName, sig);
1006         }
1007 
1008         if (tracing) {
1009             MODELMBEAN_LOGGER.log(Level.TRACE,
1010                     "found " + opMethodName + ", now invoking");
1011         }
1012 
1013         final Object result =
1014             invokeMethod(opName, method, targetObject, opArgs);
1015 
1016         if (tracing) {
1017             MODELMBEAN_LOGGER.log(Level.TRACE, "successfully invoked method");
1018         }
1019 
1020         if (result != null)
1021             cacheResult(opInfo, opDescr, result);
1022 
1023         return result;
1024     }
1025 
1026     private Method resolveMethod(Class<?> targetClass,
1027                                         String opMethodName,
1028                                         final String[] sig)
1029             throws ReflectionException {
1030         final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.TRACE);
1031 
1032         if (tracing) {
1033             MODELMBEAN_LOGGER.log(Level.TRACE,
1034                     "resolving " + targetClass.getName() + "." + opMethodName);
1035         }
1036 
1037         final Class<?>[] argClasses;
1038 
1039         if (sig == null)
1040             argClasses = null;
1041         else {
1042             final AccessControlContext stack = AccessController.getContext();
1043             final ReflectionException[] caughtException = new ReflectionException[1];
1044             final ClassLoader targetClassLoader = targetClass.getClassLoader();
1045             argClasses = new Class<?>[sig.length];
1046 
1047             javaSecurityAccess.doIntersectionPrivilege(new PrivilegedAction<Void>() {
1048 
1049                 @Override
1050                 public Void run() {
1051                     for (int i = 0; i < sig.length; i++) {
1052                         if (tracing) {
1053                             MODELMBEAN_LOGGER.log(Level.TRACE,
1054                                     "resolve type " + sig[i]);
1055                         }
1056                         argClasses[i] = (Class<?>) primitiveClassMap.get(sig[i]);
1057                         if (argClasses[i] == null) {
1058                             try {
1059                                 ReflectUtil.checkPackageAccess(sig[i]);
1060                                 argClasses[i] =
1061                                     Class.forName(sig[i], false, targetClassLoader);
1062                             } catch (ClassNotFoundException e) {
1063                                 if (tracing) {
1064                                     MODELMBEAN_LOGGER.log(Level.TRACE,
1065                                             "class not found");
1066                                 }
1067                                 final String msg = "Parameter class not found";
1068                                 caughtException[0] = new ReflectionException(e, msg);
1069                             }
1070                         }
1071                     }
1072                     return null;
1073                 }
1074             }, stack, acc);
1075 
1076             if (caughtException[0] != null) {
1077                 throw caughtException[0];
1078             }
1079         }
1080 
1081         try {
1082             return targetClass.getMethod(opMethodName, argClasses);
1083         } catch (NoSuchMethodException e) {
1084             final String msg =
1085                 "Target method not found: " + targetClass.getName() + "." +
1086                 opMethodName;
1087             throw new ReflectionException(e, msg);
1088         }
1089     }
1090 
1091     /* Map e.g. "int" to int.class.  Goodness knows how many time this
1092        particular wheel has been reinvented.  */
1093     private static final Class<?>[] primitiveClasses = {
1094         int.class, long.class, boolean.class, double.class,
1095         float.class, short.class, byte.class, char.class,
1096     };
1097     private static final Map<String,Class<?>> primitiveClassMap =
1098         new HashMap<String,Class<?>>();
1099     static {
1100         for (int i = 0; i < primitiveClasses.length; i++) {
1101             final Class<?> c = primitiveClasses[i];
1102             primitiveClassMap.put(c.getName(), c);
1103         }
1104     }
1105 
1106     /* Find a method in RequiredModelMBean as determined by the given
1107        parameters.  Return null if there is none, or if the parameters
1108        exclude using it.  Called from invoke. */
1109     private Method findRMMBMethod(String opMethodName,
1110                                          Object targetObjectField,
1111                                          String opClassName,
1112                                          String[] sig) {
1113         final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.TRACE);
1114 
1115         if (tracing) {
1116             MODELMBEAN_LOGGER.log(Level.TRACE,
1117                   "looking for method in RequiredModelMBean class");
1118         }
1119 
1120         if (!isRMMBMethodName(opMethodName))
1121             return null;
1122         if (targetObjectField != null)
1123             return null;
1124         final Class<RequiredModelMBean> rmmbClass = RequiredModelMBean.class;
1125         final Class<?> targetClass;
1126         if (opClassName == null)
1127             targetClass = rmmbClass;
1128         else {
1129             AccessControlContext stack = AccessController.getContext();
1130             final String className = opClassName;
1131             targetClass = javaSecurityAccess.doIntersectionPrivilege(new PrivilegedAction<Class<?>>() {
1132 
1133                 @Override
1134                 public Class<?> run() {
1135                     try {
1136                         ReflectUtil.checkPackageAccess(className);
1137                         final ClassLoader targetClassLoader =
1138                             rmmbClass.getClassLoader();
1139                         Class<?> clz = Class.forName(className, false,
1140                                                     targetClassLoader);
1141                         if (!rmmbClass.isAssignableFrom(clz))
1142                             return null;
1143                         return clz;
1144                     } catch (ClassNotFoundException e) {
1145                         return null;
1146                     }
1147                 }
1148             }, stack, acc);
1149         }
1150         try {
1151             return targetClass != null ? resolveMethod(targetClass, opMethodName, sig) : null;
1152         } catch (ReflectionException e) {
1153             return null;
1154         }
1155     }
1156 
1157     /*
1158      * Invoke the given method, and throw the somewhat unpredictable
1159      * appropriate exception if the method itself gets an exception.
1160      */
1161     private Object invokeMethod(String opName, final Method method,
1162                                 final Object targetObject, final Object[] opArgs)
1163             throws MBeanException, ReflectionException {
1164         try {
1165             final Throwable[] caughtException = new Throwable[1];
1166             AccessControlContext stack = AccessController.getContext();
1167             Object rslt = javaSecurityAccess.doIntersectionPrivilege(new PrivilegedAction<Object>() {
1168 
1169                 @Override
1170                 public Object run() {
1171                     try {
1172                         ReflectUtil.checkPackageAccess(method.getDeclaringClass());
1173                         return MethodUtil.invoke(method, targetObject, opArgs);
1174                     } catch (InvocationTargetException e) {
1175                         caughtException[0] = e;
1176                     } catch (IllegalAccessException e) {
1177                         caughtException[0] = e;
1178                     }
1179                     return null;
1180                 }
1181             }, stack, acc);
1182             if (caughtException[0] != null) {
1183                 if (caughtException[0] instanceof Exception) {
1184                     throw (Exception)caughtException[0];
1185                 } else if(caughtException[0] instanceof Error) {
1186                     throw (Error)caughtException[0];
1187                 }
1188             }
1189             return rslt;
1190         } catch (RuntimeErrorException ree) {
1191             throw new RuntimeOperationsException(ree,
1192                       "RuntimeException occurred in RequiredModelMBean "+
1193                       "while trying to invoke operation " + opName);
1194         } catch (RuntimeException re) {
1195             throw new RuntimeOperationsException(re,
1196                       "RuntimeException occurred in RequiredModelMBean "+
1197                       "while trying to invoke operation " + opName);
1198         } catch (IllegalAccessException iae) {
1199             throw new ReflectionException(iae,
1200                       "IllegalAccessException occurred in " +
1201                       "RequiredModelMBean while trying to " +
1202                       "invoke operation " + opName);
1203         } catch (InvocationTargetException ite) {
1204             Throwable mmbTargEx = ite.getTargetException();
1205             if (mmbTargEx instanceof RuntimeException) {
1206                 throw new MBeanException ((RuntimeException)mmbTargEx,
1207                       "RuntimeException thrown in RequiredModelMBean "+
1208                       "while trying to invoke operation " + opName);
1209             } else if (mmbTargEx instanceof Error) {
1210                 throw new RuntimeErrorException((Error)mmbTargEx,
1211                       "Error occurred in RequiredModelMBean while trying "+
1212                       "to invoke operation " + opName);
1213             } else if (mmbTargEx instanceof ReflectionException) {
1214                 throw (ReflectionException) mmbTargEx;
1215             } else {
1216                 throw new MBeanException ((Exception)mmbTargEx,
1217                       "Exception thrown in RequiredModelMBean "+
1218                       "while trying to invoke operation " + opName);
1219             }
1220         } catch (Error err) {
1221             throw new RuntimeErrorException(err,
1222                   "Error occurred in RequiredModelMBean while trying "+
1223                   "to invoke operation " + opName);
1224         } catch (Exception e) {
1225             throw new ReflectionException(e,
1226                   "Exception occurred in RequiredModelMBean while " +
1227                   "trying to invoke operation " + opName);
1228         }
1229     }
1230 
1231     /*
1232      * Cache the result of an operation in the descriptor, if that is
1233      * called for by the descriptor's configuration.  Note that we
1234      * don't remember operation parameters when caching the result, so
1235      * this is unlikely to be useful if there are any.
1236      */
1237     private void cacheResult(ModelMBeanOperationInfo opInfo,
1238                              Descriptor opDescr, Object result)
1239             throws MBeanException {
1240 
1241         Descriptor mmbDesc =
1242             modelMBeanInfo.getMBeanDescriptor();
1243 
1244         Object objctl =
1245             opDescr.getFieldValue("currencyTimeLimit");
1246         String ctl;
1247         if (objctl != null) {
1248             ctl = objctl.toString();
1249         } else {
1250             ctl = null;
1251         }
1252         if ((ctl == null) && (mmbDesc != null)) {
1253             objctl =
1254                 mmbDesc.getFieldValue("currencyTimeLimit");
1255             if (objctl != null) {
1256                 ctl = objctl.toString();
1257             } else {
1258                 ctl = null;
1259             }
1260         }
1261         if ((ctl != null) && !(ctl.equals("-1"))) {
1262             opDescr.setField("value", result);
1263             opDescr.setField("lastUpdatedTimeStamp",
1264                     String.valueOf((new Date()).getTime()));
1265 
1266 
1267             modelMBeanInfo.setDescriptor(opDescr,
1268                                          "operation");
1269             if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
1270                 MODELMBEAN_LOGGER.log(Level.TRACE,
1271                         "new descriptor is " + opDescr);
1272             }
1273         }
1274     }
1275 
1276     /*
1277      * Determine whether the given name is the name of a public method
1278      * in this class.  This is only an optimization: it prevents us
1279      * from trying to do argument type lookups and reflection on a
1280      * method that will obviously fail because it has the wrong name.
1281      *
1282      * The first time this method is called we do the reflection, and
1283      * every other time we reuse the remembered values.
1284      *
1285      * It's conceivable that the (possibly malicious) first caller
1286      * doesn't have the required permissions to do reflection, in
1287      * which case we don't touch anything so as not to interfere
1288      * with a later permissionful caller.
1289      */
1290     private static Set<String> rmmbMethodNames;
1291     private static synchronized boolean isRMMBMethodName(String name) {
1292         if (rmmbMethodNames == null) {
1293             try {
1294                 Set<String> names = new HashSet<String>();
1295                 Method[] methods = RequiredModelMBean.class.getMethods();
1296                 for (int i = 0; i < methods.length; i++)
1297                     names.add(methods[i].getName());
1298                 rmmbMethodNames = names;
1299             } catch (Exception e) {
1300                 return true;
1301                 // This is only an optimization so we'll go on to discover
1302                 // whether the name really is an RMMB method.
1303             }
1304         }
1305         return rmmbMethodNames.contains(name);
1306     }
1307 
1308     /**
1309      * Returns the value of a specific attribute defined for this
1310      * ModelMBean.
1311      * The last value returned by an attribute may be cached in the
1312      * attribute's descriptor.
1313      * The valid value will be in the 'value' field if there is one.
1314      * If the 'currencyTimeLimit' field in the descriptor is:
1315      * <UL>
1316      * <LI>  <b>&lt;0</b> Then the value is not cached and is never valid.
1317      *       The getter method is invoked for the attribute.
1318      *       The 'value' and 'lastUpdatedTimeStamp' fields are cleared.</LI>
1319      * <LI>  <b>=0</b> Then the value is always cached and always valid.
1320      *       The 'value' field is returned. If there is no'value' field
1321      *       then the getter method is invoked for the attribute.
1322      *       The 'lastUpdatedTimeStamp' field and `value' fields are set
1323      *       to the attribute's value and the current time stamp.</LI>
1324      * <LI>  <b>&gt;0</b> Represents the number of seconds that the 'value'
1325      *       field is valid.
1326      *       The 'value' field is no longer valid when
1327      *       'lastUpdatedTimeStamp' + 'currencyTimeLimit' &gt; Now.
1328      *   <UL>
1329      *        <LI>When 'value' is valid, 'value' is returned.</LI>
1330      *        <LI>When 'value' is no longer valid then the getter
1331      *            method is invoked for the attribute.
1332      *            The 'lastUpdatedTimeStamp' field and `value' fields
1333      *            are updated.</LI>
1334      *   </UL></LI>
1335      * </UL>
1336      *
1337      * <p><b>Note:</b> because of inconsistencies in previous versions of
1338      * this specification, it is recommended not to use negative or zero
1339      * values for <code>currencyTimeLimit</code>.  To indicate that a
1340      * cached value is never valid, omit the
1341      * <code>currencyTimeLimit</code> field.  To indicate that it is
1342      * always valid, use a very large number for this field.</p>
1343      *
1344      * <p>If the 'getMethod' field contains the name of a valid
1345      * operation descriptor, then the method described by the
1346      * operation descriptor is executed.  The response from the
1347      * method is returned as the value of the attribute.  If the
1348      * operation fails or the returned value is not compatible with
1349      * the declared type of the attribute, an exception will be thrown.</p>
1350      *
1351      * <p>If no 'getMethod' field is defined then the default value of the
1352      * attribute is returned. If the returned value is not compatible with
1353      * the declared type of the attribute, an exception will be thrown.</p>
1354      *
1355      * <p>The declared type of the attribute is the String returned by
1356      * {@link ModelMBeanAttributeInfo#getType()}.  A value is compatible
1357      * with this type if one of the following is true:
1358      * <ul>
1359      * <li>the value is null;</li>
1360      * <li>the declared name is a primitive type name (such as "int")
1361      *     and the value is an instance of the corresponding wrapper
1362      *     type (such as java.lang.Integer);</li>
1363      * <li>the name of the value's class is identical to the declared name;</li>
1364      * <li>the declared name can be loaded by the value's class loader and
1365      *     produces a class to which the value can be assigned.</li>
1366      * </ul>
1367      *
1368      * <p>In this implementation, in every case where the getMethod needs to
1369      * be called, because the method is invoked through the standard "invoke"
1370      * method and thus needs operationInfo, an operation must be specified
1371      * for that getMethod so that the invocation works correctly.</p>
1372      *
1373      * @param attrName A String specifying the name of the
1374      * attribute to be retrieved. It must match the name of a
1375      * ModelMBeanAttributeInfo.
1376      *
1377      * @return The value of the retrieved attribute from the
1378      * descriptor 'value' field or from the invocation of the
1379      * operation in the 'getMethod' field of the descriptor.
1380      *
1381      * @exception AttributeNotFoundException The specified attribute is
1382      *    not accessible in the MBean.
1383      *    The following cases may result in an AttributeNotFoundException:
1384      *    <UL>
1385      *      <LI> No ModelMBeanInfo was found for the Model MBean.</LI>
1386      *      <LI> No ModelMBeanAttributeInfo was found for the specified
1387      *           attribute name.</LI>
1388      *      <LI> The ModelMBeanAttributeInfo isReadable method returns
1389      *           'false'.</LI>
1390      *    </UL>
1391      * @exception MBeanException  Wraps one of the following Exceptions:
1392      *    <UL>
1393      *      <LI> {@link InvalidAttributeValueException}: A wrong value type
1394      *           was received from the attribute's getter method or
1395      *           no 'getMethod' field defined in the descriptor for
1396      *           the attribute and no default value exists.</LI>
1397      *      <LI> {@link ServiceNotFoundException}: No
1398      *           ModelMBeanOperationInfo defined for the attribute's
1399      *           getter method or no descriptor associated with the
1400      *           ModelMBeanOperationInfo or the managed resource is
1401      *           null.</LI>
1402      *      <LI> {@link InvalidTargetObjectTypeException} The 'targetType'
1403      *           field value is not 'objectReference'.</LI>
1404      *      <LI> An Exception thrown by the managed object's getter.</LI>
1405      *    </UL>
1406      * @exception ReflectionException  Wraps an {@link java.lang.Exception}
1407      *    thrown while trying to invoke the getter.
1408      * @exception RuntimeOperationsException Wraps an
1409      *    {@link IllegalArgumentException}: The attribute name in
1410      *    parameter is null.
1411      *
1412      * @see #setAttribute(javax.management.Attribute)
1413      **/
1414     public Object getAttribute(String attrName)
1415         throws AttributeNotFoundException, MBeanException,
1416                ReflectionException {
1417         if (attrName == null)
1418             throw new RuntimeOperationsException(new
1419                 IllegalArgumentException("attributeName must not be null"),
1420                 "Exception occurred trying to get attribute of a " +
1421                 "RequiredModelMBean");
1422         final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.TRACE);
1423         if (tracing) {
1424             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry with " + attrName);
1425         }
1426 
1427         /* Check attributeDescriptor for getMethod */
1428         Object response;
1429 
1430         try {
1431             if (modelMBeanInfo == null)
1432                 throw new AttributeNotFoundException(
1433                       "getAttribute failed: ModelMBeanInfo not found for "+
1434                       attrName);
1435 
1436             ModelMBeanAttributeInfo attrInfo = modelMBeanInfo.getAttribute(attrName);
1437             Descriptor mmbDesc = modelMBeanInfo.getMBeanDescriptor();
1438 
1439             if (attrInfo == null)
1440                 throw new AttributeNotFoundException("getAttribute failed:"+
1441                       " ModelMBeanAttributeInfo not found for " + attrName);
1442 
1443             Descriptor attrDescr = attrInfo.getDescriptor();
1444             if (attrDescr != null) {
1445                 if (!attrInfo.isReadable())
1446                     throw new AttributeNotFoundException(
1447                           "getAttribute failed: " + attrName +
1448                           " is not readable ");
1449 
1450                 response = resolveForCacheValue(attrDescr);
1451 
1452                 /* return current cached value */
1453                 if (tracing) {
1454                     MODELMBEAN_LOGGER.log(Level.TRACE,
1455                             "*** cached value is " + response);
1456                 }
1457 
1458                 if (response == null) {
1459                     /* no cached value, run getMethod */
1460                     if (tracing) {
1461                         MODELMBEAN_LOGGER.log(Level.TRACE,
1462                             "**** cached value is null - getting getMethod");
1463                     }
1464                     String attrGetMethod =
1465                         (String)(attrDescr.getFieldValue("getMethod"));
1466 
1467                     if (attrGetMethod != null) {
1468                         /* run method from operations descriptor */
1469                         if (tracing) {
1470                             MODELMBEAN_LOGGER.log(Level.TRACE,
1471                                 "invoking a getMethod for " +  attrName);
1472                         }
1473 
1474                         Object getResponse =
1475                             invoke(attrGetMethod, new Object[] {},
1476                                    new String[] {});
1477 
1478                         if (getResponse != null) {
1479                             // error/validity check return value here
1480                             if (tracing) {
1481                                 MODELMBEAN_LOGGER.log(Level.TRACE,
1482                                         "got a non-null response " +
1483                                         "from getMethod\n");
1484                             }
1485 
1486                             response = getResponse;
1487 
1488                             // change cached value in attribute descriptor
1489                             Object objctl =
1490                                 attrDescr.getFieldValue("currencyTimeLimit");
1491 
1492                             String ctl;
1493                             if (objctl != null) ctl = objctl.toString();
1494                             else ctl = null;
1495 
1496                             if ((ctl == null) && (mmbDesc != null)) {
1497                                 objctl = mmbDesc.
1498                                     getFieldValue("currencyTimeLimit");
1499                                 if (objctl != null) ctl = objctl.toString();
1500                                 else ctl = null;
1501                             }
1502 
1503                             if ((ctl != null) && !(ctl.equals("-1"))) {
1504                                 if (tracing) {
1505                                     MODELMBEAN_LOGGER.log(Level.TRACE,
1506                                             "setting cached value and " +
1507                                             "lastUpdatedTime in descriptor");
1508                                 }
1509                                 attrDescr.setField("value", response);
1510                                 final String stamp = String.valueOf(
1511                                     (new Date()).getTime());
1512                                 attrDescr.setField("lastUpdatedTimeStamp",
1513                                                    stamp);
1514                                 attrInfo.setDescriptor(attrDescr);
1515                                 modelMBeanInfo.setDescriptor(attrDescr,
1516                                                              "attribute");
1517                                 if (tracing) {
1518                                     MODELMBEAN_LOGGER.log(Level.TRACE,
1519                                             "new descriptor is " +attrDescr);
1520                                     MODELMBEAN_LOGGER.log(Level.TRACE,
1521                                             "AttributeInfo descriptor is " +
1522                                             attrInfo.getDescriptor());
1523                                     final String attStr = modelMBeanInfo.
1524                                         getDescriptor(attrName,"attribute").
1525                                             toString();
1526                                     MODELMBEAN_LOGGER.log(Level.TRACE,
1527                                             "modelMBeanInfo: AttributeInfo " +
1528                                             "descriptor is " + attStr);
1529                                 }
1530                             }
1531                         } else {
1532                             // response was invalid or really returned null
1533                             if (tracing) {
1534                                 MODELMBEAN_LOGGER.log(Level.TRACE,
1535                                     "got a null response from getMethod\n");
1536                             }
1537                             response = null;
1538                         }
1539                     } else {
1540                         // not getMethod so return descriptor (default) value
1541                         String qualifier="";
1542                         response = attrDescr.getFieldValue("value");
1543                         if (response == null) {
1544                             qualifier="default ";
1545                             response = attrDescr.getFieldValue("default");
1546                         }
1547                         if (tracing) {
1548                             MODELMBEAN_LOGGER.log(Level.TRACE,
1549                                 "could not find getMethod for " +attrName +
1550                                 ", returning descriptor " +qualifier + "value");
1551                         }
1552                         // !! cast response to right class
1553                     }
1554                 }
1555 
1556                 // make sure response class matches type field
1557                 final String respType = attrInfo.getType();
1558                 if (response != null) {
1559                     String responseClass = response.getClass().getName();
1560                     if (!respType.equals(responseClass)) {
1561                         boolean wrongType = false;
1562                         boolean primitiveType = false;
1563                         boolean correspondingTypes = false;
1564                         for (int i = 0; i < primitiveTypes.length; i++) {
1565                             if (respType.equals(primitiveTypes[i])) {
1566                                 primitiveType = true;
1567                                 if (responseClass.equals(primitiveWrappers[i]))
1568                                     correspondingTypes = true;
1569                                 break;
1570                             }
1571                         }
1572                         if (primitiveType) {
1573                             // inequality may come from primitive/wrapper class
1574                             if (!correspondingTypes)
1575                                 wrongType = true;
1576                         } else {
1577                             // inequality may come from type subclassing
1578                             boolean subtype;
1579                             try {
1580                                 final Class<?> respClass = response.getClass();
1581                                 final Exception[] caughException = new Exception[1];
1582 
1583                                 AccessControlContext stack = AccessController.getContext();
1584 
1585                                 Class<?> c = javaSecurityAccess.doIntersectionPrivilege(new PrivilegedAction<Class<?>>() {
1586 
1587                                     @Override
1588                                     public Class<?> run() {
1589                                         try {
1590                                             ReflectUtil.checkPackageAccess(respType);
1591                                             ClassLoader cl =
1592                                                 respClass.getClassLoader();
1593                                             return Class.forName(respType, true, cl);
1594                                         } catch (Exception e) {
1595                                             caughException[0] = e;
1596                                         }
1597                                         return null;
1598                                     }
1599                                 }, stack, acc);
1600 
1601                                 if (caughException[0] != null) {
1602                                     throw caughException[0];
1603                                 }
1604 
1605                                 subtype = c.isInstance(response);
1606                             } catch (Exception e) {
1607                                 subtype = false;
1608 
1609                                 if (tracing) {
1610                                     MODELMBEAN_LOGGER.log(Level.TRACE,
1611                                             "Exception: ", e);
1612                                 }
1613                             }
1614                             if (!subtype)
1615                                 wrongType = true;
1616                         }
1617                         if (wrongType) {
1618                             if (tracing) {
1619                                 MODELMBEAN_LOGGER.log(Level.TRACE,
1620                                      "Wrong response type '" + respType + "'");
1621                             }
1622                             // throw exception, didn't get
1623                             // back right attribute type
1624                             throw new MBeanException(
1625                               new InvalidAttributeValueException(
1626                                 "Wrong value type received for get attribute"),
1627                               "An exception occurred while trying to get an " +
1628                               "attribute value through a RequiredModelMBean");
1629                         }
1630                     }
1631                 }
1632             } else {
1633                 if (tracing) {
1634                     MODELMBEAN_LOGGER.log(Level.TRACE,
1635                             "getMethod failed " + attrName +
1636                             " not in attributeDescriptor\n");
1637                 }
1638                 throw new MBeanException(new
1639                     InvalidAttributeValueException(
1640                     "Unable to resolve attribute value, " +
1641                     "no getMethod defined in descriptor for attribute"),
1642                     "An exception occurred while trying to get an "+
1643                     "attribute value through a RequiredModelMBean");
1644             }
1645 
1646         } catch (MBeanException mbe) {
1647             throw mbe;
1648         } catch (AttributeNotFoundException t) {
1649             throw t;
1650         } catch (Exception e) {
1651             if (tracing) {
1652                 MODELMBEAN_LOGGER.log(Level.TRACE,
1653                         "getMethod failed with " + e.getMessage() +
1654                         " exception type " + (e.getClass()).toString());
1655             }
1656             throw new MBeanException(e,"An exception occurred while trying "+
1657                       "to get an attribute value: " + e.getMessage());
1658         }
1659 
1660         if (tracing) {
1661             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
1662         }
1663 
1664         return response;
1665     }
1666 
1667     /**
1668      * Returns the values of several attributes in the ModelMBean.
1669      * Executes a getAttribute for each attribute name in the
1670      * attrNames array passed in.
1671      *
1672      * @param attrNames A String array of names of the attributes
1673      * to be retrieved.
1674      *
1675      * @return The array of the retrieved attributes.
1676      *
1677      * @exception RuntimeOperationsException Wraps an
1678      * {@link IllegalArgumentException}: The object name in parameter is
1679      * null or attributes in parameter is null.
1680      *
1681      * @see #setAttributes(javax.management.AttributeList)
1682      */
1683     public AttributeList getAttributes(String[] attrNames)      {
1684         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
1685             MODELMBEAN_LOGGER.log(Level.TRACE,
1686                     RequiredModelMBean.class.getName(), "Entry");
1687         }
1688 
1689         if (attrNames == null)
1690             throw new RuntimeOperationsException(new
1691                 IllegalArgumentException("attributeNames must not be null"),
1692                 "Exception occurred trying to get attributes of a "+
1693                 "RequiredModelMBean");
1694 
1695         AttributeList responseList = new AttributeList();
1696         for (int i = 0; i < attrNames.length; i++) {
1697             try {
1698                 responseList.add(new Attribute(attrNames[i],
1699                                      getAttribute(attrNames[i])));
1700             } catch (Exception e) {
1701                 // eat exceptions because interface doesn't have an
1702                 // exception on it
1703                 if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
1704                     MODELMBEAN_LOGGER.log(Level.TRACE,
1705                             "Failed to get \"" + attrNames[i] + "\": ", e);
1706                 }
1707             }
1708         }
1709 
1710         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
1711             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
1712         }
1713 
1714         return responseList;
1715     }
1716 
1717     /**
1718      * Sets the value of a specific attribute of a named ModelMBean.
1719      *
1720      * If the 'setMethod' field of the attribute's descriptor
1721      * contains the name of a valid operation descriptor, then the
1722      * method described by the operation descriptor is executed.
1723      * In this implementation, the operation descriptor must be specified
1724      * correctly and assigned to the modelMBeanInfo so that the 'setMethod'
1725      * works correctly.
1726      * The response from the method is set as the value of the attribute
1727      * in the descriptor.
1728      *
1729      * <p>If currencyTimeLimit is &gt; 0, then the new value for the
1730      * attribute is cached in the attribute descriptor's
1731      * 'value' field and the 'lastUpdatedTimeStamp' field is set to
1732      * the current time stamp.
1733      *
1734      * <p>If the persist field of the attribute's descriptor is not null
1735      * then Persistence policy from the attribute descriptor is used to
1736      * guide storing the attribute in a persistent store.
1737      * <br>Store the MBean if 'persistPolicy' field is:
1738      * <UL>
1739      * <Li> != "never"</Li>
1740      * <Li> = "always"</Li>
1741      * <Li> = "onUpdate"</Li>
1742      * <Li> {@literal = "onTimer" and now > 'lastPersistTime' + 'persistPeriod'}</Li>
1743      * <Li> {@literal = "NoMoreOftenThan" and now > 'lastPersistTime' +
1744      *         'persistPeriod'}</Li>
1745      * </UL>
1746      * Do not store the MBean if 'persistPolicy' field is:
1747      * <UL>
1748      * <Li> = "never"</Li>
1749      * <Li> = {@literal = "onTimer" && now < 'lastPersistTime' + 'persistPeriod'}</Li>
1750      * <Li> = "onUnregister"</Li>
1751      * <Li> = {@literal = "NoMoreOftenThan" and now < 'lastPersistTime' +
1752      *        'persistPeriod'}</Li>
1753      * </UL>
1754      *
1755      * <p>The ModelMBeanInfo of the Model MBean is stored in a file.
1756      *
1757      * @param attribute The Attribute instance containing the name of
1758      *        the attribute to be set and the value it is to be set to.
1759      *
1760      *
1761      * @exception AttributeNotFoundException The specified attribute is
1762      *   not accessible in the MBean.
1763      *   <br>The following cases may result in an AttributeNotFoundException:
1764      *   <UL>
1765      *     <LI> No ModelMBeanAttributeInfo is found for the specified
1766      *          attribute.</LI>
1767      *     <LI> The ModelMBeanAttributeInfo's isWritable method returns
1768      *          'false'.</LI>
1769      *   </UL>
1770      * @exception InvalidAttributeValueException No descriptor is defined
1771      *   for the specified attribute.
1772      * @exception MBeanException Wraps one of the following Exceptions:
1773      *   <UL>
1774      *     <LI> An Exception thrown by the managed object's setter.</LI>
1775      *     <LI> A {@link ServiceNotFoundException} if a setMethod field is
1776      *          defined in the descriptor for the attribute and the managed
1777      *          resource is null; or if no setMethod field is defined and
1778      *          caching is not enabled for the attribute.
1779      *          Note that if there is no getMethod field either, then caching
1780      *          is automatically enabled.</LI>
1781      *     <LI> {@link InvalidTargetObjectTypeException} The 'targetType'
1782      *          field value is not 'objectReference'.</LI>
1783      *     <LI> An Exception thrown by the managed object's getter.</LI>
1784      *   </UL>
1785      * @exception ReflectionException  Wraps an {@link java.lang.Exception}
1786      *   thrown while trying to invoke the setter.
1787      * @exception RuntimeOperationsException Wraps an
1788      *   {@link IllegalArgumentException}: The attribute in parameter is
1789      *   null.
1790      *
1791      * @see #getAttribute(java.lang.String)
1792      **/
1793     public void setAttribute(Attribute attribute)
1794         throws AttributeNotFoundException, InvalidAttributeValueException,
1795                MBeanException, ReflectionException {
1796         final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.TRACE);
1797         if (tracing) {
1798             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
1799         }
1800 
1801         if (attribute == null)
1802             throw new RuntimeOperationsException(new
1803                 IllegalArgumentException("attribute must not be null"),
1804                 "Exception occurred trying to set an attribute of a "+
1805                 "RequiredModelMBean");
1806 
1807         /* run setMethod if there is one */
1808         /* return cached value if its current */
1809         /* set cached value in descriptor and set date/time */
1810         /* send attribute change Notification */
1811         /* check persistence policy and persist if need be */
1812         String attrName = attribute.getName();
1813         Object attrValue = attribute.getValue();
1814         boolean updateDescriptor = false;
1815 
1816         ModelMBeanAttributeInfo attrInfo =
1817             modelMBeanInfo.getAttribute(attrName);
1818 
1819         if (attrInfo == null)
1820             throw new AttributeNotFoundException("setAttribute failed: " +
1821                                                attrName + " is not found ");
1822 
1823         Descriptor mmbDesc = modelMBeanInfo.getMBeanDescriptor();
1824         Descriptor attrDescr = attrInfo.getDescriptor();
1825 
1826         if (attrDescr != null) {
1827             if (!attrInfo.isWritable())
1828                 throw new AttributeNotFoundException("setAttribute failed: "
1829                                           + attrName + " is not writable ");
1830 
1831             String attrSetMethod = (String)
1832                 (attrDescr.getFieldValue("setMethod"));
1833             String attrGetMethod = (String)
1834                 (attrDescr.getFieldValue("getMethod"));
1835 
1836             String attrType = attrInfo.getType();
1837             Object currValue = "Unknown";
1838 
1839             try {
1840                 currValue = this.getAttribute(attrName);
1841             } catch (Throwable t) {
1842                 // OK: Default "Unknown" value used for unknown attribute
1843             }
1844 
1845             Attribute oldAttr = new Attribute(attrName, currValue);
1846 
1847             /* run method from operations descriptor */
1848             if (attrSetMethod == null) {
1849                 if (attrValue != null) {
1850                     try {
1851                         final Class<?> clazz = loadClass(attrType);
1852                         if (! clazz.isInstance(attrValue))  throw new
1853                             InvalidAttributeValueException(clazz.getName() +
1854                                                            " expected, "   +
1855                                             attrValue.getClass().getName() +
1856                                                            " received.");
1857                     } catch (ClassNotFoundException x) {
1858                         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
1859                             MODELMBEAN_LOGGER.log(Level.TRACE,
1860                                 "Class " + attrType + " for attribute "
1861                                 + attrName + " not found: ", x);
1862                         }
1863                     }
1864                 }
1865                 updateDescriptor = true;
1866             } else {
1867                 invoke(attrSetMethod,
1868                        (new Object[] {attrValue}),
1869                        (new String[] {attrType}) );
1870             }
1871 
1872             /* change cached value */
1873             Object objctl = attrDescr.getFieldValue("currencyTimeLimit");
1874             String ctl;
1875             if (objctl != null) ctl = objctl.toString();
1876             else ctl = null;
1877 
1878             if ((ctl == null) && (mmbDesc != null)) {
1879                 objctl = mmbDesc.getFieldValue("currencyTimeLimit");
1880                 if (objctl != null) ctl = objctl.toString();
1881                 else ctl = null;
1882             }
1883 
1884             final boolean updateCache = ((ctl != null) && !(ctl.equals("-1")));
1885 
1886              if(attrSetMethod == null  && !updateCache && attrGetMethod != null)
1887                 throw new MBeanException(new ServiceNotFoundException("No " +
1888                         "setMethod field is defined in the descriptor for " +
1889                         attrName + " attribute and caching is not enabled " +
1890                         "for it"));
1891 
1892             if (updateCache || updateDescriptor) {
1893                 if (tracing) {
1894                     MODELMBEAN_LOGGER.log(Level.TRACE,
1895                             "setting cached value of " +
1896                             attrName + " to " + attrValue);
1897                 }
1898 
1899                 attrDescr.setField("value", attrValue);
1900 
1901                 if (updateCache) {
1902                     final String currtime = String.valueOf(
1903                         (new Date()).getTime());
1904 
1905                     attrDescr.setField("lastUpdatedTimeStamp", currtime);
1906                 }
1907 
1908                 attrInfo.setDescriptor(attrDescr);
1909 
1910                 modelMBeanInfo.setDescriptor(attrDescr,"attribute");
1911                 if (tracing) {
1912                     final StringBuilder strb = new StringBuilder()
1913                     .append("new descriptor is ").append(attrDescr)
1914                     .append(". AttributeInfo descriptor is ")
1915                     .append(attrInfo.getDescriptor())
1916                     .append(". AttributeInfo descriptor is ")
1917                     .append(modelMBeanInfo.getDescriptor(attrName,"attribute"));
1918                     MODELMBEAN_LOGGER.log(Level.TRACE, strb::toString);
1919                 }
1920 
1921             }
1922 
1923             if (tracing) {
1924                 MODELMBEAN_LOGGER.log(Level.TRACE,
1925                         "sending sendAttributeNotification");
1926             }
1927             sendAttributeChangeNotification(oldAttr,attribute);
1928 
1929         } else { // if descriptor ... else no descriptor
1930 
1931             if (tracing) {
1932                     MODELMBEAN_LOGGER.log(Level.TRACE,
1933                         "setMethod failed " + attrName +
1934                         " not in attributeDescriptor\n");
1935             }
1936 
1937             throw new InvalidAttributeValueException(
1938                       "Unable to resolve attribute value, "+
1939                       "no defined in descriptor for attribute");
1940         } // else no descriptor
1941 
1942         if (tracing) {
1943             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
1944         }
1945 
1946     }
1947 
1948     /**
1949      * Sets the values of an array of attributes of this ModelMBean.
1950      * Executes the setAttribute() method for each attribute in the list.
1951      *
1952      * @param attributes A list of attributes: The identification of the
1953      * attributes to be set and  the values they are to be set to.
1954      *
1955      * @return  The array of attributes that were set, with their new
1956      *    values in Attribute instances.
1957      *
1958      * @exception RuntimeOperationsException Wraps an
1959      *   {@link IllegalArgumentException}: The object name in parameter
1960      *   is null or attributes in parameter is null.
1961      *
1962      * @see #getAttributes
1963      **/
1964     public AttributeList setAttributes(AttributeList attributes) {
1965 
1966         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
1967             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
1968         }
1969 
1970         if (attributes == null)
1971             throw new RuntimeOperationsException(new
1972                 IllegalArgumentException("attributes must not be null"),
1973                 "Exception occurred trying to set attributes of a "+
1974                 "RequiredModelMBean");
1975 
1976         final AttributeList responseList = new AttributeList();
1977 
1978         // Go through the list of attributes
1979         for (Attribute attr : attributes.asList()) {
1980             try {
1981                 setAttribute(attr);
1982                 responseList.add(attr);
1983             } catch (Exception excep) {
1984                 responseList.remove(attr);
1985             }
1986         }
1987 
1988         return responseList;
1989     }
1990 
1991 
1992 
1993     private ModelMBeanInfo createDefaultModelMBeanInfo() {
1994         return(new ModelMBeanInfoSupport((this.getClass().getName()),
1995                    "Default ModelMBean", null, null, null, null));
1996     }
1997 
1998     /*************************************/
1999     /* NotificationBroadcaster Interface */
2000     /*************************************/
2001 
2002 
2003     private synchronized void writeToLog(String logFileName,
2004                                          String logEntry) throws Exception {
2005 
2006         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2007             MODELMBEAN_LOGGER.log(Level.TRACE,
2008                 "Notification Logging to " + logFileName + ": " + logEntry);
2009         }
2010         if ((logFileName == null) || (logEntry == null)) {
2011             if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2012                 MODELMBEAN_LOGGER.log(Level.TRACE,
2013                     "Bad input parameters, will not log this entry.");
2014             }
2015             return;
2016         }
2017 
2018         FileOutputStream fos = new FileOutputStream(logFileName, true);
2019         try {
2020             PrintStream logOut = new PrintStream(fos);
2021             logOut.println(logEntry);
2022             logOut.close();
2023             if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2024                 MODELMBEAN_LOGGER.log(Level.TRACE,
2025                     "Successfully opened log " + logFileName);
2026             }
2027         } catch (Exception e) {
2028             if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2029                 MODELMBEAN_LOGGER.log(Level.TRACE,
2030                         "Exception " + e.toString() +
2031                         " trying to write to the Notification log file " +
2032                         logFileName);
2033             }
2034             throw e;
2035         } finally {
2036             fos.close();
2037         }
2038     }
2039 
2040 
2041     /**
2042      * Registers an object which implements the NotificationListener
2043      * interface as a listener.  This
2044      * object's 'handleNotification()' method will be invoked when any
2045      * notification is issued through or by the ModelMBean.  This does
2046      * not include attributeChangeNotifications.  They must be registered
2047      * for independently.
2048      *
2049      * @param listener The listener object which will handles
2050      *        notifications emitted by the registered MBean.
2051      * @param filter The filter object. If null, no filtering will be
2052      *        performed before handling notifications.
2053      * @param handback The context to be sent to the listener with
2054      *        the notification when a notification is emitted.
2055      *
2056      * @exception IllegalArgumentException The listener cannot be null.
2057      *
2058      * @see #removeNotificationListener
2059      */
2060     public void addNotificationListener(NotificationListener listener,
2061                                         NotificationFilter filter,
2062                                         Object handback)
2063         throws java.lang.IllegalArgumentException {
2064         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2065                 MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
2066         }
2067 
2068         if (listener == null)
2069             throw new IllegalArgumentException(
2070                   "notification listener must not be null");
2071 
2072         if (generalBroadcaster == null)
2073             generalBroadcaster = new NotificationBroadcasterSupport();
2074 
2075         generalBroadcaster.addNotificationListener(listener, filter,
2076                                                    handback);
2077         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2078                 MODELMBEAN_LOGGER.log(Level.TRACE,
2079                     "NotificationListener added");
2080                 MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
2081         }
2082     }
2083 
2084     /**
2085      * Removes a listener for Notifications from the RequiredModelMBean.
2086      *
2087      * @param listener The listener name which was handling notifications
2088      *    emitted by the registered MBean.
2089      *    This method will remove all information related to this listener.
2090      *
2091      * @exception ListenerNotFoundException The listener is not registered
2092      *    in the MBean or is null.
2093      *
2094      * @see #addNotificationListener
2095      **/
2096     public void removeNotificationListener(NotificationListener listener)
2097         throws ListenerNotFoundException {
2098         if (listener == null)
2099             throw new ListenerNotFoundException(
2100                       "Notification listener is null");
2101 
2102         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2103                 MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
2104         }
2105 
2106         if (generalBroadcaster == null)
2107             throw new ListenerNotFoundException(
2108                   "No notification listeners registered");
2109 
2110 
2111         generalBroadcaster.removeNotificationListener(listener);
2112         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2113             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
2114         }
2115 
2116     }
2117 
2118     public void removeNotificationListener(NotificationListener listener,
2119                                            NotificationFilter filter,
2120                                            Object handback)
2121         throws ListenerNotFoundException {
2122 
2123         if (listener == null)
2124             throw new ListenerNotFoundException(
2125                       "Notification listener is null");
2126 
2127         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2128             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
2129         }
2130 
2131         if (generalBroadcaster == null)
2132             throw new ListenerNotFoundException(
2133                   "No notification listeners registered");
2134 
2135 
2136         generalBroadcaster.removeNotificationListener(listener,filter,
2137                                                       handback);
2138 
2139         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2140             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
2141         }
2142 
2143     }
2144 
2145     public void sendNotification(Notification ntfyObj)
2146         throws MBeanException, RuntimeOperationsException {
2147         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2148             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
2149         }
2150 
2151         if (ntfyObj == null)
2152             throw new RuntimeOperationsException(new
2153                 IllegalArgumentException("notification object must not be "+
2154                                          "null"),
2155                 "Exception occurred trying to send a notification from a "+
2156                 "RequiredModelMBean");
2157 
2158 
2159         // log notification if specified in descriptor
2160         Descriptor ntfyDesc =
2161             modelMBeanInfo.getDescriptor(ntfyObj.getType(),"notification");
2162         Descriptor mmbDesc = modelMBeanInfo.getMBeanDescriptor();
2163 
2164         if (ntfyDesc != null) {
2165             String logging = (String) ntfyDesc.getFieldValue("log");
2166 
2167             if (logging == null) {
2168                 if (mmbDesc != null)
2169                     logging = (String) mmbDesc.getFieldValue("log");
2170             }
2171 
2172             if ((logging != null) &&
2173                 (logging.equalsIgnoreCase("t") ||
2174                  logging.equalsIgnoreCase("true"))) {
2175 
2176                 String logfile = (String) ntfyDesc.getFieldValue("logfile");
2177                 if (logfile == null) {
2178                     if (mmbDesc != null)
2179                         logfile = (String)mmbDesc.getFieldValue("logfile");
2180                 }
2181                 if (logfile != null) {
2182                     try {
2183                         writeToLog(logfile,"LogMsg: " +
2184                             ((new Date(ntfyObj.getTimeStamp())).toString())+
2185                             " " + ntfyObj.getType() + " " +
2186                             ntfyObj.getMessage() + " Severity = " +
2187                             (String)ntfyDesc.getFieldValue("severity"));
2188                     } catch (Exception e) {
2189                         if (MODELMBEAN_LOGGER.isLoggable(Level.DEBUG)) {
2190                             MODELMBEAN_LOGGER.log(Level.DEBUG,
2191                                     "Failed to log " +
2192                                     ntfyObj.getType() + " notification: ", e);
2193                         }
2194                     }
2195                 }
2196             }
2197         }
2198         if (generalBroadcaster != null) {
2199             generalBroadcaster.sendNotification(ntfyObj);
2200         }
2201 
2202         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2203             MODELMBEAN_LOGGER.log(Level.TRACE,
2204                     "sendNotification sent provided notification object");
2205             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
2206         }
2207 
2208     }
2209 
2210 
2211     public void sendNotification(String ntfyText)
2212         throws MBeanException, RuntimeOperationsException {
2213         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2214             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
2215         }
2216 
2217         if (ntfyText == null)
2218             throw new RuntimeOperationsException(new
2219                 IllegalArgumentException("notification message must not "+
2220                                          "be null"),
2221                 "Exception occurred trying to send a text notification "+
2222                 "from a ModelMBean");
2223 
2224         Notification myNtfyObj = new Notification("jmx.modelmbean.generic",
2225                                                   this, 1, ntfyText);
2226         sendNotification(myNtfyObj);
2227         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2228             MODELMBEAN_LOGGER.log(Level.TRACE, "Notification sent");
2229             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
2230         }
2231     }
2232 
2233     /**
2234      * Returns `true' if the notification `notifName' is found
2235      * in `info'. (bug 4744667)
2236      **/
2237     private static final
2238         boolean hasNotification(final ModelMBeanInfo info,
2239                                 final String notifName) {
2240         try {
2241             if (info == null) return false;
2242             else return (info.getNotification(notifName)!=null);
2243         } catch (MBeanException x) {
2244             return false;
2245         } catch (RuntimeOperationsException r) {
2246             return false;
2247         }
2248     }
2249 
2250     /**
2251      * Creates a default ModelMBeanNotificationInfo for GENERIC
2252      * notification.  (bug 4744667)
2253      **/
2254     private static final ModelMBeanNotificationInfo makeGenericInfo() {
2255         final Descriptor genericDescriptor = new DescriptorSupport( new
2256             String[] {
2257                 "name=GENERIC",
2258                 "descriptorType=notification",
2259                 "log=T",
2260                 "severity=6",
2261                 "displayName=jmx.modelmbean.generic"} );
2262 
2263         return new ModelMBeanNotificationInfo(new
2264             String[] {"jmx.modelmbean.generic"},
2265             "GENERIC",
2266             "A text notification has been issued by the managed resource",
2267             genericDescriptor);
2268     }
2269 
2270     /**
2271      * Creates a default ModelMBeanNotificationInfo for ATTRIBUTE_CHANGE
2272      * notification.  (bug 4744667)
2273      **/
2274     private static final
2275         ModelMBeanNotificationInfo makeAttributeChangeInfo() {
2276         final Descriptor attributeDescriptor = new DescriptorSupport(new
2277             String[] {
2278                 "name=ATTRIBUTE_CHANGE",
2279                 "descriptorType=notification",
2280                 "log=T",
2281                 "severity=6",
2282                 "displayName=jmx.attribute.change"});
2283 
2284         return new ModelMBeanNotificationInfo(new
2285             String[] {"jmx.attribute.change"},
2286             "ATTRIBUTE_CHANGE",
2287             "Signifies that an observed MBean attribute value has changed",
2288             attributeDescriptor );
2289     }
2290 
2291     /**
2292      * Returns the array of Notifications always generated by the
2293      * RequiredModelMBean.
2294      * <P>
2295      *
2296      * RequiredModelMBean may always send also two additional notifications:
2297      * <UL>
2298      *   <LI> One with descriptor <code>"name=GENERIC,descriptorType=notification,log=T,severity=6,displayName=jmx.modelmbean.generic"</code></LI>
2299      *   <LI> Second is a standard attribute change notification
2300      *        with descriptor <code>"name=ATTRIBUTE_CHANGE,descriptorType=notification,log=T,severity=6,displayName=jmx.attribute.change"</code></LI>
2301      * </UL>
2302      * Thus these two notifications are always added to those specified
2303      * by the application.
2304      *
2305      * @return MBeanNotificationInfo[]
2306      *
2307      **/
2308     public MBeanNotificationInfo[] getNotificationInfo() {
2309         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2310             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
2311         }
2312 
2313         // Using hasNotification() is not optimal, but shouldn't really
2314         // matter in this context...
2315 
2316         // hasGeneric==true if GENERIC notification is present.
2317         // (bug 4744667)
2318         final boolean hasGeneric = hasNotification(modelMBeanInfo,"GENERIC");
2319 
2320         // hasAttributeChange==true if ATTRIBUTE_CHANGE notification is
2321         // present.
2322         // (bug 4744667)
2323         final boolean hasAttributeChange =
2324            hasNotification(modelMBeanInfo,"ATTRIBUTE_CHANGE");
2325 
2326         // User supplied list of notification infos.
2327         //
2328         final ModelMBeanNotificationInfo[] currInfo =
2329            (ModelMBeanNotificationInfo[])modelMBeanInfo.getNotifications();
2330 
2331         // Length of the returned list of notification infos:
2332         //    length of user suplied list + possibly 1 for GENERIC, +
2333         //    possibly 1 for ATTRIBUTE_CHANGE
2334         //    (bug 4744667)
2335         final int len = ((currInfo==null?0:currInfo.length) +
2336                          (hasGeneric?0:1) + (hasAttributeChange?0:1));
2337 
2338         // Returned list of notification infos:
2339         //
2340         final ModelMBeanNotificationInfo[] respInfo =
2341            new ModelMBeanNotificationInfo[len];
2342 
2343         // Preserve previous ordering (JMX 1.1)
2344         //
2345 
2346         // Counter of "standard" notification inserted before user
2347         // supplied notifications.
2348         //
2349         int inserted=0;
2350         if (!hasGeneric)
2351             // We need to add description for GENERIC notification
2352             // (bug 4744667)
2353             respInfo[inserted++] = makeGenericInfo();
2354 
2355 
2356         if (!hasAttributeChange)
2357             // We need to add description for ATTRIBUTE_CHANGE notification
2358             // (bug 4744667)
2359             respInfo[inserted++] = makeAttributeChangeInfo();
2360 
2361         // Now copy user supplied list in returned list.
2362         //
2363         final int count  = currInfo.length;
2364         final int offset = inserted;
2365         for (int j=0; j < count; j++) {
2366             respInfo[offset+j] = currInfo[j];
2367         }
2368 
2369         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2370             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
2371         }
2372 
2373         return respInfo;
2374     }
2375 
2376 
2377     public void addAttributeChangeNotificationListener(NotificationListener
2378                                                        inlistener,
2379                                                        String
2380                                                        inAttributeName,
2381                                                        Object inhandback)
2382         throws MBeanException, RuntimeOperationsException,
2383                IllegalArgumentException {
2384         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2385             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
2386         }
2387 
2388         if (inlistener == null)
2389             throw new IllegalArgumentException(
2390                   "Listener to be registered must not be null");
2391 
2392 
2393         if (attributeBroadcaster == null)
2394             attributeBroadcaster = new NotificationBroadcasterSupport();
2395 
2396         AttributeChangeNotificationFilter currFilter =
2397             new AttributeChangeNotificationFilter();
2398 
2399         MBeanAttributeInfo[] attrInfo = modelMBeanInfo.getAttributes();
2400         boolean found = false;
2401         if (inAttributeName == null) {
2402             if ((attrInfo != null) && (attrInfo.length>0)) {
2403                 for (int i=0; i<attrInfo.length; i++) {
2404                     currFilter.enableAttribute(attrInfo[i].getName());
2405                 }
2406             }
2407         } else {
2408             if ((attrInfo != null) && (attrInfo.length>0)) {
2409                 for (int i=0; i<attrInfo.length; i++) {
2410                     if (inAttributeName.equals(attrInfo[i].getName())) {
2411                         found = true;
2412                         currFilter.enableAttribute(inAttributeName);
2413                         break;
2414                     }
2415                 }
2416             }
2417             if (!found) {
2418                 throw new RuntimeOperationsException(new
2419                     IllegalArgumentException(
2420                     "The attribute name does not exist"),
2421                     "Exception occurred trying to add an "+
2422                     "AttributeChangeNotification listener");
2423             }
2424         }
2425 
2426         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2427             Vector<String> enabledAttrs = currFilter.getEnabledAttributes();
2428             String s = (enabledAttrs.size() > 1) ?
2429                         "[" + enabledAttrs.firstElement() + ", ...]" :
2430                         enabledAttrs.toString();
2431             MODELMBEAN_LOGGER.log(Level.TRACE,
2432                 "Set attribute change filter to " + s);
2433         }
2434 
2435         attributeBroadcaster.addNotificationListener(inlistener,currFilter,
2436                                                      inhandback);
2437         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2438             MODELMBEAN_LOGGER.log(Level.TRACE,
2439                     "Notification listener added for " + inAttributeName);
2440             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
2441         }
2442     }
2443 
2444     public void removeAttributeChangeNotificationListener(
2445             NotificationListener inlistener, String inAttributeName)
2446         throws MBeanException, RuntimeOperationsException,
2447                ListenerNotFoundException {
2448         if (inlistener == null) throw new
2449             ListenerNotFoundException("Notification listener is null");
2450 
2451         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2452             MODELMBEAN_LOGGER.log(Level.TRACE,
2453                     RequiredModelMBean.class.getName(), "Entry");
2454         }
2455 
2456 
2457         if (attributeBroadcaster == null)
2458             throw new ListenerNotFoundException(
2459                   "No attribute change notification listeners registered");
2460 
2461 
2462         MBeanAttributeInfo[] attrInfo = modelMBeanInfo.getAttributes();
2463         boolean found = false;
2464         if ((attrInfo != null) && (attrInfo.length>0)) {
2465             for (int i=0; i<attrInfo.length; i++) {
2466                 if (attrInfo[i].getName().equals(inAttributeName)) {
2467                     found = true;
2468                     break;
2469                 }
2470             }
2471         }
2472 
2473         if ((!found) && (inAttributeName != null)) {
2474             throw new RuntimeOperationsException(new
2475                 IllegalArgumentException("Invalid attribute name"),
2476                 "Exception occurred trying to remove "+
2477                 "attribute change notification listener");
2478         }
2479 
2480         /* note: */
2481         /* this may be a problem if the same listener is registered for
2482            multiple attributes with multiple filters and/or handback
2483            objects.  It may remove all of them */
2484 
2485         attributeBroadcaster.removeNotificationListener(inlistener);
2486 
2487         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2488             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
2489         }
2490     }
2491 
2492     public void sendAttributeChangeNotification(AttributeChangeNotification
2493                                                 ntfyObj)
2494         throws MBeanException, RuntimeOperationsException {
2495 
2496         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2497             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
2498         }
2499 
2500         if (ntfyObj == null)
2501             throw new RuntimeOperationsException(new
2502                 IllegalArgumentException(
2503                 "attribute change notification object must not be null"),
2504                 "Exception occurred trying to send "+
2505                 "attribute change notification of a ModelMBean");
2506 
2507         Object oldv = ntfyObj.getOldValue();
2508         Object newv =  ntfyObj.getNewValue();
2509 
2510         if (oldv == null) oldv = "null";
2511         if (newv == null) newv = "null";
2512 
2513         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2514             MODELMBEAN_LOGGER.log(Level.TRACE,
2515                 "Sending AttributeChangeNotification with " +
2516                 ntfyObj.getAttributeName() + ntfyObj.getAttributeType() +
2517                 ntfyObj.getNewValue() + ntfyObj.getOldValue());
2518         }
2519 
2520         // log notification if specified in descriptor
2521         Descriptor ntfyDesc =
2522             modelMBeanInfo.getDescriptor(ntfyObj.getType(),"notification");
2523         Descriptor mmbDesc = modelMBeanInfo.getMBeanDescriptor();
2524 
2525         String logging, logfile;
2526 
2527         if (ntfyDesc != null) {
2528             logging =(String)  ntfyDesc.getFieldValue("log");
2529             if (logging == null) {
2530                 if (mmbDesc != null)
2531                     logging = (String) mmbDesc.getFieldValue("log");
2532             }
2533             if ((logging != null) &&
2534                 ( logging.equalsIgnoreCase("t") ||
2535                   logging.equalsIgnoreCase("true"))) {
2536                 logfile = (String) ntfyDesc.getFieldValue("logfile");
2537                 if (logfile == null) {
2538                     if (mmbDesc != null)
2539                         logfile = (String)mmbDesc.getFieldValue("logfile");
2540                 }
2541 
2542                 if (logfile != null) {
2543                     try {
2544                         writeToLog(logfile,"LogMsg: " +
2545                            ((new Date(ntfyObj.getTimeStamp())).toString())+
2546                            " " + ntfyObj.getType() + " " +
2547                            ntfyObj.getMessage() +
2548                            " Name = " + ntfyObj.getAttributeName() +
2549                            " Old value = " + oldv +
2550                            " New value = " + newv);
2551                     } catch (Exception e) {
2552                         if (MODELMBEAN_LOGGER.isLoggable(Level.DEBUG)) {
2553                             MODELMBEAN_LOGGER.log(Level.DEBUG,
2554                                 "Failed to log " + ntfyObj.getType() +
2555                                     " notification: ", e);
2556                         }
2557                     }
2558                 }
2559             }
2560         } else if (mmbDesc != null) {
2561             logging = (String) mmbDesc.getFieldValue("log");
2562             if ((logging != null) &&
2563                 ( logging.equalsIgnoreCase("t") ||
2564                   logging.equalsIgnoreCase("true") )) {
2565                 logfile = (String) mmbDesc.getFieldValue("logfile");
2566 
2567                 if (logfile != null) {
2568                     try {
2569                         writeToLog(logfile,"LogMsg: " +
2570                            ((new Date(ntfyObj.getTimeStamp())).toString())+
2571                            " " + ntfyObj.getType() + " " +
2572                            ntfyObj.getMessage() +
2573                            " Name = " + ntfyObj.getAttributeName() +
2574                            " Old value = " + oldv +
2575                            " New value = " + newv);
2576                     } catch (Exception e) {
2577                         if (MODELMBEAN_LOGGER.isLoggable(Level.DEBUG)) {
2578                             MODELMBEAN_LOGGER.log(Level.DEBUG,
2579                                 "Failed to log " + ntfyObj.getType() +
2580                                     " notification: ", e);
2581                         }
2582                     }
2583                 }
2584             }
2585         }
2586         if (attributeBroadcaster != null) {
2587             attributeBroadcaster.sendNotification(ntfyObj);
2588         }
2589 
2590         // XXX Revisit: This is a quickfix: it would be better to have a
2591         //     single broadcaster. However, it is not so simple because
2592         //     removeAttributeChangeNotificationListener() should
2593         //     remove only listeners whose filter is an instanceof
2594         //     AttributeChangeNotificationFilter.
2595         //
2596         if (generalBroadcaster != null) {
2597             generalBroadcaster.sendNotification(ntfyObj);
2598         }
2599 
2600         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2601             MODELMBEAN_LOGGER.log(Level.TRACE, "sent notification");
2602             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
2603         }
2604     }
2605 
2606     public void sendAttributeChangeNotification(Attribute inOldVal,
2607                                                 Attribute inNewVal)
2608         throws MBeanException, RuntimeOperationsException {
2609         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2610             MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
2611         }
2612 
2613         // do we really want to do this?
2614         if ((inOldVal == null) || (inNewVal == null))
2615             throw new RuntimeOperationsException(new
2616                IllegalArgumentException("Attribute object must not be null"),
2617                "Exception occurred trying to send " +
2618                "attribute change notification of a ModelMBean");
2619 
2620 
2621         if (!(inOldVal.getName().equals(inNewVal.getName())))
2622             throw new RuntimeOperationsException(new
2623                 IllegalArgumentException("Attribute names are not the same"),
2624                 "Exception occurred trying to send " +
2625                 "attribute change notification of a ModelMBean");
2626 
2627 
2628         Object newVal = inNewVal.getValue();
2629         Object oldVal = inOldVal.getValue();
2630         String className = "unknown";
2631         if (newVal != null)
2632             className = newVal.getClass().getName();
2633         if (oldVal != null)
2634             className = oldVal.getClass().getName();
2635 
2636         AttributeChangeNotification myNtfyObj = new
2637             AttributeChangeNotification(this,
2638                                         1,
2639                                         ((new Date()).getTime()),
2640                                         "AttributeChangeDetected",
2641                                         inOldVal.getName(),
2642                                         className,
2643                                         inOldVal.getValue(),
2644                                         inNewVal.getValue());
2645 
2646         sendAttributeChangeNotification(myNtfyObj);
2647 
2648         if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
2649             MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
2650         }
2651 
2652     }
2653 
2654     /**
2655      * Return the Class Loader Repository used to perform class loading.
2656      * Subclasses may wish to redefine this method in order to return
2657      * the appropriate {@link javax.management.loading.ClassLoaderRepository}
2658      * that should be used in this object.
2659      *
2660      * @return the Class Loader Repository.
2661      *
2662      */
2663     protected ClassLoaderRepository getClassLoaderRepository() {
2664         return MBeanServerFactory.getClassLoaderRepository(server);
2665     }
2666 
2667     private Class<?> loadClass(final String className)
2668         throws ClassNotFoundException {
2669         AccessControlContext stack = AccessController.getContext();
2670         final ClassNotFoundException[] caughtException = new ClassNotFoundException[1];
2671 
2672         Class<?> c = javaSecurityAccess.doIntersectionPrivilege(new PrivilegedAction<Class<?>>() {
2673 
2674             @Override
2675             public Class<?> run() {
2676                 try {
2677                     ReflectUtil.checkPackageAccess(className);
2678                     return Class.forName(className);
2679                 } catch (ClassNotFoundException e) {
2680                     final ClassLoaderRepository clr =
2681                         getClassLoaderRepository();
2682                     try {
2683                         if (clr == null) throw new ClassNotFoundException(className);
2684                         return clr.loadClass(className);
2685                     } catch (ClassNotFoundException ex) {
2686                         caughtException[0] = ex;
2687                     }
2688                 }
2689                 return null;
2690             }
2691         }, stack, acc);
2692 
2693         if (caughtException[0] != null) {
2694             throw caughtException[0];
2695         }
2696 
2697         return c;
2698     }
2699 
2700 
2701     /*************************************/
2702     /* MBeanRegistration Interface       */
2703     /*************************************/
2704 
2705     /**
2706      * Allows the MBean to perform any operations it needs before
2707      * being registered in the MBean server.  If the name of the MBean
2708      * is not specified, the MBean can provide a name for its
2709      * registration.  If any exception is raised, the MBean will not be
2710      * registered in the MBean server.
2711      * <P>
2712      * In order to ensure proper run-time semantics of RequireModelMBean,
2713      * Any subclass of RequiredModelMBean overloading or overriding this
2714      * method should call <code>super.preRegister(server, name)</code>
2715      * in its own <code>preRegister</code> implementation.
2716      *
2717      * @param server The MBean server in which the MBean will be registered.
2718      *
2719      * @param name The object name of the MBean.  This name is null if
2720      * the name parameter to one of the <code>createMBean</code> or
2721      * <code>registerMBean</code> methods in the {@link MBeanServer}
2722      * interface is null.  In that case, this method must return a
2723      * non-null ObjectName for the new MBean.
2724      *
2725      * @return The name under which the MBean is to be registered.
2726      * This value must not be null.  If the <code>name</code>
2727      * parameter is not null, it will usually but not necessarily be
2728      * the returned value.
2729      *
2730      * @exception java.lang.Exception This exception will be caught by
2731      * the MBean server and re-thrown as an
2732      * {@link javax.management.MBeanRegistrationException
2733      * MBeanRegistrationException}.
2734      */
2735     public ObjectName preRegister(MBeanServer server,
2736                                   ObjectName name)
2737         throws java.lang.Exception  {
2738         // Since ModelMbeanInfo cannot be null (otherwise exception
2739         // thrown at creation)
2740         // no exception thrown on ModelMBeanInfo not set.
2741         if (name == null) throw new NullPointerException(
2742                      "name of RequiredModelMBean to registered is null");
2743         this.server = server;
2744         return name;
2745     }
2746 
2747     /**
2748      * Allows the MBean to perform any operations needed after having been
2749      * registered in the MBean server or after the registration has failed.
2750      * <P>
2751      * In order to ensure proper run-time semantics of RequireModelMBean,
2752      * Any subclass of RequiredModelMBean overloading or overriding this
2753      * method should call <code>super.postRegister(registrationDone)</code>
2754      * in its own <code>postRegister</code> implementation.
2755      *
2756      * @param registrationDone Indicates whether or not the MBean has
2757      * been successfully registered in the MBean server. The value
2758      * false means that the registration phase has failed.
2759      */
2760     public void postRegister(Boolean registrationDone) {
2761         registered = registrationDone.booleanValue();
2762     }
2763 
2764     /**
2765      * Allows the MBean to perform any operations it needs before
2766      * being unregistered by the MBean server.
2767      * <P>
2768      * In order to ensure proper run-time semantics of RequireModelMBean,
2769      * Any subclass of RequiredModelMBean overloading or overriding this
2770      * method should call <code>super.preDeregister()</code> in its own
2771      * <code>preDeregister</code> implementation.
2772      *
2773      * @exception java.lang.Exception This exception will be caught by
2774      * the MBean server and re-thrown as an
2775      * {@link javax.management.MBeanRegistrationException
2776      * MBeanRegistrationException}.
2777      */
2778     public void preDeregister() throws java.lang.Exception {
2779     }
2780 
2781     /**
2782      * Allows the MBean to perform any operations needed after having been
2783      * unregistered in the MBean server.
2784      * <P>
2785      * In order to ensure proper run-time semantics of RequireModelMBean,
2786      * Any subclass of RequiredModelMBean overloading or overriding this
2787      * method should call <code>super.postDeregister()</code> in its own
2788      * <code>postDeregister</code> implementation.
2789      */
2790     public void postDeregister() {
2791         registered = false;
2792         this.server=null;
2793     }
2794 
2795     private static final String[] primitiveTypes;
2796     private static final String[] primitiveWrappers;
2797     static {
2798         primitiveTypes = new String[] {
2799             Boolean.TYPE.getName(),
2800             Byte.TYPE.getName(),
2801             Character.TYPE.getName(),
2802             Short.TYPE.getName(),
2803             Integer.TYPE.getName(),
2804             Long.TYPE.getName(),
2805             Float.TYPE.getName(),
2806             Double.TYPE.getName(),
2807             Void.TYPE.getName()
2808         };
2809         primitiveWrappers = new String[] {
2810             Boolean.class.getName(),
2811             Byte.class.getName(),
2812             Character.class.getName(),
2813             Short.class.getName(),
2814             Integer.class.getName(),
2815             Long.class.getName(),
2816             Float.class.getName(),
2817             Double.class.getName(),
2818             Void.class.getName()
2819         };
2820     }
2821 }