| /* |
| * Copyright 2017-present Open Networking Foundation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.onosproject.drivers.hp; |
| |
| import com.google.common.cache.Cache; |
| import com.google.common.cache.CacheBuilder; |
| import com.google.common.cache.RemovalCause; |
| import com.google.common.cache.RemovalNotification; |
| import org.onlab.osgi.ServiceDirectory; |
| import org.onlab.util.KryoNamespace; |
| import org.onosproject.core.ApplicationId; |
| import org.onosproject.core.CoreService; |
| import org.onosproject.net.Device; |
| import org.onosproject.net.DeviceId; |
| import org.onosproject.net.behaviour.NextGroup; |
| import org.onosproject.net.behaviour.Pipeliner; |
| import org.onosproject.net.behaviour.PipelinerContext; |
| import org.onosproject.net.device.DeviceService; |
| import org.onosproject.net.driver.AbstractHandlerBehaviour; |
| import org.onosproject.net.flow.FlowRule; |
| import org.onosproject.net.flow.FlowRuleOperations; |
| import org.onosproject.net.flow.FlowRuleOperationsContext; |
| import org.onosproject.net.flow.FlowRuleService; |
| import org.onosproject.net.flow.TrafficSelector; |
| import org.onosproject.net.flow.DefaultFlowRule; |
| import org.onosproject.net.flow.TrafficTreatment; |
| import org.onosproject.net.flow.DefaultTrafficTreatment; |
| import org.onosproject.net.flow.DefaultTrafficSelector; |
| import org.onosproject.net.flow.criteria.Criteria; |
| import org.onosproject.net.flow.criteria.Criterion; |
| import org.onosproject.net.flow.criteria.EthCriterion; |
| import org.onosproject.net.flow.criteria.IPCriterion; |
| import org.onosproject.net.flow.criteria.PortCriterion; |
| import org.onosproject.net.flow.criteria.VlanIdCriterion; |
| import org.onosproject.net.flow.instructions.Instruction; |
| import org.onosproject.net.flow.instructions.L2ModificationInstruction; |
| import org.onosproject.net.flow.instructions.L3ModificationInstruction; |
| import org.onosproject.net.flow.instructions.L4ModificationInstruction; |
| import org.onosproject.net.flowobjective.FilteringObjective; |
| import org.onosproject.net.flowobjective.FlowObjectiveStore; |
| import org.onosproject.net.flowobjective.ForwardingObjective; |
| import org.onosproject.net.flowobjective.NextObjective; |
| import org.onosproject.net.flowobjective.Objective; |
| import org.onosproject.net.flowobjective.ObjectiveError; |
| import org.onosproject.net.group.Group; |
| import org.onosproject.net.group.GroupService; |
| import org.onosproject.net.meter.MeterService; |
| import org.onosproject.store.serializers.KryoNamespaces; |
| import org.slf4j.Logger; |
| |
| import java.util.Set; |
| import java.util.HashSet; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.concurrent.TimeUnit; |
| |
| import static org.onosproject.net.flow.FlowRule.Builder; |
| import static org.onosproject.net.flowobjective.Objective.Operation.ADD; |
| import static org.slf4j.LoggerFactory.getLogger; |
| |
| /** |
| * Abstraction of the HP pipeline handler. |
| * Possibly compliant with all HP switches: tested with HP3800 (v2 module) and HP3500 (v1 module). |
| * |
| * These switches supports multiple OpenFlow instances. |
| * Each instance can be created with different pipeline models. |
| * This driver refers to OpenFlow instances created with "pipeline-model standard-match" |
| * |
| * With this model Table 100 is used for all entries that can be processed in hardware, |
| * whereas table 200 is used for entries processed in software. |
| * |
| * Trying to install a flow entries only supported in software in table 100 generates |
| * an OpenFlow error message from the switch. |
| * |
| * Installation of a flow entry supported in hardware in table 200 is allowed. But it strongly |
| * degrades forwarding performance. |
| * |
| * --------------------------------------------- |
| * --- SELECTION OF PROPER TABLE ID --- |
| * --- from device manual OpenFlow v1.3 for firmware 16.04 - (Appendix A) |
| * --------------------------------------------- |
| * --- Hardware differences between v1, v2 and v3 modules affect which features are supported |
| * in hardware/software. In this driver "TableIdForForwardingObjective()" function selects the |
| * proper table ID considering the hardware features of the device and the actual FlowObjective. |
| * |
| * --------------------------------------------- |
| * --- HPE switches support OpenFlow version 1.3.1 with following limitations. |
| * --- from device manual OpenFlow v1.3 for firmware 16.04 - (Appendix A) |
| * |
| *** UNSUPPORTED FLOW MATCHES --- (implemented using unsupported_criteria) |
| * --------------------------------------------- |
| * - METADATA - DONE |
| * - IP_ECN - DONE |
| * - SCTP_SRC, SCTP_DST - DONE |
| * - IPV6_ND_SLL, IPV6_ND_TLL - DONE |
| * - MPLS_LABEL, MPLS_TC, MPLS_BOS - DONE |
| * - PBB_ISID - DONE |
| * - TUNNEL_ID - DONE |
| * - IPV6_EXTHDR - DONE |
| * |
| *** UNSUPPORTED ACTIONS --- |
| * --------------------------------------------- |
| * - METADATA - DONE |
| * - QUEUE - DONE |
| * - OFPP_TABLE action - TODO |
| * - MPLS actions: Push-MPLS, Pop-MPLS, Set-MPLS TTL, Decrement MPLS TTL - DONE |
| * - Push-PBB, Pop-PBB actions - TODO |
| * - Copy TTL inwards/outwards actions - DONE |
| * - Decrement IP TTL - DONE |
| * |
| * --------------------------------------------- |
| * --- OTHER UNSUPPORTED FEATURES --- |
| * --- from device manual OpenFlow v1.3 for firmware 16.04 |
| * --------------------------------------------- |
| * - Port commands: OFPPC_NO_STP, OFPPC_NO_RECV, OFPPC_NO_RECV_STP, OFPPC_NO_FWD - TODO |
| * - Handling of IP Fragments: OFPC_IP_REASM, OFPC_FRAG_REASM - TODO |
| * |
| * TODO MINOR: include above actions in the lists of unsupported features |
| * TODO MINOR: check pre-requites in flow match |
| * |
| * |
| * With current implementation, in case of unsupported features a WARNING message in generated |
| * in the ONOS log, but FlowRule is sent anyway to the device. |
| * The device will reply with an OFP_ERROR message. |
| * Use "debug openflow events" and "debug openflow errors" on the device to locally |
| * visualize detailed information on the specific error. |
| * |
| * TODO MAJOR: use OFP_TABLE_FEATURE messages to automate learning of unsupported features |
| * |
| */ |
| |
| public abstract class AbstractHPPipeline extends AbstractHandlerBehaviour implements Pipeliner { |
| |
| protected static final String APPLICATION_ID = "org.onosproject.drivers.hp.HPPipeline"; |
| |
| protected static final int HP_TABLE_ZERO = 0; |
| protected static final int HP_HARDWARE_TABLE = 100; |
| protected static final int HP_SOFTWARE_TABLE = 200; |
| |
| public static final int CACHE_ENTRY_EXPIRATION_PERIOD = 20; |
| |
| private final Logger log = getLogger(getClass()); |
| protected FlowRuleService flowRuleService; |
| protected GroupService groupService; |
| protected MeterService meterService; |
| protected FlowObjectiveStore flowObjectiveStore; |
| protected DeviceId deviceId; |
| protected ApplicationId appId; |
| protected DeviceService deviceService; |
| protected Device device; |
| protected String deviceHwVersion; |
| protected KryoNamespace appKryo = new KryoNamespace.Builder() |
| .register(KryoNamespaces.API) |
| .build("AbstractHPPipeline"); |
| private ServiceDirectory serviceDirectory; |
| private CoreService coreService; |
| private Cache<Integer, NextObjective> pendingAddNext = CacheBuilder.newBuilder() |
| .expireAfterWrite(CACHE_ENTRY_EXPIRATION_PERIOD, TimeUnit.SECONDS) |
| .removalListener((RemovalNotification<Integer, NextObjective> notification) -> { |
| if (notification.getCause() == RemovalCause.EXPIRED) { |
| notification.getValue().context() |
| .ifPresent(c -> c.onError(notification.getValue(), |
| ObjectiveError.FLOWINSTALLATIONFAILED)); |
| } |
| }).build(); |
| |
| /** Lists of unsupported features (firmware version K 16.04) |
| * If a FlowObjective uses one of these features a warning log message is generated. |
| */ |
| protected Set<Criterion.Type> unsupportedCriteria = new HashSet<>(); |
| protected Set<Instruction.Type> unsupportedInstructions = new HashSet<>(); |
| protected Set<L2ModificationInstruction.L2SubType> unsupportedL2mod = new HashSet<>(); |
| protected Set<L3ModificationInstruction.L3SubType> unsupportedL3mod = new HashSet<>(); |
| |
| /** Lists of Criteria and Instructions supported in hardware |
| * If a FlowObjective uses one of these features the FlowRule is intalled in HP_SOFTWARE_TABLE. |
| */ |
| protected Set<Criterion.Type> hardwareCriteria = new HashSet<>(); |
| protected Set<Instruction.Type> hardwareInstructions = new HashSet<>(); |
| protected Set<L2ModificationInstruction.L2SubType> hardwareInstructionsL2mod = new HashSet<>(); |
| protected Set<L3ModificationInstruction.L3SubType> hardwareInstructionsL3mod = new HashSet<>(); |
| protected Set<L4ModificationInstruction.L4SubType> hardwareInstructionsL4mod = new HashSet<>(); |
| protected Set<Group.Type> hardwareGroups = new HashSet<>(); |
| |
| /** |
| * Sets default table id. |
| * Using this solution all flow rules are installed on the "default" table |
| * |
| * @param ruleBuilder flow rule builder to be set table id |
| * @return flow rule builder with set table id for flow |
| */ |
| protected abstract FlowRule.Builder setDefaultTableIdForFlowObjective(Builder ruleBuilder); |
| |
| /** |
| * Return the proper table ID depending on the specific ForwardingObjective. |
| * |
| * HP switches supporting openflow have 3 tables (Pipeline Model: Standard Match) |
| * Table 0 is just a shortcut to table 100 |
| * Table 100/200 are respectively used for rules processed in HARDWARE/SOFTWARE |
| * |
| * @param selector TrafficSelector including flow match |
| * @param treatment TrafficTreatment including instructions/actions |
| * @return table id |
| */ |
| protected abstract int tableIdForForwardingObjective(TrafficSelector selector, TrafficTreatment treatment); |
| |
| /** |
| * Return TRUE if ForwardingObjective fwd includes unsupported features. |
| * |
| * @param selector TrafficSelector including flow match |
| * @param treatment TrafficTreatment including instructions/actions |
| * @return boolean |
| */ |
| protected abstract boolean checkUnSupportedFeatures(TrafficSelector selector, TrafficTreatment treatment); |
| |
| @Override |
| public void init(DeviceId deviceId, PipelinerContext context) { |
| this.deviceId = deviceId; |
| |
| serviceDirectory = context.directory(); |
| coreService = serviceDirectory.get(CoreService.class); |
| flowRuleService = serviceDirectory.get(FlowRuleService.class); |
| groupService = serviceDirectory.get(GroupService.class); |
| meterService = serviceDirectory.get(MeterService.class); |
| deviceService = serviceDirectory.get(DeviceService.class); |
| flowObjectiveStore = context.store(); |
| |
| appId = coreService.registerApplication(APPLICATION_ID); |
| |
| device = deviceService.getDevice(deviceId); |
| deviceHwVersion = device.hwVersion(); |
| |
| //Initialization of model specific features |
| log.debug("HP Driver - Initializing unsupported features for switch {}", deviceHwVersion); |
| initUnSupportedFeatures(); |
| |
| log.debug("HP Driver - Initializing features supported in hardware"); |
| initHardwareCriteria(); |
| initHardwareInstructions(); |
| |
| log.debug("HP Driver - Initializing pipeline"); |
| installHPTableZero(); |
| installHPHardwareTable(); |
| installHPSoftwareTable(); |
| } |
| |
| /** |
| * UnSupported features are specific of each model. |
| */ |
| protected abstract void initUnSupportedFeatures(); |
| |
| /** |
| * Criteria supported in hardware are specific of each model. |
| */ |
| protected abstract void initHardwareCriteria(); |
| |
| /** |
| * Instructions supported in hardware are specific of each model. |
| */ |
| protected abstract void initHardwareInstructions(); |
| |
| /** |
| * HP Table 0 initialization. |
| * Installs rule goto HP_HARDWARE_TABLE in HP_TABLE_ZERO |
| */ |
| private void installHPTableZero() { |
| TrafficSelector.Builder selector = DefaultTrafficSelector.builder(); |
| TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder(); |
| |
| treatment.transition(HP_HARDWARE_TABLE); |
| |
| FlowRule rule = DefaultFlowRule.builder().forDevice(this.deviceId) |
| .withSelector(selector.build()) |
| .withTreatment(treatment.build()) |
| .withPriority(0) |
| .fromApp(appId) |
| .makePermanent() |
| .forTable(HP_TABLE_ZERO) |
| .build(); |
| |
| this.applyRules(true, rule); |
| } |
| |
| /** |
| * HP hardware table initialization. |
| * Installs rule goto HP_SOFTWARE_TABLE in HP_HARDWARE_TABLE |
| */ |
| private void installHPHardwareTable() { |
| TrafficSelector.Builder selector = DefaultTrafficSelector.builder(); |
| |
| TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder(); |
| //treatment.setOutput(PortNumber.NORMAL); |
| treatment.transition(HP_SOFTWARE_TABLE); |
| |
| FlowRule rule = DefaultFlowRule.builder().forDevice(this.deviceId) |
| .withSelector(selector.build()) |
| .withTreatment(treatment.build()) |
| .withPriority(0) |
| .fromApp(appId) |
| .makePermanent() |
| .forTable(HP_HARDWARE_TABLE) |
| .build(); |
| |
| this.applyRules(true, rule); |
| } |
| |
| /** |
| * Applies FlowRule. |
| * Installs or removes FlowRule. |
| * |
| * @param install - whether to install or remove rule |
| * @param rule - the rule to be installed or removed |
| */ |
| private void applyRules(boolean install, FlowRule rule) { |
| FlowRuleOperations.Builder ops = FlowRuleOperations.builder(); |
| |
| ops = install ? ops.add(rule) : ops.remove(rule); |
| flowRuleService.apply(ops.build(new FlowRuleOperationsContext() { |
| @Override |
| public void onSuccess(FlowRuleOperations ops) { |
| log.trace("HP Driver: - applyRules onSuccess rule {}", rule); |
| } |
| |
| @Override |
| public void onError(FlowRuleOperations ops) { |
| log.trace("HP Driver: applyRules onError rule: " + rule); |
| } |
| })); |
| } |
| |
| /** |
| * HP software table initialization. |
| * No rules required. |
| */ |
| private void installHPSoftwareTable() {} |
| |
| protected void pass(Objective obj) { |
| obj.context().ifPresent(context -> context.onSuccess(obj)); |
| } |
| |
| protected void fail(Objective obj, ObjectiveError error) { |
| obj.context().ifPresent(context -> context.onError(obj, error)); |
| } |
| |
| @Override |
| public void forward(ForwardingObjective fwd) { |
| |
| if (fwd.treatment() != null) { |
| /* If UNSUPPORTED features included in ForwardingObjective a warning message is generated. |
| * FlowRule is anyway sent to the device, device will reply with an OFP_ERROR. |
| * Moreover, checkUnSupportedFeatures function generates further warnings specifying |
| * each unsupported feature. |
| */ |
| if (checkUnSupportedFeatures(fwd.selector(), fwd.treatment())) { |
| log.warn("HP Driver - specified ForwardingObjective contains UNSUPPORTED FEATURES"); |
| } |
| |
| // Deal with SPECIFIC and VERSATILE in the same manner. |
| // Create the FlowRule starting from the ForwardingObjective |
| FlowRule.Builder ruleBuilder = DefaultFlowRule.builder() |
| .forDevice(deviceId) |
| .withSelector(fwd.selector()) |
| .withTreatment(fwd.treatment()) |
| .withPriority(fwd.priority()) |
| .fromApp(fwd.appId()); |
| |
| // Determine the table to be used depends on selector, treatment and specific switch hardware |
| ruleBuilder.forTable(tableIdForForwardingObjective(fwd.selector(), fwd.treatment())); |
| |
| if (fwd.permanent()) { |
| ruleBuilder.makePermanent(); |
| } else { |
| ruleBuilder.makeTemporary(fwd.timeout()); |
| } |
| |
| log.debug("HP Driver - installing ForwadingObjective arrived with treatment {}", fwd); |
| installObjective(ruleBuilder, fwd); |
| |
| } else { |
| NextObjective nextObjective; |
| NextGroup next; |
| TrafficTreatment treatment; |
| if (fwd.op() == ADD) { |
| // Give a try to the cache. Doing an operation |
| // on the store seems to be very expensive. |
| nextObjective = pendingAddNext.getIfPresent(fwd.nextId()); |
| // If the next objective is not present |
| // We will try with the store |
| if (nextObjective == null) { |
| next = flowObjectiveStore.getNextGroup(fwd.nextId()); |
| // We verify that next was in the store and then de-serialize |
| // the treatment in order to re-build the flow rule. |
| if (next == null) { |
| fwd.context().ifPresent(c -> c.onError(fwd, ObjectiveError.GROUPMISSING)); |
| return; |
| } |
| treatment = appKryo.deserialize(next.data()); |
| } else { |
| pendingAddNext.invalidate(fwd.nextId()); |
| treatment = getTreatment(nextObjective); |
| if (treatment == null) { |
| fwd.context().ifPresent(c -> c.onError(fwd, ObjectiveError.UNSUPPORTED)); |
| return; |
| } |
| } |
| } else { |
| // We get the NextGroup from the remove operation. |
| // Doing an operation on the store seems to be very expensive. |
| next = flowObjectiveStore.getNextGroup(fwd.nextId()); |
| treatment = (next != null) ? appKryo.deserialize(next.data()) : null; |
| } |
| |
| // If the treatment is null we cannot re-build the original flow |
| if (treatment == null) { |
| fwd.context().ifPresent(c -> c.onError(fwd, ObjectiveError.GROUPMISSING)); |
| return; |
| } |
| // Finally we build the flow rule and push to the flowrule subsystem. |
| FlowRule.Builder ruleBuilder = DefaultFlowRule.builder() |
| .forDevice(deviceId) |
| .withSelector(fwd.selector()) |
| .fromApp(fwd.appId()) |
| .withPriority(fwd.priority()) |
| .withTreatment(treatment); |
| |
| /* If UNSUPPORTED features included in ForwardingObjective a warning message is generated. |
| * FlowRule is anyway sent to the device, device will reply with an OFP_ERROR. |
| * Moreover, checkUnSupportedFeatures function generates further warnings specifying |
| * each unsupported feature. |
| */ |
| if (checkUnSupportedFeatures(fwd.selector(), treatment)) { |
| log.warn("HP Driver - specified ForwardingObjective contains UNSUPPORTED FEATURES"); |
| } |
| |
| //Table to be used depends on the specific switch hardware and ForwardingObjective |
| ruleBuilder.forTable(tableIdForForwardingObjective(fwd.selector(), treatment)); |
| |
| if (fwd.permanent()) { |
| ruleBuilder.makePermanent(); |
| } else { |
| ruleBuilder.makeTemporary(fwd.timeout()); |
| } |
| |
| log.debug("HP Driver - installing ForwadingObjective arrived with NULL treatment (intent)"); |
| installObjective(ruleBuilder, fwd); |
| } |
| } |
| |
| /** |
| * Installs objective. |
| * |
| * @param ruleBuilder flow rule builder used to build rule from objective |
| * @param objective objective to be installed |
| */ |
| protected void installObjective(FlowRule.Builder ruleBuilder, Objective objective) { |
| FlowRuleOperations.Builder flowBuilder = FlowRuleOperations.builder(); |
| |
| switch (objective.op()) { |
| case ADD: |
| log.trace("HP Driver - Requested ADD of objective to device " + deviceId); |
| flowBuilder.add(ruleBuilder.build()); |
| break; |
| case REMOVE: |
| log.trace("HP Driver - Requested REMOVE of objective to device " + deviceId); |
| flowBuilder.remove(ruleBuilder.build()); |
| break; |
| default: |
| log.debug("HP Driver - Unknown operation {}", objective.op()); |
| } |
| |
| flowRuleService.apply(flowBuilder.build(new FlowRuleOperationsContext() { |
| @Override |
| public void onSuccess(FlowRuleOperations ops) { |
| objective.context().ifPresent(context -> context.onSuccess(objective)); |
| log.trace("HP Driver - Installed objective " + objective.toString()); |
| } |
| |
| @Override |
| public void onError(FlowRuleOperations ops) { |
| objective.context() |
| .ifPresent(context -> context.onError(objective, ObjectiveError.FLOWINSTALLATIONFAILED)); |
| log.trace("HP Driver - Objective installation failed" + objective.toString()); |
| } |
| })); |
| } |
| |
| @Override |
| public void next(NextObjective nextObjective) { |
| switch (nextObjective.op()) { |
| case ADD: |
| log.debug("HP driver: NextObjective ADDED"); |
| // We insert the value in the cache |
| pendingAddNext.put(nextObjective.id(), nextObjective); |
| // Then in the store, this will unblock the queued fwd obj |
| flowObjectiveStore.putNextGroup( |
| nextObjective.id(), |
| new SingleGroup(nextObjective.next().iterator().next()) |
| ); |
| break; |
| case REMOVE: |
| log.debug("HP driver: NextObjective REMOVED"); |
| NextGroup next = flowObjectiveStore.removeNextGroup(nextObjective.id()); |
| if (next == null) { |
| nextObjective.context().ifPresent(context -> context.onError(nextObjective, |
| ObjectiveError.GROUPMISSING)); |
| return; |
| } |
| break; |
| default: |
| log.debug("Unsupported operation {}", nextObjective.op()); |
| } |
| nextObjective.context().ifPresent(context -> context.onSuccess(nextObjective)); |
| } |
| |
| @Override |
| public List<String> getNextMappings(NextGroup nextGroup) { |
| //TODO: to be implemented |
| return Collections.emptyList(); |
| } |
| |
| @Override |
| public void filter(FilteringObjective filteringObjective) { |
| if (filteringObjective.type() == FilteringObjective.Type.PERMIT) { |
| processFilter(filteringObjective, |
| filteringObjective.op() == Objective.Operation.ADD, |
| filteringObjective.appId()); |
| } else { |
| fail(filteringObjective, ObjectiveError.UNSUPPORTED); |
| } |
| } |
| |
| @Override |
| public void purgeAll(ApplicationId appId) { |
| flowRuleService.purgeFlowRules(deviceId, appId); |
| groupService.purgeGroupEntries(deviceId, appId); |
| meterService.purgeMeters(deviceId, appId); |
| } |
| |
| /** |
| * Gets traffic treatment from a next objective. |
| * Merge traffic treatments from next objective if the next objective is |
| * BROADCAST type and contains multiple traffic treatments. |
| * Returns first treatment from next objective if the next objective is |
| * SIMPLE type and it contains only one treatment. |
| * |
| * @param nextObjective the next objective |
| * @return the treatment from next objective; null if not supported |
| */ |
| private TrafficTreatment getTreatment(NextObjective nextObjective) { |
| Collection<TrafficTreatment> treatments = nextObjective.next(); |
| switch (nextObjective.type()) { |
| case SIMPLE: |
| if (treatments.size() != 1) { |
| log.error("Next Objectives of type SIMPLE should have only " + |
| "one traffic treatment. NexObjective: {}", |
| nextObjective.toString()); |
| return null; |
| } |
| return treatments.iterator().next(); |
| case BROADCAST: |
| TrafficTreatment.Builder builder = DefaultTrafficTreatment.builder(); |
| treatments.forEach(builder::addTreatment); |
| return builder.build(); |
| default: |
| log.error("Unsupported next objective type {}.", nextObjective.type()); |
| return null; |
| } |
| } |
| |
| /** |
| * Filter processing and installation. |
| * Processes and installs filtering rules. |
| * |
| * @param filt |
| * @param install |
| * @param applicationId |
| */ |
| 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 = processEthFilter(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 = processVlanFilter(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.trace("HP Driver - Applied filtering rules"); |
| } |
| |
| @Override |
| public void onError(FlowRuleOperations ops) { |
| fail(filt, ObjectiveError.FLOWINSTALLATIONFAILED); |
| log.trace("HP Driver - Failed to apply filtering rules"); |
| } |
| })); |
| } |
| |
| protected abstract Builder processEthFilter(FilteringObjective filt, |
| EthCriterion eth, PortCriterion port); |
| |
| protected abstract Builder processVlanFilter(FilteringObjective filt, |
| VlanIdCriterion vlan, PortCriterion port); |
| |
| protected abstract Builder processIpFilter(FilteringObjective filt, |
| IPCriterion ip, PortCriterion port); |
| |
| private class SingleGroup implements NextGroup { |
| |
| private TrafficTreatment nextActions; |
| |
| SingleGroup(TrafficTreatment next) { |
| this.nextActions = next; |
| } |
| |
| @Override |
| public byte[] data() { |
| return appKryo.serialize(nextActions); |
| } |
| |
| public TrafficTreatment treatment() { |
| return nextActions; |
| } |
| |
| } |
| |
| |
| } |