Java 类javax.management.Descriptor 实例源码

protected void initDescriptorSectionFromModel() {

        Descriptor descriptor = getJmxDescriptor();
        if (descriptor == null) {
            return;
        }

        Table table = getDescriptorTable();
        if (table == null) {
            return;
        }

        table.removeAll();

        for (String fieldName : descriptor.getFieldNames()) {
            TableItem item = new TableItem(table, SWT.NONE);
            Object value = descriptor.getFieldValue(fieldName);
            item.setText(0, fieldName);
            item.setText(1, String.valueOf(value));
        }

        packTable(table, DEFAULT_NAME_VALUE_COLUMN_WIDTHS);
    }

private void populateMetricDescriptor(Descriptor desc, ManagedMetric metric) {
    applyCurrencyTimeLimit(desc, metric.getCurrencyTimeLimit());

    if (StringUtils.hasLength(metric.getPersistPolicy())) {
        desc.setField(FIELD_PERSIST_POLICY, metric.getPersistPolicy());
    }
    if (metric.getPersistPeriod() >= 0) {
        desc.setField(FIELD_PERSIST_PERIOD, Integer.toString(metric.getPersistPeriod()));
    }

    if (StringUtils.hasLength(metric.getDisplayName())) {
        desc.setField(FIELD_DISPLAY_NAME, metric.getDisplayName());
    }

    if(StringUtils.hasLength(metric.getUnit())) {
        desc.setField(FIELD_UNITS, metric.getUnit());
    }

    if(StringUtils.hasLength(metric.getCategory())) {
        desc.setField(FIELD_METRIC_CATEGORY, metric.getCategory());
    }

    String metricType = (metric.getMetricType() == null) ? MetricType.GAUGE.toString() : metric.getMetricType().toString();
    desc.setField(FIELD_METRIC_TYPE, metricType);
}

/**
 * Creates a default ModelMBeanNotificationInfo for GENERIC
 * notification.  (bug 4744667)
 **/
private static final ModelMBeanNotificationInfo makeGenericInfo() {
    final Descriptor genericDescriptor = new DescriptorSupport( new
        String[] {
            "name=GENERIC",
            "descriptorType=notification",
            "log=T",
            "severity=6",
            "displayName=jmx.modelmbean.generic"} );

    return new ModelMBeanNotificationInfo(new
        String[] {"jmx.modelmbean.generic"},
        "GENERIC",
        "A text notification has been issued by the managed resource",
        genericDescriptor);
}

static <T> Descriptor makeDescriptor(OpenType<T> openType,
                                     T defaultValue,
                                     T[] legalValues,
                                     Comparable<T> minValue,
                                     Comparable<T> maxValue) {
    Map<String, Object> map = new HashMap<String, Object>();
    if (defaultValue != null)
        map.put("defaultValue", defaultValue);
    if (legalValues != null) {
        Set<T> set = new HashSet<T>();
        for (T v : legalValues)
            set.add(v);
        set = Collections.unmodifiableSet(set);
        map.put("legalValues", set);
    }
    if (minValue != null)
        map.put("minValue", minValue);
    if (maxValue != null)
        map.put("maxValue", maxValue);
    if (map.isEmpty()) {
        return openType.getDescriptor();
    } else {
        map.put("openType", openType);
        return new ImmutableDescriptor(map);
    }
}

/**
 * Returns a copy of the associated Descriptor for the
 * ModelMBeanNotificationInfo.
 *
 * @return Descriptor associated with the
 * ModelMBeanNotificationInfo object.
 *
 * @see #setDescriptor
 **/
public Descriptor getDescriptor() {
    if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
        MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
    }

    if (notificationDescriptor == null) {
        // Dead code. Should never happen.
        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
            MODELMBEAN_LOGGER.log(Level.TRACE,
                    "Descriptor value is null, " +
                    "setting descriptor to default values");
        }
        notificationDescriptor = validDescriptor(null);
    }

    return((Descriptor)notificationDescriptor.clone());
}

/**
 * Returns a copy of the associated Descriptor.
 *
 * @return Descriptor associated with the
 * ModelMBeanConstructorInfo object.
 *
 * @see #setDescriptor
 */


@Override
public Descriptor getDescriptor()
{
    if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
        MODELMBEAN_LOGGER.logp(Level.FINER,
                ModelMBeanConstructorInfo.class.getName(),
                "getDescriptor()", "Entry");
    }
    if (consDescriptor == null){
        consDescriptor = validDescriptor(null);
    }
    return((Descriptor)consDescriptor.clone());
}

