Java DefaultTrafficTreatment类代码示例

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
/**
 * Tests adding a next objective.
 */
@Test
public void nextObjective() {
    TrafficTreatment treatment = DefaultTrafficTreatment.emptyTreatment();
    NextObjective next =
            DefaultNextObjective.builder()
                    .withId(manager.allocateNextId())
                    .addTreatment(treatment)
                    .withType(NextObjective.Type.BROADCAST)
                    .fromApp(NetTestTools.APP_ID)
                    .makePermanent()
                    .add();

    manager.next(id1, next);

    TestTools.assertAfter(RETRY_MS, () ->
            assertThat(nextObjectives, hasSize(1)));

    assertThat(forwardingObjectives, hasSize(0));
    assertThat(filteringObjectives, hasSize(0));
    assertThat(nextObjectives, hasItem("of:d1"));
}
 

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
private void populateRuleToGateway(Device d, Device gatewayDevice, long vni) {
    TrafficSelector.Builder sBuilder = DefaultTrafficSelector.builder();
    TrafficTreatment.Builder tBuilder = DefaultTrafficTreatment.builder();

    sBuilder.matchEthType(Ethernet.TYPE_IPV4)
            .matchTunnelId(vni)
            .matchEthDst(GATEWAYMAC);
    tBuilder.extension(buildNiciraExtenstion(d.id(), config.nodes().get(gatewayDevice.id())), d.id())
            .setOutput(getTunnelPort(d.id()));

    ForwardingObjective fo = DefaultForwardingObjective.builder()
            .withSelector(sBuilder.build())
            .withTreatment(tBuilder.build())
            .withFlag(ForwardingObjective.Flag.SPECIFIC)
            .withPriority(ROUTING_RULE_PRIORITY)
            .fromApp(appId)
            .add();

    flowObjectiveService.forward(d.id(), fo);
}
 

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
private void processVniTable(boolean install) {
    TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
    TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();

    treatment.transition(FORWARDING_TABLE);

    FlowRule flowRule = DefaultFlowRule.builder()
            .forDevice(deviceId)
            .withSelector(selector.build())
            .withTreatment(treatment.build())
            .withPriority(DROP_PRIORITY)
            .fromApp(appId)
            .makePermanent()
            .forTable(VNI_TABLE)
            .build();

    applyRules(install, flowRule);
}
 

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
private void processForwardingTable(boolean install) {
    TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
    TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();

    treatment.drop();

    FlowRule flowRule = DefaultFlowRule.builder()
            .forDevice(deviceId)
            .withSelector(selector.build())
            .withTreatment(treatment.build())
            .withPriority(DROP_PRIORITY)
            .fromApp(appId)
            .makePermanent()
            .forTable(FORWARDING_TABLE)
            .build();

    applyRules(install, flowRule);
}
 

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
protected List<FlowRule> processEthDstOnlyFilter(EthCriterion ethCriterion,
        ApplicationId applicationId) {
    TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
    TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();
    selector.matchEthType(Ethernet.TYPE_IPV4);
    selector.matchEthDst(ethCriterion.mac());
    treatment.transition(UNICAST_ROUTING_TABLE);
    FlowRule rule = DefaultFlowRule.builder()
            .forDevice(deviceId)
            .withSelector(selector.build())
            .withTreatment(treatment.build())
            .withPriority(DEFAULT_PRIORITY)
            .fromApp(applicationId)
            .makePermanent()
            .forTable(TMAC_TABLE).build();
    return ImmutableList.<FlowRule>builder().add(rule).build();
}
 

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
private void populateL3RulestoSameNode(Ip4Address vmIp, OpenstackPort p, Port port, Device device, long vni) {
    TrafficSelector.Builder sBuilder = DefaultTrafficSelector.builder();
    TrafficTreatment.Builder tBuilder = DefaultTrafficTreatment.builder();

    sBuilder.matchEthType(Ethernet.TYPE_IPV4)
            .matchIPDst(vmIp.toIpPrefix())
            .matchTunnelId(vni);

    tBuilder.setEthDst(p.macAddress())
            .setOutput(port.number());

    ForwardingObjective fo = DefaultForwardingObjective.builder()
            .withSelector(sBuilder.build())
            .withTreatment(tBuilder.build())
            .withPriority(ROUTING_RULE_PRIORITY)
            .withFlag(ForwardingObjective.Flag.SPECIFIC)
            .fromApp(appId)
            .add();

    flowObjectiveService.forward(device.id(), fo);
}
 

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
private Collection<FlowRule> reassemblyFlowRule(FlowRule.Builder ruleBuilder,
                                                TrafficTreatment tb,
                                                Integer transition,
                                                Integer forTable) {
    if (transition != null) {
        TrafficTreatment.Builder newTraffic = DefaultTrafficTreatment
                .builder();
        tb.allInstructions().forEach(t -> newTraffic.add(t));
        newTraffic.transition(transition);
        ruleBuilder.withTreatment(newTraffic.build());
    } else {
        ruleBuilder.withTreatment(tb);
    }
    if (forTable != null) {
        ruleBuilder.forTable(forTable);
    }
    return Collections.singletonList(ruleBuilder.build());
}
 

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
protected List<FlowRule> processEthDstOnlyFilter(EthCriterion ethCriterion,
        ApplicationId applicationId, int priority) {
    TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
    TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();
    selector.matchEthType(Ethernet.TYPE_IPV4);
    selector.matchEthDst(ethCriterion.mac());
    treatment.transition(TABLE_IPV4_UNICAST);
    FlowRule rule = DefaultFlowRule.builder()
            .forDevice(deviceId)
            .withSelector(selector.build())
            .withTreatment(treatment.build())
            .withPriority(priority)
            .fromApp(applicationId)
            .makePermanent()
            .forTable(TABLE_TMAC).build();
    return ImmutableList.<FlowRule>builder().add(rule).build();
}
 

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
/**
 * Sets the flow rules between traffic from VMs in different Cnode.
 *
 * @param vni  VNI
 * @param deviceId device ID
 * @param hostIp host IP of the VM
 * @param vmIp fixed IP of the VM
 */
