/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.felix.dm.annotation.plugin.bnd;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Dictionary;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.function.Supplier;
import org.apache.felix.dm.annotation.api.AdapterService;
import org.apache.felix.dm.annotation.api.AspectService;
import org.apache.felix.dm.annotation.api.BundleAdapterService;
import org.apache.felix.dm.annotation.api.BundleDependency;
import org.apache.felix.dm.annotation.api.Component;
import org.apache.felix.dm.annotation.api.Composition;
import org.apache.felix.dm.annotation.api.ConfigurationDependency;
import org.apache.felix.dm.annotation.api.Destroy;
import org.apache.felix.dm.annotation.api.FactoryConfigurationAdapterService;
import org.apache.felix.dm.annotation.api.Init;
import org.apache.felix.dm.annotation.api.Inject;
import org.apache.felix.dm.annotation.api.LifecycleController;
import org.apache.felix.dm.annotation.api.Property;
import org.apache.felix.dm.annotation.api.Registered;
import org.apache.felix.dm.annotation.api.RepeatableProperty;
import org.apache.felix.dm.annotation.api.ResourceAdapterService;
import org.apache.felix.dm.annotation.api.ResourceDependency;
import org.apache.felix.dm.annotation.api.ServiceDependency;
import org.apache.felix.dm.annotation.api.Start;
import org.apache.felix.dm.annotation.api.Stop;
import org.apache.felix.dm.annotation.api.Unregistered;
import org.osgi.framework.Bundle;
import aQute.bnd.osgi.Annotation;
import aQute.bnd.osgi.ClassDataCollector;
import aQute.bnd.osgi.Clazz;
import aQute.bnd.osgi.Descriptors.TypeRef;
import aQute.bnd.osgi.Verifier;
/**
* This is the scanner which does all the annotation parsing on a given class.
* To start the parsing, just invoke the parseClassFileWithCollector and finish methods.
* Once parsed, the corresponding component descriptors can be built using the "writeTo" method.
*
* @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
*/
public class AnnotationCollector extends ClassDataCollector
{
private final static String A_INIT = Init.class.getName();
private final static String A_START = Start.class.getName();
private final static String A_STOP = Stop.class.getName();
private final static String A_DESTROY = Destroy.class.getName();
private final static String A_COMPOSITION = Composition.class.getName();
private final static String A_LIFCLE_CTRL = LifecycleController.class.getName();
private final static String A_COMPONENT = Component.class.getName();
private final static String A_PROPERTY = Property.class.getName();
private final static String A_REPEATABLE_PROPERTY = RepeatableProperty.class.getName();
private final static String A_SERVICE_DEP = ServiceDependency.class.getName();
private final static String A_CONFIGURATION_DEPENDENCY = ConfigurationDependency.class.getName();
private final static String A_BUNDLE_DEPENDENCY = BundleDependency.class.getName();
private final static String A_RESOURCE_DEPENDENCY = ResourceDependency.class.getName();
private final static String A_ASPECT_SERVICE = AspectService.class.getName();
private final static String A_ADAPTER_SERVICE = AdapterService.class.getName();
private final static String A_BUNDLE_ADAPTER_SERVICE = BundleAdapterService.class.getName();
private final static String A_RESOURCE_ADAPTER_SERVICE = ResourceAdapterService.class.getName();
private final static String A_FACTORYCONFIG_ADAPTER_SERVICE = FactoryConfigurationAdapterService.class.getName();
private final static String A_INJECT = Inject.class.getName();
private final static String A_REGISTERED = Registered.class.getName();
private final static String A_UNREGISTERED = Unregistered.class.getName();
private Logger m_logger;
private String[] m_interfaces;
private boolean m_isField;
private String m_field;
private String m_method;
private String m_descriptor;
private final Set<String> m_dependencyNames = new HashSet<String>();
private final List<EntryWriter> m_writers = new ArrayList<EntryWriter>();
private MetaType m_metaType;
private String m_startMethod;
private String m_stopMethod;
private String m_initMethod;
private String m_destroyMethod;
private String m_compositionMethod;
private String m_starter;
private String m_stopper;
private final Set<String> m_importService = new HashSet<String>();
private final Set<String> m_exportService = new HashSet<String>();
private String m_bundleContextField;
private String m_dependencyManagerField;
private String m_registrationField;
private String m_componentField;
private String m_registeredMethod;
private String m_unregisteredMethod;
private TypeRef m_superClass;
private boolean m_baseClass = true;
/**
* Name of the class annotated with @Component (or other kind of components, like aspect, adapters).
*/
private String m_componentClassName;
/*
* Name of class currently being parsed (the component class name at first, then the inherited classes).
* See DescriptorGenerator class, which first calls parseClassFileWithCollector method with the component class, then it calls
* again the parseClassFileWithCollector method with all inherited component super classes.
*/
private String m_currentClassName;
/**
* Contains all bind methods annotated with a dependency.
* Each entry has the format: "methodName/method signature".
*/
private final Set<String> m_bindMethods = new HashSet<>();
/**
* When more than one @Property annotation are declared on a component type (outside of the @Component annotation), then a @Repeatable
* annotation is used as the container for the @Property annotations. When such annotation is found, it is stored in this attribute, which
* will be parsed in our finish() method.
*/
private Annotation m_repeatableProperty;
/**
* If a Single @Property is declared on the component type (outside of the @Component annotation), then there is no @Repeatable annotation.
* When such single @Property annotation is found, it is stored in this attribute, which will be parsed in our finish() method.
*/
private Annotation m_singleProperty;
/**
* List of all possible DM components.
*/
private final List<EntryType> m_componentTypes = Arrays.asList(EntryType.Component, EntryType.AspectService, EntryType.AdapterService,
EntryType.BundleAdapterService, EntryType.ResourceAdapterService, EntryType.FactoryConfigurationAdapterService);
/**
* Makes a new Collector for parsing a given class.
* @param reporter the object used to report logs.
*/
public AnnotationCollector(Logger reporter, MetaType metaType)
{
m_logger = reporter;
m_metaType = metaType;
}
/**
* Indicates that we are parsing a superclass of a given component class.
*/
public void baseClass(boolean baseClass) {
m_logger.debug("baseClass:%b", baseClass);
m_baseClass = baseClass;
}
/**
* Parses the name of the class.
* @param access the class access
* @param name the class name (package are "/" separated).
*/
@Override
public void classBegin(int access, TypeRef name)
{
if (m_baseClass)
{
m_componentClassName = name.getFQN();
m_logger.debug("Parsing class: %s", m_componentClassName);
}
m_currentClassName = name.getFQN();
}
/**
* Parses the implemented interfaces ("/" separated).
*/
@Override
public void implementsInterfaces(TypeRef[] interfaces)
{
if (m_baseClass)
{
List<String> result = new ArrayList<String>();
for (int i = 0; i < interfaces.length; i++)
{
if (!interfaces[i].getBinary().equals("scala/ScalaObject"))
{
result.add(interfaces[i].getFQN());
}
}
m_interfaces = result.toArray(new String[result.size()]);
m_logger.debug("implements: %s", Arrays.toString(m_interfaces));
}
}
/**
* Parses a method. Always invoked BEFORE eventual method annotation.
*/
@Override
public void method(Clazz.MethodDef method)
{
m_logger.debug("Parsed method %s, descriptor=%s", method.getName(), method.getDescriptor());
m_isField = false;
m_method = method.getName();
m_descriptor = method.getDescriptor().toString();
}
/**
* Parses a field. Always invoked BEFORE eventual field annotation
*/
@Override
public void field(Clazz.FieldDef field)
{
m_logger.debug("Parsed field %s, descriptor=%s", field.getName(), field.getDescriptor());
m_isField = true;
m_field = field.getName();
m_descriptor = field.getDescriptor().toString();
}
@Override
public void extendsClass(TypeRef name) {
m_superClass = name;
}
public TypeRef getSuperClass() {
return m_superClass;
}
/**
* An annotation has been parsed. Always invoked AFTER the "method"/"field"/"classBegin" callbacks.
*/
@Override
public void annotation(Annotation annotation)
{
m_logger.debug("Parsing annotation: %s", annotation.getName());
// if we are parsing a superclass of a given component, then ignore any component annotations.
String name = annotation.getName().getFQN();
if (! m_baseClass) {
String simpleName = name.indexOf(".") != -1 ? name.substring(name.lastIndexOf(".")+1) : name;
Optional<EntryType> type = m_componentTypes.stream().filter(writer -> writer.name().equals(simpleName)).findFirst();
if (type.isPresent()) {
m_logger.debug("Ignoring annotation %s from super class %s of component class %s", name, m_currentClassName, m_componentClassName);
return;
}
}
if (name.equals(A_COMPONENT))
{
parseComponentAnnotation(annotation);
}
else if (name.equals(A_ASPECT_SERVICE))
{
parseAspectService(annotation);
}
else if (name.equals(A_ADAPTER_SERVICE))
{
parseAdapterService(annotation);
}
else if (name.equals(A_BUNDLE_ADAPTER_SERVICE))
{
parseBundleAdapterService(annotation);
}
else if (name.equals(A_RESOURCE_ADAPTER_SERVICE))
{
parseResourceAdapterService(annotation);
}
else if (name.equals(A_FACTORYCONFIG_ADAPTER_SERVICE))
{
parseFactoryConfigurationAdapterService(annotation);
}
else if (name.equals(A_INIT))
{
checkAlreadyDeclaredSingleAnnot(() -> m_initMethod, "@Init");
m_initMethod = m_method;
}
else if (name.equals(A_START))
{
checkAlreadyDeclaredSingleAnnot(() -> m_startMethod, "@Start");
m_startMethod = m_method;
}
else if (name.equals(A_REGISTERED))
{
checkAlreadyDeclaredSingleAnnot(() -> m_registeredMethod, "@Registered");
m_registeredMethod = m_method;
}
else if (name.equals(A_STOP))
{
checkAlreadyDeclaredSingleAnnot(() -> m_stopMethod, "@Stop");
m_stopMethod = m_method;
}
else if (name.equals(A_UNREGISTERED))
{
checkAlreadyDeclaredSingleAnnot(() -> m_unregisteredMethod, "@Unregistered");
m_unregisteredMethod = m_method;
}
else if (name.equals(A_DESTROY))
{
checkAlreadyDeclaredSingleAnnot(() -> m_destroyMethod, "@Destroy");
m_destroyMethod = m_method;
}
else if (name.equals(A_COMPOSITION))
{
checkAlreadyDeclaredSingleAnnot(() -> m_compositionMethod, "@Composition");
Patterns.parseMethod(m_method, m_descriptor, Patterns.COMPOSITION);
m_compositionMethod = m_method;
}
else if (name.equals(A_LIFCLE_CTRL))
{
parseLifecycleAnnotation(annotation);
}
else if (name.equals(A_SERVICE_DEP))
{
parseServiceDependencyAnnotation(annotation);
}
else if (name.equals(A_CONFIGURATION_DEPENDENCY))
{
parseConfigurationDependencyAnnotation(annotation);
}
else if (name.equals(A_BUNDLE_DEPENDENCY))
{
parseBundleDependencyAnnotation(annotation);
}
else if (name.equals(A_RESOURCE_DEPENDENCY))
{
parseRersourceDependencyAnnotation(annotation);
}
else if (name.equals(A_INJECT))
{
parseInject(annotation);
}
else if (name.equals(A_REPEATABLE_PROPERTY))
{
parseRepeatableProperties(annotation);
}
else if (annotation.getName().getFQN().equals(A_PROPERTY))
{
m_singleProperty = annotation;
}
}
/**
* Finishes up the class parsing. This method must be called once the parseClassFileWithCollector method has returned.
* @return true if some annotations have been parsed, false if not.
*/
public boolean finish()
{
m_logger.info("finish %s", m_componentClassName);
// check if we have a component (or adapter) annotation.
Optional<EntryWriter> componentWriter = m_writers.stream()
.filter(writer -> m_componentTypes.indexOf(writer.getEntryType()) != -1)
.findFirst();
if (! componentWriter.isPresent() || m_writers.size() == 0) {
m_logger.info("No components found for class %s", m_componentClassName);
return false;
}
finishComponentAnnotation(componentWriter.get());
// log all meta data for component annotations, dependencies, etc ...
StringBuilder sb = new StringBuilder();
sb.append("Parsed annotation for class ");
sb.append(m_componentClassName);
for (int i = m_writers.size() - 1; i >= 0; i--)
{
sb.append("\n\t").append(m_writers.get(i).toString());
}
m_logger.info(sb.toString());
return true;
}
private void finishComponentAnnotation(EntryWriter componentWriter) {
// Register previously parsed Init/Start/Stop/Destroy/Composition annotations
addCommonServiceParams(componentWriter);
// Add any repeated @Property annotations to the component (or to the aspect, or adapter).
if (m_repeatableProperty != null)
{
Object[] properties = m_repeatableProperty.get("value");
for (Object property : properties)
{
// property is actually a @Property annotation.
parseProperty((Annotation) property, componentWriter);
}
}
// Handle a single Property declared on the component type (in this case, there is no @Repeatable annotation).
if (m_singleProperty != null) {
parseProperty(m_singleProperty, componentWriter);
}
}
/**
* Writes the generated component descriptor in the given print writer.
* The first line must be the component descriptor (@Component or AspectService, etc ..).
* @param pw the writer where the component descriptor will be written.
*/
public void writeTo(PrintWriter pw)
{
// write first the component descriptor (@Component, @AspectService, ...)
EntryWriter componentWriter = m_writers.stream()
.filter(writer -> m_componentTypes.indexOf(writer.getEntryType()) != -1)
.findFirst()
.orElseThrow(() -> new IllegalStateException("Component type not found while scanning class " + m_componentClassName));
pw.println(componentWriter);
// and write other component descriptors (dependencies, and other annotations)
m_writers.stream()
.filter(writer -> m_componentTypes.indexOf(writer.getEntryType()) == -1)
.forEach(dependency -> pw.println(dependency.toString()));
}
/**
* Returns list of all imported services. Imported services are deduced from every
* @ServiceDependency annotations.
* @return the list of imported services, or null
*/
public Set<String> getImportService()
{
return m_importService;
}
/**
* Returns list of all exported services. Imported services are deduced from every
* annotations which provides a service (@Component, etc ...)
* @return the list of exported services, or null
*/
public Set<String> getExportService()
{
return m_exportService;
}
/**
* Parses a Property annotation that is applied on the component class.
* @param property the Property annotation.
*/
private void parseRepeatableProperties(Annotation repeatedProperties)
{
m_repeatableProperty = repeatedProperties;
}
/**
* Checks double declaration of an annotation, which normally must be declared only one time.
* @param field the field supplier (if not null, means the annotation is already declared)
* @param annot the annotation name.
* @throws IllegalStateException if annotation is already declared.
*/
private void checkAlreadyDeclaredSingleAnnot(Supplier<Object> field, String annot) {
if (field.get() != null) {
throw new IllegalStateException("detected multiple " + annot + " annotation from class " + m_currentClassName + " (on from child classes)");
}
}
private void parseComponentAnnotation(Annotation annotation)
{
EntryWriter writer = new EntryWriter(EntryType.Component);
m_writers.add(writer);
// impl attribute
writer.put(EntryParam.impl, m_componentClassName);
// Parse Adapter properties, and other params common to all kind of component
parseCommonComponentAttributes(annotation, writer);
// provides attribute.
if (writer.putClassArray(annotation, EntryParam.provides, m_interfaces, m_exportService) == 0)
{
// no service provided: check if @Registered/@Unregistered annotation are used
// and raise an error if true.
checkRegisteredUnregisteredNotPresent();
}
// factorySet attribute (deprecated, replaced by factoryName)
String factorySetName = writer.putString(annotation, EntryParam.factorySet, null);
if (factorySetName != null)
{
// When a component defines a factorySet, it means that a java.util.Set will
// be provided into the OSGi registry, in order to let anoter component add
// some component instance configurations into it.
// So, we have to indicate that the Set is provided as a service, in the Export-Serviec
// header.
m_exportService.add("java.util.Set");
}
// factoryName attribute
String factoryName = writer.putString(annotation, EntryParam.factoryName, null);
if (factoryName != null)
{
// When a component defines a factoryName, it means that a ComponentFactory will
// be provided into the OSGi registry, in order to let another component create some component instances.
// So, we have to indicate that the ComponentFactory is provided as a service, in the Export-Serviec
// header.
m_exportService.add("org.apache.felix.dependencymanager.runtime.api.ComponentFactory");
}
// factoryConfigure attribute
writer.putString(annotation, EntryParam.factoryConfigure, null);
// factoryMethod attribute
writer.putString(annotation, EntryParam.factoryMethod, null);
}
private void addCommonServiceParams(EntryWriter writer)
{
if (m_initMethod != null)
{
writer.put(EntryParam.init, m_initMethod);
}
if (m_startMethod != null)
{
writer.put(EntryParam.start, m_startMethod);
}
if (m_registeredMethod != null)
{
writer.put(EntryParam.registered, m_registeredMethod);
}
if (m_stopMethod != null)
{
writer.put(EntryParam.stop, m_stopMethod);
}
if (m_unregisteredMethod != null)
{
writer.put(EntryParam.unregistered, m_unregisteredMethod);
}
if (m_destroyMethod != null)
{
writer.put(EntryParam.destroy, m_destroyMethod);
}
if (m_compositionMethod != null)
{
writer.put(EntryParam.composition, m_compositionMethod);
}
if (m_starter != null)
{
writer.put(EntryParam.starter, m_starter);
}
if (m_stopper != null)
{
writer.put(EntryParam.stopper, m_stopper);
if (m_starter == null)
{
throw new IllegalArgumentException("Can't use a @LifecycleController annotation for stopping a service without declaring a " +
"@LifecycleController that starts the component in class " + m_currentClassName);
}
}
if (m_bundleContextField != null)
{
writer.put(EntryParam.bundleContextField, m_bundleContextField);
}
if (m_dependencyManagerField != null)
{
writer.put(EntryParam.dependencyManagerField, m_dependencyManagerField);
}
if (m_componentField != null)
{
writer.put(EntryParam.componentField, m_componentField);
}
if (m_registrationField != null)
{
writer.put(EntryParam.registrationField, m_registrationField);
}
}
/**
* Check if a dependency is already declared in another same bindMethod (or class field) on another child class.
*/
private void checkDependencyAlreadyDeclaredInChild(Annotation annotation, String methodOrField, boolean method) {
if (! m_baseClass && m_bindMethods.contains(methodOrField + "/" + m_descriptor)) {
throw new IllegalStateException("Annotation " + annotation.getName().getShortName()
+ " declared on " + m_currentClassName + "." + methodOrField + (method ? " method" : " field") + " is already declared in child classe(s)");
}
m_bindMethods.add(methodOrField + "/" + m_descriptor);
}
/**
* Parses a ServiceDependency Annotation.
* @param annotation the ServiceDependency Annotation.
*/
private void parseServiceDependencyAnnotation(Annotation annotation)
{
EntryWriter writer = new EntryWriter(EntryType.ServiceDependency);
m_writers.add(writer);
// service attribute
String service = parseClassAttrValue(annotation.get(EntryParam.service.toString()));
if (service == null)
{
if (m_isField)
{
checkDependencyAlreadyDeclaredInChild(annotation, m_field, false);
service = Patterns.parseClass(m_descriptor, Patterns.CLASS, 1);
}
else
{
// if we are parsing some inherited classes, detect if the bind method is already declared in child classes
checkDependencyAlreadyDeclaredInChild(annotation, m_method, true);
// parse "bind(Component, ServiceReference, Service)" signature
service = Patterns.parseClass(m_descriptor, Patterns.BIND_CLASS1, 3, false);
if (service == null) {
// parse "bind(Component, Service)" signature
service = Patterns.parseClass(m_descriptor, Patterns.BIND_CLASS2, 2, false);
}
if (service == null) {
// parse "bind(Component, Map, Service)" signature
service = Patterns.parseClass(m_descriptor, Patterns.BIND_CLASS3, 3, false);
}
if (service == null) {
// parse "bind(ServiceReference, Service)" signature
service = Patterns.parseClass(m_descriptor, Patterns.BIND_CLASS4, 2, false);
}
if (service == null) {
// parse "bind(Service)" signature
service = Patterns.parseClass(m_descriptor, Patterns.BIND_CLASS5, 1, false);
}
if (service == null) {
// parse "bind(Service, Map)" signature
service = Patterns.parseClass(m_descriptor, Patterns.BIND_CLASS6, 1, false);
}
if (service == null) {
// parse "bind(Map, Service)" signature
service = Patterns.parseClass(m_descriptor, Patterns.BIND_CLASS7, 2, false);
}
if (service == null) {
// parse "bind(Service, Dictionary)" signature
service = Patterns.parseClass(m_descriptor, Patterns.BIND_CLASS8, 1, false);
}
if (service == null) {
// parse "bind(Dictionary, Service)" signature
service = Patterns.parseClass(m_descriptor, Patterns.BIND_CLASS9, 2, true);
}
}
}
boolean matchAnyService = service != null && service.equals(ServiceDependency.Any.class.getName());
if (matchAnyService) {
service = null;
}
writer.put(EntryParam.service, service);
// Store this service in list of imported services.
m_importService.add(service);
// autoConfig attribute
if (m_isField)
{
writer.put(EntryParam.autoConfig, m_field);
}
// filter attribute
String filter = annotation.get(EntryParam.filter.toString());
if (filter != null)
{
Verifier.verifyFilter(filter, 0);
if (matchAnyService) {
filter = "(&(objectClass=*)" + filter + ")";
}
writer.put(EntryParam.filter, filter);
} else if (matchAnyService) {
filter = "(objectClass=*)";
writer.put(EntryParam.filter, filter);
}
// defaultImpl attribute
writer.putClass(annotation, EntryParam.defaultImpl);
// added callback
writer.putString(annotation, EntryParam.added, (!m_isField) ? m_method : null);
// timeout parameter
writer.putString(annotation, EntryParam.timeout, null);
Long t = (Long) annotation.get(EntryParam.timeout.toString());
if (t != null && t.longValue() < -1)
{
throw new IllegalArgumentException("Invalid timeout value " + t + " in ServiceDependency annotation from class " + m_currentClassName);
}
// required attribute (not valid if parsing a temporal service dependency)
writer.putString(annotation, EntryParam.required, null);
// changed callback
writer.putString(annotation, EntryParam.changed, null);
// removed callback
writer.putString(annotation, EntryParam.removed, null);
// swap callback
writer.putString(annotation, EntryParam.swap, null);
// name attribute
parseDependencyName(writer, annotation);
// propagate attribute
writer.putString(annotation, EntryParam.propagate, null);
// dereference flag
writer.putString(annotation, EntryParam.dereference, null);
}
/**
* Parse the value of a given annotation attribute (which is of type 'class').
* This method is compatible with bndtools 2.4.1 (where the annotation.get() method returns a String of the form "Lfull/class/name;"),
* and with bndtools 3.x.x (where the annotation.get() method returns a TypeRef).
*
* @param annot the annotation which contains the given attribute
* @param attr the attribute name (of 'class' type).
* @return the annotation class attribute value
*/
public static String parseClassAttrValue(Object value) {
if (value instanceof String)
{
return Patterns.parseClass((String) value, Patterns.CLASS, 1);
}
else if (value instanceof TypeRef)
{
return ((TypeRef) value).getFQN();
}
else if (value == null) {
return null;
}
else {
throw new IllegalStateException("can't parse class attribute value from " + value);
}
}
/**
* Parses a ConfigurationDependency annotation.
* @param annotation the ConfigurationDependency annotation.
*/
private void parseConfigurationDependencyAnnotation(Annotation annotation)
{
checkDependencyAlreadyDeclaredInChild(annotation, m_method, true);
EntryWriter writer = new EntryWriter(EntryType.ConfigurationDependency);
m_writers.add(writer);
// The pid is either:
//
// - the fqdn of the configuration proxy type, if the callback accepts an interface (not a Dictionary).
// - or the fqdn of the class specified by the pidFromClass attribute
// - or the value of the pid attribute
// - or by default the fdqn of the class where the annotation is found
String pidFromClass = parseClassAttrValue(annotation.get(EntryParam.pidClass.toString()));
String pid = pidFromClass != null ? pidFromClass : get(annotation, EntryParam.pid.toString(), null);
// Check if annotation is applied on "updated(ConfigProxyType)"
String confProxyType = Patterns.parseClass(m_descriptor, Patterns.BIND_CLASS5, 1, false);
if (confProxyType != null)
{
if (! Dictionary.class.getName().equals(confProxyType))
{
// It's a conf proxy type.
writer.put(EntryParam.configType, confProxyType);
}
else
{
confProxyType = null;
}
}
else
{
// Check if annotation is applied on "updated(Component, ConfigProxyType)"
confProxyType = Patterns.parseClass(m_descriptor, Patterns.BIND_CLASS2, 2, false);
if (! Dictionary.class.getName().equals(confProxyType))
{
// It's a conf proxy type.
writer.put(EntryParam.configType, confProxyType);
}
else
{
confProxyType = null;
}
}
if (pid == null)
{
if (confProxyType != null)
{
pid = confProxyType;
}
else
{
pid = m_componentClassName;
}
}
writer.put(EntryParam.pid, pid);
// the method on which the annotation is applied
writer.put(EntryParam.updated, m_method);
// propagate attribute
writer.putString(annotation, EntryParam.propagate, null);
// required flag (true by default)
writer.putString(annotation, EntryParam.required, Boolean.TRUE.toString());
// Property Meta Types
parseMetaTypes(annotation, pid, false);
// name attribute
parseDependencyName(writer, annotation);
}
/**
* Parses an AspectService annotation.
* @param annotation
*/
private void parseAspectService(Annotation annotation)
{
EntryWriter writer = new EntryWriter(EntryType.AspectService);
m_writers.add(writer);
// Parse service filter
String filter = annotation.get(EntryParam.filter.toString());
if (filter != null)
{
Verifier.verifyFilter(filter, 0);
writer.put(EntryParam.filter, filter);
}
// Parse service aspect ranking
Integer ranking = annotation.get(EntryParam.ranking.toString());
writer.put(EntryParam.ranking, ranking.toString());
// Generate Aspect Implementation
writer.put(EntryParam.impl, m_componentClassName);
// Parse Adapter properties, and other params common to all kind of component
parseCommonComponentAttributes(annotation, writer);
// Parse field/added/changed/removed attributes
parseAspectOrAdapterCallbackMethods(annotation, writer);
// Parse service interface this aspect is applying to
Object service = annotation.get(EntryParam.service.toString());
if (service == null)
{
if (m_interfaces == null)
{
throw new IllegalStateException("Invalid AspectService annotation: " +
"the service attribute has not been set and the class " + m_componentClassName
+ " does not implement any interfaces");
}
if (m_interfaces.length != 1)
{
throw new IllegalStateException("Invalid AspectService annotation: " +
"the service attribute has not been set and the class " + m_componentClassName
+ " implements more than one interface");
}
writer.put(EntryParam.service, m_interfaces[0]);
}
else
{
writer.putClass(annotation, EntryParam.service);
}
// Parse factoryMethod attribute
writer.putString(annotation, EntryParam.factoryMethod, null);
}
private void parseAspectOrAdapterCallbackMethods(Annotation annotation, EntryWriter writer)
{
String field = annotation.get(EntryParam.field.toString());
String added = annotation.get(EntryParam.added.toString());
String changed = annotation.get(EntryParam.changed.toString());
String removed = annotation.get(EntryParam.removed.toString());
String swap = annotation.get(EntryParam.swap.toString());
// "field" and "added/changed/removed/swap" attributes can't be mixed
if (field != null && (added != null || changed != null || removed != null || swap != null))
{
throw new IllegalStateException("Annotation " + annotation + "can't applied on " + m_componentClassName
+ " can't mix \"field\" attribute with \"added/changed/removed\" attributes");
}
// Parse aspect impl field where to inject the original service.
writer.putString(annotation, EntryParam.field, null);
// Parse aspect impl callback methods.
writer.putString(annotation, EntryParam.added, null);
writer.putString(annotation, EntryParam.changed, null);
writer.putString(annotation, EntryParam.removed, null);
writer.putString(annotation, EntryParam.swap, null);
}
/**
* Parses an AspectService annotation.
* @param annotation
*/
private void parseAdapterService(Annotation annotation)
{
EntryWriter writer = new EntryWriter(EntryType.AdapterService);
m_writers.add(writer);
// Generate Adapter Implementation
writer.put(EntryParam.impl, m_componentClassName);
// Parse adaptee filter
String adapteeFilter = annotation.get(EntryParam.adapteeFilter.toString());
if (adapteeFilter != null)
{
Verifier.verifyFilter(adapteeFilter, 0);
writer.put(EntryParam.adapteeFilter, adapteeFilter);
}
// Parse the mandatory adapted service interface.
writer.putClass(annotation, EntryParam.adapteeService);
// Parse Adapter properties, and other params common to all kind of component
parseCommonComponentAttributes(annotation, writer);
// Parse the provided adapter service (use directly implemented interface by default).
if (writer.putClassArray(annotation, EntryParam.provides, m_interfaces, m_exportService) == 0)
{
checkRegisteredUnregisteredNotPresent();
}
// Parse factoryMethod attribute
writer.putString(annotation, EntryParam.factoryMethod, null);
// Parse propagate flag.
// Parse factoryMethod attribute
writer.putString(annotation, EntryParam.propagate, null);
// Parse field/added/changed/removed attributes
parseAspectOrAdapterCallbackMethods(annotation, writer);
}
/**
* Parses a BundleAdapterService annotation.
* @param annotation
*/
private void parseBundleAdapterService(Annotation annotation)
{
EntryWriter writer = new EntryWriter(EntryType.BundleAdapterService);
m_writers.add(writer);
// Generate Adapter Implementation
writer.put(EntryParam.impl, m_componentClassName);
// Parse bundle filter
String filter = annotation.get(EntryParam.filter.toString());
if (filter != null)
{
Verifier.verifyFilter(filter, 0);
writer.put(EntryParam.filter, filter);
}
// Parse stateMask attribute
writer.putString(annotation, EntryParam.stateMask, Integer.valueOf(
Bundle.INSTALLED | Bundle.RESOLVED | Bundle.ACTIVE).toString());
// Parse Adapter properties, and other params common to all kind of component
parseCommonComponentAttributes(annotation, writer);
// Parse the optional adapter service (use directly implemented interface by default).
if (writer.putClassArray(annotation, EntryParam.provides, m_interfaces, m_exportService) == 0)
{
checkRegisteredUnregisteredNotPresent();
}
// Parse propagate attribute
writer.putString(annotation, EntryParam.propagate, Boolean.FALSE.toString());
// Parse factoryMethod attribute
writer.putString(annotation, EntryParam.factoryMethod, null);
}
/**
* Parses a BundleAdapterService annotation.
* @param annotation
*/
private void parseResourceAdapterService(Annotation annotation)
{
EntryWriter writer = new EntryWriter(EntryType.ResourceAdapterService);
m_writers.add(writer);
// Generate Adapter Implementation
writer.put(EntryParam.impl, m_componentClassName);
// Parse resource filter
String filter = annotation.get(EntryParam.filter.toString());
if (filter != null)
{
Verifier.verifyFilter(filter, 0);
writer.put(EntryParam.filter, filter);
}
// Parse Adapter properties, and other params common to all kind of component
parseCommonComponentAttributes(annotation, writer);
// Parse the provided adapter service (use directly implemented interface by default).
if (writer.putClassArray(annotation, EntryParam.provides, m_interfaces, m_exportService) == 0)
{
checkRegisteredUnregisteredNotPresent();
}
// Parse propagate attribute
writer.putString(annotation, EntryParam.propagate, Boolean.FALSE.toString());
// Parse changed attribute
writer.putString(annotation, EntryParam.changed, null);
}
/**
* Parses a Factory Configuration Adapter annotation.
* @param annotation
*/
private void parseFactoryConfigurationAdapterService(Annotation annotation)
{
EntryWriter writer = new EntryWriter(EntryType.FactoryConfigurationAdapterService);
m_writers.add(writer);
// Generate Adapter Implementation
writer.put(EntryParam.impl, m_componentClassName);
// factory pid attribute (can be specified using the factoryPid attribute, or using the factoryPidClass attribute)
String factoryPidClass = parseClassAttrValue(annotation.get(EntryParam.factoryPidClass.toString()));
// Test if a type safe configuration type is provided.
String configType = parseClassAttrValue(annotation.get(EntryParam.configType.toString()));
if (configType != null) {
writer.put(EntryParam.configType, configType);
}
String factoryPid = null;
factoryPid = get(annotation, EntryParam.factoryPid.toString(), factoryPidClass);
if (factoryPid == null) {
factoryPid = configType != null ? configType : m_componentClassName;
}
writer.put(EntryParam.factoryPid, factoryPid);
// Parse updated callback
writer.putString(annotation, EntryParam.updated, "updated");
// propagate attribute
writer.putString(annotation, EntryParam.propagate, Boolean.FALSE.toString());
// Parse the provided adapter service (use directly implemented interface by default).
if (writer.putClassArray(annotation, EntryParam.provides, m_interfaces, m_exportService) == 0)
{
checkRegisteredUnregisteredNotPresent();
}
// Parse Adapter properties, and other params common to all kind of component
parseCommonComponentAttributes(annotation, writer);
// Parse optional meta types for configuration description.
parseMetaTypes(annotation, factoryPid, true);
// Parse factoryMethod attribute
writer.putString(annotation, EntryParam.factoryMethod, null);
}
private void parseBundleDependencyAnnotation(Annotation annotation)
{
checkDependencyAlreadyDeclaredInChild(annotation, m_method, true);
EntryWriter writer = new EntryWriter(EntryType.BundleDependency);
m_writers.add(writer);
String filter = annotation.get(EntryParam.filter.toString());
if (filter != null)
{
Verifier.verifyFilter(filter, 0);
writer.put(EntryParam.filter, filter);
}
writer.putString(annotation, EntryParam.added, m_method);
writer.putString(annotation, EntryParam.changed, null);
writer.putString(annotation, EntryParam.removed, null);
writer.putString(annotation, EntryParam.required, null);
writer.putString(annotation, EntryParam.stateMask, null);
writer.putString(annotation, EntryParam.propagate, null);
parseDependencyName(writer, annotation);
}
private void parseRersourceDependencyAnnotation(Annotation annotation)
{
checkDependencyAlreadyDeclaredInChild(annotation, ! m_isField ? m_method : m_field, ! m_isField);
EntryWriter writer = new EntryWriter(EntryType.ResourceDependency);
m_writers.add(writer);
String filter = annotation.get(EntryParam.filter.toString());
if (filter != null)
{
Verifier.verifyFilter(filter, 0);
writer.put(EntryParam.filter, filter);
}
if (m_isField)
{
writer.put(EntryParam.autoConfig, m_field);
}
writer.putString(annotation, EntryParam.added, (!m_isField) ? m_method : null);
writer.putString(annotation, EntryParam.changed, null);
writer.putString(annotation, EntryParam.removed, null);
writer.putString(annotation, EntryParam.required, null);
writer.putString(annotation, EntryParam.propagate, null);
writer.putString(annotation, EntryParam.factoryMethod, null);
parseDependencyName(writer, annotation);
}
/**
* Parse the name of a given dependency.
* @param writer The writer where to write the dependency name
* @param annotation the dependency to be parsed
*/
private void parseDependencyName(EntryWriter writer, Annotation annotation)
{
String name = annotation.get(EntryParam.name.toString());
if (name != null)
{
if(! m_dependencyNames.add(name))
{
throw new IllegalArgumentException("Duplicate dependency name " + name + " in Dependency " + annotation + " from class " + m_currentClassName);
}
writer.put(EntryParam.name, name);
}
}
private void parseLifecycleAnnotation(Annotation annotation)
{
Patterns.parseField(m_field, m_descriptor, Patterns.RUNNABLE);
if ("true".equals(get(annotation,EntryParam.start.name(), "true")))
{
if (m_starter != null) {
throw new IllegalStateException("Lifecycle annotation already defined on field " +
m_starter + " in class (or super class of) " + m_componentClassName);
}
m_starter = m_field;
} else {
if (m_stopper != null) {
throw new IllegalStateException("Lifecycle annotation already defined on field " +
m_stopper + " in class (or super class of) " + m_componentClassName);
}
m_stopper = m_field;
}
}
/**
* Parse optional meta types annotation attributes
* @param annotation
*/
private void parseMetaTypes(Annotation annotation, String pid, boolean factory)
{
if (annotation.get("metadata") != null)
{
String propertiesHeading = annotation.get("heading");
String propertiesDesc = annotation.get("description");
MetaType.OCD ocd = new MetaType.OCD(pid, propertiesHeading, propertiesDesc);
for (Object p: (Object[]) annotation.get("metadata"))
{
Annotation property = (Annotation) p;
String heading = property.get("heading");
String id = property.get("id");
String type = parseClassAttrValue(property.get("type"));
Object[] defaults = (Object[]) property.get("defaults");
String description = property.get("description");
Integer cardinality = property.get("cardinality");
Boolean required = property.get("required");
MetaType.AD ad = new MetaType.AD(id, type, defaults, heading, description,
cardinality, required);
Object[] optionLabels = property.get("optionLabels");
Object[] optionValues = property.get("optionValues");
if (optionLabels == null
&& optionValues != null
||
optionLabels != null
&& optionValues == null
||
(optionLabels != null && optionValues != null && optionLabels.length != optionValues.length))
{
throw new IllegalArgumentException("invalid option labels/values specified for property "
+ id +
" in PropertyMetadata annotation from class " + m_currentClassName);
}
if (optionValues != null)
{
for (int i = 0; i < optionValues.length; i++)
{
ad.add(new MetaType.Option(optionValues[i].toString(), optionLabels[i].toString()));
}
}
ocd.add(ad);
}
m_metaType.add(ocd);
MetaType.Designate designate = new MetaType.Designate(pid, factory);
m_metaType.add(designate);
m_logger.info("Parsed MetaType Properties from class " + m_componentClassName);
}
}
/**
* Parses attributes common to all kind of components.
* First, Property annotation is parsed which represents a list of key-value pair.
* The properties are encoded using the following json form:
*
* properties ::= key-value-pair*
* key-value-pair ::= key value
* value ::= String | String[] | value-type
* value-type ::= jsonObject with value-type-info
* value-type-info ::= "type"=primitive java type
* "value"=String|String[]
*
* Exemple:
*
* "properties" : {
* "string-param" : "string-value",
* "string-array-param" : ["str1", "str2],
* "long-param" : {"type":"java.lang.Long", "value":"1"}}
* "long-array-param" : {"type":"java.lang.Long", "value":["1"]}}
* }
* }
*
* @param component the component annotation which contains a "properties" attribute. The component can be either a @Component, or an aspect, or an adapter.
* @param writer the object where the parsed attributes are written.
*/
private void parseCommonComponentAttributes(Annotation component, EntryWriter writer)
{
// Parse properties attribute.
Object[] properties = component.get(EntryParam.properties.toString());
if (properties != null)
{
for (Object property : properties)
{
Annotation propertyAnnotation = (Annotation) property;
parseProperty(propertyAnnotation, writer);
}
}
}
/**
* Parses a Property annotation. The result is added to the associated writer object
* @param annotation the @Property annotation.
* @param writer the writer object where the parsed property will be added to.
*/
private void parseProperty(Annotation property, EntryWriter writer)
{
String name = (String) property.get("name");
String type = parseClassAttrValue(property.get("type"));
Class<?> classType;
try
{
classType = (type == null) ? String.class : Class.forName(type);
}
catch (ClassNotFoundException e)
{
// Theorically impossible
throw new IllegalArgumentException("Invalid Property type " + type
+ " from annotation " + property + " in class " + m_componentClassName);
}
Object[] values;
if ((values = property.get("value")) != null)
{
values = checkPropertyType(name, classType, values);
writer.addProperty(name, values, classType);
}
else if ((values = property.get("values")) != null)
{ // deprecated
values = checkPropertyType(name, classType, values);
writer.addProperty(name, values, classType);
}
else if ((values = property.get("longValue")) != null)
{
writer.addProperty(name, values, Long.class);
}
else if ((values = property.get("doubleValue")) != null)
{
writer.addProperty(name, values, Double.class);
}
else if ((values = property.get("floatValue")) != null)
{
writer.addProperty(name, values, Float.class);
}
else if ((values = property.get("intValue")) != null)
{
writer.addProperty(name, values, Integer.class);
}
else if ((values = property.get("byteValue")) != null)
{
writer.addProperty(name, values, Byte.class);
}
else if ((values = property.get("charValue")) != null)
{
writer.addProperty(name, values, Character.class);
}
else if ((values = property.get("booleanValue")) != null)
{
writer.addProperty(name, values, Boolean.class);
}
else if ((values = property.get("shortValue")) != null)
{
writer.addProperty(name, values, Short.class);
}
else
{
throw new IllegalArgumentException(
"Missing Property value from annotation " + property + " in class " + m_componentClassName);
}
}
/**
* Checks if a property contains values that are compatible with a give primitive type.
*
* @param name the property name
* @param values the values for the property name
* @param type the primitive type.
* @return the same property values, possibly modified if the type is 'Character' (the strings are converted to their character integer values).
*/
private Object[] checkPropertyType(String name, Class<?> type, Object ... values)
{
if (type.equals(String.class))
{
return values;
} else if (type.equals(Long.class)) {
for (Object value : values) {
try {
Long.valueOf(value.toString());
} catch (NumberFormatException e) {
throw new IllegalArgumentException("Property \"" + name + "\" in class " + m_componentClassName
+ " does not contain a valid Long value (" + value.toString() + ")");
}
}
} else if (type.equals(Double.class)) {
for (Object value : values) {
try {
Double.valueOf(value.toString());
} catch (NumberFormatException e) {
throw new IllegalArgumentException("Property \"" + name + "\" in class " + m_componentClassName
+ " does not contain a valid Double value (" + value.toString() + ")");
}
}
} else if (type.equals(Float.class)) {
for (Object value : values) {
try {
Float.valueOf(value.toString());
} catch (NumberFormatException e) {
throw new IllegalArgumentException("Property \"" + name + "\" in class " + m_componentClassName
+ " does not contain a valid Float value (" + value.toString() + ")");
}
}
} else if (type.equals(Integer.class)) {
for (Object value : values) {
try {
Integer.valueOf(value.toString());
} catch (NumberFormatException e) {
throw new IllegalArgumentException("Property \"" + name + "\" in class " + m_componentClassName
+ " does not contain a valid Integer value (" + value.toString() + ")");
}
}
} else if (type.equals(Byte.class)) {
for (Object value : values) {
try {
Byte.valueOf(value.toString());
} catch (NumberFormatException e) {
throw new IllegalArgumentException("Property \"" + name + "\" in class " + m_componentClassName
+ " does not contain a valid Byte value (" + value.toString() + ")");
}
}
} else if (type.equals(Character.class)) {
for (int i = 0; i < values.length; i++)
{
try
{
// If the string is already an integer, don't modify it
Integer.valueOf(values[i].toString());
}
catch (NumberFormatException e)
{
// Converter the character string to its corresponding integer code.
if (values[i].toString().length() != 1)
{
throw new IllegalArgumentException("Property \"" + name + "\" in class "
+ m_componentClassName + " does not contain a valid Character value (" + values[i] + ")");
}
try
{
values[i] = Integer.valueOf(values[i].toString().charAt(0));
}
catch (NumberFormatException e2)
{
throw new IllegalArgumentException("Property \"" + name + "\" in class "
+ m_componentClassName + " does not contain a valid Character value (" + values[i].toString()
+ ")");
}
}
}
} else if (type.equals(Boolean.class)) {
for (Object value : values) {
if (! value.toString().equalsIgnoreCase("false") && ! value.toString().equalsIgnoreCase("true")) {
throw new IllegalArgumentException("Property \"" + name + "\" in class " + m_componentClassName
+ " does not contain a valid Boolean value (" + value.toString() + ")");
}
}
} else if (type.equals(Short.class)) {
for (Object value : values) {
try {
Short.valueOf(value.toString());
} catch (NumberFormatException e) {
throw new IllegalArgumentException("Property \"" + name + "\" in class " + m_componentClassName
+ " does not contain a valid Short value (" + value.toString() + ")");
}
}
}
return values;
}
/**
* Parse Inject annotation, used to inject some special classes in some fields
* (BundleContext/DependencyManager etc ...)
* @param annotation the Inject annotation
*/
private void parseInject(Annotation annotation)
{
if (Patterns.BUNDLE_CONTEXT.matcher(m_descriptor).matches())
{
if (m_bundleContextField != null) {
throw new IllegalStateException("detected multiple @Inject annotation from class " + m_currentClassName + " (on from child classes)");
}
m_bundleContextField = m_field;
}
else if (Patterns.DEPENDENCY_MANAGER.matcher(m_descriptor).matches())
{
if (m_dependencyManagerField != null) {
throw new IllegalStateException("detected multiple @Inject annotation from class " + m_currentClassName + " (on from child classes)");
}
m_dependencyManagerField = m_field;
}
else if (Patterns.COMPONENT.matcher(m_descriptor).matches())
{
if (m_componentField != null) {
throw new IllegalStateException("detected multiple @Inject annotation from class " + m_currentClassName + " (on from child classes)");
}
m_componentField = m_field;
}
else if (Patterns.SERVICE_REGISTRATION.matcher(m_descriptor).matches())
{
if (m_registrationField != null) {
throw new IllegalStateException("detected multiple @Inject annotation from class " + m_currentClassName + " (on from child classes)");
}
m_registrationField = m_field;
}
else
{
throw new IllegalArgumentException("@Inject annotation can't be applied on the field \"" + m_field
+ "\" in class " + m_currentClassName);
}
}
/**
* This method checks if the @Registered and/or @Unregistered annotations have been defined
* while they should not, because the component does not provide a service.
*/
private void checkRegisteredUnregisteredNotPresent()
{
if (m_registeredMethod != null)
{
throw new IllegalStateException("@Registered annotation can't be used on a Component " +
" which does not provide a service (class=" + m_currentClassName + ")");
}
if (m_unregisteredMethod != null)
{
throw new IllegalStateException("@Unregistered annotation can't be used on a Component " +
" which does not provide a service (class=" + m_currentClassName + ")");
}
}
/**
* Get an annotation attribute, and return a default value if its not present.
* @param <T> the type of the variable which is assigned to the return value of this method.
* @param annotation The annotation we are parsing
* @param name the attribute name to get from the annotation
* @param defaultValue the default value to return if the attribute is not found in the annotation
* @return the annotation attribute value, or the defaultValue if not found
*/
@SuppressWarnings("unchecked")
private <T> T get(Annotation annotation, String name, T defaultValue)
{
T value = (T) annotation.get(name);
return value != null ? value : defaultValue;
}
}