private <T> OpenMBeanParameterInfoSupport(String name,
                                          String description,
                                          OpenType<T> openType,
                                          T defaultValue,
                                          T[] legalValues,
                                          Comparable<T> minValue,
                                          Comparable<T> maxValue)
        throws OpenDataException {
    super(name,
          (openType == null) ? null : openType.getClassName(),
          description,
          makeDescriptor(openType,
                         defaultValue, legalValues, minValue, maxValue));

    this.openType = openType;

    Descriptor d = getDescriptor();
    this.defaultValue = defaultValue;
    this.minValue = minValue;
    this.maxValue = maxValue;
    // We already converted the array into an unmodifiable Set
    // in the descriptor.
    this.legalValues = (Set<?>) d.getFieldValue("legalValues");

    check(this);
}

private Descriptor getMBeanDescriptorNoException() {
    if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
        MODELMBEAN_LOGGER.logp(Level.FINER,
                ModelMBeanInfoSupport.class.getName(),
                "getMBeanDescriptorNoException()", "Entry");
    }

    if (modelMBeanDescriptor == null)
        modelMBeanDescriptor = validDescriptor(null);

    if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
        MODELMBEAN_LOGGER.logp(Level.FINER,
                ModelMBeanInfoSupport.class.getName(),
                "getMBeanDescriptorNoException()",
                "Exit, returning: " + modelMBeanDescriptor);
    }
    return (Descriptor) modelMBeanDescriptor.clone();
}

/**
 * Creates a default ModelMBeanNotificationInfo for GENERIC
 * notification.  (bug 4744667)
 **/
private static final ModelMBeanNotificationInfo makeGenericInfo() {
    final Descriptor genericDescriptor = new DescriptorSupport( new
        String[] {
            "name=GENERIC",
            "descriptorType=notification",
            "log=T",
            "severity=6",
            "displayName=jmx.modelmbean.generic"} );

    return new ModelMBeanNotificationInfo(new
        String[] {"jmx.modelmbean.generic"},
        "GENERIC",
        "A text notification has been issued by the managed resource",
        genericDescriptor);
}

/**
 * Creates a default ModelMBeanNotificationInfo for ATTRIBUTE_CHANGE
 * notification.  (bug 4744667)
 **/
private static final
    ModelMBeanNotificationInfo makeAttributeChangeInfo() {
    final Descriptor attributeDescriptor = new DescriptorSupport(new
        String[] {
            "name=ATTRIBUTE_CHANGE",
            "descriptorType=notification",
            "log=T",
            "severity=6",
            "displayName=jmx.attribute.change"});

    return new ModelMBeanNotificationInfo(new
        String[] {"jmx.attribute.change"},
        "ATTRIBUTE_CHANGE",
        "Signifies that an observed MBean attribute value has changed",
        attributeDescriptor );
}

private <T> OpenMBeanParameterInfoSupport(String name,
                                          String description,
                                          OpenType<T> openType,
                                          T defaultValue,
                                          T[] legalValues,
                                          Comparable<T> minValue,
                                          Comparable<T> maxValue)
        throws OpenDataException {
    super(name,
          (openType == null) ? null : openType.getClassName(),
          description,
          makeDescriptor(openType,
                         defaultValue, legalValues, minValue, maxValue));

    this.openType = openType;

    Descriptor d = getDescriptor();
    this.defaultValue = defaultValue;
    this.minValue = minValue;
    this.maxValue = maxValue;
    // We already converted the array into an unmodifiable Set
    // in the descriptor.
    this.legalValues = (Set<?>) d.getFieldValue("legalValues");

    check(this);
}

private static void check(Object x, Descriptor d, Descriptor expect) {
    String fail = null;
    try {
        Descriptor u = ImmutableDescriptor.union(d, expect);
        if (!u.equals(d))
            fail = "should contain " + expect + "; is " + d;
    } catch (IllegalArgumentException e) {
        fail = e.getMessage();
    }
    if (fail == null) {
        System.out.println("OK: " + x);
    } else {
        failed = "NOT OK: Incorrect descriptor for: " + x;
        System.out.println(failed);
        System.out.println("..." + fail);
    }
}

private Descriptor getMBeanDescriptorNoException() {
    if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
        MODELMBEAN_LOGGER.logp(Level.FINER,
                ModelMBeanInfoSupport.class.getName(),
                "getMBeanDescriptorNoException()", "Entry");
    }

    if (modelMBeanDescriptor == null)
        modelMBeanDescriptor = validDescriptor(null);

    if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
        MODELMBEAN_LOGGER.logp(Level.FINER,
                ModelMBeanInfoSupport.class.getName(),
                "getMBeanDescriptorNoException()",
                "Exit, returning: " + modelMBeanDescriptor);
    }
    return (Descriptor) modelMBeanDescriptor.clone();
}

