Fixing tabs and indents - no code change
Change-Id: I4b889b5393ae0ee96165286d72a9e104c17fd4c8
diff --git a/src/main/java/net/floodlightcontroller/core/internal/Controller.java b/src/main/java/net/floodlightcontroller/core/internal/Controller.java
index b47962f..8c7c589 100644
--- a/src/main/java/net/floodlightcontroller/core/internal/Controller.java
+++ b/src/main/java/net/floodlightcontroller/core/internal/Controller.java
@@ -98,10 +98,9 @@
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-
/**
- * The main controller class. Handles all setup and network listeners
- * - Distributed ownership control of switch through IControllerRegistryService
+ * The main controller class. Handles all setup and network listeners -
+ * Distributed ownership control of switch through IControllerRegistryService
*/
public class Controller implements IFloodlightProviderService {
@@ -126,8 +125,7 @@
protected HashMap<String, String> controllerNodeIPsCache;
protected BlockingQueue<IUpdate> updates;
- protected ConcurrentMap<OFType,
- ListenerDispatcher<OFType, IOFMessageListener>> messageListeners;
+ protected ConcurrentMap<OFType, ListenerDispatcher<OFType, IOFMessageListener>> messageListeners;
protected Set<IOFSwitchListener> switchListeners;
// Module dependencies
@@ -154,7 +152,7 @@
// Load monitor for overload protection
protected final boolean overload_drop =
- Boolean.parseBoolean(System.getProperty("overload_drop", "false"));
+ Boolean.parseBoolean(System.getProperty("overload_drop", "false"));
protected final LoadMonitor loadmonitor = new LoadMonitor(log);
// Start time of the controller
@@ -168,35 +166,37 @@
protected static final int BATCH_MAX_SIZE = 100;
protected static final boolean ALWAYS_DECODE_ETH = true;
-
-
// ******************************
// Switch Management and Updates
// ******************************
/**
- * Switch updates are sent to all IOFSwitchListeners. A switch that is connected
- * to this controller instance, but not activated, is not available for updates.
- *
- * In ONOS, each controller instance can simultaneously serve in a MASTER role
- * for some connected switches, and in a EQUAL role for other connected switches.
- * The EQUAL role can be treated as a SLAVE role, by ensuring that the
- * controller instance never sends packets or commands out to the switch.
- * Activated switches, either with Controller Role MASTER or EQUAL are announced
- * as updates. We also support announcements of controller role transitions
- * from MASTER --> EQUAL, and EQUAL --> MASTER, for an individual switch.
- *
+ * Switch updates are sent to all IOFSwitchListeners. A switch that is
+ * connected to this controller instance, but not activated, is not
+ * available for updates.
+ *
+ * In ONOS, each controller instance can simultaneously serve in a MASTER
+ * role for some connected switches, and in a EQUAL role for other connected
+ * switches. The EQUAL role can be treated as a SLAVE role, by ensuring that
+ * the controller instance never sends packets or commands out to the
+ * switch. Activated switches, either with Controller Role MASTER or EQUAL
+ * are announced as updates. We also support announcements of controller
+ * role transitions from MASTER --> EQUAL, and EQUAL --> MASTER, for an
+ * individual switch.
+ *
* Disconnection of only activated switches are announced. Finally, changes
* to switch ports are announced with a portChangeType (see @IOFSwitch)
- *
+ *
* @author saurav
*/
public enum SwitchUpdateType {
/** switch activated with this controller's role as MASTER */
ACTIVATED_MASTER,
- /** switch activated with this controller's role as EQUAL.
- * listener can treat this controller's role as SLAVE by not
- * sending packets or commands to the switch */
+ /**
+ * switch activated with this controller's role as EQUAL. listener can
+ * treat this controller's role as SLAVE by not sending packets or
+ * commands to the switch
+ */
ACTIVATED_EQUAL,
/** this controller's role for this switch changed from Master to Equal */
MASTER_TO_EQUAL,
@@ -209,8 +209,8 @@
}
/**
- * Update message indicating a switch was added or removed
- * ONOS: This message extended to indicate Port add or removed event.
+ * Update message indicating a switch was added or removed ONOS: This
+ * message extended to indicate Port add or removed event.
*/
protected class SwitchUpdate implements IUpdate {
public long getSwId() {
@@ -233,10 +233,11 @@
public SwitchUpdate(long swId, SwitchUpdateType switchUpdateType) {
this(swId, switchUpdateType, null, null);
}
+
public SwitchUpdate(long swId,
- SwitchUpdateType switchUpdateType,
- OFPortDesc port,
- PortChangeType changeType) {
+ SwitchUpdateType switchUpdateType,
+ OFPortDesc port,
+ PortChangeType changeType) {
if (switchUpdateType == SwitchUpdateType.PORTCHANGED) {
if (port == null) {
throw new NullPointerException("Port must not be null " +
@@ -267,38 +268,37 @@
}
if (switchListeners != null) {
for (IOFSwitchListener listener : switchListeners) {
- switch(switchUpdateType) {
- case ACTIVATED_MASTER:
- // don't count here. We have more specific
- // counters before the update is created
- listener.switchActivatedMaster(swId);
- break;
- case ACTIVATED_EQUAL:
- // don't count here. We have more specific
- // counters before the update is created
- listener.switchActivatedEqual(swId);
- break;
- case MASTER_TO_EQUAL:
- listener.switchMasterToEqual(swId);
- break;
- case EQUAL_TO_MASTER:
- listener.switchEqualToMaster(swId);
- break;
- case DISCONNECTED:
- // don't count here. We have more specific
- // counters before the update is created
- listener.switchDisconnected(swId);
- break;
- case PORTCHANGED:
- counters.switchPortChanged.updateCounterWithFlush();
- listener.switchPortChanged(swId, port, changeType);
- break;
+ switch (switchUpdateType) {
+ case ACTIVATED_MASTER:
+ // don't count here. We have more specific
+ // counters before the update is created
+ listener.switchActivatedMaster(swId);
+ break;
+ case ACTIVATED_EQUAL:
+ // don't count here. We have more specific
+ // counters before the update is created
+ listener.switchActivatedEqual(swId);
+ break;
+ case MASTER_TO_EQUAL:
+ listener.switchMasterToEqual(swId);
+ break;
+ case EQUAL_TO_MASTER:
+ listener.switchEqualToMaster(swId);
+ break;
+ case DISCONNECTED:
+ // don't count here. We have more specific
+ // counters before the update is created
+ listener.switchDisconnected(swId);
+ break;
+ case PORTCHANGED:
+ counters.switchPortChanged.updateCounterWithFlush();
+ listener.switchPortChanged(swId, port, changeType);
+ break;
}
}
}
}
-
}
protected boolean addConnectedSwitch(long dpid, OFChannelHandler h) {
@@ -313,7 +313,7 @@
}
/**
- * Switch Events
+ * Switch Events
*/
@Override
public void addSwitchEvent(long dpid, String reason, boolean flushNow) {
@@ -335,9 +335,9 @@
log.error("Trying to activate switch but it is already "
+ "activated: dpid {}. Found in activeMaster: {} "
+ "Found in activeEqual: {}. Aborting ..", new Object[] {
- HexString.toHexString(dpid),
- (activeMasterSwitches.get(dpid) == null)? 'Y': 'N',
- (activeEqualSwitches.get(dpid) == null)? 'Y': 'N'});
+ HexString.toHexString(dpid),
+ (activeMasterSwitches.get(dpid) == null) ? 'Y' : 'N',
+ (activeEqualSwitches.get(dpid) == null) ? 'Y' : 'N'});
counters.switchWithSameDpidActivated.updateCounterWithFlush();
return false;
}
@@ -348,8 +348,9 @@
* Called when a switch is activated, with this controller's role as MASTER
*/
protected boolean addActivatedMasterSwitch(long dpid, IOFSwitch sw) {
- synchronized(multiCacheLock) {
- if (!validActivation(dpid)) return false;
+ synchronized (multiCacheLock) {
+ if (!validActivation(dpid))
+ return false;
activeMasterSwitches.put(dpid, sw);
}
// XXX Workaround to prevent race condition where a link is detected
@@ -360,7 +361,7 @@
linkDiscovery.disableDiscoveryOnPort(sw.getId(),
port.getPortNo().getShortPortNumber());
}
- //update counters and events
+ // update counters and events
counters.switchActivated.updateCounterWithFlush();
evSwitch.updateEventWithFlush(new SwitchEvent(dpid, "activeMaster"));
addUpdateToQueue(new SwitchUpdate(dpid,
@@ -372,11 +373,12 @@
* Called when a switch is activated, with this controller's role as EQUAL
*/
protected boolean addActivatedEqualSwitch(long dpid, IOFSwitch sw) {
- synchronized(multiCacheLock) {
- if (!validActivation(dpid)) return false;
+ synchronized (multiCacheLock) {
+ if (!validActivation(dpid))
+ return false;
activeEqualSwitches.put(dpid, sw);
}
- //update counters and events
+ // update counters and events
counters.switchActivated.updateCounterWithFlush();
evSwitch.updateEventWithFlush(new SwitchEvent(dpid, "activeEqual"));
addUpdateToQueue(new SwitchUpdate(dpid,
@@ -385,54 +387,54 @@
}
/**
- * Called when this controller's role for a switch transitions from equal
- * to master. For 1.0 switches, we internally refer to the role 'slave' as
+ * Called when this controller's role for a switch transitions from equal to
+ * master. For 1.0 switches, we internally refer to the role 'slave' as
* 'equal' - so this transition is equivalent to 'addActivatedMasterSwitch'.
*/
protected void transitionToMasterSwitch(long dpid) {
- synchronized(multiCacheLock) {
- IOFSwitch sw = activeEqualSwitches.remove(dpid);
- if (sw == null) {
- log.error("Transition to master called on sw {}, but switch "
- + "was not found in controller-cache", dpid);
- return;
- }
- activeMasterSwitches.put(dpid, sw);
- }
- addUpdateToQueue(new SwitchUpdate(dpid,
+ synchronized (multiCacheLock) {
+ IOFSwitch sw = activeEqualSwitches.remove(dpid);
+ if (sw == null) {
+ log.error("Transition to master called on sw {}, but switch "
+ + "was not found in controller-cache", dpid);
+ return;
+ }
+ activeMasterSwitches.put(dpid, sw);
+ }
+ addUpdateToQueue(new SwitchUpdate(dpid,
SwitchUpdateType.EQUAL_TO_MASTER));
}
-
/**
- * Called when this controller's role for a switch transitions to equal.
- * For 1.0 switches, we internally refer to the role 'slave' as
- * 'equal'.
+ * Called when this controller's role for a switch transitions to equal. For
+ * 1.0 switches, we internally refer to the role 'slave' as 'equal'.
*/
protected void transitionToEqualSwitch(long dpid) {
- synchronized(multiCacheLock) {
- IOFSwitch sw = activeMasterSwitches.remove(dpid);
- if (sw == null) {
- log.error("Transition to equal called on sw {}, but switch "
- + "was not found in controller-cache", dpid);
- return;
- }
- activeEqualSwitches.put(dpid, sw);
- }
- addUpdateToQueue(new SwitchUpdate(dpid,
+ synchronized (multiCacheLock) {
+ IOFSwitch sw = activeMasterSwitches.remove(dpid);
+ if (sw == null) {
+ log.error("Transition to equal called on sw {}, but switch "
+ + "was not found in controller-cache", dpid);
+ return;
+ }
+ activeEqualSwitches.put(dpid, sw);
+ }
+ addUpdateToQueue(new SwitchUpdate(dpid,
SwitchUpdateType.MASTER_TO_EQUAL));
}
/**
* Clear all state in controller switch maps for a switch that has
- * disconnected from the local controller. Also release control for
- * that switch from the global repository. Notify switch listeners.
+ * disconnected from the local controller. Also release control for that
+ * switch from the global repository. Notify switch listeners.
*/
protected void removeConnectedSwitch(long dpid) {
releaseRegistryControl(dpid);
connectedSwitches.remove(dpid);
IOFSwitch sw = activeMasterSwitches.remove(dpid);
- if (sw == null) sw = activeEqualSwitches.remove(dpid);
+ if (sw == null) {
+ sw = activeEqualSwitches.remove(dpid);
+ }
if (sw != null) {
sw.cancelAllStatisticsReplies();
sw.setConnected(false); // do we need this?
@@ -443,8 +445,9 @@
}
/**
- * Indicates that ports on the given switch have changed. Enqueue a
- * switch update.
+ * Indicates that ports on the given switch have changed. Enqueue a switch
+ * update.
+ *
* @param sw
*/
protected void notifyPortChanged(long dpid, OFPortDesc port,
@@ -465,7 +468,8 @@
// and attempted to be written to the database before the port is in
// the database. We now suppress link discovery on ports until we're
// sure they're in the database.
- linkDiscovery.disableDiscoveryOnPort(dpid, port.getPortNo().getShortPortNumber());
+ linkDiscovery.disableDiscoveryOnPort(dpid, port.getPortNo()
+ .getShortPortNumber());
}
SwitchUpdate update = new SwitchUpdate(dpid, SwitchUpdateType.PORTCHANGED,
@@ -509,7 +513,8 @@
// Role Handling
// **********************
- /** created by ONOS - works with registry service
+ /**
+ * created by ONOS - works with registry service
*/
protected class RoleChangeCallback implements ControlChangeCallback {
@Override
@@ -552,7 +557,7 @@
HexString.toHexString(dpid));
// FIXME shouldn't we immediately return here?
}
- //Request control of the switch from the global registry
+ // Request control of the switch from the global registry
try {
h.controlRequested = Boolean.TRUE;
registryService.requestControl(dpid, new RoleChangeCallback());
@@ -567,7 +572,8 @@
} catch (InterruptedException e) {
// Ignore interruptions
}
- // safer to bounce the switch to reconnect here than proceeding further
+ // safer to bounce the switch to reconnect here than proceeding
+ // further
// XXX S why? can't we just try again a little later?
log.debug("Closing sw:{} because we weren't able to request control " +
"successfully" + dpid);
@@ -588,25 +594,24 @@
}
}
-
// *******************
// OF Message Handling
// *******************
/**
- *
* Handle and dispatch a message to IOFMessageListeners.
- *
- * We only dispatch messages to listeners if the controller's role is MASTER.
- *
+ *
+ * We only dispatch messages to listeners if the controller's role is
+ * MASTER.
+ *
* @param sw The switch sending the message
* @param m The message the switch sent
- * @param flContext The floodlight context to use for this message. If
- * null, a new context will be allocated.
+ * @param flContext The floodlight context to use for this message. If null,
+ * a new context will be allocated.
* @throws IOException
- *
- * FIXME: this method and the ChannelHandler disagree on which messages
- * should be dispatched and which shouldn't
+ *
+ * FIXME: this method and the ChannelHandler disagree on which
+ * messages should be dispatched and which shouldn't
*/
@LogMessageDocs({
@LogMessageDoc(level = "ERROR",
@@ -620,114 +625,115 @@
explanation = "The switch sent a message not handled by " +
"the controller")
})
- @SuppressWarnings({ "fallthrough", "unchecked" })
+ @SuppressWarnings({"fallthrough", "unchecked"})
protected void handleMessage(IOFSwitch sw, OFMessage m,
- FloodlightContext bContext)
+ FloodlightContext bContext)
throws IOException {
Ethernet eth = null;
short inport = -1;
switch (m.getType()) {
- case PACKET_IN:
- OFPacketIn pi = (OFPacketIn) m;
- //log.info("saw packet in from sw {}", sw.getStringId());
- if (pi.getData().length <= 0) {
- log.error("Ignoring PacketIn (Xid = " + pi.getXid() +
- ") because/* the data field is empty.");
+ case PACKET_IN:
+ OFPacketIn pi = (OFPacketIn) m;
+ // log.info("saw packet in from sw {}", sw.getStringId());
+ if (pi.getData().length <= 0) {
+ log.error("Ignoring PacketIn (Xid = " + pi.getXid() +
+ ") because/* the data field is empty.");
+ return;
+ }
+
+ // get incoming port to store in floodlight context
+ if (sw.getOFVersion() == OFVersion.OF_10) {
+ inport = pi.getInPort().getShortPortNumber();
+ } else if (sw.getOFVersion() == OFVersion.OF_13) {
+ for (MatchField<?> mf : pi.getMatch().getMatchFields()) {
+ if (mf.id == MatchFields.IN_PORT) {
+ inport = pi.getMatch().get((MatchField<OFPort>) mf)
+ .getShortPortNumber();
+ break;
+ }
+ }
+ if (inport == -1) {
+ log.error("Match field for incoming port missing in "
+ + "packet-in from sw {}. Ignoring msg",
+ sw.getStringId());
return;
}
+ } else {
+ // should have been taken care of earlier in handshake
+ log.error("OFVersion {} not supported for "
+ + "packet-in from sw {}. Ignoring msg",
+ sw.getOFVersion(), sw.getStringId());
+ return;
+ }
- // get incoming port to store in floodlight context
- if (sw.getOFVersion() == OFVersion.OF_10) {
- inport = pi.getInPort().getShortPortNumber();
- } else if (sw.getOFVersion() == OFVersion.OF_13) {
- for (MatchField<?> mf : pi.getMatch().getMatchFields()) {
- if (mf.id == MatchFields.IN_PORT) {
- inport = pi.getMatch().get((MatchField<OFPort>)mf)
- .getShortPortNumber();
- break;
- }
- }
- if (inport == -1) {
- log.error("Match field for incoming port missing in "
- + "packet-in from sw {} .. Ignoring msg",
- sw.getStringId());
- return;
- }
+ // decode enclosed ethernet packet to store in floodlight context
+ if (Controller.ALWAYS_DECODE_ETH) {
+ eth = new Ethernet();
+ eth.deserialize(pi.getData(), 0,
+ pi.getData().length);
+ }
+ // fall through to default case...
+
+ /*log.debug("Sw:{} packet-in: {}", sw.getStringId(),
+ String.format("0x%x", eth.getEtherType()));*/
+ if (eth.getEtherType() != (short) EthType.LLDP.getValue())
+ log.trace("Sw:{} packet-in: {}", sw.getStringId(), pi);
+
+ default:
+
+ List<IOFMessageListener> listeners = null;
+
+ if (messageListeners.containsKey(m.getType())) {
+ listeners = messageListeners.get(m.getType()).
+ getOrderedListeners();
+ }
+ FloodlightContext bc = null;
+ if (listeners != null) {
+ // Check if floodlight context is passed from the calling
+ // function, if so use that floodlight context, otherwise
+ // allocate one
+ if (bContext == null) {
+ bc = flcontext_alloc();
} else {
- // should have been taken care of earlier in handshake
- log.error("OFVersion {} not supported for "
- + "packet-in from sw {} .. Ignoring msg",
- sw.getOFVersion(), sw.getStringId());
- return;
+ bc = bContext;
+ }
+ if (eth != null) {
+ IFloodlightProviderService.bcStore.put(bc,
+ IFloodlightProviderService.CONTEXT_PI_PAYLOAD,
+ eth);
+ }
+ if (inport != -1) {
+ bc.getStorage().put(
+ IFloodlightProviderService.CONTEXT_PI_INPORT,
+ inport);
}
- // decode enclosed ethernet packet to store in floodlight context
- if (Controller.ALWAYS_DECODE_ETH) {
- eth = new Ethernet();
- eth.deserialize(pi.getData(), 0,
- pi.getData().length);
- }
- // fall through to default case...
+ // Get the starting time (overall and per-component) of
+ // the processing chain for this packet if performance
+ // monitoring is turned on
- /*log.debug("Sw:{} packet-in: {}", sw.getStringId(),
- String.format("0x%x", eth.getEtherType()));*/
- if (eth.getEtherType() != (short)EthType.LLDP.getValue())
- log.trace("Sw:{} packet-in: {}", sw.getStringId(), pi);
-
- default:
-
- List<IOFMessageListener> listeners = null;
-
- if (messageListeners.containsKey(m.getType())) {
- listeners = messageListeners.get(m.getType()).
- getOrderedListeners();
- }
- FloodlightContext bc = null;
- if (listeners != null) {
- // Check if floodlight context is passed from the calling
- // function, if so use that floodlight context, otherwise
- // allocate one
- if (bContext == null) {
- bc = flcontext_alloc();
- } else {
- bc = bContext;
- }
- if (eth != null) {
- IFloodlightProviderService.bcStore.put(bc,
- IFloodlightProviderService.CONTEXT_PI_PAYLOAD,
- eth);
- }
- if (inport != -1) {
- bc.getStorage().put(
- IFloodlightProviderService.CONTEXT_PI_INPORT,
- inport);
- }
-
- // Get the starting time (overall and per-component) of
- // the processing chain for this packet if performance
- // monitoring is turned on
-
- Command cmd = null;
- for (IOFMessageListener listener : listeners) {
- if (listener instanceof IOFSwitchFilter) {
- if (!((IOFSwitchFilter) listener).isInterested(sw)) {
- continue;
- }
- }
-
- cmd = listener.receive(sw, m, bc);
-
- if (Command.STOP.equals(cmd)) {
- break;
+ Command cmd = null;
+ for (IOFMessageListener listener : listeners) {
+ if (listener instanceof IOFSwitchFilter) {
+ if (!((IOFSwitchFilter) listener).isInterested(sw)) {
+ continue;
}
}
- } else {
- log.warn("Unhandled OF Message: {} from {}", m, sw);
+ cmd = listener.receive(sw, m, bc);
+
+ if (Command.STOP.equals(cmd)) {
+ break;
+ }
}
- if ((bContext == null) && (bc != null)) flcontext_free(bc);
+ } else {
+ log.warn("Unhandled OF Message: {} from {}", m, sw);
+ }
+
+ if ((bContext == null) && (bc != null))
+ flcontext_free(bc);
}
}
@@ -737,7 +743,7 @@
// FIXME: remove this method
@Override
- public Map<Long,IOFSwitch> getSwitches() {
+ public Map<Long, IOFSwitch> getSwitches() {
return getMasterSwitches();
}
@@ -746,7 +752,6 @@
return Collections.unmodifiableMap(activeMasterSwitches);
}
-
@Override
public Set<Long> getAllSwitchDpids() {
Set<Long> dpids = new HashSet<Long>();
@@ -772,24 +777,26 @@
@Override
public IOFSwitch getSwitch(long dpid) {
IOFSwitch sw = null;
- if ((sw = activeMasterSwitches.get(dpid)) != null) return sw;
- if ((sw = activeEqualSwitches.get(dpid)) != null) return sw;
+ if ((sw = activeMasterSwitches.get(dpid)) != null)
+ return sw;
+ if ((sw = activeEqualSwitches.get(dpid)) != null)
+ return sw;
return sw;
}
@Override
public IOFSwitch getMasterSwitch(long dpid) {
- return activeMasterSwitches.get(dpid);
+ return activeMasterSwitches.get(dpid);
}
@Override
public IOFSwitch getEqualSwitch(long dpid) {
- return activeEqualSwitches.get(dpid);
+ return activeEqualSwitches.get(dpid);
}
@Override
public synchronized void addOFMessageListener(OFType type,
- IOFMessageListener listener) {
+ IOFMessageListener listener) {
ListenerDispatcher<OFType, IOFMessageListener> ldd =
messageListeners.get(type);
if (ldd == null) {
@@ -801,7 +808,7 @@
@Override
public synchronized void removeOFMessageListener(OFType type,
- IOFMessageListener listener) {
+ IOFMessageListener listener) {
ListenerDispatcher<OFType, IOFMessageListener> ldd =
messageListeners.get(type);
if (ldd != null) {
@@ -814,10 +821,8 @@
}
private void logListeners() {
- for (Map.Entry<OFType,
- ListenerDispatcher<OFType,
- IOFMessageListener>> entry
- : messageListeners.entrySet()) {
+ for (Map.Entry<OFType, ListenerDispatcher<OFType, IOFMessageListener>> entry : messageListeners
+ .entrySet()) {
OFType type = entry.getKey();
ListenerDispatcher<OFType, IOFMessageListener> ldd =
@@ -857,8 +862,8 @@
public Map<OFType, List<IOFMessageListener>> getListeners() {
Map<OFType, List<IOFMessageListener>> lers =
new HashMap<OFType, List<IOFMessageListener>>();
- for (Entry<OFType, ListenerDispatcher<OFType, IOFMessageListener>> e :
- messageListeners.entrySet()) {
+ for (Entry<OFType, ListenerDispatcher<OFType, IOFMessageListener>> e : messageListeners
+ .entrySet()) {
lers.put(e.getKey(), e.getValue().getOrderedListeners());
}
return Collections.unmodifiableMap(lers);
@@ -905,42 +910,39 @@
return true;
}*/
+ // @Override
+ // public boolean injectOfMessage(IOFSwitch sw, OFMessage msg) {
+ // // call the overloaded version with floodlight context set to null
+ // return injectOfMessage(sw, msg, null);
+ // }
-
-// @Override
-// public boolean injectOfMessage(IOFSwitch sw, OFMessage msg) {
-// // call the overloaded version with floodlight context set to null
-// return injectOfMessage(sw, msg, null);
-// }
-
-// @Override
-// public void handleOutgoingMessage(IOFSwitch sw, OFMessage m,
-// FloodlightContext bc) {
-//
-// List<IOFMessageListener> listeners = null;
-// if (messageListeners.containsKey(m.getType())) {
-// listeners =
-// messageListeners.get(m.getType()).getOrderedListeners();
-// }
-//
-// if (listeners != null) {
-// for (IOFMessageListener listener : listeners) {
-// if (listener instanceof IOFSwitchFilter) {
-// if (!((IOFSwitchFilter) listener).isInterested(sw)) {
-// continue;
-// }
-// }
-// if (Command.STOP.equals(listener.receive(sw, m, bc))) {
-// break;
-// }
-// }
-// }
-// }
-
+ // @Override
+ // public void handleOutgoingMessage(IOFSwitch sw, OFMessage m,
+ // FloodlightContext bc) {
+ //
+ // List<IOFMessageListener> listeners = null;
+ // if (messageListeners.containsKey(m.getType())) {
+ // listeners =
+ // messageListeners.get(m.getType()).getOrderedListeners();
+ // }
+ //
+ // if (listeners != null) {
+ // for (IOFMessageListener listener : listeners) {
+ // if (listener instanceof IOFSwitchFilter) {
+ // if (!((IOFSwitchFilter) listener).isInterested(sw)) {
+ // continue;
+ // }
+ // }
+ // if (Command.STOP.equals(listener.receive(sw, m, bc))) {
+ // break;
+ // }
+ // }
+ // }
+ // }
/**
* Gets an OpenFlow message factory for version 1.0.
- *
+ *
* @return an OpenFlow 1.0 message factory
*/
public OFFactory getOFMessageFactory_10() {
@@ -949,7 +951,7 @@
/**
* Gets an OpenFlow message factory for version 1.3.
- *
+ *
* @return an OpenFlow 1.3 message factory
*/
public OFFactory getOFMessageFactory_13() {
@@ -1004,7 +1006,6 @@
}
}
-
// **************
// Initialization
// **************
@@ -1013,25 +1014,24 @@
// controller roles per switch! Then it could be a way to
// deterministically configure a switch to a MASTER controller instance
/**
- * Sets the initial role based on properties in the config params.
- * It looks for two different properties.
- * If the "role" property is specified then the value should be
- * either "EQUAL", "MASTER", or "SLAVE" and the role of the
- * controller is set to the specified value. If the "role" property
- * is not specified then it looks next for the "role.path" property.
- * In this case the value should be the path to a property file in
- * the file system that contains a property called "floodlight.role"
- * which can be one of the values listed above for the "role" property.
- * The idea behind the "role.path" mechanism is that you have some
- * separate heartbeat and master controller election algorithm that
- * determines the role of the controller. When a role transition happens,
- * it updates the current role in the file specified by the "role.path"
- * file. Then if floodlight restarts for some reason it can get the
- * correct current role of the controller from the file.
- *
+ * Sets the initial role based on properties in the config params. It looks
+ * for two different properties. If the "role" property is specified then
+ * the value should be either "EQUAL", "MASTER", or "SLAVE" and the role of
+ * the controller is set to the specified value. If the "role" property is
+ * not specified then it looks next for the "role.path" property. In this
+ * case the value should be the path to a property file in the file system
+ * that contains a property called "floodlight.role" which can be one of the
+ * values listed above for the "role" property. The idea behind the
+ * "role.path" mechanism is that you have some separate heartbeat and master
+ * controller election algorithm that determines the role of the controller.
+ * When a role transition happens, it updates the current role in the file
+ * specified by the "role.path" file. Then if floodlight restarts for some
+ * reason it can get the correct current role of the controller from the
+ * file.
+ *
* @param configParams The config params for the FloodlightProvider service
- * @return A valid role if role information is specified in the
- * config params, otherwise null
+ * @return A valid role if role information is specified in the config
+ * params, otherwise null
*/
@LogMessageDocs({
@LogMessageDoc(message = "Controller role set to {role}",
@@ -1089,7 +1089,7 @@
/**
* Tell controller that we're ready to accept switches loop
- *
+ *
* @throws IOException
*/
@Override
@@ -1138,7 +1138,7 @@
update.dispatch();
} catch (InterruptedException e) {
log.error("Received interrupted exception in updates loop;" +
- "terminating process");
+ "terminating process");
terminate();
} catch (Exception e) {
log.error("Exception in controller updates loop", e);
@@ -1175,7 +1175,8 @@
if (controllerId != null) {
this.onosInstanceId = new OnosInstanceId(controllerId);
} else {
- //Try to get the hostname of the machine and use that for controller ID
+ // Try to get the hostname of the machine and use that for
+ // controller ID
try {
String hostname = java.net.InetAddress.getLocalHost().getHostName();
this.onosInstanceId = new OnosInstanceId(hostname);
@@ -1187,7 +1188,6 @@
log.debug("ControllerId set to {}", this.onosInstanceId);
}
-
/**
* Initialize internal data structures
*/
@@ -1196,7 +1196,7 @@
// module's startUp() might be called before ours
this.messageListeners =
new ConcurrentHashMap<OFType, ListenerDispatcher<OFType,
- IOFMessageListener>>();
+ IOFMessageListener>>();
this.switchListeners = new CopyOnWriteArraySet<IOFSwitchListener>();
this.activeMasterSwitches = new ConcurrentHashMap<Long, IOFSwitch>();
this.activeEqualSwitches = new ConcurrentHashMap<Long, IOFSwitch>();
@@ -1221,6 +1221,7 @@
/**
* Startup all of the controller's components
+ *
* @throws FloodlightModuleException
*/
@LogMessageDoc(message = "Waiting for storage source",
@@ -1241,7 +1242,7 @@
// Startup load monitoring
if (overload_drop) {
this.loadmonitor.startMonitoring(
- this.threadPool.getScheduledExecutor());
+ this.threadPool.getScheduledExecutor());
}
// register counters and events
@@ -1270,7 +1271,7 @@
public IDebugCounter switchActivated;
public IDebugCounter errorSameSwitchReactivated; // err
public IDebugCounter switchWithSameDpidActivated; // warn
- public IDebugCounter newSwitchActivated; // new switch
+ public IDebugCounter newSwitchActivated; // new switch
public IDebugCounter syncedSwitchActivated;
public IDebugCounter readyForReconcile;
public IDebugCounter newSwitchFromStore;
@@ -1285,7 +1286,9 @@
public IDebugCounter switchPortChanged;
public IDebugCounter switchOtherChange;
public IDebugCounter dispatchMessageWhileSlave;
- public IDebugCounter dispatchMessage; // does this cnt make sense? more specific?? per type? count stops?
+ public IDebugCounter dispatchMessage; // does this cnt make sense? more
+ // specific?? per type? count
+ // stops?
public IDebugCounter controllerNodeIpsChanged;
public IDebugCounter messageReceived;
public IDebugCounter messageInputThrottled;
@@ -1310,400 +1313,402 @@
void createCounters(IDebugCounterService debugCounters) throws CounterException {
setRoleEqual =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "set-role-equal",
- "Controller received a role request with role of "+
- "EQUAL which is unusual",
+ "Controller received a role request with role of " +
+ "EQUAL which is unusual",
CounterType.ALWAYS_COUNT);
setSameRole =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "set-same-role",
"Controller received a role request for the same " +
- "role the controller already had",
+ "role the controller already had",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_WARN);
setRoleMaster =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "set-role-master",
"Controller received a role request with role of " +
- "MASTER. This counter can be at most 1.",
+ "MASTER. This counter can be at most 1.",
CounterType.ALWAYS_COUNT);
remoteStoreNotification =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "remote-store-notification",
"Received a notification from the sync service " +
- "indicating that switch information has changed",
+ "indicating that switch information has changed",
CounterType.ALWAYS_COUNT);
invalidPortsChanged =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "invalid-ports-changed",
"Received an unexpected ports changed " +
- "notification while the controller was in " +
- "SLAVE role.",
+ "notification while the controller was in " +
+ "SLAVE role.",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_WARN);
invalidSwitchActivatedWhileSlave =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "invalid-switch-activated-while-slave",
"Received an unexpected switchActivated " +
- "notification while the controller was in " +
- "SLAVE role.",
+ "notification while the controller was in " +
+ "SLAVE role.",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_WARN);
invalidStoreEventWhileMaster =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "invalid-store-event-while-master",
"Received an unexpected notification from " +
- "the sync store while the controller was in " +
- "MASTER role.",
+ "the sync store while the controller was in " +
+ "MASTER role.",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_WARN);
switchDisconnectedWhileSlave =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "switch-disconnected-while-slave",
"A switch disconnected and the controller was " +
- "in SLAVE role.",
+ "in SLAVE role.",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_WARN);
switchActivated =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "switch-activated",
"A switch connected to this controller is now " +
- "in MASTER role",
+ "in MASTER role",
CounterType.ALWAYS_COUNT);
errorSameSwitchReactivated = // err
- debugCounters.registerCounter(
- prefix, "error-same-switch-reactivated",
- "A switch that was already in active state " +
+ debugCounters.registerCounter(
+ prefix, "error-same-switch-reactivated",
+ "A switch that was already in active state " +
"was activated again. This indicates a " +
"controller defect",
- CounterType.ALWAYS_COUNT,
- IDebugCounterService.CTR_MDATA_ERROR);
+ CounterType.ALWAYS_COUNT,
+ IDebugCounterService.CTR_MDATA_ERROR);
switchWithSameDpidActivated = // warn
- debugCounters.registerCounter(
- prefix, "switch-with-same-dpid-activated",
- "A switch with the same DPID as another switch " +
+ debugCounters.registerCounter(
+ prefix, "switch-with-same-dpid-activated",
+ "A switch with the same DPID as another switch " +
"connected to the controller. This can be " +
"caused by multiple switches configured with " +
"the same DPID or by a switch reconnecting very " +
"quickly.",
- CounterType.COUNT_ON_DEMAND,
- IDebugCounterService.CTR_MDATA_WARN);
+ CounterType.COUNT_ON_DEMAND,
+ IDebugCounterService.CTR_MDATA_WARN);
- newSwitchActivated = // new switch
- debugCounters.registerCounter(
- prefix, "new-switch-activated",
- "A new switch has completed the handshake as " +
+ newSwitchActivated = // new switch
+ debugCounters.registerCounter(
+ prefix, "new-switch-activated",
+ "A new switch has completed the handshake as " +
"MASTER. The switch was not known to any other " +
"controller in the cluster",
- CounterType.ALWAYS_COUNT);
+ CounterType.ALWAYS_COUNT);
syncedSwitchActivated =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "synced-switch-activated",
"A switch has completed the handshake as " +
- "MASTER. The switch was known to another " +
- "controller in the cluster",
+ "MASTER. The switch was known to another " +
+ "controller in the cluster",
CounterType.ALWAYS_COUNT);
readyForReconcile =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "ready-for-reconcile",
"Controller is ready for flow reconciliation " +
- "after Slave to Master transition. Either all " +
- "previously known switches are now active " +
- "or they have timed out and have been removed." +
- "This counter will be 0 or 1.",
+ "after Slave to Master transition. Either all " +
+ "previously known switches are now active " +
+ "or they have timed out and have been removed." +
+ "This counter will be 0 or 1.",
CounterType.ALWAYS_COUNT);
newSwitchFromStore =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "new-switch-from-store",
"A new switch has connected to another " +
- "another controller in the cluster. This " +
- "controller instance has received a sync store " +
- "notification for it.",
+ "another controller in the cluster. This " +
+ "controller instance has received a sync store " +
+ "notification for it.",
CounterType.ALWAYS_COUNT);
updatedSwitchFromStore =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "updated-switch-from-store",
"Information about a switch connected to " +
- "another controller instance was updated in " +
- "the sync store. This controller instance has " +
- "received a notification for it",
+ "another controller instance was updated in " +
+ "the sync store. This controller instance has " +
+ "received a notification for it",
CounterType.ALWAYS_COUNT);
switchDisconnected =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "switch-disconnected",
"FIXME: switch has disconnected",
CounterType.ALWAYS_COUNT);
syncedSwitchRemoved =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "synced-switch-removed",
"A switch connected to another controller " +
- "instance has disconnected from the controller " +
- "cluster. This controller instance has " +
- "received a notification for it",
+ "instance has disconnected from the controller " +
+ "cluster. This controller instance has " +
+ "received a notification for it",
CounterType.ALWAYS_COUNT);
unknownSwitchRemovedFromStore =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "unknown-switch-removed-from-store",
"This controller instances has received a sync " +
- "store notification that a switch has " +
- "disconnected but this controller instance " +
- "did not have the any information about the " +
- "switch", // might be less than warning
+ "store notification that a switch has " +
+ "disconnected but this controller instance " +
+ "did not have the any information about the " +
+ "switch", // might be less than warning
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_WARN);
consolidateStoreRunCount =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "consolidate-store-run-count",
"This controller has transitioned from SLAVE " +
- "to MASTER and waited for switches to reconnect. " +
- "The controller has finished waiting and has " +
- "reconciled switch entries in the sync store " +
- "with live state",
+ "to MASTER and waited for switches to reconnect. " +
+ "The controller has finished waiting and has " +
+ "reconciled switch entries in the sync store " +
+ "with live state",
CounterType.ALWAYS_COUNT);
consolidateStoreInconsistencies =
debugCounters.registerCounter(
- prefix, "consolidate-store-inconsistencies",
- "During switch sync store consolidation: " +
- "Number of switches that were in the store " +
- "but not otherwise known plus number of " +
- "switches that were in the store previously " +
- "but are now missing plus number of " +
- "connected switches that were absent from " +
- "the store although this controller has " +
- "written them. A non-zero count " +
- "indicates a brief split-brain dual MASTER " +
- "situation during fail-over",
- CounterType.ALWAYS_COUNT);
+ prefix, "consolidate-store-inconsistencies",
+ "During switch sync store consolidation: " +
+ "Number of switches that were in the store " +
+ "but not otherwise known plus number of " +
+ "switches that were in the store previously " +
+ "but are now missing plus number of " +
+ "connected switches that were absent from " +
+ "the store although this controller has " +
+ "written them. A non-zero count " +
+ "indicates a brief split-brain dual MASTER " +
+ "situation during fail-over",
+ CounterType.ALWAYS_COUNT);
storeSyncError =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "store-sync-error",
"Number of times a sync store operation failed " +
- "due to a store sync exception or an entry in " +
- "in the store had invalid data.",
+ "due to a store sync exception or an entry in " +
+ "in the store had invalid data.",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_ERROR);
switchesNotReconnectingToNewMaster =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "switches-not-reconnecting-to-new-master",
"Switches that were connected to another " +
- "controller instance in the cluster but that " +
- "did not reconnect to this controller after it " +
- "transitioned to MASTER", // might be less than warning
+ "controller instance in the cluster but that " +
+ "did not reconnect to this controller after it " +
+ "transitioned to MASTER", // might be less
+ // than warning
CounterType.ALWAYS_COUNT);
switchPortChanged =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "switch-port-changed",
"Number of times switch ports have changed",
CounterType.ALWAYS_COUNT);
switchOtherChange =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "switch-other-change",
"Number of times other information of a switch " +
- "has changed.",
+ "has changed.",
CounterType.ALWAYS_COUNT);
dispatchMessageWhileSlave =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "dispatch-message-while-slave",
"Number of times an OF message was received " +
- "and supposed to be dispatched but the " +
- "controller was in SLAVE role and the message " +
- "was not dispatched",
+ "and supposed to be dispatched but the " +
+ "controller was in SLAVE role and the message " +
+ "was not dispatched",
CounterType.ALWAYS_COUNT);
- dispatchMessage = // does this cnt make sense? more specific?? per type? count stops?
- debugCounters.registerCounter(
- prefix, "dispatch-message",
- "Number of times an OF message was dispatched " +
+ dispatchMessage = // does this cnt make sense? more specific?? per
+ // type? count stops?
+ debugCounters.registerCounter(
+ prefix, "dispatch-message",
+ "Number of times an OF message was dispatched " +
"to registered modules",
- CounterType.ALWAYS_COUNT);
+ CounterType.ALWAYS_COUNT);
controllerNodeIpsChanged =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "controller-nodes-ips-changed",
"IP addresses of controller nodes have changed",
CounterType.ALWAYS_COUNT);
- //------------------------
- // channel handler counters. Factor them out ??
+ // ------------------------
+ // channel handler counters. Factor them out ??
messageReceived =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "message-received",
"Number of OpenFlow messages received. Some of " +
- "these might be throttled",
+ "these might be throttled",
CounterType.ALWAYS_COUNT);
messageInputThrottled =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "message-input-throttled",
"Number of OpenFlow messages that were " +
- "throttled due to high load from the sender",
+ "throttled due to high load from the sender",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_WARN);
- // TODO: more counters in messageReceived ??
+ // TODO: more counters in messageReceived ??
switchDisconnectReadTimeout =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "switch-disconnect-read-timeout",
"Number of times a switch was disconnected due " +
- "due the switch failing to send OpenFlow " +
- "messages or responding to OpenFlow ECHOs",
+ "due the switch failing to send OpenFlow " +
+ "messages or responding to OpenFlow ECHOs",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_ERROR);
switchDisconnectHandshakeTimeout =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "switch-disconnect-handshake-timeout",
"Number of times a switch was disconnected " +
- "because it failed to complete the handshake " +
- "in time.",
+ "because it failed to complete the handshake " +
+ "in time.",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_ERROR);
switchDisconnectIOError =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "switch-disconnect-io-error",
"Number of times a switch was disconnected " +
- "due to IO errors on the switch connection.",
+ "due to IO errors on the switch connection.",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_ERROR);
switchDisconnectParseError =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "switch-disconnect-parse-error",
- "Number of times a switch was disconnected " +
- "because it sent an invalid packet that could " +
- "not be parsed",
- CounterType.ALWAYS_COUNT,
- IDebugCounterService.CTR_MDATA_ERROR);
+ "Number of times a switch was disconnected " +
+ "because it sent an invalid packet that could " +
+ "not be parsed",
+ CounterType.ALWAYS_COUNT,
+ IDebugCounterService.CTR_MDATA_ERROR);
switchDisconnectSwitchStateException =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "switch-disconnect-switch-state-exception",
"Number of times a switch was disconnected " +
- "because it sent messages that were invalid " +
- "given the switch connection's state.",
+ "because it sent messages that were invalid " +
+ "given the switch connection's state.",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_ERROR);
rejectedExecutionException =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "rejected-execution-exception",
"TODO",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_ERROR);
switchDisconnectOtherException =
- debugCounters.registerCounter(
- prefix, "switch-disconnect-other-exception",
+ debugCounters.registerCounter(
+ prefix, "switch-disconnect-other-exception",
"Number of times a switch was disconnected " +
- "due to an exceptional situation not covered " +
- "by other counters",
+ "due to an exceptional situation not covered " +
+ "by other counters",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_ERROR);
switchConnected =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "switch-connected",
"Number of times a new switch connection was " +
- "established",
+ "established",
CounterType.ALWAYS_COUNT);
unhandledMessage =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "unhandled-message",
"Number of times an OpenFlow message was " +
- "received that the controller ignored because " +
- "it was inapproriate given the switch " +
- "connection's state.",
+ "received that the controller ignored because " +
+ "it was inapproriate given the switch " +
+ "connection's state.",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_WARN);
- // might be less than warning
+ // might be less than warning
packetInWhileSwitchIsSlave =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "packet-in-while-switch-is-slave",
"Number of times a packet in was received " +
- "from a switch that was in SLAVE role. " +
- "Possibly inidicates inconsistent roles.",
+ "from a switch that was in SLAVE role. " +
+ "Possibly inidicates inconsistent roles.",
CounterType.ALWAYS_COUNT);
epermErrorWhileSwitchIsMaster =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "eperm-error-while-switch-is-master",
"Number of times a permission error was " +
- "received while the switch was in MASTER role. " +
- "Possibly inidicates inconsistent roles.",
+ "received while the switch was in MASTER role. " +
+ "Possibly inidicates inconsistent roles.",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_WARN);
roleNotResentBecauseRolePending =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "role-not-resent-because-role-pending",
"The controller tried to reestablish a role " +
- "with a switch but did not do so because a " +
- "previous role request was still pending",
+ "with a switch but did not do so because a " +
+ "previous role request was still pending",
CounterType.ALWAYS_COUNT);
roleRequestSent =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "role-request-sent",
"Number of times the controller sent a role " +
- "request to a switch.",
+ "request to a switch.",
CounterType.ALWAYS_COUNT);
roleReplyTimeout =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "role-reply-timeout",
"Number of times a role request message did not " +
- "receive the expected reply from a switch",
+ "receive the expected reply from a switch",
CounterType.ALWAYS_COUNT,
IDebugCounterService.CTR_MDATA_WARN);
roleReplyReceived = // expected RoleReply received
- debugCounters.registerCounter(
- prefix, "role-reply-received",
- "Number of times the controller received the " +
+ debugCounters.registerCounter(
+ prefix, "role-reply-received",
+ "Number of times the controller received the " +
"expected role reply message from a switch",
- CounterType.ALWAYS_COUNT);
+ CounterType.ALWAYS_COUNT);
roleReplyErrorUnsupported =
- debugCounters.registerCounter(
+ debugCounters.registerCounter(
prefix, "role-reply-error-unsupported",
"Number of times the controller received an " +
- "error from a switch in response to a role " +
- "request indicating that the switch does not " +
- "support roles.",
+ "error from a switch in response to a role " +
+ "request indicating that the switch does not " +
+ "support roles.",
CounterType.ALWAYS_COUNT);
switchCounterRegistrationFailed =
debugCounters.registerCounter(prefix,
- "switch-counter-registration-failed",
- "Number of times the controller failed to " +
- "register per-switch debug counters",
- CounterType.ALWAYS_COUNT,
- IDebugCounterService.CTR_MDATA_WARN);
+ "switch-counter-registration-failed",
+ "Number of times the controller failed to " +
+ "register per-switch debug counters",
+ CounterType.ALWAYS_COUNT,
+ IDebugCounterService.CTR_MDATA_WARN);
packetParsingError =
debugCounters.registerCounter(prefix,
- "packet-parsing-error",
- "Number of times the packet parsing " +
- "encountered an error",
- CounterType.ALWAYS_COUNT,
- IDebugCounterService.CTR_MDATA_ERROR);
+ "packet-parsing-error",
+ "Number of times the packet parsing " +
+ "encountered an error",
+ CounterType.ALWAYS_COUNT,
+ IDebugCounterService.CTR_MDATA_ERROR);
}
}
@@ -1722,9 +1727,9 @@
}
try {
evSwitch = debugEvents.registerEvent(
- Counters.prefix, "switchevent",
- "Switch connected, disconnected or port changed",
- EventType.ALWAYS_LOG, SwitchEvent.class, 100);
+ Counters.prefix, "switchevent",
+ "Switch connected, disconnected or port changed",
+ EventType.ALWAYS_LOG, SwitchEvent.class, 100);
} catch (MaxEventsRegistered e) {
throw new FloodlightModuleException("Max events registered", e);
}
@@ -1749,7 +1754,7 @@
@Override
public void setAlwaysClearFlowsOnSwActivate(boolean value) {
- //this.alwaysClearFlowsOnSwActivate = value;
+ // this.alwaysClearFlowsOnSwActivate = value;
// XXX S need to be a little more careful about this
}
@@ -1770,6 +1775,7 @@
/**
* Forward to the driver-manager to get an IOFSwitch instance.
+ *
* @param desc
* @return
*/
@@ -1782,16 +1788,17 @@
}
/**
- * Part of the controller updates framework (see 'run()' method)
- * Use this method to add an IUpdate. A thread-pool will serve the update
- * by dispatching it to all listeners for that update.
+ * Part of the controller updates framework (see 'run()' method) Use this
+ * method to add an IUpdate. A thread-pool will serve the update by
+ * dispatching it to all listeners for that update.
+ *
* @param update
*/
- @LogMessageDoc(level="WARN",
- message="Failure adding update {} to queue",
- explanation="The controller tried to add an internal notification" +
- " to its message queue but the add failed.",
- recommendation=LogMessageDoc.REPORT_CONTROLLER_BUG)
+ @LogMessageDoc(level = "WARN",
+ message = "Failure adding update {} to queue",
+ explanation = "The controller tried to add an internal notification" +
+ " to its message queue but the add failed.",
+ recommendation = LogMessageDoc.REPORT_CONTROLLER_BUG)
private void addUpdateToQueue(IUpdate update) {
try {
this.updates.put(update);
@@ -1810,7 +1817,7 @@
/**
* flcontext_free - Free the context to the current thread
- *
+ *
* @param flcontext
*/
protected void flcontext_free(FloodlightContext flcontext) {
@@ -1825,7 +1832,6 @@
System.exit(1);
}
-
// ***************
// Floodlight context related
// ***************
@@ -1842,8 +1848,9 @@
};
/**
- * flcontext_alloc - pop a context off the stack, if required create a new one
- *
+ * flcontext_alloc - pop a context off the stack, if required create a new
+ * one
+ *
* @return FloodlightContext
*/
protected static FloodlightContext flcontext_alloc() {
@@ -1858,5 +1865,4 @@
return flcontext;
}
-
}
diff --git a/src/main/java/net/floodlightcontroller/core/internal/OFChannelHandler.java b/src/main/java/net/floodlightcontroller/core/internal/OFChannelHandler.java
index 2008697..aa23852 100644
--- a/src/main/java/net/floodlightcontroller/core/internal/OFChannelHandler.java
+++ b/src/main/java/net/floodlightcontroller/core/internal/OFChannelHandler.java
@@ -74,17 +74,17 @@
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-
/**
- * Channel handler deals with the switch connection and dispatches
- * switch messages to the appropriate locations.
+ * Channel handler deals with the switch connection and dispatches switch
+ * messages to the appropriate locations.
+ *
* @author readams, gregor, saurav
*/
class OFChannelHandler extends IdleStateAwareChannelHandler {
private static final Logger log = LoggerFactory.getLogger(OFChannelHandler.class);
- private static final long DEFAULT_ROLE_TIMEOUT_MS = 10*1000; // 10 sec
+ private static final long DEFAULT_ROLE_TIMEOUT_MS = 10 * 1000; // 10 sec
private final Controller controller;
private final Counters counters;
private IOFSwitch sw;
@@ -94,9 +94,10 @@
// needs to check if the handshake is complete
private volatile ChannelState state;
-
- // All role messaging is handled by the roleChanger. The channel state machine
- // coordinates between the roleChanger and the controller-global-registry-service
+ // All role messaging is handled by the roleChanger. The channel state
+ // machine
+ // coordinates between the roleChanger and the
+ // controller-global-registry-service
// to determine controller roles per switch.
private RoleChanger roleChanger;
// Used to coordinate between the controller and the cleanup thread(?)
@@ -105,7 +106,8 @@
// When a switch with a duplicate dpid is found (i.e we already have a
// connected switch with the same dpid), the new switch is immediately
// disconnected. At that point netty callsback channelDisconnected() which
- // proceeds to cleaup switch state - we need to ensure that it does not cleanup
+ // proceeds to cleaup switch state - we need to ensure that it does not
+ // cleanup
// switch state for the older (still connected) switch
private volatile Boolean duplicateDpidFound;
@@ -116,19 +118,20 @@
// before we are ready to deal with them
private final CopyOnWriteArrayList<OFPortStatus> pendingPortStatusMsg;
- //Indicates the openflow version used by this switch
+ // Indicates the openflow version used by this switch
protected OFVersion ofVersion;
protected static OFFactory factory13;
protected static OFFactory factory10;
- /** transaction Ids to use during handshake. Since only one thread
- * calls into an OFChannelHandler instance, we don't need atomic.
- * We will count down
+ /**
+ * transaction Ids to use during handshake. Since only one thread calls into
+ * an OFChannelHandler instance, we don't need atomic. We will count down
*/
private int handshakeTransactionIds = -1;
/**
* Create a new unconnected OFChannelHandler.
+ *
* @param controller
*/
OFChannelHandler(Controller controller) {
@@ -143,59 +146,62 @@
duplicateDpidFound = Boolean.FALSE;
}
- //*******************
- // Role Handling
- //*******************
-
+ // *******************
+ // Role Handling
+ // *******************
/**
* When we remove a pending role request we use this enum to indicate how we
* arrived at the decision. When we send a role request to the switch, we
- * also use this enum to indicate what we expect back from the switch, so the
- * role changer can match the reply to our expectation.
+ * also use this enum to indicate what we expect back from the switch, so
+ * the role changer can match the reply to our expectation.
+ *
* @author gregor, saurav
*/
public enum RoleRecvStatus {
- /** The switch returned an error indicating that roles are not
- * supported*/
+ /**
+ * The switch returned an error indicating that roles are not supported
+ */
UNSUPPORTED,
/** The request timed out */
NO_REPLY,
/** The reply was old, there is a newer request pending */
OLD_REPLY,
/**
- * The reply's role matched the role that this controller set in the
- * request message - invoked either initially at startup or to reassert
- * current role
+ * The reply's role matched the role that this controller set in the
+ * request message - invoked either initially at startup or to reassert
+ * current role
*/
MATCHED_CURRENT_ROLE,
/**
- * The reply's role matched the role that this controller set in the
- * request message - this is the result of a callback from the
- * global registry, followed by a role request sent to the switch
+ * The reply's role matched the role that this controller set in the
+ * request message - this is the result of a callback from the global
+ * registry, followed by a role request sent to the switch
*/
MATCHED_SET_ROLE,
/**
* The reply's role was a response to the query made by this controller
*/
REPLY_QUERY,
- /** We received a role reply message from the switch
- * but the expectation was unclear, or there was no expectation
+ /**
+ * We received a role reply message from the switch but the expectation
+ * was unclear, or there was no expectation
*/
OTHER_EXPECTATION,
}
/**
* Forwards to RoleChanger. See there.
+ *
* @param role
*/
public void sendRoleRequest(Role role, RoleRecvStatus expectation) {
try {
roleChanger.sendRoleRequest(role, expectation);
} catch (IOException e) {
- log.error("Disconnecting switch {} due to IO Error: {}",
- getSwitchInfoString(), e.getMessage());
- channel.close();
+ log.error("Disconnecting switch {} due to IO Error: {}",
+ getSwitchInfoString(), e.getMessage());
+ channel.close();
}
}
@@ -207,15 +213,16 @@
/**
* A utility class to handle role requests and replies for this channel.
* After a role request is submitted the role changer keeps track of the
- * pending request, collects the reply (if any) and times out the request
- * if necessary.
- *
- * To simplify role handling we only keep track of the /last/ pending
- * role reply send to the switch. If multiple requests are pending and
- * we receive replies for earlier requests we ignore them. However, this
- * way of handling pending requests implies that we could wait forever if
- * a new request is submitted before the timeout triggers. If necessary
- * we could work around that though.
+ * pending request, collects the reply (if any) and times out the request if
+ * necessary.
+ *
+ * To simplify role handling we only keep track of the /last/ pending role
+ * reply send to the switch. If multiple requests are pending and we receive
+ * replies for earlier requests we ignore them. However, this way of
+ * handling pending requests implies that we could wait forever if a new
+ * request is submitted before the timeout triggers. If necessary we could
+ * work around that though.
+ *
* @author gregor
* @author saurav (added support OF1.3 role messages, and expectations)
*/
@@ -246,7 +253,7 @@
/**
* Send NX role request message to the switch requesting the specified
* role.
- *
+ *
* @param sw switch to send the role request message to
* @param role role to request
*/
@@ -272,7 +279,7 @@
.setRole(roleToSend)
.build();
sw.write(Collections.<OFMessage>singletonList(roleRequest),
- new FloodlightContext());
+ new FloodlightContext());
return xid;
}
@@ -306,24 +313,25 @@
}
/**
- * Send a role request with the given role to the switch and update
- * the pending request and timestamp.
- * Sends an OFPT_ROLE_REQUEST to an OF1.3 switch, OR
- * Sends an NX_ROLE_REQUEST to an OF1.0 switch if configured to support it
- * in the IOFSwitch driver. If not supported, this method sends nothing
- * and returns 'false'. The caller should take appropriate action.
- *
+ * Send a role request with the given role to the switch and update the
+ * pending request and timestamp. Sends an OFPT_ROLE_REQUEST to an OF1.3
+ * switch, OR Sends an NX_ROLE_REQUEST to an OF1.0 switch if configured
+ * to support it in the IOFSwitch driver. If not supported, this method
+ * sends nothing and returns 'false'. The caller should take appropriate
+ * action.
+ *
* One other optimization we do here is that for OF1.0 switches with
* Nicira role message support, we force the Role.EQUAL to become
- * Role.SLAVE, as there is no defined behavior for the Nicira role OTHER.
- * We cannot expect it to behave like SLAVE. We don't have this problem with
- * OF1.3 switches, because Role.EQUAL is well defined and we can simulate
- * SLAVE behavior by using ASYNC messages.
- *
+ * Role.SLAVE, as there is no defined behavior for the Nicira role
+ * OTHER. We cannot expect it to behave like SLAVE. We don't have this
+ * problem with OF1.3 switches, because Role.EQUAL is well defined and
+ * we can simulate SLAVE behavior by using ASYNC messages.
+ *
* @param role
* @throws IOException
- * @returns false if and only if the switch does not support role-request
- * messages, according to the switch driver; true otherwise.
+ * @returns false if and only if the switch does not support
+ * role-request messages, according to the switch driver; true
+ * otherwise.
*/
synchronized boolean sendRoleRequest(Role role, RoleRecvStatus expectation)
throws IOException {
@@ -333,11 +341,11 @@
Boolean supportsNxRole = (Boolean)
sw.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE);
if (!supportsNxRole) {
- log.debug("Switch driver indicates no support for Nicira "
- + "role request messages. Not sending ...");
- state.handleUnsentRoleMessage(OFChannelHandler.this, role,
- expectation);
- return false;
+ log.debug("Switch driver indicates no support for Nicira "
+ + "role request messages. Not sending ...");
+ state.handleUnsentRoleMessage(OFChannelHandler.this, role,
+ expectation);
+ return false;
}
// OF1.0 switch with support for NX_ROLE_REQUEST vendor extn.
// make Role.EQUAL become Role.SLAVE
@@ -358,18 +366,18 @@
/**
* Deliver a received role reply.
- *
+ *
* Check if a request is pending and if the received reply matches the
- * the expected pending reply (we check both role and xid) we set
- * the role for the switch/channel.
- *
+ * the expected pending reply (we check both role and xid) we set the
+ * role for the switch/channel.
+ *
* If a request is pending but doesn't match the reply we ignore it, and
* return
- *
+ *
* If no request is pending we disconnect with a SwitchStateException
- *
+ *
* @param RoleReplyInfo information about role-reply in format that
- * controller can understand.
+ * controller can understand.
* @throws SwitchStateException if no request is pending
*/
synchronized RoleRecvStatus deliverRoleReply(RoleReplyInfo rri)
@@ -402,21 +410,22 @@
+ "Switch: {} in State: {}. "
+ "This controller has no current role for this sw. "
+ "Ignoring ...", new Object[] {rri,
- getSwitchInfoString(), state});
+ getSwitchInfoString(), state});
return RoleRecvStatus.OTHER_EXPECTATION;
}
int xid = (int) rri.getXid();
Role role = rri.getRole();
- // XXX S should check generation id meaningfully and other cases of expectations
+ // XXX S should check generation id meaningfully and other cases of
+ // expectations
// U64 genId = rri.getGenId();
if (pendingXid != xid) {
log.debug("Received older role reply from " +
"switch {} ({}). Ignoring. " +
"Waiting for {}, xid={}",
- new Object[] { getSwitchInfoString(), rri,
- pendingRole, pendingXid });
+ new Object[] {getSwitchInfoString(), rri,
+ pendingRole, pendingXid});
return RoleRecvStatus.OLD_REPLY;
}
@@ -449,12 +458,11 @@
}
/**
- * Called if we receive an error message. If the xid matches the
- * pending request we handle it otherwise we ignore it.
- *
- * Note: since we only keep the last pending request we might get
- * error messages for earlier role requests that we won't be able
- * to handle
+ * Called if we receive an error message. If the xid matches the pending
+ * request we handle it otherwise we ignore it.
+ *
+ * Note: since we only keep the last pending request we might get error
+ * messages for earlier role requests that we won't be able to handle
*/
synchronized RoleRecvStatus deliverError(OFErrorMsg error)
throws SwitchStateException {
@@ -473,17 +481,19 @@
}
return RoleRecvStatus.OTHER_EXPECTATION;
}
- // it is an error related to a currently pending role request message
- requestPending = false; // we got a response, even though it is an error
+ // it is an error related to a currently pending role request
+ // message
+ requestPending = false; // we got a response, even though it is an
+ // error
if (error.getErrType() == OFErrorType.BAD_REQUEST) {
counters.roleReplyErrorUnsupported.updateCounterWithFlush();
log.error("Received a error msg {} from sw {} in state {} for "
+ "pending role request {}. Switch driver indicates "
+ "role-messaging is supported. Possible issues in "
+ "switch driver configuration?", new Object[] {
- ((OFBadRequestErrorMsg)error).toString(),
- getSwitchInfoString(), state, pendingRole
- });
+ ((OFBadRequestErrorMsg) error).toString(),
+ getSwitchInfoString(), state, pendingRole
+ });
return RoleRecvStatus.UNSUPPORTED;
}
@@ -514,21 +524,22 @@
}
}
- // This error message was for a role request message but we dont know
+ // This error message was for a role request message but we dont
+ // know
// how to handle errors for nicira role request messages
return RoleRecvStatus.OTHER_EXPECTATION;
}
/**
* Check if a pending role request has timed out.
- *
+ *
* @throws SwitchStateException
*/
void checkTimeout() throws SwitchStateException {
if (!requestPending) {
return;
}
- synchronized(this) {
+ synchronized (this) {
if (!requestPending)
return;
long now = System.currentTimeMillis();
@@ -542,16 +553,18 @@
}
- //*************************
- // Channel State Machine
- //*************************
+ // *************************
+ // Channel State Machine
+ // *************************
/**
* The state machine for handling the switch/channel state. All state
- * transitions should happen from within the state machine (and not from other
- * parts of the code)
+ * transitions should happen from within the state machine (and not from
+ * other parts of the code)
+ *
* @author gregor
- * @author saurav (modified to handle 1.0 & 1.3 switches, EQUAL state, role-handling )
+ * @author saurav (modified to handle 1.0 & 1.3 switches, EQUAL state,
+ * role-handling )
*/
enum ChannelState {
/**
@@ -579,11 +592,11 @@
},
/**
- * We send a OF 1.3 HELLO to the switch and wait for a Hello from the switch.
- * Once we receive the reply, we decide on OF 1.3 or 1.0 switch - no other
- * protocol version is accepted.
- * We send an OFFeaturesRequest depending on the protocol version selected
- * Next state is WAIT_FEATURES_REPLY
+ * We send a OF 1.3 HELLO to the switch and wait for a Hello from the
+ * switch. Once we receive the reply, we decide on OF 1.3 or 1.0 switch
+ * - no other protocol version is accepted. We send an OFFeaturesRequest
+ * depending on the protocol version selected Next state is
+ * WAIT_FEATURES_REPLY
*/
WAIT_HELLO(false) {
@Override
@@ -611,17 +624,20 @@
h.sendHandshakeFeaturesRequestMessage();
h.setState(WAIT_FEATURES_REPLY);
}
+
@Override
- void processOFFeaturesReply(OFChannelHandler h, OFFeaturesReply m)
+ void processOFFeaturesReply(OFChannelHandler h, OFFeaturesReply m)
throws IOException, SwitchStateException {
illegalMessageReceived(h, m);
}
+
@Override
void processOFStatisticsReply(OFChannelHandler h,
- OFStatsReply m)
+ OFStatsReply m)
throws IOException, SwitchStateException {
illegalMessageReceived(h, m);
}
+
@Override
void processOFError(OFChannelHandler h, OFErrorMsg m) {
logErrorDisconnect(h, m);
@@ -634,22 +650,21 @@
}
},
-
/**
* We are waiting for a features reply message. Once we receive it, the
- * behavior depends on whether this is a 1.0 or 1.3 switch. For 1.0,
- * we send a SetConfig request, barrier, and GetConfig request and the
- * next state is WAIT_CONFIG_REPLY. For 1.3, we send a Port description
+ * behavior depends on whether this is a 1.0 or 1.3 switch. For 1.0, we
+ * send a SetConfig request, barrier, and GetConfig request and the next
+ * state is WAIT_CONFIG_REPLY. For 1.3, we send a Port description
* request and the next state is WAIT_PORT_DESC_REPLY.
*/
WAIT_FEATURES_REPLY(false) {
@Override
- void processOFFeaturesReply(OFChannelHandler h, OFFeaturesReply m)
+ void processOFFeaturesReply(OFChannelHandler h, OFFeaturesReply m)
throws IOException {
h.thisdpid = m.getDatapathId().getLong();
log.info("Received features reply for switch at {} with dpid {}",
h.getSwitchInfoString(), h.thisdpid);
- //update the controller about this connected switch
+ // update the controller about this connected switch
boolean success = h.controller.addConnectedSwitch(
h.thisdpid, h);
if (!success) {
@@ -657,22 +672,24 @@
return;
}
- h.featuresReply = m; //temp store
+ h.featuresReply = m; // temp store
if (h.ofVersion == OFVersion.OF_10) {
h.sendHandshakeSetConfig();
h.setState(WAIT_CONFIG_REPLY);
} else {
- //version is 1.3, must get switchport information
+ // version is 1.3, must get switchport information
h.sendHandshakeOFPortDescRequest();
h.setState(WAIT_PORT_DESC_REPLY);
}
}
+
@Override
void processOFStatisticsReply(OFChannelHandler h,
- OFStatsReply m)
+ OFStatsReply m)
throws IOException, SwitchStateException {
illegalMessageReceived(h, m);
}
+
@Override
void processOFError(OFChannelHandler h, OFErrorMsg m) {
logErrorDisconnect(h, m);
@@ -686,9 +703,8 @@
},
/**
- * We are waiting for a description of the 1.3 switch ports.
- * Once received, we send a SetConfig request
- * Next State is WAIT_CONFIG_REPLY
+ * We are waiting for a description of the 1.3 switch ports. Once
+ * received, we send a SetConfig request Next State is WAIT_CONFIG_REPLY
*/
WAIT_PORT_DESC_REPLY(false) {
@@ -707,7 +723,7 @@
+ "port description - not currently handled",
h.getSwitchInfoString());
}
- h.portDescReply = (OFPortDescStatsReply)m; // temp store
+ h.portDescReply = (OFPortDescStatsReply) m; // temp store
log.info("Received port desc reply for switch at {}",
h.getSwitchInfoString());
try {
@@ -735,21 +751,21 @@
},
/**
- * We are waiting for a config reply message. Once we receive it
- * we send a DescriptionStatsRequest to the switch.
- * Next state: WAIT_DESCRIPTION_STAT_REPLY
+ * We are waiting for a config reply message. Once we receive it we send
+ * a DescriptionStatsRequest to the switch. Next state:
+ * WAIT_DESCRIPTION_STAT_REPLY
*/
WAIT_CONFIG_REPLY(false) {
@Override
@LogMessageDocs({
- @LogMessageDoc(level="WARN",
- message="Config Reply from {switch} has " +
- "miss length set to {length}",
- explanation="The controller requires that the switch " +
- "use a miss length of 0xffff for correct " +
- "function",
- recommendation="Use a different switch to ensure " +
- "correct function")
+ @LogMessageDoc(level = "WARN",
+ message = "Config Reply from {switch} has " +
+ "miss length set to {length}",
+ explanation = "The controller requires that the switch " +
+ "use a miss length of 0xffff for correct " +
+ "function",
+ recommendation = "Use a different switch to ensure " +
+ "correct function")
})
void processOFGetConfigReply(OFChannelHandler h, OFGetConfigReply m)
throws IOException {
@@ -775,13 +791,14 @@
}
@Override
- void processOFFeaturesReply(OFChannelHandler h, OFFeaturesReply m)
+ void processOFFeaturesReply(OFChannelHandler h, OFFeaturesReply m)
throws IOException, SwitchStateException {
illegalMessageReceived(h, m);
}
+
@Override
void processOFStatisticsReply(OFChannelHandler h,
- OFStatsReply m)
+ OFStatsReply m)
throws IOException, SwitchStateException {
log.error("Received multipart(stats) message sub-type {}",
m.getStatsType());
@@ -800,29 +817,26 @@
}
},
-
/**
- * We are waiting for a OFDescriptionStat message from the switch.
- * Once we receive any stat message we try to parse it. If it's not
- * a description stats message we disconnect. If its the expected
- * description stats message, we:
- * - use the switch driver to bind the switch and get an IOFSwitch instance
- * - setup the IOFSwitch instance
- * - add switch to FloodlightProvider(Controller) and send the initial role
- * request to the switch.
- * Next state: WAIT_INITIAL_ROLE
- * In the typical case, where switches support role request messages
- * the next state is where we expect the role reply message.
- * In the special case that where the switch does not support any kind
- * of role request messages, we don't send a role message, but we do
- * request mastership from the registry service. This controller
- * should become master once we hear back from the registry service.
- * All following states will have a h.sw instance!
+ * We are waiting for a OFDescriptionStat message from the switch. Once
+ * we receive any stat message we try to parse it. If it's not a
+ * description stats message we disconnect. If its the expected
+ * description stats message, we: - use the switch driver to bind the
+ * switch and get an IOFSwitch instance - setup the IOFSwitch instance -
+ * add switch to FloodlightProvider(Controller) and send the initial
+ * role request to the switch. Next state: WAIT_INITIAL_ROLE In the
+ * typical case, where switches support role request messages the next
+ * state is where we expect the role reply message. In the special case
+ * that where the switch does not support any kind of role request
+ * messages, we don't send a role message, but we do request mastership
+ * from the registry service. This controller should become master once
+ * we hear back from the registry service. All following states will
+ * have a h.sw instance!
*/
WAIT_DESCRIPTION_STAT_REPLY(false) {
- @LogMessageDoc(message="Switch {switch info} bound to class " +
- "{switch driver}, description {switch description}",
- explanation="The specified switch has been bound to " +
+ @LogMessageDoc(message = "Switch {switch info} bound to class " +
+ "{switch driver}, description {switch description}",
+ explanation = "The specified switch has been bound to " +
"a switch driver based on the switch description" +
"received from the switch")
@Override
@@ -838,7 +852,8 @@
log.info("Received switch description reply from switch at {}",
h.channel.getRemoteAddress());
OFDescStatsReply drep = (OFDescStatsReply) m;
- // Here is where we differentiate between different kinds of switches
+ // Here is where we differentiate between different kinds of
+ // switches
h.sw = h.controller.getOFSwitchInstance(drep, h.ofVersion);
// set switch information
h.sw.setOFVersion(h.ofVersion);
@@ -854,12 +869,13 @@
h.counters.switchCounterRegistrationFailed
.updateCounterNoFlush();
log.warn("Could not register counters for switch {} ",
- h.getSwitchInfoString(), e);
+ h.getSwitchInfoString(), e);
}
log.info("Switch {} bound to class {}, description {}",
- new Object[] { h.sw, h.sw.getClass(), drep });
- //Put switch in EQUAL mode until we hear back from the global registry
+ new Object[] {h.sw, h.sw.getClass(), drep});
+ // Put switch in EQUAL mode until we hear back from the global
+ // registry
log.debug("Setting new switch {} to EQUAL and sending Role request",
h.sw.getStringId());
h.setSwitchRole(Role.EQUAL);
@@ -891,7 +907,7 @@
}
@Override
- void processOFFeaturesReply(OFChannelHandler h, OFFeaturesReply m)
+ void processOFFeaturesReply(OFChannelHandler h, OFFeaturesReply m)
throws IOException, SwitchStateException {
illegalMessageReceived(h, m);
}
@@ -908,13 +924,13 @@
* sent after hearing back from the registry service -- OR -- we are
* just waiting to hear back from the registry service in the case that
* the switch does not support role messages. If completed successfully,
- * the controller's role for this switch will be set here.
- * Before we move to the state corresponding to the role, we allow the
- * switch specific driver to complete its configuration. This configuration
- * typically depends on the role the controller is playing for this switch.
- * And so we set the switch role (for 'this' controller) before we start
- * the driver-sub-handshake.
- * Next State: WAIT_SWITCH_DRIVER_SUB_HANDSHAKE
+ * the controller's role for this switch will be set here. Before we
+ * move to the state corresponding to the role, we allow the switch
+ * specific driver to complete its configuration. This configuration
+ * typically depends on the role the controller is playing for this
+ * switch. And so we set the switch role (for 'this' controller) before
+ * we start the driver-sub-handshake. Next State:
+ * WAIT_SWITCH_DRIVER_SUB_HANDSHAKE
*/
WAIT_INITIAL_ROLE(false) {
@Override
@@ -947,7 +963,7 @@
@Override
void processOFRoleReply(OFChannelHandler h, OFRoleReply m)
throws SwitchStateException, IOException {
- RoleReplyInfo rri = extractOFRoleReply(h,m);
+ RoleReplyInfo rri = extractOFRoleReply(h, m);
RoleRecvStatus rrs = h.roleChanger.deliverRoleReply(rri);
if (rrs == RoleRecvStatus.MATCHED_SET_ROLE) {
setRoleAndStartDriverHandshake(h, rri.getRole());
@@ -956,22 +972,22 @@
@Override
void handleUnsentRoleMessage(OFChannelHandler h, Role role,
- RoleRecvStatus expectation) throws IOException {
- // typically this is triggered for a switch where role messages
- // are not supported - we confirm that the role being set is
- // master and move to the next state
- if (expectation == RoleRecvStatus.MATCHED_SET_ROLE) {
- if (role == Role.MASTER) {
- setRoleAndStartDriverHandshake(h, role);
- } else {
- log.error("Expected MASTER role from registry for switch "
- + "which has no support for role-messages."
- + "Received {}. It is possible that this switch "
- + "is connected to other controllers, in which "
- + "case it should support role messages - not "
- + "moving forward.", role);
- }
- } // else do nothing - wait to hear back from registry
+ RoleRecvStatus expectation) throws IOException {
+ // typically this is triggered for a switch where role messages
+ // are not supported - we confirm that the role being set is
+ // master and move to the next state
+ if (expectation == RoleRecvStatus.MATCHED_SET_ROLE) {
+ if (role == Role.MASTER) {
+ setRoleAndStartDriverHandshake(h, role);
+ } else {
+ log.error("Expected MASTER role from registry for switch "
+ + "which has no support for role-messages."
+ + "Received {}. It is possible that this switch "
+ + "is connected to other controllers, in which "
+ + "case it should support role messages - not "
+ + "moving forward.", role);
+ }
+ } // else do nothing - wait to hear back from registry
}
@@ -985,7 +1001,7 @@
log.info("Switch-driver sub-handshake complete. "
+ "Activating switch {} with Role: MASTER",
h.getSwitchInfoString());
- handlePendingPortStatusMessages(h); //before activation
+ handlePendingPortStatusMessages(h); // before activation
boolean success = h.controller.addActivatedMasterSwitch(
h.sw.getId(), h.sw);
if (!success) {
@@ -997,7 +1013,7 @@
log.info("Switch-driver sub-handshake complete. "
+ "Activating switch {} with Role: EQUAL",
h.getSwitchInfoString());
- handlePendingPortStatusMessages(h); //before activation
+ handlePendingPortStatusMessages(h); // before activation
boolean success = h.controller.addActivatedEqualSwitch(
h.sw.getId(), h.sw);
if (!success) {
@@ -1012,7 +1028,7 @@
}
@Override
- void processOFFeaturesReply(OFChannelHandler h, OFFeaturesReply m)
+ void processOFFeaturesReply(OFChannelHandler h, OFFeaturesReply m)
throws IOException, SwitchStateException {
illegalMessageReceived(h, m);
}
@@ -1033,11 +1049,11 @@
/**
* We are waiting for the respective switch driver to complete its
- * configuration. Notice that we do not consider this to be part of the main
- * switch-controller handshake. But we do consider it as a step that comes
- * before we declare the switch as available to the controller.
- * Next State: depends on the role of this controller for this switch - either
- * MASTER or EQUAL.
+ * configuration. Notice that we do not consider this to be part of the
+ * main switch-controller handshake. But we do consider it as a step
+ * that comes before we declare the switch as available to the
+ * controller. Next State: depends on the role of this controller for
+ * this switch - either MASTER or EQUAL.
*/
WAIT_SWITCH_DRIVER_SUB_HANDSHAKE(true) {
@@ -1051,7 +1067,7 @@
void processOFMessage(OFChannelHandler h, OFMessage m)
throws IOException {
if (m.getType() == OFType.ECHO_REQUEST)
- processOFEchoRequest(h, (OFEchoRequest)m);
+ processOFEchoRequest(h, (OFEchoRequest) m);
else {
// FIXME: other message to handle here?
h.sw.processDriverHandshakeMessage(m);
@@ -1062,7 +1078,8 @@
log.info("Switch-driver sub-handshake complete. "
+ "Activating switch {} with Role: MASTER",
h.getSwitchInfoString());
- handlePendingPortStatusMessages(h); //before activation
+ handlePendingPortStatusMessages(h); // before
+ // activation
boolean success = h.controller.addActivatedMasterSwitch(
h.sw.getId(), h.sw);
if (!success) {
@@ -1074,7 +1091,8 @@
log.info("Switch-driver sub-handshake complete. "
+ "Activating switch {} with Role: EQUAL",
h.getSwitchInfoString());
- handlePendingPortStatusMessages(h); //before activation
+ handlePendingPortStatusMessages(h); // before
+ // activation
boolean success = h.controller.addActivatedEqualSwitch(
h.sw.getId(), h.sw);
if (!success) {
@@ -1094,43 +1112,40 @@
}
},
-
/**
- * This controller is in MASTER role for this switch. We enter this state
- * after requesting and winning control from the global registry.
- * The main handshake as well as the switch-driver sub-handshake
- * is complete at this point.
- * // XXX S reconsider below
- * In the (near) future we may deterministically assign controllers to
- * switches at startup.
- * We only leave this state if the switch disconnects or
- * if we send a role request for SLAVE /and/ receive the role reply for
- * SLAVE.
+ * This controller is in MASTER role for this switch. We enter this
+ * state after requesting and winning control from the global registry.
+ * The main handshake as well as the switch-driver sub-handshake is
+ * complete at this point. // XXX S reconsider below In the (near)
+ * future we may deterministically assign controllers to switches at
+ * startup. We only leave this state if the switch disconnects or if we
+ * send a role request for SLAVE /and/ receive the role reply for SLAVE.
*/
MASTER(true) {
- @LogMessageDoc(level="WARN",
- message="Received permission error from switch {} while" +
- "being master. Reasserting master role.",
- explanation="The switch has denied an operation likely " +
- "indicating inconsistent controller roles",
- recommendation="This situation can occurs transiently during role" +
- " changes. If, however, the condition persists or happens" +
- " frequently this indicates a role inconsistency. " +
- LogMessageDoc.CHECK_CONTROLLER )
+ @LogMessageDoc(level = "WARN",
+ message = "Received permission error from switch {} while" +
+ "being master. Reasserting master role.",
+ explanation = "The switch has denied an operation likely " +
+ "indicating inconsistent controller roles",
+ recommendation = "This situation can occurs transiently during role" +
+ " changes. If, however, the condition persists or happens" +
+ " frequently this indicates a role inconsistency. " +
+ LogMessageDoc.CHECK_CONTROLLER)
@Override
void processOFError(OFChannelHandler h, OFErrorMsg m)
throws IOException, SwitchStateException {
- // first check if the error msg is in response to a role-request message
+ // first check if the error msg is in response to a role-request
+ // message
RoleRecvStatus rrstatus = h.roleChanger.deliverError(m);
if (rrstatus != RoleRecvStatus.OTHER_EXPECTATION) {
- // rolechanger has handled the error message - we are done
+ // rolechanger has handled the error message - we are done
return;
}
// if we get here, then the error message is for something else
if (m.getErrType() == OFErrorType.BAD_REQUEST &&
((OFBadRequestErrorMsg) m).getCode() ==
- OFBadRequestCode.EPERM) {
+ OFBadRequestCode.EPERM) {
// We are the master controller and the switch returned
// a permission error. This is a likely indicator that
// the switch thinks we are slave. Reassert our
@@ -1141,14 +1156,14 @@
// persist before we reassert
h.counters.epermErrorWhileSwitchIsMaster.updateCounterWithFlush();
log.warn("Received permission error from switch {} while" +
- "being master. Reasserting master role.",
- h.getSwitchInfoString());
- //h.controller.reassertRole(h, Role.MASTER);
+ "being master. Reasserting master role.",
+ h.getSwitchInfoString());
+ // h.controller.reassertRole(h, Role.MASTER);
// XXX S reassert in role changer or reconsider if all this
// stuff is really needed
} else if (m.getErrType() == OFErrorType.FLOW_MOD_FAILED &&
- ((OFFlowModFailedErrorMsg) m).getCode() ==
- OFFlowModFailedCode.ALL_TABLES_FULL) {
+ ((OFFlowModFailedErrorMsg) m).getCode() ==
+ OFFlowModFailedCode.ALL_TABLES_FULL) {
h.sw.setTableFull(true);
} else {
logError(h, m);
@@ -1158,7 +1173,7 @@
@Override
void processOFStatisticsReply(OFChannelHandler h,
- OFStatsReply m) {
+ OFStatsReply m) {
h.sw.deliverStatisticsReply(m);
}
@@ -1167,16 +1182,16 @@
throws IOException, SwitchStateException {
Role role = extractNiciraRoleReply(h, m);
if (role == null) {
- // The message wasn't really a Nicira role reply. We just
- // dispatch it to the OFMessage listeners in this case.
- h.dispatchMessage(m);
- return;
+ // The message wasn't really a Nicira role reply. We just
+ // dispatch it to the OFMessage listeners in this case.
+ h.dispatchMessage(m);
+ return;
}
RoleRecvStatus rrs = h.roleChanger.deliverRoleReply(
- new RoleReplyInfo(role, null, m.getXid()));
+ new RoleReplyInfo(role, null, m.getXid()));
if (rrs == RoleRecvStatus.MATCHED_SET_ROLE) {
- checkAndSetRoleTransition(h, role);
+ checkAndSetRoleTransition(h, role);
}
}
@@ -1186,7 +1201,7 @@
RoleReplyInfo rri = extractOFRoleReply(h, m);
RoleRecvStatus rrs = h.roleChanger.deliverRoleReply(rri);
if (rrs == RoleRecvStatus.MATCHED_SET_ROLE) {
- checkAndSetRoleTransition(h, rri.getRole());
+ checkAndSetRoleTransition(h, rri.getRole());
}
}
@@ -1205,14 +1220,14 @@
@Override
void processOFFlowRemoved(OFChannelHandler h,
- OFFlowRemoved m) throws IOException {
+ OFFlowRemoved m) throws IOException {
h.dispatchMessage(m);
}
@Override
void processOFBarrierReply(OFChannelHandler h, OFBarrierReply m)
throws IOException {
- h.dispatchMessage(m);
+ h.dispatchMessage(m);
}
},
@@ -1223,15 +1238,16 @@
* switch. The EQUAL role can be considered the same as the SLAVE role
* if this controller does NOT send commands or packets to the switch.
* This should always be true for OF1.0 switches. XXX S need to enforce.
- *
+ *
* For OF1.3 switches, choosing this state as EQUAL instead of SLAVE,
- * gives us the flexibility that if an app wants to send commands/packets
- * to switches, it can, even thought it is running on a controller instance
- * that is not in a MASTER role for this switch. Of course, it is the job
- * of the app to ensure that commands/packets sent by this (EQUAL) controller
- * instance does not clash/conflict with commands/packets sent by the MASTER
- * controller for this switch. Neither the controller instances, nor the
- * switch provides any kind of resolution mechanism should conflicts occur.
+ * gives us the flexibility that if an app wants to send
+ * commands/packets to switches, it can, even thought it is running on a
+ * controller instance that is not in a MASTER role for this switch. Of
+ * course, it is the job of the app to ensure that commands/packets sent
+ * by this (EQUAL) controller instance does not clash/conflict with
+ * commands/packets sent by the MASTER controller for this switch.
+ * Neither the controller instances, nor the switch provides any kind of
+ * resolution mechanism should conflicts occur.
*/
EQUAL(true) {
@Override
@@ -1247,7 +1263,7 @@
@Override
void processOFStatisticsReply(OFChannelHandler h,
- OFStatsReply m) {
+ OFStatsReply m) {
h.sw.deliverStatisticsReply(m);
}
@@ -1258,10 +1274,10 @@
// If role == null it means the message wasn't really a
// Nicira role reply. We ignore it in this state.
if (role != null) {
- RoleRecvStatus rrs = h.roleChanger.deliverRoleReply(
+ RoleRecvStatus rrs = h.roleChanger.deliverRoleReply(
new RoleReplyInfo(role, null, m.getXid()));
- if (rrs == RoleRecvStatus.MATCHED_SET_ROLE) {
- checkAndSetRoleTransition(h, role);
+ if (rrs == RoleRecvStatus.MATCHED_SET_ROLE) {
+ checkAndSetRoleTransition(h, role);
}
} else {
unhandledMessageReceived(h, m);
@@ -1274,7 +1290,7 @@
RoleReplyInfo rri = extractOFRoleReply(h, m);
RoleRecvStatus rrs = h.roleChanger.deliverRoleReply(rri);
if (rrs == RoleRecvStatus.MATCHED_SET_ROLE) {
- checkAndSetRoleTransition(h, rri.getRole());
+ checkAndSetRoleTransition(h, rri.getRole());
}
}
@@ -1287,32 +1303,34 @@
}
@Override
- @LogMessageDoc(level="WARN",
- message="Received PacketIn from switch {} while" +
- "being slave. Reasserting slave role.",
- explanation="The switch has receive a PacketIn despite being " +
- "in slave role indicating inconsistent controller roles",
- recommendation="This situation can occurs transiently during role" +
- " changes. If, however, the condition persists or happens" +
- " frequently this indicates a role inconsistency. " +
- LogMessageDoc.CHECK_CONTROLLER )
+ @LogMessageDoc(level = "WARN",
+ message = "Received PacketIn from switch {} while" +
+ "being slave. Reasserting slave role.",
+ explanation = "The switch has receive a PacketIn despite being " +
+ "in slave role indicating inconsistent controller roles",
+ recommendation = "This situation can occurs transiently during role" +
+ " changes. If, however, the condition persists or happens" +
+ " frequently this indicates a role inconsistency. " +
+ LogMessageDoc.CHECK_CONTROLLER)
void processOFPacketIn(OFChannelHandler h, OFPacketIn m) throws IOException {
// we don't expect packetIn while slave, reassert we are slave
h.counters.packetInWhileSwitchIsSlave.updateCounterNoFlush();
log.warn("Received PacketIn from switch {} while" +
- "being slave. Reasserting slave role.", h.sw);
- //h.controller.reassertRole(h, Role.SLAVE);
+ "being slave. Reasserting slave role.", h.sw);
+ // h.controller.reassertRole(h, Role.SLAVE);
// XXX reassert in role changer
}
};
private final boolean handshakeComplete;
+
ChannelState(boolean handshakeComplete) {
this.handshakeComplete = handshakeComplete;
}
/**
* Is this a state in which the handshake has completed?
+ *
* @return true if the handshake is complete
*/
public boolean isHandshakeComplete() {
@@ -1320,32 +1338,33 @@
}
/**
- * Get a string specifying the switch connection, state, and
- * message received. To be used as message for SwitchStateException
- * or log messages
+ * Get a string specifying the switch connection, state, and message
+ * received. To be used as message for SwitchStateException or log
+ * messages
+ *
* @param h The channel handler (to get switch information_
* @param m The OFMessage that has just been received
- * @param details A string giving more details about the exact nature
- * of the problem.
+ * @param details A string giving more details about the exact nature of
+ * the problem.
* @return
*/
// needs to be protected because enum members are actually subclasses
protected String getSwitchStateMessage(OFChannelHandler h,
- OFMessage m,
- String details) {
+ OFMessage m,
+ String details) {
return String.format("Switch: [%s], State: [%s], received: [%s]"
- + ", details: %s",
- h.getSwitchInfoString(),
- this.toString(),
- m.getType().toString(),
- details);
+ + ", details: %s",
+ h.getSwitchInfoString(),
+ this.toString(),
+ m.getType().toString(),
+ details);
}
/**
- * We have an OFMessage we didn't expect given the current state and
- * we want to treat this as an error.
- * We currently throw an exception that will terminate the connection
- * However, we could be more forgiving
+ * We have an OFMessage we didn't expect given the current state and we
+ * want to treat this as an error. We currently throw an exception that
+ * will terminate the connection However, we could be more forgiving
+ *
* @param h the channel handler that received the message
* @param m the message
* @throws SwitchStateException
@@ -1361,13 +1380,14 @@
}
/**
- * We have an OFMessage we didn't expect given the current state and
- * we want to ignore the message
+ * We have an OFMessage we didn't expect given the current state and we
+ * want to ignore the message
+ *
* @param h the channel handler the received the message
* @param m the message
*/
protected void unhandledMessageReceived(OFChannelHandler h,
- OFMessage m) {
+ OFMessage m) {
h.counters.unhandledMessage.updateCounterNoFlush();
if (log.isDebugEnabled()) {
String msg = getSwitchStateMessage(h, m,
@@ -1378,29 +1398,31 @@
/**
* Log an OpenFlow error message from a switch
+ *
* @param sw The switch that sent the error
* @param error The error message
*/
- @LogMessageDoc(level="ERROR",
- message="Error {error type} {error code} from {switch} " +
+ @LogMessageDoc(level = "ERROR",
+ message = "Error {error type} {error code} from {switch} " +
"in state {state}",
- explanation="The switch responded with an unexpected error" +
+ explanation = "The switch responded with an unexpected error" +
"to an OpenFlow message from the controller",
- recommendation="This could indicate improper network operation. " +
+ recommendation = "This could indicate improper network operation. " +
"If the problem persists restarting the switch and " +
"controller may help."
)
- protected void logError(OFChannelHandler h, OFErrorMsg error) {
+ protected void logError(OFChannelHandler h, OFErrorMsg error) {
log.error("{} from switch {} in state {}",
- new Object[] {
- error,
- h.getSwitchInfoString(),
- this.toString()});
+ new Object[] {
+ error,
+ h.getSwitchInfoString(),
+ this.toString()});
}
/**
* Log an OpenFlow error message from a switch and disconnect the
* channel
+ *
* @param sw The switch that sent the error
* @param error The error message
*/
@@ -1421,50 +1443,50 @@
/**
* Extract the role from an OFVendor message.
- *
- * Extract the role from an OFVendor message if the message is a
- * Nicira role reply. Otherwise return null.
- *
+ *
+ * Extract the role from an OFVendor message if the message is a Nicira
+ * role reply. Otherwise return null.
+ *
* @param h The channel handler receiving the message
* @param vendorMessage The vendor message to parse.
* @return The role in the message if the message is a Nicira role
- * reply, null otherwise.
+ * reply, null otherwise.
* @throws SwitchStateException If the message is a Nicira role reply
- * but the numeric role value is unknown.
+ * but the numeric role value is unknown.
*/
protected Role extractNiciraRoleReply(OFChannelHandler h,
- OFExperimenter experimenterMsg) throws SwitchStateException {
- int vendor = (int) experimenterMsg.getExperimenter();
- if (vendor != 0x2320) // magic number representing nicira
- return null;
- OFNiciraControllerRoleReply nrr =
- (OFNiciraControllerRoleReply) experimenterMsg;
+ OFExperimenter experimenterMsg) throws SwitchStateException {
+ int vendor = (int) experimenterMsg.getExperimenter();
+ if (vendor != 0x2320) // magic number representing nicira
+ return null;
+ OFNiciraControllerRoleReply nrr =
+ (OFNiciraControllerRoleReply) experimenterMsg;
- Role role = null;
- OFNiciraControllerRole ncr = nrr.getRole();
- switch(ncr) {
- case ROLE_MASTER:
- role = Role.MASTER;
- break;
- case ROLE_OTHER:
- role = Role.EQUAL;
- break;
- case ROLE_SLAVE:
- role = Role.SLAVE;
- break;
- default: //handled below
- }
+ Role role = null;
+ OFNiciraControllerRole ncr = nrr.getRole();
+ switch (ncr) {
+ case ROLE_MASTER:
+ role = Role.MASTER;
+ break;
+ case ROLE_OTHER:
+ role = Role.EQUAL;
+ break;
+ case ROLE_SLAVE:
+ role = Role.SLAVE;
+ break;
+ default: // handled below
+ }
- if (role == null) {
- String msg = String.format("Switch: [%s], State: [%s], "
- + "received NX_ROLE_REPLY with invalid role "
- + "value %d",
- h.getSwitchInfoString(),
- this.toString(),
- nrr.getRole());
- throw new SwitchStateException(msg);
- }
- return role;
+ if (role == null) {
+ String msg = String.format("Switch: [%s], State: [%s], "
+ + "received NX_ROLE_REPLY with invalid role "
+ + "value %d",
+ h.getSwitchInfoString(),
+ this.toString(),
+ nrr.getRole());
+ throw new SwitchStateException(msg);
+ }
+ return role;
}
/**
@@ -1476,14 +1498,24 @@
private U64 genId;
private long xid;
- RoleReplyInfo (Role role, U64 genId, long xid) {
+ RoleReplyInfo(Role role, U64 genId, long xid) {
this.role = role;
this.genId = genId;
this.xid = xid;
}
- public Role getRole() { return role; }
- public U64 getGenId() { return genId; }
- public long getXid() { return xid; }
+
+ public Role getRole() {
+ return role;
+ }
+
+ public U64 getGenId() {
+ return genId;
+ }
+
+ public long getXid() {
+ return xid;
+ }
+
@Override
public String toString() {
return "[Role:" + role + " GenId:" + genId + " Xid:" + xid + "]";
@@ -1492,6 +1524,7 @@
/**
* Extract the role information from an OF1.3 Role Reply Message
+ *
* @param h
* @param rrmsg
* @return RoleReplyInfo object
@@ -1501,7 +1534,7 @@
OFRoleReply rrmsg) throws SwitchStateException {
OFControllerRole cr = rrmsg.getRole();
Role role = null;
- switch(cr) {
+ switch (cr) {
case ROLE_EQUAL:
role = Role.EQUAL;
break;
@@ -1524,10 +1557,11 @@
/**
* Handles all pending port status messages before a switch is declared
* activated in MASTER or EQUAL role. Note that since this handling
- * precedes the activation (and therefore notification to IOFSwitchListerners)
- * the changes to ports will already be visible once the switch is
- * activated. As a result, no notifications are sent out for these
- * pending portStatus messages.
+ * precedes the activation (and therefore notification to
+ * IOFSwitchListerners) the changes to ports will already be visible
+ * once the switch is activated. As a result, no notifications are sent
+ * out for these pending portStatus messages.
+ *
* @param h
* @throws SwitchStateException
*/
@@ -1546,8 +1580,8 @@
"happen";
throw new SwitchStateException(msg);
}
- ArrayList<OFPortStatus> temp = new ArrayList<OFPortStatus>();
- for (OFPortStatus ps: h.pendingPortStatusMsg) {
+ ArrayList<OFPortStatus> temp = new ArrayList<OFPortStatus>();
+ for (OFPortStatus ps : h.pendingPortStatusMsg) {
temp.add(ps);
handlePortStatusMessage(h, ps, false);
}
@@ -1555,9 +1589,12 @@
// expensive but ok - we don't expect too many port-status messages
// note that we cannot use clear(), because of the reasons below
h.pendingPortStatusMsg.removeAll(temp);
- // the iterator above takes a snapshot of the list - so while we were
- // dealing with the pending port-status messages, we could have received
- // newer ones. Handle them recursively, but break the recursion after
+ // the iterator above takes a snapshot of the list - so while we
+ // were
+ // dealing with the pending port-status messages, we could have
+ // received
+ // newer ones. Handle them recursively, but break the recursion
+ // after
// five steps to avoid an attack.
if (!h.pendingPortStatusMsg.isEmpty() && ++index < 5) {
handlePendingPortStatusMessages(h, index);
@@ -1566,30 +1603,29 @@
/**
* Handle a port status message.
- *
+ *
* Handle a port status message by updating the port maps in the
- * IOFSwitch instance and notifying Controller about the change so
- * it can dispatch a switch update.
- *
+ * IOFSwitch instance and notifying Controller about the change so it
+ * can dispatch a switch update.
+ *
* @param h The OFChannelHhandler that received the message
* @param m The PortStatus message we received
- * @param doNotify if true switch port changed events will be
- * dispatched
+ * @param doNotify if true switch port changed events will be dispatched
* @throws SwitchStateException
- *
+ *
*/
protected void handlePortStatusMessage(OFChannelHandler h, OFPortStatus m,
boolean doNotify) throws SwitchStateException {
if (h.sw == null) {
String msg = getSwitchStateMessage(h, m,
"State machine error: switch is null. Should never " +
- "happen");
+ "happen");
throw new SwitchStateException(msg);
}
Collection<PortChangeEvent> changes = h.sw.processOFPortStatus(m);
if (doNotify) {
- for (PortChangeEvent ev: changes)
+ for (PortChangeEvent ev : changes)
h.controller.notifyPortChanged(h.sw.getId(), ev.port, ev.type);
}
}
@@ -1597,56 +1633,56 @@
/**
* Checks if the role received (from the role-reply msg) is different
* from the existing role in the IOFSwitch object for this controller.
- * If so, it transitions the controller to the new role. Note that
- * the caller should have already verified that the role-reply msg
- * received was in response to a role-request msg sent out by this
- * controller after hearing from the registry service.
- *
+ * If so, it transitions the controller to the new role. Note that the
+ * caller should have already verified that the role-reply msg received
+ * was in response to a role-request msg sent out by this controller
+ * after hearing from the registry service.
+ *
* @param h the ChannelHandler that received the message
* @param role the role in the recieved role reply message
*/
protected void checkAndSetRoleTransition(OFChannelHandler h, Role role) {
- // we received a role-reply in response to a role message
- // sent after hearing from the registry service. It is
- // possible that the role of this controller instance for
- // this switch has changed:
- // for 1.0 switch: from MASTER to SLAVE
- // for 1.3 switch: from MASTER to EQUAL
- if ((h.sw.getRole() == Role.MASTER && role == Role.SLAVE) ||
- (h.sw.getRole() == Role.MASTER && role == Role.EQUAL)) {
- // the mastership has changed
- h.sw.setRole(role);
- h.setState(EQUAL);
- h.controller.transitionToEqualSwitch(h.sw.getId());
- return;
- }
+ // we received a role-reply in response to a role message
+ // sent after hearing from the registry service. It is
+ // possible that the role of this controller instance for
+ // this switch has changed:
+ // for 1.0 switch: from MASTER to SLAVE
+ // for 1.3 switch: from MASTER to EQUAL
+ if ((h.sw.getRole() == Role.MASTER && role == Role.SLAVE) ||
+ (h.sw.getRole() == Role.MASTER && role == Role.EQUAL)) {
+ // the mastership has changed
+ h.sw.setRole(role);
+ h.setState(EQUAL);
+ h.controller.transitionToEqualSwitch(h.sw.getId());
+ return;
+ }
- // or for both 1.0 and 1.3 switches from EQUAL to MASTER.
- // note that for 1.0, even though we mean SLAVE,
- // internally we call the role EQUAL.
- if (h.sw.getRole() == Role.EQUAL && role == Role.MASTER) {
- // the mastership has changed
- h.sw.setRole(role);
- h.setState(MASTER);
- h.controller.transitionToMasterSwitch(h.sw.getId());
- return;
- }
+ // or for both 1.0 and 1.3 switches from EQUAL to MASTER.
+ // note that for 1.0, even though we mean SLAVE,
+ // internally we call the role EQUAL.
+ if (h.sw.getRole() == Role.EQUAL && role == Role.MASTER) {
+ // the mastership has changed
+ h.sw.setRole(role);
+ h.setState(MASTER);
+ h.controller.transitionToMasterSwitch(h.sw.getId());
+ return;
+ }
}
/**
- * Process an OF message received on the channel and
- * update state accordingly.
- *
+ * Process an OF message received on the channel and update state
+ * accordingly.
+ *
* The main "event" of the state machine. Process the received message,
* send follow up message if required and update state if required.
- *
+ *
* Switches on the message type and calls more specific event handlers
- * for each individual OF message type. If we receive a message that
- * is supposed to be sent from a controller to a switch we throw
- * a SwitchStateExeption.
- *
+ * for each individual OF message type. If we receive a message that is
+ * supposed to be sent from a controller to a switch we throw a
+ * SwitchStateExeption.
+ *
* The more specific handlers can also throw SwitchStateExceptions
- *
+ *
* @param h The OFChannelHandler that received the message
* @param m The message we received.
* @throws SwitchStateException
@@ -1655,72 +1691,72 @@
void processOFMessage(OFChannelHandler h, OFMessage m)
throws IOException, SwitchStateException {
h.roleChanger.checkTimeout();
- switch(m.getType()) {
- case HELLO:
- processOFHello(h, (OFHello)m);
- break;
- case BARRIER_REPLY:
- processOFBarrierReply(h, (OFBarrierReply)m);
- break;
- case ECHO_REPLY:
- processOFEchoReply(h, (OFEchoReply)m);
- break;
- case ECHO_REQUEST:
- processOFEchoRequest(h, (OFEchoRequest)m);
- break;
- case ERROR:
- processOFError(h, (OFErrorMsg)m);
- break;
- case FEATURES_REPLY:
- processOFFeaturesReply(h, (OFFeaturesReply)m);
- break;
- case FLOW_REMOVED:
- processOFFlowRemoved(h, (OFFlowRemoved)m);
- break;
- case GET_CONFIG_REPLY:
- processOFGetConfigReply(h, (OFGetConfigReply)m);
- break;
- case PACKET_IN:
- processOFPacketIn(h, (OFPacketIn)m);
- break;
- case PORT_STATUS:
- processOFPortStatus(h, (OFPortStatus)m);
- break;
- case QUEUE_GET_CONFIG_REPLY:
- processOFQueueGetConfigReply(h, (OFQueueGetConfigReply)m);
- break;
- case STATS_REPLY: // multipart_reply in 1.3
- processOFStatisticsReply(h, (OFStatsReply)m);
- break;
- case EXPERIMENTER:
- processOFExperimenter(h, (OFExperimenter)m);
- break;
- case ROLE_REPLY:
- processOFRoleReply(h, (OFRoleReply)m);
- break;
- case GET_ASYNC_REPLY:
- processOFGetAsyncReply(h, (OFAsyncGetReply)m);
- break;
+ switch (m.getType()) {
+ case HELLO:
+ processOFHello(h, (OFHello) m);
+ break;
+ case BARRIER_REPLY:
+ processOFBarrierReply(h, (OFBarrierReply) m);
+ break;
+ case ECHO_REPLY:
+ processOFEchoReply(h, (OFEchoReply) m);
+ break;
+ case ECHO_REQUEST:
+ processOFEchoRequest(h, (OFEchoRequest) m);
+ break;
+ case ERROR:
+ processOFError(h, (OFErrorMsg) m);
+ break;
+ case FEATURES_REPLY:
+ processOFFeaturesReply(h, (OFFeaturesReply) m);
+ break;
+ case FLOW_REMOVED:
+ processOFFlowRemoved(h, (OFFlowRemoved) m);
+ break;
+ case GET_CONFIG_REPLY:
+ processOFGetConfigReply(h, (OFGetConfigReply) m);
+ break;
+ case PACKET_IN:
+ processOFPacketIn(h, (OFPacketIn) m);
+ break;
+ case PORT_STATUS:
+ processOFPortStatus(h, (OFPortStatus) m);
+ break;
+ case QUEUE_GET_CONFIG_REPLY:
+ processOFQueueGetConfigReply(h, (OFQueueGetConfigReply) m);
+ break;
+ case STATS_REPLY: // multipart_reply in 1.3
+ processOFStatisticsReply(h, (OFStatsReply) m);
+ break;
+ case EXPERIMENTER:
+ processOFExperimenter(h, (OFExperimenter) m);
+ break;
+ case ROLE_REPLY:
+ processOFRoleReply(h, (OFRoleReply) m);
+ break;
+ case GET_ASYNC_REPLY:
+ processOFGetAsyncReply(h, (OFAsyncGetReply) m);
+ break;
- // The following messages are sent to switches. The controller
- // should never receive them
- case SET_CONFIG:
- case GET_CONFIG_REQUEST:
- case PACKET_OUT:
- case PORT_MOD:
- case QUEUE_GET_CONFIG_REQUEST:
- case BARRIER_REQUEST:
- case STATS_REQUEST: // multipart request in 1.3
- case FEATURES_REQUEST:
- case FLOW_MOD:
- case GROUP_MOD:
- case TABLE_MOD:
- case GET_ASYNC_REQUEST:
- case SET_ASYNC:
- case METER_MOD:
- default:
- illegalMessageReceived(h, m);
- break;
+ // The following messages are sent to switches. The controller
+ // should never receive them
+ case SET_CONFIG:
+ case GET_CONFIG_REQUEST:
+ case PACKET_OUT:
+ case PORT_MOD:
+ case QUEUE_GET_CONFIG_REQUEST:
+ case BARRIER_REQUEST:
+ case STATS_REQUEST: // multipart request in 1.3
+ case FEATURES_REQUEST:
+ case FLOW_MOD:
+ case GROUP_MOD:
+ case TABLE_MOD:
+ case GET_ASYNC_REQUEST:
+ case SET_ASYNC:
+ case METER_MOD:
+ default:
+ illegalMessageReceived(h, m);
+ break;
}
}
@@ -1750,7 +1786,7 @@
}
void processOFEchoRequest(OFChannelHandler h, OFEchoRequest m)
- throws IOException {
+ throws IOException {
if (h.ofVersion == null) {
log.error("No OF version set for {}. Not sending Echo REPLY",
h.channel.getRemoteAddress());
@@ -1766,7 +1802,7 @@
}
void processOFEchoReply(OFChannelHandler h, OFEchoReply m)
- throws IOException {
+ throws IOException {
// Do nothing with EchoReplies !!
}
@@ -1775,14 +1811,13 @@
abstract void processOFError(OFChannelHandler h, OFErrorMsg m)
throws IOException, SwitchStateException;
-
- void processOFFeaturesReply(OFChannelHandler h, OFFeaturesReply m)
+ void processOFFeaturesReply(OFChannelHandler h, OFFeaturesReply m)
throws IOException, SwitchStateException {
unhandledMessageReceived(h, m);
}
void processOFFlowRemoved(OFChannelHandler h, OFFlowRemoved m)
- throws IOException {
+ throws IOException {
unhandledMessageReceived(h, m);
}
@@ -1802,7 +1837,7 @@
throws IOException, SwitchStateException;
void processOFQueueGetConfigReply(OFChannelHandler h,
- OFQueueGetConfigReply m)
+ OFQueueGetConfigReply m)
throws IOException {
unhandledMessageReceived(h, m);
}
@@ -1831,8 +1866,8 @@
}
void handleUnsentRoleMessage(OFChannelHandler h, Role role,
- RoleRecvStatus expectation) throws IOException {
- // do nothing in most states
+ RoleRecvStatus expectation) throws IOException {
+ // do nothing in most states
}
/**
@@ -1841,7 +1876,7 @@
* Role request messages that don't get role-replies (or errors related
* to the request) time out after DEFAULT_ROLE_TIMEOUT_MS secs, at which
* time the controller state-machine disconnects the switch
- *
+ *
* @param h the channel handler for this switch
* @param pendingRole the role for which no reply was received
* @throws SwitchStateException
@@ -1855,114 +1890,116 @@
}
}
-
-
- //*************************
- // Channel handler methods
- //*************************
+ // *************************
+ // Channel handler methods
+ // *************************
@Override
- @LogMessageDoc(message="New switch connection from {ip address}",
- explanation="A new switch has connected from the " +
- "specified IP address")
+ @LogMessageDoc(message = "New switch connection from {ip address}",
+ explanation = "A new switch has connected from the " +
+ "specified IP address")
public void channelConnected(ChannelHandlerContext ctx,
- ChannelStateEvent e) throws Exception {
+ ChannelStateEvent e) throws Exception {
counters.switchConnected.updateCounterWithFlush();
channel = e.getChannel();
log.info("New switch connection from {}",
- channel.getRemoteAddress());
+ channel.getRemoteAddress());
sendHandshakeHelloMessage();
setState(ChannelState.WAIT_HELLO);
}
@Override
- @LogMessageDoc(message="Disconnected switch {switch information}",
- explanation="The specified switch has disconnected.")
+ @LogMessageDoc(message = "Disconnected switch {switch information}",
+ explanation = "The specified switch has disconnected.")
public void channelDisconnected(ChannelHandlerContext ctx,
- ChannelStateEvent e) throws Exception {
+ ChannelStateEvent e) throws Exception {
log.info("Switch disconnected callback for sw:{}. Cleaning up ...",
- getSwitchInfoString());
+ getSwitchInfoString());
if (thisdpid != 0) {
- if (duplicateDpidFound != Boolean.TRUE) {
- // if the disconnected switch (on this ChannelHandler)
- // was not one with a duplicate-dpid, it is safe to remove all
- // state for it at the controller. Notice that if the disconnected
- // switch was a duplicate-dpid, calling the method below would clear
- // all state for the original switch (with the same dpid),
- // which we obviously don't want.
- controller.removeConnectedSwitch(thisdpid);
- } else {
- // A duplicate was disconnected on this ChannelHandler,
- // this is the same switch reconnecting, but the original state was
- // not cleaned up - XXX check liveness of original ChannelHandler
- duplicateDpidFound = Boolean.FALSE;
- }
+ if (duplicateDpidFound != Boolean.TRUE) {
+ // if the disconnected switch (on this ChannelHandler)
+ // was not one with a duplicate-dpid, it is safe to remove all
+ // state for it at the controller. Notice that if the
+ // disconnected
+ // switch was a duplicate-dpid, calling the method below would
+ // clear
+ // all state for the original switch (with the same dpid),
+ // which we obviously don't want.
+ controller.removeConnectedSwitch(thisdpid);
+ } else {
+ // A duplicate was disconnected on this ChannelHandler,
+ // this is the same switch reconnecting, but the original state
+ // was
+ // not cleaned up - XXX check liveness of original
+ // ChannelHandler
+ duplicateDpidFound = Boolean.FALSE;
+ }
} else {
- log.warn("no dpid in channelHandler registered for "
- + "disconnected switch {}", getSwitchInfoString());
+ log.warn("no dpid in channelHandler registered for "
+ + "disconnected switch {}", getSwitchInfoString());
}
}
@Override
@LogMessageDocs({
- @LogMessageDoc(level="ERROR",
- message="Disconnecting switch {switch} due to read timeout",
- explanation="The connected switch has failed to send any " +
+ @LogMessageDoc(level = "ERROR",
+ message = "Disconnecting switch {switch} due to read timeout",
+ explanation = "The connected switch has failed to send any " +
"messages or respond to echo requests",
- recommendation=LogMessageDoc.CHECK_SWITCH),
- @LogMessageDoc(level="ERROR",
- message="Disconnecting switch {switch}: failed to " +
- "complete handshake",
- explanation="The switch did not respond correctly " +
+ recommendation = LogMessageDoc.CHECK_SWITCH),
+ @LogMessageDoc(level = "ERROR",
+ message = "Disconnecting switch {switch}: failed to " +
+ "complete handshake",
+ explanation = "The switch did not respond correctly " +
"to handshake messages",
- recommendation=LogMessageDoc.CHECK_SWITCH),
- @LogMessageDoc(level="ERROR",
- message="Disconnecting switch {switch} due to IO Error: {}",
- explanation="There was an error communicating with the switch",
- recommendation=LogMessageDoc.CHECK_SWITCH),
- @LogMessageDoc(level="ERROR",
- message="Disconnecting switch {switch} due to switch " +
- "state error: {error}",
- explanation="The switch sent an unexpected message",
- recommendation=LogMessageDoc.CHECK_SWITCH),
- @LogMessageDoc(level="ERROR",
- message="Disconnecting switch {switch} due to " +
- "message parse failure",
- explanation="Could not parse a message from the switch",
- recommendation=LogMessageDoc.CHECK_SWITCH),
- @LogMessageDoc(level="ERROR",
- message="Terminating controller due to storage exception",
- explanation=Controller.ERROR_DATABASE,
- recommendation=LogMessageDoc.CHECK_CONTROLLER),
- @LogMessageDoc(level="ERROR",
- message="Could not process message: queue full",
- explanation="OpenFlow messages are arriving faster than " +
+ recommendation = LogMessageDoc.CHECK_SWITCH),
+ @LogMessageDoc(level = "ERROR",
+ message = "Disconnecting switch {switch} due to IO Error: {}",
+ explanation = "There was an error communicating with the switch",
+ recommendation = LogMessageDoc.CHECK_SWITCH),
+ @LogMessageDoc(level = "ERROR",
+ message = "Disconnecting switch {switch} due to switch " +
+ "state error: {error}",
+ explanation = "The switch sent an unexpected message",
+ recommendation = LogMessageDoc.CHECK_SWITCH),
+ @LogMessageDoc(level = "ERROR",
+ message = "Disconnecting switch {switch} due to " +
+ "message parse failure",
+ explanation = "Could not parse a message from the switch",
+ recommendation = LogMessageDoc.CHECK_SWITCH),
+ @LogMessageDoc(level = "ERROR",
+ message = "Terminating controller due to storage exception",
+ explanation = Controller.ERROR_DATABASE,
+ recommendation = LogMessageDoc.CHECK_CONTROLLER),
+ @LogMessageDoc(level = "ERROR",
+ message = "Could not process message: queue full",
+ explanation = "OpenFlow messages are arriving faster than " +
" the controller can process them.",
- recommendation=LogMessageDoc.CHECK_CONTROLLER),
- @LogMessageDoc(level="ERROR",
- message="Error while processing message " +
- "from switch {switch} {cause}",
- explanation="An error occurred processing the switch message",
- recommendation=LogMessageDoc.GENERIC_ACTION)
+ recommendation = LogMessageDoc.CHECK_CONTROLLER),
+ @LogMessageDoc(level = "ERROR",
+ message = "Error while processing message " +
+ "from switch {switch} {cause}",
+ explanation = "An error occurred processing the switch message",
+ recommendation = LogMessageDoc.GENERIC_ACTION)
})
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)
throws Exception {
if (e.getCause() instanceof ReadTimeoutException) {
// switch timeout
log.error("Disconnecting switch {} due to read timeout",
- getSwitchInfoString());
+ getSwitchInfoString());
counters.switchDisconnectReadTimeout.updateCounterWithFlush();
ctx.getChannel().close();
} else if (e.getCause() instanceof HandshakeTimeoutException) {
log.error("Disconnecting switch {}: failed to complete handshake",
- getSwitchInfoString());
+ getSwitchInfoString());
counters.switchDisconnectHandshakeTimeout.updateCounterWithFlush();
ctx.getChannel().close();
} else if (e.getCause() instanceof ClosedChannelException) {
log.debug("Channel for sw {} already closed", getSwitchInfoString());
} else if (e.getCause() instanceof IOException) {
log.error("Disconnecting switch {} due to IO Error: {}",
- getSwitchInfoString(), e.getCause().getMessage());
+ getSwitchInfoString(), e.getCause().getMessage());
if (log.isDebugEnabled()) {
// still print stack trace if debug is enabled
log.debug("StackTrace for previous Exception: ", e.getCause());
@@ -1971,7 +2008,7 @@
ctx.getChannel().close();
} else if (e.getCause() instanceof SwitchStateException) {
log.error("Disconnecting switch {} due to switch state error: {}",
- getSwitchInfoString(), e.getCause().getMessage());
+ getSwitchInfoString(), e.getCause().getMessage());
if (log.isDebugEnabled()) {
// still print stack trace if debug is enabled
log.debug("StackTrace for previous Exception: ", e.getCause());
@@ -1980,9 +2017,9 @@
ctx.getChannel().close();
} else if (e.getCause() instanceof OFParseError) {
log.error("Disconnecting switch "
- + getSwitchInfoString() +
- " due to message parse failure",
- e.getCause());
+ + getSwitchInfoString() +
+ " due to message parse failure",
+ e.getCause());
counters.switchDisconnectParseError.updateCounterWithFlush();
ctx.getChannel().close();
} else if (e.getCause() instanceof RejectedExecutionException) {
@@ -1990,8 +2027,8 @@
counters.rejectedExecutionException.updateCounterWithFlush();
} else {
log.error("Error while processing message from switch "
- + getSwitchInfoString()
- + "state " + this.state, e.getCause());
+ + getSwitchInfoString()
+ + "state " + this.state, e.getCause());
counters.switchDisconnectOtherException.updateCounterWithFlush();
ctx.getChannel().close();
}
@@ -2019,7 +2056,7 @@
throws Exception {
if (e.getMessage() instanceof List) {
@SuppressWarnings("unchecked")
- List<OFMessage> msglist = (List<OFMessage>)e.getMessage();
+ List<OFMessage> msglist = (List<OFMessage>) e.getMessage();
LoadMonitor.LoadLevel loadlevel;
int packets_dropped = 0;
@@ -2035,14 +2072,15 @@
for (OFMessage ofm : msglist) {
counters.messageReceived.updateCounterNoFlush();
- // Per-switch input throttling - placeholder for future throttling
+ // Per-switch input throttling - placeholder for future
+ // throttling
/*if (sw != null && sw.inputThrottled(ofm)) {
counters.messageInputThrottled.updateCounterNoFlush();
continue;
}*/
try {
if (this.controller.overload_drop &&
- !loadlevel.equals(LoadMonitor.LoadLevel.OK)) {
+ !loadlevel.equals(LoadMonitor.LoadLevel.OK)) {
switch (ofm.getType()) {
case PACKET_IN:
switch (loadlevel) {
@@ -2052,12 +2090,12 @@
continue;
case HIGH:
// Drop all packet-ins, except LLDP/BDDPs
- byte[] data = ((OFPacketIn)ofm).getData();
+ byte[] data = ((OFPacketIn) ofm).getData();
if (data.length > 14) {
- if (((data[12] == (byte)0x88) &&
- (data[13] == (byte)0xcc)) ||
- ((data[12] == (byte)0x89) &&
- (data[13] == (byte)0x42))) {
+ if (((data[12] == (byte) 0x88) &&
+ (data[13] == (byte) 0xcc)) ||
+ ((data[12] == (byte) 0x89) &&
+ (data[13] == (byte) 0x42))) {
lldps_allowed++;
packets_allowed++;
break;
@@ -2081,8 +2119,7 @@
// Do the actual packet processing
state.processOFMessage(this, ofm);
- }
- catch (Exception ex) {
+ } catch (Exception ex) {
// We are the last handler in the stream, so run the
// exception through the channel again by passing in
// ctx.getChannel().
@@ -2093,18 +2130,19 @@
if (loadlevel != LoadMonitor.LoadLevel.OK) {
if (log.isDebugEnabled()) {
log.debug(
- "Overload: Detected {}, packets dropped={}",
- loadlevel.toString(), packets_dropped);
+ "Overload: Detected {}, packets dropped={}",
+ loadlevel.toString(), packets_dropped);
log.debug(
- "Overload: Packets allowed={} (LLDP/BDDPs allowed={})",
- packets_allowed, lldps_allowed);
+ "Overload: Packets allowed={} (LLDP/BDDPs allowed={})",
+ packets_allowed, lldps_allowed);
}
}
}
else {
- //Channels.fireExceptionCaught(ctx.getChannel(),
- // new AssertionError("Message received from Channel is not a list"));
- //TODO: Pankaj: move the counters using ONOS metrics implementation
+ // Channels.fireExceptionCaught(ctx.getChannel(),
+ // new
+ // AssertionError("Message received from Channel is not a list"));
+ // TODO: Pankaj: move the counters using ONOS metrics implementation
counters.messageReceived.updateCounterNoFlush();
state.processOFMessage(this, (OFMessage) e.getMessage());
@@ -2115,14 +2153,13 @@
this.controller.flushAll();
}
-
-
- //*************************
- // Channel utility methods
- //*************************
+ // *************************
+ // Channel utility methods
+ // *************************
/**
* Is this a state in which the handshake has completed?
+ *
* @return true if the handshake is complete
*/
public boolean isHandshakeComplete() {
@@ -2137,6 +2174,7 @@
/**
* Return a string describing this switch based on the already available
* information (DPID and/or remote socket)
+ *
* @return
*/
private String getSwitchInfoString() {
@@ -2158,8 +2196,9 @@
}
/**
- * Update the channels state. Only called from the state machine.
- * TODO: enforce restricted state transitions
+ * Update the channels state. Only called from the state machine. TODO:
+ * enforce restricted state transitions
+ *
* @param state
*/
private void setState(ChannelState state) {
@@ -2168,13 +2207,16 @@
/**
* Send hello message to the switch using the handshake transactions ids.
+ *
* @throws IOException
*/
private void sendHandshakeHelloMessage() throws IOException {
- // The OF protocol requires us to start things off by sending the highest
+ // The OF protocol requires us to start things off by sending the
+ // highest
// version of the protocol supported.
- // bitmap represents OF1.0 (ofp_version=0x01) and OF1.3 (ofp_version=0x04)
+ // bitmap represents OF1.0 (ofp_version=0x01) and OF1.3
+ // (ofp_version=0x04)
// see Sec. 7.5.1 of the OF1.3.4 spec
U32 bitmap = U32.ofRaw(0x00000012);
OFHelloElem hem = factory13.buildHelloElemVersionbitmap()
@@ -2188,7 +2230,9 @@
}
/**
- * Send featuresRequest msg to the switch using the handshake transactions ids.
+ * Send featuresRequest msg to the switch using the handshake transactions
+ * ids.
+ *
* @throws IOException
*/
private void sendHandshakeFeaturesRequestMessage() throws IOException {
@@ -2204,13 +2248,14 @@
}
/**
- * Send the configuration requests to tell the switch we want full
- * packets
+ * Send the configuration requests to tell the switch we want full packets
+ *
* @throws IOException
*/
private void sendHandshakeSetConfig() throws IOException {
OFFactory factory = (ofVersion == OFVersion.OF_13) ? factory13 : factory10;
- //log.debug("Sending CONFIG_REQUEST to {}", channel.getRemoteAddress());
+ // log.debug("Sending CONFIG_REQUEST to {}",
+ // channel.getRemoteAddress());
List<OFMessage> msglist = new ArrayList<OFMessage>(3);
// Ensure we receive the full packet via PacketIn
@@ -2240,6 +2285,7 @@
/**
* send a description state request
+ *
* @throws IOException
*/
private void sendHandshakeDescriptionStatsRequest() throws IOException {
@@ -2276,5 +2322,4 @@
roleChanger = new RoleChanger(roleTimeoutMs);
}
-
}
diff --git a/src/main/java/net/floodlightcontroller/core/internal/OFSwitchImplBase.java b/src/main/java/net/floodlightcontroller/core/internal/OFSwitchImplBase.java
index 6fe5cc9..c51875f 100644
--- a/src/main/java/net/floodlightcontroller/core/internal/OFSwitchImplBase.java
+++ b/src/main/java/net/floodlightcontroller/core/internal/OFSwitchImplBase.java
@@ -84,7 +84,6 @@
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-
/**
* This is the internal representation of an openflow switch.
*/
@@ -120,27 +119,28 @@
// Lock to protect modification of the port maps. We only need to
// synchronize on modifications. For read operations we are fine since
// we rely on ConcurrentMaps which works for our use case.
- //private Object portLock; XXX S remove this
+ // private Object portLock; XXX S remove this
// Map port numbers to the appropriate OFPortDesc
protected ConcurrentHashMap<Integer, OFPortDesc> portsByNumber;
// Map port names to the appropriate OFPhyiscalPort
// XXX: The OF spec doesn't specify if port names need to be unique but
- // according it's always the case in practice.
+ // according it's always the case in practice.
protected ConcurrentHashMap<String, OFPortDesc> portsByName;
protected Map<Integer, OFStatisticsFuture> statsFutureMap;
- protected Map<Integer, IOFMessageListener> iofMsgListenersMap; // XXX S why is this needed?
+ // XXX Consider removing the following 2 maps - not used anymore
+ protected Map<Integer, IOFMessageListener> iofMsgListenersMap;
protected Map<Integer, OFFeaturesReplyFuture> featuresFutureMap;
protected boolean connected;
protected Role role;
protected ReentrantReadWriteLock listenerLock;
protected ConcurrentMap<Short, Long> portBroadcastCacheHitMap;
/**
- * When sending a role request message, the role request is added
- * to this queue. If a role reply is received this queue is checked to
- * verify that the reply matches the expected reply. We require in order
- * delivery of replies. That's why we use a Queue.
- * The RoleChanger uses a timeout to ensure we receive a timely reply.
+ * When sending a role request message, the role request is added to this
+ * queue. If a role reply is received this queue is checked to verify that
+ * the reply matches the expected reply. We require in order delivery of
+ * replies. That's why we use a Queue. The RoleChanger uses a timeout to
+ * ensure we receive a timely reply.
* <p/>
* Need to synchronize on this instance if a request is sent, received,
* checked.
@@ -157,31 +157,28 @@
protected Set<OFActionType> actions;
protected byte tables;
protected DatapathId datapathId;
- private OFAuxId auxId;
+ private OFAuxId auxId;
private IDebugCounterService debugCounters;
- private boolean debugCountersRegistered;
- @SuppressWarnings("unused")
+ private boolean debugCountersRegistered;
+ @SuppressWarnings("unused")
private IDebugCounter ctrSwitch, ctrSwitchPktin, ctrSwitchWrite,
- ctrSwitchPktinDrops, ctrSwitchWriteDrops;
+ ctrSwitchPktinDrops, ctrSwitchWriteDrops;
- protected boolean startDriverHandshakeCalled = false;
- private boolean flowTableFull = false;
+ protected boolean startDriverHandshakeCalled = false;
+ private boolean flowTableFull = false;
- private final PortManager portManager;
-
-
+ private final PortManager portManager;
protected static final ThreadLocal<Map<OFSwitchImplBase, List<OFMessage>>> local_msg_buffer =
- new ThreadLocal<Map<OFSwitchImplBase, List<OFMessage>>>() {
- @Override
- protected Map<OFSwitchImplBase, List<OFMessage>> initialValue() {
- return new WeakHashMap<OFSwitchImplBase, List<OFMessage>>();
- }
- };
+ new ThreadLocal<Map<OFSwitchImplBase, List<OFMessage>>>() {
+ @Override
+ protected Map<OFSwitchImplBase, List<OFMessage>> initialValue() {
+ return new WeakHashMap<OFSwitchImplBase, List<OFMessage>>();
+ }
+ };
-
- private static final String BASE = "switchbase";
+ private static final String BASE = "switchbase";
protected static class PendingRoleRequestEntry {
protected int xid;
@@ -201,7 +198,8 @@
this.attributes = new ConcurrentHashMap<Object, Object>();
this.connectedSince = new Date();
this.transactionIdSource = new AtomicInteger();
- this.generationIdSource = 0; // XXX S this is wrong; should be negotiated
+ this.generationIdSource = 0; // XXX S this is wrong; should be
+ // negotiated
// XXX S no need this.portLock = new Object();
this.portsByNumber = new ConcurrentHashMap<Integer, OFPortDesc>();
this.portsByName = new ConcurrentHashMap<String, OFPortDesc>();
@@ -220,9 +218,9 @@
}
- //*******************************************
- // Setters and Getters
- //*******************************************
+ // *******************************************
+ // Setters and Getters
+ // *******************************************
@Override
public Object getAttribute(String name) {
@@ -312,13 +310,12 @@
@Override
public String toString() {
return "OFSwitchImpl [" + ((channel != null) ? channel.getRemoteAddress() : "?")
- + " DPID[" + ((stringId != null) ? stringId : "?") + "]]";
+ + " DPID[" + ((stringId != null) ? stringId : "?") + "]]";
}
-
- //*******************************************
- // Channel related methods
- //*******************************************
+ // *******************************************
+ // Channel related methods
+ // *******************************************
@JsonIgnore
@Override
@@ -335,7 +332,7 @@
msg_buffer_map.put(this, msg_buffer);
}
// XXX S will change when iFloodlight provider changes
- //this.floodlightProvider.handleOutgoingMessage(this, m, bc);
+ // this.floodlightProvider.handleOutgoingMessage(this, m, bc);
msg_buffer.add(m);
if ((msg_buffer.size() >= Controller.BATCH_MAX_SIZE) ||
@@ -353,23 +350,23 @@
"that is not valid when the switch is in a slave role",
recommendation = LogMessageDoc.REPORT_CONTROLLER_BUG)
public void write(List<OFMessage> msglist,
- FloodlightContext bc) throws IOException {
+ FloodlightContext bc) throws IOException {
for (OFMessage m : msglist) {
if (role == Role.SLAVE) {
switch (m.getType()) {
- case PACKET_OUT:
- case FLOW_MOD:
- case PORT_MOD:
- log.warn("Sending OF message that modifies switch " +
- "state while in the slave role: {}",
- m.getType().name());
- break;
- default:
- break;
+ case PACKET_OUT:
+ case FLOW_MOD:
+ case PORT_MOD:
+ log.warn("Sending OF message that modifies switch " +
+ "state while in the slave role: {}",
+ m.getType().name());
+ break;
+ default:
+ break;
}
}
// XXX S again
- //this.floodlightProvider.handleOutgoingMessage(this, m, bc);
+ // this.floodlightProvider.handleOutgoingMessage(this, m, bc);
}
this.write(msglist);
}
@@ -406,95 +403,98 @@
this.connected = connected;
}
-
-
- //*******************************************
- // Switch features related methods
- //*******************************************
+ // *******************************************
+ // Switch features related methods
+ // *******************************************
/**
* Set the features reply for this switch from the handshake
*/
protected void setFeaturesReply(OFFeaturesReply featuresReply) {
- if (featuresReply == null) {
- log.error("Error setting featuresReply for switch: {}", getStringId());
- return;
- }
- this.datapathId = featuresReply.getDatapathId();
- this.capabilities = featuresReply.getCapabilities();
- this.buffers = (int) featuresReply.getNBuffers();
- this.tables = (byte) featuresReply.getNTables();
- this.stringId = this.datapathId.toString();
- if (ofversion == OFVersion.OF_13) {
- auxId = featuresReply.getAuxiliaryId();
- if (!auxId.equals(OFAuxId.MAIN)) {
- log.warn("This controller does not handle auxiliary connections. "
- + "Aux connection id {} received from switch {}",
- auxId, getStringId());
- }
- }
+ if (featuresReply == null) {
+ log.error("Error setting featuresReply for switch: {}", getStringId());
+ return;
+ }
+ this.datapathId = featuresReply.getDatapathId();
+ this.capabilities = featuresReply.getCapabilities();
+ this.buffers = (int) featuresReply.getNBuffers();
+ this.tables = (byte) featuresReply.getNTables();
+ this.stringId = this.datapathId.toString();
+ if (ofversion == OFVersion.OF_13) {
+ auxId = featuresReply.getAuxiliaryId();
+ if (!auxId.equals(OFAuxId.MAIN)) {
+ log.warn("This controller does not handle auxiliary connections. "
+ + "Aux connection id {} received from switch {}",
+ auxId, getStringId());
+ }
+ }
- if (ofversion == OFVersion.OF_10) {
- this.actions = featuresReply.getActions();
- portManager.compareAndUpdatePorts(featuresReply.getPorts(), true);
- }
+ if (ofversion == OFVersion.OF_10) {
+ this.actions = featuresReply.getActions();
+ portManager.compareAndUpdatePorts(featuresReply.getPorts(), true);
+ }
}
/**
- * Set the port descriptions for this switch from the handshake for
- * an OF1.3 switch.
+ * Set the port descriptions for this switch from the handshake for an OF1.3
+ * switch.
*/
protected void setPortDescReply(OFPortDescStatsReply pdrep) {
- if (ofversion != OFVersion.OF_13) return;
- if (pdrep == null) {
- log.error("Error setting ports description for switch: {}", getStringId());
- return;
- }
- portManager.updatePorts(pdrep.getEntries());
+ if (ofversion != OFVersion.OF_13)
+ return;
+ if (pdrep == null) {
+ log.error("Error setting ports description for switch: {}", getStringId());
+ return;
+ }
+ portManager.updatePorts(pdrep.getEntries());
}
@Override
public int getNumBuffers() {
return buffers;
}
+
@Override
public Set<OFActionType> getActions() {
return actions;
}
+
@Override
- public Set<OFCapabilities> getCapabilities() {
+ public Set<OFCapabilities> getCapabilities() {
return capabilities;
}
+
@Override
public byte getNumTables() {
return tables;
}
-// public Future<OFFeaturesReply> getFeaturesReplyFromSwitch()
-// throws IOException {
-// // XXX S fix this later
-// OFMessage request = floodlightProvider.getOFMessageFactory_13()
-// .buildFeaturesRequest()
-// .setXid(getNextTransactionId())
-// .build();
-// OFFeaturesReplyFuture future =
-// new OFFeaturesReplyFuture(threadPool, this, (int) request.getXid());
-// this.featuresFutureMap.put((int) request.getXid(), future);
-// this.channel.write(Collections.singletonList(request));
-// return future;
-//
-// }
-//
-// public void deliverOFFeaturesReply(OFMessage reply) {
-// OFFeaturesReplyFuture future = this.featuresFutureMap.get(reply.getXid());
-// if (future != null) {
-// future.deliverFuture(this, reply);
-// // The future will ultimately unregister itself and call
-// // cancelFeaturesReply
-// return;
-// }
-// log.error("Switch {}: received unexpected featureReply", this);
-// }
+ // public Future<OFFeaturesReply> getFeaturesReplyFromSwitch()
+ // throws IOException {
+ // // XXX S fix this later
+ // OFMessage request = floodlightProvider.getOFMessageFactory_13()
+ // .buildFeaturesRequest()
+ // .setXid(getNextTransactionId())
+ // .build();
+ // OFFeaturesReplyFuture future =
+ // new OFFeaturesReplyFuture(threadPool, this, (int) request.getXid());
+ // this.featuresFutureMap.put((int) request.getXid(), future);
+ // this.channel.write(Collections.singletonList(request));
+ // return future;
+ //
+ // }
+ //
+ // public void deliverOFFeaturesReply(OFMessage reply) {
+ // OFFeaturesReplyFuture future =
+ // this.featuresFutureMap.get(reply.getXid());
+ // if (future != null) {
+ // future.deliverFuture(this, reply);
+ // // The future will ultimately unregister itself and call
+ // // cancelFeaturesReply
+ // return;
+ // }
+ // log.error("Switch {}: received unexpected featureReply", this);
+ // }
@Override
public void cancelFeaturesReply(int transactionId) {
@@ -503,18 +503,18 @@
@JsonIgnore
public void setSwitchDescription(OFDescStatsReply desc) {
- switchDescription = desc;
+ switchDescription = desc;
}
@Override
@JsonIgnore
public OFDescStatsReply getSwitchDescription() {
- return switchDescription;
+ return switchDescription;
}
- //*******************************************
- // Switch port handling
- //*******************************************
+ // *******************************************
+ // Switch port handling
+ // *******************************************
@Override
@JsonIgnore
@@ -547,7 +547,7 @@
@Override
@JsonProperty("ports")
public Collection<OFPortDesc> getPorts() {
- return portManager.getPorts();
+ return portManager.getPorts();
}
@Override
@@ -557,14 +557,14 @@
@Override
public boolean portEnabled(String portName) {
- return isEnabled(portManager.getPort(portName));
+ return isEnabled(portManager.getPort(portName));
}
private boolean isEnabled(OFPortDesc p) {
- return (p != null &&
- !p.getState().contains(OFPortState.LINK_DOWN) &&
- !p.getState().contains(OFPortState.BLOCKED) &&
- !p.getConfig().contains(OFPortConfig.PORT_DOWN));
+ return (p != null &&
+ !p.getState().contains(OFPortState.LINK_DOWN) &&
+ !p.getState().contains(OFPortState.BLOCKED) && !p.getConfig().contains(
+ OFPortConfig.PORT_DOWN));
}
@Override
@@ -580,37 +580,33 @@
/**
* Manages the ports of this switch.
- *
+ *
* Provides methods to query and update the stored ports. The class ensures
- * that every port name and port number is unique. When updating ports
- * the class checks if port number <-> port name mappings have change due
- * to the update. If a new port P has number and port that are inconsistent
- * with the previous mapping(s) the class will delete all previous ports
- * with name or number of the new port and then add the new port.
- *
+ * that every port name and port number is unique. When updating ports the
+ * class checks if port number <-> port name mappings have change due to the
+ * update. If a new port P has number and port that are inconsistent with
+ * the previous mapping(s) the class will delete all previous ports with
+ * name or number of the new port and then add the new port.
+ *
* Port names are stored as-is but they are compared case-insensitive
- *
+ *
* The methods that change the stored ports return a list of
- * PortChangeEvents that represent the changes that have been applied
- * to the port list so that IOFSwitchListeners can be notified about the
- * changes.
- *
- * Implementation notes:
- * - We keep several different representations of the ports to allow for
- * fast lookups
- * - Ports are stored in unchangeable lists. When a port is modified new
- * data structures are allocated.
- * - We use a read-write-lock for synchronization, so multiple readers are
- * allowed.
- * - All port numbers have int representation (no more shorts)
+ * PortChangeEvents that represent the changes that have been applied to the
+ * port list so that IOFSwitchListeners can be notified about the changes.
+ *
+ * Implementation notes: - We keep several different representations of the
+ * ports to allow for fast lookups - Ports are stored in unchangeable lists.
+ * When a port is modified new data structures are allocated. - We use a
+ * read-write-lock for synchronization, so multiple readers are allowed. -
+ * All port numbers have int representation (no more shorts)
*/
protected class PortManager {
private final ReentrantReadWriteLock lock;
private List<OFPortDesc> portList;
private List<OFPortDesc> enabledPortList;
private List<Integer> enabledPortNumbers;
- private Map<Integer,OFPortDesc> portsByNumber;
- private Map<String,OFPortDesc> portsByName;
+ private Map<Integer, OFPortDesc> portsByNumber;
+ private Map<String, OFPortDesc> portsByName;
public PortManager() {
this.lock = new ReentrantReadWriteLock();
@@ -622,22 +618,22 @@
}
/**
- * Set the internal data structure storing this switch's port
- * to the ports specified by newPortsByNumber
- *
+ * Set the internal data structure storing this switch's port to the
+ * ports specified by newPortsByNumber
+ *
* CALLER MUST HOLD WRITELOCK
- *
+ *
* @param newPortsByNumber
* @throws IllegaalStateException if called without holding the
- * writelock
+ * writelock
*/
private void updatePortsWithNewPortsByNumber(
- Map<Integer,OFPortDesc> newPortsByNumber) {
+ Map<Integer, OFPortDesc> newPortsByNumber) {
if (!lock.writeLock().isHeldByCurrentThread()) {
throw new IllegalStateException("Method called without " +
- "holding writeLock");
+ "holding writeLock");
}
- Map<String,OFPortDesc> newPortsByName =
+ Map<String, OFPortDesc> newPortsByName =
new HashMap<String, OFPortDesc>();
List<OFPortDesc> newPortList =
new ArrayList<OFPortDesc>();
@@ -645,7 +641,7 @@
new ArrayList<OFPortDesc>();
List<Integer> newEnabledPortNumbers = new ArrayList<Integer>();
- for(OFPortDesc p: newPortsByNumber.values()) {
+ for (OFPortDesc p : newPortsByNumber.values()) {
newPortList.add(p);
newPortsByName.put(p.getName().toLowerCase(), p);
if (isEnabled(p)) {
@@ -664,27 +660,26 @@
}
/**
- * Handle a OFPortStatus delete message for the given port.
- * Updates the internal port maps/lists of this switch and returns
- * the PortChangeEvents caused by the delete. If the given port
- * exists as it, it will be deleted. If the name<->number for the
- * given port is inconsistent with the ports stored by this switch
- * the method will delete all ports with the number or name of the
- * given port.
- *
+ * Handle a OFPortStatus delete message for the given port. Updates the
+ * internal port maps/lists of this switch and returns the
+ * PortChangeEvents caused by the delete. If the given port exists as
+ * it, it will be deleted. If the name<->number for the given port is
+ * inconsistent with the ports stored by this switch the method will
+ * delete all ports with the number or name of the given port.
+ *
* This method will increment error/warn counters and log
- *
- * @param delPort the port from the port status message that should
- * be deleted.
+ *
+ * @param delPort the port from the port status message that should be
+ * deleted.
* @return ordered collection of port changes applied to this switch
*/
private OrderedCollection<PortChangeEvent> handlePortStatusDelete(
- OFPortDesc delPort) {
+ OFPortDesc delPort) {
lock.writeLock().lock();
OrderedCollection<PortChangeEvent> events =
new LinkedHashSetWrapper<PortChangeEvent>();
try {
- Map<Integer,OFPortDesc> newPortByNumber =
+ Map<Integer, OFPortDesc> newPortByNumber =
new HashMap<Integer, OFPortDesc>(portsByNumber);
OFPortDesc prevPort =
portsByNumber.get(delPort.getPortNo().getPortNumber());
@@ -694,26 +689,26 @@
if (prevPort != null) {
newPortByNumber.remove(prevPort.getPortNo().getPortNumber());
events.add(new PortChangeEvent(prevPort,
- PortChangeType.DELETE));
+ PortChangeType.DELETE));
}
} else if (prevPort.getName().equals(delPort.getName())) {
// port exists with consistent name-number mapping
newPortByNumber.remove(delPort.getPortNo().getPortNumber());
events.add(new PortChangeEvent(delPort,
- PortChangeType.DELETE));
+ PortChangeType.DELETE));
} else {
// port with same number exists but its name differs. This
// is weird. The best we can do is to delete the existing
// port(s) that have delPort's name and number.
newPortByNumber.remove(delPort.getPortNo().getPortNumber());
events.add(new PortChangeEvent(prevPort,
- PortChangeType.DELETE));
+ PortChangeType.DELETE));
// is there another port that has delPort's name?
prevPort = portsByName.get(delPort.getName().toLowerCase());
if (prevPort != null) {
newPortByNumber.remove(prevPort.getPortNo().getPortNumber());
events.add(new PortChangeEvent(prevPort,
- PortChangeType.DELETE));
+ PortChangeType.DELETE));
}
}
updatePortsWithNewPortsByNumber(newPortByNumber);
@@ -726,16 +721,16 @@
/**
* Handle a OFPortStatus message, update the internal data structures
* that store ports and return the list of OFChangeEvents.
- *
+ *
* This method will increment error/warn counters and log
- *
+ *
* @param ps
* @return
*/
public OrderedCollection<PortChangeEvent> handlePortStatusMessage(OFPortStatus ps) {
if (ps == null) {
throw new NullPointerException("OFPortStatus message must " +
- "not be null");
+ "not be null");
}
lock.writeLock().lock();
try {
@@ -747,44 +742,44 @@
if (log.isDebugEnabled()) {
log.debug("Handling OFPortStatus: {} for {}",
- reason, ps);
+ reason, ps);
}
if (reason == OFPortReason.DELETE)
- return handlePortStatusDelete(ps.getDesc());
+ return handlePortStatusDelete(ps.getDesc());
// We handle ADD and MODIFY the same way. Since OpenFlow
// doesn't specify what uniquely identifies a port the
// notion of ADD vs. MODIFY can also be hazy. So we just
// compare the new port to the existing ones.
- Map<Integer,OFPortDesc> newPortByNumber =
- new HashMap<Integer, OFPortDesc>(portsByNumber);
+ Map<Integer, OFPortDesc> newPortByNumber =
+ new HashMap<Integer, OFPortDesc>(portsByNumber);
OrderedCollection<PortChangeEvent> events =
- getSinglePortChanges(ps.getDesc());
- for (PortChangeEvent e: events) {
- switch(e.type) {
- case DELETE:
- newPortByNumber.remove(e.port.getPortNo().getPortNumber());
- break;
- case ADD:
- if (reason != OFPortReason.ADD) {
- // weird case
- }
- newPortByNumber.put(e.port.getPortNo().getPortNumber(),
- e.port);
- break;
- case DOWN:
- newPortByNumber.put(e.port.getPortNo().getPortNumber(),
- e.port);
- break;
- case OTHER_UPDATE:
- newPortByNumber.put(e.port.getPortNo().getPortNumber(),
- e.port);
- break;
- case UP:
- newPortByNumber.put(e.port.getPortNo().getPortNumber(),
- e.port);
- break;
+ getSinglePortChanges(ps.getDesc());
+ for (PortChangeEvent e : events) {
+ switch (e.type) {
+ case DELETE:
+ newPortByNumber.remove(e.port.getPortNo().getPortNumber());
+ break;
+ case ADD:
+ if (reason != OFPortReason.ADD) {
+ // weird case
+ }
+ newPortByNumber.put(e.port.getPortNo().getPortNumber(),
+ e.port);
+ break;
+ case DOWN:
+ newPortByNumber.put(e.port.getPortNo().getPortNumber(),
+ e.port);
+ break;
+ case OTHER_UPDATE:
+ newPortByNumber.put(e.port.getPortNo().getPortNumber(),
+ e.port);
+ break;
+ case UP:
+ newPortByNumber.put(e.port.getPortNo().getPortNumber(),
+ e.port);
+ break;
}
}
updatePortsWithNewPortsByNumber(newPortByNumber);
@@ -797,20 +792,20 @@
/**
* Given a new or modified port newPort, returns the list of
- * PortChangeEvents to "transform" the current ports stored by
- * this switch to include / represent the new port. The ports stored
- * by this switch are <b>NOT</b> updated.
- *
- * This method acquires the readlock and is thread-safe by itself.
- * Most callers will need to acquire the write lock before calling
- * this method though (if the caller wants to update the ports stored
- * by this switch)
- *
+ * PortChangeEvents to "transform" the current ports stored by this
+ * switch to include / represent the new port. The ports stored by this
+ * switch are <b>NOT</b> updated.
+ *
+ * This method acquires the readlock and is thread-safe by itself. Most
+ * callers will need to acquire the write lock before calling this
+ * method though (if the caller wants to update the ports stored by this
+ * switch)
+ *
* @param newPort the new or modified port.
* @return the list of changes
*/
public OrderedCollection<PortChangeEvent> getSinglePortChanges(
- OFPortDesc newPort) {
+ OFPortDesc newPort) {
lock.readLock().lock();
try {
OrderedCollection<PortChangeEvent> events =
@@ -831,13 +826,13 @@
// also matches the new port. Find the differences
if (isEnabled(prevPort) && !isEnabled(newPort)) {
events.add(new PortChangeEvent(newPort,
- PortChangeType.DOWN));
+ PortChangeType.DOWN));
} else if (!isEnabled(prevPort) && isEnabled(newPort)) {
events.add(new PortChangeEvent(newPort,
- PortChangeType.UP));
+ PortChangeType.UP));
} else {
events.add(new PortChangeEvent(newPort,
- PortChangeType.OTHER_UPDATE));
+ PortChangeType.OTHER_UPDATE));
}
return events;
}
@@ -848,7 +843,7 @@
// never have gotten here)
// Remove the port. Name-number mapping(s) have changed
events.add(new PortChangeEvent(prevPort,
- PortChangeType.DELETE));
+ PortChangeType.DELETE));
}
// We now need to check if there exists a previous port sharing
@@ -860,7 +855,7 @@
// never have gotten here).
// Remove the port. Name-number mapping(s) have changed
events.add(new PortChangeEvent(prevPort,
- PortChangeType.DELETE));
+ PortChangeType.DELETE));
}
// We always need to add the new port. Either no previous port
@@ -876,54 +871,55 @@
/**
* Compare the current ports of this switch to the newPorts list and
* return the changes that would be applied to transfort the current
- * ports to the new ports. No internal data structures are updated
- * see {@link #compareAndUpdatePorts(List, boolean)}
- *
+ * ports to the new ports. No internal data structures are updated see
+ * {@link #compareAndUpdatePorts(List, boolean)}
+ *
* @param newPorts the list of new ports
* @return The list of differences between the current ports and
- * newPortList
+ * newPortList
*/
public OrderedCollection<PortChangeEvent> comparePorts(
- Collection<OFPortDesc> newPorts) {
+ Collection<OFPortDesc> newPorts) {
return compareAndUpdatePorts(newPorts, false);
}
/**
* Compare the current ports of this switch to the newPorts list and
* return the changes that would be applied to transform the current
- * ports to the new ports. No internal data structures are updated
- * see {@link #compareAndUpdatePorts(List, boolean)}
- *
+ * ports to the new ports. No internal data structures are updated see
+ * {@link #compareAndUpdatePorts(List, boolean)}
+ *
* @param newPorts the list of new ports
* @return The list of differences between the current ports and
- * newPortList
+ * newPortList
*/
public OrderedCollection<PortChangeEvent> updatePorts(
- Collection<OFPortDesc> newPorts) {
+ Collection<OFPortDesc> newPorts) {
return compareAndUpdatePorts(newPorts, true);
}
/**
- * Compare the current ports stored in this switch instance with the
- * new port list given and return the differences in the form of
+ * Compare the current ports stored in this switch instance with the new
+ * port list given and return the differences in the form of
* PortChangeEvents. If the doUpdate flag is true, newPortList will
* replace the current list of this switch (and update the port maps)
- *
- * Implementation note:
- * Since this method can optionally modify the current ports and
- * since it's not possible to upgrade a read-lock to a write-lock
- * we need to hold the write-lock for the entire operation. If this
- * becomes a problem and if compares() are common we can consider
- * splitting in two methods but this requires lots of code duplication
- *
+ *
+ * Implementation note: Since this method can optionally modify the
+ * current ports and since it's not possible to upgrade a read-lock to a
+ * write-lock we need to hold the write-lock for the entire operation.
+ * If this becomes a problem and if compares() are common we can
+ * consider splitting in two methods but this requires lots of code
+ * duplication
+ *
* @param newPorts the list of new ports.
- * @param doUpdate If true the newPortList will replace the current
- * port list for this switch. If false this switch will not be changed.
+ * @param doUpdate If true the newPortList will replace the current port
+ * list for this switch. If false this switch will not be
+ * changed.
* @return The list of differences between the current ports and
- * newPorts
+ * newPorts
* @throws NullPointerException if newPortsList is null
* @throws IllegalArgumentException if either port names or port numbers
- * are duplicated in the newPortsList.
+ * are duplicated in the newPortsList.
*/
private OrderedCollection<PortChangeEvent> compareAndUpdatePorts(
Collection<OFPortDesc> newPorts, boolean doUpdate) {
@@ -935,9 +931,9 @@
OrderedCollection<PortChangeEvent> events =
new LinkedHashSetWrapper<PortChangeEvent>();
- Map<Integer,OFPortDesc> newPortsByNumber =
+ Map<Integer, OFPortDesc> newPortsByNumber =
new HashMap<Integer, OFPortDesc>();
- Map<String,OFPortDesc> newPortsByName =
+ Map<String, OFPortDesc> newPortsByName =
new HashMap<String, OFPortDesc>();
List<OFPortDesc> newEnabledPortList =
new ArrayList<OFPortDesc>();
@@ -946,7 +942,7 @@
List<OFPortDesc> newPortsList =
new ArrayList<OFPortDesc>(newPorts);
- for (OFPortDesc p: newPortsList) {
+ for (OFPortDesc p : newPortsList) {
if (p == null) {
throw new NullPointerException("portList must not " +
"contain null values");
@@ -956,7 +952,7 @@
// that every port is unique
OFPortDesc duplicatePort;
duplicatePort = newPortsByNumber.put(
- p.getPortNo().getPortNumber(), p);
+ p.getPortNo().getPortNumber(), p);
if (duplicatePort != null) {
String msg = String.format("Cannot have two ports " +
"with the same number: %s <-> %s",
@@ -968,7 +964,7 @@
if (duplicatePort != null) {
String msg = String.format("Cannot have two ports " +
"with the same name: %s <-> %s",
- p.toString().substring(0,80),
+ p.toString().substring(0, 80),
duplicatePort.toString().substring(0, 80));
throw new IllegalArgumentException(msg);
}
@@ -985,16 +981,16 @@
// to we can handle changed name<->number mappings correctly
// We could pull it into the loop of we address this but
// it's probably not worth it
- for (OFPortDesc oldPort: this.portList) {
- if (!newPortsByNumber.containsKey(oldPort.getPortNo().getPortNumber())) {
+ for (OFPortDesc oldPort : this.portList) {
+ if (!newPortsByNumber
+ .containsKey(oldPort.getPortNo().getPortNumber())) {
PortChangeEvent ev =
new PortChangeEvent(oldPort,
- PortChangeType.DELETE);
+ PortChangeType.DELETE);
events.add(ev);
}
}
-
if (doUpdate) {
portsByName = Collections.unmodifiableMap(newPortsByName);
portsByNumber =
@@ -1060,18 +1056,17 @@
}
}
-
- //*******************************************
- // Switch stats handling
- //*******************************************
+ // *******************************************
+ // Switch stats handling
+ // *******************************************
@Override
public Future<List<OFStatsReply>> getStatistics(OFStatsRequest<?> request)
- throws IOException {
+ throws IOException {
OFStatisticsFuture future = new OFStatisticsFuture(threadPool, this,
- (int)request.getXid());
+ (int) request.getXid());
log.info("description STAT REQUEST XID {}", request.getXid());
- this.statsFutureMap.put((int)request.getXid(), future);
+ this.statsFutureMap.put((int) request.getXid(), future);
this.channel.write(Collections.singletonList(request));
return future;
@@ -1079,7 +1074,7 @@
@Override
public void deliverStatisticsReply(OFMessage reply) {
- OFStatisticsFuture future = this.statsFutureMap.get((int)reply.getXid());
+ OFStatisticsFuture future = this.statsFutureMap.get((int) reply.getXid());
if (future != null) {
future.deliverFuture(this, reply);
// The future will ultimately unregister itself and call
@@ -1089,7 +1084,7 @@
// Transaction id was not found in statsFutureMap.check the other map
IOFMessageListener caller = this.iofMsgListenersMap.get(reply.getXid());
if (caller != null) {
- caller.receive(this, reply, null);
+ caller.receive(this, reply, null);
}
}
@@ -1112,18 +1107,17 @@
iofMsgListenersMap.clear();
}
-
- //*******************************************
- // Switch role handling
- //*******************************************
+ // *******************************************
+ // Switch role handling
+ // *******************************************
// XXX S this is completely wrong. The generation id should be obtained
// after coordinating with all controllers connected to this switch.
// ie. should be part of registry service (account for 1.3 vs 1.0)
// For now we are just generating this locally and keeping it constant.
public U64 getNextGenerationId() {
- //TODO: Pankaj, fix nextGenerationId as part of Registry interface
- return U64.of(generationIdSource);
+ // TODO: Pankaj, fix nextGenerationId as part of Registry interface
+ return U64.of(generationIdSource);
}
@Override
@@ -1137,10 +1131,9 @@
this.role = role;
}
-
- //*******************************************
- // Switch utility methods
- //*******************************************
+ // *******************************************
+ // Switch utility methods
+ // *******************************************
private void registerOverloadCounters() throws CounterException {
if (debugCountersRegistered) {
@@ -1154,32 +1147,32 @@
// every level of the hierarchical counter has to be registered
// even if they are not used
ctrSwitch = debugCounters.registerCounter(
- BASE , stringId,
- "Counter for this switch",
- CounterType.ALWAYS_COUNT);
+ BASE, stringId,
+ "Counter for this switch",
+ CounterType.ALWAYS_COUNT);
ctrSwitchPktin = debugCounters.registerCounter(
- BASE, stringId + "/pktin",
- "Packet in counter for this switch",
- CounterType.ALWAYS_COUNT);
+ BASE, stringId + "/pktin",
+ "Packet in counter for this switch",
+ CounterType.ALWAYS_COUNT);
ctrSwitchWrite = debugCounters.registerCounter(
- BASE, stringId + "/write",
- "Write counter for this switch",
- CounterType.ALWAYS_COUNT);
+ BASE, stringId + "/write",
+ "Write counter for this switch",
+ CounterType.ALWAYS_COUNT);
ctrSwitchPktinDrops = debugCounters.registerCounter(
- BASE, stringId + "/pktin/drops",
- "Packet in throttle drop count",
- CounterType.ALWAYS_COUNT,
- IDebugCounterService.CTR_MDATA_WARN);
+ BASE, stringId + "/pktin/drops",
+ "Packet in throttle drop count",
+ CounterType.ALWAYS_COUNT,
+ IDebugCounterService.CTR_MDATA_WARN);
ctrSwitchWriteDrops = debugCounters.registerCounter(
- BASE, stringId + "/write/drops",
- "Switch write throttle drop count",
- CounterType.ALWAYS_COUNT,
- IDebugCounterService.CTR_MDATA_WARN);
+ BASE, stringId + "/write/drops",
+ "Switch write throttle drop count",
+ CounterType.ALWAYS_COUNT,
+ IDebugCounterService.CTR_MDATA_WARN);
}
@Override
public void startDriverHandshake() throws IOException {
- log.debug("Starting driver handshake for sw {}", getStringId());
+ log.debug("Starting driver handshake for sw {}", getStringId());
if (startDriverHandshakeCalled)
throw new SwitchDriverSubHandshakeAlreadyStarted();
startDriverHandshakeCalled = true;
@@ -1202,20 +1195,20 @@
@Override
@JsonIgnore
- @LogMessageDoc(level="WARN",
- message="Switch {switch} flow table is full",
- explanation="The controller received flow table full " +
- "message from the switch, could be caused by increased " +
- "traffic pattern",
- recommendation=LogMessageDoc.REPORT_CONTROLLER_BUG)
+ @LogMessageDoc(level = "WARN",
+ message = "Switch {switch} flow table is full",
+ explanation = "The controller received flow table full " +
+ "message from the switch, could be caused by increased " +
+ "traffic pattern",
+ recommendation = LogMessageDoc.REPORT_CONTROLLER_BUG)
public void setTableFull(boolean isFull) {
if (isFull && !flowTableFull) {
floodlightProvider.addSwitchEvent(this.datapathId.getLong(),
"SWITCH_FLOW_TABLE_FULL " +
- "Table full error from switch", false);
+ "Table full error from switch", false);
log.warn("Switch {} flow table is full", stringId);
}
- flowTableFull = isFull;
+ flowTableFull = isFull;
}
@Override
@@ -1231,11 +1224,11 @@
// is sent, resulting in a wildcard-all flows
// XXX fix this later to be sure it works for both 1.0 and 1.3
OFMessage fm = getFactory()
- .buildFlowDelete()
- .setOutPort(OFPort.ANY)
- .setOutGroup(OFGroup.ANY)
- .setTableId(TableId.ALL)
- .build();
+ .buildFlowDelete()
+ .setOutPort(OFPort.ANY)
+ .setOutGroup(OFGroup.ANY)
+ .setTableId(TableId.ALL)
+ .build();
try {
channel.write(Collections.singletonList(fm));
@@ -1252,7 +1245,7 @@
try {
this.write(msglist);
} catch (IOException e) {
- log.error("Failed flushing messages", e);
+ log.error("Failed flushing messages", e);
}
msglist.clear();
}
@@ -1269,7 +1262,7 @@
* Return a read lock that must be held while calling the listeners for
* messages from the switch. Holding the read lock prevents the active
* switch list from being modified out from under the listeners.
- *
+ *
* @return listener read lock
*/
@JsonIgnore
@@ -1282,7 +1275,7 @@
* list of active switches. This is to ensure that the active switch list
* doesn't change out from under the listeners as they are handling a
* message from the switch.
- *
+ *
* @return listener write lock
*/
@JsonIgnore