opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/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.controller.md.sal.binding.impl;
   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.util.AbstractMap.SimpleEntry;
  19 import java.util.Iterator;
  20 import java.util.Map;
  21 import java.util.Map.Entry;
  22 import javax.annotation.Nonnull;
  23 import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationException;
  24 import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationOperation;
  25 import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizer;
  26 import org.opendaylight.yangtools.binding.data.codec.api.BindingCodecTree;
  27 import org.opendaylight.yangtools.binding.data.codec.api.BindingCodecTreeFactory;
  28 import org.opendaylight.yangtools.binding.data.codec.api.BindingCodecTreeNode;
  29 import org.opendaylight.yangtools.binding.data.codec.api.BindingNormalizedNodeSerializer;
  30 import org.opendaylight.yangtools.binding.data.codec.impl.BindingNormalizedNodeCodecRegistry;
  31 import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy;
  32 import org.opendaylight.yangtools.sal.binding.generator.util.BindingRuntimeContext;
  33 import org.opendaylight.yangtools.yang.binding.BindingMapping;
  34 import org.opendaylight.yangtools.yang.binding.DataContainer;
  35 import org.opendaylight.yangtools.yang.binding.DataObject;
  36 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  37 import org.opendaylight.yangtools.yang.binding.Notification;
  38 import org.opendaylight.yangtools.yang.binding.RpcService;
  39 import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
  40 import org.opendaylight.yangtools.yang.common.QNameModule;
  41 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  42 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  43 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  44 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  45 import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
  46 import org.opendaylight.yangtools.yang.model.api.Module;
  47 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  48 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  49 import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
  50 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  51
  52 public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFactory, BindingNormalizedNodeSerializer, SchemaContextListener, AutoCloseable {
  53
  54     private final BindingNormalizedNodeCodecRegistry codecRegistry;
  55     private DataNormalizer legacyToNormalized;
  56     private final GeneratedClassLoadingStrategy classLoadingStrategy;
  57     private BindingRuntimeContext runtimeContext;
  58     private final LoadingCache<InstanceIdentifier<?>, YangInstanceIdentifier> iiCache = CacheBuilder.newBuilder()
  59             .softValues().build(new CacheLoader<InstanceIdentifier<?>, YangInstanceIdentifier>() {
  60
  61                 @Override
  62                 public YangInstanceIdentifier load(final InstanceIdentifier<?> key) throws Exception {
  63                     return toYangInstanceIdentifier(key);
  64                 }
  65
  66             });
  67
  68     public BindingToNormalizedNodeCodec(final GeneratedClassLoadingStrategy classLoadingStrategy,
  69             final BindingNormalizedNodeCodecRegistry codecRegistry) {
  70         this.classLoadingStrategy = Preconditions.checkNotNull(classLoadingStrategy,"classLoadingStrategy");
  71         this.codecRegistry = Preconditions.checkNotNull(codecRegistry,"codecRegistry");
  72
  73     }
  74
  75     /**
  76      * Translates supplied Binding Instance Identifier into NormalizedNode
  77      * instance identifier.
  78      *
  79      * @param binding
  80      *            Binding Instance Identifier
  81      * @return DOM Instance Identifier
  82      * @throws IllegalArgumentException
  83      *             If supplied Instance Identifier is not valid.
  84      */
  85     public YangInstanceIdentifier toNormalized(final InstanceIdentifier<? extends DataObject> binding) {
  86         return codecRegistry.toYangInstanceIdentifier(binding);
  87     }
  88
  89     @Override
  90     public YangInstanceIdentifier toYangInstanceIdentifier(final InstanceIdentifier<?> binding) {
  91         return codecRegistry.toYangInstanceIdentifier(binding);
  92     }
  93
  94
  95     YangInstanceIdentifier toYangInstanceIdentifierCached(final InstanceIdentifier<?> binding) {
  96         return iiCache .getUnchecked(binding);
  97     }
  98
  99     @Override
 100     public <T extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode(
 101             final InstanceIdentifier<T> path, final T data) {
 102         return codecRegistry.toNormalizedNode(path, data);
 103     }
 104
 105     /**
 106      * Converts Binding Map.Entry to DOM Map.Entry
 107      *
 108      * Same as {@link #toNormalizedNode(InstanceIdentifier, DataObject)}.
 109      *
 110      * @param binding Map Entry with InstanceIdentifier as key and DataObject as value.
 111      * @return DOM Map Entry with {@link YangInstanceIdentifier} as key and {@link NormalizedNode}
 112      *         as value.
 113      */
 114     @SuppressWarnings({"unchecked", "rawtypes"})
 115     public Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode(
 116             final Entry<InstanceIdentifier<? extends DataObject>, DataObject> binding) {
 117         return toNormalizedNode((InstanceIdentifier) binding.getKey(),binding.getValue());
 118     }
 119
 120     @Override
 121     public Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final YangInstanceIdentifier path,
 122             final NormalizedNode<?, ?> data) {
 123         return codecRegistry.fromNormalizedNode(path, data);
 124     }
 125
 126     @Override
 127     public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data) {
 128         return codecRegistry.fromNormalizedNodeNotification(path, data);
 129     }
 130
 131     @Override
 132     public DataObject fromNormalizedNodeRpcData(final SchemaPath path, final ContainerNode data) {
 133         return codecRegistry.fromNormalizedNodeRpcData(path, data);
 134     }
 135
 136     @Override
 137     public InstanceIdentifier<?> fromYangInstanceIdentifier(final YangInstanceIdentifier dom) {
 138         return codecRegistry.fromYangInstanceIdentifier(dom);
 139     }
 140
 141     @Override
 142     public ContainerNode toNormalizedNodeNotification(final Notification data) {
 143         return codecRegistry.toNormalizedNodeNotification(data);
 144     }
 145
 146     @Override
 147     public ContainerNode toNormalizedNodeRpcData(final DataContainer data) {
 148         return codecRegistry.toNormalizedNodeRpcData(data);
 149     }
 150
 151     /**
 152      *
 153      * Returns a Binding-Aware instance identifier from normalized
 154      * instance-identifier if it is possible to create representation.
 155      *
 156      * Returns Optional.absent for cases where target is mixin node except
 157      * augmentation.
 158      *
 159      */
 160     public Optional<InstanceIdentifier<? extends DataObject>> toBinding(final YangInstanceIdentifier normalized)
 161                     throws DeserializationException {
 162         try {
 163             return Optional.<InstanceIdentifier<? extends DataObject>>fromNullable(codecRegistry.fromYangInstanceIdentifier(normalized));
 164         } catch (final IllegalArgumentException e) {
 165             return Optional.absent();
 166         }
 167     }
 168
 169     public DataNormalizer getDataNormalizer() {
 170         return legacyToNormalized;
 171     }
 172
 173     public Optional<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> toBinding(
 174             final @Nonnull Entry<YangInstanceIdentifier, ? extends NormalizedNode<?, ?>> normalized)
 175                     throws DeserializationException {
 176         try {
 177             /*
 178              * This cast is required, due to generics behaviour in openjdk / oracle javac
 179              *
 180              * InstanceIdentifier has definition InstanceIdentifier<T extends DataObject>,
 181              * this means '?' is always  <? extends DataObject>. Eclipse compiler
 182              * is able to determine this relationship and treats
 183              * Entry<InstanceIdentifier<?>,DataObject> and Entry<InstanceIdentifier<? extends DataObject,DataObject>
 184              * as assignable. However openjdk / oracle javac treats this two types
 185              * as incompatible and issues a compile error.
 186              *
 187              * It is safe to  loose generic information and cast it to other generic signature.
 188              *
 189              */
 190             @SuppressWarnings({ "unchecked", "rawtypes" })
 191             final Entry<InstanceIdentifier<? extends DataObject>, DataObject> binding = Entry.class.cast(codecRegistry.fromNormalizedNode(normalized.getKey(), normalized.getValue()));
 192             return Optional.fromNullable(binding);
 193         } catch (final IllegalArgumentException e) {
 194             return Optional.absent();
 195         }
 196     }
 197
 198     @Override
 199     public void onGlobalContextUpdated(final SchemaContext arg0) {
 200         legacyToNormalized = new DataNormalizer (arg0);
 201         runtimeContext = BindingRuntimeContext.create(classLoadingStrategy, arg0);
 202         codecRegistry.onBindingRuntimeContextUpdated(runtimeContext);
 203     }
 204
 205     public <T extends DataObject> Function<Optional<NormalizedNode<?, ?>>, Optional<T>>  deserializeFunction(final InstanceIdentifier<T> path) {
 206         return codecRegistry.deserializeFunction(path);
 207     }
 208
 209     /**
 210      * Returns an default object according to YANG schema for supplied path.
 211      *
 212      * @param path DOM Path
 213      * @return Node with defaults set on.
 214      */
 215     public NormalizedNode<?, ?> getDefaultNodeFor(final YangInstanceIdentifier path) {
 216         final Iterator<PathArgument> iterator = path.getPathArguments().iterator();
 217         DataNormalizationOperation<?> currentOp = legacyToNormalized.getRootOperation();
 218         while (iterator.hasNext()) {
 219             final PathArgument currentArg = iterator.next();
 220             try {
 221                 currentOp = currentOp.getChild(currentArg);
 222             } catch (final DataNormalizationException e) {
 223                 throw new IllegalArgumentException(String.format("Invalid child encountered in path %s", path), e);
 224             }
 225         }
 226         return currentOp.createDefault(path.getLastPathArgument());
 227     }
 228
 229     public BindingNormalizedNodeCodecRegistry getCodecRegistry() {
 230         return codecRegistry;
 231     }
 232
 233     @Override
 234     public void close() {
 235         // NOOP Intentionally
 236     }
 237
 238     public BindingNormalizedNodeCodecRegistry getCodecFactory() {
 239         return codecRegistry;
 240     }
 241
 242     // FIXME: This should be probably part of Binding Runtime context
 243     public ImmutableBiMap<Method, SchemaPath> getRpcMethodToSchemaPath(final Class<? extends RpcService> key) {
 244         final QNameModule moduleName = BindingReflections.getQNameModule(key);
 245         final Module module = runtimeContext.getSchemaContext().findModuleByNamespaceAndRevision(moduleName.getNamespace(), moduleName.getRevision());
 246         final ImmutableBiMap.Builder<Method, SchemaPath> ret = ImmutableBiMap.<Method, SchemaPath>builder();
 247         try {
 248             for (final RpcDefinition rpcDef : module.getRpcs()) {
 249                 final Method method = findRpcMethod(key, rpcDef);
 250                 ret.put(method, rpcDef.getPath());
 251             }
 252         } catch (final NoSuchMethodException e) {
 253             throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e);
 254         }
 255         return ret.build();
 256     }
 257
 258     protected ImmutableBiMap<Method, RpcDefinition> getRpcMethodToSchema(final Class<? extends RpcService> key) {
 259         final QNameModule moduleName = BindingReflections.getQNameModule(key);
 260         final Module module = runtimeContext.getSchemaContext().findModuleByNamespaceAndRevision(moduleName.getNamespace(), moduleName.getRevision());
 261         final ImmutableBiMap.Builder<Method, RpcDefinition> ret = ImmutableBiMap.builder();
 262         try {
 263             for (final RpcDefinition rpcDef : module.getRpcs()) {
 264                 final Method method = findRpcMethod(key, rpcDef);
 265                 ret.put(method, rpcDef);
 266             }
 267         } catch (final NoSuchMethodException e) {
 268             throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e);
 269         }
 270         return ret.build();
 271     }
 272
 273     private Method findRpcMethod(final Class<? extends RpcService> key, final RpcDefinition rpcDef) throws NoSuchMethodException {
 274         final String methodName = BindingMapping.getMethodName(rpcDef.getQName());
 275         if(rpcDef.getInput() != null) {
 276             final Class<?> inputClz = runtimeContext.getClassForSchema(rpcDef.getInput());
 277             return key.getMethod(methodName, inputClz);
 278         }
 279         return key.getMethod(methodName);
 280     }
 281
 282     @Override
 283     public BindingCodecTree create(final BindingRuntimeContext context) {
 284         return codecRegistry.create(context);
 285     }
 286
 287     @Override
 288     public BindingCodecTree create(final SchemaContext context, final Class<?>... bindingClasses) {
 289         return codecRegistry.create(context, bindingClasses);
 290     }
 291
 292     @Nonnull
 293     protected Map.Entry<InstanceIdentifier<?>, BindingCodecTreeNode<?>> getSubtreeCodec(
 294             final YangInstanceIdentifier domIdentifier) {
 295
 296         final BindingCodecTree currentCodecTree = codecRegistry.getCodecContext();
 297         final InstanceIdentifier<?> bindingPath = codecRegistry.fromYangInstanceIdentifier(domIdentifier);
 298         Preconditions.checkArgument(bindingPath != null);
 299         /**
 300          * If we are able to deserialize YANG instance identifier, getSubtreeCodec must
 301          * return non-null value.
 302          */
 303         final BindingCodecTreeNode<?> codecContext = currentCodecTree.getSubtreeCodec(bindingPath);
 304         return new SimpleEntry<InstanceIdentifier<?>, BindingCodecTreeNode<?>>(bindingPath, codecContext);
 305     }
 306
 307 }