Java OFStatisticsRequest类代码示例

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
/**
 * Send the configuration requests we can only do after we have
 * the features reply
 * @throws IOException
 */
void sendFeatureReplyConfiguration() throws IOException {
    // Ensure we receive the full packet via PacketIn
    OFSetConfig config = (OFSetConfig) factory
            .getMessage(OFType.SET_CONFIG);
    config.setMissSendLength((short) 0xffff)
    .setLengthU(OFSwitchConfig.MINIMUM_LENGTH);
    sw.write(config, null);
    sw.write(factory.getMessage(OFType.GET_CONFIG_REQUEST),
            null);

    // Get Description to set switch-specific flags
    OFStatisticsRequest req = new OFStatisticsRequest();
    req.setStatisticType(OFStatisticsType.DESC);
    req.setLengthU(req.getLengthU());
    Future<List<OFStatistics>> dfuture = 
            sw.getStatistics(req);
    sw.setAttribute(IOFSwitch.SWITCH_DESCRIPTION_FUTURE,
            dfuture);

}
 

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
private byte[] serializeMessage(OFMessage message) {
	String serializedMsg = "";
	if (message instanceof OFPacketOut) {
		OFPacketOut packetOut = (OFPacketOut)message;
		serializedMsg = MessageSerializer.serializeMessage(this.dummySwitch.getId(), packetOut);
	}
	else if (message instanceof OFFlowMod) {
		OFFlowMod flowMod = (OFFlowMod)message;
		serializedMsg = MessageSerializer.serializeMessage(this.dummySwitch.getId(), flowMod);
	} 
	else if (message instanceof OFStatisticsRequest) {
		OFStatisticsRequest statRequest = (OFStatisticsRequest)message;			
		serializedMsg = MessageSerializer.serializeMessage(this.dummySwitch.getId(), statRequest);
	}
	logger.debug("serialized: " + serializedMsg);
	return serializedMsg.getBytes();
}
 

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
/**
 * Serializes an Openflow Statistics Request message for Pyretic
 * @param switchID switch id
 * @param statsRequest object to be serialized
 * @return
 */
public static String serializeMessage(long switchID, OFStatisticsRequest statsRequest) {
	String retString="";
	switch (statsRequest.getStatisticType()) {
		case DESC: 
			break;
		case FLOW:
			retString = "[\"flow_stats_request\", " + switchID + "]" + "\n";
			break;
		case AGGREGATE:
		case PORT:
			retString = "[\"port_stats_request\", " + switchID + "]" + "\n"; //maybe portId is also required
		case TABLE:
		case VENDOR:
		case QUEUE:
	}
	return retString;
}
 

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
@Override
public Object getStatistics(OFStatisticsRequest req) {
    int xid = getNextXid();
    StatisticsCollector worker = new StatisticsCollector(this, xid, req);
    messageWaitingDone.put(xid, worker);
    Future<Object> submit = executor.submit(worker);
    Object result = null;
    try {
        result = submit.get(responseTimerValue, TimeUnit.MILLISECONDS);
        return result;
    } catch (Exception e) {
        logger.warn("Timeout while waiting for {} replies", req.getType());
        result = null; // to indicate timeout has occurred
        return result;
    }
}
 

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
/**
 * @param sw
 *            the switch object that we wish to get flows from
 * @param outPort
 *            the output action port we wish to find flows with
 * @return a list of OFFlowStatisticsReply objects or essentially flows
 */