private void removeAttributeChangeNotificationListener(NotificationListener listener,
    String attributeName, Object handback)
    throws MBeanException, RuntimeOperationsException, ListenerNotFoundException {
  if (listener == null)
    throw new RuntimeOperationsException(new IllegalArgumentException(
        LocalizedStrings.MX4JModelMBean_LISTENER_CANNOT_BE_NULL.toLocalizedString()));
  AttributeChangeNotificationFilter filter = new AttributeChangeNotificationFilter();
  if (attributeName != null) {
    filter.enableAttribute(attributeName);
  } else {
    MBeanAttributeInfo[] ai = m_modelMBeanInfo.getAttributes();
    for (int i = 0; i < ai.length; i++) {
      Descriptor d = ((ModelMBeanAttributeInfo) ai[i]).getDescriptor();
      filter.enableAttribute((String) d.getFieldValue("name"));
    }
  }

  getAttributeChangeBroadcaster().removeNotificationListener(listener, filter, handback);

  Logger logger = getLogger();
  if (logger.isEnabledFor(Logger.DEBUG))
    logger.debug("Listener " + listener + " for attribute " + attributeName
        + " removed successfully, handback is " + handback);
}

private boolean shouldPersistNow(Descriptor attribute, Descriptor mbean, String lastUpdateField) {
  int persist = getPersistPolicy(attribute, mbean);
  if (persist == PERSIST_NO_MORE_OFTEN_THAN) {
    Long period = getFieldTimeValue(attribute, mbean, "persistPeriod");
    long now = System.currentTimeMillis();
    Long lastUpdate = (Long) attribute.getFieldValue(lastUpdateField);
    if (now - lastUpdate.longValue() < period.longValue())
      return false;
    else
      return true;
  } else if (persist == PERSIST_NEVER) {
    return false;
  } else if (persist == PERSIST_ON_TIMER) {
    return false;
  } else if (persist == PERSIST_ON_UPDATE) {
    return true;
  } else {
    throw new ImplementationException(
        LocalizedStrings.MX4JModelMBean_INVALID_PERSIST_VALUE.toLocalizedString());
  }
}

private static boolean test(Object mbean, boolean expectImmutable)
        throws Exception {
    MBeanServer mbs = MBeanServerFactory.newMBeanServer();
    ObjectName on = new ObjectName("a:b=c");
    mbs.registerMBean(mbean, on);
    MBeanInfo mbi = mbs.getMBeanInfo(on);
    Descriptor d = mbi.getDescriptor();
    String immutableValue = (String) d.getFieldValue("immutableInfo");
    boolean immutable = ("true".equals(immutableValue));
    if (immutable != expectImmutable) {
        System.out.println("FAILED: " + mbean.getClass().getName() +
                " -> " + immutableValue);
        return false;
    } else {
        System.out.println("OK: " + mbean.getClass().getName());
        return true;
    }
}

@Override
public ModelMBeanAttributeInfo createAttributeInfo() {
  Descriptor desc = new DescriptorSupport(new String[] {"name=" + this.displayName,
      "descriptorType=attribute", "currencyTimeLimit=-1", // always stale
      "displayName=" + this.displayName, "getMethod=getValue"});

  Assert.assertTrue(this.stat != null, "Stat target object is null!");
  desc.setField("targetObject", this.stat);

  ModelMBeanAttributeInfo info = new ModelMBeanAttributeInfo(this.displayName, // name
      this.type, // type
      this.description, // description
      this.readable, // isReadable
      this.writeable, // isWritable
      this.is, // isIs
      desc);

  return info;
}

private <T> OpenMBeanAttributeInfoSupport(String name,
                                          String description,
                                          OpenType<T> openType,
                                          boolean isReadable,
                                          boolean isWritable,
                                          boolean isIs,
                                          T defaultValue,
                                          T[] legalValues,
                                          Comparable<T> minValue,
                                          Comparable<T> maxValue)
        throws OpenDataException {
    super(name,
          (openType==null) ? null : openType.getClassName(),
          description,
          isReadable,
          isWritable,
          isIs,
          makeDescriptor(openType,
                         defaultValue, legalValues, minValue, maxValue));

    this.openType = openType;

    Descriptor d = getDescriptor();
    this.defaultValue = defaultValue;
    this.minValue = minValue;
    this.maxValue = maxValue;
    // We already converted the array into an unmodifiable Set
    // in the descriptor.
    this.legalValues = (Set<?>) d.getFieldValue("legalValues");

    check(this);
}

