Java OFFlowMod类代码示例

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public ImmutablePair<Long, Boolean> installTransitFlow(final DatapathId dpid, final String flowId,
                                                       final Long cookie, final int inputPort, final int outputPort,
                                                       final int transitVlanId) {
    List<OFAction> actionList = new ArrayList<>();
    IOFSwitch sw = ofSwitchService.getSwitch(dpid);

    // build match by input port and transit vlan id
    Match match = matchFlow(sw, inputPort, transitVlanId);

    // transmit packet from outgoing port
    actionList.add(actionSetOutputPort(sw, outputPort));

    // build instruction with action list
    OFInstructionApplyActions actions = buildInstructionApplyActions(sw, actionList);

    // build FLOW_MOD command, no meter
    OFFlowMod flowMod = buildFlowMod(sw, match, null, actions,
            cookie & FLOW_COOKIE_MASK, FlowModUtils.PRIORITY_VERY_HIGH);

    // send FLOW_MOD to the switch
    boolean response = pushFlow(flowId, dpid, flowMod);
    return new ImmutablePair<>(flowMod.getXid(), response);
}
 

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
/**
 * Create an OFFlowMod that can be passed to StaticEntryPusher.
 *
 * @param sw       switch object
 * @param match    match for the flow
 * @param meter    meter for the flow
 * @param actions  actions for the flow
 * @param cookie   cookie for the flow
 * @param priority priority to set on the flow
 * @return {@link OFFlowMod}
 */
private OFFlowMod buildFlowMod(final IOFSwitch sw, final Match match, final OFInstructionMeter meter,
                               final OFInstructionApplyActions actions, final long cookie, final int priority) {
    OFFlowMod.Builder fmb = sw.getOFFactory().buildFlowAdd();
    fmb.setIdleTimeout(FlowModUtils.INFINITE_TIMEOUT);
    fmb.setHardTimeout(FlowModUtils.INFINITE_TIMEOUT);
    fmb.setBufferId(OFBufferId.NO_BUFFER);
    fmb.setCookie(U64.of(cookie));
    fmb.setPriority(priority);
    List<OFInstruction> instructions = new ArrayList<>(2);

    if (meter != null) {              // If no meter then no bandwidth limit
        instructions.add(meter);
    }

    if (actions != null) {       // If no instruction then Drops packet
        instructions.add(actions);
    }

    if (match != null) {              // If no then match everything
        fmb.setMatch(match);
    }

    return fmb.setInstructions(instructions).build();
}
 

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
/**
 * Installs the verification rule
 *
 * @param dpid        datapathId of switch
 * @param isBroadcast if broadcast then set a generic match; else specific to switch Id
 * @return true if the command is accepted to be sent to switch, false otherwise - switch is disconnected or in
 * SLAVE mode
 */
