/*
* 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.scrplugin.helper;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Map;
import org.apache.felix.scrplugin.Options;
import org.apache.felix.scrplugin.Project;
import org.apache.felix.scrplugin.SCRDescriptorException;
import org.apache.felix.scrplugin.SpecVersion;
import org.apache.felix.scrplugin.description.AbstractDescription;
import org.apache.felix.scrplugin.description.ClassDescription;
import org.apache.felix.scrplugin.description.ComponentDescription;
import org.apache.felix.scrplugin.description.PropertyDescription;
import org.apache.felix.scrplugin.description.PropertyType;
import org.apache.felix.scrplugin.description.ReferenceCardinality;
import org.apache.felix.scrplugin.description.ReferenceDescription;
import org.apache.felix.scrplugin.description.ReferencePolicy;
import org.apache.felix.scrplugin.description.ReferencePolicyOption;
import org.apache.felix.scrplugin.description.ReferenceStrategy;
import org.apache.felix.scrplugin.description.ServiceDescription;
public class Validator {
private final ComponentContainer container;
private final Options options;
private final Project project;
private final IssueLog iLog;
public Validator(final ComponentContainer container,
final Project project,
final Options options,
final IssueLog iLog) {
this.container = container;
this.project = project;
this.options = options;
this.iLog = iLog;
}
private void logWarn(final AbstractDescription desc, final String message) {
// check if location of description is the same as the class
final String classLocation = this.container.getComponentDescription().getSource();
if ( classLocation.equals(desc.getSource()) ) {
iLog.addWarning(desc.getIdentifier() + " : " + message, desc.getSource());
} else {
iLog.addWarning(desc.getIdentifier() + " (" + desc.getSource() + ") : " + message, classLocation);
}
}
private void logError(final AbstractDescription desc, final String message) {
// check if location of description is the same as the class
final String classLocation = this.container.getComponentDescription().getSource();
if ( classLocation.equals(desc.getSource()) ) {
iLog.addError(desc.getIdentifier() + " : " + message, desc.getSource());
} else {
iLog.addError(desc.getIdentifier() + " (" + desc.getSource() + ") : " + message, classLocation);
}
}
/**
* Validate the component description. If errors occur a message is added to
* the issues list, warnings can be added to the warnings list.
*/
public void validate()
throws SCRDescriptorException {
final ComponentDescription component = this.container.getComponentDescription();
// nothing to check if this is ignored
if (!component.isCreateDs()) {
return;
}
final int currentIssueCount = iLog.getNumberOfErrors();
// if the component is abstract, we do not validate everything
if (!component.isAbstract()) {
// if configuration pid is set and different from name, we need 1.2
if ( component.getConfigurationPid() != null && !component.getConfigurationPid().equals(component.getName())
&& options.getSpecVersion().ordinal() < SpecVersion.VERSION_1_2.ordinal() ) {
this.logError(component, "Different configuration pid requires "
+ SpecVersion.VERSION_1_2.getName() + " or higher.");
}
// ensure non-abstract, public class
if (!Modifier.isPublic(this.container.getClassDescription().getDescribedClass().getModifiers())) {
this.logError(component, "Class must be public: "
+ this.container.getClassDescription().getDescribedClass().getName());
}
if (Modifier.isAbstract(this.container.getClassDescription().getDescribedClass().getModifiers())
|| this.container.getClassDescription().getDescribedClass().isInterface()) {
this.logError(component, "Class must be concrete class (not abstract or interface) : "
+ this.container.getClassDescription().getDescribedClass().getName());
}
// no errors so far, let's continue
if (iLog.getNumberOfErrors() == currentIssueCount) {
final String activateName = component.getActivate() == null ? "activate" : component.getActivate();
final String deactivateName = component.getDeactivate() == null ? "deactivate" : component.getDeactivate();
// check activate and deactivate methods
this.checkLifecycleMethod(activateName, true, component.getActivate() != null);
this.checkLifecycleMethod(deactivateName, false, component.getDeactivate() != null);
if (component.getModified() != null) {
if ( this.options.getSpecVersion().ordinal() >= SpecVersion.VERSION_1_1.ordinal() ) {
this.checkLifecycleMethod(component.getModified(), true, true);
} else {
this.logError(component, "If modified version is specified, spec version must be " +
SpecVersion.VERSION_1_1.name() + " or higher : " + component.getModified());
}
}
// ensure public default constructor
boolean constructorFound = true;
Constructor<?>[] constructors = this.container.getClassDescription().getDescribedClass().getDeclaredConstructors();
for (int i = 0; constructors != null && i < constructors.length; i++) {
// if public default, succeed
if (Modifier.isPublic(constructors[i].getModifiers())
&& (constructors[i].getParameterTypes() == null || constructors[i].getParameterTypes().length == 0)) {
constructorFound = true;
break;
}
// non-public/non-default constructor found, must have
// explicit
constructorFound = false;
}
if (!constructorFound) {
this.logError(component, "Class must have public default constructor: " + this.container.getClassDescription().getDescribedClass().getName());
}
// verify properties
for (final PropertyDescription prop : this.container.getProperties().values()) {
this.validateProperty(prop);
}
// verify service
boolean isServiceFactory = false;
if (this.container.getServiceDescription() != null) {
if (this.container.getServiceDescription().getInterfaces().size() == 0) {
this.logError(component, "Service interface information is missing!");
}
this.validateService(this.container.getServiceDescription());
isServiceFactory = this.container.getServiceDescription().isServiceFactory();
}
// serviceFactory must not be true for immediate of component factory
if (isServiceFactory && component.getImmediate() != null && component.getImmediate().booleanValue()
&& component.getFactory() != null) {
this.logError(component,
"Component must not be a ServiceFactory, if immediate and/or component factory: "
+ this.container.getClassDescription().getDescribedClass().getName());
}
// immediate must not be true for component factory
if (component.getImmediate() != null && component.getImmediate().booleanValue() && component.getFactory() != null) {
this.logError(component,
"Component must not be immediate if component factory: " + this.container.getClassDescription().getDescribedClass().getName());
}
}
// additional check for metatype (FELIX-4035)
if ( this.container.getMetatypeContainer() != null ) {
if ( this.container.getMetatypeContainer().getProperties().size() == 0 ) {
this.logError(component, "Component is defined to generate metatype information, however no properties or only private properties have been " +
"defined; in case no properties or only private properties are wanted, consider to use 'metatype=false'");
}
}
if (iLog.getNumberOfErrors() == currentIssueCount) {
// verify references
for (final ReferenceDescription ref : this.container.getReferences().values()) {
this.validateReference(ref, component.isAbstract());
}
}
}
}
private static final String TYPE_COMPONENT_CONTEXT = "org.osgi.service.component.ComponentContext";
private static final String TYPE_BUNDLE_CONTEXT = "org.osgi.framework.BundleContext";
private static final String TYPE_MAP = "java.util.Map";
private static final String TYPE_INT = "int";
private static final String TYPE_INTEGER = "java.lang.Integer";
private static Method getMethod(final Project project,
final ComponentContainer container,
final String name, final String[] sig)
throws SCRDescriptorException {
Class<?>[] classSig = (sig == null ? null : new Class<?>[sig.length]);
if ( sig != null ) {
for(int i = 0; i<sig.length; i++) {
try {
if ( sig[i].equals("int") ) {
classSig[i] = int.class;
} else {
classSig[i] = project.getClassLoader().loadClass(sig[i]);
}
} catch (final ClassNotFoundException e) {
throw new SCRDescriptorException("Unable to load class.", e);
}
}
}
return getMethod(container.getClassDescription(), name, classSig);
}
/**
* Find a lifecycle methods.
*
* @param methodName
* The method name.
* @param isActivate Whether this is the activate or deactivate method.
*/
public static MethodResult findLifecycleMethod(
final Project project,
final ComponentContainer container,
final String methodName,
final boolean isActivate)
throws SCRDescriptorException {
final MethodResult result = new MethodResult();
result.requiredSpecVersion = SpecVersion.VERSION_1_0;
// first candidate is (de)activate(ComponentContext)
result.method = getMethod(project, container, methodName, new String[] { TYPE_COMPONENT_CONTEXT });
if (result.method == null) {
// Spec 1.1 or higher required
result.requiredSpecVersion = SpecVersion.VERSION_1_1;
// second candidate is (de)activate(BundleContext)
result.method = getMethod(project, container, methodName, new String[] { TYPE_BUNDLE_CONTEXT });
if (result.method == null) {
// third candidate is (de)activate(Map)
result.method = getMethod(project, container, methodName, new String[] { TYPE_MAP });
if (result.method == null) {
// if this is a deactivate method, we have two
// additional possibilities
// a method with parameter of type int and one of type
// Integer
if (!isActivate) {
result.method = getMethod(project, container, methodName, new String[] { TYPE_INT });
if (result.method == null) {
result.method = getMethod(project, container, methodName, new String[] { TYPE_INTEGER });
}
}
}
if (result.method == null) {
// fourth candidate is (de)activate with two or three
// arguments (type must be BundleContext, ComponentCtx
// and Map)
// as we have to iterate now and the fifth candidate is
// zero arguments
// we already store this option
Method zeroArgMethod = null;
Method found = result.method;
final Method[] methods = container.getClassDescription().getDescribedClass().getDeclaredMethods();
int i = 0;
while (i < methods.length) {
if (methodName.equals(methods[i].getName())) {
if (methods[i].getParameterTypes() == null || methods[i].getParameterTypes().length == 0) {
zeroArgMethod = methods[i];
} else if (methods[i].getParameterTypes().length >= 2) {
boolean valid = true;
for (int m = 0; m < methods[i].getParameterTypes().length; m++) {
final String type = methods[i].getParameterTypes()[m].getName();
if (!type.equals(TYPE_BUNDLE_CONTEXT) && !type.equals(TYPE_COMPONENT_CONTEXT)
&& !type.equals(TYPE_MAP)) {
// if this is deactivate, int and
// integer are possible as well
if (isActivate || (!type.equals(TYPE_INT) && !type.equals(TYPE_INTEGER))) {
valid = false;
}
}
}
if (valid) {
if (found == null) {
found = methods[i];
} else {
// print warning
result.additionalWarning = "Lifecycle method " + methods[i].getName()
+ " occurs several times with different matching signature.";
}
}
}
}
i++;
}
if (found != null) {
result.method = found;
} else {
result.method = zeroArgMethod;
}
}
}
}
return result;
}
/**
* Check for existence of lifecycle methods.
*
* @param methodName
* The method name.
* @param isActivate Whether this is the activate or deactivate method.
* @param isSpecified Whether this method has explicitely been specified or is just
* the default
*/
private void checkLifecycleMethod(final String methodName,
final boolean isActivate,
final boolean isSpecified)
throws SCRDescriptorException {
final MethodResult result = findLifecycleMethod(this.project, this.container, methodName, isActivate);
if ( result.additionalWarning != null ) {
this.logWarn(this.container.getComponentDescription(), result.additionalWarning);
}
// if no method is found, we check for any method with that name to print some warnings or errors!
if (result.method == null) {
final Method[] methods = this.container.getClassDescription().getDescribedClass().getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
if (methodName.equals(methods[i].getName())) {
if (methods[i].getParameterTypes() == null || methods[i].getParameterTypes().length != 1) {
final String msg = "Lifecycle method " + methods[i].getName() + " has wrong number of arguments";
if ( isSpecified ) {
this.logError(container.getComponentDescription(), msg);
} else {
this.logWarn(container.getComponentDescription(), msg);
}
} else {
final String msg = "Lifecycle method " + methods[i].getName() + " has wrong argument "
+ methods[i].getParameterTypes()[0].getName();
if ( isSpecified ) {
this.logError(container.getComponentDescription(), msg);
} else {
this.logWarn(container.getComponentDescription(), msg);
}
}
}
}
}
// method must be protected for version 1.0
if (result.method != null && options.getSpecVersion() == SpecVersion.VERSION_1_0) {
// check protected
if (Modifier.isPublic(result.method.getModifiers())) {
this.logWarn(container.getComponentDescription(), "Lifecycle method " + result.method.getName() + " should be declared protected");
} else if (!Modifier.isProtected(result.method.getModifiers())) {
this.logWarn(container.getComponentDescription(), "Lifecycle method " + result.method.getName() +
" has wrong qualifier, public or protected required");
}
}
}
/**
* Validate the service and its interfaces
* If errors occur a message is added to the issues list,
* warnings can be added to the warnings list.
*/
private void validateService(final ServiceDescription service) throws SCRDescriptorException {
for (final String interfaceName : service.getInterfaces()) {
if (this.container.getClassDescription().getDescribedClass().isInterface()) {
this.logError(service, "Must be declared in a Java class - not an interface");
} else {
try {
final Class<?> interfaceClass = project.getClassLoader().loadClass(interfaceName);
if (!interfaceClass.isAssignableFrom(this.container.getClassDescription().getDescribedClass())) {
// interface not implemented
this.logError(service, "Class must implement provided interface " + interfaceName);
}
} catch (final ClassNotFoundException cnfe) {
throw new SCRDescriptorException("Unable to load interface class.", cnfe);
}
}
}
}
/**
* Validate the property.
* If errors occur a message is added to the issues list,
* warnings can be added to the warnings list.
*/
private void validateProperty(final PropertyDescription property) {
if (property.getName() == null || property.getName().trim().length() == 0) {
this.logError(property, "Property name can not be empty.");
}
if (property.getType() != null) {
// now check for old and new char
if (this.options.getSpecVersion() == SpecVersion.VERSION_1_0 && property.getType() == PropertyType.Character) {
property.setType(PropertyType.Char);
}
if (this.options.getSpecVersion().ordinal() >= SpecVersion.VERSION_1_1.ordinal()
&& property.getType() == PropertyType.Char) {
property.setType(PropertyType.Character);
}
// check character property value
if ( property.getType() == PropertyType.Char || property.getType() == PropertyType.Character ) {
if ( property.getValue() != null ) {
if ( property.getValue().length() != 1 ) {
this.logError(property, "Value is not a character: " + property.getValue());
}
}
if ( property.getMultiValue() != null ) {
for(final String value : property.getMultiValue() ) {
if ( value.length() != 1 ) {
this.logError(property, "Value is not a character: " + value);
}
}
}
}
}
// TODO might want to check value
}
/**
* Validate the reference.
* If errors occur a message is added to the issues list,
* warnings can be added to the warnings list.
*/
private void validateReference(final ReferenceDescription ref, final boolean componentIsAbstract)
throws SCRDescriptorException {
final int currentIssueCount = iLog.getNumberOfErrors();
// validate name
if (StringUtils.isEmpty(ref.getName())) {
if (this.options.getSpecVersion().ordinal() < SpecVersion.VERSION_1_1.ordinal() ) {
this.logError(ref, "Reference has no name");
}
}
// validate interface
if (StringUtils.isEmpty(ref.getInterfaceName())) {
this.logError(ref, "Missing interface name");
} else {
try {
this.project.getClassLoader().loadClass(ref.getInterfaceName());
} catch (final ClassNotFoundException e) {
this.logError(ref, "Interface class can't be loaded: " + ref.getInterfaceName());
}
}
// validate cardinality
if (ref.getCardinality() == null) {
ref.setCardinality(ReferenceCardinality.MANDATORY_UNARY);
}
// validate policy
if (ref.getPolicy() == null) {
ref.setPolicy(ReferencePolicy.STATIC);
}
// validate policy option
if ( ref.getPolicyOption() == null ) {
ref.setPolicyOption(ReferencePolicyOption.RELUCTANT);
}
if ( ref.getPolicyOption() != ReferencePolicyOption.RELUCTANT ) {
if ( this.options.getSpecVersion().ordinal() < SpecVersion.VERSION_1_2.ordinal() ) {
this.logError(ref, "ReferencePolicyOption " + ref.getPolicyOption().name() +
" requires spec version " + SpecVersion.VERSION_1_2.getName() + " or higher.");
}
}
// validate strategy
if (ref.getStrategy() == null) {
ref.setStrategy(ReferenceStrategy.EVENT);
}
// validate methods only if interface name is set
if (!StringUtils.isEmpty(ref.getInterfaceName())) {
// validate bind and unbind methods
if (ref.getStrategy() != ReferenceStrategy.LOOKUP) {
String bindName = ref.getBind();
String unbindName = ref.getUnbind();
final boolean canGenerate = this.options.isGenerateAccessors() &&
ref.getField() != null
&& (ref.getCardinality() == ReferenceCardinality.OPTIONAL_UNARY || ref.getCardinality() == ReferenceCardinality.MANDATORY_UNARY);
if (bindName == null && !canGenerate ) {
bindName = "bind";
}
if (unbindName == null && !canGenerate ) {
unbindName = "unbind";
}
if ( bindName != null ) {
bindName = this.validateMethod(ref, bindName, componentIsAbstract);
if ( bindName == null && ref.getField() != null ) {
this.logError(ref, "Something went wrong: " + canGenerate + " - " + this.options.isGenerateAccessors() + " - " + ref.getCardinality());
}
} else {
bindName = "bind" + Character.toUpperCase(ref.getName().charAt(0)) + ref.getName().substring(1);
}
if ( unbindName != null ) {
if ( "-".equals(unbindName) )
{
unbindName = null;
} else {
unbindName = this.validateMethod(ref, unbindName, componentIsAbstract);
}
} else {
unbindName = "unbind" + Character.toUpperCase(ref.getName().charAt(0)) + ref.getName().substring(1);
}
// check for volatile on dynamic field reference with cardinality unary
if ( !this.options.isSkipVolatileCheck() ) {
if ( ref.getField() != null
&& (ref.getCardinality() == ReferenceCardinality.OPTIONAL_UNARY || ref.getCardinality() == ReferenceCardinality.MANDATORY_UNARY)
&& ref.getPolicy() == ReferencePolicy.DYNAMIC ) {
final boolean fieldIsVolatile = Modifier.isVolatile(ref.getField().getModifiers());
if ( ref.isBindMethodCreated() || ref.isUnbindMethodCreated() ) {
// field must be volatile
if (!fieldIsVolatile) {
this.logError(ref, "Dynamic field must be declared volatile for unary references");
}
}
}
}
if (iLog.getNumberOfErrors() == currentIssueCount) {
ref.setBind(bindName);
ref.setUnbind(unbindName);
}
} else {
ref.setBind(null);
ref.setUnbind(null);
}
// validate updated method
if (ref.getUpdated() != null) {
if (this.options.getSpecVersion().ordinal() < SpecVersion.VERSION_1_1_FELIX.ordinal()) {
this.logError(ref, "Updated method declaration requires version "
+ SpecVersion.VERSION_1_1_FELIX.getName() + ", " + SpecVersion.VERSION_1_2.getName() + " or newer");
}
this.validateMethod(ref, ref.getUpdated(), componentIsAbstract);
}
}
}
private String validateMethod(final ReferenceDescription ref, final String methodName, final boolean componentIsAbstract)
throws SCRDescriptorException {
final MethodResult result = findMethod(this.project, this.options, this.container.getClassDescription(), ref, methodName);
if (result == null) {
if (!componentIsAbstract) {
this.logError(ref,
"Missing method " + methodName + " for reference "
+ (ref.getName() == null ? "" : ref.getName()));
}
return null;
}
// method needs to be protected for 1.0
if (this.options.getSpecVersion() == SpecVersion.VERSION_1_0) {
if (Modifier.isPublic(result.method.getModifiers())) {
this.logWarn(ref, "Method " + result.method.getName() + " should be declared protected");
} else if (!Modifier.isProtected(result.method.getModifiers())) {
this.logError(ref, "Method " + result.method.getName() + " has wrong qualifier, public or protected required");
return null;
}
}
if (this.options.getSpecVersion().ordinal() < result.requiredSpecVersion.ordinal() ) {
this.logError(ref, "Method declaration for '" + result.method.getName() + "' requires version "
+ result.requiredSpecVersion + " or newer");
}
return result.method.getName();
}
private static final String TYPE_SERVICE_REFERENCE = "org.osgi.framework.ServiceReference";
private static Method getMethod(final ClassDescription cd, final String name, final Class<?>[] sig) {
Class<?> checkClass = cd.getDescribedClass();
while ( checkClass != null ) {
try {
return checkClass.getDeclaredMethod(name, sig);
} catch (final SecurityException e) {
// ignore
} catch (final NoSuchMethodException e) {
// ignore
}
checkClass = checkClass.getSuperclass();
}
return null;
}
public static final class MethodResult {
public Method method;
public SpecVersion requiredSpecVersion;
public String additionalWarning;
}
/**
* Find the method and the required spec version
* @throws SCRDescriptorException If the class can't be found
*/
public static MethodResult findMethod(final Project project,
final Options options,
final ClassDescription cd,
final ReferenceDescription ref,
final String methodName)
throws SCRDescriptorException {
if ( "-".equals(methodName) ) {
return null;
}
SpecVersion requiredVersion = SpecVersion.VERSION_1_0;
try {
final Class<?>[] sig = new Class<?>[] { project.getClassLoader().loadClass(TYPE_SERVICE_REFERENCE) };
final Class<?>[] sig2 = new Class<?>[] { project.getClassLoader().loadClass(ref.getInterfaceName()) };
final Class<?>[] sig3 = new Class<?>[] { project.getClassLoader().loadClass(ref.getInterfaceName()), Map.class };
// service interface or ServiceReference first
String realMethodName = methodName;
Method method = getMethod(cd, realMethodName, sig);
if (method == null) {
method = getMethod(cd, realMethodName, sig2);
if (method == null && (options.getSpecVersion() == null || options.getSpecVersion().ordinal() >= SpecVersion.VERSION_1_1.ordinal()) ) {
method = getMethod(cd, realMethodName, sig3);
requiredVersion = SpecVersion.VERSION_1_1;
}
}
// append reference name with service interface and ServiceReference
if (method == null) {
final String info;
if (StringUtils.isEmpty(ref.getName())) {
final String interfaceName = ref.getInterfaceName();
final int pos = interfaceName.lastIndexOf('.');
info = interfaceName.substring(pos + 1);
} else {
info = ref.getName();
}
realMethodName = methodName + Character.toUpperCase(info.charAt(0)) + info.substring(1);
method = getMethod(cd, realMethodName, sig);
}
if (method == null) {
method = getMethod(cd, realMethodName, sig2);
if (method == null && (options.getSpecVersion() == null || options.getSpecVersion().ordinal() >= SpecVersion.VERSION_1_1.ordinal()) ) {
method = getMethod(cd, realMethodName, sig3);
requiredVersion = SpecVersion.VERSION_1_1;
}
}
// append type name with service interface and ServiceReference
if (method == null) {
int lastDot = ref.getInterfaceName().lastIndexOf('.');
realMethodName = methodName + ref.getInterfaceName().substring(lastDot + 1);
method = getMethod(cd, realMethodName, sig);
}
if (method == null) {
method = getMethod(cd, realMethodName, sig2);
if (method == null && (options.getSpecVersion() == null || options.getSpecVersion().ordinal() >= SpecVersion.VERSION_1_1.ordinal()) ) {
method = getMethod(cd, realMethodName, sig3);
requiredVersion = SpecVersion.VERSION_1_1;
}
}
if ( method == null ) {
return null;
}
final MethodResult result = new MethodResult();
result.method = method;
result.requiredSpecVersion = requiredVersion;
return result;
} catch (final ClassNotFoundException cnfe) {
throw new SCRDescriptorException("Unable to load class!", cnfe);
}
}
}