private Descriptor commandDescriptor(Wrapper w) throws IllegalArgumentException {
    HashMap<String, Object> map = new HashMap<>();
    map.put("dcmd.name", w.info.getName());
    map.put("dcmd.description", w.info.getDescription());
    map.put("dcmd.vmImpact", w.info.getImpact());
    map.put("dcmd.permissionClass", w.info.getPermissionClass());
    map.put("dcmd.permissionName", w.info.getPermissionName());
    map.put("dcmd.permissionAction", w.info.getPermissionAction());
    map.put("dcmd.enabled", w.info.isEnabled());
    StringBuilder sb = new StringBuilder();
    sb.append("help ");
    sb.append(w.info.getName());
    map.put("dcmd.help", executeDiagnosticCommand(sb.toString()));
    if (w.info.getArgumentsInfo() != null && !w.info.getArgumentsInfo().isEmpty()) {
        HashMap<String, Object> allargmap = new HashMap<>();
        for (DiagnosticCommandArgumentInfo arginfo : w.info.getArgumentsInfo()) {
            HashMap<String, Object> argmap = new HashMap<>();
            argmap.put("dcmd.arg.name", arginfo.getName());
            argmap.put("dcmd.arg.type", arginfo.getType());
            argmap.put("dcmd.arg.description", arginfo.getDescription());
            argmap.put("dcmd.arg.isMandatory", arginfo.isMandatory());
            argmap.put("dcmd.arg.isMultiple", arginfo.isMultiple());
            boolean isOption = arginfo.isOption();
            argmap.put("dcmd.arg.isOption", isOption);
            if(!isOption) {
                argmap.put("dcmd.arg.position", arginfo.getPosition());
            } else {
                argmap.put("dcmd.arg.position", -1);
            }
            allargmap.put(arginfo.getName(), new ImmutableDescriptor(argmap));
        }
        map.put("dcmd.arguments", new ImmutableDescriptor(allargmap));
    }
    return new ImmutableDescriptor(map);
}

/**
 * Adds descriptor fields from the {@code ManagedResource} attribute
 * to the MBean descriptor. Specifically, adds the {@code currencyTimeLimit},
 * {@code persistPolicy}, {@code persistPeriod}, {@code persistLocation}
 * and {@code persistName} descriptor fields if they are present in the metadata.
 */
@Override
protected void populateMBeanDescriptor(Descriptor desc, Object managedBean, String beanKey) {
    ManagedResource mr = this.attributeSource.getManagedResource(getClassToExpose(managedBean));
    if (mr == null) {
        throw new InvalidMetadataException(
                "No ManagedResource attribute found for class: " + getClassToExpose(managedBean));
    }

    applyCurrencyTimeLimit(desc, mr.getCurrencyTimeLimit());

    if (mr.isLog()) {
        desc.setField(FIELD_LOG, "true");
    }
    if (StringUtils.hasLength(mr.getLogFile())) {
        desc.setField(FIELD_LOG_FILE, mr.getLogFile());
    }

    if (StringUtils.hasLength(mr.getPersistPolicy())) {
        desc.setField(FIELD_PERSIST_POLICY, mr.getPersistPolicy());
    }
    if (mr.getPersistPeriod() >= 0) {
        desc.setField(FIELD_PERSIST_PERIOD, Integer.toString(mr.getPersistPeriod()));
    }
    if (StringUtils.hasLength(mr.getPersistName())) {
        desc.setField(FIELD_PERSIST_NAME, mr.getPersistName());
    }
    if (StringUtils.hasLength(mr.getPersistLocation())) {
        desc.setField(FIELD_PERSIST_LOCATION, mr.getPersistLocation());
    }
}

/**
 * Adds descriptor fields from the {@code ManagedAttribute} attribute or the {@code ManagedMetric} attribute
 * to the attribute descriptor.
 */
@Override
protected void populateAttributeDescriptor(Descriptor desc, Method getter, Method setter, String beanKey) {
    if(getter != null && hasManagedMetric(getter)) {
        populateMetricDescriptor(desc, this.attributeSource.getManagedMetric(getter));
    }
    else {
        ManagedAttribute gma =
            (getter == null) ? ManagedAttribute.EMPTY : this.attributeSource.getManagedAttribute(getter);
        ManagedAttribute sma =
            (setter == null) ? ManagedAttribute.EMPTY : this.attributeSource.getManagedAttribute(setter);
        populateAttributeDescriptor(desc,gma,sma);
    }
}

@Override
Descriptor getBasicMBeanDescriptor() {
    /* We don't bother saying mxbean=false, and we can't know whether
       the info is immutable until we know whether the MBean class
       (not interface) is a NotificationBroadcaster. */
    return ImmutableDescriptor.EMPTY_DESCRIPTOR;
}

