| /* |
| * 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 clearLocalData() { |
| |
| } |
| |
| @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) { |
| |
| } |
| } |
| } |