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=6b519955accd308109657dcb44823e4bca3d595d;hp=f885b323e6c04c34d23356c50722c24dfc755ac7;hb=92f1fd15e99ce5b9e52612c0b52f70cd661b99cc;hpb=a2c374bb7bd34eb27bac4db587e843378181762e 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..6b519955ac 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,27 +7,49 @@ */ package org.opendaylight.controller.md.sal.binding.impl; +import java.lang.reflect.Method; +import java.lang.reflect.Type; import java.util.AbstractMap.SimpleEntry; +import java.util.LinkedList; +import java.util.List; import java.util.Map.Entry; +import javax.annotation.Nullable; + +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.yang.binding.DataContainer; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item; +import org.opendaylight.yangtools.yang.binding.util.BindingReflections; +import org.opendaylight.yangtools.yang.binding.util.ClassLoaderUtils; +import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.CompositeNode; +import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier; +import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier; 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.ContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode; 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.data.impl.schema.Builders; 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.base.Function; +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.base.Supplier; import com.google.common.collect.ImmutableList; +import com.google.common.collect.Iterables; public class BindingToNormalizedNodeCodec implements SchemaContextListener { @@ -43,68 +65,215 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { public org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toNormalized( final InstanceIdentifier binding) { - return legacyToNormalized.toNormalized(bindingToLegacy.toDataDom(binding)); + + // Used instance-identifier codec do not support serialization of last + // path + // argument if it is Augmentation (behaviour expected by old datastore) + // in this case, we explicitly check if last argument is augmentation + // to process it separately + if (isAugmentationIdentifier(binding)) { + return toNormalizedAugmented(binding); + } + return toNormalizedImpl(binding); } public Entry> toNormalizedNode( final InstanceIdentifier bindingPath, final DataObject bindingObject) { - return toNormalizedNode(toEntry(bindingPath, bindingObject)); + return toNormalizedNode(toBindingEntry(bindingPath, bindingObject)); } public Entry> toNormalizedNode( final Entry, DataObject> binding) { - Entry> normalizedEntry = legacyToNormalized.toNormalized(bindingToLegacy.toDataDom(binding)); - if(Augmentation.class.isAssignableFrom(binding.getKey().getTargetType())) { - - 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); - } + Entry legacyEntry = bindingToLegacy + .toDataDom(binding); + Entry> normalizedEntry = legacyToNormalized + .toNormalized(legacyEntry); + LOG.trace("Serialization of {}, Legacy Representation: {}, Normalized Representation: {}", binding, + legacyEntry, normalizedEntry); + if (isAugmentation(binding.getKey().getTargetType())) { + + for (DataContainerChild child : ((DataContainerNode) normalizedEntry + .getValue()).getValue()) { + if (child instanceof AugmentationNode) { + ImmutableList childArgs = ImmutableList. builder() + .addAll(normalizedEntry.getKey().getPathArguments()).add(child.getIdentifier()).build(); + org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create( + childArgs); + return toDOMEntry(childPath, child); + } } } return normalizedEntry; + } + + /** + * + * 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 org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) + throws DeserializationException { + PathArgument lastArgument = Iterables.getLast(normalized.getPathArguments()); + // Used instance-identifier codec do not support serialization of last + // path + // argument if it is AugmentationIdentifier (behaviour expected by old + // datastore) + // in this case, we explicitly check if last argument is augmentation + // to process it separately + if (lastArgument instanceof AugmentationIdentifier) { + return toBindingAugmented(normalized); + } + return toBindingImpl(normalized); } - public InstanceIdentifier toBinding( + private Optional> toBindingAugmented( final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) - throws DeserializationException { + throws DeserializationException { + Optional> potential = toBindingImpl(normalized); + // Shorthand check, if codec already supports deserialization + // of AugmentationIdentifier we will return + if (potential.isPresent() && isAugmentationIdentifier(potential.get())) { + return potential; + } + + int normalizedCount = getAugmentationCount(normalized); + AugmentationIdentifier lastArgument = (AugmentationIdentifier) Iterables.getLast(normalized.getPathArguments()); + + // Here we employ small trick - Binding-aware Codec injects an pointer + // to augmentation class + // if child is referenced - so we will reference child and then shorten + // path. + LOG.trace("Looking for candidates to match {}", normalized); + for (QName child : lastArgument.getPossibleChildNames()) { + org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = normalized.node(child); + try { + if (isNotRepresentable(childPath)) { + LOG.trace("Path {} is not BI-representable, skipping it", childPath); + continue; + } + } catch (DataNormalizationException e) { + LOG.warn("Failed to denormalize path {}, skipping it", childPath, e); + continue; + } + + Optional> baId = toBindingImpl(childPath); + if (!baId.isPresent()) { + LOG.debug("No binding-aware identifier found for path {}, skipping it", childPath); + continue; + } + + InstanceIdentifier potentialPath = shortenToLastAugment(baId.get()); + int potentialAugmentCount = getAugmentationCount(potentialPath); + if (potentialAugmentCount == normalizedCount) { + LOG.trace("Found matching path {}", potentialPath); + return Optional.> of(potentialPath); + } + + LOG.trace("Skipping mis-matched potential path {}", potentialPath); + } + + LOG.trace("Failed to find augmentation matching {}", normalized); + return Optional.absent(); + } + + private Optional> toBindingImpl( + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) + throws DeserializationException { + org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath; + + try { + if (isNotRepresentable(normalized)) { + return Optional.absent(); + } + legacyPath = legacyToNormalized.toLegacy(normalized); + } catch (DataNormalizationException e) { + throw new IllegalStateException("Could not denormalize path.", e); + } + LOG.trace("InstanceIdentifier Path Deserialization: Legacy representation {}, Normalized representation: {}", + legacyPath, normalized); + return Optional.> of(bindingToLegacy.fromDataDom(legacyPath)); + } - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath = legacyToNormalized - .toLegacy(normalized); - return bindingToLegacy.fromDataDom(legacyPath); + private boolean isNotRepresentable(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) + throws DataNormalizationException { + DataNormalizationOperation op = findNormalizationOperation(normalized); + if( op.isMixin() && op.getIdentifier() instanceof NodeIdentifier) { + return true; + } + if(op.isLeaf()) { + return true; + } + return false; } - private static final Entry, DataObject> toEntry( + private DataNormalizationOperation findNormalizationOperation( + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) + throws DataNormalizationException { + DataNormalizationOperation current = legacyToNormalized.getRootOperation(); + for (PathArgument arg : normalized.getPathArguments()) { + current = current.getChild(arg); + } + return current; + } + + private static final Entry, DataObject> toBindingEntry( final org.opendaylight.yangtools.yang.binding.InstanceIdentifier key, final DataObject value) { return new SimpleEntry, DataObject>( key, value); } + private static final Entry> toDOMEntry( + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier key, + final NormalizedNode value) { + return new SimpleEntry>( + key, value); + } + public DataObject toBinding(final InstanceIdentifier path, final NormalizedNode normalizedNode) throws DeserializationException { - return bindingToLegacy.dataObjectFromDataDom(path, (CompositeNode) DataNormalizer.toLegacy(normalizedNode)); + CompositeNode legacy = null; + if (isAugmentationIdentifier(path) && normalizedNode instanceof AugmentationNode) { + QName augIdentifier = BindingReflections.findQName(path.getTargetType()); + ContainerNode virtualNode = Builders.containerBuilder() // + .withNodeIdentifier(new NodeIdentifier(augIdentifier)) // + .withChild((DataContainerChild) normalizedNode) // + .build(); + legacy = (CompositeNode) DataNormalizer.toLegacy(virtualNode); + } else { + legacy = (CompositeNode) DataNormalizer.toLegacy(normalizedNode); + } + + return bindingToLegacy.dataObjectFromDataDom(path, legacy); } public DataNormalizer getDataNormalizer() { return legacyToNormalized; } - public Entry, DataObject> toBinding( + public Optional, DataObject>> toBinding( final Entry> normalized) - throws DeserializationException { - InstanceIdentifier bindingPath = toBinding(normalized.getKey()); - DataObject bindingData = toBinding(bindingPath, normalized.getValue()); - return toEntry(bindingPath, bindingData); + throws DeserializationException { + Optional> potentialPath = toBinding(normalized.getKey()); + if (potentialPath.isPresent()) { + InstanceIdentifier bindingPath = potentialPath.get(); + DataObject bindingData = toBinding(bindingPath, normalized.getValue()); + if (bindingData == null) { + LOG.warn("Failed to deserialize {} to Binding format. Binding path is: {}", normalized, bindingPath); + } + return Optional.of(toBindingEntry(bindingPath, bindingData)); + } else { + return Optional.absent(); + } } @Override @@ -112,4 +281,193 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { legacyToNormalized = new DataNormalizer(arg0); } + private org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toNormalizedAugmented( + final InstanceIdentifier augPath) { + org.opendaylight.yangtools.yang.data.api.InstanceIdentifier processed = toNormalizedImpl(augPath); + // If used instance identifier codec added supports for deserialization + // of last AugmentationIdentifier we will just reuse it + if (isAugmentationIdentifier(processed)) { + return processed; + } + // Here we employ small trick - DataNormalizer injects augmentation + // identifier if child is + // also part of the path (since using a child we can safely identify + // augmentation) + // so, we scan augmentation for children add it to path + // and use original algorithm, then shorten it to last augmentation + for (@SuppressWarnings("rawtypes") + Class augChild : getAugmentationChildren(augPath.getTargetType())) { + @SuppressWarnings("unchecked") + InstanceIdentifier childPath = augPath.child(augChild); + org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized = toNormalizedImpl(childPath); + org.opendaylight.yangtools.yang.data.api.InstanceIdentifier potentialDiscovered = shortenToLastAugmentation(normalized); + if (potentialDiscovered != null) { + return potentialDiscovered; + } + } + return processed; + } + + private org.opendaylight.yangtools.yang.data.api.InstanceIdentifier shortenToLastAugmentation( + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) { + int position = 0; + int foundPosition = -1; + for (PathArgument arg : normalized.getPathArguments()) { + position++; + if (arg instanceof AugmentationIdentifier) { + foundPosition = position; + } + } + if (foundPosition > 0) { + Iterable shortened = Iterables.limit(normalized.getPathArguments(), foundPosition); + return org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create(shortened); + } + return null; + } + + private InstanceIdentifier shortenToLastAugment( + final InstanceIdentifier binding) { + int position = 0; + int foundPosition = -1; + for (org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : binding.getPathArguments()) { + position++; + if (isAugmentation(arg.getType())) { + foundPosition = position; + } + } + return InstanceIdentifier.create(Iterables.limit(binding.getPathArguments(), foundPosition)); + } + + private org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toNormalizedImpl( + final InstanceIdentifier binding) { + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath = bindingToLegacy + .toDataDom(binding); + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized = legacyToNormalized + .toNormalized(legacyPath); + return normalized; + } + + @SuppressWarnings("unchecked") + private Iterable> getAugmentationChildren(final Class targetType) { + List> ret = new LinkedList<>(); + for (Method method : targetType.getMethods()) { + Class entity = getYangModeledType(method); + if (entity != null) { + ret.add((Class) entity); + } + } + return ret; + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + private Class getYangModeledType(final Method method) { + if (method.getName().equals("getClass") || !method.getName().startsWith("get") + || method.getParameterTypes().length > 0) { + return null; + } + + Class returnType = method.getReturnType(); + if (DataContainer.class.isAssignableFrom(returnType)) { + return (Class) returnType; + } else if (List.class.isAssignableFrom(returnType)) { + try { + return ClassLoaderUtils.withClassLoader(method.getDeclaringClass().getClassLoader(), + new Supplier() { + @Override + public Class get() { + Type listResult = ClassLoaderUtils.getFirstGenericParameter(method + .getGenericReturnType()); + if (listResult instanceof Class + && DataObject.class.isAssignableFrom((Class) listResult)) { + return (Class) listResult; + } + return null; + } + + }); + } catch (Exception e) { + LOG.debug("Could not get YANG modeled entity for {}", method, e); + return null; + } + + } + return null; + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + private static InstanceIdentifier toWildcarded(final InstanceIdentifier orig) { + List wildArgs = new LinkedList<>(); + for (org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : orig.getPathArguments()) { + wildArgs.add(new Item(arg.getType())); + } + return InstanceIdentifier.create(wildArgs); + } + + private static boolean isAugmentation(final Class type) { + return Augmentation.class.isAssignableFrom(type); + } + + private static boolean isAugmentationIdentifier(final InstanceIdentifier potential) { + return Augmentation.class.isAssignableFrom(potential.getTargetType()); + } + + private boolean isAugmentationIdentifier(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier processed) { + return Iterables.getLast(processed.getPathArguments()) instanceof AugmentationIdentifier; + } + + private static int getAugmentationCount(final InstanceIdentifier potential) { + int count = 0; + for(org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : potential.getPathArguments()) { + if(isAugmentation(arg.getType())) { + count++; + } + + } + return count; + } + + private static int getAugmentationCount(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier potential) { + int count = 0; + for(PathArgument arg : potential.getPathArguments()) { + if(arg instanceof AugmentationIdentifier) { + count++; + } + } + return count; + } + + public Function>, Optional> deserializeFunction(final InstanceIdentifier path) { + return new DeserializeFunction(this, path); + } + + private static class DeserializeFunction implements Function>, Optional> { + + private final BindingToNormalizedNodeCodec codec; + private final InstanceIdentifier path; + + public DeserializeFunction(final BindingToNormalizedNodeCodec codec, final InstanceIdentifier path) { + super(); + this.codec = Preconditions.checkNotNull(codec, "Codec must not be null"); + this.path = Preconditions.checkNotNull(path, "Path must not be null"); + } + + @Nullable + @Override + public Optional apply(@Nullable final Optional> normalizedNode) { + if (normalizedNode.isPresent()) { + final DataObject dataObject; + try { + dataObject = codec.toBinding(path, normalizedNode.get()); + } catch (DeserializationException e) { + LOG.warn("Failed to create dataobject from node {}", normalizedNode.get(), e); + throw new IllegalStateException("Failed to create dataobject", e); + } + + if (dataObject != null) { + return Optional.of(dataObject); + } + } + return Optional.absent(); + } + } }