X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-binding-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fbinding%2Fimpl%2FBindingToNormalizedNodeCodec.java;h=e4e205307cf43600d68b5b4737fb70cd646dc5b0;hb=refs%2Fchanges%2F92%2F64292%2F8;hp=fd9eec633744361f6682a4e6c3bc6de6343f04aa;hpb=383553dbada5e4c3078133c81a42d05990031992;p=controller.git 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 fd9eec6337..e4e205307c 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 @@ -33,10 +33,10 @@ import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree; import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeFactory; import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode; import org.opendaylight.mdsal.binding.dom.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.api.ClassLoadingStrategy; -import org.opendaylight.yangtools.sal.binding.generator.util.BindingRuntimeContext; +import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry; +import org.opendaylight.mdsal.binding.dom.codec.impl.MissingSchemaException; +import org.opendaylight.mdsal.binding.generator.api.ClassLoadingStrategy; +import org.opendaylight.mdsal.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; @@ -50,16 +50,20 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgum 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.DeserializationException; +import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; 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.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.meta.StatementSource; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFactory, BindingNormalizedNodeSerializer, SchemaContextListener, AutoCloseable { +public class BindingToNormalizedNodeCodec + implements BindingCodecTreeFactory, BindingNormalizedNodeSerializer, SchemaContextListener, AutoCloseable { private static final long WAIT_DURATION_SEC = 5; private static final Logger LOG = LoggerFactory.getLogger(BindingToNormalizedNodeCodec.class); @@ -82,23 +86,24 @@ public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFacto public BindingToNormalizedNodeCodec(final ClassLoadingStrategy classLoadingStrategy, final BindingNormalizedNodeCodecRegistry codecRegistry) { - this(classLoadingStrategy,codecRegistry,false); + this(classLoadingStrategy, codecRegistry, false); } public BindingToNormalizedNodeCodec(final ClassLoadingStrategy classLoadingStrategy, - final BindingNormalizedNodeCodecRegistry codecRegistry,final boolean waitForSchema) { - this.classLoadingStrategy = Preconditions.checkNotNull(classLoadingStrategy,"classLoadingStrategy"); - this.codecRegistry = Preconditions.checkNotNull(codecRegistry,"codecRegistry"); + 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) { + public YangInstanceIdentifier + toYangInstanceIdentifierBlocking(final InstanceIdentifier binding) { try { - return codecRegistry.toYangInstanceIdentifier(binding); + return this.codecRegistry.toYangInstanceIdentifier(binding); } catch (final MissingSchemaException e) { - waitForSchema(decompose(binding),e); - return codecRegistry.toYangInstanceIdentifier(binding); + waitForSchema(decompose(binding), e); + return this.codecRegistry.toYangInstanceIdentifier(binding); } } @@ -113,23 +118,22 @@ public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFacto * If supplied Instance Identifier is not valid. */ public YangInstanceIdentifier toNormalized(final InstanceIdentifier binding) { - return codecRegistry.toYangInstanceIdentifier(binding); + return this.codecRegistry.toYangInstanceIdentifier(binding); } @Override public YangInstanceIdentifier toYangInstanceIdentifier(final InstanceIdentifier binding) { - return codecRegistry.toYangInstanceIdentifier(binding); + return this.codecRegistry.toYangInstanceIdentifier(binding); } - - YangInstanceIdentifier toYangInstanceIdentifierCached(final InstanceIdentifier binding) { - return iiCache .getUnchecked(binding); + public YangInstanceIdentifier toYangInstanceIdentifierCached(final InstanceIdentifier binding) { + return this.iiCache.getUnchecked(binding); } @Override public Entry> toNormalizedNode( final InstanceIdentifier path, final T data) { - return codecRegistry.toNormalizedNode(path, data); + return this.codecRegistry.toNormalizedNode(path, data); } /** @@ -141,41 +145,41 @@ public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFacto * @return DOM Map Entry with {@link YangInstanceIdentifier} as key and {@link NormalizedNode} * as value. */ - @SuppressWarnings({"unchecked", "rawtypes"}) + @SuppressWarnings({ "unchecked", "rawtypes" }) public Entry> toNormalizedNode( final Entry, DataObject> binding) { - return toNormalizedNode((InstanceIdentifier) binding.getKey(),binding.getValue()); + return toNormalizedNode((InstanceIdentifier) binding.getKey(), binding.getValue()); } @Override public Entry, DataObject> fromNormalizedNode(final YangInstanceIdentifier path, final NormalizedNode data) { - return codecRegistry.fromNormalizedNode(path, data); + return this.codecRegistry.fromNormalizedNode(path, data); } @Override public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data) { - return codecRegistry.fromNormalizedNodeNotification(path, data); + return this.codecRegistry.fromNormalizedNodeNotification(path, data); } @Override public DataObject fromNormalizedNodeRpcData(final SchemaPath path, final ContainerNode data) { - return codecRegistry.fromNormalizedNodeRpcData(path, data); + return this.codecRegistry.fromNormalizedNodeRpcData(path, data); } @Override public InstanceIdentifier fromYangInstanceIdentifier(final YangInstanceIdentifier dom) { - return codecRegistry.fromYangInstanceIdentifier(dom); + return this.codecRegistry.fromYangInstanceIdentifier(dom); } @Override public ContainerNode toNormalizedNodeNotification(final Notification data) { - return codecRegistry.toNormalizedNodeNotification(data); + return this.codecRegistry.toNormalizedNodeNotification(data); } @Override public ContainerNode toNormalizedNodeRpcData(final DataContainer data) { - return codecRegistry.toNormalizedNodeRpcData(data); + return this.codecRegistry.toNormalizedNodeRpcData(data); } /** @@ -188,21 +192,22 @@ public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFacto * */ public Optional> toBinding(final YangInstanceIdentifier normalized) - throws DeserializationException { + throws DeserializationException { try { - return Optional.>fromNullable(codecRegistry.fromYangInstanceIdentifier(normalized)); + return Optional.>fromNullable( + this.codecRegistry.fromYangInstanceIdentifier(normalized)); } catch (final IllegalArgumentException e) { return Optional.absent(); } } public DataNormalizer getDataNormalizer() { - return legacyToNormalized; + return this.legacyToNormalized; } public Optional, DataObject>> toBinding( @Nonnull final Entry> normalized) - throws DeserializationException { + throws DeserializationException { try { /* * This cast is required, due to generics behaviour in openjdk / oracle javac @@ -218,7 +223,8 @@ public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFacto * */ @SuppressWarnings("unchecked") - final Entry, DataObject> binding = Entry.class.cast(codecRegistry.fromNormalizedNode(normalized.getKey(), normalized.getValue())); + final Entry, DataObject> binding = + Entry.class.cast(this.codecRegistry.fromNormalizedNode(normalized.getKey(), normalized.getValue())); return Optional.fromNullable(binding); } catch (final IllegalArgumentException e) { return Optional.absent(); @@ -227,14 +233,16 @@ public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFacto @Override public void onGlobalContextUpdated(final SchemaContext schemaContext) { - legacyToNormalized = new DataNormalizer(schemaContext); - BindingRuntimeContext runtimeContext = BindingRuntimeContext.create(classLoadingStrategy, schemaContext); - codecRegistry.onBindingRuntimeContextUpdated(runtimeContext); - futureSchema.onRuntimeContextUpdated(runtimeContext); + this.legacyToNormalized = new DataNormalizer(schemaContext); + final BindingRuntimeContext runtimeContext = + BindingRuntimeContext.create(this.classLoadingStrategy, schemaContext); + this.codecRegistry.onBindingRuntimeContextUpdated(runtimeContext); + this.futureSchema.onRuntimeContextUpdated(runtimeContext); } - public Function>, Optional> deserializeFunction(final InstanceIdentifier path) { - return codecRegistry.deserializeFunction(path); + public Function>, Optional> + deserializeFunction(final InstanceIdentifier path) { + return this.codecRegistry.deserializeFunction(path); } /** @@ -245,7 +253,7 @@ public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFacto */ public NormalizedNode getDefaultNodeFor(final YangInstanceIdentifier path) { final Iterator iterator = path.getPathArguments().iterator(); - DataNormalizationOperation currentOp = legacyToNormalized.getRootOperation(); + DataNormalizationOperation currentOp = this.legacyToNormalized.getRootOperation(); while (iterator.hasNext()) { final PathArgument currentArg = iterator.next(); try { @@ -258,7 +266,7 @@ public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFacto } public BindingNormalizedNodeCodecRegistry getCodecRegistry() { - return codecRegistry; + return this.codecRegistry; } @Override @@ -267,7 +275,7 @@ public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFacto } public BindingNormalizedNodeCodecRegistry getCodecFactory() { - return codecRegistry; + return this.codecRegistry; } // FIXME: This should be probably part of Binding Runtime context @@ -285,7 +293,7 @@ public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFacto return ret.build(); } - protected ImmutableBiMap getRpcMethodToSchema(final Class key) { + public ImmutableBiMap getRpcMethodToSchema(final Class key) { final Module module = getModuleBlocking(key); final ImmutableBiMap.Builder ret = ImmutableBiMap.builder(); try { @@ -304,7 +312,7 @@ public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFacto final URI namespace = moduleName.getNamespace(); final Date revision = moduleName.getRevision(); Module module = runtimeContext().getSchemaContext().findModuleByNamespaceAndRevision(namespace, revision); - if(module == null && futureSchema.waitForSchema(namespace,revision)) { + if ((module == null) && this.futureSchema.waitForSchema(namespace, revision)) { module = runtimeContext().getSchemaContext().findModuleByNamespaceAndRevision(namespace, revision); } Preconditions.checkState(module != null, "Schema for %s is not available.", modeledClass); @@ -312,44 +320,50 @@ public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFacto } 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)) { + LOG.warn("Blocking thread to wait for schema convergence updates for {} {}", this.futureSchema.getDuration(), + this.futureSchema.getUnit()); + if (this.futureSchema.waitForSchema(binding)) { return; } throw e; } - private Method findRpcMethod(final Class key, final RpcDefinition rpcDef) throws NoSuchMethodException { + private Method findRpcMethod(final Class key, final RpcDefinition rpcDef) + throws NoSuchMethodException { final String methodName = BindingMapping.getMethodName(rpcDef.getQName()); - if(rpcDef.getInput() != null) { + if ((rpcDef.getInput() != null) && isExplicitStatement(rpcDef.getInput())) { final Class inputClz = runtimeContext().getClassForSchema(rpcDef.getInput()); return key.getMethod(methodName, inputClz); } return key.getMethod(methodName); } + private static boolean isExplicitStatement(final ContainerSchemaNode node) { + return (node instanceof EffectiveStatement) + && (((EffectiveStatement) node).getDeclared().getStatementSource() == StatementSource.DECLARATION); + } + private BindingRuntimeContext runtimeContext() { - return futureSchema.runtimeContext(); + return this.futureSchema.runtimeContext(); } @Override public BindingCodecTree create(final BindingRuntimeContext context) { - return codecRegistry.create(context); + return this.codecRegistry.create(context); } @Override public BindingCodecTree create(final SchemaContext context, final Class... bindingClasses) { - return codecRegistry.create(context, bindingClasses); + return this.codecRegistry.create(context, bindingClasses); } @Nonnull - protected Map.Entry, BindingCodecTreeNode> getSubtreeCodec( - final YangInstanceIdentifier domIdentifier) { + public Map.Entry, BindingCodecTreeNode> + getSubtreeCodec(final YangInstanceIdentifier domIdentifier) { - final BindingCodecTree currentCodecTree = codecRegistry.getCodecContext(); - final InstanceIdentifier bindingPath = codecRegistry.fromYangInstanceIdentifier(domIdentifier); + final BindingCodecTree currentCodecTree = this.codecRegistry.getCodecContext(); + final InstanceIdentifier bindingPath = this.codecRegistry.fromYangInstanceIdentifier(domIdentifier); Preconditions.checkArgument(bindingPath != null); /** * If we are able to deserialize YANG instance identifier, getSubtreeCodec must @@ -369,7 +383,7 @@ public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFacto result.add((Class) runtimeContext().getClassForSchema(notification)); } catch (final IllegalStateException e) { // Ignore - LOG.warn("Class for {} is currently not known.",notification.getPath(),e); + LOG.warn("Class for {} is currently not known.", notification.getPath(), e); } } } @@ -378,10 +392,9 @@ public final class BindingToNormalizedNodeCodec implements BindingCodecTreeFacto private static Collection> decompose(final InstanceIdentifier path) { final Set> clazzes = new HashSet<>(); - for(final InstanceIdentifier.PathArgument arg : path.getPathArguments()) { + for (final InstanceIdentifier.PathArgument arg : path.getPathArguments()) { clazzes.add(arg.getType()); } return clazzes; } - }