private void setVxLanFlowRule(String vni, DeviceId deviceId, Ip4Address hostIp,
                              Ip4Address vmIp) {
    TrafficSelector.Builder sBuilder = DefaultTrafficSelector.builder();
    TrafficTreatment.Builder tBuilder = DefaultTrafficTreatment.builder();

    sBuilder.matchEthType(Ethernet.TYPE_IPV4)
            .matchTunnelId(Long.parseLong(vni))
            .matchIPDst(vmIp.toIpPrefix());
    tBuilder.extension(buildNiciraExtenstion(deviceId, hostIp), deviceId)
            .setOutput(getTunnelPort(deviceId));

    ForwardingObjective fo = DefaultForwardingObjective.builder()
            .withSelector(sBuilder.build())
            .withTreatment(tBuilder.build())
            .withPriority(SWITCHING_RULE_PRIORITY)
            .withFlag(ForwardingObjective.Flag.SPECIFIC)
            .fromApp(appId)
            .add();

    flowObjectiveService.forward(deviceId, fo);
}
 

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
/**
 * Removes flow rules for tagging tunnelId.
 *
 * @param deviceId device id
 * @param portNumber port number
 */
private void removeFlowRuleForTunnelTag(DeviceId deviceId, PortNumber portNumber) {
    TrafficSelector.Builder sBuilder = DefaultTrafficSelector.builder();
    TrafficTreatment.Builder tBuilder = DefaultTrafficTreatment.builder();

    sBuilder.matchEthType(Ethernet.TYPE_IPV4)
            .matchInPort(portNumber);

    ForwardingObjective fo = DefaultForwardingObjective.builder()
            .withSelector(sBuilder.build())
            .withTreatment(tBuilder.build())
            .withPriority(TUNNELTAG_RULE_PRIORITY)
            .withFlag(ForwardingObjective.Flag.SPECIFIC)
            .fromApp(appId)
            .remove();

    flowObjectiveService.forward(deviceId, fo);
}
 

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
private FlowRule ingressFlow(PortNumber inPort, Link link,
                             MplsPathIntent intent,
                             MplsLabel label) {

    TrafficSelector.Builder ingressSelector = DefaultTrafficSelector
            .builder(intent.selector());
    TrafficTreatment.Builder treat = DefaultTrafficTreatment.builder();
    ingressSelector.matchInPort(inPort);

    if (intent.ingressLabel().isPresent()) {
        ingressSelector.matchEthType(Ethernet.MPLS_UNICAST)
                .matchMplsLabel(intent.ingressLabel().get());

        // Swap the MPLS label
        treat.setMpls(label);
    } else {
        // Push and set the MPLS label
        treat.pushMpls().setMpls(label);
    }
    // Add the output action
    treat.setOutput(link.src().port());

    return createFlowRule(intent, link.src().deviceId(), ingressSelector.build(), treat.build());
}
 

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
/**
 * Builds a Single Point to Multi Point intent.
 *
 * @param key  The intent key
 * @param src  The source Connect Point
 * @param dsts The destination Connect Points
 * @return Single Point to Multi Point intent generated.
 */
