binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/BindingToNormalizedNodeCodec.java

   1 /*
   2  * Copyright (c) 2014 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.mdsal.binding.dom.adapter;
   9
  10 import com.google.common.base.Function;
  11 import com.google.common.base.Optional;
  12 import com.google.common.base.Preconditions;
  13 import com.google.common.cache.CacheBuilder;
  14 import com.google.common.cache.CacheLoader;
  15 import com.google.common.cache.LoadingCache;
  16 import com.google.common.collect.ImmutableBiMap;
  17 import java.lang.reflect.Method;
  18 import java.net.URI;
  19 import java.util.AbstractMap.SimpleEntry;
  20 import java.util.Collection;
  21 import java.util.Date;
  22 import java.util.HashSet;
  23 import java.util.Map;
  24 import java.util.Map.Entry;
  25 import java.util.Set;
  26 import java.util.concurrent.TimeUnit;
  27 import javax.annotation.Nonnull;
  28 import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
  29 import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
  30 import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeFactory;
  31 import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode;
  32 import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
  33 import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
  34 import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
  35 import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
  36 import org.opendaylight.yangtools.binding.data.codec.impl.BindingNormalizedNodeCodecRegistry;
  37 import org.opendaylight.yangtools.binding.data.codec.impl.MissingSchemaException;
  38 import org.opendaylight.yangtools.yang.binding.BindingMapping;
  39 import org.opendaylight.yangtools.yang.binding.DataContainer;
  40 import org.opendaylight.yangtools.yang.binding.DataObject;
  41 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  42 import org.opendaylight.yangtools.yang.binding.Notification;
  43 import org.opendaylight.yangtools.yang.binding.RpcService;
  44 import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
  45 import org.opendaylight.yangtools.yang.common.QNameModule;
  46 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  47 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  48 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  49 import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
  50 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  51 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  52 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  53 import org.opendaylight.yangtools.yang.model.api.Module;
  54 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  55 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  56 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  57 import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
  58 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  59 import org.slf4j.Logger;
  60 import org.slf4j.LoggerFactory;
  61
  62 public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFactory,
  63         BindingNormalizedNodeSerializer, SchemaContextListener, AutoCloseable {
  64
  65     private static final long WAIT_DURATION_SEC = 5;
  66     private static final Logger LOG = LoggerFactory.getLogger(BindingToNormalizedNodeCodec.class);
  67
  68     private final BindingNormalizedNodeCodecRegistry codecRegistry;
  69
  70     private final GeneratedClassLoadingStrategy classLoadingStrategy;
  71     private final FutureSchema futureSchema;
  72     private final LoadingCache<InstanceIdentifier<?>, YangInstanceIdentifier> iiCache = CacheBuilder.newBuilder()
  73             .softValues().build(new CacheLoader<InstanceIdentifier<?>, YangInstanceIdentifier>() {
  74
  75                 @Override
  76                 public YangInstanceIdentifier load(final InstanceIdentifier<?> key) throws Exception {
  77                     return toYangInstanceIdentifierBlocking(key);
  78                 }
  79
  80             });
  81
  82     private volatile BindingRuntimeContext runtimeContext;
  83
  84     public BindingToNormalizedNodeCodec(final GeneratedClassLoadingStrategy classLoadingStrategy,
  85             final BindingNormalizedNodeCodecRegistry codecRegistry) {
  86         this(classLoadingStrategy,codecRegistry,false);
  87
  88     }
  89
  90     public BindingToNormalizedNodeCodec(final GeneratedClassLoadingStrategy classLoadingStrategy,
  91             final BindingNormalizedNodeCodecRegistry codecRegistry,final boolean waitForSchema) {
  92         this.classLoadingStrategy = Preconditions.checkNotNull(classLoadingStrategy,"classLoadingStrategy");
  93         this.codecRegistry = Preconditions.checkNotNull(codecRegistry,"codecRegistry");
  94         this.futureSchema = waitForSchema ? new FutureSchema(WAIT_DURATION_SEC, TimeUnit.SECONDS) : null;
  95     }
  96
  97     YangInstanceIdentifier toYangInstanceIdentifierBlocking(final InstanceIdentifier<? extends DataObject> binding) {
  98         try {
  99             return codecRegistry.toYangInstanceIdentifier(binding);
 100         } catch (final MissingSchemaException e) {
 101             waitForSchema(decompose(binding),e);
 102             return codecRegistry.toYangInstanceIdentifier(binding);
 103         }
 104     }
 105
 106     /**
 107      * Translates supplied Binding Instance Identifier into NormalizedNode
 108      * instance identifier.
 109      *
 110      * @param binding
 111      *            Binding Instance Identifier
 112      * @return DOM Instance Identifier
 113      * @throws IllegalArgumentException
 114      *             If supplied Instance Identifier is not valid.
 115      */
 116     public YangInstanceIdentifier toNormalized(final InstanceIdentifier<? extends DataObject> binding) {
 117         return codecRegistry.toYangInstanceIdentifier(binding);
 118     }
 119
 120     @Override
 121     public YangInstanceIdentifier toYangInstanceIdentifier(final InstanceIdentifier<?> binding) {
 122         return codecRegistry.toYangInstanceIdentifier(binding);
 123     }
 124
 125
 126     YangInstanceIdentifier toYangInstanceIdentifierCached(final InstanceIdentifier<?> binding) {
 127         return iiCache .getUnchecked(binding);
 128     }
 129
 130     @Override
 131     public <T extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode(
 132             final InstanceIdentifier<T> path, final T data) {
 133         try {
 134             return codecRegistry.toNormalizedNode(path, data);
 135         } catch (final MissingSchemaException e) {
 136             waitForSchema(decompose(path), e);
 137             return codecRegistry.toNormalizedNode(path, data);
 138         }
 139     }
 140
 141     /**
 142      * Converts Binding Map.Entry to DOM Map.Entry.
 143      *
 144      * <p>
 145      * Same as {@link #toNormalizedNode(InstanceIdentifier, DataObject)}.
 146      *
 147      * @param binding Map Entry with InstanceIdentifier as key and DataObject as value.
 148      * @return DOM Map Entry with {@link YangInstanceIdentifier} as key and {@link NormalizedNode}
 149      *         as value.
 150      */
 151     @SuppressWarnings({"unchecked", "rawtypes"})
 152     public Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode(
 153             final Entry<InstanceIdentifier<? extends DataObject>, DataObject> binding) {
 154         return toNormalizedNode((InstanceIdentifier) binding.getKey(),binding.getValue());
 155     }
 156
 157     @Override
 158     public Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final YangInstanceIdentifier path,
 159             final NormalizedNode<?, ?> data) {
 160         return codecRegistry.fromNormalizedNode(path, data);
 161     }
 162
 163     @Override
 164     public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data) {
 165         return codecRegistry.fromNormalizedNodeNotification(path, data);
 166     }
 167
 168     @Override
 169     public DataObject fromNormalizedNodeRpcData(final SchemaPath path, final ContainerNode data) {
 170         return codecRegistry.fromNormalizedNodeRpcData(path, data);
 171     }
 172
 173     @Override
 174     public InstanceIdentifier<?> fromYangInstanceIdentifier(final YangInstanceIdentifier dom) {
 175         return codecRegistry.fromYangInstanceIdentifier(dom);
 176     }
 177
 178     @Override
 179     public ContainerNode toNormalizedNodeNotification(final Notification data) {
 180         return codecRegistry.toNormalizedNodeNotification(data);
 181     }
 182
 183     @Override
 184     public ContainerNode toNormalizedNodeRpcData(final DataContainer data) {
 185         return codecRegistry.toNormalizedNodeRpcData(data);
 186     }
 187
 188     /**
 189      * Returns a Binding-Aware instance identifier from normalized
 190      * instance-identifier if it is possible to create representation.
 191      *
 192      * <p>
 193      * Returns Optional.absent for cases where target is mixin node except
 194      * augmentation.
 195      *
 196      */
 197     public Optional<InstanceIdentifier<? extends DataObject>> toBinding(final YangInstanceIdentifier normalized)
 198                     throws DeserializationException {
 199         try {
 200             return Optional.<InstanceIdentifier<? extends DataObject>>fromNullable(
 201                     codecRegistry.fromYangInstanceIdentifier(normalized));
 202         } catch (final IllegalArgumentException e) {
 203             return Optional.absent();
 204         }
 205     }
 206
 207     public Optional<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> toBinding(
 208             @Nonnull final Entry<YangInstanceIdentifier, ? extends NormalizedNode<?, ?>> normalized)
 209                     throws DeserializationException {
 210         try {
 211             /*
 212              * This cast is required, due to generics behaviour in openjdk / oracle javac.
 213              *
 214              * <p>
 215              * InstanceIdentifier has definition InstanceIdentifier<T extends DataObject>,
 216              * this means '?' is always  <? extends DataObject>. Eclipse compiler
 217              * is able to determine this relationship and treats
 218              * Entry<InstanceIdentifier<?>,DataObject> and Entry<InstanceIdentifier<? extends DataObject,DataObject>
 219              * as assignable. However openjdk / oracle javac treats this two types
 220              * as incompatible and issues a compile error.
 221              *
 222              * <p>
 223              * It is safe to  loose generic information and cast it to other generic signature.
 224              *
 225              */
 226             @SuppressWarnings("unchecked")
 227             final Entry<InstanceIdentifier<? extends DataObject>, DataObject> binding = Entry.class.cast(
 228                     codecRegistry.fromNormalizedNode(normalized.getKey(), normalized.getValue()));
 229             return Optional.fromNullable(binding);
 230         } catch (final IllegalArgumentException e) {
 231             return Optional.absent();
 232         }
 233     }
 234
 235     @Override
 236     public void onGlobalContextUpdated(final SchemaContext arg0) {
 237         runtimeContext = BindingRuntimeContext.create(classLoadingStrategy, arg0);
 238         codecRegistry.onBindingRuntimeContextUpdated(runtimeContext);
 239         if (futureSchema != null) {
 240             futureSchema.onRuntimeContextUpdated(runtimeContext);
 241         }
 242     }
 243
 244     public <T extends DataObject> Function<Optional<NormalizedNode<?, ?>>, Optional<T>>
 245             deserializeFunction(final InstanceIdentifier<T> path) {
 246         return codecRegistry.deserializeFunction(path);
 247     }
 248
 249     public BindingNormalizedNodeCodecRegistry getCodecRegistry() {
 250         return codecRegistry;
 251     }
 252
 253     @Override
 254     public void close() {
 255         // NOOP Intentionally
 256     }
 257
 258     public BindingNormalizedNodeCodecRegistry getCodecFactory() {
 259         return codecRegistry;
 260     }
 261
 262     // FIXME: This should be probably part of Binding Runtime context
 263     public ImmutableBiMap<Method, SchemaPath> getRpcMethodToSchemaPath(final Class<? extends RpcService> key) {
 264         final Module module = getModuleBlocking(key);
 265         final ImmutableBiMap.Builder<Method, SchemaPath> ret = ImmutableBiMap.<Method, SchemaPath>builder();
 266         try {
 267             for (final RpcDefinition rpcDef : module.getRpcs()) {
 268                 final Method method = findRpcMethod(key, rpcDef);
 269                 ret.put(method, rpcDef.getPath());
 270             }
 271         } catch (final NoSuchMethodException e) {
 272             throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e);
 273         }
 274         return ret.build();
 275     }
 276
 277     protected ImmutableBiMap<Method, RpcDefinition> getRpcMethodToSchema(final Class<? extends RpcService> key) {
 278         final Module module = getModuleBlocking(key);
 279         final ImmutableBiMap.Builder<Method, RpcDefinition> ret = ImmutableBiMap.builder();
 280         try {
 281             for (final RpcDefinition rpcDef : module.getRpcs()) {
 282                 final Method method = findRpcMethod(key, rpcDef);
 283                 ret.put(method, rpcDef);
 284             }
 285         } catch (final NoSuchMethodException e) {
 286             throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e);
 287         }
 288         return ret.build();
 289     }
 290
 291     private Module getModuleBlocking(final Class<?> modeledClass) {
 292         final QNameModule moduleName = BindingReflections.getQNameModule(modeledClass);
 293         final URI namespace = moduleName.getNamespace();
 294         final Date revision = moduleName.getRevision();
 295         BindingRuntimeContext localRuntimeContext = runtimeContext;
 296         Module module = localRuntimeContext == null ? null :
 297             localRuntimeContext.getSchemaContext().findModuleByNamespaceAndRevision(namespace, revision);
 298         if (module == null && futureSchema != null && futureSchema.waitForSchema(namespace,revision)) {
 299             localRuntimeContext = runtimeContext;
 300             Preconditions.checkState(localRuntimeContext != null, "BindingRuntimeContext is not available.");
 301             module = localRuntimeContext.getSchemaContext().findModuleByNamespaceAndRevision(namespace, revision);
 302         }
 303         Preconditions.checkState(module != null, "Schema for %s is not available.", modeledClass);
 304         return module;
 305     }
 306
 307     private void waitForSchema(final Collection<Class<?>> binding, final MissingSchemaException exception) {
 308         if (futureSchema != null) {
 309             LOG.warn("Blocking thread to wait for schema convergence updates for {} {}",
 310                     futureSchema.getDuration(), futureSchema.getUnit());
 311             if (!futureSchema.waitForSchema(binding)) {
 312                 return;
 313             }
 314         }
 315         throw exception;
 316     }
 317
 318     private Method findRpcMethod(final Class<? extends RpcService> key, final RpcDefinition rpcDef)
 319             throws NoSuchMethodException {
 320         final String methodName = BindingMapping.getMethodName(rpcDef.getQName());
 321         if (rpcDef.getInput() != null) {
 322             final Class<?> inputClz = runtimeContext.getClassForSchema(rpcDef.getInput());
 323             return key.getMethod(methodName, inputClz);
 324         }
 325         return key.getMethod(methodName);
 326     }
 327
 328     @Override
 329     public BindingCodecTree create(final BindingRuntimeContext context) {
 330         return codecRegistry.create(context);
 331     }
 332
 333     @Override
 334     public BindingCodecTree create(final SchemaContext context, final Class<?>... bindingClasses) {
 335         return codecRegistry.create(context, bindingClasses);
 336     }
 337
 338     @Nonnull
 339     protected Map.Entry<InstanceIdentifier<?>, BindingCodecTreeNode<?>> getSubtreeCodec(
 340             final YangInstanceIdentifier domIdentifier) {
 341
 342         final BindingCodecTree currentCodecTree = codecRegistry.getCodecContext();
 343         final InstanceIdentifier<?> bindingPath = codecRegistry.fromYangInstanceIdentifier(domIdentifier);
 344         Preconditions.checkArgument(bindingPath != null);
 345         /**
 346          * If we are able to deserialize YANG instance identifier, getSubtreeCodec must
 347          * return non-null value.
 348          */
 349         final BindingCodecTreeNode<?> codecContext = currentCodecTree.getSubtreeCodec(bindingPath);
 350         return new SimpleEntry<>(bindingPath, codecContext);
 351     }
 352
 353     @SuppressWarnings("unchecked")
 354     public Set<Class<? extends Notification>> getNotificationClasses(final Set<SchemaPath> interested) {
 355         final Set<Class<? extends Notification>> result = new HashSet<>();
 356         final Set<NotificationDefinition> knownNotifications = runtimeContext.getSchemaContext().getNotifications();
 357         for (final NotificationDefinition notification : knownNotifications) {
 358             if (interested.contains(notification.getPath())) {
 359                 try {
 360                     result.add((Class<? extends Notification>) runtimeContext.getClassForSchema(notification));
 361                 } catch (final IllegalStateException e) {
 362                     // Ignore
 363                     LOG.warn("Class for {} is currently not known.",notification.getPath(),e);
 364                 }
 365             }
 366         }
 367         return result;
 368     }
 369
 370     private static Collection<Class<?>> decompose(final InstanceIdentifier<?> path) {
 371         final Set<Class<?>> clazzes = new HashSet<>();
 372         for (final InstanceIdentifier.PathArgument arg : path.getPathArguments()) {
 373             clazzes.add(arg.getType());
 374         }
 375         return clazzes;
 376     }
 377
 378     protected NormalizedNode<?, ?> instanceIdentifierToNode(final YangInstanceIdentifier parentPath) {
 379         return ImmutableNodes.fromInstanceId(runtimeContext.getSchemaContext(), parentPath);
 380     }
 381
 382     public NormalizedNode<?, ?> getDefaultNodeFor(final YangInstanceIdentifier parentMapPath) {
 383         final BindingCodecTreeNode<?> mapCodec = codecRegistry.getCodecContext().getSubtreeCodec(parentMapPath);
 384         final Object schema = mapCodec.getSchema();
 385         if (schema instanceof ListSchemaNode) {
 386             final ListSchemaNode castedSchema = (ListSchemaNode) schema;
 387             if (castedSchema.isUserOrdered()) {
 388                 return Builders.orderedMapBuilder(castedSchema).build();
 389             } else {
 390                 return Builders.mapBuilder(castedSchema).build();
 391             }
 392         }
 393         throw new IllegalArgumentException("Path does not point to list schema node");
 394     }
 395
 396     protected Collection<DOMDataTreeIdentifier> toDOMDataTreeIdentifiers(
 397             final Collection<DataTreeIdentifier<?>> subtrees) {
 398         final Set<DOMDataTreeIdentifier> ret = new HashSet<>(subtrees.size());
 399
 400         for (final DataTreeIdentifier<?> subtree : subtrees) {
 401             ret.add(toDOMDataTreeIdentifier(subtree));
 402         }
 403         return ret;
 404     }
 405
 406     protected DOMDataTreeIdentifier toDOMDataTreeIdentifier(final DataTreeIdentifier<?> path) {
 407         final YangInstanceIdentifier domPath = toYangInstanceIdentifierBlocking(path.getRootIdentifier());
 408         return new DOMDataTreeIdentifier(path.getDatastoreType(), domPath);
 409     }
 410
 411 }