*/
@SuppressWarnings("unchecked")
public ManagedObject buildManagedObject(Class<?> clazz, MetaData metaData)
{
boolean trace = log.isTraceEnabled();
BeanInfo beanInfo = configuration.getBeanInfo(clazz);
ClassInfo classInfo = beanInfo.getClassInfo();
ManagementObject managementObject = getAnnotation(ManagementObject.class, classInfo, metaData);
if( managementObject == null )
{
if (trace)
log.trace("No ManagementObject annotation, skipping ManagedObject for class: "+clazz);
// Skip the ManagedObject creation
return null;
}
// If a targetInterface exists, rebuild the BeanInfo from that
Class<?> targetInterface = managementObject.targetInterface();
if(targetInterface != Object.class)
{
beanInfo = getBeanInfo(targetInterface);
classInfo = beanInfo.getClassInfo();
}
HashMap<String, Annotation> moAnnotations = new HashMap<String, Annotation>();
moAnnotations.put(ManagementObject.class.getName(), managementObject);
ManagementDeployment mnagementDeployment = getAnnotation(ManagementDeployment.class, classInfo, metaData);
if(mnagementDeployment != null)
moAnnotations.put(ManagementDeployment.class.getName(), mnagementDeployment);
ManagementObjectID moID = getAnnotation(ManagementObjectID.class, classInfo, metaData);
if (moID != null)
moAnnotations.put(ManagementObjectID.class.getName(), moID);
// Process the ManagementObject fields
boolean isRuntime = managementObject.isRuntime();
String name = classInfo.getName();
String nameType = null;
String attachmentName = classInfo.getName();
Class<? extends Fields> moFieldsFactory = null;
ConstraintsPopulatorFactory moCPF = null;
Class<? extends ManagedPropertyConstraintsPopulatorFactory> moConstraintsFactory = null;
Class<? extends ManagedProperty> moPropertyFactory = null;
if (managementObject != null)
{
name = managementObject.name();
if (name.length() == 0 || name.equals(ManagementConstants.GENERATED))
name = classInfo.getName();
nameType = managementObject.type();
if (nameType.length() == 0)
nameType = null;
attachmentName = managementObject.attachmentName();
if (attachmentName.length() == 0)
attachmentName = classInfo.getName();
// Check for a component specification
ManagementComponent mc = null;
if (metaData != null )
mc = metaData.getAnnotation(ManagementComponent.class);
if (mc == null)
mc = managementObject.componentType();
// Work around JBMDR-51 by checking type/subtype
// if (mc.equals(AnnotationDefaults.COMP_TYPE) == false)
if (mc.type().length() > 0 || mc.subtype().length() > 0)
{
log.debug("ManagedObject("+name+") is ManagedComponent type: "+mc);
moAnnotations.put(ManagementComponent.class.getName(), mc);
}
// ManagementObject level default factory classes
FieldsFactory ff = getAnnotation(FieldsFactory.class, classInfo, metaData);
if(ff != null)
moFieldsFactory = ff.value();
moCPF = getAnnotation(ConstraintsPopulatorFactory.class, classInfo, metaData);
if(moCPF != null)
moConstraintsFactory = moCPF.value();
ManagementPropertyFactory mpf = getAnnotation(ManagementPropertyFactory.class, classInfo, metaData);
if(mpf != null)
moPropertyFactory = mpf.value();
}
if (trace)
{
log.trace("Building MangedObject(name="+name+",nameType="+nameType
+",attachmentName="+attachmentName+",isRuntime="+isRuntime+")");
}
ManagementProperties propertyType = ManagementProperties.ALL;
Set<String> classProperties = null;
if (managementObject != null)
{
propertyType = managementObject.properties();
if(propertyType == ManagementProperties.CLASS || propertyType == ManagementProperties.CLASS_AND_EXPLICIT)
{
classProperties = new HashSet<String>();
for(ManagementProperty mp : managementObject.classProperties())
{
if(mp.name().length() > 0)
classProperties.add(mp.name());
if(mp.mappedName().length() > 0)
classProperties.add(mp.mappedName());
}
}
}
// Build the ManagedProperties
Set<ManagedProperty> properties = new HashSet<ManagedProperty>();
Set<PropertyInfo> propertyInfos = beanInfo.getProperties();
if (propertyInfos != null && propertyInfos.isEmpty() == false)
{
for (PropertyInfo propertyInfo : propertyInfos)
{
// Ignore the "class" property
if ("class".equals(propertyInfo.getName()))
continue;
ManagementProperty managementProperty = getAnnotation(ManagementProperty.class, propertyInfo, metaData);
ManagementObjectID id = getAnnotation(ManagementObjectID.class, propertyInfo, metaData);
ManagementObjectRef ref = getAnnotation(ManagementObjectRef.class, propertyInfo, metaData);
ManagementRuntimeRef runtimeRef = getAnnotation(ManagementRuntimeRef.class, propertyInfo, metaData);
RunStateProperty rsp = getAnnotation(RunStateProperty.class, propertyInfo, metaData);
Masked masked = getAnnotation(Masked.class, propertyInfo, metaData);
DefaultValueBuilderFactory defaultsFactory = getAnnotation(DefaultValueBuilderFactory.class, propertyInfo, metaData);
HashMap<String, Annotation> propAnnotations = new HashMap<String, Annotation>();
if (managementProperty != null)
propAnnotations.put(ManagementProperty.class.getName(), managementProperty);
if (id != null)
{
propAnnotations.put(ManagementObjectID.class.getName(), id);
// This overrides the MO nameType
nameType = id.type();
}
if (ref != null)
propAnnotations.put(ManagementObjectRef.class.getName(), ref);
if (runtimeRef != null)
propAnnotations.put(ManagementRuntimeRef.class.getName(), runtimeRef);
if (rsp != null)
propAnnotations.put(RunStateProperty.class.getName(), rsp);
if (masked != null)
propAnnotations.put(Masked.class.getName(), masked);
// Check whether this property should be included
boolean includeProperty = false;
switch(propertyType)
{
// Only if the property as a ManagementProperty
case EXPLICIT:
includeProperty = managementProperty != null &&
(managementProperty.ignored() == false);
break;
// Only if the property is listed in the classProperties
case CLASS:
includeProperty = classProperties.contains(propertyInfo.getName());
break;
// Only if the property is listed in the classProperties
case CLASS_AND_EXPLICIT:
includeProperty = classProperties.contains(propertyInfo.getName())
|| (managementProperty != null && managementProperty.ignored() == false);
break;
// Any property that is not ignored
case ALL:
includeProperty = managementProperty == null
|| managementProperty.ignored() == false;
break;
}
if (includeProperty)
{
Fields fields = null;
Class<? extends Fields> factory = moFieldsFactory;
FieldsFactory ff = getAnnotation(FieldsFactory.class, propertyInfo, metaData);
if(ff != null)
factory = ff.value();
if (factory != null)
{
try
{
fields = factory.newInstance();
}
catch (Exception e)
{
log.debug("Failed to created Fields", e);
}
}
if (fields == null)
fields = new DefaultFieldsImpl();
if( propertyInfo instanceof Serializable )
{
Serializable info = Serializable.class.cast(propertyInfo);
fields.setField(Fields.PROPERTY_INFO, info);
}
String propertyName = propertyInfo.getName();
if (managementProperty != null)
propertyName = managementProperty.name();
if( propertyName.length() == 0 )
propertyName = propertyInfo.getName();
fields.setField(Fields.NAME, propertyName);
// This should probably always the the propertyInfo name?
String mappedName = propertyInfo.getName();
if (managementProperty != null)
mappedName = managementProperty.mappedName();
if( mappedName.length() == 0 )
mappedName = propertyInfo.getName();
fields.setField(Fields.MAPPED_NAME, mappedName);
String description = ManagementConstants.GENERATED;
if (managementProperty != null)
description = managementProperty.description();
if (description.equals(ManagementConstants.GENERATED))
description = propertyName;
fields.setField(Fields.DESCRIPTION, description);
if (trace)
{
log.trace("Building MangedProperty(name="+propertyName
+",mappedName="+mappedName
+") ,annotations="+propAnnotations);
}
boolean mandatory = false;
if (managementProperty != null)
mandatory = managementProperty.mandatory();
if (mandatory)
fields.setField(Fields.MANDATORY, Boolean.TRUE);
boolean readOnly = propertyInfo.isWritable() == false;
if (readOnly == false && managementProperty != null)
readOnly = managementProperty.readOnly();
if (readOnly)
fields.setField(Fields.READ_ONLY, Boolean.TRUE);
boolean managed = false;
if (managementProperty != null)
managed = managementProperty.managed();
// View Use
if (managementProperty != null)
{
ViewUse[] use = managementProperty.use();
fields.setField(Fields.VIEW_USE, use);
}
// ActivationPolicy
ActivationPolicy apolicy = ActivationPolicy.IMMEDIATE;
if (managementProperty != null)
{
apolicy = managementProperty.activationPolicy();
}
fields.setField(Fields.ACTIVATION_POLICY, apolicy);
// The managed property type
MetaMapper[] mapperReturn = {null};
MetaType metaType = this.getMetaType(propertyInfo, propertyInfo.getType(), metaData, false, mapperReturn);
// Determine meta type based on property type
if(metaType == null)
{
if (managed)
{
TypeInfo typeInfo = propertyInfo.getType();
if(typeInfo.isArray())
metaType = new ArrayMetaType(1, MANAGED_OBJECT_META_TYPE);
else if (typeInfo.isCollection())
metaType = new CollectionMetaType(typeInfo.getName(), MANAGED_OBJECT_META_TYPE);
else
metaType = MANAGED_OBJECT_META_TYPE;
}
else
{
metaType = metaTypeFactory.resolve(propertyInfo.getType());
}
}
fields.setField(Fields.META_TYPE, metaType);
// Default value
if(managementProperty != null)
{
String defaultValue = managementProperty.defaultValue();
if(defaultValue.length() > 0)
{
try
{
// Check for a DefaultValueBuilderFactory
DefaultValueBuilder builder = null;
if(defaultsFactory != null)
{
Class<? extends DefaultValueBuilder> factoryClass = defaultsFactory.value();
builder = factoryClass.newInstance();
}
// Lookup the builder by metaType
if(builder == null)
{
builder = defaultBuilders.get(metaType);
}
if(builder != null)
{
MetaValue defaultMV = builder.buildMetaValue(defaultValue);
if(defaultMV != null)
fields.setField(Fields.DEFAULT_VALUE, defaultMV);
}
else
{
log.warn("Failed to find DefaultValueBuilder for type: "+metaType);
}
}
catch(Exception e)
{
log.warn("Failed to create default value for: "+propertyInfo, e);
}
}
}
// Property annotations
if (propAnnotations.isEmpty() == false)
fields.setField(Fields.ANNOTATIONS, propAnnotations);
// Delegate others (legal values, min/max etc.) to the constraints factory
try
{
Class<? extends ManagedPropertyConstraintsPopulatorFactory> factoryClass = moConstraintsFactory;
ConstraintsPopulatorFactory cpf = getAnnotation(ConstraintsPopulatorFactory.class, propertyInfo, metaData);
if(cpf != null)
factoryClass = cpf.value();
else
cpf = moCPF;
if(factoryClass != null)
{
ManagedPropertyConstraintsPopulatorFactory mpcpf = factoryClass.newInstance();
ManagedPropertyConstraintsPopulator populator = mpcpf.newInstance(cpf.min(), cpf.max(), cpf.legalValues(), cpf.args());
if (populator != null)
populator.populateManagedProperty(clazz, propertyInfo, fields);
}
}
catch(Exception e)
{
log.debug("Failed to populate constraints for: "+propertyInfo, e);
}
ManagedProperty property = null;
Class<? extends ManagedProperty> mpClass = moPropertyFactory;
ManagementPropertyFactory mpf = getAnnotation(ManagementPropertyFactory.class, propertyInfo, metaData);
if (mpf != null)
mpClass = mpf.value();
if (mpClass != null)
property = getManagedProperty(mpClass, fields);
// we should have write-through by default
// use factory to change this default behavior
if (property == null)
property = createDefaultManagedProperty(fields);
// Pass the MetaMapper as an attachment
if (mapperReturn[0] != null)
property.setTransientAttachment(MetaMapper.class.getName(), mapperReturn[0]);
properties.add(property);
}
else if (trace)
log.trace("Ignoring property: " + propertyInfo);
}
}
/* TODO: Operations. In general the bean metadata does not contain
operation information.
*/
Set<ManagedOperation> operations = new HashSet<ManagedOperation>();
Set<MethodInfo> methodInfos = beanInfo.getMethods();
if (methodInfos != null && methodInfos.isEmpty() == false)
{
for (MethodInfo methodInfo : methodInfos)
{
ManagementOperation managementOp = getAnnotation(ManagementOperation.class, methodInfo, metaData);