/**
 * Returns a copy of the associated Descriptor of the
 * ModelMBeanOperationInfo.
 *
 * @return Descriptor associated with the
 * ModelMBeanOperationInfo object.
 *
 * @see #setDescriptor
 */

public Descriptor getDescriptor()
{
    if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
        MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
    }
    if (operationDescriptor == null) {
        operationDescriptor = validDescriptor(null);
    }

    return((Descriptor) operationDescriptor.clone());
}

static String toString(OpenMBeanParameterInfo info) {
    Descriptor d = (info instanceof DescriptorRead) ?
        ((DescriptorRead) info).getDescriptor() : null;
    return
        info.getClass().getName() +
        "(name=" + info.getName() +
        ",openType=" + info.getOpenType() +
        ",default=" + info.getDefaultValue() +
        ",minValue=" + info.getMinValue() +
        ",maxValue=" + info.getMaxValue() +
        ",legalValues=" + info.getLegalValues() +
        ((d == null) ? "" : ",descriptor=" + d) +
        ")";
}

private Descriptor getMBeanDescriptorNoException() {
    if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
        MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
    }

    if (modelMBeanDescriptor == null)
        modelMBeanDescriptor = validDescriptor(null);

    if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
        MODELMBEAN_LOGGER.log(Level.TRACE,
                "Exit, returning: " + modelMBeanDescriptor);
    }
    return (Descriptor) modelMBeanDescriptor.clone();
}

@Override
Descriptor getBasicMBeanDescriptor() {
    /* We don't bother saying mxbean=false, and we can't know whether
       the info is immutable until we know whether the MBean class
       (not interface) is a NotificationBroadcaster. */
    return ImmutableDescriptor.EMPTY_DESCRIPTOR;
}

/**
 * Constructs a ModelMBeanInfoSupport which is a duplicate of the given
 * ModelMBeanInfo.  The returned object is a shallow copy of the given
 * object.  Neither the Descriptor nor the contained arrays
 * ({@code ModelMBeanAttributeInfo[]} etc) are cloned.  This method is
 * chiefly of interest to modify the Descriptor of the returned instance
 * via {@link #setDescriptor setDescriptor} without affecting the
 * Descriptor of the original object.
 *
 * @param mbi the ModelMBeanInfo instance from which the ModelMBeanInfo
 * being created is initialized.
 */
public ModelMBeanInfoSupport(ModelMBeanInfo  mbi) {
    super(mbi.getClassName(),
            mbi.getDescription(),
            mbi.getAttributes(),
            mbi.getConstructors(),
            mbi.getOperations(),
            mbi.getNotifications());

    modelMBeanAttributes = mbi.getAttributes();
    modelMBeanConstructors = mbi.getConstructors();
    modelMBeanOperations = mbi.getOperations();
    modelMBeanNotifications = mbi.getNotifications();

    try {
        Descriptor mbeandescriptor = mbi.getMBeanDescriptor();
        modelMBeanDescriptor = validDescriptor(mbeandescriptor);
    } catch (MBeanException mbe) {
        modelMBeanDescriptor = validDescriptor(null);
        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
            MODELMBEAN_LOGGER.log(Level.TRACE,
                    "ModelMBeanInfo(ModelMBeanInfo) " +
                    "Could not get a valid modelMBeanDescriptor, " +
                    "setting a default Descriptor");
        }
    }

    if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
        MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
    }
}

public static void main(String[] args) throws Exception {
    System.out.println("Testing that annotations are correctly " +
                       "reflected in Descriptor entries");

    MBeanServer mbs =
        java.lang.management.ManagementFactory.getPlatformMBeanServer();
    ObjectName on = new ObjectName("a:b=c");

    Thing thing = new Thing();
    mbs.registerMBean(thing, on);
    check(mbs, on);
    mbs.unregisterMBean(on);

    ThingImpl thingImpl = new ThingImpl();
    mbs.registerMBean(thingImpl, on);
    Descriptor d = mbs.getMBeanInfo(on).getDescriptor();
    if (!d.getFieldValue("mxbean").equals("true")) {
        System.out.println("NOT OK: expected MXBean");
        failed = "Expected MXBean";
    }
    check(mbs, on);

    if (failed == null)
        System.out.println("Test passed");
    else
        throw new Exception("TEST FAILED: " + failed);
}

/**
 * Returns a copy of the associated Descriptor of the
 * ModelMBeanOperationInfo.
 *
 * @return Descriptor associated with the
 * ModelMBeanOperationInfo object.
 *
 * @see #setDescriptor
 */

public Descriptor getDescriptor()
{
    if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
        MODELMBEAN_LOGGER.logp(Level.FINER,
                ModelMBeanOperationInfo.class.getName(),
                "getDescriptor()", "Entry");
    }
    if (operationDescriptor == null) {
        operationDescriptor = validDescriptor(null);
    }

    return((Descriptor) operationDescriptor.clone());
}

