Examples with FlowRuleOperations org.onosproject.net.flow.FlowRuleOperations used on opensource projects

Example 1 with FlowRuleOperations

use of org.onosproject.net.flow.FlowRuleOperations in project onos by opennetworkinglab.

the class MockFlowRuleService method apply.

@Override
public void apply(FlowRuleOperations ops) {
    AtomicBoolean thisSuccess = new AtomicBoolean(success);
    ops.stages().forEach(stage -> stage.forEach(flow -> {
        if (errorFlow == flow.rule().id().value()) {
            thisSuccess.set(false);
        } else {
            switch(flow.type()) {
                case ADD:
                case // TODO is this the right behavior for modify?
                MODIFY:
                    flows.add(flow.rule());
                    break;
                case REMOVE:
                    flows.remove(flow.rule());
                    break;
                default:
                    break;
            }
        }
    }));
    if (thisSuccess.get()) {
        ops.callback().onSuccess(ops);
    } else {
        ops.callback().onError(ops);
    }
}

Example 2 with FlowRuleOperations

use of org.onosproject.net.flow.FlowRuleOperations in project onos by opennetworkinglab.

the class DefaultVirtualFlowRuleProvider method executeBatch.

@Override
public void executeBatch(NetworkId networkId, FlowRuleBatchOperation batch) {
    checkNotNull(batch);
    for (FlowRuleBatchEntry fop : batch.getOperations()) {
        FlowRuleOperations.Builder builder = FlowRuleOperations.builder();
        switch(fop.operator()) {
            case ADD:
                devirtualize(networkId, fop.target()).forEach(builder::add);
                break;
            case REMOVE:
                devirtualize(networkId, fop.target()).forEach(builder::remove);
                break;
            case MODIFY:
                devirtualize(networkId, fop.target()).forEach(builder::modify);
                break;
            default:
                break;
        }
        flowRuleService.apply(builder.build(new FlowRuleOperationsContext() {

            @Override
            public void onSuccess(FlowRuleOperations ops) {
                CompletedBatchOperation status = new CompletedBatchOperation(true, Sets.newConcurrentHashSet(), batch.deviceId());
                VirtualFlowRuleProviderService providerService = (VirtualFlowRuleProviderService) providerRegistryService.getProviderService(networkId, VirtualFlowRuleProvider.class);
                providerService.batchOperationCompleted(batch.id(), status);
            }

            @Override
            public void onError(FlowRuleOperations ops) {
                Set<FlowRule> failures = ImmutableSet.copyOf(Lists.transform(batch.getOperations(), BatchOperationEntry::target));
                CompletedBatchOperation status = new CompletedBatchOperation(false, failures, batch.deviceId());
                VirtualFlowRuleProviderService providerService = (VirtualFlowRuleProviderService) providerRegistryService.getProviderService(networkId, VirtualFlowRuleProvider.class);
                providerService.batchOperationCompleted(batch.id(), status);
            }
        }));
    }
}

Example 3 with FlowRuleOperations

use of org.onosproject.net.flow.FlowRuleOperations in project onos by opennetworkinglab.

the class AddTestFlowsCommand method doExecute.

