Examples with ManagedDescription org.exoplatform.management.annotations.ManagedDescription used on opensource projects

Example 1 with ManagedDescription

use of org.exoplatform.management.annotations.ManagedDescription in project kernel by exoplatform.

the class PortalContainer method getConfigurationXML.

/**
 * @return returns the configuration of the container in XML format
 */
@Managed
@ManagedDescription("The configuration of the container in XML format.")
public String getConfigurationXML() {
    Configuration conf = getConfiguration();
    if (conf == null) {
        LOG.warn("The configuration of the PortalContainer could not be found");
        return null;
    }
    Configuration result = Configuration.merge(((ExoContainer) parent).getConfiguration(), conf);
    if (result == null) {
        LOG.warn("The configurations could not be merged");
        return null;
    }
    return result.toXML();
}

Example 2 with ManagedDescription

use of org.exoplatform.management.annotations.ManagedDescription in project kernel by exoplatform.

the class MetaDataBuilder method build.

/**
 * Build the info.
 *
 * @return returns the info
 * @throws IllegalStateException raised by any build time issue
 */
public ManagedTypeMetaData build() throws IllegalStateException {
    if (!buildable) {
        throw new IllegalStateException("Class " + clazz.getName() + " does not contain management annotation");
    }
    // 
    ManagedDescription typeDescriptionAnn = AnnotationIntrospector.resolveClassAnnotations(clazz, ManagedDescription.class);
    String typeDescription = typeDescriptionAnn != null ? typeDescriptionAnn.value() : null;
    // 
    Map<Method, Managed> managedMethods = AnnotationIntrospector.resolveMethodAnnotations(clazz, Managed.class);
    Map<Method, ManagedName> methodNames = AnnotationIntrospector.resolveMethodAnnotations(clazz, ManagedName.class);
    Map<Method, ManagedDescription> methodDescriptions = AnnotationIntrospector.resolveMethodAnnotations(clazz, ManagedDescription.class);
    // 
    Map<Method, ManagedMethodMetaData> bilto = new HashMap<Method, ManagedMethodMetaData>();
    for (Map.Entry<Method, Managed> entry : managedMethods.entrySet()) {
        Method method = entry.getKey();
        // 
        ManagedDescription methodDescriptionAnn = methodDescriptions.get(method);
        String methodDescription = methodDescriptionAnn != null ? methodDescriptionAnn.value() : null;
        // 
        Impact impactAnn = method.getAnnotation(Impact.class);
        ImpactType impactType = impactAnn != null ? impactAnn.value() : ImpactType.WRITE;
        // Build the default mbean info
        ManagedMethodMetaData managedMethod = new ManagedMethodMetaData(method, impactType);
        managedMethod.setDescription(methodDescription);
        // Overload with annotations meta data
        Annotation[][] parameterAnnotations = method.getParameterAnnotations();
        for (int i = 0; i < parameterAnnotations.length; i++) {
            ManagedMethodParameterMetaData mmpMD = new ManagedMethodParameterMetaData(i);
            for (Annotation parameterAnnotation : parameterAnnotations[i]) {
                if (parameterAnnotation instanceof ManagedName) {
                    mmpMD.setName(((ManagedName) parameterAnnotation).value());
                } else if (parameterAnnotation instanceof ManagedDescription) {
                    mmpMD.setDescription(((ManagedDescription) parameterAnnotation).value());
                }
            }
            managedMethod.addParameter(mmpMD);
        }
        // 
        bilto.put(method, managedMethod);
    }
    // 
    ManagedTypeMetaData managedType = new ManagedTypeMetaData(clazz);
    managedType.setDescription(typeDescription);
    // 
    Map<String, ManagedMethodMetaData> setters = new HashMap<String, ManagedMethodMetaData>();
    Map<String, ManagedMethodMetaData> getters = new HashMap<String, ManagedMethodMetaData>();
    for (Map.Entry<Method, ManagedMethodMetaData> entry : bilto.entrySet()) {
        Method method = entry.getKey();
        // 
        String methodName = method.getName();
        Class[] parameterTypes = method.getParameterTypes();
        // 
        OperationType type = OperationType.OP;
        Integer index = null;
        if (method.getReturnType() == void.class) {
            if (parameterTypes.length == 1 && methodName.startsWith("set") && methodName.length() > 4) {
                type = OperationType.SET;
                index = 3;
            }
        } else {
            if (parameterTypes.length == 0) {
                type = OperationType.GET;
                if (methodName.startsWith("get") && methodName.length() > 3) {
                    index = 3;
                } else if (methodName.startsWith("is") && methodName.length() > 2) {
                    index = 2;
                }
            }
        }
        // Put in the correct map if it is an attribute
        if (index != null) {
            String attributeName = methodName.substring(index);
            // 
            Map<String, ManagedMethodMetaData> map = type == OperationType.SET ? setters : getters;
            ManagedMethodMetaData previous = map.put(attributeName, entry.getValue());
            if (previous != null) {
                throw new IllegalArgumentException("Duplicate attribute " + type + " " + previous + " and " + method);
            }
        } else {
            ManagedName managedName = methodNames.get(method);
            if (managedName != null) {
                throw new IllegalArgumentException("Managed operation " + method.getName() + " cannot be annoated with @" + ManagedName.class.getName() + " with value " + managedName.value());
            }
            // 
            managedType.addMethod(entry.getValue());
        }
    }
    // Process attributes
    Set<String> attributeNames = new HashSet<String>();
    attributeNames.addAll(getters.keySet());
    attributeNames.addAll(setters.keySet());
    for (String attributeName : attributeNames) {
        ManagedMethodMetaData managedGetter = getters.get(attributeName);
        ManagedMethodMetaData managedSetter = setters.get(attributeName);
        String propertyDescription = null;
        ManagedName getterName = null;
        ManagedName setterName = null;
        String getterDescription = null;
        String setterDescription = null;
        Method getter = null;
        Method setter = null;
        ManagedParameterMetaData mpm = null;
        if (managedGetter != null) {
            getter = managedGetter.getMethod();
            getterName = methodNames.get(getter);
            getterDescription = managedGetter.getDescription();
            propertyDescription = getterDescription;
        }
        if (managedSetter != null) {
            setter = managedSetter.getMethod();
            setterName = methodNames.get(setter);
            setterDescription = managedSetter.getDescription();
            if (propertyDescription == null) {
                propertyDescription = setterDescription;
            }
            mpm = managedSetter.getParameters().iterator().next();
        }
        // Consistency check
        if (getterName != null) {
            if (setterName != null) {
                if (!getterName.value().equals(setterName.value())) {
                    throw new IllegalArgumentException("Getter name=" + getterName.value() + " does not match the setter name=" + setterName.value());
                }
            }
            attributeName = getterName.value();
        } else if (setterName != null) {
            attributeName = setterName.value();
        }
        // 
        ManagedPropertyMetaData managedProperty = new ManagedPropertyMetaData(attributeName, getter, getterDescription, setter, setterDescription, mpm);
        managedProperty.setDescription(propertyDescription);
        // 
        ManagedPropertyMetaData previousManagedProperty = managedType.getProperty(managedProperty.getName());
        if (previousManagedProperty != null) {
            throw new IllegalArgumentException("The same property was declared twice old=" + previousManagedProperty + " new=" + managedProperty);
        }
        // 
        managedType.addProperty(managedProperty);
    }
    // 
    return managedType;
}