static void testOperation(MBeanServer mbs, CustomSecurityManager sm,
        ObjectName on, MBeanOperationInfo opInfo) {
    System.out.println("Testing " + opInfo.getName());
    Descriptor desc = opInfo.getDescriptor();
    if (desc.getFieldValue("dcmd.permissionClass") == null) {
    // No special permission required, execution should not trigger
    // any security exception
        if (invokeOperation(mbs, on, opInfo)) {
            throw new RuntimeException("TEST FAILED");
        }
    } else {
        // Building the required permission
        Permission reqPerm = createPermission(
                (String)desc.getFieldValue("dcmd.permissionClass"),
                (String)desc.getFieldValue("dcmd.permissionName"),
                (String)desc.getFieldValue("dcmd.permissionAction"));
        // Paranoid mode: check that the SecurityManager has not already
        // been granted the permission
        sm.denyPermission(reqPerm);
        // A special permission is required for this operation,
        // invoking it without the permission granted must trigger
        // a security exception
        if(!invokeOperation(mbs, on, opInfo)) {
            throw new RuntimeException("TEST FAILED");
        }
        // grant the permission and re-try invoking the operation
        sm.grantPermission(reqPerm);
        if(invokeOperation(mbs, on, opInfo)) {
            throw new RuntimeException("TEST FAILED");
        }
        // Clean up
        sm.denyPermission(reqPerm);
    }
}

static void printOperation(MBeanOperationInfo info) {
    System.out.println("Name: "+info.getName());
    System.out.println("Description: "+info.getDescription());
    System.out.println("Return Type: "+info.getReturnType());
    System.out.println("Impact: "+info.getImpact());
    Descriptor desc = info.getDescriptor();
    System.out.println("Descriptor");
    for(int i=0; i<desc.getFieldNames().length; i++) {
        if(desc.getFieldNames()[i].compareTo("dcmd.arguments") == 0) {
            System.out.println("\t"+desc.getFieldNames()[i]+":");
            Descriptor desc2 =
                    (Descriptor)desc.getFieldValue(desc.getFieldNames()[i]);
            for(int j=0; j<desc2.getFieldNames().length; j++) {
                System.out.println("\t\t"+desc2.getFieldNames()[j]+"=");
                Descriptor desc3 =
                        (Descriptor)desc2.getFieldValue(desc2.getFieldNames()[j]);
                for(int k=0; k<desc3.getFieldNames().length; k++) {
                    System.out.println("\t\t\t"+desc3.getFieldNames()[k]+"="
                                       +desc3.getFieldValue(desc3.getFieldNames()[k]));
                }
            }
        } else {
            System.out.println("\t"+desc.getFieldNames()[i]+"="
                    +desc.getFieldValue(desc.getFieldNames()[i]));
        }
    }
}

static <T> Comparable<?> comparableValueFrom(Descriptor d, String name,
                                             OpenType<T> openType) {
    T t = valueFrom(d, name, openType);
    if (t == null || t instanceof Comparable<?>)
        return (Comparable<?>) t;
    final String msg =
        "Descriptor field " + name + " with value " + t +
        " is not Comparable";
    throw new IllegalArgumentException(msg);
}

/**
 * Deserializes a {@link ModelMBeanInfoSupport} from an {@link ObjectInputStream}.
 */
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException {
    if (compat) {
        // Read an object serialized in the old serial form
        //
        ObjectInputStream.GetField fields = in.readFields();
        modelMBeanDescriptor =
                (Descriptor) fields.get("modelMBeanDescriptor", null);
        if (fields.defaulted("modelMBeanDescriptor")) {
            throw new NullPointerException("modelMBeanDescriptor");
        }
        modelMBeanAttributes =
                (MBeanAttributeInfo[]) fields.get("mmbAttributes", null);
        if (fields.defaulted("mmbAttributes")) {
            throw new NullPointerException("mmbAttributes");
        }
        modelMBeanConstructors =
                (MBeanConstructorInfo[]) fields.get("mmbConstructors", null);
        if (fields.defaulted("mmbConstructors")) {
            throw new NullPointerException("mmbConstructors");
        }
        modelMBeanNotifications =
                (MBeanNotificationInfo[]) fields.get("mmbNotifications", null);
        if (fields.defaulted("mmbNotifications")) {
            throw new NullPointerException("mmbNotifications");
        }
        modelMBeanOperations =
                (MBeanOperationInfo[]) fields.get("mmbOperations", null);
        if (fields.defaulted("mmbOperations")) {
            throw new NullPointerException("mmbOperations");
        }
    } else {
        // Read an object serialized in the new serial form
        //
        in.defaultReadObject();
    }
}

