X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-binding%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fbinding%2Futil%2FBindingReflections.java;h=3f4c85e4b2a9b2aecc1c83a029be47ef227c1f62;hb=98dfd2809c37a392fc0981a8459b63816a3aaf4f;hp=5e1494c55e7d27b6a620ccba5fe9aab318560448;hpb=eddf6c8705762efa0b0dad76684f2b5ffe11b606;p=mdsal.git diff --git a/yang/yang-binding/src/main/java/org/opendaylight/yangtools/yang/binding/util/BindingReflections.java b/yang/yang-binding/src/main/java/org/opendaylight/yangtools/yang/binding/util/BindingReflections.java index 5e1494c55e..3f4c85e4b2 100644 --- a/yang/yang-binding/src/main/java/org/opendaylight/yangtools/yang/binding/util/BindingReflections.java +++ b/yang/yang-binding/src/main/java/org/opendaylight/yangtools/yang/binding/util/BindingReflections.java @@ -9,20 +9,31 @@ package org.opendaylight.yangtools.yang.binding.util; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkState; -import static org.opendaylight.yangtools.concepts.util.ClassLoaderUtils.withClassLoader; +import com.google.common.base.Optional; +import com.google.common.cache.CacheBuilder; +import com.google.common.cache.CacheLoader; +import com.google.common.cache.LoadingCache; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.ImmutableSet.Builder; +import com.google.common.collect.Sets; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Type; +import java.net.URI; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; import java.util.ServiceLoader; import java.util.concurrent.Callable; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.regex.Matcher; import java.util.regex.Pattern; - -import org.opendaylight.yangtools.concepts.util.ClassLoaderUtils; +import org.opendaylight.yangtools.util.ClassLoaderUtils; import org.opendaylight.yangtools.yang.binding.Augmentable; import org.opendaylight.yangtools.yang.binding.Augmentation; import org.opendaylight.yangtools.yang.binding.BaseIdentity; @@ -35,17 +46,10 @@ import org.opendaylight.yangtools.yang.binding.RpcService; import org.opendaylight.yangtools.yang.binding.YangModelBindingProvider; import org.opendaylight.yangtools.yang.binding.YangModuleInfo; import org.opendaylight.yangtools.yang.common.QName; - +import org.opendaylight.yangtools.yang.common.QNameModule; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.google.common.base.Optional; -import com.google.common.cache.CacheBuilder; -import com.google.common.cache.CacheLoader; -import com.google.common.cache.LoadingCache; -import com.google.common.collect.ImmutableSet; -import com.google.common.collect.ImmutableSet.Builder; - public class BindingReflections { private static final long EXPIRATION_TIME = 60; @@ -58,7 +62,15 @@ public class BindingReflections { .expireAfterAccess(EXPIRATION_TIME, TimeUnit.SECONDS) // .build(new ClassToQNameLoader()); + private BindingReflections() { + throw new UnsupportedOperationException("Utility class."); + } + /** + * Find augmentation target class from concrete Augmentation class + * + * This method uses first generic argument of implemented + * {@link Augmentation} interface. * * @param augmentation * {@link Augmentation} subclass for which we want to determine @@ -72,28 +84,33 @@ public class BindingReflections { } /** + * Find data hierarchy parent from concrete Data class * - * @param augmentation - * {@link Augmentation} subclass for which we want to determine - * augmentation target. - * @return Augmentation target - class which augmentation provides - * additional extensions. + * This method uses first generic argument of implemented {@link ChildOf} + * interface. + * + * @param childClass + * child class for which we want to find the parent class. + * @return Parent class, e.g. class of which the childClass is ChildOf. */ public static Class findHierarchicalParent(final Class> childClass) { return ClassLoaderUtils.findFirstGenericArgument(childClass, ChildOf.class); } /** + * Find data hierarchy parent from concrete Data class * - * @param augmentation - * {@link Augmentation} subclass for which we want to determine - * augmentation target. - * @return Augmentation target - class which augmentation provides - * additional extensions. + * This method is shorthand which gets DataObject class by invoking + * {@link DataObject#getImplementedInterface()} and uses + * {@link #findHierarchicalParent(Class)}. + * + * @param child + * Child object for which the parent needs to be located. + * @return Parent class, or null if a parent is not found. */ - public static Class findHierarchicalParent(final DataObject childClass) { - if (childClass instanceof ChildOf) { - return ClassLoaderUtils.findFirstGenericArgument(childClass.getImplementedInterface(), ChildOf.class); + public static Class findHierarchicalParent(final DataObject child) { + if (child instanceof ChildOf) { + return ClassLoaderUtils.findFirstGenericArgument(child.getImplementedInterface(), ChildOf.class); } return null; } @@ -102,42 +119,41 @@ public class BindingReflections { * Returns a QName associated to supplied type * * @param dataType - * @return QName associated to supplied dataType. If dataType is Augmentation - * method does not return canonical QName, but QName with correct namespace - * revision, but virtual local name, since augmentations do not have name. + * @return QName associated to supplied dataType. If dataType is + * Augmentation method does not return canonical QName, but QName + * with correct namespace revision, but virtual local name, since + * augmentations do not have name. + * + * May return null if QName is not present. */ public static final QName findQName(final Class dataType) { return classToQName.getUnchecked(dataType).orNull(); } - private static class ClassToQNameLoader extends CacheLoader, Optional> { - - @Override - public Optional load(final Class key) throws Exception { - try { - Field field = key.getField(BindingMapping.QNAME_STATIC_FIELD_NAME); - Object obj = field.get(null); - if (obj instanceof QName) { - return Optional.of((QName) obj); - } - } catch (NoSuchFieldException e) { - if(Augmentation.class.isAssignableFrom(key)) { - YangModuleInfo moduleInfo = getModuleInfo(key); - return Optional.of(QName.create(moduleInfo.getNamespace(), moduleInfo.getRevision(), moduleInfo.getName())); - } - } catch (SecurityException | IllegalArgumentException | IllegalAccessException e) { - // NOOP - } - return Optional.absent(); - } - } - + /** + * Checks if method is RPC invocation + * + * + * + * @param possibleMethod + * Method to check + * @return true if method is RPC invocation, false otherwise. + */ public static boolean isRpcMethod(final Method possibleMethod) { return possibleMethod != null && RpcService.class.isAssignableFrom(possibleMethod.getDeclaringClass()) && Future.class.isAssignableFrom(possibleMethod.getReturnType()) && possibleMethod.getParameterTypes().length <= 1; } + /** + * + * Extracts Output class for RPC method + * + * @param targetMethod + * method to scan + * @return Optional.absent() if result type could not be get, or return type + * is Void. + */ @SuppressWarnings("rawtypes") public static Optional> resolveRpcOutputClass(final Method targetMethod) { checkState(isRpcMethod(targetMethod), "Supplied method is not Rpc invocation method"); @@ -150,6 +166,14 @@ public class BindingReflections { return Optional.absent(); } + /** + * + * Extracts input class for RPC method + * + * @param targetMethod + * method to scan + * @return Optional.absent() if rpc has no input, Rpc input type otherwise. + */ @SuppressWarnings("unchecked") public static Optional> resolveRpcInputClass(final Method targetMethod) { @SuppressWarnings("rawtypes") @@ -167,6 +191,14 @@ public class BindingReflections { return findQName(context); } + /** + * + * Checks if class is child of augmentation. + * + * + * @param clazz + * @return + */ public static boolean isAugmentationChild(final Class clazz) { // FIXME: Current resolver could be still confused when // child node was added by grouping @@ -185,27 +217,68 @@ public class BindingReflections { return !clazzModelPackage.equals(parentModelPackage); } + /** + * Returns root package name for suplied package. + * + * @param pkg + * Package for which find model root package. + * @return Package of model root. + */ public static String getModelRootPackageName(final Package pkg) { return getModelRootPackageName(pkg.getName()); } + /** + * Returns root package name for supplied package name. + * + * @param name + * Package for which find model root package. + * @return Package of model root. + */ public static String getModelRootPackageName(final String name) { checkArgument(name != null, "Package name should not be null."); checkArgument(name.startsWith(BindingMapping.PACKAGE_PREFIX), "Package name not starting with %s, is: %s", BindingMapping.PACKAGE_PREFIX, name); Matcher match = ROOT_PACKAGE_PATTERN.matcher(name); - checkArgument(match.find(),"Package name '%s' does not match required pattern '%s'",name,ROOT_PACKAGE_PATTERN_STRING); + checkArgument(match.find(), "Package name '%s' does not match required pattern '%s'", name, + ROOT_PACKAGE_PATTERN_STRING); return match.group(0); } + public static final QNameModule getQNameModule(Class clz) { + if(DataContainer.class.isAssignableFrom(clz) || BaseIdentity.class.isAssignableFrom(clz)) { + return findQName(clz).getModule(); + } + try { + YangModuleInfo modInfo = BindingReflections.getModuleInfo(clz); + return getQNameModule(modInfo); + } catch (Exception e) { + throw new IllegalStateException("Unable to get QName of defining model.", e); + } + } + + public static final QNameModule getQNameModule(YangModuleInfo modInfo) { + return QNameModule.create(URI.create(modInfo.getNamespace()), QName.parseRevision(modInfo.getRevision())); + } + + /** + * + * Returns instance of {@link YangModuleInfo} of declaring model for + * specific class. + * + * @param cls + * @return Instance of {@link YangModuleInfo} associated with model, from + * which this class was derived. + * @throws Exception + */ public static YangModuleInfo getModuleInfo(final Class cls) throws Exception { checkArgument(cls != null); String packageName = getModelRootPackageName(cls.getPackage()); final String potentialClassName = getModuleInfoClassName(packageName); - return withClassLoader(cls.getClassLoader(), new Callable() { - + return ClassLoaderUtils.withClassLoader(cls.getClassLoader(), new Callable() { @Override - public YangModuleInfo call() throws ClassNotFoundException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException { + public YangModuleInfo call() throws ClassNotFoundException, IllegalAccessException, + IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException { Class moduleInfoClass = Thread.currentThread().getContextClassLoader().loadClass(potentialClassName); return (YangModuleInfo) moduleInfoClass.getMethod("getInstance").invoke(null); } @@ -216,6 +289,14 @@ public class BindingReflections { return packageName + "." + BindingMapping.MODULE_INFO_CLASS_NAME; } + /** + * + * Check if supplied class is derived from YANG model. + * + * @param cls + * Class to check + * @return true if class is derived from YANG model. + */ public static boolean isBindingClass(final Class cls) { if (DataContainer.class.isAssignableFrom(cls) || Augmentation.class.isAssignableFrom(cls)) { return true; @@ -223,6 +304,13 @@ public class BindingReflections { return (cls.getName().startsWith(BindingMapping.PACKAGE_PREFIX)); } + /** + * + * Checks if supplied method is callback for notifications. + * + * @param method + * @return true if method is notification callback. + */ public static boolean isNotificationCallback(final Method method) { checkArgument(method != null); if (method.getName().startsWith("on") && method.getParameterTypes().length == 1) { @@ -235,38 +323,349 @@ public class BindingReflections { return false; } + /** + * + * Checks is supplied class is Notification. + * + * @param potentialNotification + * @return + */ public static boolean isNotification(final Class potentialNotification) { - checkArgument(potentialNotification != null); + checkArgument(potentialNotification != null, "potentialNotification must not be null."); return Notification.class.isAssignableFrom(potentialNotification); } + /** + * + * Loads {@link YangModuleInfo} infos available on current classloader. + * + * This method is shorthand for {@link #loadModuleInfos(ClassLoader)} with + * {@link Thread#getContextClassLoader()} for current thread. + * + * @return Set of {@link YangModuleInfo} available for current classloader. + */ public static ImmutableSet loadModuleInfos() { return loadModuleInfos(Thread.currentThread().getContextClassLoader()); } + /** + * + * Loads {@link YangModuleInfo} infos available on supplied classloader. + * + * {@link YangModuleInfo} are discovered using {@link ServiceLoader} for + * {@link YangModelBindingProvider}. {@link YangModelBindingProvider} are + * simple classes which holds only pointers to actual instance + * {@link YangModuleInfo}. + * + * When {@link YangModuleInfo} is available, all dependencies are + * recursivelly collected into returning set by collecting results of + * {@link YangModuleInfo#getImportedModules()}. + * + * + * @param loader + * Classloader for which {@link YangModuleInfo} should be + * retrieved. + * @return Set of {@link YangModuleInfo} available for supplied classloader. + */ public static ImmutableSet loadModuleInfos(final ClassLoader loader) { - Builder moduleInfoSet = ImmutableSet.builder(); - ServiceLoader serviceLoader = ServiceLoader.load(YangModelBindingProvider.class, loader); - for(YangModelBindingProvider bindingProvider : serviceLoader) { + Builder moduleInfoSet = ImmutableSet. builder(); + ServiceLoader serviceLoader = ServiceLoader.load(YangModelBindingProvider.class, + loader); + for (YangModelBindingProvider bindingProvider : serviceLoader) { YangModuleInfo moduleInfo = bindingProvider.getModuleInfo(); - checkState(moduleInfo != null, "Module Info for %s is not available.",bindingProvider.getClass()); - collectYangModuleInfo(bindingProvider.getModuleInfo(),moduleInfoSet); + checkState(moduleInfo != null, "Module Info for %s is not available.", bindingProvider.getClass()); + collectYangModuleInfo(bindingProvider.getModuleInfo(), moduleInfoSet); } - return moduleInfoSet.build(); + return moduleInfoSet.build(); } - private static void collectYangModuleInfo(final YangModuleInfo moduleInfo, final Builder moduleInfoSet) { + private static void collectYangModuleInfo(final YangModuleInfo moduleInfo, + final Builder moduleInfoSet) { moduleInfoSet.add(moduleInfo); - for(YangModuleInfo dependency : moduleInfo.getImportedModules()) { + for (YangModuleInfo dependency : moduleInfo.getImportedModules()) { collectYangModuleInfo(dependency, moduleInfoSet); } } + /** + * + * Checks if supplied class represents RPC Input / RPC Output. + * + * @param targetType + * Class to be checked + * @return true if class represents RPC Input or RPC Output class. + */ public static boolean isRpcType(final Class targetType) { - return DataContainer.class.isAssignableFrom(targetType) // + return DataContainer.class.isAssignableFrom(targetType) // && !ChildOf.class.isAssignableFrom(targetType) // && !Notification.class.isAssignableFrom(targetType) // && (targetType.getName().endsWith("Input") || targetType.getName().endsWith("Output")); } + /** + * + * Scans supplied class and returns an iterable of all data children + * classes. + * + * @param type + * YANG Modeled Entity derived from DataContainer + * @return Iterable of all data children, which have YANG modeled entity + */ + @SuppressWarnings("unchecked") + public static Iterable> getChildrenClasses(final Class type) { + checkArgument(type != null, "Target type must not be null"); + checkArgument(DataContainer.class.isAssignableFrom(type), "Supplied type must be derived from DataContainer"); + List> ret = new LinkedList<>(); + for (Method method : type.getMethods()) { + Optional> entity = getYangModeledReturnType(method); + if (entity.isPresent()) { + ret.add((Class) entity.get()); + } + } + return ret; + } + + /** + * + * Scans supplied class and returns an iterable of all data children + * classes. + * + * @param type + * YANG Modeled Entity derived from DataContainer + * @return Iterable of all data children, which have YANG modeled entity + */ + public static Map, Method> getChildrenClassToMethod(final Class type) { + checkArgument(type != null, "Target type must not be null"); + checkArgument(DataContainer.class.isAssignableFrom(type), "Supplied type must be derived from DataContainer"); + Map, Method> ret = new HashMap<>(); + for (Method method : type.getMethods()) { + Optional> entity = getYangModeledReturnType(method); + if (entity.isPresent()) { + ret.put(entity.get(), method); + } + } + return ret; + } + + @SuppressWarnings("unchecked") + private static Optional> getYangModeledReturnType(final Method method) { + if (method.getName().equals("getClass") || !method.getName().startsWith("get") + || method.getParameterTypes().length > 0) { + return Optional.absent(); + } + + @SuppressWarnings("rawtypes") + Class returnType = method.getReturnType(); + if (DataContainer.class.isAssignableFrom(returnType)) { + return Optional.> of(returnType); + } else if (List.class.isAssignableFrom(returnType)) { + try { + return ClassLoaderUtils.withClassLoader(method.getDeclaringClass().getClassLoader(), + new Callable>>() { + @SuppressWarnings("rawtypes") + @Override + public Optional> call() { + Type listResult = ClassLoaderUtils.getFirstGenericParameter(method + .getGenericReturnType()); + if (listResult instanceof Class + && DataContainer.class.isAssignableFrom((Class) listResult)) { + return Optional.> of((Class) listResult); + } + return Optional.absent(); + } + + }); + } catch (Exception e) { + /* + * + * It is safe to log this this exception on debug, since this + * method should not fail. Only failures are possible if the + * runtime / backing. + */ + LOG.debug("Unable to find YANG modeled return type for {}", method, e); + } + } + return Optional.absent(); + } + + private static class ClassToQNameLoader extends CacheLoader, Optional> { + + @Override + public Optional load(final Class key) throws Exception { + return resolveQNameNoCache(key); + } + } + + /** + * + * Tries to resolve QName for supplied class. + * + * Looks up for static field with name from constant + * {@link BindingMapping#QNAME_STATIC_FIELD_NAME} and returns value if + * present. + * + * If field is not present uses {@link #computeQName(Class)} to compute + * QName for missing types. + * + * @param key + * @return + */ + private static Optional resolveQNameNoCache(final Class key) { + try { + Field field = key.getField(BindingMapping.QNAME_STATIC_FIELD_NAME); + Object obj = field.get(null); + if (obj instanceof QName) { + return Optional.of((QName) obj); + } + + } catch (NoSuchFieldException e) { + return Optional.of(computeQName(key)); + + } catch (SecurityException | IllegalArgumentException | IllegalAccessException e) { + /* + * + * It is safe to log this this exception on debug, since this method + * should not fail. Only failures are possible if the runtime / + * backing. + */ + LOG.debug("Unexpected exception during extracting QName for {}", key, e); + } + return Optional.absent(); + } + + /** + * Computes QName for supplied class + * + * Namespace and revision are same as {@link YangModuleInfo} associated with + * supplied class. + *

+ * If class is + *

    + *
  • rpc input: local name is "input". + *
  • rpc output: local name is "output". + *
  • augmentation: local name is "module name". + *
+ * + * There is also fallback, if it is not possible to compute QName using + * following algorithm returns module QName. + * + * FIXME: Extend this algorithm to also provide QName for YANG modeled + * simple types. + * + * @throws IllegalStateException + * If YangModuleInfo could not be resolved + * @throws IllegalArgumentException + * If supplied class was not derived from YANG model. + * + */ + @SuppressWarnings({ "rawtypes", "unchecked" }) + private static QName computeQName(final Class key) { + if (isBindingClass(key)) { + YangModuleInfo moduleInfo; + try { + moduleInfo = getModuleInfo(key); + } catch (Exception e) { + throw new IllegalStateException("Unable to get QName for " + key + ". YangModuleInfo was not found.", e); + } + final QName module = getModuleQName(moduleInfo); + if (Augmentation.class.isAssignableFrom(key)) { + return module; + } else if (isRpcType(key)) { + final String className = key.getSimpleName(); + if (className.endsWith(BindingMapping.RPC_OUTPUT_SUFFIX)) { + return QName.create(module, "output"); + } else { + return QName.create(module, "input"); + } + } + /* + * Fallback for Binding types which fo not have QNAME field + */ + return module; + } else { + throw new IllegalArgumentException("Supplied class " + key + "is not derived from YANG."); + } + } + + /** + * Given a {@link YangModuleInfo}, create a QName representing it. The QName + * is formed by reusing the module's namespace and revision using the + * module's name as the QName's local name. + * + * @param moduleInfo + * module information + * @return QName representing the module + */ + public static QName getModuleQName(final YangModuleInfo moduleInfo) { + checkArgument(moduleInfo != null, "moduleInfo must not be null."); + return QName.create(moduleInfo.getNamespace(), moduleInfo.getRevision(), moduleInfo.getName()); + } + + /** + * Extracts augmentation from Binding DTO field using reflection + * + * @param input + * Instance of DataObject which is augmentable and may contain + * augmentation + * @return Map of augmentations if read was successful, otherwise empty map. + */ + public static Map>, Augmentation> getAugmentations(final Augmentable input) { + return AugmentationFieldGetter.getGetter(input.getClass()).getAugmentations(input); + } + + /** + * + * Determines if two augmentation classes or case classes represents same + * data. + *

+ * Two augmentations or cases could be substituted only if and if: + *

    + *
  • Both implements same interfaces
    • + *
  • Both have same children
    • + *
  • If augmentations: Both have same augmentation target class. Target + * class was generated for data node in grouping.
    • + *
  • If cases: Both are from same choice. Choice class was generated for + * data node in grouping.
    • + *
+ *

+ * Explanation: Binding Specification reuses classes generated for + * groupings as part of normal data tree, this classes from grouping could + * be used at various locations and user may not be aware of it and may use + * incorrect case or augmentation in particular subtree (via copy + * constructors, etc). + * + * @param potential + * Class which is potential substition + * @param target + * Class which should be used at particular subtree + * @return true if and only if classes represents same data. + */ + @SuppressWarnings({ "rawtypes", "unchecked" }) + public static boolean isSubstitutionFor(final Class potential, final Class target) { + HashSet subImplemented = Sets.newHashSet(potential.getInterfaces()); + HashSet targetImplemented = Sets.newHashSet(target.getInterfaces()); + if (!subImplemented.equals(targetImplemented)) { + return false; + } + if (Augmentation.class.isAssignableFrom(potential) + && !BindingReflections.findAugmentationTarget(potential).equals( + BindingReflections.findAugmentationTarget(target))) { + return false; + } + for (Method potentialMethod : potential.getMethods()) { + try { + Method targetMethod = target.getMethod(potentialMethod.getName(), potentialMethod.getParameterTypes()); + if (!potentialMethod.getReturnType().equals(targetMethod.getReturnType())) { + return false; + } + } catch (NoSuchMethodException e) { + // Counterpart method is missing, so classes could not be + // substituted. + return false; + } catch (SecurityException e) { + throw new IllegalStateException("Could not compare methods", e); + } + } + return true; + } }