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=f8c1cf6b99f4dfd7664251db168b0f59eddce557;hp=6b519955accd308109657dcb44823e4bca3d595d;hb=7de815a866483636d621ba0953684a42c36f208e;hpb=e2df8aa67238c153f1038eb45f7799442861985b 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 6b519955ac..f8c1cf6b99 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 @@ -8,11 +8,11 @@ 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.HashSet; +import java.util.Iterator; import java.util.Map.Entry; +import java.util.Set; import javax.annotation.Nullable; @@ -20,13 +20,13 @@ import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizat 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.BindingMapping; 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.YangModuleInfo; 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.common.QNameModule; 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; @@ -39,6 +39,9 @@ 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.AugmentationSchema; +import org.opendaylight.yangtools.yang.model.api.AugmentationTarget; +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaContextListener; import org.slf4j.Logger; @@ -47,7 +50,7 @@ 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.base.Predicate; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; @@ -98,8 +101,8 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { 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); + org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier + .create(childArgs); return toDOMEntry(childPath, child); } } @@ -206,10 +209,10 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { 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) { + if (op.isMixin() && op.getIdentifier() instanceof NodeIdentifier) { return true; } - if(op.isLeaf()) { + if (op.isLeaf()) { return true; } return false; @@ -233,10 +236,9 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { } private static final Entry> toDOMEntry( - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier key, - final NormalizedNode value) { - return new SimpleEntry>( - key, value); + 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) @@ -289,27 +291,155 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { 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())) { + Optional additionalSerialized; + additionalSerialized = toNormalizedAugmentedUsingChildContainers(augPath, processed); + + if (additionalSerialized.isPresent()) { + return additionalSerialized.get(); + } + additionalSerialized = toNormalizedAugmentedUsingChildLeafs(augPath, processed); + if (additionalSerialized.isPresent()) { + return additionalSerialized.get(); + } + throw new IllegalStateException("Unabled to construct augmentation identfier for " + augPath); + } + + /** + * Tries to find correct augmentation identifier using children leafs + * + * This method uses normalized Instance Identifier of parent node to fetch + * schema and {@link BindingReflections#getModuleInfo(Class)} to learn about + * augmentation namespace, specificly, in which module it was defined. + * + * Then it uses it to filter all available augmentations for parent by + * module. After that it walks augmentations in particular module and + * pick-up first which at least one leaf name matches supplied augmentation. + * We could do this safely since YANG explicitly states that no any existing + * augmentations must differ in leaf fully qualified names. + * + * + * @param augPath + * Binding Aware Path which ends with augment + * @param parentPath + * Processed path + * @return + */ + private Optional toNormalizedAugmentedUsingChildLeafs( + final InstanceIdentifier augPath, + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier parentPath) { + try { + DataNormalizationOperation parentOp = legacyToNormalized.getOperation(parentPath); + if(!parentOp.getDataSchemaNode().isPresent()) { + return Optional.absent(); + } + DataSchemaNode parentSchema = parentOp.getDataSchemaNode().get(); + if (parentSchema instanceof AugmentationTarget) { + Set augmentations = ((AugmentationTarget) parentSchema).getAvailableAugmentations(); + LOG.info("Augmentations for {}, {}", augPath, augmentations); + Optional schema = findAugmentation(augPath.getTargetType(), augmentations); + if (schema.isPresent()) { + AugmentationIdentifier augmentationIdentifier = DataNormalizationOperation + .augmentationIdentifierFrom(schema.get()); + return Optional.of(parentPath.node(augmentationIdentifier)); + } + } + } catch (DataNormalizationException e) { + throw new IllegalArgumentException(e); + } + return Optional.absent(); + } + + /** + * Creates instance identifier for augmentation child, tries to serialize it + * Instance Identifier is then shortened to last augmentation. + * + * This is for situations, where underlying codec is implementing hydrogen + * style DOM APIs (which did not supported {@link AugmentationIdentifier}.) + * + * @param augPath + * @param parentPath + * Path to parent node + * @return + */ + @SuppressWarnings("rawtypes") + private Optional toNormalizedAugmentedUsingChildContainers( + final InstanceIdentifier augPath, + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier parentPath) { + for (Class augChild : BindingReflections.getChildrenClasses(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); + org.opendaylight.yangtools.yang.data.api.InstanceIdentifier potentialDiscovered = shortenToLastAugmentation( + normalized, parentPath); if (potentialDiscovered != null) { - return potentialDiscovered; + return Optional.of(potentialDiscovered); + } + } + return Optional.absent(); + } + + private Optional findAugmentation(final Class targetType, + final Set augmentations) { + YangModuleInfo moduleInfo; + try { + moduleInfo = BindingReflections.getModuleInfo(targetType); + } catch (Exception e) { + throw new IllegalStateException(e); + } + Iterable filtered = filteredByModuleInfo(augmentations, + BindingReflections.getModuleQName(moduleInfo).getModule()); + filtered.toString(); + Set targetTypeGetters = getYangModeledGetters(targetType); + for (AugmentationSchema schema : filtered) { + for (DataSchemaNode child : schema.getChildNodes()) { + String getterName = "get" + BindingMapping.getClassName(child.getQName()); + if (targetTypeGetters.contains(getterName)) { + return Optional.of(schema); + } } } - return processed; + return Optional.absent(); + } + + private static Iterable filteredByModuleInfo(final Iterable augmentations, + final QNameModule module) { + return Iterables.filter(augmentations, new Predicate() { + @Override + public boolean apply(final AugmentationSchema schema) { + final Set childNodes = schema.getChildNodes(); + return !schema.getChildNodes().isEmpty() + && module.equals(Iterables.get(childNodes, 0).getQName().getModule()); + } + }); + } + + public static final Set getYangModeledGetters(final Class targetType) { + HashSet ret = new HashSet(); + for (Method method : targetType.getMethods()) { + if (isYangModeledGetter(method)) { + ret.add(method.getName()); + } + } + return ret; + } + + /** + * + * Returns true if supplied method represent getter for YANG modeled value + * + * @param method + * Method to be tested + * @return true if method represent getter for YANG Modeled value. + */ + private static final boolean isYangModeledGetter(final Method method) { + return !method.getName().equals("getClass") && !method.getName().equals("getImplementedInterface") + && method.getName().startsWith("get") && method.getParameterTypes().length == 0; } private org.opendaylight.yangtools.yang.data.api.InstanceIdentifier shortenToLastAugmentation( - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) { + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized, + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier parentPath) { + int parentSize = Iterables.size(parentPath.getPathArguments()); int position = 0; int foundPosition = -1; for (PathArgument arg : normalized.getPathArguments()) { @@ -318,7 +448,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { foundPosition = position; } } - if (foundPosition > 0) { + if (foundPosition > 0 && foundPosition > parentSize) { Iterable shortened = Iterables.limit(normalized.getPathArguments(), foundPosition); return org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create(shortened); } @@ -347,62 +477,6 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { 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); } @@ -417,8 +491,8 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { 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())) { + for (org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : potential.getPathArguments()) { + if (isAugmentation(arg.getType())) { count++; } @@ -428,19 +502,20 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { 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) { + for (PathArgument arg : potential.getPathArguments()) { + if (arg instanceof AugmentationIdentifier) { count++; } } return count; } - public Function>, Optional> deserializeFunction(final InstanceIdentifier path) { + @SuppressWarnings({ "rawtypes", "unchecked" }) + public Function>, Optional> deserializeFunction(final InstanceIdentifier path) { return new DeserializeFunction(this, path); } - private static class DeserializeFunction implements Function>, Optional> { + private static class DeserializeFunction implements Function>, Optional> { private final BindingToNormalizedNodeCodec codec; private final InstanceIdentifier path; @@ -451,9 +526,10 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { this.path = Preconditions.checkNotNull(path, "Path must not be null"); } + @SuppressWarnings("rawtypes") @Nullable @Override - public Optional apply(@Nullable final Optional> normalizedNode) { + public Optional apply(@Nullable final Optional> normalizedNode) { if (normalizedNode.isPresent()) { final DataObject dataObject; try { @@ -470,4 +546,24 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { return Optional.absent(); } } + + /** + * 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 org.opendaylight.yangtools.yang.data.api.InstanceIdentifier path) { + Iterator iterator = path.getPathArguments().iterator(); + DataNormalizationOperation currentOp = legacyToNormalized.getRootOperation(); + while (iterator.hasNext()) { + PathArgument currentArg = iterator.next(); + try { + currentOp = currentOp.getChild(currentArg); + } catch (DataNormalizationException e) { + throw new IllegalArgumentException(String.format("Invalid child encountered in path %s", path), e); + } + } + return currentOp.createDefault(path.getLastPathArgument()); + } }