private boolean installVerificationRule(final DatapathId dpid, final boolean isBroadcast) {
    IOFSwitch sw = ofSwitchService.getSwitch(dpid);

    Match match = matchVerification(sw, isBroadcast);
    ArrayList<OFAction> actionList = new ArrayList<>(2);
    actionList.add(actionSendToController(sw));
    actionList.add(actionSetDstMac(sw, dpidToMac(sw)));
    OFInstructionApplyActions instructionApplyActions = sw.getOFFactory().instructions()
            .applyActions(actionList).createBuilder().build();
    final long cookie = isBroadcast ? 0x8000000000000002L : 0x8000000000000003L;
    OFFlowMod flowMod = buildFlowMod(sw, match, null, instructionApplyActions,
            cookie, FlowModUtils.PRIORITY_VERY_HIGH);
    String flowname = (isBroadcast) ? "Broadcast" : "Unicast";
    flowname += "--VerificationFlow--" + dpid.toString();
    return pushFlow(flowname, dpid, flowMod);
}
 

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
@Override
public void sendMsg(OFMessage msg) {
    // Ignore everything but flow mods and stat requests
    if (!(msg instanceof OFFlowMod || msg instanceof OFFlowStatsRequest)) {
        super.sendMsg(msg);
        return;
    }

    Match newMatch;
    OFMessage newMsg = null;

    if (msg instanceof OFFlowStatsRequest) {
        // Rewrite match only
        OFFlowStatsRequest fsr = (OFFlowStatsRequest) msg;
        newMatch = rewriteMatch(fsr.getMatch());
        newMsg = fsr.createBuilder().setMatch(newMatch).build();
    } else if (msg instanceof OFFlowMod) {
        // Rewrite match and actions
        OFFlowMod fm = (OFFlowMod) msg;
        newMatch = rewriteMatch(fm.getMatch());
        List<OFAction> actions = rewriteActions(fm.getActions());
        newMsg = fm.createBuilder().setMatch(newMatch).setActions(actions).build();
    }

    super.sendMsg(newMsg);
}
 

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
@Override
public OFFlowMod buildFlowDel() {
    Match match = buildMatch();

    long cookie = flowRule().id().value();

    OFFlowDeleteStrict fm = factory().buildFlowDeleteStrict()
            .setXid(xid)
            .setCookie(U64.of(cookie))
            .setBufferId(OFBufferId.NO_BUFFER)
            .setMatch(match)
            .setFlags(Collections.singleton(OFFlowModFlags.SEND_FLOW_REM))
            .setPriority(flowRule().priority())
            .setTableId(TableId.of(flowRule().tableId()))
            .build();

    return fm;
}
 

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
@Override
public OFFlowMod buildFlowMod() {
    Match match = buildMatch();
    List<OFAction> actions = buildActions();

    long cookie = flowRule().id().value();

    OFFlowMod fm = factory().buildFlowModify()
            .setXid(xid)
            .setCookie(U64.of(cookie))
            .setBufferId(OFBufferId.NO_BUFFER)
            .setActions(actions)
            .setMatch(match)
            .setFlags(Collections.singleton(OFFlowModFlags.SEND_FLOW_REM))
            .setPriority(flowRule().priority())
            .build();

    return fm;
}
 

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
private OFFlowMod createFRESCOFlowMod(IOFSwitch sw, Match match, List<OFAction> actions, int priority){
	OFFlowMod.Builder fmb = sw.getOFFactory().buildFlowAdd();;
	
	fmb.setIdleTimeout(FlowModUtils.INFINITE_TIMEOUT);
	fmb.setHardTimeout(FlowModUtils.INFINITE_TIMEOUT);
	fmb.setBufferId(OFBufferId.NO_BUFFER);
	fmb.setOutPort(OFPort.ANY);
	fmb.setCookie(U64.of(0));  
	
	fmb.setPriority(U16.t(priority));
	fmb.setMatch(match);
	fmb.setActions(actions);
	
	return fmb.build();
	
}
 

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
/**
 * Reads from our entriesFromStorage for the specified switch and
 * sends the FlowMods down to the controller in <b>sorted</b> order.
 *
 * Sorted is important to maintain correctness of the switch:
 * if a packet would match both a lower and a higher priority
 * rule, then we want it to match the higher priority or nothing,
 * but never just the lower priority one.  Inserting from high to
 * low priority fixes this.
 *
 * TODO consider adding a "block all" flow mod and then removing it
 * while starting up.
 *
 * @param sw The switch to send entries to
 */
protected void sendEntriesToSwitch(DatapathId switchId) {
	IOFSwitch sw = switchService.getSwitch(switchId);
	if (sw == null)
		return;
	String stringId = sw.getId().toString();

	if ((entriesFromStorage != null) && (entriesFromStorage.containsKey(stringId))) {
		Map<String, OFFlowMod> entries = entriesFromStorage.get(stringId);
		List<String> sortedList = new ArrayList<String>(entries.keySet());
		// weird that Collections.sort() returns void
		Collections.sort( sortedList, new FlowModSorter(stringId));
		for (String entryName : sortedList) {
			OFFlowMod flowMod = entries.get(entryName);
			if (flowMod != null) {
				if (log.isDebugEnabled()) {
					log.debug("Pushing static entry {} for {}", stringId, entryName);
				}
				writeFlowModToSwitch(sw, flowMod);
			}
		}
	}
}
 

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
/**
 * Read entries from storageSource, and store them in a hash
 *
 * @return
 */
