yang/yang-binding/src/main/java/org/opendaylight/yangtools/yang/binding/util/BindingReflections.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.yang.binding.util;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11 import static com.google.common.base.Preconditions.checkState;
  12
  13 import java.lang.reflect.Field;
  14 import java.lang.reflect.InvocationTargetException;
  15 import java.lang.reflect.Method;
  16 import java.lang.reflect.Type;
  17 import java.util.LinkedList;
  18 import java.util.List;
  19 import java.util.ServiceLoader;
  20 import java.util.concurrent.Callable;
  21 import java.util.concurrent.Future;
  22 import java.util.concurrent.TimeUnit;
  23 import java.util.regex.Matcher;
  24 import java.util.regex.Pattern;
  25
  26 import org.opendaylight.yangtools.yang.binding.Augmentable;
  27 import org.opendaylight.yangtools.yang.binding.Augmentation;
  28 import org.opendaylight.yangtools.yang.binding.BaseIdentity;
  29 import org.opendaylight.yangtools.yang.binding.BindingMapping;
  30 import org.opendaylight.yangtools.yang.binding.ChildOf;
  31 import org.opendaylight.yangtools.yang.binding.DataContainer;
  32 import org.opendaylight.yangtools.yang.binding.DataObject;
  33 import org.opendaylight.yangtools.yang.binding.Notification;
  34 import org.opendaylight.yangtools.yang.binding.RpcService;
  35 import org.opendaylight.yangtools.yang.binding.YangModelBindingProvider;
  36 import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
  37 import org.opendaylight.yangtools.yang.common.QName;
  38 import org.slf4j.Logger;
  39 import org.slf4j.LoggerFactory;
  40
  41 import com.google.common.base.Optional;
  42 import com.google.common.cache.CacheBuilder;
  43 import com.google.common.cache.CacheLoader;
  44 import com.google.common.cache.LoadingCache;
  45 import com.google.common.collect.ImmutableSet;
  46 import com.google.common.collect.ImmutableSet.Builder;
  47
  48 public class BindingReflections {
  49
  50     private static final long EXPIRATION_TIME = 60;
  51     private static final String ROOT_PACKAGE_PATTERN_STRING = "(org.opendaylight.yang.gen.v1.[a-z0-9_\\.]*\\.rev[0-9][0-9][0-1][0-9][0-3][0-9])";
  52     private static final Pattern ROOT_PACKAGE_PATTERN = Pattern.compile(ROOT_PACKAGE_PATTERN_STRING);
  53     private static final Logger LOG = LoggerFactory.getLogger(BindingReflections.class);
  54
  55     private static final LoadingCache<Class<?>, Optional<QName>> classToQName = CacheBuilder.newBuilder() //
  56             .weakKeys() //
  57             .expireAfterAccess(EXPIRATION_TIME, TimeUnit.SECONDS) //
  58             .build(new ClassToQNameLoader());
  59
  60     /**
  61      *
  62      * @param augmentation
  63      *            {@link Augmentation} subclass for which we want to determine
  64      *            augmentation target.
  65      * @return Augmentation target - class which augmentation provides
  66      *         additional extensions.
  67      */
  68     public static Class<? extends Augmentable<?>> findAugmentationTarget(
  69             final Class<? extends Augmentation<?>> augmentation) {
  70         return ClassLoaderUtils.findFirstGenericArgument(augmentation, Augmentation.class);
  71     }
  72
  73     /**
  74      *
  75      * @param augmentation
  76      *            {@link Augmentation} subclass for which we want to determine
  77      *            augmentation target.
  78      * @return Augmentation target - class which augmentation provides
  79      *         additional extensions.
  80      */
  81     public static Class<?> findHierarchicalParent(final Class<? extends ChildOf<?>> childClass) {
  82         return ClassLoaderUtils.findFirstGenericArgument(childClass, ChildOf.class);
  83     }
  84
  85     /**
  86      *
  87      * @param augmentation
  88      *            {@link Augmentation} subclass for which we want to determine
  89      *            augmentation target.
  90      * @return Augmentation target - class which augmentation provides
  91      *         additional extensions.
  92      */
  93     public static Class<?> findHierarchicalParent(final DataObject childClass) {
  94         if (childClass instanceof ChildOf) {
  95             return ClassLoaderUtils.findFirstGenericArgument(childClass.getImplementedInterface(), ChildOf.class);
  96         }
  97         return null;
  98     }
  99
 100     /**
 101      * Returns a QName associated to supplied type
 102      *
 103      * @param dataType
 104      * @return QName associated to supplied dataType. If dataType is
 105      *         Augmentation method does not return canonical QName, but QName
 106      *         with correct namespace revision, but virtual local name, since
 107      *         augmentations do not have name.
 108      */
 109     public static final QName findQName(final Class<?> dataType) {
 110         return classToQName.getUnchecked(dataType).orNull();
 111     }
 112
 113     private static class ClassToQNameLoader extends CacheLoader<Class<?>, Optional<QName>> {
 114
 115         @Override
 116         public Optional<QName> load(final Class<?> key) throws Exception {
 117             try {
 118                 Field field = key.getField(BindingMapping.QNAME_STATIC_FIELD_NAME);
 119                 Object obj = field.get(null);
 120                 if (obj instanceof QName) {
 121                     return Optional.of((QName) obj);
 122                 }
 123             } catch (NoSuchFieldException e) {
 124                 if (Augmentation.class.isAssignableFrom(key)) {
 125                     YangModuleInfo moduleInfo = getModuleInfo(key);
 126                     return Optional.of(QName.create(moduleInfo.getNamespace(), moduleInfo.getRevision(),
 127                             moduleInfo.getName()));
 128                 }
 129             } catch (SecurityException | IllegalArgumentException | IllegalAccessException e) {
 130                 // NOOP
 131             }
 132             return Optional.absent();
 133         }
 134     }
 135
 136     public static boolean isRpcMethod(final Method possibleMethod) {
 137         return possibleMethod != null && RpcService.class.isAssignableFrom(possibleMethod.getDeclaringClass())
 138                 && Future.class.isAssignableFrom(possibleMethod.getReturnType())
 139                 && possibleMethod.getParameterTypes().length <= 1;
 140     }
 141
 142     @SuppressWarnings("rawtypes")
 143     public static Optional<Class<?>> resolveRpcOutputClass(final Method targetMethod) {
 144         checkState(isRpcMethod(targetMethod), "Supplied method is not Rpc invocation method");
 145         Type futureType = targetMethod.getGenericReturnType();
 146         Type rpcResultType = ClassLoaderUtils.getFirstGenericParameter(futureType);
 147         Type rpcResultArgument = ClassLoaderUtils.getFirstGenericParameter(rpcResultType);
 148         if (rpcResultArgument instanceof Class && !Void.class.equals(rpcResultArgument)) {
 149             return Optional.<Class<?>> of((Class) rpcResultArgument);
 150         }
 151         return Optional.absent();
 152     }
 153
 154     @SuppressWarnings("unchecked")
 155     public static Optional<Class<? extends DataContainer>> resolveRpcInputClass(final Method targetMethod) {
 156         @SuppressWarnings("rawtypes")
 157         Class[] types = targetMethod.getParameterTypes();
 158         if (types.length == 0) {
 159             return Optional.absent();
 160         }
 161         if (types.length == 1) {
 162             return Optional.<Class<? extends DataContainer>> of(types[0]);
 163         }
 164         throw new IllegalArgumentException("Method has 2 or more arguments.");
 165     }
 166
 167     public static QName getQName(final Class<? extends BaseIdentity> context) {
 168         return findQName(context);
 169     }
 170
 171     public static boolean isAugmentationChild(final Class<?> clazz) {
 172         // FIXME: Current resolver could be still confused when
 173         // child node was added by grouping
 174         checkArgument(clazz != null);
 175
 176         @SuppressWarnings({ "rawtypes", "unchecked" })
 177         Class<?> parent = findHierarchicalParent((Class) clazz);
 178         if (parent == null) {
 179             LOG.debug("Did not find a parent for class {}", clazz);
 180             return false;
 181         }
 182
 183         String clazzModelPackage = getModelRootPackageName(clazz.getPackage());
 184         String parentModelPackage = getModelRootPackageName(parent.getPackage());
 185
 186         return !clazzModelPackage.equals(parentModelPackage);
 187     }
 188
 189     public static String getModelRootPackageName(final Package pkg) {
 190         return getModelRootPackageName(pkg.getName());
 191     }
 192
 193     public static String getModelRootPackageName(final String name) {
 194         checkArgument(name != null, "Package name should not be null.");
 195         checkArgument(name.startsWith(BindingMapping.PACKAGE_PREFIX), "Package name not starting with %s, is: %s",
 196                 BindingMapping.PACKAGE_PREFIX, name);
 197         Matcher match = ROOT_PACKAGE_PATTERN.matcher(name);
 198         checkArgument(match.find(), "Package name '%s' does not match required pattern '%s'", name,
 199                 ROOT_PACKAGE_PATTERN_STRING);
 200         return match.group(0);
 201     }
 202
 203     public static YangModuleInfo getModuleInfo(final Class<?> cls) throws Exception {
 204         checkArgument(cls != null);
 205         String packageName = getModelRootPackageName(cls.getPackage());
 206         final String potentialClassName = getModuleInfoClassName(packageName);
 207         return ClassLoaderUtils.withClassLoader(cls.getClassLoader(), new Callable<YangModuleInfo>() {
 208             @Override
 209             public YangModuleInfo call() throws ClassNotFoundException, IllegalAccessException,
 210                     IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
 211                 Class<?> moduleInfoClass = Thread.currentThread().getContextClassLoader().loadClass(potentialClassName);
 212                 return (YangModuleInfo) moduleInfoClass.getMethod("getInstance").invoke(null);
 213             }
 214         });
 215     }
 216
 217     public static String getModuleInfoClassName(final String packageName) {
 218         return packageName + "." + BindingMapping.MODULE_INFO_CLASS_NAME;
 219     }
 220
 221     public static boolean isBindingClass(final Class<?> cls) {
 222         if (DataContainer.class.isAssignableFrom(cls) || Augmentation.class.isAssignableFrom(cls)) {
 223             return true;
 224         }
 225         return (cls.getName().startsWith(BindingMapping.PACKAGE_PREFIX));
 226     }
 227
 228     public static boolean isNotificationCallback(final Method method) {
 229         checkArgument(method != null);
 230         if (method.getName().startsWith("on") && method.getParameterTypes().length == 1) {
 231             Class<?> potentialNotification = method.getParameterTypes()[0];
 232             if (isNotification(potentialNotification)
 233                     && method.getName().equals("on" + potentialNotification.getSimpleName())) {
 234                 return true;
 235             }
 236         }
 237         return false;
 238     }
 239
 240     public static boolean isNotification(final Class<?> potentialNotification) {
 241         checkArgument(potentialNotification != null);
 242         return Notification.class.isAssignableFrom(potentialNotification);
 243     }
 244
 245     public static ImmutableSet<YangModuleInfo> loadModuleInfos() {
 246         return loadModuleInfos(Thread.currentThread().getContextClassLoader());
 247     }
 248
 249     public static ImmutableSet<YangModuleInfo> loadModuleInfos(final ClassLoader loader) {
 250         Builder<YangModuleInfo> moduleInfoSet = ImmutableSet.<YangModuleInfo> builder();
 251         ServiceLoader<YangModelBindingProvider> serviceLoader = ServiceLoader.load(YangModelBindingProvider.class,
 252                 loader);
 253         for (YangModelBindingProvider bindingProvider : serviceLoader) {
 254             YangModuleInfo moduleInfo = bindingProvider.getModuleInfo();
 255             checkState(moduleInfo != null, "Module Info for %s is not available.", bindingProvider.getClass());
 256             collectYangModuleInfo(bindingProvider.getModuleInfo(), moduleInfoSet);
 257         }
 258         return moduleInfoSet.build();
 259     }
 260
 261     private static void collectYangModuleInfo(final YangModuleInfo moduleInfo,
 262             final Builder<YangModuleInfo> moduleInfoSet) {
 263         moduleInfoSet.add(moduleInfo);
 264         for (YangModuleInfo dependency : moduleInfo.getImportedModules()) {
 265             collectYangModuleInfo(dependency, moduleInfoSet);
 266         }
 267     }
 268
 269     public static boolean isRpcType(final Class<? extends DataObject> targetType) {
 270         return DataContainer.class.isAssignableFrom(targetType) //
 271                 && !ChildOf.class.isAssignableFrom(targetType) //
 272                 && !Notification.class.isAssignableFrom(targetType) //
 273                 && (targetType.getName().endsWith("Input") || targetType.getName().endsWith("Output"));
 274     }
 275
 276     /**
 277      *
 278      * Scans supplied class and returns an iterable of all data children classes.
 279      *
 280      * @param type YANG Modeled Entity derived from DataContainer
 281      * @return Iterable of all data children, which have YANG modeled entity
 282      */
 283     @SuppressWarnings("unchecked")
 284     public static Iterable<Class<? extends DataObject>> getChildrenClasses(final Class<? extends DataContainer> type) {
 285         checkArgument(type != null, "Target type must not be null");
 286         checkArgument(DataContainer.class.isAssignableFrom(type), "Supplied type must be derived from DataContainer");
 287         List<Class<? extends DataObject>> ret = new LinkedList<>();
 288         for (Method method : type.getMethods()) {
 289             Optional<Class<? extends DataContainer>> entity = getYangModeledReturnType(method);
 290             if (entity.isPresent()) {
 291                 ret.add((Class<? extends DataObject>) entity.get());
 292             }
 293         }
 294         return ret;
 295     }
 296
 297     @SuppressWarnings("unchecked")
 298     private static Optional<Class<? extends DataContainer>> getYangModeledReturnType(final Method method) {
 299         if (method.getName().equals("getClass") || !method.getName().startsWith("get")
 300                 || method.getParameterTypes().length > 0) {
 301             return Optional.absent();
 302         }
 303
 304         @SuppressWarnings("rawtypes")
 305         Class returnType = method.getReturnType();
 306         if (DataContainer.class.isAssignableFrom(returnType)) {
 307             return Optional.<Class<? extends DataContainer>> of(returnType);
 308         } else if (List.class.isAssignableFrom(returnType)) {
 309             try {
 310                 return ClassLoaderUtils.withClassLoader(method.getDeclaringClass().getClassLoader(),
 311                         new Callable<Optional<Class<? extends DataContainer>>>() {
 312                             @SuppressWarnings("rawtypes")
 313                             @Override
 314                             public Optional<Class<? extends DataContainer>> call() {
 315                                 Type listResult = ClassLoaderUtils.getFirstGenericParameter(method
 316                                         .getGenericReturnType());
 317                                 if (listResult instanceof Class
 318                                         && DataContainer.class.isAssignableFrom((Class) listResult)) {
 319                                     return Optional.<Class<? extends DataContainer>> of((Class) listResult);
 320                                 }
 321                                 return Optional.absent();
 322                             }
 323
 324                         });
 325             } catch (Exception e) {
 326                 LOG.debug("Unable to find YANG modeled return type for {}", method, e);
 327             }
 328         }
 329         return Optional.absent();
 330     }
 331
 332 }