@Test
  public void testByteArrayObject() throws Exception {
    ModelNode description = createDescription(ModelType.OBJECT, ModelType.BYTES);
    TypeConverter converter = getConverter(description);

    assertMapType(
        assertCast(TabularType.class, converter.getOpenType()),
        SimpleType.STRING,
        ArrayType.getPrimitiveArrayType(byte[].class));

    ModelNode node = new ModelNode();
    node.get("one").set(new byte[] {1, 2});
    node.get("two").set(new byte[] {3, 4});

    TabularData tabularData = assertCast(TabularData.class, converter.fromModelNode(node));
    Assert.assertEquals(2, tabularData.size());
    Assert.assertTrue(
        Arrays.equals(
            new byte[] {1, 2}, (byte[]) tabularData.get(new Object[] {"one"}).get("value")));
    Assert.assertTrue(
        Arrays.equals(
            new byte[] {3, 4}, (byte[]) tabularData.get(new Object[] {"two"}).get("value")));

    // Allow plain map as well? Yeah why not!
    Map<String, byte[]> map = new HashMap<String, byte[]>();
    map.put("one", new byte[] {1, 2});
    map.put("two", new byte[] {3, 4});
    Assert.assertEquals(node, converter.toModelNode(map));
  }
  @Test
  public void testSimpleTypeObject() throws Exception {
    ModelNode description = createDescription(ModelType.OBJECT, ModelType.LONG);
    TypeConverter converter = getConverter(description);

    assertMapType(
        assertCast(TabularType.class, converter.getOpenType()), SimpleType.STRING, SimpleType.LONG);

    ModelNode node = new ModelNode();
    node.get("one").set(1L);
    node.get("two").set(2L);

    TabularData tabularData = assertCast(TabularData.class, converter.fromModelNode(node));
    Assert.assertEquals(2, tabularData.size());
    Assert.assertEquals(Long.valueOf(1), tabularData.get(new Object[] {"one"}).get("value"));
    Assert.assertEquals(Long.valueOf(2), tabularData.get(new Object[] {"two"}).get("value"));

    Assert.assertEquals(node, converter.toModelNode(tabularData));

    // Allow plain map as well? Yeah why not!
    Map<String, Long> map = new HashMap<String, Long>();
    map.put("one", 1L);
    map.put("two", 2L);
    Assert.assertEquals(node, converter.toModelNode(map));
  }
  /**
   * Adds the attribute to the given list.
   *
   * @param mBeanAttributes The attributes
   * @param root The root attribute
   * @param value The value
   */
  private void addAttributeRoots(
      List<AttributeNode> mBeanAttributes, AttributeNode root, Object value) {
    if (value instanceof CompositeData) {
      mBeanAttributes.add(root);
      CompositeData compositeData = (CompositeData) value;
      CompositeType type = compositeData.getCompositeType();
      for (String key : type.keySet()) {
        AttributeNode attribute = new AttributeNode(key, root);

        root.addChild(attribute);
        addAttributeItems(attribute, compositeData.get(key));
      }
    } else if (value instanceof TabularData) {
      mBeanAttributes.add(root);
      TabularData tabularData = (TabularData) value;
      for (Object keyList : tabularData.keySet()) {
        @SuppressWarnings("unchecked")
        Object[] keys = ((List<Object>) keyList).toArray(new Object[0]);
        AttributeNode attribute = new AttributeNode(String.valueOf(keys[0]), root);

        root.addChild(attribute);
        addAttributeItems(attribute, tabularData.get(keys));
      }
    } else if (value instanceof Long || value instanceof Integer || value instanceof Double) {
      root.setValidLeaf(true);
      root.setRgb(getRGB(root.getQualifiedName()));
      mBeanAttributes.add(root);
    }
  }
