bgp/extensions/linkstate/src/main/java/org/opendaylight/protocol/bgp/linkstate/spi/pojo/SimpleNlriTypeRegistry.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.protocol.bgp.linkstate.spi.pojo;
  10
  11 import static java.util.Objects.requireNonNull;
  12
  13 import com.google.common.base.Preconditions;
  14 import io.netty.buffer.ByteBuf;
  15 import io.netty.buffer.Unpooled;
  16 import java.util.HashMap;
  17 import java.util.Map;
  18 import org.opendaylight.protocol.bgp.linkstate.spi.LinkstateTlvParser;
  19 import org.opendaylight.protocol.bgp.linkstate.spi.NlriTypeCaseParser;
  20 import org.opendaylight.protocol.bgp.linkstate.spi.NlriTypeCaseSerializer;
  21 import org.opendaylight.protocol.bgp.linkstate.spi.TlvUtil;
  22 import org.opendaylight.protocol.concepts.HandlerRegistry;
  23 import org.opendaylight.protocol.concepts.MultiRegistry;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev180329.linkstate.ObjectType;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev180329.linkstate.destination.CLinkstateDestination;
  26 import org.opendaylight.yangtools.yang.common.QName;
  27 import org.slf4j.Logger;
  28 import org.slf4j.LoggerFactory;
  29
  30 public final class SimpleNlriTypeRegistry {
  31
  32     private static final Logger LOG = LoggerFactory.getLogger(SimpleNlriTypeRegistry.class);
  33     private static final SimpleNlriTypeRegistry SINGLETON = new SimpleNlriTypeRegistry();
  34     private final HandlerRegistry<ObjectType, NlriTypeCaseParser, NlriTypeCaseSerializer> nlriRegistry = new HandlerRegistry<>();
  35     private final MultiRegistry<QName, LinkstateTlvParser.LinkstateTlvSerializer<?>> tlvSerializers = new MultiRegistry<>();
  36     private final MultiRegistry<Integer, LinkstateTlvParser<?>> tlvParsers = new MultiRegistry<>();
  37
  38     private SimpleNlriTypeRegistry() {
  39     }
  40
  41     public static SimpleNlriTypeRegistry getInstance() {
  42         return SINGLETON;
  43     }
  44
  45     public AutoCloseable registerNlriParser(final int type, final NlriTypeCaseParser parser) {
  46         return this.nlriRegistry.registerParser(type, parser);
  47     }
  48
  49     public AutoCloseable registerNlriSerializer(
  50             final Class<? extends ObjectType> clazzType,
  51             final NlriTypeCaseSerializer serializer) {
  52         return this.nlriRegistry.registerSerializer(clazzType, serializer);
  53     }
  54
  55     public <T> AutoCloseable registerTlvParser(final int tlvType, final LinkstateTlvParser<T> parser) {
  56         return this.tlvParsers.register(tlvType, parser);
  57     }
  58
  59     public <T> AutoCloseable registerTlvSerializer(
  60             final QName tlvQName,
  61             final LinkstateTlvParser.LinkstateTlvSerializer<T> serializer) {
  62         return this.tlvSerializers.register(tlvQName, serializer);
  63     }
  64
  65     public CLinkstateDestination parseNlriType(final ByteBuf buffer) {
  66         final int type = buffer.readUnsignedShort();
  67         final int length = buffer.readUnsignedShort();
  68         final NlriTypeCaseParser parser = this.nlriRegistry.getParser(type);
  69         if (parser == null) {
  70             LOG.warn("Linkstate NLRI parser for Type: {} was not found.", type);
  71             return null;
  72         }
  73         return parser.parseTypeNlri(buffer.readSlice(length));
  74     }
  75
  76     public void serializeNlriType(final CLinkstateDestination nlri, final ByteBuf byteAggregator) {
  77         if (nlri == null) {
  78             return;
  79         }
  80         requireNonNull(byteAggregator);
  81         final ObjectType objectType = nlri.getObjectType();
  82         final NlriTypeCaseSerializer serializer = this.nlriRegistry
  83                 .getSerializer((Class<? extends ObjectType>) objectType.getImplementedInterface());
  84         if (serializer == null) {
  85             LOG.warn("Linkstate NLRI serializer for Type: {} was not found.", objectType.getImplementedInterface());
  86             return;
  87         }
  88         final ByteBuf nlriType = Unpooled.buffer();
  89         serializer.serializeTypeNlri(nlri, nlriType);
  90         TlvUtil.writeTLV(serializer.getNlriType(), nlriType, byteAggregator);
  91     }
  92
  93     public <T> T parseTlv(final ByteBuf buffer) {
  94         return parseTlv(buffer, getParser(buffer));
  95     }
  96
  97     public Map<QName, Object> parseSubTlvs(final ByteBuf buffer) {
  98         final Map<QName, Object> tlvs = new HashMap<>();
  99         while (buffer.isReadable()) {
 100             final LinkstateTlvParser<?> tlvParser = getParser(buffer);
 101             final Object tlvBody = parseTlv(buffer, tlvParser);
 102             if (tlvBody != null) {
 103                 tlvs.put(tlvParser.getTlvQName(), tlvBody);
 104             }
 105         }
 106         return tlvs;
 107     }
 108
 109     private <T> LinkstateTlvParser<T> getParser(final ByteBuf buffer) {
 110         Preconditions.checkArgument(buffer != null && buffer.isReadable());
 111         final int type = buffer.readUnsignedShort();
 112         final LinkstateTlvParser<T> parser = (LinkstateTlvParser<T>) this.tlvParsers.get(type);
 113         if (parser == null) {
 114             LOG.warn("Linkstate TLV parser for Type: {} was not found.", type);
 115         }
 116         return parser;
 117     }
 118
 119     private static <T> T parseTlv(final ByteBuf buffer, final LinkstateTlvParser<T> parser) {
 120         if (parser == null) {
 121             return null;
 122         }
 123         Preconditions.checkArgument(buffer != null && buffer.isReadable());
 124         final int length = buffer.readUnsignedShort();
 125         return parser.parseTlvBody(buffer.readSlice(length));
 126     }
 127
 128
 129     public <T> void serializeTlv(final QName tlvQName, final T tlv, final ByteBuf buffer) {
 130         if (tlv == null) {
 131             return;
 132         }
 133         requireNonNull(tlvQName);
 134         requireNonNull(buffer);
 135         final LinkstateTlvParser.LinkstateTlvSerializer<T> tlvSerializer
 136                 = (LinkstateTlvParser.LinkstateTlvSerializer<T>) this.tlvSerializers.get(tlvQName);
 137         if (tlvSerializer == null) {
 138             LOG.warn("Linkstate TLV serializer for QName: {} was not found.", tlvQName);
 139             return;
 140         }
 141         final ByteBuf body = Unpooled.buffer();
 142         tlvSerializer.serializeTlvBody(tlv, body);
 143         TlvUtil.writeTLV(tlvSerializer.getType(), body, buffer);
 144     }
 145 }