private void cacheResult(ModelMBeanOperationInfo opInfo,
                         Descriptor opDescr, Object result)
        throws MBeanException {

    Descriptor mmbDesc =
        modelMBeanInfo.getMBeanDescriptor();

    Object objctl =
        opDescr.getFieldValue("currencyTimeLimit");
    String ctl;
    if (objctl != null) {
        ctl = objctl.toString();
    } else {
        ctl = null;
    }
    if ((ctl == null) && (mmbDesc != null)) {
        objctl =
            mmbDesc.getFieldValue("currencyTimeLimit");
        if (objctl != null) {
            ctl = objctl.toString();
        } else {
            ctl = null;
        }
    }
    if ((ctl != null) && !(ctl.equals("-1"))) {
        opDescr.setField("value", result);
        opDescr.setField("lastUpdatedTimeStamp",
                String.valueOf((new Date()).getTime()));


        modelMBeanInfo.setDescriptor(opDescr,
                                     "operation");
        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
            MODELMBEAN_LOGGER.logp(Level.FINER,
                    RequiredModelMBean.class.getName(),
                    "invoke(String,Object[],Object[])",
                    "new descriptor is " + opDescr);
        }
    }
}

@Override
Descriptor getMBeanDescriptor(Class<?> resourceClass) {
    /* We already have immutableInfo=true in the Descriptor
     * included in the MBeanInfo for the MXBean interface.  This
     * method is being called for the MXBean *class* to add any
     * new items beyond those in the interface Descriptor, which
     * currently it does not.
     */
    return ImmutableDescriptor.EMPTY_DESCRIPTOR;
}

/** Make an MBeanInfo based on the attributes and operations
 *  found in the interface. */
MBeanInfo makeMBeanInfo(Class<?> mbeanInterface,
        String description) {
    final MBeanAttributeInfo[] attrArray =
            attrs.toArray(new MBeanAttributeInfo[0]);
    final MBeanOperationInfo[] opArray =
            ops.toArray(new MBeanOperationInfo[0]);
    final String interfaceClassName =
            "interfaceClassName=" + mbeanInterface.getName();
    final Descriptor classNameDescriptor =
            new ImmutableDescriptor(interfaceClassName);
    final Descriptor mbeanDescriptor = getBasicMBeanDescriptor();
    final Descriptor annotatedDescriptor =
            Introspector.descriptorForElement(mbeanInterface);
    final Descriptor descriptor =
        DescriptorCache.getInstance().union(
            classNameDescriptor,
            mbeanDescriptor,
            annotatedDescriptor);

    return new MBeanInfo(mbeanInterface.getName(),
            description,
            attrArray,
            null,
            opArray,
            null,
            descriptor);
}

/**
 * Constructs an {@code OpenMBeanParameterInfoSupport} instance,
 * which describes the parameter used in one or more operations or
 * constructors of a class of open MBeans, with the specified
 * {@code name}, {@code openType}, {@code description},
 * and {@code descriptor}.
 *
 * <p>The {@code descriptor} can contain entries that will define
 * the values returned by certain methods of this class, as
 * explained in the <a href="package-summary.html#constraints">
 * package description</a>.
 *
 * @param name  cannot be a null or empty string.
 *
 * @param description  cannot be a null or empty string.
 *
 * @param openType  cannot be null.
 *
 * @param descriptor The descriptor for the parameter.  This may be null
 * which is equivalent to an empty descriptor.
 *
 * @throws IllegalArgumentException if {@code name} or {@code
 * description} are null or empty string, or {@code openType} is
 * null, or the descriptor entries are invalid as described in the
 * <a href="package-summary.html#constraints">package
 * description</a>.
 *
 * @since 1.6
 */
public OpenMBeanParameterInfoSupport(String name,
                                     String description,
                                     OpenType<?> openType,
                                     Descriptor descriptor) {


    // Construct parent's state
    //
    super(name,
          (openType==null) ? null : openType.getClassName(),
          description,
          ImmutableDescriptor.union(descriptor,(openType==null)?null:
            openType.getDescriptor()));

    // Initialize this instance's specific state
    //
    this.openType = openType;

    descriptor = getDescriptor();  // replace null by empty
    this.defaultValue = valueFrom(descriptor, "defaultValue", openType);
    this.legalValues = valuesFrom(descriptor, "legalValues", openType);
    this.minValue = comparableValueFrom(descriptor, "minValue", openType);
    this.maxValue = comparableValueFrom(descriptor, "maxValue", openType);

    try {
        check(this);
    } catch (OpenDataException e) {
        throw new IllegalArgumentException(e.getMessage(), e);
    }
}

