X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-binding-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fbinding%2Fimpl%2FBindingToNormalizedNodeCodec.java;h=ee60afbfd3d0ed12587752ed6b0d85c779f6c116;hp=1e2d2b17f0b1846ab9272f6683f2a0f00cd1c070;hb=7257dc4ecacf3e4d08273c31accd945fb8f3e769;hpb=f0f107f9b889b728be457cf84289b53386d7d301 diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java index 1e2d2b17f0..ee60afbfd3 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java @@ -9,58 +9,173 @@ package org.opendaylight.controller.md.sal.binding.impl; import com.google.common.base.Function; import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.cache.CacheBuilder; +import com.google.common.cache.CacheLoader; +import com.google.common.cache.LoadingCache; +import com.google.common.collect.ImmutableBiMap; +import java.lang.reflect.Method; +import java.net.URI; import java.util.AbstractMap.SimpleEntry; +import java.util.Collection; +import java.util.Date; +import java.util.HashSet; import java.util.Iterator; +import java.util.Map; import java.util.Map.Entry; +import java.util.Set; +import java.util.concurrent.TimeUnit; +import javax.annotation.Nonnull; import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationException; import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationOperation; import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizer; +import org.opendaylight.yangtools.binding.data.codec.api.BindingCodecTree; +import org.opendaylight.yangtools.binding.data.codec.api.BindingCodecTreeFactory; +import org.opendaylight.yangtools.binding.data.codec.api.BindingCodecTreeNode; +import org.opendaylight.yangtools.binding.data.codec.api.BindingNormalizedNodeSerializer; import org.opendaylight.yangtools.binding.data.codec.impl.BindingNormalizedNodeCodecRegistry; +import org.opendaylight.yangtools.binding.data.codec.impl.MissingSchemaException; import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy; import org.opendaylight.yangtools.sal.binding.generator.util.BindingRuntimeContext; +import org.opendaylight.yangtools.yang.binding.BindingMapping; +import org.opendaylight.yangtools.yang.binding.DataContainer; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.Notification; +import org.opendaylight.yangtools.yang.binding.RpcService; +import org.opendaylight.yangtools.yang.binding.util.BindingReflections; +import org.opendaylight.yangtools.yang.common.QNameModule; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService; import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException; +import org.opendaylight.yangtools.yang.model.api.Module; +import org.opendaylight.yangtools.yang.model.api.NotificationDefinition; +import org.opendaylight.yangtools.yang.model.api.RpcDefinition; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaContextListener; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class BindingToNormalizedNodeCodec implements SchemaContextListener,AutoCloseable { +public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFactory, BindingNormalizedNodeSerializer, SchemaContextListener, AutoCloseable { + private static final long WAIT_DURATION_SEC = 5; private static final Logger LOG = LoggerFactory.getLogger(BindingToNormalizedNodeCodec.class); - private final BindingIndependentMappingService bindingToLegacy; private final BindingNormalizedNodeCodecRegistry codecRegistry; - private DataNormalizer legacyToNormalized; + private final GeneratedClassLoadingStrategy classLoadingStrategy; + private final FutureSchema futureSchema; + private final LoadingCache, YangInstanceIdentifier> iiCache = CacheBuilder.newBuilder() + .softValues().build(new CacheLoader, YangInstanceIdentifier>() { + + @Override + public YangInstanceIdentifier load(final InstanceIdentifier key) throws Exception { + return toYangInstanceIdentifierBlocking(key); + } + + }); + + private DataNormalizer legacyToNormalized; - public BindingToNormalizedNodeCodec(final GeneratedClassLoadingStrategy classLoadingStrategy, final BindingIndependentMappingService mappingService, final BindingNormalizedNodeCodecRegistry codecRegistry) { - super(); - this.bindingToLegacy = mappingService; - this.classLoadingStrategy = classLoadingStrategy; - this.codecRegistry = codecRegistry; + public BindingToNormalizedNodeCodec(final GeneratedClassLoadingStrategy classLoadingStrategy, + final BindingNormalizedNodeCodecRegistry codecRegistry) { + this(classLoadingStrategy,codecRegistry,false); } - public org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier toNormalized( - final InstanceIdentifier binding) { + public BindingToNormalizedNodeCodec(final GeneratedClassLoadingStrategy classLoadingStrategy, + final BindingNormalizedNodeCodecRegistry codecRegistry,final boolean waitForSchema) { + this.classLoadingStrategy = Preconditions.checkNotNull(classLoadingStrategy,"classLoadingStrategy"); + this.codecRegistry = Preconditions.checkNotNull(codecRegistry,"codecRegistry"); + this.futureSchema = new FutureSchema(WAIT_DURATION_SEC, TimeUnit.SECONDS, waitForSchema); + } + + YangInstanceIdentifier toYangInstanceIdentifierBlocking(final InstanceIdentifier binding) { + try { + return codecRegistry.toYangInstanceIdentifier(binding); + } catch (final MissingSchemaException e) { + waitForSchema(decompose(binding),e); + return codecRegistry.toYangInstanceIdentifier(binding); + } + } + + /** + * Translates supplied Binding Instance Identifier into NormalizedNode + * instance identifier. + * + * @param binding + * Binding Instance Identifier + * @return DOM Instance Identifier + * @throws IllegalArgumentException + * If supplied Instance Identifier is not valid. + */ + public YangInstanceIdentifier toNormalized(final InstanceIdentifier binding) { return codecRegistry.toYangInstanceIdentifier(binding); } - @SuppressWarnings({ "unchecked", "rawtypes" }) - public Entry> toNormalizedNode( - final InstanceIdentifier bindingPath, final DataObject bindingObject) { - return codecRegistry.toNormalizedNode((InstanceIdentifier) bindingPath, bindingObject); + @Override + public YangInstanceIdentifier toYangInstanceIdentifier(final InstanceIdentifier binding) { + return codecRegistry.toYangInstanceIdentifier(binding); + } + + YangInstanceIdentifier toYangInstanceIdentifierCached(final InstanceIdentifier binding) { + return iiCache .getUnchecked(binding); } - public Entry> toNormalizedNode( - final Entry, DataObject> binding) { - return toNormalizedNode(binding.getKey(),binding.getValue()); + @Override + public Entry> toNormalizedNode( + final InstanceIdentifier path, final T data) { + return codecRegistry.toNormalizedNode(path, data); + } + + /** + * Converts Binding Map.Entry to DOM Map.Entry + * + * Same as {@link #toNormalizedNode(InstanceIdentifier, DataObject)}. + * + * @param binding Map Entry with InstanceIdentifier as key and DataObject as value. + * @return DOM Map Entry with {@link YangInstanceIdentifier} as key and {@link NormalizedNode} + * as value. + */ + @SuppressWarnings({"unchecked", "rawtypes"}) + public Entry> toNormalizedNode( + final Entry, DataObject> binding) { + return toNormalizedNode((InstanceIdentifier) binding.getKey(),binding.getValue()); + } + + @Override + public Entry, DataObject> fromNormalizedNode(final YangInstanceIdentifier path, + final NormalizedNode data) { + return codecRegistry.fromNormalizedNode(path, data); + } + + @Override + public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data) { + return codecRegistry.fromNormalizedNodeNotification(path, data); + } + + @Override + public DataObject fromNormalizedNodeRpcData(final SchemaPath path, final ContainerNode data) { + return codecRegistry.fromNormalizedNodeRpcData(path, data); + } + + @Override + public InstanceIdentifier fromYangInstanceIdentifier(final YangInstanceIdentifier dom) { + return codecRegistry.fromYangInstanceIdentifier(dom); + } + + @Override + public ContainerNode toNormalizedNodeNotification(final Notification data) { + return codecRegistry.toNormalizedNodeNotification(data); + } + + @Override + public ContainerNode toNormalizedNodeRpcData(final DataContainer data) { + return codecRegistry.toNormalizedNodeRpcData(data); } /** @@ -72,45 +187,50 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener,AutoC * augmentation. * */ - public Optional> toBinding( - final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized) + public Optional> toBinding(final YangInstanceIdentifier normalized) throws DeserializationException { try { - return Optional.>of(codecRegistry.fromYangInstanceIdentifier(normalized)); - } catch (IllegalArgumentException e) { + return Optional.>fromNullable(codecRegistry.fromYangInstanceIdentifier(normalized)); + } catch (final IllegalArgumentException e) { return Optional.absent(); } } - - private static final Entry, DataObject> toBindingEntry( - final org.opendaylight.yangtools.yang.binding.InstanceIdentifier key, - final DataObject value) { - return new SimpleEntry, DataObject>( - key, value); - } - public DataNormalizer getDataNormalizer() { return legacyToNormalized; } - @SuppressWarnings("unchecked") - public Optional, DataObject>> toBinding( - final Entry> normalized) + public Optional, DataObject>> toBinding( + @Nonnull final Entry> normalized) throws DeserializationException { try { - @SuppressWarnings("rawtypes") - Entry binding = codecRegistry.fromNormalizedNode(normalized.getKey(), normalized.getValue()); - return Optional., DataObject>>fromNullable(binding); - } catch (IllegalArgumentException e) { + /* + * This cast is required, due to generics behaviour in openjdk / oracle javac + * + * InstanceIdentifier has definition InstanceIdentifier, + * this means '?' is always  . Eclipse compiler + * is able to determine this relationship and treats + * Entry,DataObject> and Entry + * as assignable. However openjdk / oracle javac treats this two types + * as incompatible and issues a compile error. + * + * It is safe to loose generic information and cast it to other generic signature. + * + */ + @SuppressWarnings("unchecked") + final Entry, DataObject> binding = Entry.class.cast(codecRegistry.fromNormalizedNode(normalized.getKey(), normalized.getValue())); + return Optional.fromNullable(binding); + } catch (final IllegalArgumentException e) { return Optional.absent(); } } @Override - public void onGlobalContextUpdated(final SchemaContext arg0) { - legacyToNormalized = new DataNormalizer(arg0); - codecRegistry.onBindingRuntimeContextUpdated(BindingRuntimeContext.create(classLoadingStrategy, arg0)); + public void onGlobalContextUpdated(final SchemaContext schemaContext) { + legacyToNormalized = new DataNormalizer(schemaContext); + BindingRuntimeContext runtimeContext = BindingRuntimeContext.create(classLoadingStrategy, schemaContext); + codecRegistry.onBindingRuntimeContextUpdated(runtimeContext); + futureSchema.onRuntimeContextUpdated(runtimeContext); } public Function>, Optional> deserializeFunction(final InstanceIdentifier path) { @@ -123,26 +243,145 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener,AutoC * @param path DOM Path * @return Node with defaults set on. */ - public NormalizedNode getDefaultNodeFor(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier path) { - Iterator iterator = path.getPathArguments().iterator(); + public NormalizedNode getDefaultNodeFor(final YangInstanceIdentifier path) { + final Iterator iterator = path.getPathArguments().iterator(); DataNormalizationOperation currentOp = legacyToNormalized.getRootOperation(); while (iterator.hasNext()) { - PathArgument currentArg = iterator.next(); + final PathArgument currentArg = iterator.next(); try { currentOp = currentOp.getChild(currentArg); - } catch (DataNormalizationException e) { + } catch (final DataNormalizationException e) { throw new IllegalArgumentException(String.format("Invalid child encountered in path %s", path), e); } } return currentOp.createDefault(path.getLastPathArgument()); } - public BindingIndependentMappingService getLegacy() { - return bindingToLegacy; + public BindingNormalizedNodeCodecRegistry getCodecRegistry() { + return codecRegistry; } @Override - public void close() throws Exception { + public void close() { // NOOP Intentionally } + + public BindingNormalizedNodeCodecRegistry getCodecFactory() { + return codecRegistry; + } + + // FIXME: This should be probably part of Binding Runtime context + public ImmutableBiMap getRpcMethodToSchemaPath(final Class key) { + final Module module = getModuleBlocking(key); + final ImmutableBiMap.Builder ret = ImmutableBiMap.builder(); + try { + for (final RpcDefinition rpcDef : module.getRpcs()) { + final Method method = findRpcMethod(key, rpcDef); + ret.put(method, rpcDef.getPath()); + } + } catch (final NoSuchMethodException e) { + throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e); + } + return ret.build(); + } + + protected ImmutableBiMap getRpcMethodToSchema(final Class key) { + final Module module = getModuleBlocking(key); + final ImmutableBiMap.Builder ret = ImmutableBiMap.builder(); + try { + for (final RpcDefinition rpcDef : module.getRpcs()) { + final Method method = findRpcMethod(key, rpcDef); + ret.put(method, rpcDef); + } + } catch (final NoSuchMethodException e) { + throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e); + } + return ret.build(); + } + + private Module getModuleBlocking(final Class modeledClass) { + final QNameModule moduleName = BindingReflections.getQNameModule(modeledClass); + final URI namespace = moduleName.getNamespace(); + final Date revision = moduleName.getRevision(); + Module module = runtimeContext().getSchemaContext().findModuleByNamespaceAndRevision(namespace, revision); + if(module == null && futureSchema.waitForSchema(namespace,revision)) { + module = runtimeContext().getSchemaContext().findModuleByNamespaceAndRevision(namespace, revision); + } + Preconditions.checkState(module != null, "Schema for %s is not available.", modeledClass); + return module; + } + + private void waitForSchema(final Collection> binding, final MissingSchemaException e) { + LOG.warn("Blocking thread to wait for schema convergence updates for {} {}", futureSchema.getDuration(), + futureSchema.getUnit()); + if(futureSchema.waitForSchema(binding)) { + return; + } + + throw e; + } + + private Method findRpcMethod(final Class key, final RpcDefinition rpcDef) throws NoSuchMethodException { + final String methodName = BindingMapping.getMethodName(rpcDef.getQName()); + if(rpcDef.getInput() != null) { + final Class inputClz = runtimeContext().getClassForSchema(rpcDef.getInput()); + return key.getMethod(methodName, inputClz); + } + return key.getMethod(methodName); + } + + private BindingRuntimeContext runtimeContext() { + return futureSchema.runtimeContext(); + } + + @Override + public BindingCodecTree create(final BindingRuntimeContext context) { + return codecRegistry.create(context); + } + + @Override + public BindingCodecTree create(final SchemaContext context, final Class... bindingClasses) { + return codecRegistry.create(context, bindingClasses); + } + + @Nonnull + protected Map.Entry, BindingCodecTreeNode> getSubtreeCodec( + final YangInstanceIdentifier domIdentifier) { + + final BindingCodecTree currentCodecTree = codecRegistry.getCodecContext(); + final InstanceIdentifier bindingPath = codecRegistry.fromYangInstanceIdentifier(domIdentifier); + Preconditions.checkArgument(bindingPath != null); + /** + * If we are able to deserialize YANG instance identifier, getSubtreeCodec must + * return non-null value. + */ + final BindingCodecTreeNode codecContext = currentCodecTree.getSubtreeCodec(bindingPath); + return new SimpleEntry, BindingCodecTreeNode>(bindingPath, codecContext); + } + + @SuppressWarnings("unchecked") + public Set> getNotificationClasses(final Set interested) { + final Set> result = new HashSet<>(); + final Set knownNotifications = runtimeContext().getSchemaContext().getNotifications(); + for (final NotificationDefinition notification : knownNotifications) { + if (interested.contains(notification.getPath())) { + try { + result.add((Class) runtimeContext().getClassForSchema(notification)); + } catch (final IllegalStateException e) { + // Ignore + LOG.warn("Class for {} is currently not known.",notification.getPath(),e); + } + } + } + return result; + } + + private static Collection> decompose(final InstanceIdentifier path) { + final Set> clazzes = new HashSet<>(); + for(final InstanceIdentifier.PathArgument arg : path.getPathArguments()) { + clazzes.add(arg.getType()); + } + return clazzes; + } + }