Bug 2327: Handle binary data in NormalizedNode streaming

[controller.git] / opendaylight / md-sal / sal-clustering-commons / src / main / java / org / opendaylight / controller / cluster / datastore / node / NormalizedNodeToNodeCodec.java

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/NormalizedNodeToNodeCodec.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/NormalizedNodeToNodeCodec.java
index d1ae264c3b912839a4332fc74766076859b754db..6669e48627b6b782327684fcc9a13818b867816a 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/NormalizedNodeToNodeCodec.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/NormalizedNodeToNodeCodec.java
@@ -10,65 +10,116 @@
 
 package org.opendaylight.controller.cluster.datastore.node;
 
+import org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeSerializer;
+import org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeSerializer.DeSerializer;
+import org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeSerializer.Serializer;
 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
-import org.opendaylight.controller.cluster.datastore.node.utils.PathUtils;
-import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Container;
+import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 public class NormalizedNodeToNodeCodec {
+    public interface Encoded {
+        NormalizedNodeMessages.Container getEncodedNode();
+
+        NormalizedNodeMessages.InstanceIdentifier getEncodedPath();
+    }
+
+    public interface Decoded {
+        NormalizedNode<?,?> getDecodedNode();
+
+        YangInstanceIdentifier getDecodedPath();
+    }
+
     private final SchemaContext ctx;
-    private static final Logger logger = LoggerFactory.getLogger(NormalizedNodeToNodeCodec.class);
 
     public NormalizedNodeToNodeCodec(final SchemaContext ctx){
         this.ctx = ctx;
+    }
 
+    public NormalizedNodeMessages.Container encode(NormalizedNode<?,?> node){
+        return encode(null, node).getEncodedNode();
     }
 
-    public NormalizedNodeMessages.Container encode(YangInstanceIdentifier id, NormalizedNode node){
-        String parentPath = "";
+    public Encoded encode(YangInstanceIdentifier path, NormalizedNode<?,?> node) {
+
+        NormalizedNodeMessages.InstanceIdentifier serializedPath = null;
 
-        if(id != null){
-            parentPath = PathUtils.getParentPath(PathUtils.toString(id));
+        NormalizedNodeMessages.Container.Builder builder = NormalizedNodeMessages.Container.newBuilder();
+
+        // Note: parent path is no longer used
+        builder.setParentPath("");
+
+        if(node != null) {
+            if(path == null) {
+                builder.setNormalizedNode(NormalizedNodeSerializer.serialize(node));
+            } else {
+                Serializer serializer = NormalizedNodeSerializer.newSerializer(node);
+                builder.setNormalizedNode(serializer.serialize(path));
+                serializedPath = serializer.getSerializedPath();
+            }
         }
 
+        return new EncodedImpl(builder.build(), serializedPath);
+    }
 
-        NormalizedNodeToProtocolBufferNode encoder = new NormalizedNodeToProtocolBufferNode();
-        encoder.encode(parentPath, node);
 
-        return encoder.getContainer();
+    public NormalizedNode<?,?> decode(NormalizedNodeMessages.Node node){
+        return decode(null, node).getDecodedNode();
+    }
 
+    public Decoded decode(NormalizedNodeMessages.InstanceIdentifier path,
+            NormalizedNodeMessages.Node node) {
+        if(node.getIntType() < 0 || node.getSerializedSize() == 0){
+            return new DecodedImpl(null, null);
+        }
 
+        DeSerializer deSerializer = NormalizedNodeSerializer.newDeSerializer(path, node);
+        NormalizedNode<?,?> decodedNode = deSerializer.deSerialize();
+        return new DecodedImpl(decodedNode, deSerializer.getDeserializedPath());
     }
 
-    public NormalizedNode<?,?> decode(YangInstanceIdentifier id, NormalizedNodeMessages.Node node){
-            NodeToNormalizedNodeBuilder currentOp = NodeToNormalizedNodeBuilder.from(ctx);
+    private static class DecodedImpl implements Decoded {
 
-            for(YangInstanceIdentifier.PathArgument pathArgument : id.getPathArguments()){
-                currentOp = currentOp.getChild(pathArgument);
-            }
+        private final NormalizedNode<?, ?> decodedNode;
+        private final YangInstanceIdentifier decodedPath;
 
-            QName nodeType = null;
+        public DecodedImpl(NormalizedNode<?, ?> decodedNode, YangInstanceIdentifier decodedPath) {
+            this.decodedNode = decodedNode;
+            this.decodedPath = decodedPath;
+        }
 
-            if(id.getPath().size() < 1){
-                nodeType = null;
-            } else {
-                final YangInstanceIdentifier.PathArgument pathArgument = id.getPath().get(id.getPath().size() - 1);
-                if(pathArgument instanceof YangInstanceIdentifier.AugmentationIdentifier){
-                    nodeType = null;
-                } else {
-                    nodeType = pathArgument.getNodeType();
-                }
-            }
-            if((node != null)&& (!node.getType().isEmpty())){
-               return currentOp.normalize(nodeType, node);
-            } else{
-              return null;
-            }
+        @Override
+        public NormalizedNode<?, ?> getDecodedNode() {
+            return decodedNode;
+        }
+
+        @Override
+        public YangInstanceIdentifier getDecodedPath() {
+            return decodedPath;
+        }
     }
 
+    private static class EncodedImpl implements Encoded {
 
+        private final Container encodedNode;
+        private final InstanceIdentifier encodedPath;
+
+        EncodedImpl(Container encodedNode, InstanceIdentifier encodedPath) {
+            this.encodedNode = encodedNode;
+            this.encodedPath = encodedPath;
+        }
+
+        @Override
+        public Container getEncodedNode() {
+            return encodedNode;
+        }
+
+        @Override
+        public InstanceIdentifier getEncodedPath() {
+            return encodedPath;
+        }
+    }
 }