Example #1
0
  @SuppressWarnings("rawtypes")
  public void loadMetadata(Element metadata, Dictionary configuration) {

    if (metadata.containsAttribute(ProviderMetadata.PROFILE_POLICY)) {
      this.policy = metadata.getAttribute(ProviderMetadata.PROFILE_POLICY);
    }

    if (metadata.containsElement(ProviderMetadata.RESOURCE)) {
      Element[] tagResource = metadata.getElements(ProviderMetadata.RESOURCE);
      for (Element e_resource : tagResource) {
        Resource resource = new Resource();
        resource.loadMetadata(e_resource, configuration);
        resources.add(resource);
      }
    }
  }
Example #2
0
  /**
   * Constructs the structure JmxConfigFieldMap and the Dynamic Mbean.
   *
   * @param metadata the component metadata
   * @param dict the instance configuration
   */
  public void configure(Element metadata, Dictionary dict) {

    PojoMetadata manipulation = getPojoMetadata();

    m_instanceManager = getInstanceManager();

    m_jmxConfigFieldMap = new JmxConfigFieldMap();

    // Build the hashmap
    Element[] mbeans = metadata.getElements(JMX_CONFIG_ELT, m_namespace);
    if (mbeans == null || mbeans.length == 0) {
      mbeans = metadata.getElements(JMX_CONFIG_ALT_ELT, m_namespace);
    }

    if (mbeans.length != 1) {
      error(
          "A component must have exactly one "
              + JMX_CONFIG_ELT
              + " or "
              + JMX_CONFIG_ALT_ELT
              + " element.");
      error("The JMX handler configuration is ignored.");
      return;
    }

    Element mbean = mbeans[0];

    // retrieve kind of MBeanServer to use
    m_usesMOSGi = Boolean.parseBoolean(mbean.getAttribute(JMX_USES_MOSGI_ELT));

    // retrieve object name
    m_completeObjNameElt = mbean.getAttribute(JMX_OBJ_NAME_ELT);
    m_domainElt = mbean.getAttribute(JMX_OBJ_NAME_DOMAIN_ELT);
    m_objNameWODomainElt = mbean.getAttribute(JMX_OBJ_NAME_WO_DOMAIN_ELT);

    // test if Pojo is interested in registration callbacks
    m_registerCallbacks = manipulation.isInterfaceImplemented(MBeanRegistration.class.getName());
    if (m_registerCallbacks) {
      // don't need to check that methods exist, the pojo implements
      // MBeanRegistration interface
      String[] preRegisterParams = {MBeanServer.class.getName(), ObjectName.class.getName()};
      m_preRegisterMeth = manipulation.getMethod(PRE_REGISTER_METH_NAME, preRegisterParams);

      String[] postRegisterParams = {Boolean.class.getName()};
      m_postRegisterMeth = manipulation.getMethod(POST_REGISTER_METH_NAME, postRegisterParams);

      m_preDeregisterMeth = manipulation.getMethod(PRE_DEREGISTER_METH_NAME, new String[0]);

      m_postDeregisterMeth = manipulation.getMethod(POST_DEREGISTER_METH_NAME, new String[0]);
    }

    // set property
    Element[] attributes = mbean.getElements(JMX_PROPERTY_ELT, m_namespace);
    Element[] attributesAlt = mbean.getElements(JMX_PROPERTY_ELT_ALT, m_namespace);
    List<Element> listOfAttributes = new ArrayList<Element>();
    if (attributes != null) {
      listOfAttributes.addAll(Arrays.asList(attributes));
    }
    if (attributesAlt != null) {
      listOfAttributes.addAll(Arrays.asList(attributesAlt));
    }

    Element[] attributesOld = mbeans[0].getElements(JMX_PROPERTY_ELT);
    if (attributesOld != null) {
      warn("The JMX property element should use the '" + m_namespace + "' namespace.");
      listOfAttributes.addAll(Arrays.asList(attributesOld));
    }

    for (Element attribute : listOfAttributes) {
      boolean notif = false;
      String rights;
      String name;
      String field = attribute.getAttribute(JMX_FIELD_ELT);

      if (attribute.containsAttribute(JMX_NAME_ELT)) {
        name = attribute.getAttribute(JMX_NAME_ELT);
      } else {
        name = field;
      }
      if (attribute.containsAttribute(JMX_RIGHTS_ELT)) {
        rights = attribute.getAttribute(JMX_RIGHTS_ELT);
      } else {
        rights = "r";
      }

      PropertyField property =
          new PropertyField(name, field, rights, getTypeFromAttributeField(field, manipulation));

      if (attribute.containsAttribute(JMX_NOTIFICATION_ELT)) {
        notif = Boolean.parseBoolean(attribute.getAttribute(JMX_NOTIFICATION_ELT));
      }

      property.setNotifiable(notif);

      if (notif) {
        // add the new notifiable property in structure
        NotificationField notification =
            new NotificationField(name, this.getClass().getName() + "." + field, null);
        m_jmxConfigFieldMap.addNotificationFromName(name, notification);
      }
      m_jmxConfigFieldMap.addPropertyFromName(name, property);
      getInstanceManager().register(manipulation.getField(field), this);
      info(
          "property exposed:"
              + name
              + " "
              + field
              + ":"
              + getTypeFromAttributeField(field, manipulation)
              + " "
              + rights
              + ", Notif="
              + notif);
    }

    // set methods
    Element[] methods = mbean.getElements(JMX_METHOD_ELT, m_namespace);
    Element[] methodsAlt = mbean.getElements(JMX_METHOD_ELT_ALT, m_namespace);
    List<Element> listOfMethods = new ArrayList<Element>();
    if (methods != null) {
      listOfMethods.addAll(Arrays.asList(methods));
    }
    if (methodsAlt != null) {
      listOfMethods.addAll(Arrays.asList(methodsAlt));
    }

    Element[] methodsOld = mbeans[0].getElements(JMX_PROPERTY_ELT);
    if (methodsOld != null) {
      warn("The JMX method element should use the '" + m_namespace + "' namespace.");
      listOfMethods.addAll(Arrays.asList(methodsOld));
    }

    for (Element method : listOfMethods) {
      String name = method.getAttribute(JMX_NAME_ELT);
      if (name == null) {
        name = method.getAttribute("method");
      }
      String description = null;
      if (method.containsAttribute(JMX_DESCRIPTION_ELT)) {
        description = method.getAttribute(JMX_DESCRIPTION_ELT);
      }

      MethodField[] meth = getMethodsFromName(name, manipulation, description);

      for (int j = 0; j < meth.length; j++) {
        m_jmxConfigFieldMap.addMethodFromName(name, meth[j]);

        info("method exposed:" + meth[j].getReturnType() + " " + name);
      }
    }
  }