Fixup Augmentable and Identifiable methods changing

[bgpcep.git] / bgp / parser-spi / src / main / java / org / opendaylight / protocol / bgp / parser / spi / pojo / SimpleAttributeRegistry.java

diff --git a/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/pojo/SimpleAttributeRegistry.java b/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/pojo/SimpleAttributeRegistry.java
index f6c4c669cacdce0b920ec33e877be61341ae271d..50c6f4cc0e0774c2c0fbe75a97befdd6abc0b566 100644 (file)
--- a/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/pojo/SimpleAttributeRegistry.java
+++ b/bgp/parser-spi/src/main/java/org/opendaylight/protocol/bgp/parser/spi/pojo/SimpleAttributeRegistry.java
@@ -7,9 +7,13 @@
  */
 package org.opendaylight.protocol.bgp.parser.spi.pojo;
 
+import static java.util.Objects.requireNonNull;
+
 import com.google.common.base.Preconditions;
 import io.netty.buffer.ByteBuf;
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.TreeMap;
@@ -20,12 +24,17 @@ import org.opendaylight.protocol.bgp.parser.BGPParsingException;
 import org.opendaylight.protocol.bgp.parser.spi.AttributeParser;
 import org.opendaylight.protocol.bgp.parser.spi.AttributeRegistry;
 import org.opendaylight.protocol.bgp.parser.spi.AttributeSerializer;
+import org.opendaylight.protocol.bgp.parser.spi.PeerSpecificParserConstraint;
 import org.opendaylight.protocol.concepts.AbstractRegistration;
 import org.opendaylight.protocol.concepts.HandlerRegistry;
 import org.opendaylight.protocol.util.BitArray;
+import org.opendaylight.protocol.util.ByteArray;
 import org.opendaylight.protocol.util.Values;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.update.PathAttributes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.update.PathAttributesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev180329.path.attributes.Attributes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev180329.path.attributes.AttributesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev180329.path.attributes.attributes.UnrecognizedAttributes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev180329.path.attributes.attributes.UnrecognizedAttributesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev180329.path.attributes.attributes.UnrecognizedAttributesKey;
 import org.opendaylight.yangtools.yang.binding.DataContainer;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.slf4j.Logger;
@@ -38,21 +47,22 @@ final class SimpleAttributeRegistry implements AttributeRegistry {
         private final ByteBuf buffer;
 
         public RawAttribute(final AttributeParser parser, final ByteBuf buffer) {
-            this.parser = Preconditions.checkNotNull(parser);
-            this.buffer = Preconditions.checkNotNull(buffer);
+            this.parser = requireNonNull(parser);
+            this.buffer = requireNonNull(buffer);
         }
     }
 
     private static final Logger LOG = LoggerFactory.getLogger(SimpleAttributeRegistry.class);
     private static final int OPTIONAL_BIT = 0;
     private static final int TRANSITIVE_BIT = 1;
-    @SuppressWarnings("unused")
     private static final int PARTIAL_BIT = 2;
     private static final int EXTENDED_LENGTH_BIT = 3;
     private final HandlerRegistry<DataContainer, AttributeParser, AttributeSerializer> handlers = new HandlerRegistry<>();
     private final Map<AbstractRegistration, AttributeSerializer> serializers = new LinkedHashMap<>();
     private final AtomicReference<Iterable<AttributeSerializer>> roSerializers =
-        new AtomicReference<Iterable<AttributeSerializer>>(this.serializers.values());
+        new AtomicReference<>(this.serializers.values());
+    private final List<UnrecognizedAttributes> unrecognizedAttributes = new ArrayList<>();
+
 
     AutoCloseable registerAttributeParser(final int attributeType, final AttributeParser parser) {
         Preconditions.checkArgument(attributeType >= 0 && attributeType <= Values.UNSIGNED_BYTE_MAX_VALUE);
@@ -75,22 +85,15 @@ final class SimpleAttributeRegistry implements AttributeRegistry {
         };
     }
 
