VOL-3818: Initial version of OLT Topology discovery app; used to find active links between OLT NNI and Leaf switch ports.
Change-Id: I058b603d028446e8176821d85a25af8963e28924
diff --git a/app/src/test/java/org/opencord/olttopology/impl/OltTopologyTest.java b/app/src/test/java/org/opencord/olttopology/impl/OltTopologyTest.java
new file mode 100644
index 0000000..27eeec7
--- /dev/null
+++ b/app/src/test/java/org/opencord/olttopology/impl/OltTopologyTest.java
@@ -0,0 +1,706 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * 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.opencord.olttopology.impl;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import org.apache.commons.lang.ArrayUtils;
+import org.easymock.EasyMock;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.osgi.ComponentContextAdapter;
+import org.onlab.packet.ChassisId;
+import org.onlab.packet.Ethernet;
+import org.onlab.packet.Ip4Address;
+import org.onlab.packet.LLDP;
+import org.onlab.packet.LLDPTLV;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.VlanId;
+import org.onosproject.cfg.ComponentConfigService;
+import org.onosproject.codec.CodecService;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreServiceAdapter;
+import org.onosproject.mastership.MastershipServiceAdapter;
+import org.onosproject.net.AnnotationKeys;
+import org.onosproject.net.Annotations;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.DefaultAnnotations;
+import org.onosproject.net.DefaultDevice;
+import org.onosproject.net.Device;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Element;
+import org.onosproject.net.Port;
+import org.onosproject.net.PortNumber;
+import org.onosproject.net.config.NetworkConfigListener;
+import org.onosproject.net.device.DeviceEvent;
+import org.onosproject.net.device.DeviceListener;
+import org.onosproject.net.device.DeviceServiceAdapter;
+import org.onosproject.net.provider.ProviderId;
+import org.onosproject.store.service.TestStorageService;
+import org.opencord.sadis.BaseInformationService;
+import org.opencord.sadis.SadisService;
+import org.opencord.sadis.SubscriberAndDeviceInformation;
+import org.opencord.sadis.UniTagInformation;
+import org.slf4j.Logger;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.onosproject.net.intent.TestTools.assertAfter;
+import static org.opencord.olttopology.impl.OltTopology.SYSTEMNAME_TLV_TYPE;
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Tests OLT topology app.
+ */
+public class OltTopologyTest extends OltTopologyTestBase {
+ private static final VlanId CLIENT_C_TAG = VlanId.vlanId((short) 999);
+ private static final VlanId CLIENT_S_TAG = VlanId.vlanId((short) 111);
+ private static final String CLIENT_NAS_PORT_ID = "PON 1/1";
+ private static final String CLIENT_CIRCUIT_ID = "CIR-PON 1/1";
+ private static final String OLT_DEV_ID = "of:0000c6b1cd40dc93";
+ private static final MacAddress OLT_MAC_ADDRESS = MacAddress.valueOf("01:02:03:04:05:06");
+ private static final DeviceId DEVICE_ID_1 = DeviceId.deviceId(OLT_DEV_ID);
+ private static final String SCHEME_NAME = "olttopology";
+ private static final DefaultAnnotations DEVICE_ANNOTATIONS = DefaultAnnotations.builder()
+ .set(AnnotationKeys.PROTOCOL, SCHEME_NAME.toUpperCase()).build();
+ private final Logger log = getLogger(getClass());
+ ComponentConfigService mockConfigService =
+ EasyMock.createMock(ComponentConfigService.class);
+ CodecService mockCodecService =
+ EasyMock.createMock(CodecService.class);
+ private OltTopology oltTopology;
+ private NetworkConfigListener configListener;
+ private DeviceListener deviceListener;
+
+ @Before
+ public void setUp() {
+ oltTopology = new OltTopology();
+ oltTopology.mastershipService = new MockMastershipService();
+ oltTopology.deviceService = new MockDeviceService();
+ oltTopology.coreService = new MockCoreService();
+ oltTopology.componentConfigService = mockConfigService;
+ oltTopology.packetService = new MockPacketService();
+ oltTopology.flowObjectiveService = new MockFlowObjectiveService();
+ oltTopology.storageService = new TestStorageService();
+ oltTopology.codecService = mockCodecService;
+ oltTopology.subsService = new MockSubService();
+ oltTopology.sadisService = new MockSadisService();
+ oltTopology.subsService.get(OLT_DEV_ID).setUplinkPort(1);
+ oltTopology.activate(new ComponentContextAdapter());
+ }
+
+ @After
+ public void tearDown() {
+ oltTopology.deactivate();
+
+ }
+
+ private DeviceEvent deviceEvent(DeviceEvent.Type type, DeviceId did, Port port) {
+ return new DeviceEvent(type, oltTopology.deviceService.getDevice(did), port);
+
+ }
+
+ /**
+ * Fetches the sent packet at the given index. The requested packet
+ * must be the last packet on the list.
+ *
+ * @param index index into sent packets array
+ * @return packet
+ */
+ private Ethernet fetchPacket(int index) {
+ for (int iteration = 0; iteration < 20; iteration++) {
+ if (savedPackets.size() > index) {
+ return (Ethernet) savedPackets.get(index);
+ } else {
+ try {
+ Thread.sleep(250);
+ } catch (Exception ex) {
+ return null;
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Testing Port Added Scenario.
+ * Note: Need to See second packet as first will be sent when MockPort is called
+ *
+ */
+ @Test
+ public void testPortAdded() {
+ Device d = oltTopology.deviceService.getDevice(DEVICE_ID_1);
+ Port port = new MockPort();
+ DeviceEvent portAdd = deviceEvent(DeviceEvent.Type.PORT_ADDED, DEVICE_ID_1, port);
+ deviceListener.event(portAdd);
+ Ethernet responsePacket = fetchPacket(1);
+ assertThat(responsePacket, notNullValue());
+ checkLldpPacket(responsePacket);
+ }
+
+ /**
+ * Testing Port Delete Scenario.
+ *
+ */
+ @Test
+ public void testPortDeleted() {
+ Device d = oltTopology.deviceService.getDevice(DEVICE_ID_1);
+ Port port = new MockPort();
+ DeviceEvent portAdd = deviceEvent(DeviceEvent.Type.PORT_ADDED, DEVICE_ID_1, port);
+ deviceListener.event(portAdd);
+ Ethernet responsePacket = fetchPacket(1);
+ assertThat(responsePacket, notNullValue());
+ checkLldpPacket(responsePacket);
+ DeviceEvent portRem = deviceEvent(DeviceEvent.Type.PORT_REMOVED, DEVICE_ID_1, port);
+ deviceListener.event(portRem);
+ }
+
+ /**
+ * Tests LLDP packet in scenario.
+ *
+ */
+ @Test
+ public void testHandlePacket() {
+ Device d = oltTopology.deviceService.getDevice(DEVICE_ID_1);
+ Port port = new MockPort();
+ DeviceEvent portAdd = deviceEvent(DeviceEvent.Type.PORT_ADDED, DEVICE_ID_1, port);
+ deviceListener.event(portAdd);
+ MacAddress destMac = MacAddress.valueOf(OsgiPropertyConstants.DEFAULT_DEST_MAC_ADDRESS_DEFAULT);
+ MacAddress srcMac = MacAddress.valueOf("c6:b1:cd:40:dc:93");
+ String serialNumber = "switch-1";
+ final short ttlInSec = 120;
+ final short chasisId = 0;
+ String portName = "p0";
+ Ip4Address devIpAddr = Ip4Address.valueOf("192.168.1.1");
+ Ethernet packet = createLldpPacket(destMac, srcMac, chasisId, portName,
+ ttlInSec, serialNumber, devIpAddr.toString());
+
+ ConnectPoint cp = new ConnectPoint(d.id(), port.number());
+ sendInboundPacket(packet, cp);
+
+ assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+ validateNeighborList(oltTopology.getNeighbours());
+ });
+ }
+
+ /**
+ * Tests Packet out timer functionality.
+ *
+ * @throws Exception
+ */
+ @Test
+ public void testOltTopologyTimerTask() throws Exception {
+ Device d = oltTopology.deviceService.getDevice(DEVICE_ID_1);
+ Port port = new MockPort();
+ DeviceEvent portAdd = deviceEvent(DeviceEvent.Type.PORT_ADDED, DEVICE_ID_1, port);
+ deviceListener.event(portAdd);
+ oltTopology.lldpPeriodicity(2);
+ Thread.sleep(2000);
+ Ethernet responsePacket = fetchPacket(1);
+ assertThat(responsePacket, notNullValue());
+ checkLldpPacket(responsePacket);
+ }
+
+ /**
+ * Testing Device Delete Scenario with Packet Out.
+ *
+ */
+ @Test
+ public void testDeviceDeleted() {
+ log.info("oltTopology {}", oltTopology);
+ Device d = oltTopology.deviceService.getDevice(DEVICE_ID_1);
+ Port port = new MockPort();
+ DeviceEvent portAdd = deviceEvent(DeviceEvent.Type.PORT_ADDED, DEVICE_ID_1, port);
+ deviceListener.event(portAdd);
+ Ethernet responsePacket = fetchPacket(1);
+ assertThat(responsePacket, notNullValue());
+ checkLldpPacket(responsePacket);
+ DeviceEvent portRem = deviceEvent(DeviceEvent.Type.DEVICE_REMOVED, DEVICE_ID_1, port);
+ deviceListener.event(portRem);
+ }
+
+ /**
+ * Testing Port Delete Scenario After Packet Handle for Packet in.
+ *
+ */
+ @Test
+ public void testPortDelAfterHandlePacket() {
+ Device d = oltTopology.deviceService.getDevice(DEVICE_ID_1);
+ Port port = new MockPort();
+ DeviceEvent portAdd = deviceEvent(DeviceEvent.Type.PORT_ADDED, DEVICE_ID_1, port);
+ deviceListener.event(portAdd);
+ MacAddress destMac = MacAddress.valueOf(OsgiPropertyConstants.DEFAULT_DEST_MAC_ADDRESS_DEFAULT);
+ MacAddress srcMac = MacAddress.valueOf("c6:b1:cd:40:dc:93");
+ String serialNumber = "switch-1";
+ final short ttlInSec = 120;
+ final short chasisId = 0;
+ String portName = "p0";
+ Ip4Address devIpAddr = Ip4Address.valueOf("192.168.1.1");
+ Ethernet packet = createLldpPacket(destMac, srcMac, chasisId, portName,
+ ttlInSec, serialNumber, devIpAddr.toString());
+
+ ConnectPoint cp = new ConnectPoint(d.id(), port.number());
+ sendInboundPacket(packet, cp);
+ // Need to have a delay before the validation as the packet processing now happens in a different thread
+ assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+ validateNeighborList(oltTopology.getNeighbours());
+ });
+ DeviceEvent portRem = deviceEvent(DeviceEvent.Type.PORT_REMOVED, DEVICE_ID_1, port);
+ deviceListener.event(portRem);
+ assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+ assertThat(oltTopology.getNeighbours().size(), is(0));
+ });
+ }
+
+ /**
+ * Testing Device Delete Scenario After Packet Handle for Packet in.
+ *
+ */
+ @Test
+ public void testDeviceDelAfterHandlePacket() {
+ Device d = oltTopology.deviceService.getDevice(DEVICE_ID_1);
+ Port port = new MockPort();
+ DeviceEvent portAdd = deviceEvent(DeviceEvent.Type.PORT_ADDED, DEVICE_ID_1, port);
+ deviceListener.event(portAdd);
+ MacAddress destMac = MacAddress.valueOf(OsgiPropertyConstants.DEFAULT_DEST_MAC_ADDRESS_DEFAULT);
+ MacAddress srcMac = MacAddress.valueOf("c6:b1:cd:40:dc:93");
+ String serialNumber = "switch-1";
+ final short ttlInSec = 120;
+ final short chasisId = 0;
+ String portName = "p0";
+ Ip4Address devIpAddr = Ip4Address.valueOf("192.168.1.1");
+ Ethernet packet = createLldpPacket(destMac, srcMac, chasisId, portName,
+ ttlInSec, serialNumber, devIpAddr.toString());
+
+ ConnectPoint cp = new ConnectPoint(d.id(), port.number());
+ sendInboundPacket(packet, cp);
+ assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+ validateNeighborList(oltTopology.getNeighbours());
+ assertThat(oltTopology.getNeighbours().size(), is(1));
+ });
+ DeviceEvent portRem = deviceEvent(DeviceEvent.Type.DEVICE_REMOVED, DEVICE_ID_1, port);
+ deviceListener.event(portRem);
+ assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+ assertThat(oltTopology.getNeighbours().size(), is(0));
+ });
+ }
+
+ /**
+ * Creates dummy packet for LLDP packet to test Packet in scenario.
+ *
+ * @param destMac Destination Mac address of LLDP packet
+ * @param srcMac Source mac address of LLDP packet
+ * @param chassisId Chassis ID tlv value
+ * @param port port Id tlv value
+ * @param ttl TTL tlv value
+ * @param systemName System name tlv value
+ * @param mgmtAddr Management Address tlv value
+ * @return LLDP ethernet packet
+ */
+ private Ethernet createLldpPacket(MacAddress destMac, MacAddress srcMac,
+ int chassisId, String port, short ttl,
+ String systemName, String mgmtAddr) {
+ Ethernet ethPkt = new Ethernet();
+ ethPkt.setEtherType(Ethernet.TYPE_LLDP);
+ ethPkt.setDestinationMACAddress(destMac);
+ ethPkt.setSourceMACAddress(srcMac);
+
+ LLDP lldpPkt = new LLDP();
+
+ setChassisId(lldpPkt, chassisId);
+ setPortId(lldpPkt, port);
+ setTtl(lldpPkt, ttl);
+
+ List<LLDPTLV> optionalTlv = new ArrayList<>();
+ optionalTlv.add(createSystemNameTlv(systemName));
+ optionalTlv.add(createMgmtAddressTlv(mgmtAddr));
+
+ lldpPkt.setOptionalTLVList(optionalTlv);
+
+ ethPkt.setPayload(lldpPkt);
+ return ethPkt;
+ }
+
+ /**
+ * Sets Chassis ID TLV for LLDP packet.
+ *
+ * @param lldpPkt LLDP packet reference
+ * @param chassisId Chassid ID tlv value
+ */
+ private void setChassisId(LLDP lldpPkt, final int chassisId) {
+ final byte chassisTlvSubtype = 1;
+
+ byte[] chassis = ArrayUtils.addAll(new byte[]{chassisTlvSubtype},
+ ByteBuffer.allocate(String.valueOf(chassisId).length())
+ .put(String.valueOf(chassisId).getBytes()).array());
+
+ LLDPTLV chassisTlv = new LLDPTLV();
+ lldpPkt.setChassisId(chassisTlv.setLength((byte) chassis.length)
+ .setType(LLDP.CHASSIS_TLV_TYPE)
+ .setValue(chassis));
+ }
+
+ /**
+ * Sets Port ID tlv for LLDP packet.
+ *
+ * @param lldpPkt LLDP packet reference
+ * @param ifaceName Port Name TLV value
+ */
+ public void setPortId(LLDP lldpPkt, final String ifaceName) {
+ final byte portTlvSubtype = 5;
+
+ byte[] port = ArrayUtils.addAll(new byte[]{portTlvSubtype},
+ ifaceName.getBytes());
+
+ LLDPTLV portTlv = new LLDPTLV();
+ lldpPkt.setPortId(portTlv.setLength((byte) port.length)
+ .setType(LLDP.PORT_TLV_TYPE)
+ .setValue(port));
+ }
+
+ /**
+ * Sets TTL tlv for LLDP packet.
+ *
+ * @param lldpPkt LLDP Packet reference
+ * @param timeInSecs TTL tlv value in sec
+ */
+ public void setTtl(LLDP lldpPkt, final short timeInSecs) {
+ byte[] time = ByteBuffer.allocate(2).putShort(timeInSecs).array();
+ LLDPTLV ttlTlv = new LLDPTLV();
+ lldpPkt.setTtl(ttlTlv.setType(LLDP.TTL_TLV_TYPE)
+ .setLength((short) time.length)
+ .setValue(time));
+ }
+
+ /**
+ * Sets System name tlv for LLDP packet.
+ *
+ * @param systemName System name tlv value
+ * @return systemName tlv
+ */
+ public LLDPTLV createSystemNameTlv(String systemName) {
+ byte[] bytes = systemName.getBytes();
+ LLDPTLV sysNameTlv = new LLDPTLV();
+ return sysNameTlv.setType(SYSTEMNAME_TLV_TYPE)
+ .setLength((byte) bytes.length)
+ .setValue(bytes);
+ }
+
+ /**
+ * Sets Management address tlv for LLDP packet.
+ *
+ * @param mgmtAddress Management address tlv value
+ * @return Management address tlv
+ */
+ public LLDPTLV createMgmtAddressTlv(String mgmtAddress) {
+ final byte mgmtAddressTlvType = 0x8;
+ final byte ipAddressSubType = 0x1; // IPv4
+ // 5 below is address subtype + IP4 address len
+ final byte ipAddrStrLen = 0x5;
+ final byte interfaceSubtype = 0x1;
+ final int interfaceNum = 0;
+ final byte oidString = 0x0;
+ Ip4Address ipAddr = Ip4Address.valueOf(mgmtAddress);
+
+ byte[] addrStr = ArrayUtils.addAll(new byte[]{ipAddressSubType},
+ ipAddr.toOctets());
+
+ byte[] ipAddrBytes = ArrayUtils.addAll(new byte[]{ipAddrStrLen},
+ addrStr);
+ byte[] bytesInterfacetype = ArrayUtils.addAll(ipAddrBytes,
+ ByteBuffer.allocate(1).put(interfaceSubtype).array());
+ byte[] bytesInterfaceNumber = ArrayUtils.addAll(bytesInterfacetype,
+ ByteBuffer.allocate(4).putInt(interfaceNum).array());
+ byte[] finalMgmtAddrBytes = ArrayUtils.addAll(bytesInterfaceNumber,
+ ByteBuffer.allocate(1).put(oidString).array());
+
+ LLDPTLV mgmtAddrTlv = new LLDPTLV();
+ return mgmtAddrTlv.setType(mgmtAddressTlvType)
+ .setLength((byte) finalMgmtAddrBytes.length)
+ .setValue(finalMgmtAddrBytes);
+ }
+
+ /*
+ Mocks application id.
+ */
+ private static final class MockApplicationId implements ApplicationId {
+
+ private final short id;
+ private final String name;
+
+ public MockApplicationId(short id, String name) {
+ this.id = id;
+ this.name = name;
+ }
+
+ @Override
+ public short id() {
+ return id;
+ }
+
+ @Override
+ public String name() {
+ return name;
+ }
+ }
+
+ /*
+ Mocks Core service adapter.
+ */
+ private static final class MockCoreService extends CoreServiceAdapter {
+
+ private List<ApplicationId> idList = new ArrayList<>();
+ private Map<String, ApplicationId> idMap = new HashMap<>();
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.onosproject.core.CoreServiceAdapter#getAppId(java.lang.Short)
+ */
+ @Override
+ public ApplicationId getAppId(Short id) {
+ if (id >= idList.size()) {
+ return null;
+ }
+ return idList.get(id);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.onosproject.core.CoreServiceAdapter#getAppId(java.lang.String)
+ */
+ @Override
+ public ApplicationId getAppId(String name) {
+ return idMap.get(name);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.onosproject.core.CoreServiceAdapter#registerApplication(java.lang
+ * .String)
+ */
+ @Override
+ public ApplicationId registerApplication(String name) {
+ ApplicationId appId = idMap.get(name);
+ if (appId == null) {
+ appId = new MockApplicationId((short) idList.size(), name);
+ idList.add(appId);
+ idMap.put(name, appId);
+ }
+ return appId;
+ }
+
+ }
+
+ private static class MockMastershipService extends MastershipServiceAdapter {
+ @Override
+ public boolean isLocalMaster(DeviceId d) {
+ return true;
+ }
+ }
+
+ private static class MockDevice extends DefaultDevice {
+
+ /*
+ Mocks OLT device.
+ */
+ public MockDevice(ProviderId providerId, DeviceId id, Type type,
+ String manufacturer, String hwVersion, String swVersion,
+ String serialNumber, ChassisId chassisId, Annotations... annotations) {
+ super(providerId, id, type, manufacturer, hwVersion, swVersion, serialNumber,
+ chassisId, annotations);
+ }
+ }
+
+ private static class MockSadisService implements SadisService {
+
+ @Override
+ public MockSubService getSubscriberInfoService() {
+ return new MockSubService();
+ }
+
+ @Override
+ public MockSubService getBandwidthProfileService() {
+ return new MockSubService();
+ }
+
+ }
+
+ /*
+ Mocks SubscriberAndDeviceInformationService(SADIS) information.
+ */
+ private static class MockSubService implements BaseInformationService {
+ MockSubscriberAndDeviceInformation device =
+ new MockSubscriberAndDeviceInformation(OLT_DEV_ID, VlanId.NONE, VlanId.NONE, null, null,
+ OLT_MAC_ADDRESS, Ip4Address.valueOf("10.10.10.10"));
+ MockSubscriberAndDeviceInformation sub =
+ new MockSubscriberAndDeviceInformation(CLIENT_NAS_PORT_ID, CLIENT_C_TAG,
+ CLIENT_S_TAG, CLIENT_NAS_PORT_ID, CLIENT_CIRCUIT_ID, null, null);
+
+ @Override
+ public SubscriberAndDeviceInformation get(String id) {
+ if (id.equals(OLT_DEV_ID)) {
+ return device;
+ } else {
+ return sub;
+ }
+ }
+
+ @Override
+ public void invalidateAll() {
+ }
+
+ public void invalidateId(String id) {
+ }
+
+ public SubscriberAndDeviceInformation getfromCache(String id) {
+ return null;
+ }
+ }
+
+ /*
+ Mocks SubscriberAndDeviceInformation.
+ */
+ private static class MockSubscriberAndDeviceInformation extends SubscriberAndDeviceInformation {
+
+ MockSubscriberAndDeviceInformation(String id, VlanId ctag,
+ VlanId stag, String nasPortId,
+ String circuitId, MacAddress hardId,
+ Ip4Address ipAddress) {
+ UniTagInformation uniTagInformation = new UniTagInformation.Builder()
+ .setPonCTag(ctag)
+ .setPonSTag(stag)
+ .build();
+ List<UniTagInformation> uniTagInformationList = Lists.newArrayList(uniTagInformation);
+ this.setUniTagList(uniTagInformationList);
+ // this.setCTag(ctag);
+ this.setHardwareIdentifier(hardId);
+ this.setId(id);
+ this.setIPAddress(ipAddress);
+// this.setSTag(stag);
+ this.setNasPortId(nasPortId);
+ this.setCircuitId(circuitId);
+ }
+ }
+
+ private static class MockPort implements Port {
+
+ @Override
+ public boolean isEnabled() {
+ return true;
+ }
+
+ public long portSpeed() {
+ return 1000;
+ }
+
+ public Element element() {
+ return null;
+ }
+
+ public PortNumber number() {
+ return PortNumber.portNumber(1);
+ }
+
+ public Annotations annotations() {
+ return new MockAnnotations();
+ }
+
+ public Type type() {
+ return Port.Type.FIBER;
+ }
+
+ private static class MockAnnotations implements Annotations {
+
+ @Override
+ public String value(String val) {
+ return "nni-";
+ }
+
+ public Set<String> keys() {
+ return Sets.newHashSet("portName");
+ }
+ }
+ }
+
+ /*
+ Mocks Device Service Adapter.
+ */
+ private class MockDeviceService extends DeviceServiceAdapter {
+
+ private ProviderId providerId = new ProviderId("of", "foo");
+ private final Device device1 = new MockDevice(providerId, DEVICE_ID_1, Device.Type.SWITCH,
+ "foo.inc", "0", "0", OLT_DEV_ID, new ChassisId(),
+ DEVICE_ANNOTATIONS);
+
+ @Override
+ public Device getDevice(DeviceId devId) {
+ return device1;
+
+ }
+
+ @Override
+ public Iterable<Device> getDevices() {
+ List<Device> devices = new ArrayList<>();
+ devices.add(device1);
+ return devices;
+ }
+
+ @Override
+ public Port getPort(ConnectPoint cp) {
+ return new MockPort();
+ }
+
+ @Override
+ public Port getPort(DeviceId deviceId, PortNumber portNumber) {
+ return new MockPort();
+ }
+
+ @Override
+ public List<Port> getPorts(DeviceId deviceId) {
+ return Lists.newArrayList(new MockPort());
+ }
+
+ @Override
+ public boolean isAvailable(DeviceId d) {
+ return true;
+ }
+
+ @Override
+ public void addListener(DeviceListener listener) {
+ deviceListener = listener;
+ }
+
+ @Override
+ public void removeListener(DeviceListener listener) {
+
+ }
+ }
+}
diff --git a/app/src/test/java/org/opencord/olttopology/impl/OltTopologyTestBase.java b/app/src/test/java/org/opencord/olttopology/impl/OltTopologyTestBase.java
new file mode 100644
index 0000000..6dbfc5c
--- /dev/null
+++ b/app/src/test/java/org/opencord/olttopology/impl/OltTopologyTestBase.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * 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.opencord.olttopology.impl;
+
+import org.apache.commons.lang.ArrayUtils;
+import org.onlab.packet.BasePacket;
+import org.onlab.packet.Ethernet;
+import org.onlab.packet.EthType;
+import org.onlab.packet.Ip4Address;
+import org.onlab.packet.LLDP;
+import org.onlab.packet.LLDPTLV;
+import org.onlab.packet.MacAddress;
+
+
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.flow.criteria.Criterion;
+import org.onosproject.net.flow.criteria.EthTypeCriterion;
+import org.onosproject.net.flowobjective.FilteringObjective;
+import org.onosproject.net.flowobjective.FlowObjectiveServiceAdapter;
+import org.onosproject.net.packet.DefaultInboundPacket;
+import org.onosproject.net.packet.InboundPacket;
+import org.onosproject.net.packet.OutboundPacket;
+import org.onosproject.net.packet.DefaultPacketContext;
+import org.onosproject.net.packet.PacketContext;
+import org.onosproject.net.packet.PacketProcessor;
+import org.onosproject.net.packet.PacketServiceAdapter;
+
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.notNullValue;
+
+import org.opencord.olttopology.OltNeighborInfo;
+import org.slf4j.Logger;
+
+import static org.junit.Assert.assertThat;
+
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.fail;
+
+
+import static org.slf4j.LoggerFactory.getLogger;
+
+/*
+Olt topology test base class.
+ */
+public class OltTopologyTestBase {
+ private final Logger log = getLogger(getClass());
+
+ //Time in ms to wait before checking packets
+ static final int ASSERTION_DELAY = 250;
+ //Duration in ms of the assertion for packets
+ static final int ASSERTION_LENGTH = 250;
+
+ private static final String EXPECTED_IP = "10.10.10.10";
+ private static final String EXPECTED_OLT_DEV_ID = "of:0000c6b1cd40dc93";
+ private static final DeviceId EXPECTED_DEVICE_ID_1 = DeviceId.deviceId(EXPECTED_OLT_DEV_ID);
+
+
+
+ List<BasePacket> savedPackets = new LinkedList<>();
+ PacketProcessor packetProcessor;
+ MacAddress srcMac = MacAddress.valueOf("c6:b1:cd:40:dc:93");
+ MacAddress dstMac = MacAddress.valueOf(OsgiPropertyConstants.DEFAULT_DEST_MAC_ADDRESS_DEFAULT);
+
+
+ /**
+ * Saves the given packet onto the saved packets list.
+ *
+ * @param packet packet to save
+ */
+ void savePacket(BasePacket packet) {
+ savedPackets.add(packet);
+ }
+
+ /**
+ * Sends packet to Packer process to test Handle packet functionality.
+ * @param packet LLDP ethernet packet
+ * @param cp Device connect point info
+ */
+ void sendInboundPacket(Ethernet packet, ConnectPoint cp) {
+ final ByteBuffer byteBuffer = ByteBuffer.wrap(packet.serialize());
+ InboundPacket inPacket = new DefaultInboundPacket(cp, packet, byteBuffer);
+ PacketContext context = new TestPacketContext(127L, inPacket, null, false);
+ packetProcessor.process(context);
+ }
+
+ /**
+ * Validates LLDP packet out functionality.
+ * @param responsePacket LLDP packet
+ */
+ void checkLldpPacket(Ethernet responsePacket) {
+ assertThat(responsePacket.getSourceMAC(), is(srcMac));
+ assertThat(responsePacket.getDestinationMAC(), is(dstMac));
+ assertThat(responsePacket.getPayload(), instanceOf(LLDP.class));
+ assertThat(responsePacket.getEtherType(), is(Ethernet.TYPE_LLDP));
+ LLDP lldp = (LLDP) responsePacket.getPayload();
+ assertThat(lldp, notNullValue());
+ assertThat(lldp.getPortId(), notNullValue());
+ String portName = "nni-";
+ byte[] port = ArrayUtils.addAll(new byte[] {5}, portName.getBytes());
+ assertThat(lldp.getPortId().getValue(), is(port));
+ assertThat(lldp.getChassisId(), notNullValue());
+ int chassisId = 0;
+ byte[] chassis = ArrayUtils.addAll(new byte[] {1},
+ ByteBuffer.allocate(String.valueOf(chassisId).length())
+ .put(String.valueOf(chassisId).getBytes()).array());
+ assertThat(lldp.getChassisId().getValue(), is(chassis));
+ assertThat(lldp.getTtl().getValue(), notNullValue());
+ short ttl = 120;
+ byte[] time = ByteBuffer.allocate(2).putShort(ttl).array();
+ assertThat(lldp.getTtl().getValue(), is(time));
+ assertThat(lldp.getOptionalTLVList(), notNullValue());
+ List<LLDPTLV> optionalTlvs = lldp.getOptionalTLVList();
+ for (LLDPTLV tlv: optionalTlvs) {
+ if (tlv.getType() == OltTopology.SYSTEMNAME_TLV_TYPE) {
+ assertThat(tlv.getValue(), notNullValue());
+ String[] systemName = EXPECTED_DEVICE_ID_1.toString().split(":", 2);
+ byte[] deviceId = systemName[1].getBytes();
+ assertThat(tlv.getValue(), is(deviceId));
+ } else if (tlv.getType() == OltTopology.MANAGEMENT_ADDR_TLV_TYPE) {
+ assertThat(tlv.getValue(), notNullValue());
+ final byte ipAddressSubType = 0x1; // IPv4
+ // 5 below is address subtype + IP4 address len
+ final byte ipAddrStrLen = 0x5;
+ final byte interfaceSubtype = 0x1;
+ final int interfaceNum = 0;
+ final byte oidString = 0x0;
+ Ip4Address ipAddr = Ip4Address.valueOf(EXPECTED_IP);
+
+ byte[] addrStr = ArrayUtils.addAll(new byte[] {ipAddressSubType},
+ ipAddr.toOctets());
+
+ byte[] ipAddrBytes = ArrayUtils.addAll(new byte[] {ipAddrStrLen},
+ addrStr);
+ byte[] bytesInterfacetype = ArrayUtils.addAll(ipAddrBytes,
+ ByteBuffer.allocate(1).put(interfaceSubtype).array());
+ byte[] bytesInterfaceNumber = ArrayUtils.addAll(bytesInterfacetype,
+ ByteBuffer.allocate(4).putInt(interfaceNum).array());
+ byte[] finalMgmtAddrBytes = ArrayUtils.addAll(bytesInterfaceNumber,
+ ByteBuffer.allocate(1).put(oidString).array());
+ assertThat(tlv.getValue(), is(finalMgmtAddrBytes));
+
+ }
+ }
+ }
+
+ /**
+ * Validates Neightbour list table.
+ * @param neighborList Neighbour list table created using inbound LLDP packets.
+ */
+ void validateNeighborList(Map<ConnectPoint, OltNeighborInfo> neighborList) {
+ assertThat(neighborList, notNullValue());
+ assertThat(neighborList.size(), is(1));
+ for (Map.Entry<ConnectPoint, OltNeighborInfo> entry: neighborList.entrySet()) {
+ assertThat(entry.getValue().mgmtAddr(), is("192.168.1.1"));
+ assertThat(entry.getValue().neighborName(), is("switch-1"));
+ assertThat(entry.getValue().neighborPort(), is("p0"));
+ assertThat(entry.getValue().oltName(), is("0000c6b1cd40dc93"));
+ assertThat(entry.getValue().oltPort().annotations().value("portName"), is("nni-"));
+ }
+ }
+ /**
+ * Keeps a reference to the PacketProcessor and saves the OutboundPackets.
+ */
+ class MockPacketService extends PacketServiceAdapter {
+
+ @Override
+ public void addProcessor(PacketProcessor processor, int priority) {
+ packetProcessor = processor;
+ }
+
+ @Override
+ public void emit(OutboundPacket packet) {
+ try {
+ Ethernet eth = Ethernet.deserializer().deserialize(packet.data().array(),
+ 0, packet.data().array().length);
+ savePacket(eth);
+ } catch (Exception e) {
+ fail(e.getMessage());
+ }
+ }
+ }
+ /**
+ * Mock Flow Objective Service.
+ */
+ public static class MockFlowObjectiveService extends FlowObjectiveServiceAdapter {
+
+ @Override
+ public void filter(DeviceId deviceId, FilteringObjective filter) {
+ assertThat(deviceId, notNullValue());
+ assertThat(filter, notNullValue());
+ EthTypeCriterion ethType = (EthTypeCriterion)
+ filterForCriterion(filter.conditions(), Criterion.Type.ETH_TYPE);
+ assertThat(ethType, notNullValue());
+ assertThat(ethType.ethType(), is(EthType.EtherType.LLDP.ethType()));
+ assertThat(filter.key().type(), is(Criterion.Type.IN_PORT));
+
+ }
+ private Criterion filterForCriterion(Collection<Criterion> criteria, Criterion.Type type) {
+ return criteria.stream()
+ .filter(c -> c.type().equals(type))
+ .limit(1)
+ .findFirst().orElse(null);
+ }
+
+ }
+ /**
+ * Mocks the DefaultPacketContext.
+ */
+ static final class TestPacketContext extends DefaultPacketContext {
+
+ private TestPacketContext(long time, InboundPacket inPkt,
+ OutboundPacket outPkt, boolean block) {
+ super(time, inPkt, outPkt, block);
+ }
+
+ @Override
+ public void send() {
+ // We don't send anything out.
+ }
+ }
+}
diff --git a/app/src/test/java/org/opencord/olttopology/impl/package-info.java b/app/src/test/java/org/opencord/olttopology/impl/package-info.java
new file mode 100755
index 0000000..7104a76
--- /dev/null
+++ b/app/src/test/java/org/opencord/olttopology/impl/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2016-present Open Networking Foundation
+ *
+ * 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.
+ */
+
+/**
+ * OLT Topology application for finding the topology of OLTs.
+ */
+package org.opencord.olttopology.impl;