Merge "Bug 611 - NlriReg supports serialization"

diff --git a/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/NlriRegistry.java b/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/NlriRegistry.java
index 92a110dcce0178f39f545c46e1a30ad9ab4f86d2..802c04028bb5be5839f24f3035086d3edb5f8ad2 100644 (file)
--- a/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/NlriRegistry.java
+++ b/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/NlriRegistry.java
@@ -18,4 +18,5 @@ public interface NlriRegistry {
     MpUnreachNlri parseMpUnreach(final ByteBuf buffer) throws BGPParsingException;
     void serializeMpReach(final MpReachNlri mpReachNlri,final ByteBuf byteAggregator);
     void serializeMpUnReach(final MpUnreachNlri mpUnreachNlri,final ByteBuf byteAggregator);
+    Iterable<NlriSerializer> getSerializers();
 }

diff --git a/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/pojo/SimpleBGPExtensionProviderContext.java b/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/pojo/SimpleBGPExtensionProviderContext.java
index 7219feff91c9ffe802dda24c1e7f1d4baadec227..460fab3a9971a92ba5fd35517b76e5f7a46f4e42 100644 (file)
--- a/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/pojo/SimpleBGPExtensionProviderContext.java
+++ b/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/pojo/SimpleBGPExtensionProviderContext.java
@@ -33,13 +33,14 @@ import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.Notification;
 
 public class SimpleBGPExtensionProviderContext extends SimpleBGPExtensionConsumerContext implements BGPExtensionProviderContext {
+
     public static final int DEFAULT_MAXIMUM_CACHED_OBJECTS = 100000;
 
     private final AtomicReference<Cache<Object, Object>> cacheRef;
     private final ReferenceCache referenceCache = new ReferenceCache() {
         @Override
         public <T> T getSharedReference(final T object) {
-            final Cache<Object, Object> cache = cacheRef.get();
+            final Cache<Object, Object> cache = SimpleBGPExtensionProviderContext.this.cacheRef.get();
 
             @SuppressWarnings("unchecked")
             final T ret = (T) cache.getIfPresent(object);
@@ -61,85 +62,84 @@ public class SimpleBGPExtensionProviderContext extends SimpleBGPExtensionConsume
         this.maximumCachedObjects = maximumCachedObjects;
 
         final Cache<Object, Object> cache = CacheBuilder.newBuilder().maximumSize(maximumCachedObjects).build();
-        cacheRef = new AtomicReference<Cache<Object, Object>>(cache);
+        this.cacheRef = new AtomicReference<Cache<Object,Object>>(cache);
     }
 
     @Override
     public AutoCloseable registerAddressFamily(final Class<? extends AddressFamily> clazz, final int number) {
-        return afiReg.registerAddressFamily(clazz, number);
+        return this.afiReg.registerAddressFamily(clazz, number);
     }
 
     @Override
     public AutoCloseable registerAttributeParser(final int attributeType, final AttributeParser parser) {
-        return attrReg.registerAttributeParser(attributeType, parser);
+        return this.attrReg.registerAttributeParser(attributeType, parser);
     }
 
     @Override
     public AutoCloseable registerAttributeSerializer(final Class<? extends DataObject> attributeClass, final AttributeSerializer serializer) {
-        return attrReg.registerAttributeSerializer(attributeClass, serializer);
+        return this.attrReg.registerAttributeSerializer(attributeClass, serializer);
     }
 
     @Override
     public AutoCloseable registerCapabilityParser(final int capabilityType, final CapabilityParser parser) {
-        return capReg.registerCapabilityParser(capabilityType, parser);
+        return this.capReg.registerCapabilityParser(capabilityType, parser);
     }
 
     @Override
-    public AutoCloseable registerCapabilitySerializer(final Class<? extends CParameters> capabilityClass,
-            final CapabilitySerializer serializer) {
-        return capReg.registerCapabilitySerializer(capabilityClass, serializer);
+    public AutoCloseable registerCapabilitySerializer(final Class<? extends CParameters> capabilityClass, final CapabilitySerializer serializer) {
+        return this.capReg.registerCapabilitySerializer(capabilityClass, serializer);
     }
 
     @Override
     public AutoCloseable registerMessageParser(final int messageType, final MessageParser parser) {
-        return msgReg.registerMessageParser(messageType, parser);
+        return this.msgReg.registerMessageParser(messageType, parser);
     }
 
     @Override
     public AutoCloseable registerMessageSerializer(final Class<? extends Notification> messageClass, final MessageSerializer serializer) {
-        return msgReg.registerMessageSerializer(messageClass, serializer);
+        return this.msgReg.registerMessageSerializer(messageClass, serializer);
     }
 
     @Override
     public AutoCloseable registerNlriParser(final Class<? extends AddressFamily> afi, final Class<? extends SubsequentAddressFamily> safi,
             final NlriParser parser) {
-        return nlriReg.registerNlriParser(afi, safi, parser);
+        return this.nlriReg.registerNlriParser(afi, safi, parser);
     }
 
     @Override
     public AutoCloseable registerNlriSerializer(final Class<? extends DataObject> nlriClass, final NlriSerializer serializer) {
-        throw new UnsupportedOperationException("NLRI serialization not implemented");
+        return this.nlriReg.registerNlriSerializer(nlriClass,serializer);
     }
 
     @Override
     public AutoCloseable registerParameterParser(final int parameterType, final ParameterParser parser) {
-        return paramReg.registerParameterParser(parameterType, parser);
+        return this.paramReg.registerParameterParser(parameterType, parser);
     }
 
     @Override
     public AutoCloseable registerParameterSerializer(final Class<? extends BgpParameters> paramClass, final ParameterSerializer serializer) {
-        return paramReg.registerParameterSerializer(paramClass, serializer);
+        return this.paramReg.registerParameterSerializer(paramClass, serializer);
     }
 
     @Override
     public AutoCloseable registerSubsequentAddressFamily(final Class<? extends SubsequentAddressFamily> clazz, final int number) {
-        return safiReg.registerSubsequentAddressFamily(clazz, number);
+        return this.safiReg.registerSubsequentAddressFamily(clazz, number);
     }
 
     @Override
     public ReferenceCache getReferenceCache() {
-        return referenceCache;
+        return this.referenceCache;
     }
 
     public final synchronized int getMaximumCachedObjects() {
-        return maximumCachedObjects;
+        return this.maximumCachedObjects;
     }
 
     public final synchronized void setMaximumCachedObjects(final int maximumCachedObjects) {
         Preconditions.checkArgument(maximumCachedObjects >= 0);
 
         Cache<Object, Object> newCache = CacheBuilder.newBuilder().maximumSize(maximumCachedObjects).build();
-        newCache.putAll(cacheRef.get().asMap());
-        cacheRef.set(newCache);
+        newCache.putAll(this.cacheRef.get().asMap());
+        this.cacheRef.set(newCache);
     }
 }

diff --git a/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/pojo/SimpleNlriRegistry.java b/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/pojo/SimpleNlriRegistry.java
index 3824024e77205cd642bdd1fe6af6b818e3bea1f4..de17abfec7176b0da81989c064004cff5feb8ecc 100644 (file)
--- a/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/pojo/SimpleNlriRegistry.java
+++ b/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/pojo/SimpleNlriRegistry.java
@@ -8,6 +8,7 @@
 package org.opendaylight.protocol.bgp.parser.spi.pojo;
 
 import com.google.common.base.Preconditions;
+import com.google.common.collect.Iterables;
 import com.google.common.primitives.UnsignedBytes;
 
 import io.netty.buffer.ByteBuf;
@@ -22,6 +23,7 @@ import org.opendaylight.protocol.bgp.parser.BgpTableTypeImpl;
 import org.opendaylight.protocol.bgp.parser.spi.AddressFamilyRegistry;
 import org.opendaylight.protocol.bgp.parser.spi.NlriParser;
 import org.opendaylight.protocol.bgp.parser.spi.NlriRegistry;
+import org.opendaylight.protocol.bgp.parser.spi.NlriSerializer;
 import org.opendaylight.protocol.bgp.parser.spi.SubsequentAddressFamilyRegistry;
 import org.opendaylight.protocol.concepts.AbstractRegistration;
 import org.opendaylight.protocol.util.ByteArray;
@@ -32,10 +34,14 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mult
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.path.attributes.MpUnreachNlriBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.AddressFamily;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.SubsequentAddressFamily;
+import org.opendaylight.yangtools.yang.binding.DataObject;
 
 final class SimpleNlriRegistry implements NlriRegistry {
 
+    private static final int RESERVED = 1;
+
     private final ConcurrentMap<BgpTableType, NlriParser> handlers = new ConcurrentHashMap<>();
+    private final ConcurrentMap<Class<? extends DataObject>, NlriSerializer> serializers = new ConcurrentHashMap<>();
     private final SubsequentAddressFamilyRegistry safiReg;
     private final AddressFamilyRegistry afiReg;
 
@@ -45,14 +51,30 @@ final class SimpleNlriRegistry implements NlriRegistry {
     }
 
     private static BgpTableType createKey(final Class<? extends AddressFamily> afi,
-                                          final Class<? extends SubsequentAddressFamily> safi) {
+            final Class<? extends SubsequentAddressFamily> safi) {
         Preconditions.checkNotNull(afi);
         Preconditions.checkNotNull(safi);
         return new BgpTableTypeImpl(afi, safi);
     }
 
+    synchronized AutoCloseable registerNlriSerializer(final Class<? extends DataObject> nlriClass, final NlriSerializer serializer){
+        final NlriParser prev = this.handlers.get(nlriClass);
+        Preconditions.checkState(prev == null, "Serializer already bound to class " + prev);
+
+        this.serializers.put(nlriClass, serializer);
+        final Object lock = this;
+        return new AbstractRegistration() {
+            @Override
+            protected void removeRegistration() {
+                synchronized (lock) {
+                    SimpleNlriRegistry.this.serializers.remove(nlriClass);
+                }
+            }
+        };
+    }
+
     synchronized AutoCloseable registerNlriParser(final Class<? extends AddressFamily> afi,
-                                                  final Class<? extends SubsequentAddressFamily> safi, final NlriParser parser) {
+            final Class<? extends SubsequentAddressFamily> safi, final NlriParser parser) {
         final BgpTableType key = createKey(afi, safi);
         final NlriParser prev = this.handlers.get(key);
         Preconditions.checkState(prev == null, "AFI/SAFI is already bound to parser " + prev);
@@ -110,9 +132,7 @@ final class SimpleNlriRegistry implements NlriRegistry {
 
         byteAggregator.writeByte(nextHopBuffer.writerIndex());
         byteAggregator.writeBytes(nextHopBuffer);
-
-        //TODO how to calculate number of SNPAs Subnetwork Points of Attachment and serialize SNPAs ?
-        byteAggregator.writeByte(0);
+        byteAggregator.writeZero(RESERVED);
     }
 
     @Override
@@ -122,6 +142,11 @@ final class SimpleNlriRegistry implements NlriRegistry {
         byteAggregator.writeByte(this.safiReg.numberForClass(mpUnreachNlri.getSafi()));
     }
 
+    @Override
+    public Iterable<NlriSerializer> getSerializers() {
+        return Iterables.unmodifiableIterable(this.serializers.values());
+    }
+
     @Override
     public MpReachNlri parseMpReach(final ByteBuf buffer) throws BGPParsingException {
         final MpReachNlriBuilder builder = new MpReachNlriBuilder();
@@ -132,8 +157,7 @@ final class SimpleNlriRegistry implements NlriRegistry {
 
         final int nextHopLength = UnsignedBytes.toInt(buffer.readByte());
         final byte[] nextHop = ByteArray.readBytes(buffer, nextHopLength);
-        // reserved
-        buffer.skipBytes(1);
+        buffer.skipBytes(RESERVED);
 
         final ByteBuf nlri = buffer.slice();
         parser.parseNlri(nlri, nextHop, builder);