private SinglePointToMultiPointIntent buildBrcIntent(Key key,
                                                     ConnectPoint src,
                                                     Set<ConnectPoint> dsts,
                                                     VlanId vlanId) {
    SinglePointToMultiPointIntent intent;

    TrafficTreatment treatment = DefaultTrafficTreatment.emptyTreatment();

    TrafficSelector selector = DefaultTrafficSelector.builder()
            .matchEthDst(MacAddress.BROADCAST)
            .matchVlanId(vlanId)
            .build();

    intent = SinglePointToMultiPointIntent.builder()
            .appId(APPID)
            .key(key)
            .selector(selector)
            .treatment(treatment)
            .ingressPoint(src)
            .egressPoints(dsts)
            .priority(PRIORITY_OFFSET)
            .build();
    return intent;
}
 

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
protected void processTableMissDrop(boolean install, int table, String description) {
    TrafficSelector.Builder selector = DefaultTrafficSelector.builder();

    TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();
    treatment.drop();

    FlowRule rule = DefaultFlowRule.builder()
            .forDevice(deviceId)
            .withSelector(selector.build())
            .withTreatment(treatment.build())
            .withPriority(DROP_PRIORITY)
            .fromApp(appId)
            .makePermanent()
            .forTable(table).build();

    processFlowRule(install, rule, description);
}
 

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
@Override
public void programArpClassifierRules(DeviceId deviceId, IpAddress dstIp,
                                      SegmentationId actionVni,
                                      Objective.Operation type) {
    TrafficSelector selector = DefaultTrafficSelector.builder()
            .matchEthType(ETH_TYPE.ethType().toShort())
            .matchArpTpa(Ip4Address.valueOf(dstIp.toString()))
            .build();
    TrafficTreatment treatment = DefaultTrafficTreatment.builder()
            .setTunnelId(Long.parseLong(actionVni.segmentationId()))
            .build();
    ForwardingObjective.Builder objective = DefaultForwardingObjective
            .builder().withTreatment(treatment).withSelector(selector)
            .fromApp(appId).withFlag(Flag.SPECIFIC)
            .withPriority(ARP_CLASSIFIER_PRIORITY);
    if (type.equals(Objective.Operation.ADD)) {
        log.debug("ArpClassifierRules-->ADD");
        flowObjectiveService.forward(deviceId, objective.add());
    } else {
        log.debug("ArpClassifierRules-->REMOVE");
        flowObjectiveService.forward(deviceId, objective.remove());
    }
}
 

import org.onosproject.net.flow.DefaultTrafficTreatment; //导入依赖的package包/类
@Override
protected FlowRule.Builder processVlanFiler(FilteringObjective filt, VlanIdCriterion vlan, PortCriterion port) {
    log.debug("adding rule for VLAN: {}", vlan.vlanId());
    TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
    TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();
    selector.matchVlanId(vlan.vlanId());
    selector.matchInPort(port.port());
    treatment.transition(ETHER_TABLE);
    treatment.deferred().popVlan();
    return DefaultFlowRule.builder()
            .forDevice(deviceId)
            .withSelector(selector.build())
            .withTreatment(treatment.build())
            .withPriority(CONTROLLER_PRIORITY)
            .makePermanent()
            .forTable(VLAN_TABLE);
}