package net.onrc.onos.core.topology;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.LinkedBlockingQueue;
import javax.annotation.concurrent.GuardedBy;
import net.floodlightcontroller.util.MACAddress;
import net.onrc.onos.core.datagrid.IDatagridService;
import net.onrc.onos.core.datagrid.IEventChannel;
import net.onrc.onos.core.datagrid.IEventChannelListener;
import net.onrc.onos.core.metrics.OnosMetrics;
import net.onrc.onos.core.metrics.OnosMetrics.MetricsComponent;
import net.onrc.onos.core.metrics.OnosMetrics.MetricsFeature;
import net.onrc.onos.core.registry.IControllerRegistryService;
import net.onrc.onos.core.util.Dpid;
import net.onrc.onos.core.util.EventEntry;
import net.onrc.onos.core.util.SwitchPort;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.codahale.metrics.Gauge;
import com.codahale.metrics.Meter;
/**
* The TopologyManager receives topology updates from the southbound discovery
* modules and from other ONOS instances. These updates are processed and
* applied to the in-memory topology instance.
* <p/>
* - Maintain Invariant/Relationships between Topology Objects.
* <p/>
* TODO To be synchronized based on TopologyEvent Notification.
* <p/>
* TODO TBD: Caller is expected to maintain parent/child calling order. Parent
* Object must exist before adding sub component(Add Switch -> Port).
* <p/>
* TODO TBD: This class may delay the requested change to handle event
* re-ordering. e.g.) Link Add came in, but Switch was not there.
*/
public class TopologyManager {
private static final Logger log = LoggerFactory
.getLogger(TopologyManager.class);
private IEventChannel<byte[], TopologyEvent> eventChannel;
public static final String EVENT_CHANNEL_NAME = "onos.topology";
private EventHandler eventHandler = new EventHandler();
private final TopologyImpl topology = new TopologyImpl();
private TopologyEventPreprocessor eventPreprocessor;
private CopyOnWriteArrayList<ITopologyListener> topologyListeners =
new CopyOnWriteArrayList<>();
private CopyOnWriteArrayList<ITopologyListener> newTopologyListeners =
new CopyOnWriteArrayList<>();
//
// Metrics
//
private static final MetricsComponent METRICS_COMPONENT =
OnosMetrics.registerComponent("Topology");
private static final MetricsFeature METRICS_FEATURE_EVENT_NOTIFICATION =
METRICS_COMPONENT.registerFeature("EventNotification");
//
// Timestamp of the last Topology event (ms from the Epoch)
private volatile long lastEventTimestampEpochMs = 0;
private final Gauge<Long> gaugeLastEventTimestampEpochMs =
OnosMetrics.registerMetric(METRICS_COMPONENT,
METRICS_FEATURE_EVENT_NOTIFICATION,
"LastEventTimestamp.EpochMs",
new Gauge<Long>() {
@Override
public Long getValue() {
return lastEventTimestampEpochMs;
}
});
// Rate of the Topology events published to the Topology listeners
private final Meter listenerEventRate =
OnosMetrics.createMeter(METRICS_COMPONENT,
METRICS_FEATURE_EVENT_NOTIFICATION,
"ListenerEventRate");
//
// Local state for keeping the last ADD Mastership Event entries.
// TODO: In the future, we might have to keep this state somewhere else.
//
private Map<ByteBuffer, MastershipData> lastAddMastershipDataEntries =
new HashMap<>();
//
// Local state for keeping track of the application event notifications
//
// - Queue of events, which will be dispatched to local listeners
// on next notification.
private List<MastershipData> apiAddedMastershipDataEntries =
new LinkedList<>();
private List<MastershipData> apiRemovedMastershipDataEntries =
new LinkedList<>();
private List<SwitchData> apiAddedSwitchDataEntries = new LinkedList<>();
private List<SwitchData> apiRemovedSwitchDataEntries = new LinkedList<>();
private List<PortData> apiAddedPortDataEntries = new LinkedList<>();
private List<PortData> apiRemovedPortDataEntries = new LinkedList<>();
private List<LinkData> apiAddedLinkDataEntries = new LinkedList<>();
private List<LinkData> apiRemovedLinkDataEntries = new LinkedList<>();
private List<HostData> apiAddedHostDataEntries = new LinkedList<>();
private List<HostData> apiRemovedHostDataEntries = new LinkedList<>();
/**
* Constructor.
*
* @param registryService the Registry Service to use.
*/
public TopologyManager(IControllerRegistryService registryService) {
this.eventPreprocessor =
new TopologyEventPreprocessor(registryService);
}
/**
* Get the MutableTopology.
*
* @return the MutableTopology.
*/
MutableTopology getTopology() {
return topology;
}
/**
* Event handler class.
*/
class EventHandler extends Thread implements
IEventChannelListener<byte[], TopologyEvent> {
private BlockingQueue<EventEntry<TopologyEvent>> topologyEvents =
new LinkedBlockingQueue<EventEntry<TopologyEvent>>();
/**
* Startup processing.
*/
private void startup() {
//
// Read all topology state
//
Collection<TopologyEvent> allTopologyEvents =
eventChannel.getAllEntries();
List<EventEntry<TopologyEvent>> events =
new LinkedList<EventEntry<TopologyEvent>>();
for (TopologyEvent topologyEvent : allTopologyEvents) {
EventEntry<TopologyEvent> eventEntry =
new EventEntry<TopologyEvent>(EventEntry.Type.ENTRY_ADD,
topologyEvent);
events.add(eventEntry);
}
processEvents(events);
}
/**
* Run the thread.
*/
@Override
public void run() {
List<EventEntry<TopologyEvent>> events =
new LinkedList<EventEntry<TopologyEvent>>();
this.setName("TopologyManager.EventHandler " + this.getId());
startup();
//
// The main loop
//
while (true) {
try {
EventEntry<TopologyEvent> eventEntry =
topologyEvents.take();
events.add(eventEntry);
topologyEvents.drainTo(events);
processEvents(events);
events.clear();
} catch (Exception exception) {
log.debug("Exception processing Topology Events: ",
exception);
}
}
}
/**
* Process all topology events.
*
* @param events the events to process.
*/
private void processEvents(List<EventEntry<TopologyEvent>> events) {
//
// Process pending (new) listeners
//
processPendingListeners();
//
// Pre-process the events
//
events = eventPreprocessor.processEvents(events);
//
// Lock the topology while it is modified
//
topology.acquireWriteLock();
try {
// Apply the events
//
// NOTE: The events are suppose to be in the proper order
// to naturally build and update the topology.
//
for (EventEntry<TopologyEvent> event : events) {
// Ignore NO-OP events
if (event.isNoop()) {
continue;
}
TopologyEvent topologyEvent = event.eventData();
// Get the event itself
MastershipData mastershipData =
topologyEvent.getMastershipData();
SwitchData switchData = topologyEvent.getSwitchData();
PortData portData = topologyEvent.getPortData();
LinkData linkData = topologyEvent.getLinkData();
HostData hostData = topologyEvent.getHostData();
boolean wasAdded = false;
//
// Extract the events
//
switch (event.eventType()) {
case ENTRY_ADD:
if (mastershipData != null) {
wasAdded = addMastershipData(mastershipData);
}
if (switchData != null) {
wasAdded = addSwitch(switchData);
}
if (portData != null) {
wasAdded = addPort(portData);
}
if (linkData != null) {
wasAdded = addLink(linkData);
}
if (hostData != null) {
wasAdded = addHost(hostData);
}
// If the item wasn't added, probably it was reordered
if (!wasAdded) {
ByteBuffer id = topologyEvent.getIDasByteBuffer();
eventPreprocessor.reorderedEvents.put(id, topologyEvent);
}
break;
case ENTRY_REMOVE:
if (mastershipData != null) {
removeMastershipData(mastershipData);
}
if (switchData != null) {
removeSwitch(switchData);
}
if (portData != null) {
removePort(portData);
}
if (linkData != null) {
removeLink(linkData);
}
if (hostData != null) {
removeHost(hostData);
}
break;
default:
log.error("Unknown topology event {}",
event.eventType());
}
}
} finally {
//
// Topology modifications completed: Release the lock
//
topology.releaseWriteLock();
}
//
// Dispatch the Topology Notification Events to the applications
//
dispatchTopologyEvents();
}
/**
* Receive a notification that an entry is added.
*
* @param value the value for the entry.
*/
@Override
public void entryAdded(TopologyEvent value) {
EventEntry<TopologyEvent> eventEntry =
new EventEntry<TopologyEvent>(EventEntry.Type.ENTRY_ADD,
value);
topologyEvents.add(eventEntry);
}
/**
* Receive a notification that an entry is removed.
*
* @param value the value for the entry.
*/
@Override
public void entryRemoved(TopologyEvent value) {
EventEntry<TopologyEvent> eventEntry =
new EventEntry<TopologyEvent>(EventEntry.Type.ENTRY_REMOVE,
value);
topologyEvents.add(eventEntry);
}
/**
* Receive a notification that an entry is updated.
*
* @param value the value for the entry.
*/
@Override
public void entryUpdated(TopologyEvent value) {
// NOTE: The ADD and UPDATE events are processed in same way
entryAdded(value);
}
/**
* Informs the event handler that a new listener has been added,
* and that listener expects the first event to be a snapshot of the
* current topology.
*/
void listenerAdded() {
//
// Generate a NO-OP event so the Event Handler processing can be
// triggered to generate in-order a snapshot of the current
// topology.
// TODO: This is a hack.
//
EventEntry<TopologyEvent> eventEntry = EventEntry.makeNoop();
topologyEvents.add(eventEntry);
}
}
/**
* Startup processing.
*
* @param datagridService the datagrid service to use.
*/
void startup(IDatagridService datagridService) {
eventChannel = datagridService.addListener(EVENT_CHANNEL_NAME,
eventHandler,
byte[].class,
TopologyEvent.class);
eventHandler.start();
}
/**
* Adds a listener for topology events.
*
* @param listener the listener to add.
* @param startFromSnapshot if true, and if the topology is not
* empty, the first event should be a snapshot of the current topology.
*/
void addListener(ITopologyListener listener, boolean startFromSnapshot) {
if (startFromSnapshot) {
newTopologyListeners.addIfAbsent(listener);
eventHandler.listenerAdded();
} else {
topologyListeners.addIfAbsent(listener);
}
}
/**
* Removes a listener for topology events. The listener will no longer
* receive topology events after this call.
*
* @param listener the listener to remove.
*/
void removeListener(ITopologyListener listener) {
topologyListeners.remove(listener);
newTopologyListeners.remove(listener);
}
/**
* Processes pending (new) listeners.
* <p>
* During the processing, we dispatch Topology Snapshot Events to new
* listeners.
*/
private void processPendingListeners() {
if (newTopologyListeners.isEmpty()) {
return;
}
//
// Create the Topology Snapshot Event
//
TopologyEvents events = null;
Collection<MastershipData> mastershipDataEntries =
lastAddMastershipDataEntries.values();
Collection<SwitchData> switchDataEntries = topology.getAllSwitchDataEntries();
Collection<PortData> portDataEntries = topology.getAllPortDataEntries();
Collection<LinkData> linkDataEntries = topology.getAllLinkDataEntries();
Collection<HostData> hostDataEntries = topology.getAllHostDataEntries();
if (!(mastershipDataEntries.isEmpty() &&
switchDataEntries.isEmpty() &&
portDataEntries.isEmpty() &&
linkDataEntries.isEmpty() &&
hostDataEntries.isEmpty())) {
events = new TopologyEvents(mastershipDataEntries,
switchDataEntries,
portDataEntries,
linkDataEntries,
hostDataEntries);
}
//
// Dispatch Snapshot Event to each new listener, and keep track
// of each processed listener.
//
// NOTE: We deliver the event only if it is not empty.
// NOTE: We need to execute the loop so we can properly
// move the new listeners together with the older listeners.
//
List<ITopologyListener> processedListeners = new LinkedList<>();
for (ITopologyListener listener : newTopologyListeners) {
processedListeners.add(listener);
// Move the new listener together with the rest of the listeners
topologyListeners.addIfAbsent(listener);
// Dispatch the event
if (events != null) {
listener.topologyEvents(events);
}
}
newTopologyListeners.removeAll(processedListeners);
}
/**
* Dispatch Topology Events to the listeners.
*/
private void dispatchTopologyEvents() {
if (apiAddedMastershipDataEntries.isEmpty() &&
apiRemovedMastershipDataEntries.isEmpty() &&
apiAddedSwitchDataEntries.isEmpty() &&
apiRemovedSwitchDataEntries.isEmpty() &&
apiAddedPortDataEntries.isEmpty() &&
apiRemovedPortDataEntries.isEmpty() &&
apiAddedLinkDataEntries.isEmpty() &&
apiRemovedLinkDataEntries.isEmpty() &&
apiAddedHostDataEntries.isEmpty() &&
apiRemovedHostDataEntries.isEmpty()) {
return; // No events to dispatch
}
if (log.isDebugEnabled()) {
//
// Debug statements
// TODO: Those statements should be removed in the future
//
for (MastershipData mastershipData : apiAddedMastershipDataEntries) {
log.debug("Dispatch Topology Event: ADDED {}",
mastershipData);
}
for (MastershipData mastershipData : apiRemovedMastershipDataEntries) {
log.debug("Dispatch Topology Event: REMOVED {}",
mastershipData);
}
for (SwitchData switchData : apiAddedSwitchDataEntries) {
log.debug("Dispatch Topology Event: ADDED {}", switchData);
}
for (SwitchData switchData : apiRemovedSwitchDataEntries) {
log.debug("Dispatch Topology Event: REMOVED {}", switchData);
}
for (PortData portData : apiAddedPortDataEntries) {
log.debug("Dispatch Topology Event: ADDED {}", portData);
}
for (PortData portData : apiRemovedPortDataEntries) {
log.debug("Dispatch Topology Event: REMOVED {}", portData);
}
for (LinkData linkData : apiAddedLinkDataEntries) {
log.debug("Dispatch Topology Event: ADDED {}", linkData);
}
for (LinkData linkData : apiRemovedLinkDataEntries) {
log.debug("Dispatch Topology Event: REMOVED {}", linkData);
}
for (HostData hostData : apiAddedHostDataEntries) {
log.debug("Dispatch Topology Event: ADDED {}", hostData);
}
for (HostData hostData : apiRemovedHostDataEntries) {
log.debug("Dispatch Topology Event: REMOVED {}", hostData);
}
}
//
// Update the metrics
//
long totalEvents =
apiAddedMastershipDataEntries.size() + apiRemovedMastershipDataEntries.size() +
apiAddedSwitchDataEntries.size() + apiRemovedSwitchDataEntries.size() +
apiAddedPortDataEntries.size() + apiRemovedPortDataEntries.size() +
apiAddedLinkDataEntries.size() + apiRemovedLinkDataEntries.size() +
apiAddedHostDataEntries.size() + apiRemovedHostDataEntries.size();
this.listenerEventRate.mark(totalEvents);
this.lastEventTimestampEpochMs = System.currentTimeMillis();
//
// Allocate the events to deliver.
//
TopologyEvents events = new TopologyEvents(
apiAddedMastershipDataEntries,
apiRemovedMastershipDataEntries,
apiAddedSwitchDataEntries,
apiRemovedSwitchDataEntries,
apiAddedPortDataEntries,
apiRemovedPortDataEntries,
apiAddedLinkDataEntries,
apiRemovedLinkDataEntries,
apiAddedHostDataEntries,
apiRemovedHostDataEntries);
//
// Deliver the events
//
for (ITopologyListener listener : this.topologyListeners) {
listener.topologyEvents(events);
}
//
// Cleanup
//
apiAddedMastershipDataEntries.clear();
apiRemovedMastershipDataEntries.clear();
apiAddedSwitchDataEntries.clear();
apiRemovedSwitchDataEntries.clear();
apiAddedPortDataEntries.clear();
apiRemovedPortDataEntries.clear();
apiAddedLinkDataEntries.clear();
apiRemovedLinkDataEntries.clear();
apiAddedHostDataEntries.clear();
apiRemovedHostDataEntries.clear();
}
//
// Methods to update topology replica
//
/**
* Adds Switch Mastership event.
*
* @param mastershipData the MastershipData to process.
* @return true if the item was successfully added, otherwise false.
*/
@GuardedBy("topology.writeLock")
private boolean addMastershipData(MastershipData mastershipData) {
log.debug("Added Mastership event {}", mastershipData);
lastAddMastershipDataEntries.put(mastershipData.getIDasByteBuffer(),
mastershipData);
apiAddedMastershipDataEntries.add(mastershipData);
return true;
}
/**
* Removes Switch Mastership event.
*
* @param mastershipData the MastershipData to process.
*/
@GuardedBy("topology.writeLock")
private void removeMastershipData(MastershipData mastershipData) {
log.debug("Removed Mastership event {}", mastershipData);
lastAddMastershipDataEntries.remove(mastershipData.getIDasByteBuffer());
apiRemovedMastershipDataEntries.add(mastershipData);
}
/**
* Adds a switch to the topology replica.
*
* @param switchData the SwitchData with the switch to add.
* @return true if the item was successfully added, otherwise false.
*/
@GuardedBy("topology.writeLock")
private boolean addSwitch(SwitchData switchData) {
if (log.isDebugEnabled()) {
SwitchData sw = topology.getSwitchData(switchData.getDpid());
if (sw != null) {
log.debug("Update {}", switchData);
} else {
log.debug("Added {}", switchData);
}
}
topology.putSwitch(switchData.freeze());
apiAddedSwitchDataEntries.add(switchData);
return true;
}
/**
* Removes a switch from the topology replica.
* <p/>
* It will call {@link #removePort(PortData)} for each ports on this
* switch.
*
* @param switchData the SwitchData with the switch to remove.
*/
@GuardedBy("topology.writeLock")
private void removeSwitch(SwitchData switchData) {
final Dpid dpid = switchData.getDpid();
SwitchData swInTopo = topology.getSwitchData(dpid);
if (swInTopo == null) {
log.warn("Switch {} already removed, ignoring", switchData);
return;
}
//
// Remove all Ports on the Switch
//
ArrayList<PortData> portsToRemove = new ArrayList<>();
for (Port port : topology.getPorts(dpid)) {
log.warn("Port {} on Switch {} should be removed prior to removing Switch. Removing Port now.",
port, switchData);
PortData portData = new PortData(port.getSwitchPort());
portsToRemove.add(portData);
}
for (PortData portData : portsToRemove) {
removePort(portData);
}
log.debug("Removed {}", swInTopo);
topology.removeSwitch(dpid);
apiRemovedSwitchDataEntries.add(swInTopo);
}
/**
* Adds a port to the topology replica.
*
* @param portData the PortData with the port to add.
* @return true if the item was successfully added, otherwise false.
*/
@GuardedBy("topology.writeLock")
private boolean addPort(PortData portData) {
Switch sw = topology.getSwitch(portData.getDpid());
if (sw == null) {
// Reordered event
log.debug("{} reordered because switch is null", portData);
return false;
}
if (log.isDebugEnabled()) {
PortData port = topology.getPortData(portData.getSwitchPort());
if (port != null) {
log.debug("Update {}", portData);
} else {
log.debug("Added {}", portData);
}
}
topology.putPort(portData.freeze());
apiAddedPortDataEntries.add(portData);
return true;
}
/**
* Removes a port from the topology replica.
* <p/>
* It will remove attachment points from each hosts on this port
* and call {@link #removeLink(LinkData)} for each links on this port.
*
* @param portData the PortData with the port to remove.
*/
@GuardedBy("topology.writeLock")
private void removePort(PortData portData) {
SwitchData sw = topology.getSwitchData(portData.getDpid());
if (sw == null) {
log.warn("Parent Switch for Port {} already removed, ignoring",
portData);
return;
}
final SwitchPort switchPort = portData.getSwitchPort();
PortData portInTopo = topology.getPortData(switchPort);
if (portInTopo == null) {
log.warn("Port {} already removed, ignoring", portData);
return;
}
//
// Remove all Host attachment points bound to this Port
//
List<HostData> hostsToUpdate = new ArrayList<>();
for (Host host : topology.getHosts(switchPort)) {
log.debug("Removing Host {} on Port {}", host, portInTopo);
HostData hostData = topology.getHostData(host.getMacAddress());
hostsToUpdate.add(hostData);
}
for (HostData hostData : hostsToUpdate) {
HostData newHostData = new HostData(hostData);
newHostData.removeAttachmentPoint(switchPort);
newHostData.freeze();
// TODO should this event be fired inside #addHost?
if (newHostData.getAttachmentPoints().isEmpty()) {
// No more attachment point left -> remove Host
removeHost(hostData);
} else {
// Update Host
addHost(newHostData);
}
}
//
// Remove all Links connected to the Port
//
Set<Link> links = new HashSet<>();
links.addAll(topology.getOutgoingLinks(switchPort));
links.addAll(topology.getIncomingLinks(switchPort));
for (Link link : links) {
if (link == null) {
continue;
}
LinkData linkData = topology.getLinkData(link.getLinkTuple());
if (linkData != null) {
log.debug("Removing Link {} on Port {}", link, portInTopo);
removeLink(linkData);
}
}
// Remove the Port from Topology
log.debug("Removed {}", portInTopo);
topology.removePort(switchPort);
apiRemovedPortDataEntries.add(portInTopo);
}
/**
* Adds a link to the topology replica.
* <p/>
* It will remove attachment points from each hosts using the same ports.
*
* @param linkData the LinkData with the link to add.
* @return true if the item was successfully added, otherwise false.
*/
@GuardedBy("topology.writeLock")
private boolean addLink(LinkData linkData) {
PortData srcPort = topology.getPortData(linkData.getSrc());
PortData dstPort = topology.getPortData(linkData.getDst());
if ((srcPort == null) || (dstPort == null)) {
// Reordered event
log.debug("{} reordered because {} port is null", linkData,
(srcPort == null) ? "src" : "dst");
return false;
}
//
// XXX domain knowledge: Sanity check: Port cannot have both Link and
// Host.
//
// FIXME: Potentially local replica may not be up-to-date yet due to
// Hazelcast delay.
// FIXME: May need to manage local truth and use them instead.
//
if (topology.getLinkData(linkData.getLinkTuple()) == null) {
// Only check for existing Host when adding new Link.
// Remove all Hosts attached to the ports on both ends
Set<HostData> hostsToUpdate =
new TreeSet<>(new Comparator<HostData>() {
// Comparison only using ID(=MAC)
@Override
public int compare(HostData o1, HostData o2) {
return Long.compare(o1.getMac().toLong(), o2.getMac().toLong());
}
});
List<SwitchPort> portsToCheck = Arrays.asList(
srcPort.getSwitchPort(),
dstPort.getSwitchPort());
// Enumerate Host which needs to be updated by this Link add event
for (SwitchPort port : portsToCheck) {
for (Host host : topology.getHosts(port)) {
log.error("Host {} on Port {} should have been removed prior to adding Link {}",
host, port, linkData);
HostData hostData =
topology.getHostData(host.getMacAddress());
hostsToUpdate.add(hostData);
}
}
// Remove attachment point from them
for (HostData hostData : hostsToUpdate) {
// Remove port from attachment point and update
HostData newHostData = new HostData(hostData);
newHostData.removeAttachmentPoint(srcPort.getSwitchPort());
newHostData.removeAttachmentPoint(dstPort.getSwitchPort());
newHostData.freeze();
// TODO should this event be fired inside #addHost?
if (newHostData.getAttachmentPoints().isEmpty()) {
// No more attachment point left -> remove Host
removeHost(hostData);
} else {
// Update Host
addHost(newHostData);
}
}
}
if (log.isDebugEnabled()) {
LinkData link = topology.getLinkData(linkData.getLinkTuple());
if (link != null) {
log.debug("Update {}", linkData);
} else {
log.debug("Added {}", linkData);
}
}
topology.putLink(linkData.freeze());
apiAddedLinkDataEntries.add(linkData);
return true;
}
/**
* Removes a link from the topology replica.
*
* @param linkData the LinkData with the link to remove.
*/
@GuardedBy("topology.writeLock")
private void removeLink(LinkData linkData) {
Port srcPort = topology.getPort(linkData.getSrc().getDpid(),
linkData.getSrc().getPortNumber());
if (srcPort == null) {
log.warn("Src Port for Link {} already removed, ignoring",
linkData);
return;
}
Port dstPort = topology.getPort(linkData.getDst().getDpid(),
linkData.getDst().getPortNumber());
if (dstPort == null) {
log.warn("Dst Port for Link {} already removed, ignoring",
linkData);
return;
}
LinkData linkInTopo = topology.getLinkData(linkData.getLinkTuple(),
linkData.getType());
if (linkInTopo == null) {
log.warn("Link {} already removed, ignoring", linkData);
return;
}
if (log.isDebugEnabled()) {
// only do sanity check on debug level
Link linkIn = dstPort.getIncomingLink(linkData.getType());
if (linkIn == null) {
log.warn("Link {} already removed on destination Port",
linkData);
}
Link linkOut = srcPort.getOutgoingLink(linkData.getType());
if (linkOut == null) {
log.warn("Link {} already removed on src Port", linkData);
}
}
log.debug("Removed {}", linkInTopo);
topology.removeLink(linkData.getLinkTuple(), linkData.getType());
apiRemovedLinkDataEntries.add(linkInTopo);
}
/**
* Adds a host to the topology replica.
* <p/>
* TODO: Host-related work is incomplete.
* TODO: Eventually, we might need to consider reordering
* or {@link #addLink(LinkData)} and {@link #addHost(HostData)} events
* on the same port.
*
* @param hostData the HostData with the host to add.
* @return true if the item was successfully added, otherwise false.
*/
@GuardedBy("topology.writeLock")
private boolean addHost(HostData hostData) {
// TODO Decide how to handle update scenario.
// If the new HostData has less attachment point compared to
// existing HostData, what should the event be?
// - Add HostData with some attachment point removed? (current behavior)
// create unfrozen copy
// for removing attachment points which already has a link
HostData modifiedHostData = new HostData(hostData);
// Verify each attachment point
boolean attachmentFound = false;
for (SwitchPort swp : hostData.getAttachmentPoints()) {
// XXX domain knowledge: Port must exist before Host
// but this knowledge cannot be pushed down to driver.
// Attached Ports must exist
Port port = topology.getPort(swp.getDpid(), swp.getPortNumber());
if (port == null) {
log.debug("{} reordered because port {} was not there",
hostData, swp);
// Reordered event
return false; // should not continue if re-applying later
}
// Attached Ports must not have Link
if (port.getOutgoingLink() != null ||
port.getIncomingLink() != null) {
log.warn("Link (Out:{},In:{}) exist on the attachment point. "
+ "Ignoring this attachmentpoint ({}) from {}.",
port.getOutgoingLink(), port.getIncomingLink(),
swp, modifiedHostData);
// FIXME Should either reject, reorder this HostData,
// or remove attachment point from given HostData
// Removing attachment point from given HostData for now.
modifiedHostData.removeAttachmentPoint(swp);
continue;
}
attachmentFound = true;
}
// Update the host in the topology
if (attachmentFound) {
if (modifiedHostData.getAttachmentPoints().isEmpty()) {
log.warn("No valid attachment point left. Ignoring."
+ "original: {}, modified: {}",
hostData, modifiedHostData);
// TODO Should we call #removeHost to trigger remove event?
// only if this call is update.
return false;
}
if (log.isDebugEnabled()) {
HostData host = topology.getHostData(hostData.getMac());
if (host != null) {
log.debug("Update {}", modifiedHostData);
} else {
log.debug("Added {}", modifiedHostData);
}
}
topology.putHost(modifiedHostData.freeze());
apiAddedHostDataEntries.add(modifiedHostData);
return true;
}
return false;
}
/**
* Removes a host from the topology replica.
* <p/>
* TODO: Host-related work is incomplete.
*
* @param hostData the Host Event with the host to remove.
*/
@GuardedBy("topology.writeLock")
private void removeHost(HostData hostData) {
final MACAddress mac = hostData.getMac();
HostData hostInTopo = topology.getHostData(mac);
if (hostInTopo == null) {
log.warn("Host {} already removed, ignoring", hostData);
return;
}
log.debug("Removed {}", hostInTopo);
topology.removeHost(mac);
apiRemovedHostDataEntries.add(hostInTopo);
}
}