static <T> T valueFrom(Descriptor d, String name, OpenType<T> openType) {
    Object x = d.getFieldValue(name);
    if (x == null)
        return null;
    try {
        return convertFrom(x, openType);
    } catch (Exception e) {
        final String msg =
            "Cannot convert descriptor field " + name + "  to " +
            openType.getTypeName();
        throw EnvHelp.initCause(new IllegalArgumentException(msg), e);
    }
}

/**
 * Creates a ModelMBeanInfoSupport with the provided information
 * and the descriptor given in parameter.
 *
 * @param className classname of the MBean
 * @param description human readable description of the
 * ModelMBean
 * @param attributes array of ModelMBeanAttributeInfo objects
 * which have descriptors
 * @param constructors array of ModelMBeanConstructorInfo
 * objects which have descriptor
 * @param operations array of ModelMBeanOperationInfo objects
 * which have descriptor
 * @param notifications array of ModelMBeanNotificationInfo
 * objects which have descriptor
 * @param mbeandescriptor descriptor to be used as the
 * MBeanDescriptor containing MBean wide policy. If the
 * descriptor is null, a default descriptor will be constructed.
 * The default descriptor is:
 * name=className, descriptorType="mbean", displayName=className,
 * persistPolicy="never", log="F", visibility="1".  If the descriptor
 * does not contain all of these fields, the missing ones are
 * added with these default values.
 *
 * @exception RuntimeOperationsException Wraps an
 * IllegalArgumentException for invalid descriptor passed in
 * parameter.  (see {@link #getMBeanDescriptor
 * getMBeanDescriptor} for the definition of a valid MBean
 * descriptor.)
 */

public ModelMBeanInfoSupport(String    className,
        String description,
        ModelMBeanAttributeInfo[] attributes,
        ModelMBeanConstructorInfo[] constructors,
        ModelMBeanOperationInfo[] operations,
        ModelMBeanNotificationInfo[] notifications,
        Descriptor mbeandescriptor) {
    super(className,
            description,
            (attributes != null) ? attributes : NO_ATTRIBUTES,
            (constructors != null) ? constructors : NO_CONSTRUCTORS,
            (operations != null) ? operations : NO_OPERATIONS,
            (notifications != null) ? notifications : NO_NOTIFICATIONS);
    /* The values saved here are possibly null, but we
       check this everywhere they are referenced.  If at
       some stage we replace null with an empty array
       here, as we do in the superclass constructor
       parameters, then we must also do this in
       readObject().  */
    modelMBeanAttributes = attributes;
    modelMBeanConstructors = constructors;
    modelMBeanOperations = operations;
    modelMBeanNotifications = notifications;
    modelMBeanDescriptor = validDescriptor(mbeandescriptor);
    if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
        MODELMBEAN_LOGGER.logp(Level.FINER,
                ModelMBeanInfoSupport.class.getName(),
                "ModelMBeanInfoSupport(String,String,ModelMBeanAttributeInfo[]," +
                "ModelMBeanConstructorInfo[],ModelMBeanOperationInfo[]," +
                "ModelMBeanNotificationInfo[],Descriptor)",
                "Exit");
    }
}

/**
 * Deserializes a {@link ModelMBeanInfoSupport} from an {@link ObjectInputStream}.
 */
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException {
    if (compat) {
        // Read an object serialized in the old serial form
        //
        ObjectInputStream.GetField fields = in.readFields();
        modelMBeanDescriptor =
                (Descriptor) fields.get("modelMBeanDescriptor", null);
        if (fields.defaulted("modelMBeanDescriptor")) {
            throw new NullPointerException("modelMBeanDescriptor");
        }
        modelMBeanAttributes =
                (MBeanAttributeInfo[]) fields.get("mmbAttributes", null);
        if (fields.defaulted("mmbAttributes")) {
            throw new NullPointerException("mmbAttributes");
        }
        modelMBeanConstructors =
                (MBeanConstructorInfo[]) fields.get("mmbConstructors", null);
        if (fields.defaulted("mmbConstructors")) {
            throw new NullPointerException("mmbConstructors");
        }
        modelMBeanNotifications =
                (MBeanNotificationInfo[]) fields.get("mmbNotifications", null);
        if (fields.defaulted("mmbNotifications")) {
            throw new NullPointerException("mmbNotifications");
        }
        modelMBeanOperations =
                (MBeanOperationInfo[]) fields.get("mmbOperations", null);
        if (fields.defaulted("mmbOperations")) {
            throw new NullPointerException("mmbOperations");
        }
    } else {
        // Read an object serialized in the new serial form
        //
        in.defaultReadObject();
    }
}