public List<OFFlowStatisticsReply> getFlows(IOFSwitch sw, Short outPort) {

    statsReply = new ArrayList<OFFlowStatisticsReply>();
    List<OFStatistics> values = null;
    Future<List<OFStatistics>> future;

    // Statistics request object for getting flows
    OFStatisticsRequest req = new OFStatisticsRequest();
    req.setStatisticType(OFStatisticsType.FLOW);
    int requestLength = req.getLengthU();
    OFFlowStatisticsRequest specificReq = new OFFlowStatisticsRequest();
    specificReq.setMatch(new OFMatch().setWildcards(0xffffffff));
    specificReq.setOutPort(outPort);
    specificReq.setTableId((byte) 0xff);
    req.setStatistics(Collections.singletonList((OFStatistics) specificReq));
    requestLength += specificReq.getLength();
    req.setLengthU(requestLength);

    try {
        // System.out.println(sw.getStatistics(req));
        future = sw.queryStatistics(req);
        values = future.get(10, TimeUnit.SECONDS);
        if (values != null) {
            for (OFStatistics stat : values) {
                statsReply.add((OFFlowStatisticsReply) stat);
            }
        }
    } catch (Exception e) {
        log.error("Failure retrieving statistics from switch " + sw, e);
    }

    return statsReply;
}
 

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
@Override
public void sendStatsQuery(OFStatisticsRequest request, int xid,
                            IOFMessageListener caller) throws IOException {
    request.setXid(xid);
    this.iofMsgListenersMap.put(xid, caller);
    List<OFMessage> msglist = new ArrayList<OFMessage>(1);
    msglist.add(request);
    this.write(msglist);
    return;
}
 

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
@Override
public Future<List<OFStatistics>> queryStatistics(OFStatisticsRequest request) throws IOException {
    request.setXid(getNextTransactionId());
    OFStatisticsFuture future = new OFStatisticsFuture(threadPool, this, request.getXid());
    this.statsFutureMap.put(request.getXid(), future);
    List<OFMessage> msglist = new ArrayList<OFMessage>(1);
    msglist.add(request);
    this.write(msglist);
    return future;
}
 

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
/**
 * send a description state request
 * @throws IOException
 */
private void sendHandshakeDescriptionStatsRequest() throws IOException {
    // Get Description to set switch-specific flags
    OFStatisticsRequest req = new OFStatisticsRequest();
    req.setStatisticType(OFStatisticsType.DESC);
    req.setXid(handshakeTransactionIds--);

    channel.write(Collections.singletonList(req));
}
 

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
/** Move the channel from scratch to WAIT_DESCRIPTION_STAT_REPLY state
 * Builds on moveToWaitConfigReply()
 * adds testing for WAIT_CONFIG_REPLY state
 */
@Test
public void moveToWaitDescriptionStatReply() throws Exception {
    moveToWaitConfigReply();
    resetChannel();
    channel.write(capture(writeCapture));
    expectLastCall().andReturn(null).atLeastOnce();
    replay(channel);

    OFGetConfigReply cr = (OFGetConfigReply)BasicFactory.getInstance()
            .getMessage(OFType.GET_CONFIG_REPLY);
    cr.setMissSendLength((short)0xffff);

    sendMessageToHandlerWithControllerReset(Collections.<OFMessage>singletonList(cr));

    List<OFMessage> msgs = getMessagesFromCapture();
    assertEquals(1, msgs.size());
    assertEquals(OFType.STATS_REQUEST, msgs.get(0).getType());
    OFStatisticsRequest sr = (OFStatisticsRequest)msgs.get(0);
    assertEquals(OFStatisticsType.DESC, sr.getStatisticType());
    // no idea why an  OFStatisticsRequest even /has/ a getStatistics()
    // methods. It really shouldn't
    assertNull(sr.getStatistics());
    verifyUniqueXids(msgs);
    assertEquals(OFChannelHandler.ChannelState.WAIT_DESCRIPTION_STAT_REPLY,
                 handler.getStateForTesting());
}
 

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
@Override
public void sendStatsQuery(OFStatisticsRequest request, int xid,
                            IOFMessageListener caller) throws IOException {
    request.setXid(xid);
    this.iofMsgListenersMap.put(xid, caller);
    List<OFMessage> msglist = new ArrayList<OFMessage>(1);
    msglist.add(request);
    this.channel.write(msglist);
    return;
}
 

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
@Override
public Future<List<OFStatistics>> getStatistics(OFStatisticsRequest request) throws IOException {
    request.setXid(getNextTransactionId());
    OFStatisticsFuture future = new OFStatisticsFuture(threadPool, this, request.getXid());
    this.statsFutureMap.put(request.getXid(), future);
    List<OFMessage> msglist = new ArrayList<OFMessage>(1);
    msglist.add(request);
    this.channel.write(msglist);
    return future;
}
 

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
protected void sendHandshakeDescriptionStatsRequest() {
    final OFStatisticsRequest req = new OFStatisticsRequest();
    req.setStatisticType(OFStatisticsType.DESC);
    req.setXid(this.handshakeTransactionIds--);

    this.channel.write(Collections.singletonList(req));

}
 

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
/**
 * Description Stats Reply Builder
 *
 * @param incomingStat incoming Stats Request
 * @return the Stats Reply
 */
