private NodeIdentifierWithPredicates createRouteKey(final UnkeyedListEntryNode linkstate) {
final ByteBuf buffer = Unpooled.buffer();
- LinkstateNlriParser.serializeNlri(linkstate, buffer);
+ final CLinkstateDestination cLinkstateDestination = LinkstateNlriParser.extractLinkstateDestination(linkstate);
+ LinkstateNlriParser.serializeNlri(cLinkstateDestination, buffer);
+
return new NodeIdentifierWithPredicates(LinkstateRoute.QNAME, ROUTE_KEY, ByteArray.readAllBytes(buffer));
}
import org.opendaylight.protocol.bgp.parser.BGPParsingException;
import org.opendaylight.protocol.util.Ipv4Util;
import org.opendaylight.protocol.util.Ipv6Util;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.Ipv4InterfaceIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.Ipv6InterfaceIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.TopologyIdentifier;
private static final int IPV6_NEIGHBOR_ADDRESS = 262;
/* Link Descriptor QNames */
- private static final NodeIdentifier IPV4_IFACE_NID = new NodeIdentifier(QName.cachedReference(QName.create(LinkDescriptors.QNAME, "ipv4-interface-address")));
+ @VisibleForTesting
+ public static final NodeIdentifier IPV4_IFACE_NID = new NodeIdentifier(QName.cachedReference(QName.create(LinkDescriptors.QNAME, "ipv4-interface-address")));
private static final NodeIdentifier IPV6_IFACE_NID = new NodeIdentifier(QName.cachedReference(QName.create(LinkDescriptors.QNAME, "ipv6-interface-address")));
- private static final NodeIdentifier IPV4_NEIGHBOR_NID = new NodeIdentifier(QName.cachedReference(QName.create(LinkDescriptors.QNAME, "ipv4-neighbor-address")));
+ @VisibleForTesting
+ public static final NodeIdentifier IPV4_NEIGHBOR_NID = new NodeIdentifier(QName.cachedReference(QName.create(LinkDescriptors.QNAME, "ipv4-neighbor-address")));
private static final NodeIdentifier IPV6_NEIGHBOR_NID = new NodeIdentifier(QName.cachedReference(QName.create(LinkDescriptors.QNAME, "ipv6-neighbor-address")));
- private static final NodeIdentifier LINK_LOCAL_NID = new NodeIdentifier(QName.cachedReference(QName.create(LinkDescriptors.QNAME, "link-local-identifier")));
- private static final NodeIdentifier LINK_REMOTE_NID = new NodeIdentifier(QName.cachedReference(QName.create(LinkDescriptors.QNAME, "link-remote-identifier")));
+ @VisibleForTesting
+ public static final NodeIdentifier LINK_LOCAL_NID = new NodeIdentifier(QName.cachedReference(QName.create(LinkDescriptors.QNAME, "link-local-identifier")));
+ @VisibleForTesting
+ public static final NodeIdentifier LINK_REMOTE_NID = new NodeIdentifier(QName.cachedReference(QName.create(LinkDescriptors.QNAME, "link-remote-identifier")));
static LinkDescriptors parseLinkDescriptors(final ByteBuf buffer) throws BGPParsingException {
final LinkDescriptorsBuilder builder = new LinkDescriptorsBuilder();
}
}
- static void serializeLinkDescriptors(final ContainerNode descriptors, final ByteBuf buffer) {
+ static LinkDescriptors serializeLinkDescriptors(final ContainerNode descriptors) {
+ final LinkDescriptorsBuilder linkDescBuilder = new LinkDescriptorsBuilder();
+
if (descriptors.getChild(LINK_LOCAL_NID).isPresent() && descriptors.getChild(LINK_REMOTE_NID).isPresent()) {
- final ByteBuf identifierBuf = Unpooled.buffer();
- identifierBuf.writeInt(((Long)descriptors.getChild(LINK_LOCAL_NID).get().getValue()).intValue());
- identifierBuf.writeInt(((Long)descriptors.getChild(LINK_REMOTE_NID).get().getValue()).intValue());
- TlvUtil.writeTLV(LINK_LR_IDENTIFIERS, identifierBuf, buffer);
+ linkDescBuilder.setLinkLocalIdentifier((Long) descriptors.getChild(LINK_LOCAL_NID).get().getValue());
+ linkDescBuilder.setLinkRemoteIdentifier((Long) descriptors.getChild(LINK_REMOTE_NID).get().getValue());
}
if (descriptors.getChild(IPV4_IFACE_NID).isPresent()) {
- TlvUtil.writeTLV(IPV4_IFACE_ADDRESS, Ipv4Util.byteBufForAddress(new Ipv4Address((String)descriptors.getChild(IPV4_IFACE_NID).get().getValue())), buffer);
+ linkDescBuilder.setIpv4InterfaceAddress(new Ipv4InterfaceIdentifier((String) descriptors.getChild(IPV4_IFACE_NID).get().getValue()));
}
if (descriptors.getChild(IPV6_IFACE_NID).isPresent()) {
- TlvUtil.writeTLV(IPV6_IFACE_ADDRESS, Ipv6Util.byteBufForAddress(new Ipv6Address((String)descriptors.getChild(IPV6_IFACE_NID).get().getValue())), buffer);
+ linkDescBuilder.setIpv6InterfaceAddress(new Ipv6InterfaceIdentifier((String) descriptors.getChild(IPV6_IFACE_NID).get().getValue()));
}
if (descriptors.getChild(IPV4_NEIGHBOR_NID).isPresent()) {
- TlvUtil.writeTLV(IPV4_NEIGHBOR_ADDRESS, Ipv4Util.byteBufForAddress(new Ipv4Address((String)descriptors.getChild(IPV4_NEIGHBOR_NID).get().getValue())), buffer);
+ linkDescBuilder.setIpv4NeighborAddress(new Ipv4InterfaceIdentifier((String) descriptors.getChild(IPV4_NEIGHBOR_NID).get().getValue()));
}
if (descriptors.getChild(IPV6_NEIGHBOR_NID).isPresent()) {
- TlvUtil.writeTLV(IPV6_NEIGHBOR_ADDRESS, Ipv6Util.byteBufForAddress(new Ipv6Address((String)descriptors.getChild(IPV6_NEIGHBOR_NID).get().getValue())), buffer);
+ linkDescBuilder.setIpv6NeighborAddress(new Ipv6InterfaceIdentifier((String) descriptors.getChild(IPV6_NEIGHBOR_NID).get().getValue()));
}
if (descriptors.getChild(TlvUtil.MULTI_TOPOLOGY_NID).isPresent()) {
- TlvUtil.writeTLV(TlvUtil.MULTI_TOPOLOGY_ID, Unpooled.copyShort((Short)descriptors.getChild(TlvUtil.MULTI_TOPOLOGY_NID).get().getValue()), buffer);
+ linkDescBuilder.setMultiTopologyId(new TopologyIdentifier((Integer) descriptors.getChild(TlvUtil.MULTI_TOPOLOGY_NID).get().getValue()));
}
+ return linkDescBuilder.build();
}
}
*/
package org.opendaylight.protocol.bgp.linkstate.nlri;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
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.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final int LOCAL_NODE_DESCRIPTORS_TYPE = 256;
private static final int REMOTE_NODE_DESCRIPTORS_TYPE = 257;
- private static final NodeIdentifier OBJECT_TYPE_NID = new NodeIdentifier(ObjectType.QNAME);
- private static final NodeIdentifier NODE_DESCRIPTORS_NID = new NodeIdentifier(NodeDescriptors.QNAME);
- private static final NodeIdentifier LOCAL_NODE_DESCRIPTORS_NID = new NodeIdentifier(LocalNodeDescriptors.QNAME);
- private static final NodeIdentifier REMOTE_NODE_DESCRIPTORS_NID = new NodeIdentifier(RemoteNodeDescriptors.QNAME);
- private static final NodeIdentifier ADVERTISING_NODE_DESCRIPTORS_NID = new NodeIdentifier(AdvertisingNodeDescriptors.QNAME);
-
- private static final NodeIdentifier DISTINGUISHER_NID = new NodeIdentifier(QName.cachedReference(QName.create(CLinkstateDestination.QNAME, "route-distinguisher")));
- private static final NodeIdentifier PROTOCOL_ID_NID = new NodeIdentifier(QName.cachedReference(QName.create(CLinkstateDestination.QNAME, "protocol-id")));
- private static final NodeIdentifier IDENTIFIER_NID = new NodeIdentifier(QName.cachedReference(QName.create(CLinkstateDestination.QNAME, "identifier")));
+ @VisibleForTesting
+ public static final NodeIdentifier OBJECT_TYPE_NID = new NodeIdentifier(ObjectType.QNAME);
+ @VisibleForTesting
+ public static final NodeIdentifier NODE_DESCRIPTORS_NID = new NodeIdentifier(NodeDescriptors.QNAME);
+ @VisibleForTesting
+ public static final NodeIdentifier LOCAL_NODE_DESCRIPTORS_NID = new NodeIdentifier(LocalNodeDescriptors.QNAME);
+ @VisibleForTesting
+ public static final NodeIdentifier REMOTE_NODE_DESCRIPTORS_NID = new NodeIdentifier(RemoteNodeDescriptors.QNAME);
+ @VisibleForTesting
+ public static final NodeIdentifier ADVERTISING_NODE_DESCRIPTORS_NID = new NodeIdentifier(AdvertisingNodeDescriptors.QNAME);
+ @VisibleForTesting
+ public static final NodeIdentifier PREFIX_DESCRIPTORS_NID = new NodeIdentifier(PrefixDescriptors.QNAME);
+ @VisibleForTesting
+ public static final NodeIdentifier LINK_DESCRIPTORS_NID = new NodeIdentifier(LinkDescriptors.QNAME);
+
+ @VisibleForTesting
+ public static final NodeIdentifier DISTINGUISHER_NID = new NodeIdentifier(QName.cachedReference(QName.create(CLinkstateDestination.QNAME, "route-distinguisher")));
+ @VisibleForTesting
+ public static final NodeIdentifier PROTOCOL_ID_NID = new NodeIdentifier(QName.cachedReference(QName.create(CLinkstateDestination.QNAME, "protocol-id")));
+ @VisibleForTesting
+ public static final NodeIdentifier IDENTIFIER_NID = new NodeIdentifier(QName.cachedReference(QName.create(CLinkstateDestination.QNAME, "identifier")));
private final boolean isVpn;
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.NodeIdentifier remote = null;
RemoteNodeDescriptors remoteDescriptors = null;
if (type == REMOTE_NODE_DESCRIPTORS_TYPE) {
- remoteDescriptors = (RemoteNodeDescriptors)NodeNlriParser.parseNodeDescriptors(buffer.readSlice(length), NlriType.Link, false);
+ remoteDescriptors = (RemoteNodeDescriptors) NodeNlriParser.parseNodeDescriptors(buffer.readSlice(length), NlriType.Link, false);
}
builder.setObjectType(new LinkCaseBuilder()
.setLocalNodeDescriptors(localDescriptors)
break;
case Ipv4Prefix:
builder.setObjectType(new PrefixCaseBuilder()
- .setAdvertisingNodeDescriptors((AdvertisingNodeDescriptors)localDescriptor)
+ .setAdvertisingNodeDescriptors((AdvertisingNodeDescriptors) localDescriptor)
.setPrefixDescriptors(PrefixNlriParser.parsePrefixDescriptors(rest, true)).build());
break;
case Ipv6Prefix:
builder.setObjectType(new PrefixCaseBuilder()
- .setAdvertisingNodeDescriptors((AdvertisingNodeDescriptors)localDescriptor)
+ .setAdvertisingNodeDescriptors((AdvertisingNodeDescriptors) localDescriptor)
.setPrefixDescriptors(PrefixNlriParser.parsePrefixDescriptors(rest, false)).build());
break;
case Node:
// node nlri is already parsed as it contains only the common fields for node and link nlri
- builder.setObjectType(new NodeCaseBuilder().setNodeDescriptors((NodeDescriptors)localDescriptor).build());
+ builder.setObjectType(new NodeCaseBuilder().setNodeDescriptors((NodeDescriptors) localDescriptor).build());
break;
default:
break;
final ObjectType ot = destination.getObjectType();
NlriType nlriType = null;
if (ot instanceof PrefixCase) {
- final PrefixCase pCase = (PrefixCase)destination.getObjectType();
+ final PrefixCase pCase = (PrefixCase) destination.getObjectType();
NodeNlriParser.serializeNodeDescriptors(pCase.getAdvertisingNodeDescriptors(), ldescs);
TlvUtil.writeTLV(LOCAL_NODE_DESCRIPTORS_TYPE, ldescs, nlriByteBuf);
if (pCase.getPrefixDescriptors() != null) {
}
}
} else if (ot instanceof LinkCase) {
- final LinkCase lCase = (LinkCase)destination.getObjectType();
+ final LinkCase lCase = (LinkCase) destination.getObjectType();
NodeNlriParser.serializeNodeDescriptors(lCase.getLocalNodeDescriptors(), ldescs);
TlvUtil.writeTLV(LOCAL_NODE_DESCRIPTORS_TYPE, ldescs, nlriByteBuf);
final ByteBuf rdescs = Unpooled.buffer();
}
nlriType = NlriType.Link;
} else if (ot instanceof NodeCase) {
- final NodeCase nCase = (NodeCase)destination.getObjectType();
+ final NodeCase nCase = (NodeCase) destination.getObjectType();
NodeNlriParser.serializeNodeDescriptors(nCase.getNodeDescriptors(), ldescs);
TlvUtil.writeTLV(LOCAL_NODE_DESCRIPTORS_TYPE, ldescs, nlriByteBuf);
nlriType = NlriType.Node;
// FIXME : use codec
private static int domProtocolIdValue(final String protocolId) {
- switch(protocolId) {
+ switch (protocolId) {
case "unknown":
return 0;
case "isis-level1":
}
}
- /**
- * Serializes DOM interpretation of Linkstate NLRI to ByteBuf. Used to create linkstate route key.
- *
- * @param linkstate UnkeyedListEntryNode basically CLinkstateDestination in DOM
- * @param buffer ByteBuf where the key will be serialized
- */
- public static void serializeNlri(final UnkeyedListEntryNode linkstate, final ByteBuf buffer) {
- final ByteBuf nlriByteBuf = Unpooled.buffer();
+ public static CLinkstateDestination extractLinkstateDestination(final DataContainerNode<? extends PathArgument> linkstate) {
+ final CLinkstateDestinationBuilder builder = new CLinkstateDestinationBuilder();
// serialize common parts
final Optional<DataContainerChild<? extends PathArgument, ?>> distinguisher = linkstate.getChild(DISTINGUISHER_NID);
if (distinguisher.isPresent()) {
- nlriByteBuf.writeBytes(((String)distinguisher.get().getValue()).getBytes());
+ builder.setDistinguisher(new RouteDistinguisher((BigInteger) distinguisher.get().getValue()));
}
final Optional<DataContainerChild<? extends PathArgument, ?>> protocolId = linkstate.getChild(PROTOCOL_ID_NID);
// DOM representation contains values as are in the model, not as are in generated enum
- nlriByteBuf.writeLong(domProtocolIdValue((String) protocolId.get().getValue()));
+ if (protocolId.isPresent()) {
+ builder.setProtocolId(ProtocolId.forValue(domProtocolIdValue((String) protocolId.get().getValue())));
+ }
final Optional<DataContainerChild<? extends PathArgument, ?>> identifier = linkstate.getChild(IDENTIFIER_NID);
- nlriByteBuf.writeLong(((BigInteger)identifier.get().getValue()).longValue());
+ if (identifier.isPresent()) {
+ builder.setIdentifier(new Identifier((BigInteger) identifier.get().getValue()));
+ }
- // serialize node
- final ByteBuf ldescs = Unpooled.buffer();
- NlriType nlriType = null;
final ChoiceNode objectType = (ChoiceNode) linkstate.getChild(OBJECT_TYPE_NID).get();
- if (objectType.getChild(ADVERTISING_NODE_DESCRIPTORS_NID).isPresent()) {
+ if (objectType.getChild(ADVERTISING_NODE_DESCRIPTORS_NID).isPresent()) {
// prefix node descriptors
- NodeNlriParser.serializeNodeDescriptors((ContainerNode)objectType.getChild(ADVERTISING_NODE_DESCRIPTORS_NID).get(), ldescs);
- TlvUtil.writeTLV(LinkstateNlriParser.LOCAL_NODE_DESCRIPTORS_TYPE, ldescs, nlriByteBuf);
- final Optional<DataContainerChild<? extends PathArgument, ?>> prefixDescriptors = objectType.getChild(new NodeIdentifier(PrefixDescriptors.QNAME));
+ PrefixCaseBuilder prefixBuilder = new PrefixCaseBuilder();
+ prefixBuilder.setAdvertisingNodeDescriptors(NodeNlriParser.serializeAdvNodeDescriptors((ContainerNode) objectType.getChild(
+ ADVERTISING_NODE_DESCRIPTORS_NID).get()));
// prefix descriptors
+ final Optional<DataContainerChild<? extends PathArgument, ?>> prefixDescriptors = objectType.getChild(PREFIX_DESCRIPTORS_NID);
if (prefixDescriptors.isPresent()) {
- nlriType = PrefixNlriParser.serializePrefixDescriptors((ContainerNode)prefixDescriptors.get(), nlriByteBuf);
+ prefixBuilder.setPrefixDescriptors(PrefixNlriParser.serializePrefixDescriptors((ContainerNode) prefixDescriptors.get()));
}
+ builder.setObjectType(prefixBuilder.build());
} else if (objectType.getChild(LOCAL_NODE_DESCRIPTORS_NID).isPresent()) {
-
// link local node descriptors
- NodeNlriParser.serializeNodeDescriptors((ContainerNode)objectType.getChild(LOCAL_NODE_DESCRIPTORS_NID).get(), ldescs);
- TlvUtil.writeTLV(LinkstateNlriParser.LOCAL_NODE_DESCRIPTORS_TYPE, ldescs, nlriByteBuf);
+ final LinkCaseBuilder linkBuilder = new LinkCaseBuilder();
+ linkBuilder.setLocalNodeDescriptors(NodeNlriParser.serializeLocalNodeDescriptors((ContainerNode) objectType.getChild(LOCAL_NODE_DESCRIPTORS_NID).get()));
// link remote node descriptors
- final ByteBuf rdescs = Unpooled.buffer();
if (objectType.getChild(REMOTE_NODE_DESCRIPTORS_NID).isPresent()) {
- NodeNlriParser.serializeNodeDescriptors((ContainerNode)objectType.getChild(REMOTE_NODE_DESCRIPTORS_NID).get(), rdescs);
- TlvUtil.writeTLV(LinkstateNlriParser.REMOTE_NODE_DESCRIPTORS_TYPE, rdescs, nlriByteBuf);
+ linkBuilder.setRemoteNodeDescriptors(NodeNlriParser.serializeRemoteNodeDescriptors((ContainerNode) objectType.getChild(REMOTE_NODE_DESCRIPTORS_NID).get()));
}
-
// link descriptors
- final Optional<DataContainerChild<? extends PathArgument, ?>> linkDescriptors = objectType.getChild(new NodeIdentifier(LinkDescriptors.QNAME));
+ final Optional<DataContainerChild<? extends PathArgument, ?>> linkDescriptors = objectType.getChild(LINK_DESCRIPTORS_NID);
if (linkDescriptors.isPresent()) {
- LinkNlriParser.serializeLinkDescriptors((ContainerNode)linkDescriptors.get(), nlriByteBuf);
+ linkBuilder.setLinkDescriptors(LinkNlriParser.serializeLinkDescriptors((ContainerNode) linkDescriptors.get()));
}
- nlriType = NlriType.Link;
+ builder.setObjectType(linkBuilder.build());
} else if (objectType.getChild(NODE_DESCRIPTORS_NID).isPresent()) {
-
+ final NodeCaseBuilder nodeBuilder = new NodeCaseBuilder();
// node descriptors
- NodeNlriParser.serializeNodeDescriptors((ContainerNode)objectType.getChild(NODE_DESCRIPTORS_NID).get(), ldescs);
- TlvUtil.writeTLV(LinkstateNlriParser.LOCAL_NODE_DESCRIPTORS_TYPE, ldescs, nlriByteBuf);
- nlriType = NlriType.Node;
+ nodeBuilder.setNodeDescriptors(NodeNlriParser.serializeNodeDescriptors((ContainerNode) objectType.getChild(NODE_DESCRIPTORS_NID).get()));
+ builder.setObjectType(nodeBuilder.build());
} else {
LOG.warn("Unknown Object Type.");
}
- TlvUtil.writeTLV(nlriType.getIntValue(), nlriByteBuf, buffer);
- }
-
- public static CLinkstateDestination extractLinkstateDestination(final MapEntryNode route) {
- // FIXME: BUG-3012 - finish this
- return new CLinkstateDestinationBuilder().build();
+ return builder.build();
}
}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.AsNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.AreaIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.DomainIdentifier;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.IsisRouterIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.NlriType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.OspfInterfaceIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.isis.lan.identifier.IsIsRouterIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.isis.lan.identifier.IsIsRouterIdentifierBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.linkstate.object.type.link._case.LocalNodeDescriptors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.linkstate.object.type.link._case.LocalNodeDescriptorsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.linkstate.object.type.link._case.RemoteNodeDescriptors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.linkstate.object.type.link._case.RemoteNodeDescriptorsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.linkstate.object.type.node._case.NodeDescriptors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.linkstate.object.type.node._case.NodeDescriptorsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.linkstate.object.type.prefix._case.AdvertisingNodeDescriptors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.linkstate.object.type.prefix._case.AdvertisingNodeDescriptorsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.node.identifier.CRouterIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.node.identifier.c.router.identifier.IsisNodeCase;
private static final int IGP_ROUTER_ID = 515;
/* Node Descriptor QNames */
- private static final NodeIdentifier AS_NUMBER_NID = new NodeIdentifier(QName.cachedReference(QName.create(NodeDescriptors.QNAME, "as-number")));
- private static final NodeIdentifier AREA_NID = new NodeIdentifier(QName.cachedReference(QName.create(NodeDescriptors.QNAME, "area-id")));
- private static final NodeIdentifier DOMAIN_NID = new NodeIdentifier(QName.cachedReference(QName.create(NodeDescriptors.QNAME, "domain-id")));
- private static final NodeIdentifier ROUTER_NID = new NodeIdentifier(CRouterIdentifier.QNAME);
+ @VisibleForTesting
+ public static final NodeIdentifier AS_NUMBER_NID = new NodeIdentifier(QName.cachedReference(QName.create(NodeDescriptors.QNAME, "as-number")));
+ @VisibleForTesting
+ public static final NodeIdentifier AREA_NID = new NodeIdentifier(QName.cachedReference(QName.create(NodeDescriptors.QNAME, "area-id")));
+ @VisibleForTesting
+ public static final NodeIdentifier DOMAIN_NID = new NodeIdentifier(QName.cachedReference(QName.create(NodeDescriptors.QNAME, "domain-id")));
+ @VisibleForTesting
+ public static final NodeIdentifier ROUTER_NID = new NodeIdentifier(CRouterIdentifier.QNAME);
/* Router Identifier QNames */
- private static final NodeIdentifier ISIS_NODE_NID = new NodeIdentifier(IsisNode.QNAME);
- private static final NodeIdentifier ISIS_PSEUDONODE_NID = new NodeIdentifier(IsisPseudonode.QNAME);
- private static final NodeIdentifier OSPF_NODE_NID = new NodeIdentifier(OspfNode.QNAME);
- private static final NodeIdentifier OSPF_PSEUDONODE_NID = new NodeIdentifier(OspfPseudonode.QNAME);
- private static final NodeIdentifier ISIS_ROUTER_NID = new NodeIdentifier(IsisRouterIdentifier.QNAME);
- private static final NodeIdentifier ISO_SYSTEM_NID = new NodeIdentifier(QName.cachedReference(QName.create(NodeDescriptors.QNAME, "iso-system-id")));
- private static final NodeIdentifier PSN_NID = new NodeIdentifier(QName.cachedReference(QName.create(NodeDescriptors.QNAME, "psn")));
- private static final NodeIdentifier OSPF_ROUTER_NID = new NodeIdentifier(QName.cachedReference(QName.create(NodeDescriptors.QNAME, "ospf-router-id")));
+ @VisibleForTesting
+ public static final NodeIdentifier ISIS_NODE_NID = new NodeIdentifier(IsisNode.QNAME);
+ @VisibleForTesting
+ public static final NodeIdentifier ISIS_PSEUDONODE_NID = new NodeIdentifier(IsisPseudonode.QNAME);
+ @VisibleForTesting
+ public static final NodeIdentifier OSPF_NODE_NID = new NodeIdentifier(OspfNode.QNAME);
+ @VisibleForTesting
+ public static final NodeIdentifier OSPF_PSEUDONODE_NID = new NodeIdentifier(OspfPseudonode.QNAME);
+ @VisibleForTesting
+ public static final NodeIdentifier ISO_SYSTEM_NID = new NodeIdentifier(QName.cachedReference(QName.create(NodeDescriptors.QNAME, "iso-system-id")));
+ @VisibleForTesting
+ public static final NodeIdentifier PSN_NID = new NodeIdentifier(QName.cachedReference(QName.create(NodeDescriptors.QNAME, "psn")));
+ @VisibleForTesting
+ public static final NodeIdentifier OSPF_ROUTER_NID = new NodeIdentifier(QName.cachedReference(QName.create(NodeDescriptors.QNAME, "ospf-router-id")));
private static final NodeIdentifier LAN_IFACE_NID = new NodeIdentifier(QName.cachedReference(QName.create(NodeDescriptors.QNAME, "lan-interface")));
static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.NodeIdentifier parseNodeDescriptors(final ByteBuf buffer, final NlriType nlriType, final boolean local) throws BGPParsingException {
}
}
- private static void serializeIsisNode(final ContainerNode isis, final ByteBuf buffer) {
- buffer.writeBytes((byte[])isis.getChild(ISO_SYSTEM_NID).get().getValue());
+ private static IsisNodeCase serializeIsisNode(final ContainerNode isis) {
+ final IsisNodeCaseBuilder builder = new IsisNodeCaseBuilder();
+ final IsisNodeBuilder isisBuilder = new IsisNodeBuilder();
+ isisBuilder.setIsoSystemId(new IsoSystemIdentifier((byte[]) isis.getChild(ISO_SYSTEM_NID).get().getValue()));
+ builder.setIsisNode(isisBuilder.build());
+ return builder.build();
}
- private static void serializeOspfNode(final ContainerNode ospf, final ByteBuf buffer) {
- buffer.writeInt(UnsignedInteger.valueOf((Long)ospf.getChild(OSPF_ROUTER_NID).get().getValue()).intValue());
+ private static IsisPseudonodeCase serializeIsisPseudoNode(final ContainerNode pseudoIsisNode) {
+ final IsisPseudonodeCaseBuilder builder = new IsisPseudonodeCaseBuilder();
+ final IsisPseudonodeBuilder nodeBuilder = new IsisPseudonodeBuilder();
+ final IsIsRouterIdentifierBuilder isisRouterId = new IsIsRouterIdentifierBuilder();
+ if (pseudoIsisNode.getChild(ISO_SYSTEM_NID).isPresent()) {
+ isisRouterId.setIsoSystemId(new IsoSystemIdentifier((byte[]) pseudoIsisNode.getChild(ISO_SYSTEM_NID).get().getValue()));
+ }
+ nodeBuilder.setIsIsRouterIdentifier(isisRouterId.build());
+
+ if (pseudoIsisNode.getChild(PSN_NID).isPresent()) {
+ nodeBuilder.setPsn((Short) pseudoIsisNode.getChild(PSN_NID).get().getValue());
+ } else {
+ nodeBuilder.setPsn((short) 0);
+ }
+ builder.setIsisPseudonode(nodeBuilder.build());
+ return builder.build();
}
- private static void serializeRouterId(final ChoiceNode routerId, final ByteBuf buffer) {
- if (routerId.getChild(ISIS_NODE_NID).isPresent()) {
- serializeIsisNode((ContainerNode)routerId.getChild(ISIS_NODE_NID).get(), buffer);
- } else if (routerId.getChild(ISIS_PSEUDONODE_NID).isPresent()) {
- final ContainerNode isisPseudo = (ContainerNode)routerId.getChild(ISIS_PSEUDONODE_NID).get();
- serializeIsisNode((ContainerNode) isisPseudo.getChild(ISIS_ROUTER_NID).get(), buffer);
- if (isisPseudo.getChild(PSN_NID).isPresent()) {
- buffer.writeByte(((Short)isisPseudo.getChild(PSN_NID).get().getValue()));
- } else {
- buffer.writeZero(PSN_LENGTH);
+ private static OspfNodeCase serializeOspfNode(final ContainerNode ospf) {
+ final OspfNodeCaseBuilder builder = new OspfNodeCaseBuilder();
+ if (ospf.getChild(OSPF_ROUTER_NID).isPresent()) {
+ final OspfNodeBuilder nodeBuilder = new OspfNodeBuilder();
+ nodeBuilder.setOspfRouterId((Long) ospf.getChild(OSPF_ROUTER_NID).get().getValue());
+ builder.setOspfNode(nodeBuilder.build());
+ }
+ return builder.build();
+ }
+
+ private static CRouterIdentifier serializeOspfPseudoNode(final ContainerNode ospfPseudonode) {
+ final OspfPseudonodeCaseBuilder builder = new OspfPseudonodeCaseBuilder();
+ if (ospfPseudonode.getChild(OSPF_PSEUDONODE_NID).isPresent()) {
+ final OspfPseudonodeBuilder nodeBuilder = new OspfPseudonodeBuilder();
+ if (ospfPseudonode.getChild(LAN_IFACE_NID).isPresent()) {
+ nodeBuilder.setLanInterface(new OspfInterfaceIdentifier((Long) ospfPseudonode.getChild(LAN_IFACE_NID).get().getValue()));
}
- } else if (routerId.getChild(OSPF_NODE_NID).isPresent()) {
- serializeOspfNode((ContainerNode)routerId.getChild(OSPF_NODE_NID).get(), buffer);
- } else if (routerId.getChild(OSPF_PSEUDONODE_NID).isPresent()) {
- final ContainerNode ospfPseudo = (ContainerNode)routerId.getChild(OSPF_PSEUDONODE_NID).get();
- serializeOspfNode((ContainerNode)ospfPseudo.getChild(OSPF_NODE_NID), buffer);
- buffer.writeInt(UnsignedInteger.valueOf((Long)ospfPseudo.getChild(LAN_IFACE_NID).get().getValue()).intValue());
+ if (ospfPseudonode.getChild(OSPF_ROUTER_NID).isPresent()) {
+ nodeBuilder.setOspfRouterId((Long) ospfPseudonode.getChild(OSPF_ROUTER_NID).get().getValue());
+ }
+ builder.setOspfPseudonode(nodeBuilder.build());
}
+ return builder.build();
}
- static void serializeNodeDescriptors(final ContainerNode descriptors, final ByteBuf buffer) {
- final Optional<DataContainerChild<? extends PathArgument, ?>> asNumber = descriptors.getChild(AS_NUMBER_NID);
+ private static CRouterIdentifier serializeRouterId(final ContainerNode descriptorsData) {
+ CRouterIdentifier cRouterId = null;
+ final Optional<DataContainerChild<? extends PathArgument, ?>> maybeRouterId = descriptorsData.getChild(ROUTER_NID);
+ if (maybeRouterId.isPresent()) {
+ final ChoiceNode routerId = (ChoiceNode) maybeRouterId.get();
+ if (routerId.getChild(ISIS_NODE_NID).isPresent()) {
+ cRouterId = serializeIsisNode((ContainerNode) routerId.getChild(ISIS_NODE_NID).get());
+ } else if (routerId.getChild(ISIS_PSEUDONODE_NID).isPresent()) {
+ cRouterId = serializeIsisPseudoNode((ContainerNode) routerId.getChild(ISIS_PSEUDONODE_NID).get());
+ } else if (routerId.getChild(OSPF_NODE_NID).isPresent()) {
+ cRouterId = serializeOspfNode((ContainerNode) routerId.getChild(OSPF_NODE_NID).get());
+ } else if (routerId.getChild(OSPF_PSEUDONODE_NID).isPresent()) {
+ cRouterId = serializeOspfPseudoNode((ContainerNode) routerId.getChild(OSPF_PSEUDONODE_NID).get());
+ }
+ }
+ return cRouterId;
+ }
+
+ private static AsNumber serializeAsNumber(final ContainerNode descriptorsData) {
+ final Optional<DataContainerChild<? extends PathArgument, ?>> asNumber = descriptorsData.getChild(AS_NUMBER_NID);
if (asNumber.isPresent()) {
- TlvUtil.writeTLV(AS_NUMBER, Unpooled.copyInt(UnsignedInteger.valueOf((Long)asNumber.get().getValue()).intValue()), buffer);
+ return new AsNumber((Long) asNumber.get().getValue());
}
- final Optional<DataContainerChild<? extends PathArgument, ?>> domainId = descriptors.getChild(DOMAIN_NID);
+ return null;
+ }
+
+ private static DomainIdentifier serializeDomainId(final ContainerNode descriptorsData) {
+ final Optional<DataContainerChild<? extends PathArgument, ?>> domainId = descriptorsData.getChild(DOMAIN_NID);
if (domainId.isPresent()) {
- TlvUtil.writeTLV(BGP_LS_ID, Unpooled.copyInt(UnsignedInteger.valueOf((Long)domainId.get().getValue()).intValue()), buffer);
+ return new DomainIdentifier((Long) domainId.get().getValue());
}
- final Optional<DataContainerChild<? extends PathArgument, ?>> areaId = descriptors.getChild(AREA_NID);
+ return null;
+ }
+
+ private static AreaIdentifier serializeAreaId(final ContainerNode descriptorsData) {
+ final Optional<DataContainerChild<? extends PathArgument, ?>> areaId = descriptorsData.getChild(AREA_NID);
if (areaId.isPresent()) {
- TlvUtil.writeTLV(AREA_ID, Unpooled.copyInt(UnsignedInteger.valueOf((Long)domainId.get().getValue()).intValue()), buffer);
- }
- final Optional<DataContainerChild<? extends PathArgument, ?>> routerId = descriptors.getChild(ROUTER_NID);
- if (routerId.isPresent()) {
- final ByteBuf routerIdBuf = Unpooled.buffer();
- serializeRouterId((ChoiceNode)routerId.get(), routerIdBuf);
- TlvUtil.writeTLV(IGP_ROUTER_ID, routerIdBuf, buffer);
+ return new AreaIdentifier((Long) areaId.get().getValue());
}
+ return null;
+ }
+
+ static LocalNodeDescriptors serializeLocalNodeDescriptors(final ContainerNode descriptorsData) {
+ LocalNodeDescriptorsBuilder builder = new LocalNodeDescriptorsBuilder();
+ builder.setAsNumber(serializeAsNumber(descriptorsData));
+ builder.setDomainId(serializeDomainId(descriptorsData));
+ builder.setAreaId(serializeAreaId(descriptorsData));
+ builder.setCRouterIdentifier(serializeRouterId(descriptorsData));
+ return builder.build();
+ }
+
+ static RemoteNodeDescriptors serializeRemoteNodeDescriptors(final ContainerNode descriptorsData) {
+ RemoteNodeDescriptorsBuilder builder = new RemoteNodeDescriptorsBuilder();
+ builder.setAsNumber(serializeAsNumber(descriptorsData));
+ builder.setDomainId(serializeDomainId(descriptorsData));
+ builder.setAreaId(serializeAreaId(descriptorsData));
+ builder.setCRouterIdentifier(serializeRouterId(descriptorsData));
+ return builder.build();
+ }
+
+ static AdvertisingNodeDescriptors serializeAdvNodeDescriptors(final ContainerNode descriptorsData) {
+ AdvertisingNodeDescriptorsBuilder builder = new AdvertisingNodeDescriptorsBuilder();
+ builder.setAsNumber(serializeAsNumber(descriptorsData));
+ builder.setDomainId(serializeDomainId(descriptorsData));
+ builder.setAreaId(serializeAreaId(descriptorsData));
+ builder.setCRouterIdentifier(serializeRouterId(descriptorsData));
+ return builder.build();
+ }
+
+ static NodeDescriptors serializeNodeDescriptors(final ContainerNode descriptorsData) {
+ NodeDescriptorsBuilder builder = new NodeDescriptorsBuilder();
+ builder.setAsNumber(serializeAsNumber(descriptorsData));
+ builder.setDomainId(serializeDomainId(descriptorsData));
+ builder.setAreaId(serializeAreaId(descriptorsData));
+ builder.setCRouterIdentifier(serializeRouterId(descriptorsData));
+ return builder.build();
}
}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Prefix;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.NlriType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.OspfRouteType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.TopologyIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.linkstate.object.type.prefix._case.PrefixDescriptors;
private static final int IP_REACHABILITY = 265;
/* Prefix Descriptor QNames */
- private static final NodeIdentifier OSPF_ROUTE_NID = new NodeIdentifier(QName.cachedReference(QName.create(PrefixDescriptors.QNAME, "ospf-route-type")));
- private static final NodeIdentifier IP_REACH_NID = new NodeIdentifier(QName.cachedReference(QName.create(PrefixDescriptors.QNAME, "ip-reachability-information")));
+ @VisibleForTesting
+ public static final NodeIdentifier OSPF_ROUTE_NID = new NodeIdentifier(QName.cachedReference(QName.create(PrefixDescriptors.QNAME, "ospf-route-type")));
+ @VisibleForTesting
+ public static final NodeIdentifier IP_REACH_NID = new NodeIdentifier(QName.cachedReference(QName.create(PrefixDescriptors.QNAME, "ip-reachability-information")));
static PrefixDescriptors parsePrefixDescriptors(final ByteBuf buffer, final boolean ipv4) throws BGPParsingException {
final PrefixDescriptorsBuilder builder = new PrefixDescriptorsBuilder();
LOG.debug("Expected length {}, actual length {}.", size, value.readableBytes());
throw new BGPParsingException("Illegal length of IP reachability TLV: " + (value.readableBytes()));
}
- prefix = (ipv4) ? new IpPrefix(Ipv4Util.prefixForBytes(ByteArray.readBytes(value, size), prefixLength)):
+ prefix = (ipv4) ? new IpPrefix(Ipv4Util.prefixForBytes(ByteArray.readBytes(value, size), prefixLength)) :
new IpPrefix(Ipv6Util.prefixForBytes(ByteArray.readBytes(value, size), prefixLength));
builder.setIpReachabilityInformation(prefix);
LOG.trace("Parsed IP reachability info: {}", prefix);
}
if (descriptors.getOspfRouteType() != null) {
TlvUtil.writeTLV(OSPF_ROUTE_TYPE,
- Unpooled.wrappedBuffer(new byte[] {UnsignedBytes.checkedCast(descriptors.getOspfRouteType().getIntValue()) }), buffer);
+ Unpooled.wrappedBuffer(new byte[] { UnsignedBytes.checkedCast(descriptors.getOspfRouteType().getIntValue()) }), buffer);
}
if (descriptors.getIpReachabilityInformation() != null) {
final IpPrefix prefix = descriptors.getIpReachabilityInformation();
// FIXME : use codec
private static int domOspfRouteTypeValue(final String ospfRouteType) {
- switch(ospfRouteType) {
+ switch (ospfRouteType) {
case "intra-area":
return 1;
case "inter-area":
}
}
- static NlriType serializePrefixDescriptors(final ContainerNode descriptors, final ByteBuf buffer) {
- if (descriptors.getChild(TlvUtil.MULTI_TOPOLOGY_NID).isPresent()) {
- TlvUtil.writeTLV(TlvUtil.MULTI_TOPOLOGY_ID, Unpooled.copyShort((Short)descriptors.getChild(TlvUtil.MULTI_TOPOLOGY_NID).get().getValue()), buffer);
+ public static PrefixDescriptors serializePrefixDescriptors(final ContainerNode prefixDesc) {
+ final PrefixDescriptorsBuilder prefixDescBuilder = new PrefixDescriptorsBuilder();
+ if (prefixDesc.getChild(TlvUtil.MULTI_TOPOLOGY_NID).isPresent()) {
+ prefixDescBuilder.setMultiTopologyId(new TopologyIdentifier((Integer) prefixDesc.getChild(TlvUtil.MULTI_TOPOLOGY_NID).get().getValue()));
}
- final Optional<DataContainerChild<? extends PathArgument, ?>> ospfRoute = descriptors.getChild(OSPF_ROUTE_NID);
+ final Optional<DataContainerChild<? extends PathArgument, ?>> ospfRoute = prefixDesc.getChild(OSPF_ROUTE_NID);
if (ospfRoute.isPresent()) {
- // DOM representation contains values as are in the model, not as are in generated enum
- TlvUtil.writeTLV(OSPF_ROUTE_TYPE,
- Unpooled.wrappedBuffer(new byte[] {UnsignedBytes.checkedCast(domOspfRouteTypeValue((String)ospfRoute.get().getValue())) }), buffer);
+ prefixDescBuilder.setOspfRouteType(OspfRouteType.forValue(domOspfRouteTypeValue((String) ospfRoute.get().getValue())));
}
- byte[] prefixBytes = null;
- NlriType prefixType = null;
- if (descriptors.getChild(IP_REACH_NID).isPresent()) {
- final String prefix = (String)descriptors.getChild(IP_REACH_NID).get().getValue();
- // DOM data does not have any information what kind of prefix is it holding,
- // therefore we need to rely on the pattern matcher in Ipv4Prefix constructor
+ if (prefixDesc.getChild(IP_REACH_NID).isPresent()) {
+ final String prefix = (String) prefixDesc.getChild(IP_REACH_NID).get().getValue();
+
try {
- prefixBytes = Ipv4Util.bytesForPrefixBegin(new Ipv4Prefix(prefix));
- prefixType = NlriType.Ipv4Prefix;
- } catch(final IllegalArgumentException e) {
+ Ipv4Util.bytesForPrefixBegin(new Ipv4Prefix(prefix));
+ prefixDescBuilder.setIpReachabilityInformation(new IpPrefix(new Ipv4Prefix(prefix)));
+ } catch (final IllegalArgumentException e) {
LOG.debug("Creating Ipv6 prefix because", e);
- prefixBytes = Ipv6Util.bytesForPrefixBegin(new Ipv6Prefix(prefix));
- prefixType = NlriType.Ipv6Prefix;
+ prefixDescBuilder.setIpReachabilityInformation(new IpPrefix(new Ipv6Prefix(prefix)));
}
- TlvUtil.writeTLV(IP_REACHABILITY, Unpooled.wrappedBuffer(prefixBytes), buffer);
}
- return prefixType;
+ return prefixDescBuilder.build();
}
}
import org.opendaylight.protocol.bgp.linkstate.nlri.LinkstateNlriParser;
import org.opendaylight.protocol.bgp.linkstate.nlri.NodeNlriParser;
import org.opendaylight.protocol.bgp.linkstate.nlri.PrefixNlriParser;
+import org.opendaylight.protocol.bgp.linkstate.spi.TlvUtil;
import org.opendaylight.protocol.bgp.parser.BGPParsingException;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.AsNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.linkstate.object.type.node._case.NodeDescriptors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.linkstate.object.type.prefix._case.AdvertisingNodeDescriptors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.linkstate.object.type.prefix._case.PrefixDescriptors;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.node.identifier.CRouterIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.node.identifier.c.router.identifier.IsisNodeCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.node.identifier.c.router.identifier.IsisPseudonodeCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.node.identifier.c.router.identifier.OspfNodeCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.attributes.mp.unreach.nlri.WithdrawnRoutes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.attributes.mp.unreach.nlri.WithdrawnRoutesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.concepts.rev131125.IsoSystemIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUnkeyedListEntryNodeBuilder;
public class LinkstateNlriParserTest {
+ private static final NodeIdentifier C_LINKSTATE_NID = new NodeIdentifier(CLinkstateDestination.QNAME);
+ private static final NodeIdentifier C_ROUTER_ID_NID = new NodeIdentifier(CRouterIdentifier.QNAME);
+
private final byte[] nodeNlri = new byte[] { (byte) 0x00, (byte) 0x01, (byte) 0x00, (byte) 0x30, (byte) 0x02, (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x01, (byte) 0x01, (byte) 0x00, (byte) 0x00, (byte) 0x23,
(byte) 0x02, (byte) 0x00, (byte) 0x00, (byte) 0x04, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x48, (byte) 0x02, (byte) 0x01,
public void testNodeNlri() throws BGPParsingException {
setUp(this.nodeNlri);
+ // test BA form
assertNull(this.dest.getDistinguisher());
assertEquals(ProtocolId.IsisLevel2, this.dest.getProtocolId());
assertEquals(BigInteger.ONE, this.dest.getIdentifier().getValue());
- final NodeCase nCase = ((NodeCase)this.dest.getObjectType());
+ final NodeCase nCase = ((NodeCase) this.dest.getObjectType());
final NodeDescriptors nodeD = nCase.getNodeDescriptors();
assertEquals(new AsNumber(72L), nodeD.getAsNumber());
assertEquals(new DomainIdentifier(0x28282828L), nodeD.getDomainId());
assertEquals(new IsisPseudonodeCaseBuilder().setIsisPseudonode(
new IsisPseudonodeBuilder().setPsn((short) 5).setIsIsRouterIdentifier(
- new IsIsRouterIdentifierBuilder().setIsoSystemId(
- new IsoSystemIdentifier(new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
- (byte) 0x39 })).build()).build()).build(), nodeD.getCRouterIdentifier());
+ new IsIsRouterIdentifierBuilder().setIsoSystemId(new IsoSystemIdentifier(new byte[] { 0, 0, 0, 0, 0, (byte) 0x39 })).build()).build()).build(), nodeD.getCRouterIdentifier());
final ByteBuf buffer = Unpooled.buffer();
LinkstateNlriParser.serializeNlri(this.dest, buffer);
assertArrayEquals(this.nodeNlri, ByteArray.readAllBytes(buffer));
+
+ // test BI form
+ final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode> linkstateBI = ImmutableUnkeyedListEntryNodeBuilder
+ .create();
+ linkstateBI.withNodeIdentifier(C_LINKSTATE_NID);
+
+ final ImmutableLeafNodeBuilder<String> protocolId = new ImmutableLeafNodeBuilder<>();
+ protocolId.withNodeIdentifier(LinkstateNlriParser.PROTOCOL_ID_NID);
+ protocolId.withValue("isis-level2");
+ linkstateBI.addChild(protocolId.build());
+
+ final ImmutableLeafNodeBuilder<BigInteger> identifier = new ImmutableLeafNodeBuilder<>();
+ identifier.withNodeIdentifier(LinkstateNlriParser.IDENTIFIER_NID);
+ identifier.withValue(BigInteger.ONE);
+ linkstateBI.addChild(identifier.build());
+
+ final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> objectType = Builders.choiceBuilder();
+ objectType.withNodeIdentifier(LinkstateNlriParser.OBJECT_TYPE_NID);
+
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> nodeDescriptors = Builders.containerBuilder();
+ nodeDescriptors.withNodeIdentifier(LinkstateNlriParser.NODE_DESCRIPTORS_NID);
+
+ final ImmutableLeafNodeBuilder<Long> asNumber = new ImmutableLeafNodeBuilder<>();
+ asNumber.withNodeIdentifier(NodeNlriParser.AS_NUMBER_NID);
+ asNumber.withValue(72L);
+ nodeDescriptors.addChild(asNumber.build());
+
+ final ImmutableLeafNodeBuilder<Long> areaID = new ImmutableLeafNodeBuilder<>();
+ areaID.withNodeIdentifier(NodeNlriParser.AREA_NID);
+ areaID.withValue(2697513L); nodeDescriptors.addChild(areaID.build());
+
+ final ImmutableLeafNodeBuilder<Long> domainID = new ImmutableLeafNodeBuilder<>();
+ domainID.withNodeIdentifier(NodeNlriParser.DOMAIN_NID);
+ domainID.withValue(0x28282828L);
+ nodeDescriptors.addChild(domainID.build());
+
+ final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> crouterId = Builders.choiceBuilder();
+ crouterId.withNodeIdentifier(C_ROUTER_ID_NID);
+
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> isisNode = Builders.containerBuilder();
+ isisNode.withNodeIdentifier(NodeNlriParser.ISIS_PSEUDONODE_NID);
+
+ final ImmutableLeafNodeBuilder<byte[]> isoSystemID = new ImmutableLeafNodeBuilder<>();
+ isoSystemID.withNodeIdentifier(NodeNlriParser.ISO_SYSTEM_NID);
+ isoSystemID.withValue(new byte[] { 0, 0, 0, 0, 0, (byte) 0x39 });
+ isisNode.addChild(isoSystemID.build());
+ isisNode.addChild(Builders.leafBuilder().withNodeIdentifier(NodeNlriParser.PSN_NID).withValue((short) 5).build());
+ crouterId.addChild(isisNode.build());
+
+ nodeDescriptors.addChild(crouterId.build());
+ objectType.addChild(nodeDescriptors.build());
+ linkstateBI.addChild(objectType.build());
+
+ assertEquals(this.dest, LinkstateNlriParser.extractLinkstateDestination(linkstateBI.build()));
}
@Test
public void testLinkNlri() throws BGPParsingException {
setUp(this.linkNlri);
+ // test BA form
assertNull(this.dest.getDistinguisher());
assertEquals(ProtocolId.IsisLevel2, this.dest.getProtocolId());
assertEquals(BigInteger.ONE, this.dest.getIdentifier().getValue());
- final LinkCase lCase = ((LinkCase)this.dest.getObjectType());
+ final LinkCase lCase = ((LinkCase) this.dest.getObjectType());
final LocalNodeDescriptors local = lCase.getLocalNodeDescriptors();
assertEquals(new AsNumber(72L), local.getAsNumber());
final ByteBuf buffer = Unpooled.buffer();
LinkstateNlriParser.serializeNlri(this.dest, buffer);
assertArrayEquals(this.linkNlri, ByteArray.readAllBytes(buffer));
+
+ // test BI form
+ final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode> linkstateBI = ImmutableUnkeyedListEntryNodeBuilder.create();
+ linkstateBI.withNodeIdentifier(C_LINKSTATE_NID);
+
+ final ImmutableLeafNodeBuilder<String> protocolId = new ImmutableLeafNodeBuilder<>();
+ protocolId.withNodeIdentifier(LinkstateNlriParser.PROTOCOL_ID_NID);
+ protocolId.withValue("isis-level2");
+ linkstateBI.addChild(protocolId.build());
+
+ final ImmutableLeafNodeBuilder<BigInteger> identifier = new ImmutableLeafNodeBuilder<>();
+ identifier.withNodeIdentifier(LinkstateNlriParser.IDENTIFIER_NID);
+ identifier.withValue(BigInteger.ONE);
+ linkstateBI.addChild(identifier.build());
+
+ final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> objectType = Builders.choiceBuilder();
+ objectType.withNodeIdentifier(LinkstateNlriParser.OBJECT_TYPE_NID);
+
+ // local node descriptors
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> localNodeDescriptors = Builders.containerBuilder();
+ localNodeDescriptors.withNodeIdentifier(LinkstateNlriParser.LOCAL_NODE_DESCRIPTORS_NID);
+
+ final ImmutableLeafNodeBuilder<Long> asNumber = new ImmutableLeafNodeBuilder<>();
+ asNumber.withNodeIdentifier(NodeNlriParser.AS_NUMBER_NID);
+ asNumber.withValue(72L);
+ localNodeDescriptors.addChild(asNumber.build());
+
+ final ImmutableLeafNodeBuilder<Long> domainID = new ImmutableLeafNodeBuilder<>();
+ domainID.withNodeIdentifier(NodeNlriParser.DOMAIN_NID);
+ domainID.withValue(0x28282828L);
+ localNodeDescriptors.addChild(domainID.build());
+
+ final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> crouterId = Builders.choiceBuilder();
+ crouterId.withNodeIdentifier(C_ROUTER_ID_NID);
+
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> isisNode = Builders.containerBuilder();
+ isisNode.withNodeIdentifier(NodeNlriParser.ISIS_NODE_NID);
+
+ final ImmutableLeafNodeBuilder<byte[]> isoSystemID = new ImmutableLeafNodeBuilder<>();
+ isoSystemID.withNodeIdentifier(NodeNlriParser.ISO_SYSTEM_NID);
+ isoSystemID.withValue(new byte[] { 0, 0, 0, 0, 0, (byte) 0x42 });
+
+ isisNode.addChild(isoSystemID.build());
+ crouterId.addChild(isisNode.build());
+ localNodeDescriptors.addChild(crouterId.build());
+
+ // remote descriptors
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> remoteNodeDescriptors = Builders.containerBuilder();
+ remoteNodeDescriptors.withNodeIdentifier(LinkstateNlriParser.REMOTE_NODE_DESCRIPTORS_NID);
+ remoteNodeDescriptors.addChild(asNumber.build());
+ remoteNodeDescriptors.addChild(domainID.build());
+
+ final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> crouterId2 = Builders.choiceBuilder();
+ crouterId2.withNodeIdentifier(C_ROUTER_ID_NID);
+
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> ospfNode = Builders.containerBuilder();
+ ospfNode.withNodeIdentifier(NodeNlriParser.OSPF_NODE_NID);
+
+ final ImmutableLeafNodeBuilder<Long> ospfRouterId = new ImmutableLeafNodeBuilder<>();
+ ospfRouterId.withNodeIdentifier(NodeNlriParser.OSPF_ROUTER_NID);
+ ospfRouterId.withValue(0x00000040L);
+ ospfNode.addChild(ospfRouterId.build());
+ crouterId2.addChild(ospfNode.build());
+ remoteNodeDescriptors.addChild(crouterId2.build());
+
+ // link descritpors
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> linkDescriptors = Builders.containerBuilder();
+ linkDescriptors.withNodeIdentifier(LinkstateNlriParser.LINK_DESCRIPTORS_NID);
+
+ final ImmutableLeafNodeBuilder<Long> linkLocalIdentifier = new ImmutableLeafNodeBuilder<>();
+ linkLocalIdentifier.withNodeIdentifier(LinkNlriParser.LINK_LOCAL_NID);
+ linkLocalIdentifier.withValue(16909060L);
+
+ final ImmutableLeafNodeBuilder<Long> linkRemoteIdentifier = new ImmutableLeafNodeBuilder<>();
+ linkRemoteIdentifier.withNodeIdentifier(LinkNlriParser.LINK_REMOTE_NID);
+ linkRemoteIdentifier.withValue(168496141L);
+
+ final ImmutableLeafNodeBuilder<String> ipv4InterfaceAddress = new ImmutableLeafNodeBuilder<>();
+ ipv4InterfaceAddress.withNodeIdentifier(LinkNlriParser.IPV4_IFACE_NID);
+ ipv4InterfaceAddress.withValue("197.20.160.42");
+
+ final ImmutableLeafNodeBuilder<String> ipv4NeighborAddress = new ImmutableLeafNodeBuilder<>();
+ ipv4NeighborAddress.withNodeIdentifier(LinkNlriParser.IPV4_NEIGHBOR_NID);
+ ipv4NeighborAddress.withValue("197.20.160.40");
+
+ final ImmutableLeafNodeBuilder<Integer> multiTopologyId = new ImmutableLeafNodeBuilder<>();
+ multiTopologyId.withNodeIdentifier(TlvUtil.MULTI_TOPOLOGY_NID);
+ multiTopologyId.withValue(3);
+
+ linkDescriptors.addChild(linkLocalIdentifier.build());
+ linkDescriptors.addChild(linkRemoteIdentifier.build());
+ linkDescriptors.addChild(ipv4InterfaceAddress.build());
+ linkDescriptors.addChild(ipv4NeighborAddress.build());
+ linkDescriptors.addChild(multiTopologyId.build());
+
+ objectType.addChild(localNodeDescriptors.build());
+ objectType.addChild(remoteNodeDescriptors.build());
+ objectType.addChild(linkDescriptors.build());
+
+ linkstateBI.addChild(objectType.build());
+ assertEquals(this.dest, LinkstateNlriParser.extractLinkstateDestination(linkstateBI.build()));
}
@Test
public void testPrefixNlri() throws BGPParsingException {
setUp(this.prefixNlri);
+ // test BA form
assertNull(this.dest.getDistinguisher());
assertEquals(ProtocolId.IsisLevel2, this.dest.getProtocolId());
assertEquals(BigInteger.ONE, this.dest.getIdentifier().getValue());
- final PrefixCase pCase = ((PrefixCase)this.dest.getObjectType());
+ final PrefixCase pCase = ((PrefixCase) this.dest.getObjectType());
final AdvertisingNodeDescriptors local = pCase.getAdvertisingNodeDescriptors();
assertEquals(new AsNumber(72L), local.getAsNumber());
final ByteBuf buffer = Unpooled.buffer();
LinkstateNlriParser.serializeNlri(this.dest, buffer);
assertArrayEquals(this.prefixNlri, ByteArray.readAllBytes(buffer));
+
+ // test BI form
+ final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode> linkstateBI = ImmutableUnkeyedListEntryNodeBuilder.create();
+ linkstateBI.withNodeIdentifier(C_LINKSTATE_NID);
+
+ final ImmutableLeafNodeBuilder<String> protocolId = new ImmutableLeafNodeBuilder<>();
+ protocolId.withNodeIdentifier(LinkstateNlriParser.PROTOCOL_ID_NID);
+ protocolId.withValue("isis-level2");
+ linkstateBI.addChild(protocolId.build());
+
+ final ImmutableLeafNodeBuilder<BigInteger> identifier = new ImmutableLeafNodeBuilder<>();
+ identifier.withNodeIdentifier(LinkstateNlriParser.IDENTIFIER_NID);
+ identifier.withValue(BigInteger.ONE);
+ linkstateBI.addChild(identifier.build());
+
+ final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> objectType = Builders.choiceBuilder();
+ objectType.withNodeIdentifier(LinkstateNlriParser.OBJECT_TYPE_NID);
+
+ // advertising node descriptors
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> advertisingNodeDescriptors = Builders.containerBuilder();
+ advertisingNodeDescriptors.withNodeIdentifier(LinkstateNlriParser.ADVERTISING_NODE_DESCRIPTORS_NID);
+
+ final ImmutableLeafNodeBuilder<Long> asNumber = new ImmutableLeafNodeBuilder<>();
+ asNumber.withNodeIdentifier(NodeNlriParser.AS_NUMBER_NID);
+ asNumber.withValue(72L);
+ advertisingNodeDescriptors.addChild(asNumber.build());
+
+ final ImmutableLeafNodeBuilder<Long> domainID = new ImmutableLeafNodeBuilder<>();
+ domainID.withNodeIdentifier(NodeNlriParser.DOMAIN_NID);
+ domainID.withValue(673720360L);
+ advertisingNodeDescriptors.addChild(domainID.build());
+
+ final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> crouterId = Builders.choiceBuilder();
+ crouterId.withNodeIdentifier(C_ROUTER_ID_NID);
+
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> isisNode = Builders.containerBuilder();
+ isisNode.withNodeIdentifier(NodeNlriParser.ISIS_NODE_NID);
+
+ final ImmutableLeafNodeBuilder<byte[]> isoSystemID = new ImmutableLeafNodeBuilder<>();
+ isoSystemID.withNodeIdentifier(NodeNlriParser.ISO_SYSTEM_NID);
+ isoSystemID.withValue(new byte[] { 0, 0, 0, 0, 0, (byte) 0x42 });
+
+ isisNode.addChild(isoSystemID.build());
+ crouterId.addChild(isisNode.build());
+ advertisingNodeDescriptors.addChild(crouterId.build());
+
+ // prefix descriptors
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> prefixDescriptors = Builders.containerBuilder();
+ prefixDescriptors.withNodeIdentifier(LinkstateNlriParser.PREFIX_DESCRIPTORS_NID);
+ prefixDescriptors.addChild(asNumber.build());
+ prefixDescriptors.addChild(domainID.build());
+
+ final ImmutableLeafNodeBuilder<Integer> multiTopologyId = new ImmutableLeafNodeBuilder<>();
+ multiTopologyId.withNodeIdentifier(TlvUtil.MULTI_TOPOLOGY_NID);
+ multiTopologyId.withValue(15);
+
+ prefixDescriptors.addChild(multiTopologyId.build());
+
+ final ImmutableLeafNodeBuilder<String> ipReachabilityInformation = new ImmutableLeafNodeBuilder<>();
+ ipReachabilityInformation.withNodeIdentifier(PrefixNlriParser.IP_REACH_NID);
+ ipReachabilityInformation.withValue("255.255.0.0/16");
+
+ prefixDescriptors.addChild(ipReachabilityInformation.build());
+
+ final ImmutableLeafNodeBuilder<String> ospfRouteType = new ImmutableLeafNodeBuilder<>();
+ ospfRouteType.withNodeIdentifier(PrefixNlriParser.OSPF_ROUTE_NID);
+ ospfRouteType.withValue("external1");
+
+ prefixDescriptors.addChild(ospfRouteType.build());
+
+ objectType.addChild(advertisingNodeDescriptors.build());
+ objectType.addChild(prefixDescriptors.build());
+
+ linkstateBI.addChild(objectType.build());
+ assertEquals(this.dest, LinkstateNlriParser.extractLinkstateDestination(linkstateBI.build()));
}
@Test
public void testSerializeAttribute() throws BGPParsingException {
final LinkstateNlriParser parser = new LinkstateNlriParser(true);
setUp(this.prefixNlri);
- final List<CLinkstateDestination> dests = Lists.newArrayList( this.dest );
+ final List<CLinkstateDestination> dests = Lists.newArrayList(this.dest);
final DestinationLinkstateCase dlc = new DestinationLinkstateCaseBuilder().setDestinationLinkstate(new DestinationLinkstateBuilder().setCLinkstateDestination(dests).build()).build();
final AdvertizedRoutes aroutes = new AdvertizedRoutesBuilder().setDestinationType(dlc).build();
final Attributes1 reach = new Attributes1Builder().setMpReachNlri(new MpReachNlriBuilder().setAdvertizedRoutes(aroutes).build()).build();
assertArrayEquals(this.prefixNlri, ByteArray.getAllBytes(result));
setUp(this.nodeNlri);
- final List<CLinkstateDestination> destsU = Lists.newArrayList( this.dest );
+ final List<CLinkstateDestination> destsU = Lists.newArrayList(this.dest);
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.update.attributes.mp.unreach.nlri.withdrawn.routes.destination.type.DestinationLinkstateCase dlcU =
new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.update.attributes.mp.unreach.nlri.withdrawn.routes.destination.type.DestinationLinkstateCaseBuilder().setDestinationLinkstate(
new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.update.attributes.mp.unreach.nlri.withdrawn.routes.destination.type.destination.linkstate._case.DestinationLinkstateBuilder().setCLinkstateDestination(destsU).build()).build();
assertArrayEquals(this.nodeNlri, ByteArray.getAllBytes(result));
}
- @Test(expected=UnsupportedOperationException.class)
+ @Test(expected = UnsupportedOperationException.class)
public void testLinkNlriPrivateConstructor() throws Throwable {
final Constructor<LinkNlriParser> c = LinkNlriParser.class.getDeclaredConstructor();
c.setAccessible(true);
}
}
- @Test(expected=UnsupportedOperationException.class)
+ @Test(expected = UnsupportedOperationException.class)
public void testNodeNlriPrivateConstructor() throws Throwable {
final Constructor<NodeNlriParser> c = NodeNlriParser.class.getDeclaredConstructor();
c.setAccessible(true);
}
}
- @Test(expected=UnsupportedOperationException.class)
+ @Test(expected = UnsupportedOperationException.class)
public void testPrefixNlriPrivateConstructor() throws Throwable {
final Constructor<PrefixNlriParser> c = PrefixNlriParser.class.getDeclaredConstructor();
c.setAccessible(true);
Code Review / bgpcep.git / commitdiff