*/
package org.opendaylight.controller.md.sal.binding.impl;
+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.lang.reflect.Type;
-import java.util.AbstractMap.SimpleEntry;
-import java.util.LinkedList;
-import java.util.List;
+import java.util.Iterator;
import java.util.Map.Entry;
-import java.util.concurrent.Callable;
-
+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.concepts.util.ClassLoaderUtils;
-import org.opendaylight.yangtools.yang.binding.Augmentation;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
+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.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.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item;
+import org.opendaylight.yangtools.yang.binding.RpcService;
import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
-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.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.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.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;
-import com.google.common.collect.Iterables;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-public class BindingToNormalizedNodeCodec implements SchemaContextListener {
+public class BindingToNormalizedNodeCodec implements BindingCodecTreeFactory, SchemaContextListener, AutoCloseable {
- private static final Logger LOG = LoggerFactory.getLogger(BindingToNormalizedNodeCodec.class);
-
- 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 org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toNormalized(
- final InstanceIdentifier<? extends DataObject> 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<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode(
- final InstanceIdentifier<? extends DataObject> bindingPath, final DataObject bindingObject) {
- return toNormalizedNode(toEntry(bindingPath, bindingObject));
+ public BindingToNormalizedNodeCodec(final GeneratedClassLoadingStrategy classLoadingStrategy,
+ final BindingNormalizedNodeCodecRegistry codecRegistry) {
+ this.classLoadingStrategy = classLoadingStrategy;
+ this.codecRegistry = codecRegistry;
}
- public Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode(
- final Entry<org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject>, DataObject> binding) {
- Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> legacyEntry = bindingToLegacy
- .toDataDom(binding);
- Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> normalizedEntry = legacyToNormalized
- .toNormalized(legacyEntry);
- LOG.trace("Serialization of {}, Legacy Representation: {}, Normalized Representation: {}", binding,
- legacyEntry, normalizedEntry);
- if (Augmentation.class.isAssignableFrom(binding.getKey().getTargetType())) {
-
- for (DataContainerChild<? extends PathArgument, ?> child : ((DataContainerNode<?>) normalizedEntry
- .getValue()).getValue()) {
- if (child instanceof AugmentationNode) {
- ImmutableList<PathArgument> childArgs = ImmutableList.<PathArgument> 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<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>>(
- childPath, child);
- }
- }
-
- }
- return normalizedEntry;
-
+ public YangInstanceIdentifier toNormalized(final InstanceIdentifier<? extends DataObject> binding) {
+ return codecRegistry.toYangInstanceIdentifier(binding);
}
- public InstanceIdentifier<? extends DataObject> toBinding(
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized)
- throws DeserializationException {
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ public Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode(
+ final InstanceIdentifier<? extends DataObject> bindingPath, final DataObject bindingObject) {
+ return codecRegistry.toNormalizedNode((InstanceIdentifier) bindingPath, bindingObject);
- 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)
- // 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);
}
- private InstanceIdentifier<? extends DataObject> toBindingAugmented(
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) throws DeserializationException {
- InstanceIdentifier<? extends DataObject> potential = toBindingImpl(normalized);
- // Shorthand check, if codec already supports deserialization
- // of AugmentationIdentifier we will return
- if(isAugmentationIdentifier(potential)) {
- 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.
- for (QName child : lastArgument.getPossibleChildNames()) {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = new org.opendaylight.yangtools.yang.data.api.InstanceIdentifier(
- ImmutableList.<PathArgument> builder()
- .addAll(normalized.getPath()).add(new NodeIdentifier(child)).build());
- try {
-
- InstanceIdentifier<? extends DataObject> potentialPath = shortenToLastAugment(toBindingImpl(childPath));
- return potentialPath;
- } catch (Exception e) {
- LOG.trace("Unable to deserialize aug. child path for {}",childPath,e);
- }
- }
- return toBindingImpl(normalized);
+ public Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode(
+ final Entry<InstanceIdentifier<? extends DataObject>, DataObject> binding) {
+ return toNormalizedNode(binding.getKey(),binding.getValue());
}
- private InstanceIdentifier<? extends DataObject> toBindingImpl(
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized)
- throws DeserializationException {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath;
+ /**
+ *
+ * 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<InstanceIdentifier<? extends DataObject>> toBinding(final YangInstanceIdentifier normalized)
+ throws DeserializationException {
try {
- 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);
- }
-
- private static final Entry<org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject>, DataObject> toEntry(
- final org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject> key,
- final DataObject value) {
- return new SimpleEntry<org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject>, DataObject>(
- key, value);
- }
-
- public DataObject toBinding(final InstanceIdentifier<?> path, final NormalizedNode<?, ?> normalizedNode)
- throws DeserializationException {
- 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 Optional.<InstanceIdentifier<? extends DataObject>>fromNullable(codecRegistry.fromYangInstanceIdentifier(normalized));
+ } catch (final IllegalArgumentException e) {
+ return Optional.absent();
}
-
- return bindingToLegacy.dataObjectFromDataDom(path, legacy);
}
public DataNormalizer getDataNormalizer() {
return legacyToNormalized;
}
- public Entry<org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject>, DataObject> toBinding(
- final Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, ? extends NormalizedNode<?, ?>> normalized)
- throws DeserializationException {
- InstanceIdentifier<? extends DataObject> bindingPath = toBinding(normalized.getKey());
- DataObject bindingData = toBinding(bindingPath, normalized.getValue());
- return toEntry(bindingPath, bindingData);
+ public Optional<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> toBinding(
+ final @Nonnull Entry<YangInstanceIdentifier, ? extends NormalizedNode<?, ?>> normalized)
+ throws DeserializationException {
+ try {
+ /*
+ * This cast is required, due to generics behaviour in openjdk / oracle javac
+ *
+ * InstanceIdentifier has definition InstanceIdentifier<T extends DataObject>,
+ * this means '?' is always <? extends DataObject>. Eclipse compiler
+ * is able to determine this relationship and treats
+ * Entry<InstanceIdentifier<?>,DataObject> and Entry<InstanceIdentifier<? extends DataObject,DataObject>
+ * 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<InstanceIdentifier<? extends DataObject>, 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);
- }
-
- 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 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())) {
- @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.getPath()) {
- position++;
- if (arg instanceof AugmentationIdentifier) {
- foundPosition = position;
+ legacyToNormalized = new DataNormalizer (arg0);
+ runtimeContext = BindingRuntimeContext.create(classLoadingStrategy, arg0);
+ codecRegistry.onBindingRuntimeContextUpdated(runtimeContext);
+ }
+
+ public <T extends DataObject> Function<Optional<NormalizedNode<?, ?>>, Optional<T>> deserializeFunction(final InstanceIdentifier<T> 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<PathArgument> 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);
}
}
- if (foundPosition > 0) {
- return new org.opendaylight.yangtools.yang.data.api.InstanceIdentifier(normalized.getPath().subList(0,
- foundPosition));
- }
- return null;
+ return currentOp.createDefault(path.getLastPathArgument());
}
- private InstanceIdentifier<? extends DataObject> shortenToLastAugment(
- final InstanceIdentifier<? extends DataObject> 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));
+ public BindingNormalizedNodeCodecRegistry getCodecRegistry() {
+ return codecRegistry;
}
-
-
- private org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toNormalizedImpl(
- final InstanceIdentifier<? extends DataObject> 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;
+ @Override
+ public void close() {
+ // NOOP Intentionally
}
- @SuppressWarnings("unchecked")
- private Iterable<Class<? extends DataObject>> getAugmentationChildren(final Class<?> targetType) {
- List<Class<? extends DataObject>> ret = new LinkedList<>();
- for (Method method : targetType.getMethods()) {
- Class<?> entity = getYangModeledType(method);
- if (entity != null) {
- ret.add((Class<? extends DataObject>) entity);
- }
- }
- return ret;
+ public BindingNormalizedNodeCodecRegistry getCodecFactory() {
+ return codecRegistry;
}
- @SuppressWarnings({ "rawtypes", "unchecked" })
- private Class<? extends DataObject> 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 Callable<Class>() {
-
- @SuppressWarnings("rawtypes")
- @Override
- public Class call() throws Exception {
- 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;
+ // FIXME: This should be probably part of Binding Runtime context
+ public ImmutableBiMap<Method, SchemaPath> getRpcMethodToSchemaPath(final Class<? extends RpcService> key) {
+ final QNameModule moduleName = BindingReflections.getQNameModule(key);
+ final Module module = runtimeContext.getSchemaContext().findModuleByNamespaceAndRevision(moduleName.getNamespace(), moduleName.getRevision());
+ final ImmutableBiMap.Builder<Method, SchemaPath> ret = ImmutableBiMap.<Method, SchemaPath>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 null;
+ return ret.build();
}
- @SuppressWarnings({ "unchecked", "rawtypes" })
- private static InstanceIdentifier<?> toWildcarded(final InstanceIdentifier<?> orig) {
- List<org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument> wildArgs = new LinkedList<>();
- for (org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : orig.getPathArguments()) {
- wildArgs.add(new Item(arg.getType()));
+ private Method findRpcMethod(final Class<? extends RpcService> 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 InstanceIdentifier.create(wildArgs);
+ return key.getMethod(methodName);
}
-
- private static boolean isAugmentation(final Class<? extends DataObject> type) {
- return Augmentation.class.isAssignableFrom(type);
+ @Override
+ public BindingCodecTree create(BindingRuntimeContext context) {
+ return codecRegistry.create(context);
}
- private static boolean isAugmentationIdentifier(final InstanceIdentifier<?> path) {
- return Augmentation.class.isAssignableFrom(path.getTargetType());
+ @Override
+ public BindingCodecTree create(SchemaContext context, Class<?>... bindingClasses) {
+ return codecRegistry.create(context, bindingClasses);
}
- private boolean isAugmentationIdentifier(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier processed) {
- return Iterables.getLast(processed.getPath()) instanceof AugmentationIdentifier;
- }
}