-    private void addAttribute(final ByteBuf buffer, final Map<Integer, RawAttribute> attributes) throws BGPDocumentedException {
+    private void addAttribute(final ByteBuf buffer, final Map<Integer, RawAttribute> attributes)
+            throws BGPDocumentedException {
         final BitArray flags = BitArray.valueOf(buffer.readByte());
         final int type = buffer.readUnsignedByte();
-        final int len = (flags.get(EXTENDED_LENGTH_BIT)) ? buffer.readUnsignedShort() : buffer.readUnsignedByte();
+        final int len = flags.get(EXTENDED_LENGTH_BIT) ? buffer.readUnsignedShort() : buffer.readUnsignedByte();
         if (!attributes.containsKey(type)) {
             final AttributeParser parser = this.handlers.getParser(type);
             if (parser == null) {
-                if (!flags.get(OPTIONAL_BIT)) {
-                    throw new BGPDocumentedException("Well known attribute not recognized.", BGPError.WELL_KNOWN_ATTR_NOT_RECOGNIZED);
-                }
-                if (flags.get(TRANSITIVE_BIT)) {
-                    // FIXME: transitive attributes need to be preserved
-                    LOG.warn("Losing unrecognized transitive attribute {}. Some data might be missing from the output.", type);
-                } else {
-                    LOG.warn("Ignoring unrecognized attribute type {}. Some data might be missing from the output.", type);
-                }
+                processUnrecognized(flags, type, buffer, len);
             } else {
                 attributes.put(type, new RawAttribute(parser, buffer.readSlice(len)));
             }
@@ -99,8 +102,23 @@ final class SimpleAttributeRegistry implements AttributeRegistry {
         }
     }
 
+    private void processUnrecognized(final BitArray flags, final int type, final ByteBuf buffer, final int len) throws BGPDocumentedException {
+        if (!flags.get(OPTIONAL_BIT)) {
+            throw new BGPDocumentedException("Well known attribute not recognized.", BGPError.WELL_KNOWN_ATTR_NOT_RECOGNIZED);
+        }
+        final UnrecognizedAttributes unrecognizedAttribute = new UnrecognizedAttributesBuilder()
+            .withKey(new UnrecognizedAttributesKey((short) type))
+            .setPartial(flags.get(PARTIAL_BIT))
+            .setTransitive(flags.get(TRANSITIVE_BIT))
+            .setType((short) type)
+            .setValue(ByteArray.readBytes(buffer, len)).build();
+        this.unrecognizedAttributes.add(unrecognizedAttribute);
+        LOG.debug("Unrecognized attribute were parsed: {}", unrecognizedAttribute);
+    }
+
     @Override
-    public PathAttributes parseAttributes(final ByteBuf buffer) throws BGPDocumentedException, BGPParsingException {
+    public Attributes parseAttributes(final ByteBuf buffer, final PeerSpecificParserConstraint constraint)
+            throws BGPDocumentedException, BGPParsingException {
         final Map<Integer, RawAttribute> attributes = new TreeMap<>();
         while (buffer.isReadable()) {
             addAttribute(buffer, attributes);
@@ -109,13 +127,14 @@ final class SimpleAttributeRegistry implements AttributeRegistry {
          * TreeMap guarantees that we will be invoking the parser in the order
          * of increasing attribute type.
          */
-        final PathAttributesBuilder builder = new PathAttributesBuilder();
+        final AttributesBuilder builder = new AttributesBuilder();
         for (final Entry<Integer, RawAttribute> e : attributes.entrySet()) {
             LOG.debug("Parsing attribute type {}", e.getKey());
 
             final RawAttribute a = e.getValue();
-            a.parser.parseAttribute(a.buffer, builder);
+            a.parser.parseAttribute(a.buffer, builder, constraint);
         }
+        builder.setUnrecognizedAttributes(this.unrecognizedAttributes);
         return builder.build();
     }