| /* |
| * 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.ipojo.handlers.dependency; |
| |
| import org.apache.felix.ipojo.ConfigurationException; |
| import org.apache.felix.ipojo.metadata.Element; |
| import org.apache.felix.ipojo.parser.FieldMetadata; |
| import org.apache.felix.ipojo.parser.MethodMetadata; |
| import org.apache.felix.ipojo.parser.PojoMetadata; |
| import org.apache.felix.ipojo.util.DependencyModel; |
| import org.osgi.framework.ServiceReference; |
| |
| import java.util.*; |
| |
| /** |
| * Utility class checking the configuration of a dependency. |
| */ |
| public class DependencyConfigurationChecker { |
| |
| public static void ensure(Dependency dependency, Element metadata, PojoMetadata manipulation) throws |
| ConfigurationException { |
| ensureThatAtLeastOneInjectionIsSpecified(dependency); |
| ensureThatTheFieldIsInComponentClass(dependency, manipulation); |
| ensureThatTheConstructorParameterIsCoherent(dependency, manipulation); |
| ensureThatCallbacksAreCoherent(dependency, manipulation); |
| deduceAggregationFromTheInjectionPoints(dependency, manipulation); |
| deduceTheServiceSpecification(dependency, manipulation); |
| checkTheServiceUnavailableAction(dependency, metadata); |
| checkTheConsistencyOfTheFromAttribute(dependency, metadata); |
| disableProxyForInconsistentTypes(dependency); |
| } |
| |
| /** |
| * Disables the proxy settings for types that does not support it: Vector, Array, and non interface specification. |
| * If the dependency is disabled, check that we are no constructor injection. |
| * @param dependency the dependency |
| */ |
| private static void disableProxyForInconsistentTypes(Dependency dependency) throws ConfigurationException { |
| if (! dependency.getSpecification().isInterface() |
| || dependency.isAggregate() && dependency.getAggregateType() == AggregateDependencyInjectionType.ARRAY |
| || dependency.isAggregate() && dependency.getAggregateType() == AggregateDependencyInjectionType.VECTOR) { |
| dependency.setProxy(false); |
| if (dependency.getConstructorParameterIndex() != -1) { |
| throw new ConfigurationException("The dependency " + DependencyHandler.getDependencyIdentifier |
| (dependency) + " has an inconsistent configuration. - reason: the service specification " + |
| "or container do not support proxy, which is required for constructor injection"); |
| } |
| dependency.getHandler().info("Proxy disabled for " + DependencyHandler.getDependencyIdentifier |
| (dependency) + " - the service specification or container do not support proxy"); |
| } |
| } |
| |
| /** |
| * Checks that the dependency callbacks are consistent: |
| * <ul> |
| * <li>have a supported 'type'</li> |
| * <li>have a supported signature</li> |
| * </ul> |
| * If the method is not in the component class, a message is logged, as this verification cannot be used. |
| * If the method is found in the manipulation metadata, the callback parameters are set. |
| * @param dependency the dependency |
| * @param manipulation the manipulation |
| * @throws ConfigurationException if the methods do not obey to the previously mentioned rules. |
| */ |
| private static void ensureThatCallbacksAreCoherent(Dependency dependency, PojoMetadata manipulation) throws |
| ConfigurationException { |
| DependencyCallback[] callbacks = dependency.getCallbacks(); |
| if (callbacks != null) { |
| for (DependencyCallback callback : callbacks) { |
| MethodMetadata metadata = manipulation.getMethod(callback.getMethodName()); |
| if (metadata == null) { |
| dependency.getHandler().debug("A dependency callback " + callback.getMethodName() + " of " + |
| DependencyHandler.getDependencyIdentifier(dependency) + " does not " + |
| "exist in the implementation class, will try the parent classes"); |
| } else { |
| String[] parameters = metadata.getMethodArguments(); |
| switch(parameters.length) { |
| case 0 : // Just a notification method. |
| callback.setArgument(parameters); |
| break; |
| case 1 : |
| // Can be the service object, service reference or properties |
| callback.setArgument(parameters); |
| break; |
| case 2 : |
| // Constraints on the second argument, must be a service reference, a dictionary or a map |
| if (!ServiceReference.class.getName().equals(parameters[1]) |
| && ! Dictionary.class.getName().equals(parameters[1]) |
| && ! Map.class.getName().equals(parameters[1])) { |
| throw new ConfigurationException("The method " + callback.getMethodName() + " of " + |
| DependencyHandler.getDependencyIdentifier(dependency) + " is not a valid " + |
| "dependency callback - reason: the second argument (" + parameters[1] + |
| ") must be a service reference, a dictionary or a map."); |
| } |
| callback.setArgument(parameters); |
| break; |
| default: |
| // Invalid signature. |
| throw new ConfigurationException("The method " + callback.getMethodName() + " of " + |
| DependencyHandler.getDependencyIdentifier(dependency) + " is not a valid " + |
| "dependency callback - reason: the signature is invalid"); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Checks whether the constructor parameter injection is suitable. this check verified that the constructor has |
| * enough parameter. |
| * @param dependency the dependency |
| * @param manipulation the manipulation metadata |
| * @throws ConfigurationException if the constructor is not suitable |
| */ |
| private static void ensureThatTheConstructorParameterIsCoherent(Dependency dependency, |
| PojoMetadata manipulation) throws |
| ConfigurationException { |
| if (dependency.getConstructorParameterIndex() != -1) { |
| MethodMetadata[] constructors = manipulation.getConstructors(); |
| if (constructors == null || constructors.length == 0) { |
| throw new ConfigurationException("The constructor parameter attribute of " + DependencyHandler |
| .getDependencyIdentifier(dependency) + " is inconsistent - reason: there is no constructor in" + |
| " the component class (" + dependency.getHandler().getInstanceManager().getClassName() + ")"); |
| } |
| |
| //TODO Consider only the first constructor. This is a limitation we should think about, |
| // how to determine which constructor to use. Only one constructor should have annotations, |
| // it could be use as hint. |
| MethodMetadata constructor = constructors[0]; |
| if (! (constructor.getMethodArguments().length > dependency.getConstructorParameterIndex())) { |
| throw new ConfigurationException("The constructor parameter attribute of " + DependencyHandler |
| .getDependencyIdentifier(dependency) + " is inconsistent - reason: the constructor with the " + |
| "signature " + Arrays.toString(constructor.getMethodArguments()) + " has not enough " + |
| "parameters"); |
| } |
| |
| } |
| } |
| |
| /** |
| * Checks that the field used to inject the dependency is in the component class. If the dependency has no field, |
| * this method does nothing. |
| * @param dependency the dependency |
| * @param manipulation the manipulation metadata |
| * @throws ConfigurationException if the field used to inject the given dependency is not in the component class. |
| */ |
| private static void ensureThatTheFieldIsInComponentClass(Dependency dependency, PojoMetadata manipulation) throws ConfigurationException { |
| if (dependency.getField() != null) { |
| FieldMetadata field = manipulation.getField(dependency.getField()); |
| if (field == null) { |
| throw new ConfigurationException("Incorrect field injection for " + DependencyHandler |
| .getDependencyIdentifier(dependency) + " - reason: the field " + dependency.getField() + " is" + |
| " not in the component class (" + dependency.getHandler().getInstanceManager().getClassName() |
| + ")"); |
| } |
| } |
| } |
| |
| /** |
| * Determines if the dependency is aggregate from the field or constructor parameter used to inject the dependency. |
| * If the dependency just uses methods, this method does nothing. This method also check that dependencies set to |
| * aggregate have a valid injection type. |
| * @param dependency the dependency |
| * @param manipulation the manipulation metadata |
| * @throws ConfigurationException if the type of the field or constructor parameter used to inject the dependency |
| * is not suitable for aggregate dependencies. |
| */ |
| private static void deduceAggregationFromTheInjectionPoints(Dependency dependency, PojoMetadata manipulation) throws ConfigurationException { |
| if (dependency.getField() != null) { |
| FieldMetadata field = manipulation.getField(dependency.getField()); |
| String type = field.getFieldType(); |
| if (type.endsWith("[]")) { |
| dependency.setAggregateType(AggregateDependencyInjectionType.ARRAY); |
| } else if (Collection.class.getName().equals(type) || List.class.getName().equals(type)) { |
| dependency.setAggregateType(AggregateDependencyInjectionType.LIST); |
| } else if (Set.class.getName().equals(type)) { |
| dependency.setAggregateType(AggregateDependencyInjectionType.SET); |
| } else if (Vector.class.getName().equals(type)) { |
| dependency.setAggregateType(AggregateDependencyInjectionType.VECTOR); |
| } else if (dependency.isAggregate()) { |
| // Something wrong. The dependency has a field that is not suitable for aggregate dependencies |
| throw new ConfigurationException("The dependency " + DependencyHandler.getDependencyIdentifier |
| (dependency) + " cannot be an aggregate dependency - reason: the type " + field.getFieldType |
| () + " of the field " + field.getFieldName() + " is not suitable for aggregate " + |
| "dependencies. Compatible types are array, vector, list, set and collection."); |
| } |
| } |
| if (dependency.getConstructorParameterIndex() != -1) { |
| String type = manipulation.getConstructors()[0].getMethodArguments()[dependency |
| .getConstructorParameterIndex()]; |
| if (type.endsWith("[]")) { |
| dependency.setAggregateType(AggregateDependencyInjectionType.ARRAY); |
| } else if (Collection.class.getName().equals(type) || List.class.getName().equals(type)) { |
| dependency.setAggregateType(AggregateDependencyInjectionType.LIST); |
| } else if (Set.class.getName().equals(type)) { |
| dependency.setAggregateType(AggregateDependencyInjectionType.SET); |
| } else if (Vector.class.getName().equals(type)) { |
| dependency.setAggregateType(AggregateDependencyInjectionType.VECTOR); |
| } else if (dependency.isAggregate()) { |
| // Something wrong. The dependency has a field that is not suitable for aggregate dependencies |
| throw new ConfigurationException("The dependency " + DependencyHandler.getDependencyIdentifier |
| (dependency) + " cannot be an aggregate dependency - reason: the type " + type |
| + " of the constructor parameter " + dependency.getConstructorParameterIndex() + " is not suitable for aggregate " + |
| "dependencies. Compatible types are array, vector, list, set and collection."); |
| } |
| } |
| //TODO We may not cover some cases such as inconsistency between the constructor and the field. However this |
| // should be very rare. |
| |
| } |
| |
| /** |
| * Checks that the dependency has at least one injection point. |
| * @param dependency the dependency |
| * @throws ConfigurationException if the dependency has no injection point |
| */ |
| private static void ensureThatAtLeastOneInjectionIsSpecified(Dependency dependency) throws ConfigurationException { |
| if (dependency.getField() == null |
| && (dependency.getCallbacks() == null || dependency.getCallbacks().length == 0) |
| && dependency.getConstructorParameterIndex() == -1) { |
| throw new ConfigurationException("The dependency " + DependencyHandler.getDependencyIdentifier |
| (dependency) + " is invalid - reason: no injection specified, at least a field, " + |
| "a method or a constructor parameter index must be set"); |
| } |
| } |
| |
| /** |
| * Checks that the `from` attribute is used consistently: |
| * <ul> |
| * <li>Rule 1 : it cannot be used on aggregate dependency</li> |
| * <li>Rule 2 : it cannot be used in combination with the `comparator` attribute</li> |
| * <li>Rule 3 : it cannot be used in combination with the `dynamic-priority` binding policy</li> |
| * </ul> |
| * |
| * @param dependency the dependency |
| * @param metadata the dependency metadata |
| * @throws ConfigurationException if the `from` attribute is used inconsistently. |
| */ |
| private static void checkTheConsistencyOfTheFromAttribute(Dependency dependency, |
| Element metadata) throws ConfigurationException { |
| // Check if we have a from attribute. |
| if (metadata.getAttribute("from") != null) { |
| final String message = "The `from` attribute is not usable in " + DependencyHandler |
| .getDependencyIdentifier(dependency) + " - reason: "; |
| // Rule 1 |
| if (dependency.isAggregate()) { |
| throw new ConfigurationException(message + "the dependency is " + |
| "aggregate"); |
| } |
| // Rule 2 |
| String comparator = metadata.getAttribute("comparator"); |
| if (comparator != null) { |
| throw new ConfigurationException(message + "the dependency uses a comparator"); |
| } |
| // Rule 3 |
| if (dependency.getBindingPolicy() == DependencyModel.DYNAMIC_PRIORITY_BINDING_POLICY) { |
| throw new ConfigurationException(message + "the dependency uses the dynamic-priority " + |
| "binding policy"); |
| } |
| } |
| } |
| |
| /** |
| * Checks that service unavailable actions are consistent. |
| * <ul> |
| * <li>Rule 1: Nullable, Exception, Default-Implementation... can only be used for scalar optional dependency</li> |
| * <li>Rule 2: Only one can be used</li> |
| * <li>Rule 3: Timeout can only be used on optional dependency</li> |
| * </ul> |
| * |
| * @param dependency the dependency |
| * @throws ConfigurationException if the dependency used inconsistent attributes |
| */ |
| private static void checkTheServiceUnavailableAction(Dependency dependency, |
| Element metadata) throws ConfigurationException { |
| if (metadata.containsAttribute("nullable") || dependency.getDefaultImplementation() != null || dependency |
| .getException() != null) { |
| // Rule 1: |
| String message = "The `nullable`, `default-implementation` and `exception` attributes are not " + |
| "usable in " + DependencyHandler.getDependencyIdentifier(dependency) + " - reason: "; |
| if (dependency.isAggregate()) { |
| throw new ConfigurationException(message + "the dependency is aggregate"); |
| } |
| if (! dependency.isOptional()) { |
| throw new ConfigurationException(message + "the dependency is mandatory"); |
| } |
| |
| // At this point, we know that the dependency is scalar and optional, and at least one attribute is set |
| |
| // Rule 2: |
| message = "Inconsistent use of the `nullable`, `default-implementation` and `exception` attributes are " + |
| "not usable in " + DependencyHandler.getDependencyIdentifier(dependency) + " - reason: "; |
| if (metadata.containsAttribute("nullable") && dependency.getDefaultImplementation() != null) { |
| throw new ConfigurationException(message + "`nullable` and `default-implementation` cannot be " + |
| "combined"); |
| } |
| if (metadata.containsAttribute("nullable") && dependency.getException() != null) { |
| throw new ConfigurationException(message + "`nullable` and `exception` cannot be combined"); |
| } |
| if (dependency.getDefaultImplementation() != null && dependency.getException() != null) { |
| throw new ConfigurationException(message + "`exception` and `default-implementation` cannot be " + |
| "combined"); |
| } |
| } |
| |
| // Rule 3: |
| if (dependency.getTimeout() != 0 && ! dependency.isOptional()) { |
| throw new ConfigurationException("The `timeout` attribute is not usable in " + DependencyHandler |
| .getDependencyIdentifier(dependency) + " - reason: the dependency is not optional"); |
| } |
| |
| |
| |
| |
| } |
| |
| /** |
| * Tries to determine the service specification to inject in the dependency. |
| * If the specification is already checked by the dependency, just checks the consistency. |
| * |
| * @param dependency the dependency |
| * @param manipulation the manipulation metadata |
| * @throws ConfigurationException if the specification cannot be deduced, or when the set specification is not |
| * consistent. |
| */ |
| private static void deduceTheServiceSpecification(Dependency dependency, PojoMetadata manipulation) throws |
| ConfigurationException { |
| |
| // Deduction algorithm |
| String fieldType = null; |
| String callbackType = null; |
| String constructorType = null; |
| // First check the field |
| if (dependency.getField() != null) { |
| fieldType = extractSpecificationFromField(dependency.getField(), manipulation); |
| } |
| if (dependency.getCallbacks() != null && dependency.getCallbacks().length != 0) { |
| callbackType = extractSpecificationFromMethods(dependency, dependency.getCallbacks(), manipulation); |
| } |
| if (dependency.getConstructorParameterIndex() != -1) { |
| constructorType = extractSpecificationFromConstructor(dependency.getConstructorParameterIndex(), |
| manipulation); |
| } |
| |
| if (dependency.getSpecification() == null |
| && fieldType == null && callbackType == null && constructorType == null) { |
| throw new ConfigurationException("The deduction of the service specification for " + DependencyHandler |
| .getDependencyIdentifier(dependency) + " has failed - reason: when neither the field, " + |
| "methods and constructor parameter have provided the service specification, " + |
| "the `specification` attribute must be set"); |
| |
| } |
| |
| // The Dependency.setSpecification method check whether the specification coming from the different sources |
| // are consistent. |
| if (fieldType != null) { |
| setSpecification(dependency, fieldType); |
| } |
| if (callbackType != null) { |
| setSpecification(dependency, callbackType); |
| } |
| if (constructorType != null) { |
| setSpecification(dependency, constructorType); |
| } |
| } |
| |
| private static String extractSpecificationFromMethods(Dependency dependency, DependencyCallback[] callbacks, |
| PojoMetadata manipulation) throws ConfigurationException { |
| String type = null; |
| for (DependencyCallback callback : callbacks) { |
| MethodMetadata metadata = manipulation.getMethod(callback.getMethodName()); |
| if (metadata != null) { |
| String[] parameters = metadata.getMethodArguments(); |
| if (parameters.length == 1 || parameters.length == 2) { |
| if (! ServiceReference.class.getName().equals(parameters[0]) |
| && ! Dictionary.class.getName().equals(parameters[0]) |
| && ! Map.class.getName().equals(parameters[0])) { |
| if (type == null) { |
| type = parameters[0]; |
| } else { |
| if (! type.equals(parameters[0])) { |
| throw new ConfigurationException("The callbacks of " + DependencyHandler |
| .getDependencyIdentifier(dependency) + " have inconsistent parameters"); |
| } |
| } |
| } |
| } |
| } |
| } |
| return type; |
| } |
| |
| private static String extractSpecificationFromConstructor(int index, PojoMetadata manipulation) { |
| // We can write the following instructions as everything was previously checked. |
| String type = manipulation.getConstructors()[0].getMethodArguments()[index]; |
| if (type.endsWith("[]")) { |
| return type.substring(0, type.length() - 2); |
| } |
| if (AggregateDependencyInjectionType.AGGREGATE_TYPES.contains(type)) { |
| return null; // It's an aggregate |
| } |
| return type; |
| } |
| |
| /** |
| * Extracts the service specification from the field. |
| * When this method is called, we know that the field is containing in the component class. |
| * @param field the field |
| * @param manipulation the manipulation metadata |
| * @return the service specification, or {@code null} if is cannot be extracted. |
| */ |
| private static String extractSpecificationFromField(String field, PojoMetadata manipulation) { |
| FieldMetadata metadata = manipulation.getField(field); |
| if (metadata.getFieldType().endsWith("[]")) { |
| return metadata.getFieldType().substring(0, metadata.getFieldType().length() - 2); |
| } |
| if (AggregateDependencyInjectionType.AGGREGATE_TYPES.contains(metadata.getFieldType())) { |
| return null; // It's an aggregate |
| } |
| return metadata.getFieldType(); |
| } |
| |
| /** |
| * Sets the dependency specification. If the dependency has already a specification set, |
| * throw an error if the current specification and the given one are not equal. |
| * @param dep the dependency |
| * @param className the service specification |
| * @throws ConfigurationException if the given specification is not loadable or if the dependency has already a |
| * specification set that is not the given one. |
| */ |
| private static void setSpecification(Dependency dep, String className) throws ConfigurationException { |
| if (dep.getSpecification() != null && ! dep.getSpecification().getName().equals(className)) { |
| throw new ConfigurationException("Inconsistent service specification for " + DependencyHandler |
| .getDependencyIdentifier(dep) + " - reason: mismatch between the current specification (" + dep |
| .getSpecification().getName() + ") and the discovered specification (" + className + ")"); |
| } else if (dep.getSpecification() == null) { |
| // Set the specification |
| try { |
| dep.setSpecification(dep.getBundleContext().getBundle().loadClass(className)); |
| } catch (ClassNotFoundException e) { |
| throw new ConfigurationException("Cannot set the service specification of " + DependencyHandler |
| .getDependencyIdentifier(dep) + " - reason: the class " + className + " cannot be loaded from" + |
| " the bundle " + dep.getBundleContext().getBundle().getBundleId(), e); |
| } |
| } |
| } |
| |
| } |
