/**
* 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 java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import net.floodlightcontroller.core.FloodlightContext;
import net.floodlightcontroller.core.IFloodlightProviderService;
import net.floodlightcontroller.core.IOFMessageListener;
import net.floodlightcontroller.core.IOFSwitch;
import net.floodlightcontroller.core.IOFSwitch.PortChangeType;
import net.floodlightcontroller.core.IOFSwitchListener;
import net.floodlightcontroller.core.IUpdate;
import net.floodlightcontroller.core.annotations.LogMessageCategory;
import net.floodlightcontroller.core.annotations.LogMessageDoc;
import net.floodlightcontroller.core.annotations.LogMessageDocs;
import net.floodlightcontroller.core.module.FloodlightModuleContext;
import net.floodlightcontroller.core.module.FloodlightModuleException;
import net.floodlightcontroller.core.module.IFloodlightModule;
import net.floodlightcontroller.core.module.IFloodlightService;
import net.floodlightcontroller.core.util.SingletonTask;
import net.floodlightcontroller.restserver.IRestApiService;
import net.floodlightcontroller.threadpool.IThreadPoolService;
import net.onrc.onos.core.linkdiscovery.web.LinkDiscoveryWebRoutable;
import net.onrc.onos.core.packet.Ethernet;
import net.onrc.onos.core.packet.LLDP;
import net.onrc.onos.core.packet.OnosLldp;
import net.onrc.onos.core.registry.IControllerRegistryService;
import net.onrc.onos.core.util.SwitchPort;
import org.projectfloodlight.openflow.protocol.OFFactory;
import org.projectfloodlight.openflow.protocol.OFMessage;
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.OFType;
import org.projectfloodlight.openflow.protocol.action.OFAction;
import org.projectfloodlight.openflow.types.OFBufferId;
import org.projectfloodlight.openflow.types.OFPort;
import org.projectfloodlight.openflow.util.HexString;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Discovers links between OpenFlow switches.
* <p>
* Discovery is performed by sending probes (LLDP packets) over the links in the
* data plane. The LinkDiscoveryManager sends probes periodically on all ports
* on all connected switches. The probes contain the sending switch's DPID and
* outgoing port number. LLDP packets that are received (via an OpenFlow
* packet-in) indicate there is a link between the receiving port and the
* sending port, which was encoded in the LLDP. When the LinkDiscoveryManager
* observes a new link, a Link object is created and an event is fired for any
* event listeners.
* </p>
* Links are removed for one of three reasons:
* <ul>
* <li>A probe has not been received on the link for an interval (the timeout
* interval)</li>
* <li>The port went down or was disabled (as observed by OpenFlow port-status
* messages) or the disconnection of the switch</li>
* <li>Link discovery was explicitly disabled on a port with the
* {@link #disableDiscoveryOnPort(long, short)} method</li>
* </ul>
* When the LinkDiscoveryManager removes a link it also fires an event for the
* listeners.
*/
@LogMessageCategory("Network Topology")
public class LinkDiscoveryManager implements IOFMessageListener, IOFSwitchListener,
ILinkDiscoveryService, IFloodlightModule {
private static final Logger log =
LoggerFactory.getLogger(LinkDiscoveryManager.class);
private IFloodlightProviderService controller;
private IFloodlightProviderService floodlightProvider;
private IThreadPoolService threadPool;
private IRestApiService restApi;
private IControllerRegistryService registryService;
// LLDP fields
static final byte[] LLDP_STANDARD_DST_MAC_STRING =
HexString.fromHexString("01:80:c2:00:00:0e");
private static final long LINK_LOCAL_MASK = 0xfffffffffff0L;
private static final long LINK_LOCAL_VALUE = 0x0180c2000000L;
// Link discovery task details.
private SingletonTask discoveryTask;
private static final int DISCOVERY_TASK_INTERVAL = 1;
private static final int LINK_TIMEOUT = 35; // original 35 secs, aggressive
// 5 secs
private static final int LLDP_TO_ALL_INTERVAL = 15; // original 15 seconds,
// aggressive 2 secs.
private long lldpClock = 0;
// This value is intentionally kept higher than LLDP_TO_ALL_INTERVAL.
// If we want to identify link failures faster, we could decrease this
// value to a small number, say 1 or 2 sec.
private static final int LLDP_TO_KNOWN_INTERVAL = 20; // LLDP frequency for
// known links
private ReentrantReadWriteLock lock;
/**
* Map from link to the most recent time it was verified functioning.
*/
protected Map<Link, LinkInfo> links;
/**
* Map from switch id to a set of all links with it as an endpoint.
*/
protected Map<Long, Set<Link>> switchLinks;
/**
* Map from a id:port to the set of links containing it as an endpoint.
*/
protected Map<NodePortTuple, Set<Link>> portLinks;
/**
* Listeners are called in the order they were added to the the list.
*/
private final List<ILinkDiscoveryListener> linkDiscoveryListeners =
new CopyOnWriteArrayList<>();
/**
* List of ports through which LLDPs are not sent.
*/
private Set<NodePortTuple> suppressLinkDiscovery;
private enum UpdateType {
LINK_ADDED,
LINK_REMOVED
}
private class LinkUpdate implements IUpdate {
private final Link link;
private final UpdateType operation;
public LinkUpdate(Link link, UpdateType operation) {
this.link = link;
this.operation = operation;
}
@Override
public void dispatch() {
if (log.isTraceEnabled()) {
log.trace("Dispatching link discovery update {} for {}",
operation, link);
}
for (ILinkDiscoveryListener listener : linkDiscoveryListeners) {
switch (operation) {
case LINK_ADDED:
listener.linkAdded(link);
break;
case LINK_REMOVED:
listener.linkRemoved(link);
break;
default:
log.warn("Unknown link update operation {}", operation);
break;
}
}
}
}
/**
* Gets the LLDP sending period in seconds.
*
* @return LLDP sending period in seconds.
*/
public int getLldpFrequency() {
return LLDP_TO_KNOWN_INTERVAL;
}
/**
* Gets the LLDP timeout value in seconds.
*
* @return LLDP timeout value in seconds
*/
public int getLldpTimeout() {
return LINK_TIMEOUT;
}
@Override
public Set<NodePortTuple> getDiscoveryDisabledPorts() {
return suppressLinkDiscovery;
}
@Override
public void disableDiscoveryOnPort(long sw, short port) {
NodePortTuple npt = new NodePortTuple(sw, port);
this.suppressLinkDiscovery.add(npt);
deleteLinksOnPort(npt);
}
@Override
public void enableDiscoveryOnPort(long sw, short port) {
NodePortTuple npt = new NodePortTuple(sw, port);
this.suppressLinkDiscovery.remove(npt);
discover(npt);
}
private boolean isLinkDiscoverySuppressed(long sw, short p) {
return this.suppressLinkDiscovery.contains(new NodePortTuple(sw, p));
}
private void discoverLinks() {
// time out known links.
timeOutLinks();
// increment LLDP clock
lldpClock = (lldpClock + 1) % LLDP_TO_ALL_INTERVAL;
if (lldpClock == 0) {
log.debug("Sending LLDP out on all ports.");
discoverOnAllPorts();
}
}
/**
* Send LLDP on known ports.
*/
protected void discoverOnKnownLinkPorts() {
// Copy the port set.
Set<NodePortTuple> nptSet = new HashSet<NodePortTuple>();
nptSet.addAll(portLinks.keySet());
// Send LLDP from each of them.
for (NodePortTuple npt : nptSet) {
discover(npt);
}
}
private void discover(NodePortTuple npt) {
discover(npt.getNodeId(), npt.getPortId());
}
private void discover(long sw, short port) {
sendDiscoveryMessage(sw, port, false);
}
/**
* Send link discovery message out of a given switch port. The discovery
* message is a standard LLDP containing ONOS-specific TLVs.
*
* @param sw the switch to send on
* @param port the port to send out
* @param isReverse indicates whether the LLDP was sent as a response
*/
@LogMessageDoc(level = "ERROR",
message = "Failure sending LLDP out port {port} on switch {switch}",
explanation = "An I/O error occured while sending LLDP message " +
"to the switch.",
recommendation = LogMessageDoc.CHECK_SWITCH)
protected void sendDiscoveryMessage(long sw, short port,
boolean isReverse) {
IOFSwitch iofSwitch = floodlightProvider.getSwitches().get(sw);
if (iofSwitch == null) {
return;
}
if (port == OFPort.LOCAL.getShortPortNumber()) {
return;
}
OFPortDesc ofpPort = iofSwitch.getPort(port);
if (ofpPort == null) {
if (log.isTraceEnabled()) {
log.trace("Null physical port. sw={}, port={}", sw, port);
}
return;
}
if (isLinkDiscoverySuppressed(sw, port)) {
// Don't send LLDPs out of this port as suppressLLDPs set
return;
}
if (log.isTraceEnabled()) {
log.trace("Sending LLDP packet out of swich: {}, port: {}",
sw, port);
}
OFFactory factory = iofSwitch.getFactory();
OFPacketOut po = createLLDPPacketOut(sw, ofpPort, isReverse, factory);
try {
iofSwitch.write(po, null);
iofSwitch.flush();
} catch (IOException e) {
log.error("Failure sending LLDP out port " + port + " on switch "
+ iofSwitch.getStringId(), e);
}
}
/**
* Creates packet_out LLDP for specified output port.
*
* @param dpid the dpid of the outgoing switch
* @param port the outgoing port
* @param isReverse whether this is a reverse LLDP or not
* @param factory the factory to use to create the message
* @return Packet_out message with LLDP data
*/
private OFPacketOut createLLDPPacketOut(long dpid,
final OFPortDesc port, boolean isReverse, OFFactory factory) {
// Set up packets
// TODO optimize by not creating new packets each time
OnosLldp lldpPacket = new OnosLldp();
Ethernet ethPacket = new Ethernet();
ethPacket.setEtherType(Ethernet.TYPE_LLDP);
ethPacket.setDestinationMACAddress(LLDP_STANDARD_DST_MAC_STRING);
ethPacket.setPayload(lldpPacket);
ethPacket.setPad(true);
lldpPacket.setSwitch(dpid);
lldpPacket.setPort(port.getPortNo().getShortPortNumber());
lldpPacket.setReverse(isReverse);
ethPacket.setSourceMACAddress(port.getHwAddr().getBytes());
final byte[] lldp = ethPacket.serialize();
List<OFAction> actions = new ArrayList<OFAction>();
actions.add(factory.actions()
.buildOutput()
.setPort(OFPort.ofShort(port.getPortNo().getShortPortNumber()))
.build());
OFPacketOut po = factory.buildPacketOut()
.setData(lldp)
.setBufferId(OFBufferId.NO_BUFFER)
.setInPort(OFPort.CONTROLLER)
.setActions(actions)
.build();
return po;
}
/**
* Send LLDPs to all switch-ports.
*/
protected void discoverOnAllPorts() {
if (log.isTraceEnabled()) {
log.trace("Sending LLDP packets out of all the enabled ports on switch");
}
for (IOFSwitch sw : floodlightProvider.getSwitches().values()) {
if (sw.getEnabledPorts() == null) {
continue;
}
for (OFPortDesc ofp : sw.getEnabledPorts()) {
if (isLinkDiscoverySuppressed(sw.getId(),
ofp.getPortNo().getShortPortNumber())) {
continue;
}
sendDiscoveryMessage(sw.getId(),
ofp.getPortNo().getShortPortNumber(), false);
}
}
}
@Override
public String getName() {
return "linkdiscovery";
}
@Override
public Command receive(IOFSwitch sw, OFMessage msg, FloodlightContext cntx) {
switch (msg.getType()) {
case PACKET_IN:
if (msg instanceof OFPacketIn) {
return this.handlePacketIn(sw.getId(), (OFPacketIn) msg,
cntx);
}
break;
case PORT_STATUS:
if (msg instanceof OFPortStatus) {
return this.handlePortStatus(sw, (OFPortStatus) msg);
}
break;
default:
break;
}
return Command.CONTINUE;
}
protected Command handleLldp(LLDP lldp, long sw, OFPacketIn pi, short inport) {
// If LLDP is suppressed on this port, ignore received packet as well
IOFSwitch iofSwitch = floodlightProvider.getSwitch(sw);
if (iofSwitch == null) {
return Command.STOP;
}
if (isLinkDiscoverySuppressed(sw, inport)) {
return Command.STOP;
}
// If this is a malformed LLDP, or not from us, exit
if (lldp.getPortId() == null || lldp.getPortId().getLength() != 3) {
return Command.CONTINUE;
}
// Verify this LLDP packet matches what we're looking for
byte[] packetData = pi.getData();
if (!OnosLldp.isOnosLldp(packetData)) {
log.trace("Dropping LLDP that wasn't sent by ONOS");
return Command.STOP;
}
SwitchPort switchPort = OnosLldp.extractSwitchPort(packetData);
long remoteDpid = switchPort.getDpid().value();
short remotePort = switchPort.getPortNumber().shortValue();
IOFSwitch remoteSwitch = floodlightProvider.getSwitches().get(
switchPort.getDpid().value());
OFPortDesc physicalPort = null;
if (remoteSwitch != null) {
physicalPort = remoteSwitch.getPort(remotePort);
if (!remoteSwitch.portEnabled(remotePort)) {
if (log.isTraceEnabled()) {
log.trace("Ignoring link with disabled source port: " +
"switch {} port {}", remoteSwitch, remotePort);
}
return Command.STOP;
}
if (suppressLinkDiscovery.contains(
new NodePortTuple(remoteSwitch.getId(), remotePort))) {
if (log.isTraceEnabled()) {
log.trace("Ignoring link with suppressed src port: " +
"switch {} port {}", remoteSwitch, remotePort);
}
return Command.STOP;
}
}
if (!iofSwitch.portEnabled(inport)) {
if (log.isTraceEnabled()) {
log.trace("Ignoring link with disabled dest port: " +
"switch {} port {}", sw, inport);
}
return Command.STOP;
}
// TODO It probably should be empty Set instead of null. Confirm and fix.
Set<OFPortState> srcPortState = (physicalPort != null)
? physicalPort.getState() : null;
physicalPort = iofSwitch.getPort(inport);
Set<OFPortState> dstPortState = (physicalPort != null)
? physicalPort.getState() : null;
// Store the time of update to this link, and push it out to
// routingEngine
Link lt = new Link(remoteDpid, remotePort, iofSwitch.getId(), inport);
LinkInfo linkInfo = new LinkInfo(System.currentTimeMillis(),
System.currentTimeMillis(), srcPortState, dstPortState);
addOrUpdateLink(lt, linkInfo);
// Check if reverse link exists.
// If it doesn't exist and if the forward link was seen
// first seen within a small interval, send probe on the
// reverse link.
boolean isReverse = OnosLldp.isReverse(lldp);
LinkInfo newLinkInfo = links.get(lt);
if (newLinkInfo != null && !isReverse) {
Link reverseLink = new Link(lt.getDst(), lt.getDstPort(),
lt.getSrc(), lt.getSrcPort());
LinkInfo reverseInfo = links.get(reverseLink);
if (reverseInfo == null) {
// the reverse link does not exist.
if (newLinkInfo.getFirstSeenTime() > System.currentTimeMillis()
- LINK_TIMEOUT) {
this.sendDiscoveryMessage(lt.getDst(), lt.getDstPort(), true);
}
}
}
// Consume this message
return Command.STOP;
}
protected Command handlePacketIn(long sw, OFPacketIn pi,
FloodlightContext cntx) {
Ethernet eth =
IFloodlightProviderService.bcStore.get(cntx,
IFloodlightProviderService.CONTEXT_PI_PAYLOAD);
short inport = (short) cntx.getStorage()
.get(IFloodlightProviderService.CONTEXT_PI_INPORT);
if (eth.getEtherType() == Ethernet.TYPE_LLDP) {
return handleLldp((LLDP) eth.getPayload(), sw, pi, inport);
} else if (eth.getEtherType() < 1500) {
long destMac = eth.getDestinationMAC().toLong();
if ((destMac & LINK_LOCAL_MASK) == LINK_LOCAL_VALUE) {
if (log.isTraceEnabled()) {
log.trace("Ignoring packet addressed to 802.1D/Q " +
"reserved address.");
}
return Command.STOP;
}
}
return Command.CONTINUE;
}
protected void addOrUpdateLink(Link lt, LinkInfo detectedLinkInfo) {
lock.writeLock().lock();
try {
LinkInfo existingInfo = links.get(lt);
LinkInfo newLinkInfo = new LinkInfo(
((existingInfo == null) ? detectedLinkInfo.getFirstSeenTime()
: existingInfo.getFirstSeenTime()),
detectedLinkInfo.getLastProbeReceivedTime(),
detectedLinkInfo.getSrcPortState(),
detectedLinkInfo.getDstPortState());
// Add new LinkInfo or update old LinkInfo
links.put(lt, newLinkInfo);
if (log.isTraceEnabled()) {
log.trace("addOrUpdateLink: {}", lt);
}
NodePortTuple srcNpt = new NodePortTuple(lt.getSrc(), lt.getSrcPort());
NodePortTuple dstNpt = new NodePortTuple(lt.getDst(), lt.getDstPort());
// If this is the first time we've seen the link, add the Link
// object to the data structures/indexes as well
if (existingInfo == null) {
log.trace("Creating new Link: {}", lt);
// index it by switch source
if (!switchLinks.containsKey(lt.getSrc())) {
switchLinks.put(lt.getSrc(), new HashSet<Link>());
}
switchLinks.get(lt.getSrc()).add(lt);
// index it by switch dest
if (!switchLinks.containsKey(lt.getDst())) {
switchLinks.put(lt.getDst(), new HashSet<Link>());
}
switchLinks.get(lt.getDst()).add(lt);
// index both ends by switch:port
if (!portLinks.containsKey(srcNpt)) {
portLinks.put(srcNpt, new HashSet<Link>());
}
portLinks.get(srcNpt).add(lt);
if (!portLinks.containsKey(dstNpt)) {
portLinks.put(dstNpt, new HashSet<Link>());
}
portLinks.get(dstNpt).add(lt);
// Publish LINK_ADDED event
controller.publishUpdate(new LinkUpdate(lt, UpdateType.LINK_ADDED));
}
} finally {
lock.writeLock().unlock();
}
}
/**
* Removes links from the data structures.
*
* @param linksToDelete the list of links to delete
*/
protected void deleteLinks(List<Link> linksToDelete) {
lock.writeLock().lock();
try {
for (Link lt : linksToDelete) {
NodePortTuple srcNpt = new NodePortTuple(lt.getSrc(), lt.getSrcPort());
NodePortTuple dstNpt = new NodePortTuple(lt.getDst(), lt.getDstPort());
switchLinks.get(lt.getSrc()).remove(lt);
switchLinks.get(lt.getDst()).remove(lt);
if (switchLinks.containsKey(lt.getSrc()) &&
switchLinks.get(lt.getSrc()).isEmpty()) {
this.switchLinks.remove(lt.getSrc());
}
if (this.switchLinks.containsKey(lt.getDst()) &&
this.switchLinks.get(lt.getDst()).isEmpty()) {
this.switchLinks.remove(lt.getDst());
}
if (this.portLinks.get(srcNpt) != null) {
this.portLinks.get(srcNpt).remove(lt);
if (this.portLinks.get(srcNpt).isEmpty()) {
this.portLinks.remove(srcNpt);
}
}
if (this.portLinks.get(dstNpt) != null) {
this.portLinks.get(dstNpt).remove(lt);
if (this.portLinks.get(dstNpt).isEmpty()) {
this.portLinks.remove(dstNpt);
}
}
this.links.remove(lt);
controller.publishUpdate(new LinkUpdate(lt,
UpdateType.LINK_REMOVED));
if (log.isTraceEnabled()) {
log.trace("Deleted link {}", lt);
}
}
} finally {
lock.writeLock().unlock();
}
}
/**
* Handles an OFPortStatus message from a switch. We will add or delete
* LinkTupes as well re-compute the topology if needed.
*
* @param sw The dpid of the switch that sent the port status message
* @param ps The OFPortStatus message
* @return The Command to continue or stop after we process this message
*/
protected Command handlePortStatus(IOFSwitch sw, OFPortStatus ps) {
// If we do not control this switch, then we should not process its
// port status messages
if (!registryService.hasControl(sw.getId())) {
return Command.CONTINUE;
}
if (log.isTraceEnabled()) {
log.trace("handlePortStatus: Switch {} port #{} reason {}; " +
"config is {} state is {}",
new Object[] {sw.getStringId(),
ps.getDesc().getPortNo(),
ps.getReason(),
ps.getDesc().getConfig(),
ps.getDesc().getState()});
}
short port = ps.getDesc().getPortNo().getShortPortNumber();
NodePortTuple npt = new NodePortTuple(sw.getId(), port);
boolean linkDeleted = false;
boolean linkInfoChanged = false;
lock.writeLock().lock();
try {
// if ps is a delete, or a modify where the port is down or
// configured down
if (OFPortReason.DELETE == ps.getReason() ||
(OFPortReason.MODIFY == ps.getReason() &&
!portEnabled(ps.getDesc()))) {
deleteLinksOnPort(npt);
linkDeleted = true;
} else if (ps.getReason() == OFPortReason.MODIFY) {
// If ps is a port modification and the port state has changed
// that affects links in the topology
if (this.portLinks.containsKey(npt)) {
for (Link lt : this.portLinks.get(npt)) {
LinkInfo linkInfo = links.get(lt);
assert (linkInfo != null);
LinkInfo newLinkInfo = null;
if (lt.isSrcPort(npt) &&
!linkInfo.getSrcPortState().equals(
ps.getDesc().getState())) {
// If this port status is for the src port and the
// port state has changed, create a new link info
// with the new state
newLinkInfo = new LinkInfo(linkInfo.getFirstSeenTime(),
linkInfo.getLastProbeReceivedTime(),
ps.getDesc().getState(),
linkInfo.getDstPortState());
} else if (lt.isDstPort(npt) &&
!linkInfo.getDstPortState().equals(
ps.getDesc().getState())) {
// If this port status is for the dst port and the
// port state has changed, create a new link info
// with the new state
newLinkInfo = new LinkInfo(linkInfo.getFirstSeenTime(),
linkInfo.getLastProbeReceivedTime(),
linkInfo.getSrcPortState(),
ps.getDesc().getState());
}
if (newLinkInfo != null) {
linkInfoChanged = true;
links.put(lt, newLinkInfo);
}
}
}
}
if (!linkDeleted && !linkInfoChanged) {
if (log.isTraceEnabled()) {
log.trace("handlePortStatus: Switch {} port #{} reason {};" +
" no links to update/remove",
new Object[] {HexString.toHexString(sw.getId()),
ps.getDesc().getPortNo(),
ps.getReason()});
}
}
} finally {
lock.writeLock().unlock();
}
if (!linkDeleted) {
// Send LLDP right away when port state is changed for faster
// cluster-merge. If it is a link delete then there is not need
// to send the LLDPs right away and instead we wait for the LLDPs
// to be sent on the timer as it is normally done
// do it outside the write-lock
// sendLLDPTask.reschedule(1000, TimeUnit.MILLISECONDS);
processNewPort(npt.getNodeId(), npt.getPortId());
}
return Command.CONTINUE;
}
/**
* Process a new port. If link discovery is disabled on the port, then do
* nothing. Otherwise, send LLDP message.
*
* @param sw the dpid of the switch the port is on
* @param p the number of the port
*/
private void processNewPort(long sw, int p) {
if (isLinkDiscoverySuppressed(sw, (short) p)) {
// Do nothing as link discovery is suppressed.
return;
} else {
discover(sw, (short) p);
}
}
/**
* We send out LLDP messages when a switch is added to discover the
* topology.
*
* @param swId the datapath Id of the new switch
*/
@Override
public void switchActivatedMaster(long swId) {
IOFSwitch sw = floodlightProvider.getSwitch(swId);
if (sw == null) {
log.warn("Added switch not available {} ", swId);
return;
}
if (sw.getEnabledPorts() != null) {
for (Integer p : sw.getEnabledPortNumbers()) {
processNewPort(swId, p);
}
}
}
/**
* When a switch disconnects we remove any links from our map and notify.
*
* @param swId the datapath Id of the switch that was removed
*/
@Override
public void switchDisconnected(long swId) {
// Cleanup link state
List<Link> eraseList = new ArrayList<Link>();
lock.writeLock().lock();
try {
if (switchLinks.containsKey(swId)) {
if (log.isTraceEnabled()) {
log.trace("Handle switchRemoved. Switch {}; removing links {}",
HexString.toHexString(swId), switchLinks.get(swId));
}
// add all tuples with an endpoint on this switch to erase list
eraseList.addAll(switchLinks.get(swId));
deleteLinks(eraseList);
}
} finally {
lock.writeLock().unlock();
}
}
@Override
public void switchActivatedEqual(long swId) {
// TODO Auto-generated method stub
}
@Override
public void switchMasterToEqual(long swId) {
// TODO Auto-generated method stub
}
@Override
public void switchEqualToMaster(long swId) {
// for now treat as switchActivatedMaster
switchActivatedMaster(swId);
}
/*
* We don't react to port changed notifications here. we listen for
* OFPortStatus messages directly. Might consider using this notifier
* instead
*/
@Override
public void switchPortChanged(long swId, OFPortDesc port,
PortChangeType changeType) {
// TODO Auto-generated method stub
}
/**
* Delete links incident on a given switch port.
*
* @param npt the port to delete links on
*/
protected void deleteLinksOnPort(NodePortTuple npt) {
List<Link> eraseList = new ArrayList<Link>();
if (this.portLinks.containsKey(npt)) {
if (log.isTraceEnabled()) {
log.trace("handlePortStatus: Switch {} port #{} " +
"removing links {}",
new Object[] {HexString.toHexString(npt.getNodeId()),
npt.getPortId(),
this.portLinks.get(npt)});
}
eraseList.addAll(this.portLinks.get(npt));
deleteLinks(eraseList);
}
}
/**
* Iterates through the list of links and deletes if the last discovery
* message reception time exceeds timeout values.
*/
protected void timeOutLinks() {
List<Link> eraseList = new ArrayList<Link>();
Long curTime = System.currentTimeMillis();
// reentrant required here because deleteLink also write locks
lock.writeLock().lock();
try {
Iterator<Entry<Link, LinkInfo>> it =
this.links.entrySet().iterator();
while (it.hasNext()) {
Entry<Link, LinkInfo> entry = it.next();
LinkInfo info = entry.getValue();
if ((info.getLastProbeReceivedTime() + (1000L * LINK_TIMEOUT)
< curTime)) {
eraseList.add(entry.getKey());
}
}
deleteLinks(eraseList);
} finally {
lock.writeLock().unlock();
}
}
private boolean portEnabled(OFPortDesc port) {
if (port == null) {
return false;
}
if (port.getConfig().contains(OFPortConfig.PORT_DOWN)) {
return false;
}
if (port.getState().contains(OFPortState.LINK_DOWN)) {
return false;
}
return true;
}
@Override
public Map<Link, LinkInfo> getLinks() {
lock.readLock().lock();
Map<Link, LinkInfo> result;
try {
result = new HashMap<Link, LinkInfo>(links);
} finally {
lock.readLock().unlock();
}
return result;
}
@Override
public void addListener(ILinkDiscoveryListener listener) {
linkDiscoveryListeners.add(listener);
}
@Override
public void removeListener(ILinkDiscoveryListener listener) {
linkDiscoveryListeners.remove(listener);
}
@Override
public boolean isCallbackOrderingPrereq(OFType type, String name) {
return false;
}
@Override
public boolean isCallbackOrderingPostreq(OFType type, String name) {
return false;
}
// IFloodlightModule classes
@Override
public Collection<Class<? extends IFloodlightService>> getModuleServices() {
Collection<Class<? extends IFloodlightService>> l =
new ArrayList<Class<? extends IFloodlightService>>();
l.add(ILinkDiscoveryService.class);
return l;
}
@Override
public Map<Class<? extends IFloodlightService>, IFloodlightService>
getServiceImpls() {
Map<Class<? extends IFloodlightService>, IFloodlightService> m =
new HashMap<>();
m.put(ILinkDiscoveryService.class, this);
return m;
}
@Override
public Collection<Class<? extends IFloodlightService>> getModuleDependencies() {
Collection<Class<? extends IFloodlightService>> l = new ArrayList<>();
l.add(IFloodlightProviderService.class);
l.add(IThreadPoolService.class);
l.add(IRestApiService.class);
l.add(IControllerRegistryService.class);
return l;
}
@Override
public void init(FloodlightModuleContext context)
throws FloodlightModuleException {
floodlightProvider = context.getServiceImpl(IFloodlightProviderService.class);
threadPool = context.getServiceImpl(IThreadPoolService.class);
restApi = context.getServiceImpl(IRestApiService.class);
registryService = context.getServiceImpl(IControllerRegistryService.class);
this.lock = new ReentrantReadWriteLock();
this.links = new HashMap<Link, LinkInfo>();
this.portLinks = new HashMap<NodePortTuple, Set<Link>>();
this.suppressLinkDiscovery =
Collections.synchronizedSet(new HashSet<NodePortTuple>());
this.switchLinks = new HashMap<Long, Set<Link>>();
}
@Override
@LogMessageDocs({
@LogMessageDoc(level = "ERROR",
message = "No storage source found.",
explanation = "Storage source was not initialized; cannot initialize "
+
"link discovery.",
recommendation = LogMessageDoc.REPORT_CONTROLLER_BUG),
@LogMessageDoc(level = "ERROR",
message = "Error in installing listener for " +
"switch config table {table}",
explanation = "Failed to install storage notification for the " +
"switch config table",
recommendation = LogMessageDoc.REPORT_CONTROLLER_BUG),
@LogMessageDoc(level = "ERROR",
message = "No storage source found.",
explanation = "Storage source was not initialized; cannot initialize "
+
"link discovery.",
recommendation = LogMessageDoc.REPORT_CONTROLLER_BUG),
@LogMessageDoc(level = "ERROR",
message = "Exception in LLDP send timer.",
explanation = "An unknown error occured while sending LLDP " +
"messages to switches.",
recommendation = LogMessageDoc.CHECK_SWITCH)
})
public void startUp(FloodlightModuleContext context) {
ScheduledExecutorService ses = threadPool.getScheduledExecutor();
controller = context.getServiceImpl(IFloodlightProviderService.class);
discoveryTask = new SingletonTask(ses, new Runnable() {
@Override
public void run() {
try {
discoverLinks();
} catch (Exception e) {
log.error("Exception in LLDP send timer.", e);
} finally {
log.trace("Rescheduling discovery task");
discoveryTask.reschedule(DISCOVERY_TASK_INTERVAL,
TimeUnit.SECONDS);
}
}
});
discoveryTask.reschedule(DISCOVERY_TASK_INTERVAL, TimeUnit.SECONDS);
// Register for the OpenFlow messages we want to receive
floodlightProvider.addOFMessageListener(OFType.PACKET_IN, this);
floodlightProvider.addOFMessageListener(OFType.PORT_STATUS, this);
// Register for switch updates
floodlightProvider.addOFSwitchListener(this);
restApi.addRestletRoutable(new LinkDiscoveryWebRoutable());
}
}