import org.openflow.protocol.OFBarrierRequest; //导入依赖的package包/类
/**
 * Send the configuration requests to tell the switch we want full
 * packets
 * @throws IOException
 */
private void sendHandshakeSetConfig() throws IOException {
    List<OFMessage> msglist = new ArrayList<OFMessage>(3);

    // Ensure we receive the full packet via PacketIn
    // FIXME: We don't set the reassembly flags.
    OFSetConfig configSet = (OFSetConfig) BasicFactory.getInstance()
            .getMessage(OFType.SET_CONFIG);
    configSet.setMissSendLength((short) 0xffff)
        .setLengthU(OFSwitchConfig.MINIMUM_LENGTH);
    configSet.setXid(handshakeTransactionIds--);
    msglist.add(configSet);

    // Barrier
    OFBarrierRequest barrier = (OFBarrierRequest) BasicFactory.getInstance()
            .getMessage(OFType.BARRIER_REQUEST);
    barrier.setXid(handshakeTransactionIds--);
    msglist.add(barrier);

    // Verify (need barrier?)
    OFGetConfigRequest configReq = (OFGetConfigRequest)
            BasicFactory.getInstance().getMessage(OFType.GET_CONFIG_REQUEST);
    configReq.setXid(handshakeTransactionIds--);
    msglist.add(configReq);
    channel.write(msglist);
}
 

import org.openflow.protocol.OFBarrierRequest; //导入依赖的package包/类
/**
 * Sends the configuration requests to tell the switch we want full packets.
 *
 * @throws IOException
 */
private void sendHandshakeSetConfig() throws IOException {
    final List<OFMessage> msglist = new ArrayList<OFMessage>(3);

    // Ensure we receive the full packet via PacketIn

    final OFSetConfig configSet = (OFSetConfig) BasicFactory.getInstance()
            .getMessage(OFType.SET_CONFIG);
    configSet.setMissSendLength(OVXSetConfig.MSL_FULL).setLengthU(
            OFSwitchConfig.MINIMUM_LENGTH);
    configSet.setXid(this.handshakeTransactionIds--);
    msglist.add(configSet);

    // Barrier
    final OFBarrierRequest barrier = (OFBarrierRequest) BasicFactory
            .getInstance().getMessage(OFType.BARRIER_REQUEST);
    barrier.setXid(this.handshakeTransactionIds--);
    msglist.add(barrier);

    // Verify (need barrier?)
    final OFGetConfigRequest configReq = (OFGetConfigRequest) BasicFactory
            .getInstance().getMessage(OFType.GET_CONFIG_REQUEST);
    configReq.setXid(this.handshakeTransactionIds--);
    msglist.add(configReq);
    this.channel.write(msglist);
}
 

import org.openflow.protocol.OFBarrierRequest; //导入依赖的package包/类
@Override
public Object call() throws Exception {
    /*
     * Send out message only if syncRequest is set to true. Otherwise, just
     * wait for the Barrier response back.
     */
    if (syncRequest) {
        sw.asyncSend(syncMsg, xid);
        if (!(syncMsg instanceof OFBarrierRequest)) {
            OFBarrierRequest barrierMsg = new OFBarrierRequest();
            sw.asyncSend(barrierMsg, xid);
        }
    }
    latch.await();
    return result;
}
 

import org.openflow.protocol.OFBarrierRequest; //导入依赖的package包/类
@Override
@LogMessageDoc(level="ERROR",
               message="Failed to clear all flows on switch {switch}",
               explanation="An I/O error occured while trying to clear " +
                           "flows on the switch.",
               recommendation=LogMessageDoc.CHECK_SWITCH)
public void clearAllFlowMods() {
    // Delete all pre-existing flows
    OFMatch match = new OFMatch().setWildcards(OFMatch.OFPFW_ALL);
    OFMessage fm = ((OFFlowMod) floodlightProvider.getOFMessageFactory()
        .getMessage(OFType.FLOW_MOD))
            .setMatch(match)
        .setCommand(OFFlowMod.OFPFC_DELETE)
        .setOutPort(OFPort.OFPP_NONE)
        .setLength(U16.t(OFFlowMod.MINIMUM_LENGTH));
    fm.setXid(getNextTransactionId());
    OFMessage barrierMsg = (OFBarrierRequest)
            floodlightProvider.getOFMessageFactory().getMessage(
                    OFType.BARRIER_REQUEST);
    barrierMsg.setXid(getNextTransactionId());
    try {
        List<OFMessage> msglist = new ArrayList<OFMessage>(1);
        msglist.add(fm);
        write(msglist);
        msglist = new ArrayList<OFMessage>(1);
        msglist.add(barrierMsg);
        write(msglist);
    } catch (Exception e) {
        log.error("Failed to clear all flows on switch " + this, e);
    }
}
 

import org.openflow.protocol.OFBarrierRequest; //导入依赖的package包/类
/**
 * Send Barrier message asynchronously. The caller is not blocked. The
 * Barrier message will be sent in a transmit thread which will be blocked
 * until the Barrier reply is received.
 */
@Override
public Object asyncSendBarrierMessage() {
    if (transmitQ == null) {
        return Boolean.FALSE;
    }

    OFBarrierRequest barrierMsg = new OFBarrierRequest();
    int xid = getNextXid();

    barrierMsg.setXid(xid);
    transmitQ.add(new PriorityMessage(barrierMsg, 0, true));

    return Boolean.TRUE;
}
 

import org.openflow.protocol.OFBarrierRequest; //导入依赖的package包/类
void processOFBarrierRequest(final ControllerChannelHandler h,
        final OFBarrierRequest m) {
    this.illegalMessageReceived(h, m);
}
 

import org.openflow.protocol.OFBarrierRequest; //导入依赖的package包/类
/**
 * Send Barrier message synchronously. The caller will be blocked until the
 * Barrier reply is received.
 */
@Override
public Object syncSendBarrierMessage() {
    OFBarrierRequest barrierMsg = new OFBarrierRequest();
    return syncSend(barrierMsg);
}