@Override
protected void doExecute() {
    FlowRuleService flowService = get(FlowRuleService.class);
    DeviceService deviceService = get(DeviceService.class);
    CoreService coreService = get(CoreService.class);
    ApplicationId appId = coreService.registerApplication("onos.test.flow.installer");
    int flowsPerDevice = Integer.parseInt(flows);
    int num = Integer.parseInt(numOfRuns);
    ArrayList<Long> results = Lists.newArrayList();
    Iterable<Device> devices = deviceService.getDevices();
    TrafficTreatment treatment = DefaultTrafficTreatment.builder().setOutput(PortNumber.portNumber(RandomUtils.nextInt(MAX_OUT_PORT))).build();
    TrafficSelector.Builder sbuilder;
    FlowRuleOperations.Builder rules = FlowRuleOperations.builder();
    FlowRuleOperations.Builder remove = FlowRuleOperations.builder();
    for (Device d : devices) {
        for (long i = 0; i < flowsPerDevice; i++) {
            sbuilder = DefaultTrafficSelector.builder();
            sbuilder.matchEthSrc(MacAddress.valueOf(RandomUtils.nextInt() * i)).matchEthDst(MacAddress.valueOf((Integer.MAX_VALUE - i) * RandomUtils.nextInt()));
            int randomPriority = RandomUtils.nextInt(FlowRule.MAX_PRIORITY - FlowRule.MIN_PRIORITY + 1) + FlowRule.MIN_PRIORITY;
            FlowRule addRule = DefaultFlowRule.builder().forDevice(d.id()).withSelector(sbuilder.build()).withTreatment(treatment).withPriority(randomPriority).fromApp(appId).makeTemporary(10).build();
            FlowRule removeRule = DefaultFlowRule.builder().forDevice(d.id()).withSelector(sbuilder.build()).withTreatment(treatment).withPriority(randomPriority).fromApp(appId).makeTemporary(10).build();
            rules.add(addRule);
            remove.remove(removeRule);
        }
    }
    // close stages
    rules.newStage();
    remove.newStage();
    for (int i = 0; i < num; i++) {
        printProgress("Run %d:", i);
        latch = new CountDownLatch(2);
        final CountDownLatch addSuccess = new CountDownLatch(1);
        printProgress("..batch add request");
        Stopwatch add = Stopwatch.createStarted();
        flowService.apply(rules.build(new FlowRuleOperationsContext() {

            private final Stopwatch timer = Stopwatch.createStarted();

            @Override
            public void onSuccess(FlowRuleOperations ops) {
                timer.stop();
                printProgress("..add success");
                results.add(timer.elapsed(TimeUnit.MILLISECONDS));
                if (results.size() == num) {
                    if (outputJson()) {
                        print("%s", json(new ObjectMapper(), true, results));
                    } else {
                        printTime(true, results);
                    }
                }
                latch.countDown();
                addSuccess.countDown();
            }
        }));
        try {
            addSuccess.await();
            // wait until all flows reaches ADDED state
            while (!Streams.stream(flowService.getFlowEntriesById(appId)).allMatch(fr -> fr.state() == FlowEntryState.ADDED)) {
                Thread.sleep(100);
            }
            add.stop();
            printProgress("..completed %d ± 100 ms", add.elapsed(TimeUnit.MILLISECONDS));
        } catch (InterruptedException e1) {
            printProgress("Interrupted");
            Thread.currentThread().interrupt();
        }
        printProgress("..cleaning up");
        flowService.apply(remove.build(new FlowRuleOperationsContext() {

            @Override
            public void onSuccess(FlowRuleOperations ops) {
                latch.countDown();
            }
        }));
        try {
            latch.await();
            while (!Iterables.isEmpty(flowService.getFlowEntriesById(appId))) {
                Thread.sleep(500);
            }
        } catch (InterruptedException e) {
            printProgress("Interrupted.");
            Thread.currentThread().interrupt();
        }
    }
    if (outputJson()) {
        print("%s", json(new ObjectMapper(), true, results));
    } else {
        printTime(true, results);
    }
}

Example 4 with FlowRuleOperations

use of org.onosproject.net.flow.FlowRuleOperations in project onos by opennetworkinglab.

the class AbstractCorsaPipeline method processFilter.