private Map<String, Map<String, OFFlowMod>> readEntriesFromStorage() {
	Map<String, Map<String, OFFlowMod>> entries = new ConcurrentHashMap<String, Map<String, OFFlowMod>>();
	try {
		Map<String, Object> row;
		// null1=no predicate, null2=no ordering
		IResultSet resultSet = storageSourceService.executeQuery(TABLE_NAME, ColumnNames, null, null);
		for (Iterator<IResultSet> it = resultSet.iterator(); it.hasNext();) {
			row = it.next().getRow();
			parseRow(row, entries);
		}
	} catch (StorageException e) {
		log.error("failed to access storage: {}", e.getMessage());
		// if the table doesn't exist, then wait to populate later via
		// setStorageSource()
	}
	return entries;
}
 

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
/** 
 * Adds the instructions to the list of OFInstructions in the OFFlowMod. Any pre-existing
 * instruction of the same type is replaced with OFInstruction inst.
 * @param fmb, the flow mod to append the instruction to
 * @param inst, the instuction to append
 */
public static void appendInstruction(OFFlowMod.Builder fmb, OFInstruction inst) {
	List<OFInstruction> newIl = new ArrayList<OFInstruction>();
	List<OFInstruction> oldIl = fmb.getInstructions();
	if (oldIl != null) { // keep any existing instructions that were added earlier
		newIl.addAll(fmb.getInstructions());
	}

	for (OFInstruction i : newIl) { // remove any duplicates. Only one of each instruction.
		if (i.getType() == inst.getType()) {
			newIl.remove(i);
		}
	}	
	newIl.add(inst);
	fmb.setInstructions(newIl);
}
 

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
/**
 * Convert the string representation of an OFInstructionGotoTable to
 * an OFInstructionGotoTable. The instruction will be set within the
 * OFFlowMod.Builder provided. Notice nothing is returned, but the
 * side effect is the addition of an instruction in the OFFlowMod.Builder.
 * @param fmb; The FMB in which to append the new instruction
 * @param instStr; The string to parse the instruction from
 * @param log
 */
public static void gotoTableFromString(OFFlowMod.Builder fmb, String inst, Logger log) {
	if (inst == null || inst.equals("")) {
		return;
	}

	if (fmb.getVersion().compareTo(OFVersion.OF_11) < 0) {
		log.error("Goto Table Instruction not supported in OpenFlow 1.0");
		return;
	}

	OFInstructionGotoTable.Builder ib = OFFactories.getFactory(fmb.getVersion()).instructions().buildGotoTable();

	// Get the table ID
	if (inst.startsWith("0x")) {
		ib.setTableId(TableId.of(Integer.parseInt(inst.replaceFirst("0x", ""), 16)));
	} else {
		ib.setTableId(TableId.of(Integer.parseInt(inst))).build();
	}

	log.debug("Appending GotoTable instruction: {}", ib.build());
	appendInstruction(fmb, ib.build());
	log.debug("All instructions after append: {}", fmb.getInstructions());	
}
 

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
/**
 * Convert the string representation of an OFInstructionClearActions to
 * an OFInstructionClearActions. The instruction will be set within the
 * OFFlowMod.Builder provided. Notice nothing is returned, but the
 * side effect is the addition of an instruction in the OFFlowMod.Builder.
 * @param fmb; The FMB in which to append the new instruction
 * @param instStr; The string to parse the instruction from
 * @param log
 */
