import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
private void buildConnectivityDetails(ConnectivityIntent intent,
                                      StringBuilder sb) {
    Set<Criterion> criteria = intent.selector().criteria();
    List<Instruction> instructions = intent.treatment().allInstructions();
    List<Constraint> constraints = intent.constraints();

    if (!criteria.isEmpty()) {
        sb.append("Selector: ").append(criteria);
    }
    if (!instructions.isEmpty()) {
        sb.append("Treatment: ").append(instructions);
    }
    if (constraints != null && !constraints.isEmpty()) {
        sb.append("Constraints: ").append(constraints);
    }
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
private Collection<FlowRule> processSpecific(ForwardingObjective fwd) {
    log.debug("Processing specific forwarding objective");
    TrafficSelector selector = fwd.selector();
    EthTypeCriterion ethType =
            (EthTypeCriterion) selector.getCriterion(Criterion.Type.ETH_TYPE);
    if (ethType != null) {
        short et = ethType.ethType().toShort();
        if (et == Ethernet.TYPE_IPV4) {
            return processSpecificRoute(fwd);
        } else if (et == Ethernet.TYPE_VLAN) {
            /* The ForwardingObjective must specify VLAN ethtype in order to use the Transit Circuit */
            return processSpecificSwitch(fwd);
        }
    }

    fail(fwd, ObjectiveError.UNSUPPORTED);
    return ImmutableSet.of();
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
@Override
protected Collection<FlowRule> processSpecificSwitch(ForwardingObjective fwd) {
    TrafficSelector filteredSelector =
            DefaultTrafficSelector.builder()
                    .matchInPort(
                            ((PortCriterion) fwd.selector().getCriterion(Criterion.Type.IN_PORT)).port())
                    .matchVlanId(
                            ((VlanIdCriterion) fwd.selector().getCriterion(Criterion.Type.VLAN_VID)).vlanId())
                    .build();

    Builder ruleBuilder = DefaultFlowRule.builder()
            .fromApp(fwd.appId())
            .withPriority(fwd.priority())
            .forDevice(deviceId)
            .withSelector(filteredSelector)
            .withTreatment(fwd.treatment())
            .forTable(VLAN_CIRCUIT_TABLE);

    if (fwd.permanent()) {
        ruleBuilder.makePermanent();
    } else {
        ruleBuilder.makeTemporary(fwd.timeout());
    }

    return Collections.singletonList(ruleBuilder.build());
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
/**
 * Tests encoding of a ForwardingObjective object.
 */
@Test
public void testForwardingObjectiveEncode() {

    Criterion criterion1 = Criteria.matchVlanId(VlanId.ANY);
    Criterion criterion2 = Criteria.matchEthType((short) 0x8844);
    TrafficSelector selector = DefaultTrafficSelector.builder()
            .add(criterion1)
            .add(criterion2)
            .build();

    ForwardingObjective forwardingObj = DefaultForwardingObjective.builder()
            .makePermanent()
            .fromApp(APP_ID)
            .withPriority(60)
            .withFlag(ForwardingObjective.Flag.SPECIFIC)
            .nextStep(1)
            .withSelector(selector)
            .add();

    ObjectNode forwardingObjJson = forwardingObjectiveCodec.encode(forwardingObj, context);
    assertThat(forwardingObjJson, matchesForwardingObjective(forwardingObj));
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
private void cleanAllFlowRules() {
    Iterable<Device> deviceList = deviceService.getAvailableDevices();

    for (Device d : deviceList) {
        DeviceId id = d.id();
        log.trace("Searching for flow rules to remove from: " + id);
        for (FlowEntry r : flowRuleService.getFlowEntries(id)) {
            boolean match = false;
            for (Instruction i : r.treatment().allInstructions()) {
                if (i.type() == Instruction.Type.OUTPUT) {
                    OutputInstruction oi = (OutputInstruction) i;
                    // if the flow has matching src and dst
                    for (Criterion cr : r.selector().criteria()) {
                        if (cr.type() == Criterion.Type.ETH_DST || cr.type() == Criterion.Type.ETH_SRC) {
                                    match = true;
                        }
                    }
                }
            }
            if (match) {
                log.trace("Removed flow rule from device: " + id);
                flowRuleService.removeFlowRules((FlowRule) r);
            }
        }
    }
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
/**
 * Tests encoding of a traffic selector object.
 */
@Test
public void testTrafficSelectorEncode() {

    Criterion inPort = Criteria.matchInPort(PortNumber.portNumber(0));
    Criterion ethSrc = Criteria.matchEthSrc(MacAddress.valueOf("11:22:33:44:55:66"));
    Criterion ethDst = Criteria.matchEthDst(MacAddress.valueOf("44:55:66:77:88:99"));
    Criterion ethType = Criteria.matchEthType(Ethernet.TYPE_IPV4);

    TrafficSelector.Builder sBuilder = DefaultTrafficSelector.builder();
    TrafficSelector selector = sBuilder
            .add(inPort)
            .add(ethSrc)
            .add(ethDst)
            .add(ethType)
            .build();

    ObjectNode selectorJson = trafficSelectorCodec.encode(selector, context);
    assertThat(selectorJson, TrafficSelectorJsonMatcher.matchesTrafficSelector(selector));
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
@Override
public ObjectNode encodeCriterion(ObjectNode root, Criterion criterion) {
    OduSignalId oduSignalId = ((OduSignalIdCriterion) criterion).oduSignalId();
    ObjectNode child = root.putObject(CriterionCodec.ODU_SIGNAL_ID);

    child.put(CriterionCodec.TRIBUTARY_PORT_NUMBER, oduSignalId.tributaryPortNumber());
    child.put(CriterionCodec.TRIBUTARY_SLOT_LEN, oduSignalId.tributarySlotLength());
    child.put(CriterionCodec.TRIBUTARY_SLOT_BITMAP, HexString.toHexString(oduSignalId.tributarySlotBitmap()));

    return root;
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
/**
 * Tests Och signal type criterion.
 */
@Test
public void matchOchSignalTypeTest() {
    Criterion criterion = Criteria.matchOchSignalType(OchSignalType.FIXED_GRID);
    ObjectNode result = criterionCodec.encode(criterion, context);
    assertThat(result, matchesCriterion(criterion));
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
private boolean isSupportedEthDstObjective(ForwardingObjective fwd) {
    TrafficSelector selector = fwd.selector();
    EthCriterion ethDst = (EthCriterion) selector
            .getCriterion(Criterion.Type.ETH_DST);
    VlanIdCriterion vlanId = (VlanIdCriterion) selector
            .getCriterion(Criterion.Type.VLAN_VID);
    return !(ethDst == null && vlanId == null);
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
protected static IpPrefix readIpDstFromSelector(TrafficSelector selector) {
    if (selector == null) {
        return null;
    }
    Criterion criterion = selector.getCriterion(Criterion.Type.IPV4_DST);
    return (criterion == null) ? null : ((IPCriterion) criterion).ip();
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
private boolean isSupportedEthTypeObjective(ForwardingObjective fwd) {
    TrafficSelector selector = fwd.selector();
    EthTypeCriterion ethType = (EthTypeCriterion) selector
            .getCriterion(Criterion.Type.ETH_TYPE);
    if ((ethType == null) ||
            ((ethType.ethType().toShort() != Ethernet.TYPE_IPV4) &&
                    (ethType.ethType().toShort() != Ethernet.MPLS_UNICAST))) {
        return false;
    }
    return true;
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
private boolean isSupportedEthDstObjective(ForwardingObjective fwd) {
    TrafficSelector selector = fwd.selector();
    EthCriterion ethDst = (EthCriterion) selector
            .getCriterion(Criterion.Type.ETH_DST);
    VlanIdCriterion vlanId = (VlanIdCriterion) selector
            .getCriterion(Criterion.Type.VLAN_VID);
    if (ethDst == null && vlanId == null) {
        return false;
    }
    return true;
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
/**
 * Tests IPV6 TLL criterion.
 */
@Test
public void matchIPv6NDTargetLinkLayerAddressTest() {
    Criterion criterion = Criteria.matchIPv6NDTargetLinkLayerAddress(mac1);
    ObjectNode result = criterionCodec.encode(criterion, context);
    assertThat(result, matchesCriterion(criterion));
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
private Collection<FlowRule> processVersatile(ForwardingObjective fwd) {
    log.debug("Processing versatile forwarding objective");
    TrafficSelector selector = fwd.selector();
    TrafficTreatment treatment = fwd.treatment();
    Collection<FlowRule> flowrules = new ArrayList<FlowRule>();

    // first add this rule for basic single-table operation
    // or non-ARP related multi-table operation
    FlowRule rule = DefaultFlowRule.builder()
            .forDevice(deviceId)
            .withSelector(selector)
            .withTreatment(treatment)
            .withPriority(fwd.priority())
            .fromApp(fwd.appId())
            .makePermanent()
            .forTable(ACL_TABLE).build();
    flowrules.add(rule);

    EthTypeCriterion ethType =
            (EthTypeCriterion) selector.getCriterion(Criterion.Type.ETH_TYPE);
    if (ethType == null) {
        log.warn("No ethType in versatile forwarding obj. Not processing further.");
        return flowrules;
    }

    // now deal with possible mix of ARP with filtering objectives
    // in multi-table scenarios
    if (ethType.ethType().toShort() == Ethernet.TYPE_ARP) {
        if (filters.isEmpty()) {
            pendingVersatiles.add(fwd);
            return flowrules;
        }
        for (Filter filter : filters) {
            flowrules.addAll(processVersatilesWithFilters(filter, fwd));
        }
    }
    return flowrules;
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
/**
 * Tests VLAN Id criterion.
 */
@Test
public void matchVlanIdTest() {
    Criterion criterion = Criteria.matchVlanId(VlanId.ANY);
    ObjectNode result = criterionCodec.encode(criterion, context);
    assertThat(result, matchesCriterion(criterion));
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
/**
 * Tests ethernet destination criterion.
 */
@Test
public void matchEthDstTest() {
    Criterion criterion = Criteria.matchEthDst(mac1);
    ObjectNode result = criterionCodec.encode(criterion, context);
    assertThat(result, matchesCriterion(criterion));
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
/**
 * Sets up for each test.  Creates a context and fetches the criterion
 * codec.
 */
@Before
public void setUp() {
    context = new MockCodecContext();
    criterionCodec = context.codec(Criterion.class);
    assertThat(criterionCodec, notNullValue());
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
@Override
protected Collection<FlowRule> processIpTraffic(ForwardingObjective fwd, FlowRule.Builder rule) {
    IPCriterion ipSrc = (IPCriterion) fwd.selector()
            .getCriterion(Criterion.Type.IPV4_SRC);
    if (ipSrc != null) {
        log.warn("Driver does not currently handle matching Src IP");
        fail(fwd, ObjectiveError.UNSUPPORTED);
        return Collections.emptySet();
    }
    IPCriterion ipDst = (IPCriterion) fwd.selector()
            .getCriterion(Criterion.Type.IPV4_DST);
    if (ipDst != null) {
        log.error("Driver handles Dst IP matching as specific forwarding "
                + "objective, not versatile");
        fail(fwd, ObjectiveError.UNSUPPORTED);
        return Collections.emptySet();
    }
    IPProtocolCriterion ipProto = (IPProtocolCriterion) fwd.selector()
            .getCriterion(Criterion.Type.IP_PROTO);
    if (ipProto != null && ipProto.protocol() == IPv4.PROTOCOL_TCP) {
        log.warn("Driver automatically punts all packets reaching the "
                + "LOCAL table to the controller");
        pass(fwd);
        return Collections.emptySet();
    }
    return Collections.emptySet();
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
/**
 * Tests the point to point intent JSON codec.
 *
 * @throws IOException if JSON processing fails
 */
@Test
public void decodePointToPointIntent() throws IOException {
    JsonCodec<Intent> intentCodec = context.codec(Intent.class);
    assertThat(intentCodec, notNullValue());

    Intent intent = getIntent("PointToPointIntent.json", intentCodec);
    assertThat(intent, notNullValue());
    assertThat(intent, instanceOf(PointToPointIntent.class));

    PointToPointIntent pointIntent = (PointToPointIntent) intent;
    assertThat(pointIntent.priority(), is(55));
    assertThat(pointIntent.ingressPoint().deviceId(), is(did("0000000000000001")));
    assertThat(pointIntent.ingressPoint().port(), is(PortNumber.portNumber(1)));
    assertThat(pointIntent.egressPoint().deviceId(), is(did("0000000000000007")));
    assertThat(pointIntent.egressPoint().port(), is(PortNumber.portNumber(2)));

    assertThat(pointIntent.constraints(), hasSize(1));

    assertThat(pointIntent.selector(), notNullValue());
    assertThat(pointIntent.selector().criteria(), hasSize(1));
    Criterion criterion1 = pointIntent.selector().criteria().iterator().next();
    assertThat(criterion1, instanceOf(EthCriterion.class));
    EthCriterion ethCriterion = (EthCriterion) criterion1;
    assertThat(ethCriterion.mac().toString(), is("11:22:33:44:55:66"));
    assertThat(ethCriterion.type().name(), is("ETH_DST"));

    assertThat(pointIntent.treatment(), notNullValue());
    assertThat(pointIntent.treatment().allInstructions(), hasSize(1));
    Instruction instruction1 = pointIntent.treatment().allInstructions().iterator().next();
    assertThat(instruction1, instanceOf(ModEtherInstruction.class));
    ModEtherInstruction ethInstruction = (ModEtherInstruction) instruction1;
    assertThat(ethInstruction.mac().toString(), is("22:33:44:55:66:77"));
    assertThat(ethInstruction.type().toString(), is("L2MODIFICATION"));
    assertThat(ethInstruction.subtype().toString(), is("ETH_SRC"));
}
 

import org.onosproject.net.flow.criteria.Criterion; //导入依赖的package包/类
/**
 * Tests in physical port criterion.
 */
@Test
public void matchInPhyPortTest() {
    Criterion criterion = Criteria.matchInPhyPort(port);
    ObjectNode result = criterionCodec.encode(criterion, context);
    assertThat(result, matchesCriterion(criterion));
}