private void processFilter(FilteringObjective filt, boolean install, ApplicationId applicationId) {
    // This driver only processes filtering criteria defined with switch
    // ports as the key
    PortCriterion port;
    if (!filt.key().equals(Criteria.dummy()) && filt.key().type() == Criterion.Type.IN_PORT) {
        port = (PortCriterion) filt.key();
    } else {
        log.warn("No key defined in filtering objective from app: {}. Not" + "processing filtering objective", applicationId);
        fail(filt, ObjectiveError.UNKNOWN);
        return;
    }
    // convert filtering conditions for switch-intfs into flowrules
    FlowRuleOperations.Builder ops = FlowRuleOperations.builder();
    for (Criterion c : filt.conditions()) {
        if (c.type() == Criterion.Type.ETH_DST) {
            EthCriterion eth = (EthCriterion) c;
            FlowRule.Builder rule = processEthFiler(filt, eth, port);
            rule.forDevice(deviceId).fromApp(applicationId);
            ops = install ? ops.add(rule.build()) : ops.remove(rule.build());
        } else if (c.type() == Criterion.Type.VLAN_VID) {
            VlanIdCriterion vlan = (VlanIdCriterion) c;
            FlowRule.Builder rule = processVlanFiler(filt, vlan, port);
            rule.forDevice(deviceId).fromApp(applicationId);
            ops = install ? ops.add(rule.build()) : ops.remove(rule.build());
        } else if (c.type() == Criterion.Type.IPV4_DST) {
            IPCriterion ip = (IPCriterion) c;
            FlowRule.Builder rule = processIpFilter(filt, ip, port);
            rule.forDevice(deviceId).fromApp(applicationId);
            ops = install ? ops.add(rule.build()) : ops.remove(rule.build());
        } else {
            log.warn("Driver does not currently process filtering condition" + " of type: {}", c.type());
            fail(filt, ObjectiveError.UNSUPPORTED);
        }
    }
    // apply filtering flow rules
    flowRuleService.apply(ops.build(new FlowRuleOperationsContext() {

        @Override
        public void onSuccess(FlowRuleOperations ops) {
            pass(filt);
            log.info("Applied filtering rules");
        }

        @Override
        public void onError(FlowRuleOperations ops) {
            fail(filt, ObjectiveError.FLOWINSTALLATIONFAILED);
            log.info("Failed to apply filtering rules");
        }
    }));
}

Example 5 with FlowRuleOperations

use of org.onosproject.net.flow.FlowRuleOperations in project onos by opennetworkinglab.

the class SoftRouterPipeline method processFilter.

private void processFilter(FilteringObjective filt, boolean install, ApplicationId applicationId) {
    // This driver only processes filtering criteria defined with switch
    // ports as the key
    PortCriterion p;
    EthCriterion e = null;
    VlanIdCriterion v = null;
    if (!filt.key().equals(Criteria.dummy()) && filt.key().type() == Criterion.Type.IN_PORT) {
        p = (PortCriterion) filt.key();
    } else {
        log.warn("No key defined in filtering objective from app: {}. Not" + "processing filtering objective", applicationId);
        fail(filt, ObjectiveError.UNKNOWN);
        return;
    }
    // convert filtering conditions for switch-intfs into flowrules
    FlowRuleOperations.Builder ops = FlowRuleOperations.builder();
    for (Criterion c : filt.conditions()) {
        if (c.type() == Criterion.Type.ETH_DST || c.type() == Criterion.Type.ETH_DST_MASKED) {
            e = (EthCriterion) c;
        } else if (c.type() == Criterion.Type.VLAN_VID) {
            v = (VlanIdCriterion) c;
        } else {
            log.error("Unsupported filter {}", c);
            fail(filt, ObjectiveError.UNSUPPORTED);
            return;
        }
    }
    if (v == null || e == null) {
        log.warn("Soft Router Pipeline ETH_DST and/or VLAN_ID not specified");
        fail(filt, ObjectiveError.BADPARAMS);
        return;
    }
    log.debug("Modifying Port/VLAN/MAC filtering rules in filter table: {}/{}/{}", p.port(), v.vlanId(), e.mac());
    TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
    TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();
    selector.matchInPort(p.port());
    // Multicast MAC
    if (e.mask() != null) {
        selector.matchEthDstMasked(e.mac(), e.mask());
    } else {
        selector.matchEthDst(e.mac());
    }
    selector.matchVlanId(v.vlanId());
    if (!v.vlanId().equals(VlanId.NONE)) {
        treatment.popVlan();
    }
    treatment.transition(FIB_TABLE);
    FlowRule rule = DefaultFlowRule.builder().forDevice(deviceId).withSelector(selector.build()).withTreatment(treatment.build()).withPriority(DEFAULT_PRIORITY).fromApp(applicationId).makePermanent().forTable(FILTER_TABLE).build();
    ops = install ? ops.add(rule) : ops.remove(rule);
    // apply filtering flow rules
    flowRuleService.apply(ops.build(new FlowRuleOperationsContext() {

        @Override
        public void onSuccess(FlowRuleOperations ops) {
            log.info("Applied filtering rules");
            pass(filt);
        }

        @Override
        public void onError(FlowRuleOperations ops) {
            log.info("Failed to apply filtering rules");
            fail(filt, ObjectiveError.FLOWINSTALLATIONFAILED);
        }
    }));
}