public static void clearActionsFromString(OFFlowMod.Builder fmb, String inst, Logger log) {

	if (fmb.getVersion().compareTo(OFVersion.OF_11) < 0) {
		log.error("Clear Actions Instruction not supported in OpenFlow 1.0");
		return;
	}

	if (inst != null && inst.trim().isEmpty()) { /* Allow the empty string, since this is what specifies clear (i.e. key clear does not have any defined values). */
		OFInstructionClearActions i = OFFactories.getFactory(fmb.getVersion()).instructions().clearActions();
		log.debug("Appending ClearActions instruction: {}", i);
		appendInstruction(fmb, i);
		log.debug("All instructions after append: {}", fmb.getInstructions());		
	} else {
		log.error("Got non-empty or null string, but ClearActions should not have any String sub-fields: {}", inst);
	}
}
 

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
/**
 * Convert the string representation of an OFInstructionExperimenter to
 * an OFInstructionExperimenter. The instruction will be set within the
 * OFFlowMod.Builder provided. Notice nothing is returned, but the
 * side effect is the addition of an instruction in the OFFlowMod.Builder.
 * @param fmb; The FMB in which to append the new instruction
 * @param instStr; The string to parse the instruction from
 * @param log
 */
public static void experimenterFromString(OFFlowMod.Builder fmb, String inst, Logger log) {
	/* TODO This is a no-op right now. */

	/*
	if (inst == null || inst.equals("")) {
		return; // TODO @Ryan quietly fail?
	}

	OFInstructionExperimenter.Builder ib = OFFactories.getFactory(fmb.getVersion()).instructions().buildExperimenter();

	String[] keyValue = inst.split("=");	
	if (keyValue.length != 2) {
		throw new IllegalArgumentException("[Key, Value] " + keyValue + " does not have form 'key=value' parsing " + inst);
	}
	switch (keyValue[0]) {
	case STR_SUB_GOTO_METER_METER_ID:
		ib.setExperimenter(Long.parseLong(keyValue[1]));
		break;
	default:
		log.error("Invalid String key for OFInstructionExperimenter: {}", keyValue[0]);
	}

	appendInstruction(fmb, ib.build());
	 */
}
 

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
/**
 * Convert the string representation of an OFInstructionMeter to
 * an OFInstructionMeter. The instruction will be set within the
 * OFFlowMod.Builder provided. Notice nothing is returned, but the
 * side effect is the addition of an instruction in the OFFlowMod.Builder.
 * @param fmb; The FMB in which to append the new instruction
 * @param instStr; The string to parse the instruction from
 * @param log
 */
public static void meterFromString(OFFlowMod.Builder fmb, String inst, Logger log) {
	if (inst == null || inst.isEmpty()) {
		return;
	}

	if (fmb.getVersion().compareTo(OFVersion.OF_13) < 0) {
		log.error("Goto Meter Instruction not supported in OpenFlow 1.0, 1.1, or 1.2");
		return;
	}

	OFInstructionMeter.Builder ib = OFFactories.getFactory(fmb.getVersion()).instructions().buildMeter();

	if (inst.startsWith("0x")) {
		ib.setMeterId(Long.valueOf(inst.replaceFirst("0x", ""), 16));
	} else {
		ib.setMeterId(Long.valueOf(inst));
	}		

	log.debug("Appending (Goto)Meter instruction: {}", ib.build());
	appendInstruction(fmb, ib.build());
	log.debug("All instructions after append: {}", fmb.getInstructions());
}
 

import org.projectfloodlight.openflow.protocol.OFFlowMod; //导入依赖的package包/类
@Get("json")
public OFFlowModMap ListStaticFlowEntries() {
    IStaticFlowEntryPusherService sfpService =
            (IStaticFlowEntryPusherService)getContext().getAttributes().
                get(IStaticFlowEntryPusherService.class.getCanonicalName());
    
    String param = (String) getRequestAttributes().get("switch");
    if (log.isDebugEnabled())
        log.debug("Listing all static flow entires for switch: " + param);
    
    if (param.toLowerCase().equals("all")) {
        return new OFFlowModMap(sfpService.getFlows());
    } else {
        try {
            Map<String, Map<String, OFFlowMod>> retMap = new HashMap<String, Map<String, OFFlowMod>>();
            retMap.put(param, sfpService.getFlows(DatapathId.of(param)));
            return new OFFlowModMap(retMap);
            
        } catch (NumberFormatException e){
            setStatus(Status.CLIENT_ERROR_BAD_REQUEST, ControllerSwitchesResource.DPID_ERROR);
        }
    }
    return null;
}