private OFDescriptionStatistics descStatBuilder(OFStatisticsRequest incomingStat) {

    OFDescriptionStatistics descStat = new OFDescriptionStatistics();
    descStat.setDatapathDescription("None");
    descStat.setHardwareDescription("OFCProbe Vswitch");
    descStat.setManufacturerDescription("Lehrstuhl fuer Informatik III, University of Wuerzburg");
    descStat.setSerialNumber(String.valueOf(this.dpid));
    descStat.setSoftwareDescription("1.0.3");

    return descStat;
}
 

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
/**
 * @param sw
 *            the switch object that we wish to get flows from
 * @param outPort
 *            the output action port we wish to find flows with
 * @return a list of OFFlowStatisticsReply objects or essentially flows
 */
public List<OFFlowStatisticsReply> getFlows(IOFSwitch sw, Short outPort) {

    statsReply = new ArrayList<OFFlowStatisticsReply>();
    List<OFStatistics> values = null;
    Future<List<OFStatistics>> future;

    // Statistics request object for getting flows
    OFStatisticsRequest req = new OFStatisticsRequest();
    req.setStatisticType(OFStatisticsType.FLOW);
    int requestLength = req.getLengthU();
    OFFlowStatisticsRequest specificReq = new OFFlowStatisticsRequest();
    specificReq.setMatch(new OFMatch().setWildcards(0xffffffff));
    specificReq.setOutPort(outPort);
    specificReq.setTableId((byte) 0xff);
    req.setStatistics(Collections.singletonList((OFStatistics) specificReq));
    requestLength += specificReq.getLength();
    req.setLengthU(requestLength);

    try {
        // System.out.println(sw.getStatistics(req));
        future = sw.getStatistics(req);
        values = future.get(10, TimeUnit.SECONDS);
        if (values != null) {
            for (OFStatistics stat : values) {
                statsReply.add((OFFlowStatisticsReply) stat);
            }
        }
    } catch (Exception e) {
        log.error("Failure retrieving statistics from switch " + sw, e);
    }

    return statsReply;
}
 

import org.openflow.protocol.OFStatisticsRequest; //导入依赖的package包/类
/**
 * Send the configuration requests we can only do after we have
 * the features reply
 * @throws IOException
 */
private void sendFeatureReplyConfiguration() throws IOException {
    List<OFMessage> msglist = new ArrayList<OFMessage>(3);

    // Ensure we receive the full packet via PacketIn
    OFSetConfig configSet = (OFSetConfig) factory
            .getMessage(OFType.SET_CONFIG);
    configSet.setMissSendLength((short) 0xffff)
        .setLengthU(OFSwitchConfig.MINIMUM_LENGTH);
    configSet.setXid(-4);
    msglist.add(configSet);

    // Verify (need barrier?)
    OFGetConfigRequest configReq = (OFGetConfigRequest)
            factory.getMessage(OFType.GET_CONFIG_REQUEST);
    configReq.setXid(-3);
    msglist.add(configReq);

    // Get Description to set switch-specific flags
    OFStatisticsRequest req = new OFStatisticsRequest();
    req.setStatisticType(OFStatisticsType.DESC);
    req.setXid(-2);  // something "large"
    req.setLengthU(req.getLengthU());
    msglist.add(req);

    channel.write(msglist);
}