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=53615ad7dedc6c7d751554fb7f28bf446b96f1ee;hp=6329637dd01cfdad2470345e4c8433a07fe62ebf;hb=b7c373b1edb9864feb6811bb6c370943d3e8f75f;hpb=31b7a44c89d1057489338492fcf62a64147bea24 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 6329637dd0..53615ad7de 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 @@ -16,6 +16,7 @@ import java.util.Map.Entry; import java.util.concurrent.Callable; 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.concepts.util.ClassLoaderUtils; import org.opendaylight.yangtools.yang.binding.Augmentation; @@ -42,6 +43,7 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContextListener; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import com.google.common.base.Optional; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; @@ -60,7 +62,8 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { public org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toNormalized( final InstanceIdentifier binding) { - // Used instance-identifier codec do not support serialization of last path + // 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 @@ -103,13 +106,24 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { } - public InstanceIdentifier toBinding( + /** + * + * 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.getPath()); - // Used instance-identifier codec do not support serialization of last path - // argument if it is AugmentationIdentifier (behaviour expected by old datastore) + // 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) { @@ -118,46 +132,71 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { return toBindingImpl(normalized); } - private InstanceIdentifier toBindingAugmented( - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) throws DeserializationException { - InstanceIdentifier potential = toBindingImpl(normalized); + private Optional> toBindingAugmented( + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) + throws DeserializationException { + Optional> potential = toBindingImpl(normalized); // Shorthand check, if codec already supports deserialization // of AugmentationIdentifier we will return - if(isAugmentationIdentifier(potential)) { + if (potential.isPresent() && isAugmentationIdentifier(potential.get())) { return potential; } AugmentationIdentifier lastArgument = (AugmentationIdentifier) Iterables.getLast(normalized.getPath()); - // 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. + // 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. for (QName child : lastArgument.getPossibleChildNames()) { org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = new org.opendaylight.yangtools.yang.data.api.InstanceIdentifier( - ImmutableList. builder() - .addAll(normalized.getPath()).add(new NodeIdentifier(child)).build()); + ImmutableList. builder().addAll(normalized.getPath()).add(new NodeIdentifier(child)) + .build()); try { - - InstanceIdentifier potentialPath = shortenToLastAugment(toBindingImpl(childPath)); - return potentialPath; + if (!isChoiceOrCasePath(childPath)) { + InstanceIdentifier potentialPath = shortenToLastAugment(toBindingImpl( + childPath).get()); + return Optional.> of(potentialPath); + } } catch (Exception e) { - LOG.trace("Unable to deserialize aug. child path for {}",childPath,e); + LOG.trace("Unable to deserialize aug. child path for {}", childPath, e); } } return toBindingImpl(normalized); } - private InstanceIdentifier toBindingImpl( + private Optional> toBindingImpl( final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) throws DeserializationException { org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath; + try { + if (isChoiceOrCasePath(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 bindingToLegacy.fromDataDom(legacyPath); + return Optional.> of(bindingToLegacy.fromDataDom(legacyPath)); + } + + private boolean isChoiceOrCasePath(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) + throws DataNormalizationException { + DataNormalizationOperation op = findNormalizationOperation(normalized); + return op.isMixin() && op.getIdentifier() instanceof NodeIdentifier; + } + + private DataNormalizationOperation findNormalizationOperation( + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) + throws DataNormalizationException { + DataNormalizationOperation current = legacyToNormalized.getRootOperation(); + for (PathArgument arg : normalized.getPath()) { + current = current.getChild(arg); + } + return current; } private static final Entry, DataObject> toEntry( @@ -170,7 +209,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { public DataObject toBinding(final InstanceIdentifier path, final NormalizedNode normalizedNode) throws DeserializationException { CompositeNode legacy = null; - if(isAugmentationIdentifier(path) && normalizedNode instanceof AugmentationNode) { + if (isAugmentationIdentifier(path) && normalizedNode instanceof AugmentationNode) { QName augIdentifier = BindingReflections.findQName(path.getTargetType()); ContainerNode virtualNode = Builders.containerBuilder() // .withNodeIdentifier(new NodeIdentifier(augIdentifier)) // @@ -188,12 +227,20 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { 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); + 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(toEntry(bindingPath, bindingData)); + } else { + return Optional.absent(); + } } @Override @@ -206,14 +253,17 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { 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)) { + if (isAugmentationIdentifier(processed)) { return processed; } - // Here we employ small trick - DataNormalizer injecst augmentation identifier if child is - // also part of the path (since using a child we can safely identify augmentation) + // Here we employ small trick - DataNormalizer injecst 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())) { + 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); @@ -225,8 +275,6 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { return processed; } - - private org.opendaylight.yangtools.yang.data.api.InstanceIdentifier shortenToLastAugmentation( final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) { int position = 0; @@ -248,7 +296,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { final InstanceIdentifier binding) { int position = 0; int foundPosition = -1; - for(org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : binding.getPathArguments()) { + for (org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : binding.getPathArguments()) { position++; if (isAugmentation(arg.getType())) { foundPosition = position; @@ -257,8 +305,6 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { 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 @@ -326,13 +372,12 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { return InstanceIdentifier.create(wildArgs); } - private static boolean isAugmentation(final Class type) { return Augmentation.class.isAssignableFrom(type); } - private static boolean isAugmentationIdentifier(final InstanceIdentifier path) { - return Augmentation.class.isAssignableFrom(path.getTargetType()); + 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) {