Java IOFSwitchListener.removedSwitch方法代码示例

import net.floodlightcontroller.core.IOFSwitchListener; //导入方法依赖的package包/类
public void dispatch() {
    if (log.isTraceEnabled()) {
        log.trace("Dispatching switch update {} {}",
                sw, switchUpdateType);
    }
    if (switchListeners != null) {
        for (IOFSwitchListener listener : switchListeners) {
            switch(switchUpdateType) {
                case ADDED:
                    listener.addedSwitch(sw);
                    break;
                case REMOVED:
                    listener.removedSwitch(sw);
                    break;
                case PORTCHANGED:
                    listener.switchPortChanged(sw.getId());
                    break;
            }
        }
    }
}
 

import net.floodlightcontroller.core.IOFSwitchListener; //导入方法依赖的package包/类
@Override
public void dispatch() {
    if (log.isTraceEnabled()) {
        log.trace("Dispatching switch update {} {}",
                sw, switchUpdateType);
    }
    if (switchListeners != null) {
        for (IOFSwitchListener listener : switchListeners) {
            switch(switchUpdateType) {
                case ADDED:
                    listener.addedSwitch(sw);
                    break;
                case REMOVED:
                    listener.removedSwitch(sw);
                    break;
                case PORTCHANGED:
                    listener.switchPortChanged(sw.getId());
                    break;
            }
        }
    }
}
 

import net.floodlightcontroller.core.IOFSwitchListener; //导入方法依赖的package包/类
/**
 * Add a switch to the active switch list and call the switch listeners.
 * This happens either when a switch first connects (and the controller is
 * not in the slave role) or when the role of the controller changes from
 * slave to master.
 * @param sw the switch that has been added
 */
// TODO: need to rethink locking and the synchronous switch update.
//       We can / should also handle duplicate DPIDs in connectedSwitches
@LogMessageDoc(level="ERROR",
        message="New switch added {switch} for already-added switch {switch}",
        explanation="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 reconnected very quickly after " +
                "disconnecting.",
        recommendation="If this happens repeatedly, it is likely there " +
                "are switches with duplicate DPIDs on the network.  " +
                "Reconfigure the appropriate switches.  If it happens " +
                "very rarely, then it is likely this is a transient " +
                "network problem that can be ignored."
        )
protected void addSwitch(IOFSwitch sw) {
    // TODO: is it safe to modify the HashMap without holding 
    // the old switch's lock?
    OFSwitchImpl oldSw = (OFSwitchImpl) this.activeSwitches.put(sw.getId(), sw);
    if (sw == oldSw) {
        // Note == for object equality, not .equals for value
        log.info("New add switch for pre-existing switch {}", sw);
        return;
    }
    
    if (oldSw != null) {
        oldSw.getListenerWriteLock().lock();
        try {
            log.error("New switch added {} for already-added switch {}",
                      sw, oldSw);
            // Set the connected flag to false to suppress calling
            // the listeners for this switch in processOFMessage
            oldSw.setConnected(false);
            
            oldSw.cancelAllStatisticsReplies();
            
            updateInactiveSwitchInfo(oldSw);

            // we need to clean out old switch state definitively 
            // before adding the new switch
            // FIXME: It seems not completely kosher to call the
            // switch listeners here. I thought one of the points of
            // having the asynchronous switch update mechanism was so
            // the addedSwitch and removedSwitch were always called
            // from a single thread to simplify concurrency issues
            // for the listener.
            if (switchListeners != null) {
                for (IOFSwitchListener listener : switchListeners) {
                    listener.removedSwitch(oldSw);
                }
            }
            // will eventually trigger a removeSwitch(), which will cause
            // a "Not removing Switch ... already removed debug message.
            // TODO: Figure out a way to handle this that avoids the
            // spurious debug message.
            oldSw.getChannel().close();
        }
        finally {
            oldSw.getListenerWriteLock().unlock();
        }
    }
    
    updateActiveSwitchInfo(sw);
    SwitchUpdate update = new SwitchUpdate(sw, SwitchUpdateType.ADDED);
    try {
        this.updates.put(update);
    } catch (InterruptedException e) {
        log.error("Failure adding update to queue", e);
    }
}