Java TypedStoredFlowEntry.life方法代码示例

import org.onosproject.net.flow.TypedStoredFlowEntry; //导入方法依赖的package包/类
private void calAndSetFlowLiveTypeInternal(TypedStoredFlowEntry rule) {
    long life = rule.life();
    FlowLiveType prevFlowLiveType = rule.flowLiveType();

    if (life >= longPollInterval) {
        rule.setFlowLiveType(FlowLiveType.LONG_FLOW);
        longFlows.add(rule);
    } else if (life >= midPollInterval) {
        rule.setFlowLiveType(FlowLiveType.MID_FLOW);
        midFlows.add(rule);
    } else if (life >= calAndPollInterval) {
        rule.setFlowLiveType(FlowLiveType.SHORT_FLOW);
        shortFlows.add(rule);
    } else if (life >= 0) {
        rule.setFlowLiveType(FlowLiveType.IMMEDIATE_FLOW);
    } else { // life < 0
        rule.setFlowLiveType(FlowLiveType.UNKNOWN_FLOW);
    }

    if (rule.flowLiveType() != prevFlowLiveType) {
        switch (prevFlowLiveType) {
        // delete it from previous flow table
        case SHORT_FLOW:
            shortFlows.remove(rule);
            break;
        case MID_FLOW:
            midFlows.remove(rule);
            break;
        case LONG_FLOW:
            longFlows.remove(rule);
            break;
        default:
            break;
        }
    }
}
 

import org.onosproject.net.flow.TypedStoredFlowEntry; //导入方法依赖的package包/类
/**
 * Adds or updates typed flow entry from flow entry into the internal flow table.
 *
 * @param flowEntries the flow entries
 */
public synchronized void addOrUpdateFlows(FlowEntry... flowEntries) {
    for (FlowEntry fe : flowEntries) {
        // check if this new rule is an update to an existing entry
        TypedStoredFlowEntry stored = deviceFlowTable.getFlowEntry(fe);

        if (stored != null) {
            // duplicated flow entry is collected!, just skip
            if (fe.bytes() == stored.bytes() && fe.packets() == stored.packets()
                    && fe.life() == stored.life()) {
                if (log.isTraceEnabled()) {
                    log.trace("addOrUpdateFlows({}): flowId={},is DUPLICATED stats collection, just skip.",
                            sw.getStringId(), fe.id());
                }

                //FIXME modification of "stored" flow entry outside of store
                stored.setLastSeen();
                continue;
            } else if (fe.life() < stored.life()) {
                // Invalid updates the stats values, i.e., bytes, packets, durations ...
                if (log.isDebugEnabled()) {
                    log.debug(ADD_INVALID_LOG, fe.id(), stored.id(), fe.bytes(),
                            stored.bytes(), fe.life(), stored.life(),
                            fe.lastSeen(), stored.lastSeen());
                }
                // go next
                //FIXME modification of "stored" flow entry outside of store
                stored.setLastSeen();
                continue;
            }

            // update now
            //FIXME modification of "stored" flow entry outside of store
            stored.setLife(fe.life());
            stored.setPackets(fe.packets());
            stored.setBytes(fe.bytes());
            stored.setLastSeen();
            if (stored.state() == FlowEntry.FlowEntryState.PENDING_ADD) {
                // flow is really RULE_ADDED
                stored.setState(FlowEntry.FlowEntryState.ADDED);
            }
            // flow is RULE_UPDATED, skip adding and just updating flow live table
            //deviceFlowTable.calAndSetFlowLiveType(stored);
            continue;
        }

        // add new flow entry, we suppose IMMEDIATE_FLOW
        TypedStoredFlowEntry newFlowEntry = new DefaultTypedFlowEntry(fe,
                FlowLiveType.IMMEDIATE_FLOW);
        deviceFlowTable.addWithCalAndSetFlowLiveType(newFlowEntry);
    }
}
 

import org.onosproject.net.flow.TypedStoredFlowEntry; //导入方法依赖的package包/类
private boolean checkAndMoveLiveFlowInternal(TypedStoredFlowEntry fe, long cTime) {
    long curTime = (cTime > 0 ? cTime : System.currentTimeMillis());
    // For latency adjustment(default=500 millisecond) between FlowStatsRequest and Reply
    long fromLastSeen = ((curTime - fe.lastSeen() + latencyFlowStatsRequestAndReplyMillis) / 1000);
    // fe.life() unit is SECOND!
    long liveTime = fe.life() + fromLastSeen;


    switch (fe.flowLiveType()) {
    case IMMEDIATE_FLOW:
        if (liveTime >= longPollInterval) {
            fe.setFlowLiveType(FlowLiveType.LONG_FLOW);
            longFlows.add(fe);
        } else if (liveTime >= midPollInterval) {
            fe.setFlowLiveType(FlowLiveType.MID_FLOW);
            midFlows.add(fe);
        } else if (liveTime >= calAndPollInterval) {
            fe.setFlowLiveType(FlowLiveType.SHORT_FLOW);
            shortFlows.add(fe);
        }
        break;
    case SHORT_FLOW:
        if (liveTime >= longPollInterval) {
            fe.setFlowLiveType(FlowLiveType.LONG_FLOW);
            shortFlows.remove(fe);
            longFlows.add(fe);
        } else if (liveTime >= midPollInterval) {
            fe.setFlowLiveType(FlowLiveType.MID_FLOW);
            shortFlows.remove(fe);
            midFlows.add(fe);
        }
        break;
    case MID_FLOW:
        if (liveTime >= longPollInterval) {
            fe.setFlowLiveType(FlowLiveType.LONG_FLOW);
            midFlows.remove(fe);
            longFlows.add(fe);
        }
        break;
    case LONG_FLOW:
        if (fromLastSeen > entirePollInterval) {
            log.trace("checkAndMoveLiveFlowInternal: flow is already removed at switch.");
            return false;
        }
        break;
    case UNKNOWN_FLOW: // Unknown flow is an internal error flow type, just fall through
    default:
        log.error("Unknown live type error for {}", sw.getStringId());
        return false;
    }

    if (log.isTraceEnabled()) {
        log.trace(CHECK_AND_MOVE_LOG, fe.id(), fe.state(), fe.flowLiveType(),
                liveTime, fe.life(), fe.bytes(), fe.packets(), fromLastSeen,
                fe.priority(), fe.selector().criteria(), fe.treatment(),
                sw.getStringId());
    }

    return true;
}