Example #4
0
 private static String getProperty(TabularData td, String propName) {
   CompositeData cd = td.get(new Object[] {propName});
   if (cd != null) {
     String key = (String) cd.get("key");
     if (!propName.equals(key)) {
       throw new RuntimeException(
           "TEST FAILED: " + key + " property found" + " but expected to be " + propName);
     }
     return (String) cd.get("value");
   }
   return null;
 }
  /**
   * Reads in the numeric value of mapped to the tabularDataKey value specified when this object was
   * created
   *
   * @param jmxConnection
   * @param f
   * @param beanName
   * @throws Exception
   */
  protected void readValueFromBean(
      MBeanServerConnection jmxConnection, AggregateFunction f, ObjectName beanName)
      throws Exception {
    checkBeanExists(jmxConnection, beanName);
    Object attribute = safelyGetAttribute(jmxConnection, beanName);

    if (!(attribute instanceof TabularData)) {
      raiseValueException("The attribute was not of type TabularData");
    }

    TabularData tabularData = (TabularData) attribute;
    Object[] key = {tabularDataKey};

    if (!tabularData.containsKey(key)) {
      raiseValueException("No value is available for the key Object[] {" + tabularDataKey + "}");
    }

    CompositeData compositeData = null;
    try {
      compositeData = tabularData.get(key);
    } catch (InvalidKeyException k) {
      raiseValueException("The TabularDataKey " + tabularDataKey + " was invalid", k);
    }

    if (compositeData == null) {
      raiseValueException(
          "Even after checking the TabularDataKey "
              + tabularDataKey
              + " existed, we were still return a null value");
      // key asynchronously removed on remote server?, probably possible, but never seen it
    }

    Object value = getValueFromCompositeData(compositeData, "value");
    if (value == null) {
      raiseValueException(
          "The value attribute of the CompositeDataItem with tabular key "
              + tabularDataKey
              + " was null");
    }

    Double v = convertToDouble(value);

    // yippee! after all this checking we actually have a value!
    f.addValue(v);
  }
  @Test
  public void testSimpleTypeObjectExpressions() throws Exception {
    ModelNode description = createDescription(ModelType.OBJECT, ModelType.LONG);
    description.get(EXPRESSIONS_ALLOWED).set(true);
    TypeConverter converter = getConverter(description);

    assertMapType(
        assertCast(TabularType.class, converter.getOpenType()), SimpleType.STRING, SimpleType.LONG);

    ModelNode node = new ModelNode();
    node.get("one").setExpression("${this.should.not.exist.!!!!!:1}");
    node.get("two").setExpression("${this.should.not.exist.!!!!!:2}");

    TabularData tabularData = assertCast(TabularData.class, converter.fromModelNode(node));
    Assert.assertEquals(2, tabularData.size());
    Assert.assertEquals(Long.valueOf(1), tabularData.get(new Object[] {"one"}).get("value"));
    Assert.assertEquals(Long.valueOf(2), tabularData.get(new Object[] {"two"}).get("value"));
  }
  @Test
  public void testSimpleTypeObjectEmpty() throws Exception {
    ModelNode description = createDescription(ModelType.OBJECT, ModelType.LONG);
    TypeConverter converter = getConverter(description);

    assertMapType(
        assertCast(TabularType.class, converter.getOpenType()), SimpleType.STRING, SimpleType.LONG);

    ModelNode node = new ModelNode();
    node.get("one").set("");
    node.get("two").set("");

    TabularData tabularData = assertCast(TabularData.class, converter.fromModelNode(node));
    Assert.assertEquals(2, tabularData.size());
    Assert.assertNull(tabularData.get(new Object[] {"one"}).get("value"));
    Assert.assertNull(tabularData.get(new Object[] {"two"}).get("value"));

    ModelNode expected = new ModelNode();
    expected.get("one");
    expected.get("two");

    Assert.assertEquals(expected, converter.toModelNode(tabularData));
  }
  /**
   * Gets the initial file name.
   *
   * @param jvm The active JVM
   * @return The file name, or <tt>null</tt> if file name is specified
   * @throws JvmCoreException
   */
  String getInitialFileName(IActiveJvm jvm) throws JvmCoreException {

    ObjectName objectName;
    try {
      objectName = new ObjectName(ManagementFactory.RUNTIME_MXBEAN_NAME);
    } catch (MalformedObjectNameException e) {
      throw new JvmCoreException(IStatus.ERROR, e.getMessage(), e);
    } catch (NullPointerException e) {
      throw new JvmCoreException(IStatus.ERROR, e.getMessage(), e);
    }

    TabularData initialName =
        (TabularData)
            jvm.getMBeanServer().getAttribute(objectName, "SystemProperties"); // $NON-NLS-1$
    CompositeData compisiteData = initialName.get(new Object[] {"user.home"}); // $NON-NLS-1$
    String home = compisiteData.values().toArray(new String[0])[1];
    StringBuffer initialFileName = new StringBuffer(home);
    initialFileName
        .append(File.separator)
        .append(new Date().getTime())
        .append('.')
        .append(SnapshotType.Hprof.getExtension());
    return initialFileName.toString();
  }