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=d275c838f25adacc554898b36db32aa47b7cfaa6;hb=8eaba1eb027b02f8b36480721055dc99c6700e85;hp=f885b323e6c04c34d23356c50722c24dfc755ac7;hpb=e27d63bdcfbfb0c1078a9c3e5aabf59ae7e2315f;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 f885b323e6..d9e58e538d 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 @@ -7,109 +7,231 @@ */ package org.opendaylight.controller.md.sal.binding.impl; -import java.util.AbstractMap.SimpleEntry; +import com.google.common.base.Function; +import com.google.common.base.Optional; +import com.google.common.collect.ImmutableBiMap; +import java.lang.reflect.Method; +import java.util.Iterator; import java.util.Map.Entry; - +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.yang.binding.Augmentation; +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.BindingNormalizedNodeSerializer; +import org.opendaylight.yangtools.binding.data.codec.impl.BindingNormalizedNodeCodecRegistry; +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.data.api.CompositeNode; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument; -import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode; -import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; -import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode; +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.RpcDefinition; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaContextListener; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import com.google.common.collect.ImmutableList; - -public class BindingToNormalizedNodeCodec implements SchemaContextListener { +import org.opendaylight.yangtools.yang.model.api.SchemaPath; - private static final Logger LOG = LoggerFactory.getLogger(BindingToNormalizedNodeCodec.class); +public class BindingToNormalizedNodeCodec implements BindingCodecTreeFactory, BindingNormalizedNodeSerializer, SchemaContextListener, AutoCloseable { - private final BindingIndependentMappingService bindingToLegacy; + private final BindingNormalizedNodeCodecRegistry codecRegistry; private DataNormalizer legacyToNormalized; + private final GeneratedClassLoadingStrategy classLoadingStrategy; + private BindingRuntimeContext runtimeContext; - public BindingToNormalizedNodeCodec(final BindingIndependentMappingService mappingService) { - super(); - this.bindingToLegacy = mappingService; - } + public BindingToNormalizedNodeCodec(final GeneratedClassLoadingStrategy classLoadingStrategy, + final BindingNormalizedNodeCodecRegistry codecRegistry) { + this.classLoadingStrategy = classLoadingStrategy; + this.codecRegistry = codecRegistry; - public org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toNormalized( - final InstanceIdentifier binding) { - return legacyToNormalized.toNormalized(bindingToLegacy.toDataDom(binding)); } - public Entry> toNormalizedNode( - final InstanceIdentifier bindingPath, final DataObject bindingObject) { - return toNormalizedNode(toEntry(bindingPath, bindingObject)); + public YangInstanceIdentifier toNormalized(final InstanceIdentifier binding) { + return codecRegistry.toYangInstanceIdentifier(binding); + } + @Override + public YangInstanceIdentifier toYangInstanceIdentifier(InstanceIdentifier binding) { + return codecRegistry.toYangInstanceIdentifier(binding); } - public Entry> toNormalizedNode( - final Entry, DataObject> binding) { - Entry> normalizedEntry = legacyToNormalized.toNormalized(bindingToLegacy.toDataDom(binding)); - if(Augmentation.class.isAssignableFrom(binding.getKey().getTargetType())) { + @Override + public Entry> toNormalizedNode( + InstanceIdentifier path, T data) { + return codecRegistry.toNormalizedNode(path, data); + } - for(DataContainerChild child : ((DataContainerNode) normalizedEntry.getValue()).getValue()) { - if(child instanceof AugmentationNode) { - ImmutableList childArgs = ImmutableList.builder() - .addAll(normalizedEntry.getKey().getPath()) - .add(child.getIdentifier()) - .build(); - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = new org.opendaylight.yangtools.yang.data.api.InstanceIdentifier(childArgs); - return new SimpleEntry>(childPath,child); - } - } + @SuppressWarnings({"unchecked", "rawtypes"}) + public Entry> toNormalizedNode( + final Entry, DataObject> binding) { + return toNormalizedNode((InstanceIdentifier) binding.getKey(),binding.getValue()); + } - } - return normalizedEntry; + @Override + public Entry, DataObject> fromNormalizedNode(YangInstanceIdentifier path, + NormalizedNode data) { + return codecRegistry.fromNormalizedNode(path, data); + } + @Override + public Notification fromNormalizedNodeNotification(SchemaPath path, ContainerNode data) { + return codecRegistry.fromNormalizedNodeNotification(path, data); + } + @Override + public DataObject fromNormalizedNodeRpcData(SchemaPath path, ContainerNode data) { + return codecRegistry.fromNormalizedNodeRpcData(path, data); } - public InstanceIdentifier toBinding( - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) - throws DeserializationException { + @Override + public InstanceIdentifier fromYangInstanceIdentifier(YangInstanceIdentifier dom) { + return codecRegistry.fromYangInstanceIdentifier(dom); + } - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath = legacyToNormalized - .toLegacy(normalized); - return bindingToLegacy.fromDataDom(legacyPath); + @Override + public ContainerNode toNormalizedNodeNotification(Notification data) { + return codecRegistry.toNormalizedNodeNotification(data); } - private static final Entry, DataObject> toEntry( - final org.opendaylight.yangtools.yang.binding.InstanceIdentifier key, - final DataObject value) { - return new SimpleEntry, DataObject>( - key, value); + @Override + public ContainerNode toNormalizedNodeRpcData(DataContainer data) { + return codecRegistry.toNormalizedNodeRpcData(data); } - public DataObject toBinding(final InstanceIdentifier path, final NormalizedNode normalizedNode) - throws DeserializationException { - return bindingToLegacy.dataObjectFromDataDom(path, (CompositeNode) DataNormalizer.toLegacy(normalizedNode)); + /** + * + * Returns a Binding-Aware instance identifier from normalized + * instance-identifier if it is possible to create representation. + * + * Returns Optional.absent for cases where target is mixin node except + * augmentation. + * + */ + public Optional> toBinding(final YangInstanceIdentifier normalized) + throws DeserializationException { + try { + return Optional.>fromNullable(codecRegistry.fromYangInstanceIdentifier(normalized)); + } catch (final IllegalArgumentException e) { + return Optional.absent(); + } } public DataNormalizer getDataNormalizer() { return legacyToNormalized; } - public Entry, DataObject> toBinding( - final Entry> normalized) - throws DeserializationException { - InstanceIdentifier bindingPath = toBinding(normalized.getKey()); - DataObject bindingData = toBinding(bindingPath, normalized.getValue()); - return toEntry(bindingPath, bindingData); + public Optional, DataObject>> toBinding( + final @Nonnull Entry> normalized) + throws DeserializationException { + try { + /* + * 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", "rawtypes" }) + 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); + legacyToNormalized = new DataNormalizer (arg0); + runtimeContext = BindingRuntimeContext.create(classLoadingStrategy, arg0); + codecRegistry.onBindingRuntimeContextUpdated(runtimeContext); + } + + public Function>, Optional> deserializeFunction(final InstanceIdentifier path) { + return codecRegistry.deserializeFunction(path); + } + + /** + * Returns an default object according to YANG schema for supplied path. + * + * @param path DOM Path + * @return Node with defaults set on. + */ + public NormalizedNode getDefaultNodeFor(final YangInstanceIdentifier path) { + final Iterator iterator = path.getPathArguments().iterator(); + DataNormalizationOperation currentOp = legacyToNormalized.getRootOperation(); + while (iterator.hasNext()) { + final PathArgument currentArg = iterator.next(); + try { + currentOp = currentOp.getChild(currentArg); + } catch (final DataNormalizationException e) { + throw new IllegalArgumentException(String.format("Invalid child encountered in path %s", path), e); + } + } + return currentOp.createDefault(path.getLastPathArgument()); + } + + public BindingNormalizedNodeCodecRegistry getCodecRegistry() { + return codecRegistry; + } + + @Override + 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 QNameModule moduleName = BindingReflections.getQNameModule(key); + final Module module = runtimeContext.getSchemaContext().findModuleByNamespaceAndRevision(moduleName.getNamespace(), moduleName.getRevision()); + 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(); + } + + 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); + } + + @Override + public BindingCodecTree create(BindingRuntimeContext context) { + return codecRegistry.create(context); + } + + @Override + public BindingCodecTree create(SchemaContext context, Class... bindingClasses) { + return codecRegistry.create(context, bindingClasses); } }