/**
* Gets the type from a field name.
*
* @param fieldRequire the name of the required field
* @param manipulation the metadata extracted from metadata.xml file
* @return the type of the field or {@code null} if it wasn't found
*/
private static String getTypeFromAttributeField(String fieldRequire, PojoMetadata manipulation) {
FieldMetadata field = manipulation.getField(fieldRequire);
if (field == null) {
return null;
} else {
return FieldMetadata.getReflectionType(field.getFieldType());
}
}
/**
* Gets all the methods available which get this name.
*
* @param methodName the name of the required methods
* @param manipulation the metadata extract from metadata.xml file
* @param description the description which appears in JMX console
* @return the array of methods with the right name
*/
private MethodField[] getMethodsFromName(
String methodName, PojoMetadata manipulation, String description) {
MethodMetadata[] methods = manipulation.getMethods(methodName);
if (methods.length == 0) {
return null;
}
MethodField[] ret = new MethodField[methods.length];
if (methods.length == 1) {
ret[0] = new MethodField(methods[0], description);
return ret;
} else {
for (int i = 0; i < methods.length; i++) {
ret[i] = new MethodField(methods[i], description);
}
return ret;
}
}
/**
* 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);
}
}
}
/**
* Initialize the component type.
*
* @param desc : component type description to populate.
* @param metadata : component type metadata.
* @throws ConfigurationException : metadata are incorrect.
* @see
* org.apache.felix.ipojo.Handler#initializeComponentFactory(org.apache.felix.ipojo.architecture.ComponentTypeDescription,
* org.apache.felix.ipojo.metadata.Element)
*/
public void initializeComponentFactory(ComponentTypeDescription desc, Element metadata)
throws ConfigurationException {
Element[] confs = metadata.getElements("Properties", "");
if (confs == null) {
return;
}
Element[] configurables = confs[0].getElements("Property");
for (int i = 0; configurables != null && i < configurables.length; i++) {
String fieldName = configurables[i].getAttribute("field");
String methodName = configurables[i].getAttribute("method");
if (fieldName == null && methodName == null) {
throw new ConfigurationException(
"Malformed property : The property needs to contain at least a field or a method");
}
String name = configurables[i].getAttribute("name");
if (name == null) {
if (fieldName == null) {
name = methodName;
} else {
name = fieldName;
}
configurables[i].addAttribute(
new Attribute("name", name)); // Add the type to avoid configure checking
}
String value = configurables[i].getAttribute("value");
// Detect the type of the property
PojoMetadata manipulation = getFactory().getPojoMetadata();
String type = null;
if (fieldName == null) {
MethodMetadata[] method = manipulation.getMethods(methodName);
if (method.length == 0) {
type = configurables[i].getAttribute("type");
if (type == null) {
throw new ConfigurationException(
"Malformed property : The type of the property cannot be discovered, add a 'type' attribute");
}
} else {
if (method[0].getMethodArguments().length != 1) {
throw new ConfigurationException(
"Malformed property : The method " + methodName + " does not have one argument");
}
type = method[0].getMethodArguments()[0];
configurables[i].addAttribute(
new Attribute("type", type)); // Add the type to avoid configure checking
}
} else {
FieldMetadata field = manipulation.getField(fieldName);
if (field == null) {
throw new ConfigurationException(
"Malformed property : The field "
+ fieldName
+ " does not exist in the implementation class");
}
type = field.getFieldType();
configurables[i].addAttribute(
new Attribute("type", type)); // Add the type to avoid configure checking
}
// Is the property set to immutable
boolean immutable = false;
String imm = configurables[i].getAttribute("immutable");
immutable = imm != null && imm.equalsIgnoreCase("true");
boolean mandatory = false;
String man = configurables[i].getAttribute("mandatory");
mandatory = man != null && man.equalsIgnoreCase("true");
PropertyDescription pd = null;
if (value == null) {
pd =
new PropertyDescription(
name, type, null, false); // Cannot be immutable if we have no value.
} else {
pd = new PropertyDescription(name, type, value, immutable);
}
if (mandatory) {
pd.setMandatory();
}
desc.addProperty(pd);
}
}
