/**
* Copyright 2011, Big Switch Networks, Inc.
* Originally created by David Erickson, Stanford University
*
* 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 net.onrc.onos.core.linkdiscovery;
import static org.easymock.EasyMock.anyLong;
import static org.easymock.EasyMock.anyObject;
import static org.easymock.EasyMock.anyShort;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.createNiceMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.reportMatcher;
import static org.easymock.EasyMock.verify;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import net.floodlightcontroller.core.FloodlightContext;
import net.floodlightcontroller.core.IFloodlightProviderService;
import net.floodlightcontroller.core.IListener.Command;
import net.floodlightcontroller.core.IOFSwitch;
import net.floodlightcontroller.core.module.FloodlightModuleContext;
import net.floodlightcontroller.core.test.MockThreadPoolService;
import net.floodlightcontroller.restserver.IRestApiService;
import net.floodlightcontroller.restserver.RestApiServer;
import net.floodlightcontroller.test.FloodlightTestCase;
import net.floodlightcontroller.threadpool.IThreadPoolService;
import net.onrc.onos.core.packet.Ethernet;
import net.onrc.onos.core.packet.OnosLldp;
import net.onrc.onos.core.registry.IControllerRegistryService;
import org.easymock.IArgumentMatcher;
import org.junit.Before;
import org.junit.Test;
import org.projectfloodlight.openflow.protocol.OFFactories;
import org.projectfloodlight.openflow.protocol.OFFactory;
import org.projectfloodlight.openflow.protocol.OFPacketIn;
import org.projectfloodlight.openflow.protocol.OFPacketOut;
import org.projectfloodlight.openflow.protocol.OFPortConfig;
import org.projectfloodlight.openflow.protocol.OFPortDesc;
import org.projectfloodlight.openflow.protocol.OFPortReason;
import org.projectfloodlight.openflow.protocol.OFPortState;
import org.projectfloodlight.openflow.protocol.OFPortStatus;
import org.projectfloodlight.openflow.protocol.OFVersion;
import org.projectfloodlight.openflow.protocol.action.OFActionOutput;
import org.projectfloodlight.openflow.types.MacAddress;
import org.projectfloodlight.openflow.types.OFPort;
// CHECKSTYLE IGNORE WriteTag FOR NEXT 2 LINES
/**
* @author David Erickson (daviderickson@cs.stanford.edu)
*/
public class LinkDiscoveryManagerTest extends FloodlightTestCase {
private LinkDiscoveryManager ldm;
private static final Set<OFPortState> EMPTY_PORT_STATE =
Collections.<OFPortState>emptySet();
// Arbitrary MAC address that we can feed in to our mock objects. This
// value is never actually checked during the tests so it doesn't matter if
// all ports have the same MAC address.
private static final byte[] DEFAULT_MAC_ADDRESS =
new byte[] {0x0, 0x0, 0x0, 0x0, 0x0, 0x1};
private OFFactory factory10 = OFFactories.getFactory(OFVersion.OF_10);
/**
* EasyMock matcher to verify the value of the output port of a packet out.
* This is used to verify that the packet out messages generated by
* LinkDiscoveryManager contain the correct output port.
*
*/
private static final class PacketOutPortMatcher implements IArgumentMatcher {
private final int portNumber;
public PacketOutPortMatcher(int portNumber) {
this.portNumber = portNumber;
}
@Override
public void appendTo(StringBuffer strBuffer) {
strBuffer.append("PacketOutPortMatcher failed to verify output port");
}
@Override
public boolean matches(Object object) {
if (!(object instanceof OFPacketOut)) {
return false;
}
OFPacketOut po = (OFPacketOut) object;
if (po.getActions().size() != 1
|| !(po.getActions().get(0) instanceof OFActionOutput)) {
return false;
}
OFActionOutput action = (OFActionOutput) po.getActions().get(0);
return action.getPort().getPortNumber() == portNumber;
}
}
/**
* Matcher method to match a given output port against a packet out message
* passed as an argument to a mock switch.
*
* @param outPort the output port to check in the packet out
* @return anything of type OFPacketOut
*/
private static OFPacketOut matchOutPort(int outPort) {
reportMatcher(new PacketOutPortMatcher(outPort));
return null;
}
private LinkDiscoveryManager getLinkDiscoveryManager() {
return ldm;
}
private IOFSwitch createMockSwitch(Long id) {
IOFSwitch mockSwitch = createNiceMock(IOFSwitch.class);
expect(mockSwitch.getId()).andReturn(id).anyTimes();
expect(mockSwitch.portEnabled(anyShort())).andReturn(true).anyTimes();
expect(mockSwitch.getFactory()).andReturn(factory10).anyTimes();
return mockSwitch;
}
private OFPortDesc createMockPort(short portNumber) {
return createMockPortWithState(portNumber,
Collections.<OFPortState>emptySet());
}
private OFPortDesc createMockPortWithState(short portNumber,
Set<OFPortState> state) {
OFPort ofPort = createMock(OFPort.class);
expect(ofPort.getShortPortNumber()).andReturn(portNumber).anyTimes();
OFPortDesc ofPortDesc = createMock(OFPortDesc.class);
expect(ofPortDesc.getPortNo()).andReturn(ofPort).anyTimes();
expect(ofPortDesc.getHwAddr()).andReturn(
MacAddress.of(DEFAULT_MAC_ADDRESS)).anyTimes();
expect(ofPortDesc.getConfig()).
andReturn(Collections.<OFPortConfig>emptySet()).anyTimes();
expect(ofPortDesc.getState()).andReturn(state).anyTimes();
replay(ofPort);
replay(ofPortDesc);
return ofPortDesc;
}
@Override
@Before
public void setUp() throws Exception {
super.setUp();
FloodlightModuleContext cntx = new FloodlightModuleContext();
ldm = new LinkDiscoveryManager();
MockThreadPoolService tp = new MockThreadPoolService();
RestApiServer restApi = new RestApiServer();
IControllerRegistryService registry =
createMock(IControllerRegistryService.class);
expect(registry.hasControl(anyLong())).andReturn(true).anyTimes();
replay(registry);
cntx.addService(IControllerRegistryService.class, registry);
cntx.addService(IRestApiService.class, restApi);
cntx.addService(IThreadPoolService.class, tp);
cntx.addService(ILinkDiscoveryService.class, ldm);
cntx.addService(IFloodlightProviderService.class, getMockFloodlightProvider());
restApi.init(cntx);
tp.init(cntx);
ldm.init(cntx);
restApi.startUp(cntx);
tp.startUp(cntx);
ldm.startUp(cntx);
IOFSwitch sw1 = createMockSwitch(1L);
IOFSwitch sw2 = createMockSwitch(2L);
Map<Long, IOFSwitch> switches = new HashMap<Long, IOFSwitch>();
switches.put(1L, sw1);
switches.put(2L, sw2);
getMockFloodlightProvider().setSwitches(switches);
replay(sw1, sw2);
}
@Test
public void testAddOrUpdateLink() throws Exception {
LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();
Link lt = new Link(1L, 2, 2L, 1);
long firstSeenTime = System.currentTimeMillis();
LinkInfo info = new LinkInfo(firstSeenTime,
System.currentTimeMillis(), EMPTY_PORT_STATE,
EMPTY_PORT_STATE);
linkDiscovery.addOrUpdateLink(lt, info);
NodePortTuple srcNpt = new NodePortTuple(1L, 2);
NodePortTuple dstNpt = new NodePortTuple(2L, 1);
// check invariants hold
assertNotNull(linkDiscovery.switchLinks.get(lt.getSrc()));
assertTrue(linkDiscovery.switchLinks.get(lt.getSrc()).contains(lt));
assertNotNull(linkDiscovery.portLinks.get(srcNpt));
assertTrue(linkDiscovery.portLinks.get(srcNpt).contains(lt));
assertNotNull(linkDiscovery.portLinks.get(dstNpt));
assertTrue(linkDiscovery.portLinks.get(dstNpt).contains(lt));
assertTrue(linkDiscovery.links.containsKey(lt));
LinkInfo infoToVerify = linkDiscovery.links.get(lt);
assertEquals(firstSeenTime, infoToVerify.getFirstSeenTime());
assertEquals(EMPTY_PORT_STATE, infoToVerify.getSrcPortState());
assertEquals(EMPTY_PORT_STATE, infoToVerify.getDstPortState());
// Arbitrary new port states to verify that the port state is updated
final Set<OFPortState> newSrcPortState =
Collections.singleton(OFPortState.STP_BLOCK);
final Set<OFPortState> newDstPortState =
Collections.singleton(OFPortState.LINK_DOWN);
// Update the last received probe timestamp and the port states
LinkInfo infoWithStateChange = new LinkInfo(System.currentTimeMillis(),
System.currentTimeMillis(), newSrcPortState, newDstPortState);
linkDiscovery.addOrUpdateLink(lt, infoWithStateChange);
assertNotNull(linkDiscovery.links.get(lt));
infoToVerify = linkDiscovery.links.get(lt);
// First seen time should be the original time, not the second update time
assertEquals(firstSeenTime, infoToVerify.getFirstSeenTime());
// Both port states should have been updated
assertEquals(newSrcPortState, infoToVerify.getSrcPortState());
assertEquals(newDstPortState, infoToVerify.getDstPortState());
}
@Test
public void testDeleteLink() throws Exception {
LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();
Link lt = new Link(1L, 2, 2L, 1);
LinkInfo info = new LinkInfo(System.currentTimeMillis(),
System.currentTimeMillis(), EMPTY_PORT_STATE, EMPTY_PORT_STATE);
linkDiscovery.addOrUpdateLink(lt, info);
linkDiscovery.deleteLinks(Collections.singletonList(lt));
// check invariants hold
assertNull(linkDiscovery.switchLinks.get(lt.getSrc()));
assertNull(linkDiscovery.switchLinks.get(lt.getDst()));
assertNull(linkDiscovery.portLinks.get(lt.getSrc()));
assertNull(linkDiscovery.portLinks.get(lt.getDst()));
assertTrue(linkDiscovery.links.isEmpty());
}
@Test
public void testAddOrUpdateLinkToSelf() throws Exception {
LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();
Link lt = new Link(1L, 2, 2L, 3);
NodePortTuple srcNpt = new NodePortTuple(1L, 2);
NodePortTuple dstNpt = new NodePortTuple(2L, 3);
LinkInfo info = new LinkInfo(System.currentTimeMillis(),
System.currentTimeMillis(), EMPTY_PORT_STATE, EMPTY_PORT_STATE);
linkDiscovery.addOrUpdateLink(lt, info);
// check invariants hold
assertNotNull(linkDiscovery.switchLinks.get(lt.getSrc()));
assertTrue(linkDiscovery.switchLinks.get(lt.getSrc()).contains(lt));
assertNotNull(linkDiscovery.portLinks.get(srcNpt));
assertTrue(linkDiscovery.portLinks.get(srcNpt).contains(lt));
assertNotNull(linkDiscovery.portLinks.get(dstNpt));
assertTrue(linkDiscovery.portLinks.get(dstNpt).contains(lt));
assertTrue(linkDiscovery.links.containsKey(lt));
}
@Test
public void testDeleteLinkToSelf() throws Exception {
LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();
Link lt = new Link(1L, 2, 1L, 3);
NodePortTuple srcNpt = new NodePortTuple(1L, 2);
NodePortTuple dstNpt = new NodePortTuple(2L, 3);
LinkInfo info = new LinkInfo(System.currentTimeMillis(),
System.currentTimeMillis(), EMPTY_PORT_STATE, EMPTY_PORT_STATE);
linkDiscovery.addOrUpdateLink(lt, info);
linkDiscovery.deleteLinks(Collections.singletonList(lt));
// check invariants hold
assertNull(linkDiscovery.switchLinks.get(lt.getSrc()));
assertNull(linkDiscovery.switchLinks.get(lt.getDst()));
assertNull(linkDiscovery.portLinks.get(srcNpt));
assertNull(linkDiscovery.portLinks.get(dstNpt));
assertTrue(linkDiscovery.links.isEmpty());
}
@Test
public void testRemovedSwitch() {
LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();
Link lt = new Link(1L, 2, 2L, 1);
NodePortTuple srcNpt = new NodePortTuple(1L, 2);
NodePortTuple dstNpt = new NodePortTuple(2L, 1);
LinkInfo info = new LinkInfo(System.currentTimeMillis(),
System.currentTimeMillis(), EMPTY_PORT_STATE, EMPTY_PORT_STATE);
linkDiscovery.addOrUpdateLink(lt, info);
IOFSwitch sw1 = getMockFloodlightProvider().getSwitches().get(1L);
IOFSwitch sw2 = getMockFloodlightProvider().getSwitches().get(2L);
// Mock up our expected behavior
linkDiscovery.switchDisconnected(sw1.getId());
verify(sw1, sw2);
// check invariants hold
assertNull(linkDiscovery.switchLinks.get(lt.getSrc()));
assertNull(linkDiscovery.switchLinks.get(lt.getDst()));
assertNull(linkDiscovery.portLinks.get(srcNpt));
assertNull(linkDiscovery.portLinks.get(dstNpt));
assertTrue(linkDiscovery.links.isEmpty());
}
@Test
public void testRemovedSwitchSelf() {
LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();
IOFSwitch sw1 = createMockSwitch(1L);
replay(sw1);
Link lt = new Link(1L, 2, 1L, 3);
LinkInfo info = new LinkInfo(System.currentTimeMillis(),
System.currentTimeMillis(), EMPTY_PORT_STATE, EMPTY_PORT_STATE);
linkDiscovery.addOrUpdateLink(lt, info);
// Mock up our expected behavior
linkDiscovery.switchDisconnected(sw1.getId());
verify(sw1);
// check invariants hold
assertNull(linkDiscovery.switchLinks.get(lt.getSrc()));
assertNull(linkDiscovery.portLinks.get(lt.getSrc()));
assertNull(linkDiscovery.portLinks.get(lt.getDst()));
assertTrue(linkDiscovery.links.isEmpty());
}
@Test
public void testAddUpdateLinks() throws Exception {
LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();
Link lt = new Link(1L, 1, 2L, 1);
NodePortTuple srcNpt = new NodePortTuple(1L, 1);
NodePortTuple dstNpt = new NodePortTuple(2L, 1);
LinkInfo info;
// Setting the last LLDP reception time to be 40 seconds old, so we
// can use this to test that an old link times out correctly
info = new LinkInfo(System.currentTimeMillis() - 40000,
System.currentTimeMillis() - 40000,
EMPTY_PORT_STATE, EMPTY_PORT_STATE);
linkDiscovery.addOrUpdateLink(lt, info);
// check invariants hold
assertNotNull(linkDiscovery.switchLinks.get(lt.getSrc()));
assertTrue(linkDiscovery.switchLinks.get(lt.getSrc()).contains(lt));
assertNotNull(linkDiscovery.portLinks.get(srcNpt));
assertTrue(linkDiscovery.portLinks.get(srcNpt).contains(lt));
assertNotNull(linkDiscovery.portLinks.get(dstNpt));
assertTrue(linkDiscovery.portLinks.get(dstNpt).contains(lt));
assertTrue(linkDiscovery.links.containsKey(lt));
linkDiscovery.timeOutLinks();
// Setting the last LLDP reception time to be 40 seconds old, so we
// can use this to test that an old link times out correctly
info = new LinkInfo(System.currentTimeMillis() - 40000,
System.currentTimeMillis() - 40000,
EMPTY_PORT_STATE, EMPTY_PORT_STATE);
linkDiscovery.addOrUpdateLink(lt, info);
// Expect to timeout the unicast Valid Time, so the link should disappear
linkDiscovery.timeOutLinks();
assertTrue(linkDiscovery.links.get(lt) == null);
}
/**
* This test case verifies that LinkDiscoveryManager.sendDiscoveryMessage()
* performs "write" operation on the specified IOFSwitch object
* with a LLDP packet.
*
* @throws IOException
*/
@Test
public void testSendDiscoveryMessage() throws IOException {
LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();
// Mock up our expected behavior
IOFSwitch swTest = createMockSwitch(3L);
getMockFloodlightProvider().getSwitches().put(3L, swTest);
short portNum = 1;
OFPortDesc ofPortDesc = createMockPort(portNum);
expect(swTest.getPort(portNum)).andReturn(ofPortDesc).atLeastOnce();
swTest.write(matchOutPort(portNum),
anyObject(FloodlightContext.class));
expectLastCall().times(1);
swTest.flush();
expectLastCall().once();
replay(swTest);
linkDiscovery.sendDiscoveryMessage(3L, portNum, false);
verify(swTest);
}
@Test
public void testHandlePortStatusForNewPort() throws IOException {
LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();
long dpid = 3L;
IOFSwitch sw = createMockSwitch(dpid);
getMockFloodlightProvider().getSwitches().put(dpid, sw);
short portNum = 1;
OFPortDesc ofPortDesc = createMockPort(portNum);
OFPortStatus portStatus = factory10.buildPortStatus()
.setDesc(ofPortDesc)
.setReason(OFPortReason.ADD)
.build();
expect(sw.getPort(portNum)).andReturn(ofPortDesc).once();
sw.write(matchOutPort(portNum),
anyObject(FloodlightContext.class));
sw.flush();
replay(sw);
linkDiscovery.handlePortStatus(sw, portStatus);
verify(sw);
}
@Test
public void testHandlePortStatusForExistingPort() {
LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();
// Add a link that we can update later during the test
Link lt = new Link(1L, 1, 2L, 1);
LinkInfo info = new LinkInfo(System.currentTimeMillis(),
System.currentTimeMillis(), EMPTY_PORT_STATE, EMPTY_PORT_STATE);
linkDiscovery.addOrUpdateLink(lt, info);
short portNum = 1;
// Arbitrary states to test state changes
Set<OFPortState> srcPortState =
Collections.singleton(OFPortState.STP_FORWARD);
Set<OFPortState> dstPortState =
Collections.singleton(OFPortState.STP_LISTEN);
OFPortDesc srcPortDesc = createMockPortWithState(portNum, srcPortState);
OFPortDesc dstPortDesc = createMockPortWithState(portNum, dstPortState);
OFPortStatus srcPortStatus = factory10.buildPortStatus()
.setDesc(srcPortDesc)
.setReason(OFPortReason.MODIFY)
.build();
OFPortStatus dstPortStatus = factory10.buildPortStatus()
.setDesc(dstPortDesc)
.setReason(OFPortReason.MODIFY)
.build();
linkDiscovery.handlePortStatus(
getMockFloodlightProvider().getSwitches().get(1L), srcPortStatus);
LinkInfo newInfo = linkDiscovery.links.get(lt);
assertEquals(srcPortState, newInfo.getSrcPortState());
assertEquals(EMPTY_PORT_STATE, newInfo.getDstPortState());
linkDiscovery.handlePortStatus(
getMockFloodlightProvider().getSwitches().get(2L), dstPortStatus);
newInfo = linkDiscovery.links.get(lt);
assertEquals(srcPortState, newInfo.getSrcPortState());
assertEquals(dstPortState, newInfo.getDstPortState());
}
@Test
public void testHandlePortStatusForDeletePort() {
LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();
// Add a link that we can delete later during the test
Link lt = new Link(1L, 1, 2L, 2);
LinkInfo info = new LinkInfo(System.currentTimeMillis(),
System.currentTimeMillis(), EMPTY_PORT_STATE, EMPTY_PORT_STATE);
linkDiscovery.addOrUpdateLink(lt, info);
short portNum = 1;
OFPortDesc srcPortDesc = createMockPort(portNum);
OFPortStatus srcPortStatus = factory10.buildPortStatus()
.setDesc(srcPortDesc)
.setReason(OFPortReason.DELETE)
.build();
assertNotNull(linkDiscovery.getLinks().get(lt));
// Send a delete port status for the source port, which should result
// in the link being deleted
linkDiscovery.handlePortStatus(
getMockFloodlightProvider().getSwitches().get(1L), srcPortStatus);
assertNull(linkDiscovery.getLinks().get(lt));
}
@Test
public void testReceive() {
OnosLldp lldpPacket = new OnosLldp();
lldpPacket.setPort((short) 1);
lldpPacket.setSwitch(1L);
lldpPacket.setReverse(false);
Ethernet ethPacket = new Ethernet();
ethPacket.setEtherType(Ethernet.TYPE_LLDP);
ethPacket.setSourceMACAddress(DEFAULT_MAC_ADDRESS);
ethPacket.setDestinationMACAddress(
LinkDiscoveryManager.LLDP_STANDARD_DST_MAC_STRING);
ethPacket.setPayload(lldpPacket);
ethPacket.setPad(true);
OFPacketIn pi = createMock(OFPacketIn.class);
expect(pi.getData()).andReturn(ethPacket.serialize()).anyTimes();
replay(pi);
LinkDiscoveryManager linkDiscovery = getLinkDiscoveryManager();
Link expectedLink = new Link(1L, 1, 2L, 2);
assertNull(linkDiscovery.links.get(expectedLink));
// Sending in the LLDP packet should cause the link to be created
Command command = linkDiscovery.handleLldp(lldpPacket, 2L, pi, (short) 2);
assertEquals(Command.STOP, command);
assertNotNull(linkDiscovery.links.get(expectedLink));
}
}