[ONOS] BGP Selection Algo and Test
Change-Id: I9d9e8c699dea46fde07b7cba526b3c7fd1f3bd34
diff --git a/bgp/ctl/src/main/java/org/onosproject/bgp/controller/impl/BgpSelectionAlgo.java b/bgp/ctl/src/main/java/org/onosproject/bgp/controller/impl/BgpSelectionAlgo.java
new file mode 100644
index 0000000..d3065f4
--- /dev/null
+++ b/bgp/ctl/src/main/java/org/onosproject/bgp/controller/impl/BgpSelectionAlgo.java
@@ -0,0 +1,242 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.bgp.controller.impl;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.ListIterator;
+
+import org.onosproject.bgpio.protocol.linkstate.PathAttrNlriDetailsLocalRib;
+import org.onosproject.bgpio.types.AsPath;
+import org.onosproject.bgpio.types.BgpValueType;
+import org.onosproject.bgpio.types.LocalPref;
+import org.onosproject.bgpio.types.Med;
+import org.onosproject.bgpio.types.Origin;
+import org.onosproject.bgpio.types.Origin.ORIGINTYPE;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Implementation of BGP best path Selection process.
+ */
+public final class BgpSelectionAlgo implements Comparator<PathAttrNlriDetailsLocalRib> {
+ private static final Logger log = LoggerFactory.getLogger(BgpSelectionAlgo.class);
+ LocalPref obj1LocPref = null;
+ AsPath obj1Aspath = null;
+ Origin obj1Origin = null;
+ Med obj1Med = null;
+ LocalPref obj2LocPref = null;
+ AsPath obj2Aspath = null;
+ Origin obj2Origin = null;
+ Med obj2Med = null;
+
+ @Override
+ public int compare(PathAttrNlriDetailsLocalRib pathNlriDetails1, PathAttrNlriDetailsLocalRib pathNlriDetails2) {
+ if (pathNlriDetails1 == null) {
+ return -1;
+ }
+ if (pathNlriDetails2 == null) {
+ return 1;
+ }
+ if (pathNlriDetails1.equals(pathNlriDetails2)) {
+ return 0;
+ }
+
+ List<BgpValueType> o1 = pathNlriDetails1.localRibNlridetails().pathAttributes();
+ List<BgpValueType> o2 = pathNlriDetails2.localRibNlridetails().pathAttributes();
+ ListIterator<BgpValueType> listIteratorObj1 = o1.listIterator();
+ ListIterator<BgpValueType> listIteratorObj2 = o2.listIterator();
+ storeAttr(listIteratorObj1, listIteratorObj2);
+
+ // prefer attribute with higher local preference
+ if (obj1LocPref != null || obj2LocPref != null && (obj1LocPref != null && !obj1LocPref.equals(obj2LocPref))) {
+ return compareLocalPref(obj1LocPref, obj2LocPref);
+ }
+
+ // prefer attribute with shortest Aspath
+ if (!obj1Aspath.equals(obj2Aspath)) {
+ Integer obj1Size = countASSize(obj1Aspath);
+ Integer obj2Size = countASSize(obj2Aspath);
+ if (obj1Size != obj2Size) {
+ return compareAsPath(obj1Size, obj2Size);
+ }
+ }
+
+ // prefer attribute with lowest origin type
+ if (!obj1Origin.equals(obj2Origin)) {
+ return compareOrigin(obj1Origin, obj2Origin);
+ }
+
+ // prefer attribute with lowest MED
+ if (obj1Med != null || obj2Med != null && (obj1Med != null && !obj1Med.equals(obj2Med))) {
+ return compareMed(obj1Med, obj2Med);
+ }
+
+ if ((pathNlriDetails1 != null || pathNlriDetails2 != null) && (pathNlriDetails1 != null && !pathNlriDetails1
+ .equals(pathNlriDetails2))) {
+ return comparePeerDetails(pathNlriDetails1, pathNlriDetails2);
+ }
+ return 0;
+ }
+
+ /**
+ * Compares local preference of two objects and returns object with higher preference.
+ *
+ * @param obj1LocPref local preference object1
+ * @param obj2LocPref local preference object2
+ * @return object with higher preference
+ */
+ int compareLocalPref(LocalPref obj1LocPref, LocalPref obj2LocPref) {
+ return ((Integer) (obj1LocPref.localPref())).compareTo((Integer) (obj2LocPref.localPref()));
+ }
+
+ /**
+ * Compares AsPath of two objects and returns object with shortest AsPath.
+ *
+ * @param obj1Size object1 AS count
+ * @param obj2Size object2 AS count
+ * @return
+ */
+ int compareAsPath(Integer obj1Size, Integer obj2Size) {
+ return obj1Size.compareTo(obj2Size);
+ }
+
+ /**
+ * Compare Origin of two objects and returns object with lowest origin value.
+ *
+ * @param obj1Origin Origin object1
+ * @param obj2Origin Origin object1
+ * @return object with lowest origin value
+ */
+ int compareOrigin(Origin obj1Origin, Origin obj2Origin) {
+ if (obj1Origin.origin() == ORIGINTYPE.IGP) {
+ return 1;
+ }
+ if (obj2Origin.origin() == ORIGINTYPE.IGP) {
+ return -1;
+ }
+ if (obj1Origin.origin() == ORIGINTYPE.EGP) {
+ return 1;
+ } else {
+ return -1;
+ }
+ }
+
+ /**
+ * Compare Med of two objects and returns object with lowestMed value.
+ *
+ * @param obj1Med Med object1
+ * @param obj2Med Med object2
+ * @return returns object with lowestMed value
+ */
+ int compareMed(Med obj1Med, Med obj2Med) {
+ return ((Integer) (obj2Med.med())).compareTo((Integer) (obj1Med.med()));
+ }
+
+ /**
+ * Compares EBGP over IBGP, BGP identifier value and peer address.
+ *
+ * @param pathNlriDetails1 PathAttrNlriDetailsLocalRib object1
+ * @param pathNlriDetails2 PathAttrNlriDetailsLocalRib object2
+ * @return object which as EBGP over IBGP, lowest BGP identifier value and lowest peer address
+ */
+ int comparePeerDetails(PathAttrNlriDetailsLocalRib pathNlriDetails1, PathAttrNlriDetailsLocalRib pathNlriDetails2) {
+ // consider EBGP over IBGP
+ if (pathNlriDetails1.isLocalRibIbgpSession() != pathNlriDetails2.isLocalRibIbgpSession()) {
+ if (pathNlriDetails1 == null || pathNlriDetails1.isLocalRibIbgpSession()) {
+ return -1;
+ }
+ if (pathNlriDetails2 == null || pathNlriDetails2.isLocalRibIbgpSession()) {
+ return 1;
+ }
+ }
+ // prefer lowest BGP identifier value.
+ if (pathNlriDetails1.localRibIdentifier() != pathNlriDetails2.localRibIdentifier()) {
+ return ((Integer) pathNlriDetails2.localRibIdentifier())
+ .compareTo(pathNlriDetails1.localRibIdentifier());
+ }
+ //prefer lowest peer address
+ if (pathNlriDetails1.localRibIpAddress() != pathNlriDetails2.localRibIpAddress()) {
+ return pathNlriDetails2.localRibIpAddress().compareTo(pathNlriDetails1.localRibIpAddress());
+ }
+ return 0;
+ }
+
+ /**
+ * Returns ASes count of AsPath attribute , if AS_SET is present then count as 1.
+ *
+ * @param aspath object of AsPath
+ * @return count of ASes
+ */
+ Integer countASSize(AsPath aspath) {
+ boolean isASSet = false;
+ int count = 0;
+ if (!aspath.asPathSet().isEmpty()) {
+ isASSet = true;
+ }
+ if (!aspath.asPathSeq().isEmpty()) {
+ count = aspath.asPathSeq().size();
+ }
+ return isASSet ? ++count : count;
+ }
+
+ /**
+ * Stores BGP basic attributes of two objects.
+ *
+ * @param listIteratorObj1 list iterator of object1
+ * @param listIteratorObj2 list iterator of object2
+ */
+ void storeAttr(ListIterator<BgpValueType> listIteratorObj1, ListIterator<BgpValueType> listIteratorObj2) {
+ while (listIteratorObj1.hasNext()) {
+ BgpValueType pathAttributeObj1 = listIteratorObj1.next();
+ switch (pathAttributeObj1.getType()) {
+ case LocalPref.LOCAL_PREF_TYPE:
+ obj1LocPref = (LocalPref) pathAttributeObj1;
+ break;
+ case AsPath.ASPATH_TYPE:
+ obj1Aspath = (AsPath) pathAttributeObj1;
+ break;
+ case Origin.ORIGIN_TYPE:
+ obj1Origin = (Origin) pathAttributeObj1;
+ break;
+ case Med.MED_TYPE:
+ obj1Med = (Med) pathAttributeObj1;
+ break;
+ default:
+ log.debug("Got other type, Not required: " + pathAttributeObj1.getType());
+ }
+ }
+ while (listIteratorObj2.hasNext()) {
+ BgpValueType pathAttributeObj2 = listIteratorObj2.next();
+ switch (pathAttributeObj2.getType()) {
+ case LocalPref.LOCAL_PREF_TYPE:
+ obj2LocPref = (LocalPref) pathAttributeObj2;
+ break;
+ case AsPath.ASPATH_TYPE:
+ obj2Aspath = (AsPath) pathAttributeObj2;
+ break;
+ case Origin.ORIGIN_TYPE:
+ obj2Origin = (Origin) pathAttributeObj2;
+ break;
+ case Med.MED_TYPE:
+ obj2Med = (Med) pathAttributeObj2;
+ break;
+ default:
+ log.debug("Got other type, Not required: " + pathAttributeObj2.getType());
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/bgp/ctl/src/test/java/org/onosproject/controller/impl/BgpSelectionAlgoTest.java b/bgp/ctl/src/test/java/org/onosproject/controller/impl/BgpSelectionAlgoTest.java
new file mode 100644
index 0000000..7c0fa41
--- /dev/null
+++ b/bgp/ctl/src/test/java/org/onosproject/controller/impl/BgpSelectionAlgoTest.java
@@ -0,0 +1,595 @@
+/*
+ * Copyright 2014-2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.controller.impl;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+
+import java.util.LinkedList;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.jboss.netty.buffer.ChannelBuffers;
+import org.junit.Test;
+import org.onlab.packet.IpAddress;
+import org.onlab.packet.IpAddress.Version;
+import org.onosproject.bgpio.exceptions.BgpParseException;
+import org.onosproject.bgpio.protocol.linkstate.BgpNodeLSNlriVer4.ProtocolType;
+import org.onosproject.bgpio.protocol.linkstate.PathAttrNlriDetails;
+import org.onosproject.bgpio.protocol.linkstate.PathAttrNlriDetailsLocalRib;
+import org.onosproject.bgpio.types.AsPath;
+import org.onosproject.bgpio.types.BgpValueType;
+import org.onosproject.bgpio.types.LocalPref;
+import org.onosproject.bgpio.types.Med;
+import org.onosproject.bgpio.types.Origin;
+import org.onosproject.bgp.controller.impl.BgpSelectionAlgo;
+
+/**
+ * Test cases for BGP Selection Algorithm.
+ */
+public class BgpSelectionAlgoTest {
+
+ /**
+ * firstPathAttribute and secondPathAttribute has same AS count and firstPathAttribute
+ * has shortest Origin value than secondPathAttribute.
+ */
+ @Test
+ public void selectionAlgoTest1() throws BgpParseException {
+ byte[] peerIp = new byte[] {0x0a, 0x0a, 0x0a, 0x0a };
+ LinkedList<BgpValueType> pathAttributes1 = new LinkedList<>();
+ BgpValueType pathAttribute1;
+ //origin with IGP
+ byte[] origin = new byte[] {0x40, 0x01, 0x01, 0x00 };
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute1 = Origin.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+ //AsPath with AS_SEQ with one AS
+ byte[] asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xea };
+ buffer.writeBytes(asPath);
+ pathAttribute1 = AsPath.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+
+ IpAddress ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ int bgpId = 168427777;
+ short locRIBASNum = 100;
+ boolean isIbgp = false;
+ PathAttrNlriDetails attrList1 = new PathAttrNlriDetails();
+ attrList1.setIdentifier(0);
+ attrList1.setPathAttribute(pathAttributes1);
+ attrList1.setProtocolID(ProtocolType.ISIS_LEVEL_ONE);
+ PathAttrNlriDetailsLocalRib list1 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList1);
+
+ peerIp = new byte[] {0x0b, 0x0b, 0x0b, 0x0b };
+ LinkedList<BgpValueType> pathAttributes2 = new LinkedList<>();
+ BgpValueType pathAttribute2;
+ //origin with INCOMPLETE
+ origin = new byte[] {0x40, 0x01, 0x01, 0x02 };
+ buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute2 = Origin.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+ //AsPath with AS_SEQ with one AS
+ asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xe9 };
+ buffer.writeBytes(asPath);
+ pathAttribute2 = AsPath.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+
+ ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ bgpId = 536936448;
+ locRIBASNum = 200;
+ isIbgp = true;
+ PathAttrNlriDetails attrList2 = new PathAttrNlriDetails();
+ attrList2.setIdentifier(0);
+ attrList2.setPathAttribute(pathAttributes2);
+ attrList2.setProtocolID(ProtocolType.OSPF_V2);
+ PathAttrNlriDetailsLocalRib list2 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList2);
+ BgpSelectionAlgo algo = new BgpSelectionAlgo();
+ int result = algo.compare(list1, list2);
+ assertThat(result, is(1));
+ }
+
+ /**
+ * firstPathAttribute has 1 AS count and secondPathAttribute has 2 AS count
+ * and firstPathAttribute has shortest Origin value than secondPathAttribute.
+ */
+ @Test
+ public void selectionAlgoTest2() throws BgpParseException {
+
+ byte[] peerIp = new byte[] {0x0a, 0x0a, 0x0a, 0x0a };
+ LinkedList<BgpValueType> pathAttributes1 = new LinkedList<>();
+ BgpValueType pathAttribute1;
+ byte[] origin = new byte[] {0x40, 0x01, 0x01, 0x00 };
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute1 = Origin.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+ byte[] asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xe9 };
+ buffer.writeBytes(asPath);
+ pathAttribute1 = AsPath.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+
+ IpAddress ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ int bgpId = 168427777;
+ short locRIBASNum = 100;
+ boolean isIbgp = false;
+ PathAttrNlriDetails attrList1 = new PathAttrNlriDetails();
+ attrList1.setIdentifier(0);
+ attrList1.setPathAttribute(pathAttributes1);
+ attrList1.setProtocolID(ProtocolType.ISIS_LEVEL_ONE);
+ PathAttrNlriDetailsLocalRib list1 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList1);
+
+ peerIp = new byte[] {0x0b, 0x0b, 0x0b, 0x0b };
+ LinkedList<BgpValueType> pathAttributes2 = new LinkedList<>();
+ BgpValueType pathAttribute2;
+ origin = new byte[] {0x40, 0x01, 0x01, 0x02 };
+ buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute2 = Origin.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+ asPath = new byte[] {0x40, 0x02, 0x08, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xea, 0x02, 0x01, (byte) 0xfd, (byte) 0xea };
+ buffer.writeBytes(asPath);
+ pathAttribute2 = AsPath.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+
+ ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ bgpId = 536936448;
+ locRIBASNum = 200;
+ isIbgp = true;
+ PathAttrNlriDetails attrList2 = new PathAttrNlriDetails();
+ attrList2.setIdentifier(0);
+ attrList2.setPathAttribute(pathAttributes2);
+ attrList2.setProtocolID(ProtocolType.OSPF_V2);
+ PathAttrNlriDetailsLocalRib list2 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList2);
+ BgpSelectionAlgo algo = new BgpSelectionAlgo();
+ int result = algo.compare(list1, list2);
+ assertThat(result, is(-1));
+ }
+
+ /**
+ * firstPathAttribute and secondPathAttribute has same AS value
+ * and firstPathAttribute has shortest Origin value than secondPathAttribute.
+ */
+ @Test
+ public void selectionAlgoTest3() throws BgpParseException {
+
+ byte[] peerIp = new byte[] {0x0a, 0x0a, 0x0a, 0x0a };
+ LinkedList<BgpValueType> pathAttributes1 = new LinkedList<>();
+ BgpValueType pathAttribute1;
+ byte[] origin = new byte[] {0x40, 0x01, 0x01, 0x00 };
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute1 = Origin.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+ byte[] asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xe9 };
+ buffer.writeBytes(asPath);
+ pathAttribute1 = AsPath.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+
+ IpAddress ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ int bgpId = 168427777;
+ short locRIBASNum = 100;
+ boolean isIbgp = false;
+ PathAttrNlriDetails attrList1 = new PathAttrNlriDetails();
+ attrList1.setIdentifier(0);
+ attrList1.setPathAttribute(pathAttributes1);
+ attrList1.setProtocolID(ProtocolType.ISIS_LEVEL_ONE);
+ PathAttrNlriDetailsLocalRib list1 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList1);
+
+ peerIp = new byte[] {0x0b, 0x0b, 0x0b, 0x0b };
+ LinkedList<BgpValueType> pathAttributes2 = new LinkedList<>();
+ BgpValueType pathAttribute2;
+ origin = new byte[] {0x40, 0x01, 0x01, 0x02 };
+ buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute2 = Origin.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+ asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xe9 };
+ buffer.writeBytes(asPath);
+ pathAttribute2 = AsPath.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+
+ ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ bgpId = 536936448;
+ locRIBASNum = 200;
+ isIbgp = true;
+ PathAttrNlriDetails attrList2 = new PathAttrNlriDetails();
+ attrList2.setIdentifier(0);
+ attrList2.setPathAttribute(pathAttributes2);
+ attrList2.setProtocolID(ProtocolType.OSPF_V2);
+ PathAttrNlriDetailsLocalRib list2 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList2);
+ BgpSelectionAlgo algo = new BgpSelectionAlgo();
+ int result = algo.compare(list1, list2);
+ assertThat(result, is(1));
+ }
+
+ /**
+ * firstPathAttribute has lowest med than secondPathAttribute.
+ */
+ @Test
+ public void selectionAlgoTest4() throws BgpParseException {
+
+ byte[] peerIp = new byte[] {0x0a, 0x0a, 0x0a, 0x0a };
+ LinkedList<BgpValueType> pathAttributes1 = new LinkedList<>();
+ BgpValueType pathAttribute1;
+ byte[] origin = new byte[] {0x40, 0x01, 0x01, 0x00 };
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute1 = Origin.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+ byte[] med = new byte[] {(byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00,
+ 0x00 };
+ buffer.writeBytes(med);
+ pathAttribute1 = Med.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+ byte[] asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xe9 };
+ buffer.writeBytes(asPath);
+ pathAttribute1 = AsPath.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+
+ IpAddress ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ int bgpId = 168427777;
+ short locRIBASNum = 100;
+ boolean isIbgp = false;
+ PathAttrNlriDetails attrList1 = new PathAttrNlriDetails();
+ attrList1.setIdentifier(0);
+ attrList1.setPathAttribute(pathAttributes1);
+ attrList1.setProtocolID(ProtocolType.ISIS_LEVEL_ONE);
+ PathAttrNlriDetailsLocalRib list1 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList1);
+
+ peerIp = new byte[] {0x0b, 0x0b, 0x0b, 0x0b };
+ LinkedList<BgpValueType> pathAttributes2 = new LinkedList<>();
+ BgpValueType pathAttribute2;
+ origin = new byte[] {0x40, 0x01, 0x01, 0x02 };
+ buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute2 = Origin.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+ med = new byte[] {(byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x01 };
+ buffer.writeBytes(med);
+ pathAttribute2 = Med.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+ asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xe9 };
+ buffer.writeBytes(asPath);
+ pathAttribute2 = AsPath.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+
+ ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ bgpId = 536936448;
+ locRIBASNum = 200;
+ isIbgp = true;
+ PathAttrNlriDetails attrList2 = new PathAttrNlriDetails();
+ attrList2.setIdentifier(0);
+ attrList2.setPathAttribute(pathAttributes2);
+ attrList2.setProtocolID(ProtocolType.OSPF_V2);
+ PathAttrNlriDetailsLocalRib list2 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList2);
+ BgpSelectionAlgo algo = new BgpSelectionAlgo();
+ int result = algo.compare(list1, list2);
+ assertThat(result, is(1));
+ }
+
+ /**
+ * secondPathAttribute has higher local preference than firstPathAttribute.
+ */
+ @Test
+ public void selectionAlgoTest5() throws BgpParseException {
+
+ byte[] peerIp = new byte[] {0x0a, 0x0a, 0x0a, 0x0a };
+ LinkedList<BgpValueType> pathAttributes1 = new LinkedList<>();
+ BgpValueType pathAttribute1;
+ byte[] locPref = new byte[] {(byte) 0x00, 0x05, 0x04, 0x00, 0x00,
+ 0x00, 0x01 };
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(locPref);
+ pathAttribute1 = LocalPref.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+
+ IpAddress ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ int bgpId = 168427777;
+ short locRIBASNum = 100;
+ boolean isIbgp = false;
+ PathAttrNlriDetails attrList1 = new PathAttrNlriDetails();
+ attrList1.setIdentifier(0);
+ attrList1.setPathAttribute(pathAttributes1);
+ attrList1.setProtocolID(ProtocolType.ISIS_LEVEL_ONE);
+ PathAttrNlriDetailsLocalRib list1 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList1);
+
+ peerIp = new byte[] {0x0b, 0x0b, 0x0b, 0x0b };
+ LinkedList<BgpValueType> pathAttributes2 = new LinkedList<>();
+ BgpValueType pathAttribute2;
+ locPref = new byte[] {(byte) 0x00, 0x05, 0x04, 0x00, 0x00, 0x00, 0x0a };
+ buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(locPref);
+ pathAttribute2 = LocalPref.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+
+ ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ bgpId = 536936448;
+ locRIBASNum = 200;
+ isIbgp = true;
+ PathAttrNlriDetails attrList2 = new PathAttrNlriDetails();
+ attrList2.setIdentifier(0);
+ attrList2.setPathAttribute(pathAttributes2);
+ attrList2.setProtocolID(ProtocolType.OSPF_V2);
+ PathAttrNlriDetailsLocalRib list2 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList2);
+ BgpSelectionAlgo algo = new BgpSelectionAlgo();
+ int result = algo.compare(list1, list2);
+ assertThat(result, is(-1));
+ }
+
+ /**
+ * secondPathAttribute is EBGP than firstPathAttribute is IBGP.
+ */
+ @Test
+ public void selectionAlgoTest6() throws BgpParseException {
+
+ byte[] peerIp = new byte[] {0x0a, 0x0a, 0x0a, 0x0a };
+ LinkedList<BgpValueType> pathAttributes1 = new LinkedList<>();
+ BgpValueType pathAttribute1;
+ byte[] origin = new byte[] {0x40, 0x01, 0x01, 0x00 };
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute1 = Origin.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+ byte[] asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xe9 };
+ buffer.writeBytes(asPath);
+ pathAttribute1 = AsPath.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+
+ IpAddress ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ int bgpId = 168427777;
+ short locRIBASNum = 100;
+ boolean isIbgp = true;
+ PathAttrNlriDetails attrList1 = new PathAttrNlriDetails();
+ attrList1.setIdentifier(0);
+ attrList1.setPathAttribute(pathAttributes1);
+ attrList1.setProtocolID(ProtocolType.ISIS_LEVEL_ONE);
+ PathAttrNlriDetailsLocalRib list1 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList1);
+
+ peerIp = new byte[] {0x0b, 0x0b, 0x0b, 0x0b };
+ LinkedList<BgpValueType> pathAttributes2 = new LinkedList<>();
+ BgpValueType pathAttribute2;
+ origin = new byte[] {0x40, 0x01, 0x01, 0x00 };
+ buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute2 = Origin.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+ asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xe9 };
+ buffer.writeBytes(asPath);
+ pathAttribute2 = AsPath.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+
+ ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ bgpId = 536936448;
+ locRIBASNum = 200;
+ isIbgp = false;
+ PathAttrNlriDetails attrList2 = new PathAttrNlriDetails();
+ attrList2.setIdentifier(0);
+ attrList2.setPathAttribute(pathAttributes2);
+ attrList2.setProtocolID(ProtocolType.OSPF_V2);
+ PathAttrNlriDetailsLocalRib list2 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, false, attrList2);
+ BgpSelectionAlgo algo = new BgpSelectionAlgo();
+ int result = algo.compare(list1, list2);
+ assertThat(result, is(-1));
+ }
+
+ /**
+ * firstPathAttribute has lower BGPID than secondPathAttribute.
+ */
+ @Test
+ public void selectionAlgoTest7() throws BgpParseException {
+
+ byte[] peerIp = new byte[] {0x0a, 0x0a, 0x0a, 0x0a };
+ LinkedList<BgpValueType> pathAttributes1 = new LinkedList<>();
+ BgpValueType pathAttribute1;
+ byte[] origin = new byte[] {0x40, 0x01, 0x01, 0x00 };
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute1 = Origin.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+ byte[] asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xe9 };
+ buffer.writeBytes(asPath);
+ pathAttribute1 = AsPath.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+
+ IpAddress ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ //A0A0A00
+ Integer bgpId = 168430080;
+ short locRIBASNum = 100;
+ boolean isIbgp = false;
+ PathAttrNlriDetails attrList1 = new PathAttrNlriDetails();
+ attrList1.setIdentifier(0);
+ attrList1.setPathAttribute(pathAttributes1);
+ attrList1.setProtocolID(ProtocolType.ISIS_LEVEL_ONE);
+ PathAttrNlriDetailsLocalRib list1 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList1);
+
+ peerIp = new byte[] {0x0b, 0x0b, 0x0b, 0x0b };
+ LinkedList<BgpValueType> pathAttributes2 = new LinkedList<>();
+ BgpValueType pathAttribute2;
+ origin = new byte[] {0x40, 0x01, 0x01, 0x00 };
+ buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute2 = Origin.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+ asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xe9 };
+ buffer.writeBytes(asPath);
+ pathAttribute2 = AsPath.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+
+ ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ //B0A0A00
+ bgpId = 185207296;
+ locRIBASNum = 200;
+ isIbgp = false;
+ PathAttrNlriDetails attrList2 = new PathAttrNlriDetails();
+ attrList2.setIdentifier(0);
+ attrList2.setPathAttribute(pathAttributes2);
+ attrList2.setProtocolID(ProtocolType.OSPF_V2);
+ PathAttrNlriDetailsLocalRib list2 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList2);
+ BgpSelectionAlgo algo = new BgpSelectionAlgo();
+ int result = algo.compare(list1, list2);
+ assertThat(result, is(1));
+ }
+
+ /**
+ * secondPathAttribute has lowest peer address than firstPathAttribute.
+ */
+ @Test
+ public void selectionAlgoTest8() throws BgpParseException {
+
+ byte[] peerIp = new byte[] {0x0b, 0x0b, 0x0b, 0x0b };
+ LinkedList<BgpValueType> pathAttributes1 = new LinkedList<>();
+ BgpValueType pathAttribute1;
+ byte[] origin = new byte[] {0x40, 0x01, 0x01, 0x00 };
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute1 = Origin.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+ byte[] asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xe9 };
+ buffer.writeBytes(asPath);
+ pathAttribute1 = AsPath.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+
+ IpAddress ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ //A0A0A00
+ Integer bgpId = 168430080;
+ short locRIBASNum = 100;
+ boolean isIbgp = false;
+ PathAttrNlriDetails attrList1 = new PathAttrNlriDetails();
+ attrList1.setIdentifier(0);
+ attrList1.setPathAttribute(pathAttributes1);
+ attrList1.setProtocolID(ProtocolType.ISIS_LEVEL_ONE);
+ PathAttrNlriDetailsLocalRib list1 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList1);
+
+ peerIp = new byte[] {0x0a, 0x0a, 0x0a, 0x0a };
+ LinkedList<BgpValueType> pathAttributes2 = new LinkedList<>();
+ BgpValueType pathAttribute2;
+ origin = new byte[] {0x40, 0x01, 0x01, 0x00 };
+ buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute2 = Origin.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+ asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xe9 };
+ buffer.writeBytes(asPath);
+ pathAttribute2 = AsPath.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+
+ ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ //A0A0A00
+ bgpId = 168430080;
+ locRIBASNum = 200;
+ isIbgp = false;
+ PathAttrNlriDetails attrList2 = new PathAttrNlriDetails();
+ attrList2.setIdentifier(0);
+ attrList2.setPathAttribute(pathAttributes2);
+ attrList2.setProtocolID(ProtocolType.OSPF_V2);
+ PathAttrNlriDetailsLocalRib list2 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList2);
+ BgpSelectionAlgo algo = new BgpSelectionAlgo();
+ int result = algo.compare(list1, list2);
+ assertThat(result, is(-1));
+ }
+
+ /**
+ * firstPathAttribute and secondPathAttribute are same.
+ */
+ @Test
+ public void selectionAlgoTest9() throws BgpParseException {
+
+ byte[] peerIp = new byte[] {0x0a, 0x0a, 0x0a, 0x0a };
+ LinkedList<BgpValueType> pathAttributes1 = new LinkedList<>();
+ BgpValueType pathAttribute1;
+ byte[] origin = new byte[] {0x40, 0x01, 0x01, 0x00 };
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute1 = Origin.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+ byte[] asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xe9 };
+ buffer.writeBytes(asPath);
+ pathAttribute1 = AsPath.read(buffer);
+ pathAttributes1.add(pathAttribute1);
+
+ IpAddress ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ //A0A0A00
+ Integer bgpId = 168430080;
+ short locRIBASNum = 100;
+ boolean isIbgp = false;
+ PathAttrNlriDetails attrList1 = new PathAttrNlriDetails();
+ attrList1.setIdentifier(0);
+ attrList1.setPathAttribute(pathAttributes1);
+ attrList1.setProtocolID(ProtocolType.ISIS_LEVEL_ONE);
+ PathAttrNlriDetailsLocalRib list1 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList1);
+
+ peerIp = new byte[] {0x0a, 0x0a, 0x0a, 0x0a };
+ LinkedList<BgpValueType> pathAttributes2 = new LinkedList<>();
+ BgpValueType pathAttribute2;
+ origin = new byte[] {0x40, 0x01, 0x01, 0x00 };
+ buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(origin);
+ pathAttribute2 = Origin.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+ asPath = new byte[] {0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd,
+ (byte) 0xe9 };
+ buffer.writeBytes(asPath);
+ pathAttribute2 = AsPath.read(buffer);
+ pathAttributes2.add(pathAttribute2);
+
+ ipAddress = IpAddress.valueOf(Version.INET, peerIp);
+ //A0A0A00
+ bgpId = 168430080;
+ locRIBASNum = 200;
+ isIbgp = false;
+ PathAttrNlriDetails attrList2 = new PathAttrNlriDetails();
+ attrList2.setIdentifier(0);
+ attrList2.setPathAttribute(pathAttributes2);
+ attrList2.setProtocolID(ProtocolType.OSPF_V2);
+ PathAttrNlriDetailsLocalRib list2 = new PathAttrNlriDetailsLocalRib(
+ ipAddress, bgpId, locRIBASNum, isIbgp, attrList2);
+ BgpSelectionAlgo algo = new BgpSelectionAlgo();
+ int result = algo.compare(list1, list2);
+ assertThat(result, is(0));
+ }
+}