diff --git a/drivers/server/src/main/java/org/onosproject/drivers/server/FlowRuleProgrammableServerImpl.java b/drivers/server/src/main/java/org/onosproject/drivers/server/FlowRuleProgrammableServerImpl.java
new file mode 100644
index 0000000..7177dc0
--- /dev/null
+++ b/drivers/server/src/main/java/org/onosproject/drivers/server/FlowRuleProgrammableServerImpl.java
@@ -0,0 +1,382 @@
+/*
+ * Copyright 2018 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.server;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.collect.Sets;
+
+import org.slf4j.Logger;
+
+import org.onosproject.drivers.server.devices.nic.NicFlowRule;
+import org.onosproject.drivers.server.devices.nic.NicRxFilter.RxFilter;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.flow.DefaultFlowEntry;
+import org.onosproject.net.flow.FlowEntry;
+import org.onosproject.net.flow.FlowRule;
+import org.onosproject.net.flow.FlowRuleProgrammable;
+import org.onosproject.net.flow.FlowRuleService;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import javax.ws.rs.ProcessingException;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Manages rules on commodity server devices, by
+ * converting ONOS FlowRule objetcs into
+ * network interface card (NIC) rules and vice versa.
+ */
+public class FlowRuleProgrammableServerImpl extends BasicServerDriver
+        implements FlowRuleProgrammable {
+
+    private final Logger log = getLogger(getClass());
+
+    /**
+     * Resource endpoints of the server agent (REST server-side).
+     */
+    private static final String RULE_MANAGEMENT_URL = BASE_URL + "/rules";
+
+    /**
+     * Parameters to be exchanged with the server's agent.
+     */
+    private static final String PARAM_RULES        = "rules";
+    private static final String PARAM_NIC_ID       = "nicId";
+    private static final String PARAM_CPU_ID       = "cpuId";
+    private static final String PARAM_CPU_RULES    = "cpuRules";
+    private static final String PARAM_RULE_ID      = "ruleId";
+    private static final String PARAM_RULE_CONTENT = "ruleContent";
+
+    @Override
+    public Collection<FlowEntry> getFlowEntries() {
+        DeviceId deviceId = getHandler().data().deviceId();
+        checkNotNull(deviceId, DEVICE_ID_NULL);
+
+        // Expected FlowEntries installed through ONOS
+        FlowRuleService flowService = getHandler().get(FlowRuleService.class);
+        Iterable<FlowEntry> flowEntries = flowService.getFlowEntries(deviceId);
+
+        // Hit the path that provides the server's flow rules
+        InputStream response = null;
+        try {
+            response = getController().get(deviceId, RULE_MANAGEMENT_URL, JSON);
+        } catch (ProcessingException pEx) {
+            log.error("Failed to get flow entries from device: {}", deviceId);
+            return Collections.EMPTY_LIST;
+        }
+
+        // Load the JSON into objects
+        ObjectMapper mapper = new ObjectMapper();
+        ObjectNode objNode = null;
+        try {
+            Map<String, Object> jsonMap  = mapper.readValue(response, Map.class);
+            JsonNode jsonNode = mapper.convertValue(jsonMap, JsonNode.class);
+            objNode = (ObjectNode) jsonNode;
+        } catch (IOException ioEx) {
+            log.error("Failed to get flow entries from device: {}", deviceId);
+            return Collections.EMPTY_LIST;
+        }
+
+        if (objNode == null) {
+            log.error("Failed to get flow entries from device: {}", deviceId);
+            return Collections.EMPTY_LIST;
+        }
+
+        JsonNode scsNode = objNode.path(PARAM_RULES);
+
+        // Here we store the trully installed rules
+        Collection<FlowEntry> actualFlowEntries =
+            Sets.<FlowEntry>newConcurrentHashSet();
+
+        for (JsonNode scNode : scsNode) {
+            String scId = get(scNode, PARAM_ID);
+            String rxFilter = get(
+                scNode.path(NIC_PARAM_RX_FILTER), NIC_PARAM_RX_METHOD);
+
+            // Only Flow-based RxFilter is permitted
+            if (RxFilter.getByName(rxFilter) != RxFilter.FLOW) {
+                log.warn("Device with Rx filter {} is not managed by this driver",
+                    rxFilter.toString().toUpperCase());
+                continue;
+            }
+
+            // Each device might have multiple NICs
+            for (JsonNode nicNode : scNode.path(PARAM_NICS)) {
+                String nicId = get(nicNode, PARAM_NIC_ID);
+                JsonNode cpusNode = nicNode.path(PARAM_CPUS);
+
+                // Each NIC can dispatch to multiple CPU cores
+                for (JsonNode cpuNode : cpusNode) {
+                    String cpuId = get(cpuNode, PARAM_CPU_ID);
+                    JsonNode rulesNode = cpuNode.path(PARAM_CPU_RULES);
+
+                    // Multiple rules might correspond to each CPU core
+                    for (JsonNode ruleNode : rulesNode) {
+                        long ruleId = ruleNode.path(PARAM_RULE_ID).asLong();
+                        String ruleContent = get(ruleNode, PARAM_RULE_CONTENT);
+
+                        // Search for this rule ID in ONOS's store
+                        FlowRule r = findRuleInFlowEntries(flowEntries, ruleId);
+
+                        // Local rule, not present in the controller => Ignore
+                        if (r == null) {
+                            continue;
+                        // Rule trully present in the data plane => Add
+                        } else {
+                            actualFlowEntries.add(
+                                new DefaultFlowEntry(
+                                    r, FlowEntry.FlowEntryState.ADDED, 0, 0, 0));
+                        }
+                    }
+                }
+            }
+        }
+
+        return actualFlowEntries;
+    }
+
+    @Override
+    public Collection<FlowRule> applyFlowRules(Collection<FlowRule> rules) {
+        DeviceId deviceId = getHandler().data().deviceId();
+        checkNotNull(deviceId, DEVICE_ID_NULL);
+
+        // Set of truly-installed rules to be reported
+        Set<FlowRule> installedRules = Sets.<FlowRule>newConcurrentHashSet();
+
+        // Splits the rule set into multiple ones, grouped by traffic class ID
+        Map<String, Set<FlowRule>> rulesPerTc = groupRules(rules);
+
+        // Install NIC rules on a per-traffic class basis
+        for (Map.Entry<String, Set<FlowRule>> entry : rulesPerTc.entrySet()) {
+            String tcId = entry.getKey();
+            Set<FlowRule> tcRuleSet = entry.getValue();
+
+            installedRules.addAll(
+                installNicFlowRules(deviceId, tcId, tcRuleSet)
+            );
+        }
+
+        return installedRules;
+    }
+
+    @Override
+    public Collection<FlowRule> removeFlowRules(Collection<FlowRule> rules) {
+        DeviceId deviceId = getHandler().data().deviceId();
+        checkNotNull(deviceId, DEVICE_ID_NULL);
+
+        // Set of truly-removed rules to be reported
+        Set<FlowRule> removedRules = Sets.<FlowRule>newConcurrentHashSet();
+
+        // for (FlowRule rule : rules) {
+        rules.forEach(rule -> {
+            if (removeNicFlowRule(deviceId, rule.id().value())) {
+                removedRules.add(rule);
+            }
+        });
+
+        return removedRules;
+    }
+
+    /**
+     * Groups a set of FlowRules by their traffic class ID.
+     *
+     * @param rules set of NIC rules to install
+     * @return a map of traffic class IDs to their set of NIC rules
+     */
+    private Map<String, Set<FlowRule>> groupRules(Collection<FlowRule> rules) {
+        Map<String, Set<FlowRule>> rulesPerTc =
+            new ConcurrentHashMap<String, Set<FlowRule>>();
+
+        rules.forEach(rule -> {
+            if (!(rule instanceof FlowEntry)) {
+                NicFlowRule nicRule = (NicFlowRule) rule;
+                String tcId = nicRule.trafficClassId();
+
+                // Create a bucket of flow rules for this traffic class
+                if (!rulesPerTc.containsKey(tcId)) {
+                    rulesPerTc.put(tcId, Sets.<FlowRule>newConcurrentHashSet());
+                }
+
+                Set<FlowRule> tcRuleSet = rulesPerTc.get(tcId);
+                tcRuleSet.add(nicRule);
+            }
+        });
+
+        return rulesPerTc;
+    }
+
+    /**
+     * Searches for a flow rule with certain ID.
+     *
+     * @param flowEntries a list of FlowEntries
+     * @param ruleId a desired rule ID
+     * @return a FlowRule that corresponds to the desired ID or null
+     */
+    private FlowRule findRuleInFlowEntries(
+            Iterable<FlowEntry> flowEntries, long ruleId) {
+        for (FlowEntry fe : flowEntries) {
+            if (fe.id().value() == ruleId) {
+                return (FlowRule) fe;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Installs a set of FlowRules of the same traffic class ID
+     * on a server device.
+     *
+     * @param deviceId target server device ID
+     * @param trafficClassId traffic class ID of the NIC rules
+     * @param rules set of NIC rules to install
+     * @return a set of successfully installed NIC rules
+     */
+    private Collection<FlowRule> installNicFlowRules(
+            DeviceId deviceId, String trafficClassId,
+            Collection<FlowRule> rules) {
+        if (rules.isEmpty()) {
+            return Collections.EMPTY_LIST;
+        }
+
+        ObjectMapper mapper = new ObjectMapper();
+
+        // Create the object node to host the list of rules
+        ObjectNode scsObjNode = mapper.createObjectNode();
+
+        // Add the service chain's traffic class ID that requested these rules
+        scsObjNode.put(BasicServerDriver.PARAM_ID, trafficClassId);
+
+        // Create the object node to host the Rx filter method
+        ObjectNode methodObjNode = mapper.createObjectNode();
+        methodObjNode.put(BasicServerDriver.NIC_PARAM_RX_METHOD, "flow");
+        scsObjNode.put(BasicServerDriver.NIC_PARAM_RX_FILTER, methodObjNode);
+
+        // Map each core to an array of rule IDs and rules
+        Map<Long, ArrayNode> cpuObjSet =
+            new ConcurrentHashMap<Long, ArrayNode>();
+
+        String nicId = null;
+
+        for (FlowRule rule : rules) {
+            NicFlowRule nicRule = (NicFlowRule) rule;
+            long coreIndex = nicRule.cpuCoreIndex();
+
+            // Keep the ID of the target NIC
+            if (nicId == null) {
+                long nicIfaceNb = nicRule.interfaceNumber();
+                checkArgument(nicIfaceNb > 0,
+                    "Attempted to install NIC rules on an invalid NIC ID: "
+                    + nicIfaceNb);
+                // NIC IDs in the dataplane start from 0
+                nicId = Long.toString(nicIfaceNb - 1);
+            }
+
+            // Create a JSON array for this CPU core
+            if (!cpuObjSet.containsKey(coreIndex)) {
+                cpuObjSet.put(coreIndex, mapper.createArrayNode());
+            }
+
+            // The array of rules that corresponds to this CPU core
+            ArrayNode ruleArrayNode = cpuObjSet.get(coreIndex);
+
+            // Each rule has an ID and a content
+            ObjectNode ruleNode = mapper.createObjectNode();
+            ruleNode.put("ruleId", nicRule.id().value());
+            ruleNode.put("ruleContent", nicRule.ruleBody());
+
+            ruleArrayNode.add(ruleNode);
+        }
+
+        ObjectNode nicObjNode = mapper.createObjectNode();
+        // TODO: Fix this as it might cause issues
+        nicObjNode.put("nicId", "fd" + nicId);
+
+        ArrayNode cpusArrayNode = nicObjNode.putArray(PARAM_CPUS);
+
+        // Convert the map of CPU cores to arrays of rules to JSON
+        for (Map.Entry<Long, ArrayNode> entry : cpuObjSet.entrySet()) {
+            long coreIndex = entry.getKey();
+            ArrayNode ruleArrayNode = entry.getValue();
+
+            ObjectNode cpuObjNode = mapper.createObjectNode();
+            cpuObjNode.put("cpuId", coreIndex);
+            cpuObjNode.putArray(PARAM_CPU_RULES).addAll(ruleArrayNode);
+
+            cpusArrayNode.add(cpuObjNode);
+        }
+
+        scsObjNode.putArray(PARAM_NICS).add(nicObjNode);
+
+        // Create the object node to host all the data
+        ObjectNode sendObjNode = mapper.createObjectNode();
+        sendObjNode.putArray(PARAM_RULES).add(scsObjNode);
+
+        // Post the NIC rules to the server
+        int response = getController().post(
+            deviceId, RULE_MANAGEMENT_URL,
+            new ByteArrayInputStream(sendObjNode.toString().getBytes()), JSON);
+
+        // Upon an error, return an empty set of rules
+        if (!checkStatusCode(response)) {
+            log.error("Failed to install flow rules on device {}", deviceId);
+            return Collections.EMPTY_LIST;
+        }
+
+        log.info("Successfully installed {} flow rules on device {}",
+            rules.size(), deviceId);
+
+        // .. or all of them
+        return rules;
+    }
+
+    /**
+     * Removes a FlowRule from a server device.
+     *
+     * @param deviceId target server device ID
+     * @param ruleId NIC rule ID to be removed
+     * @return boolean removal status
+     */
+    private boolean removeNicFlowRule(DeviceId deviceId, long ruleId) {
+        // Remove rule with ID from this server
+        int response = getController().delete(deviceId,
+            RULE_MANAGEMENT_URL + "/" + Long.toString(ruleId), null, JSON);
+
+        if (!checkStatusCode(response)) {
+            log.error("Failed to remove flow rule {} from device {}",
+                ruleId, deviceId);
+            return false;
+        }
+
+        log.info("Successfully removed flow rule {} from device {}",
+            ruleId, deviceId);
+
+        return true;
+    }
+
+}
diff --git a/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/DefaultDpdkNicFlowRule.java b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/DefaultDpdkNicFlowRule.java
new file mode 100644
index 0000000..5831b79
--- /dev/null
+++ b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/DefaultDpdkNicFlowRule.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright 2018-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.server.devices.nic;
+
+import org.onosproject.net.flow.FlowRule;
+
+import org.onlab.packet.MacAddress;
+
+/**
+ * Implementation of a DPDK-based network interface card (NIC) flow rule.
+ */
+public class DefaultDpdkNicFlowRule extends DefaultNicFlowRule {
+
+    public DefaultDpdkNicFlowRule(
+            FlowRule         flowRule,
+            String           trafficClassId,
+            String           interfaceName,
+            long             interfaceNumber,
+            long             cpuCoreIndex,
+            NicRuleScope     scope) {
+        super(flowRule, trafficClassId, interfaceName, interfaceNumber,
+            cpuCoreIndex, scope);
+    }
+
+    @Override
+    public String createRule() {
+        String rule = "flow create " + Long.toString(this.interfaceNumber) + " ";
+        return rule + ruleBody();
+    }
+
+    @Override
+    public String removeRule() {
+        String rule = "flow remove " + Long.toString(this.interfaceNumber) + " ";
+        return rule + ruleBody();
+    }
+
+    @Override
+    public String ruleBody() {
+        String rule = "";
+
+        rule += this.scope() + " pattern ";
+
+        if (this.hasEthernet()) {
+            rule += "eth ";
+
+            if (this.ethernetType() != null) {
+                rule += "type is " + Integer.toString(this.ethernetTypeValue()) + " ";
+            }
+
+            if (this.ethernetSrcAddress() != null) {
+                rule += "src spec " + this.ethernetSrcAddress().toString() + " ";
+                rule += "src mask " + MacAddress.BROADCAST.toString() + " ";
+            }
+
+            if (this.ethernetDstAddress() != null) {
+                rule += "dst spec " + this.ethernetDstAddress().toString() + " ";
+                rule += "dst mask " + MacAddress.BROADCAST.toString() + " ";
+            }
+
+            rule += "/ ";
+        }
+
+        if (this.hasIpv4()) {
+            rule += "ipv4 ";
+
+            if (this.ipv4Protocol() > 0) {
+                rule += "proto spec " + Integer.toString(this.ipv4Protocol()) + " ";
+                rule += "proto mask 0x0 ";
+            }
+
+            if (this.ipv4SrcAddress() != null) {
+                rule += "src is " + this.ipv4SrcAddress().toString() + " ";
+            }
+
+            if (this.ipv4SrcMask() != null) {
+                rule += "src mask " + this.ipv4SrcMask().toString() + " ";
+            }
+
+            if (this.ipv4DstAddress() != null) {
+                rule += "dst is " + this.ipv4DstAddress().toString() + " ";
+            }
+
+            if (this.ipv4DstMask() != null) {
+                rule += "dst mask " + this.ipv4DstMask().toString() + " ";
+            }
+
+            rule += "/ ";
+        }
+
+        if (this.hasTransport()) {
+
+            if (this.hasUdp()) {
+                rule += "udp ";
+            } else if (this.hasTcp()) {
+                rule += "tcp ";
+            }
+
+            if (this.sourcePort() > 0) {
+                rule += "src is " + Integer.toString(this.sourcePort()) + " ";
+            }
+
+            if (this.destinationPort() > 0) {
+                rule += "dst is " + Integer.toString(this.destinationPort()) + " ";
+            }
+
+            rule += "/ ";
+        }
+
+        rule += "end ";
+
+        if (this.actions() != null) {
+            rule += "actions ";
+
+            for (NicRuleAction action : this.actions()) {
+                rule += action.actionType().toString() + " ";
+
+                // No subsequent field
+                if (action.actionField().isEmpty()) {
+                    continue;
+                }
+
+                // A subsequent field is associated with a value
+                rule += action.actionField() + " ";
+                rule += Long.toString(action.actionValue()) + " ";
+            }
+
+            rule += "/ end";
+        }
+
+        return rule;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return super.equals(obj);
+    }
+
+    @Override
+    public int hashCode() {
+        return super.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return super.toString();
+    }
+
+    /**
+     * Returns a DPDK NIC rule builder.
+     *
+     * @return builder
+     */
+    public static Builder nicRulebuilder() {
+        return new Builder();
+    }
+
+    /**
+     * Default DPDK NIC rule builder.
+     */
+    public static final class Builder extends DefaultNicFlowRule.Builder {
+
+        public Builder() {
+            super();
+        }
+
+        @Override
+        public NicFlowRule build() {
+            return new DefaultDpdkNicFlowRule(
+                flowRule, trafficClassId, interfaceName, interfaceNumber,
+                cpuCoreIndex, scope);
+        }
+
+    }
+
+}
diff --git a/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/DefaultNicFlowRule.java b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/DefaultNicFlowRule.java
new file mode 100644
index 0000000..d50a2b0
--- /dev/null
+++ b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/DefaultNicFlowRule.java
@@ -0,0 +1,498 @@
+/*
+ * Copyright 2018-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.server.devices.nic;
+
+import com.google.common.base.Strings;
+
+import org.onosproject.net.flow.DefaultFlowRule;
+import org.onosproject.net.flow.FlowRule;
+import org.onosproject.net.flow.criteria.EthTypeCriterion;
+import org.onosproject.net.flow.criteria.EthCriterion;
+import org.onosproject.net.flow.criteria.IPProtocolCriterion;
+import org.onosproject.net.flow.criteria.IPCriterion;
+import org.onosproject.net.flow.criteria.UdpPortCriterion;
+import org.onosproject.net.flow.criteria.TcpPortCriterion;
+
+import org.onosproject.net.flow.instructions.Instruction;
+import org.onosproject.net.flow.instructions.Instructions.SetQueueInstruction;
+import org.onosproject.net.flow.instructions.Instructions.MeterInstruction;
+
+import org.onlab.packet.EthType;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.Ip4Prefix;
+
+import org.slf4j.Logger;
+
+import java.util.Objects;
+import java.util.HashSet;
+import java.util.Set;
+
+import static com.google.common.base.MoreObjects.toStringHelper;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.onosproject.net.flow.criteria.Criterion.Type.ETH_TYPE;
+import static org.onosproject.net.flow.criteria.Criterion.Type.ETH_SRC;
+import static org.onosproject.net.flow.criteria.Criterion.Type.ETH_DST;
+import static org.onosproject.net.flow.criteria.Criterion.Type.IP_PROTO;
+import static org.onosproject.net.flow.criteria.Criterion.Type.IPV4_SRC;
+import static org.onosproject.net.flow.criteria.Criterion.Type.IPV4_DST;
+import static org.onosproject.net.flow.criteria.Criterion.Type.UDP_SRC;
+import static org.onosproject.net.flow.criteria.Criterion.Type.UDP_DST;
+import static org.onosproject.net.flow.criteria.Criterion.Type.TCP_SRC;
+import static org.onosproject.net.flow.criteria.Criterion.Type.TCP_DST;
+import static org.onosproject.net.flow.instructions.Instruction.Type.NOACTION;
+import static org.onosproject.net.flow.instructions.Instruction.Type.QUEUE;
+import static org.onosproject.net.flow.instructions.Instruction.Type.METER;
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Implementation of an abstract NIC rule.
+ */
+public abstract class DefaultNicFlowRule extends DefaultFlowRule implements NicFlowRule {
+
+    protected static final Logger log = getLogger(DefaultNicFlowRule.class);
+
+    // Additional members that a NIC rule requires
+    protected final String trafficClassId;
+    protected final String interfaceName;
+    protected long interfaceNumber;
+    protected long cpuCoreIndex;
+    protected final NicRuleScope scope;
+
+    // Derive from FlowRule's selector
+    protected EthTypeCriterion ethTypeCriterion;
+    protected EthCriterion ethSrcAddrCriterion;
+    protected EthCriterion ethDstAddrCriterion;
+
+    protected IPProtocolCriterion ipv4ProtoCriterion;
+    protected IPCriterion ipv4SrcAddrCriterion;
+    protected IPCriterion ipv4SrcMaskCriterion;
+    protected IPCriterion ipv4DstAddrCriterion;
+    protected IPCriterion ipv4DstMaskCriterion;
+
+    protected UdpPortCriterion udpSrcPortCriterion;
+    protected UdpPortCriterion udpDstPortCriterion;
+    protected TcpPortCriterion tcpSrcPortCriterion;
+    protected TcpPortCriterion tcpDstPortCriterion;
+
+    // Derives from FlowRule's treatment
+    protected Set<NicRuleAction> actions;
+
+    protected DefaultNicFlowRule(
+            FlowRule         flowRule,
+            String           trafficClassId,
+            String           interfaceName,
+            long             interfaceNumber,
+            long             cpuCoreIndex,
+            NicRuleScope     scope) {
+        super(flowRule);
+
+        checkNotNull(!Strings.isNullOrEmpty(trafficClassId),
+            "NIC rule's traffic class ID is NULL or empty");
+        checkNotNull(interfaceName,
+            "NIC rule's interface name is NULL");
+        checkArgument(interfaceNumber >= 0,
+            "NIC rule's interface number must not be negative");
+        checkArgument(cpuCoreIndex >= 0,
+            "NIC rule's CPU core index must not be negative");
+        checkNotNull(scope, "NIC rule's scope is NULL");
+
+        this.trafficClassId  = trafficClassId;
+        this.interfaceName   = interfaceName;
+        this.interfaceNumber = interfaceNumber;
+        this.cpuCoreIndex    = cpuCoreIndex;
+        this.scope           = scope;
+
+        this.populate();
+    }
+
+    protected DefaultNicFlowRule(FlowRule flowRule) {
+        super(flowRule);
+
+        this.trafficClassId  = Builder.DEFAULT_TRAFFIC_CLASS_ID;
+        this.interfaceName   = "";
+        this.interfaceNumber = Builder.DEFAULT_INTERFACE_NB;
+        this.cpuCoreIndex    = Builder.DEFAULT_CPU_CORE_INDEX;
+        this.scope           = Builder.DEFAULT_RULE_SCOPE;
+
+        this.populate();
+    }
+
+    /**
+     * Parses FlowRule's traffic selector and treatment
+     * and keeps relevant information for this NIC rule.
+     */
+    private void populate() {
+        this.ethTypeCriterion = (EthTypeCriterion) this.selector().getCriterion(ETH_TYPE);
+        this.ethSrcAddrCriterion = (EthCriterion) this.selector().getCriterion(ETH_SRC);
+        this.ethDstAddrCriterion = (EthCriterion) this.selector().getCriterion(ETH_DST);
+        this.ipv4ProtoCriterion = (IPProtocolCriterion) this.selector().getCriterion(IP_PROTO);
+        this.ipv4SrcAddrCriterion = (IPCriterion) this.selector().getCriterion(IPV4_SRC);
+        this.ipv4DstAddrCriterion = (IPCriterion) this.selector().getCriterion(IPV4_DST);
+        // Is there a criterion for IP masks?
+        this.ipv4SrcMaskCriterion = (IPCriterion) null;
+        this.ipv4DstMaskCriterion = (IPCriterion) null;
+        this.udpSrcPortCriterion = (UdpPortCriterion) this.selector().getCriterion(UDP_SRC);
+        this.udpDstPortCriterion = (UdpPortCriterion) this.selector().getCriterion(UDP_DST);
+        this.tcpSrcPortCriterion = (TcpPortCriterion) this.selector().getCriterion(TCP_SRC);
+        this.tcpDstPortCriterion = (TcpPortCriterion) this.selector().getCriterion(TCP_DST);
+
+        this.actions = new HashSet<NicRuleAction>();
+        // TODO: Expand this translator with more actions
+        for (Instruction instr : this.treatment().allInstructions()) {
+            if (instr.type() == NOACTION) {
+                this.actions.add(new NicRuleAction(NicRuleAction.Action.DROP));
+            } else if (instr.type() == QUEUE) {
+                SetQueueInstruction queueInstruction = (SetQueueInstruction) instr;
+                this.actions.add(
+                    new NicRuleAction(NicRuleAction.Action.QUEUE, queueInstruction.queueId()));
+                this.interfaceNumber = queueInstruction.port().toLong();
+            } else if (instr.type() == METER) {
+                MeterInstruction meterInstruction = (MeterInstruction) instr;
+                this.actions.add(
+                    new NicRuleAction(NicRuleAction.Action.METER, meterInstruction.meterId().id()));
+            }
+        }
+    }
+
+    @Override
+    public FlowRule flowRule() {
+        return this;
+    }
+
+    @Override
+    public String trafficClassId() {
+        return trafficClassId;
+    }
+
+    @Override
+    public String interfaceName() {
+        return interfaceName;
+    }
+
+    @Override
+    public long interfaceNumber() {
+        return interfaceNumber;
+    }
+
+    @Override
+    public long cpuCoreIndex() {
+        return cpuCoreIndex;
+    }
+
+    @Override
+    public NicRuleScope scope() {
+        return scope;
+    }
+
+    @Override
+    public EthType ethernetType() {
+        return (ethTypeCriterion != null) ?
+            ethTypeCriterion.ethType() : null;
+    }
+
+    @Override
+    public short ethernetTypeValue() {
+        return (ethTypeCriterion != null) ?
+            ethTypeCriterion.ethType().toShort() : -1;
+    }
+
+    @Override
+    public MacAddress ethernetSrcAddress() {
+        return (ethSrcAddrCriterion != null) ?
+            ethSrcAddrCriterion.mac() : null;
+    }
+
+    @Override
+    public MacAddress ethernetDstAddress() {
+        return (ethDstAddrCriterion != null) ?
+            ethDstAddrCriterion.mac() : null;
+    }
+
+    @Override
+    public boolean hasEthernet() {
+        return (ethernetType() != null) ||
+               (ethernetSrcAddress() != null) ||
+               (ethernetDstAddress() != null);
+    }
+
+    @Override
+    public short ipv4Protocol() {
+        return (ipv4ProtoCriterion != null) ?
+            ipv4ProtoCriterion.protocol() : -1;
+    }
+
+    @Override
+    public Ip4Prefix ipv4SrcAddress() {
+        return (ipv4SrcAddrCriterion != null) ?
+            ipv4SrcAddrCriterion.ip().getIp4Prefix() : null;
+    }
+
+    @Override
+    public Ip4Prefix ipv4SrcMask() {
+        return (ipv4SrcMaskCriterion != null) ?
+            ipv4SrcMaskCriterion.ip().getIp4Prefix() : null;
+    }
+
+    @Override
+    public Ip4Prefix ipv4DstAddress() {
+        return (ipv4DstAddrCriterion != null) ?
+            ipv4DstAddrCriterion.ip().getIp4Prefix() : null;
+    }
+
+    @Override
+    public Ip4Prefix ipv4DstMask() {
+        return (ipv4DstMaskCriterion != null) ?
+            ipv4DstMaskCriterion.ip().getIp4Prefix() : null;
+    }
+
+    @Override
+    public boolean hasIpv4() {
+        return (ipv4Protocol() > 0) ||
+               (ipv4SrcAddress() != null) ||
+               (ipv4DstAddress() != null);
+    }
+
+    @Override
+    public boolean hasIpv6() {
+        return false;
+    }
+
+    @Override
+    public int sourcePort() {
+        return ((udpSrcPortCriterion != null) ?
+                 udpSrcPortCriterion.udpPort().toInt() :
+                    ((tcpSrcPortCriterion != null) ?
+                      tcpSrcPortCriterion.tcpPort().toInt() : -1));
+    }
+
+    @Override
+    public int destinationPort() {
+        return ((udpDstPortCriterion != null) ?
+                 udpDstPortCriterion.udpPort().toInt() :
+                    ((tcpDstPortCriterion != null) ?
+                      tcpDstPortCriterion.tcpPort().toInt() : -1));
+    }
+
+    @Override
+    public boolean hasUdp() {
+        return (udpSrcPortCriterion != null) || (udpDstPortCriterion != null);
+    }
+
+    @Override
+    public boolean hasTcp() {
+        return (tcpSrcPortCriterion != null) || (tcpDstPortCriterion != null);
+    }
+
+    @Override
+    public boolean hasTransport() {
+        return (sourcePort() > 0) || (destinationPort() > 0);
+    }
+
+    @Override
+    public Set<NicRuleAction> actions() {
+        return actions;
+    }
+
+    @Override
+    public void addAction(NicRuleAction action) {
+        checkNotNull(action, "Cannot add a NULL NIC rule action");
+        if (actions == null) {
+            actions = new HashSet<NicRuleAction>();
+        }
+        actions.add(action);
+    }
+
+    @Override
+    public long queueNumber() {
+        for (NicRuleAction action : actions) {
+            if (action.actionType() == NicRuleAction.Action.QUEUE) {
+                return action.actionValue();
+            }
+        }
+
+        return (long) -1;
+    }
+
+    @Override
+    public abstract String createRule();
+
+    @Override
+    public abstract String removeRule();
+
+    @Override
+    public abstract String ruleBody();
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+
+        if (obj instanceof DefaultNicFlowRule) {
+            DefaultNicFlowRule that = (DefaultNicFlowRule) obj;
+            return  Objects.equals(trafficClassId, that.trafficClassId) &&
+                    Objects.equals(interfaceName, that.interfaceName) &&
+                    Objects.equals(interfaceNumber, that.interfaceNumber) &&
+                    Objects.equals(cpuCoreIndex, that.cpuCoreIndex) &&
+                    Objects.equals(scope, that.scope) &&
+                    Objects.equals(actions, that.actions) &&
+                    Objects.equals(deviceId(), that.deviceId()) &&
+                    Objects.equals(id(), that.id()) &&
+                    Objects.equals(selector(), that.selector());
+        }
+
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(
+            trafficClassId, interfaceName, interfaceNumber,
+            cpuCoreIndex, scope, deviceId(), id(), selector()
+        );
+    }
+
+    @Override
+    public String toString() {
+        return toStringHelper(this)
+                .omitNullValues()
+                .add("Device ID", deviceId())
+                .add("Traffic class ID", trafficClassId())
+                .add("Flow ID", id())
+                .add("Interface name", interfaceName())
+                .add("Interface number", interfaceNumber())
+                .add("CPU core index", cpuCoreIndex())
+                .add("Scope", scope())
+                .add("Traffic selector", selector())
+                .add("Traffic treatment", treatment())
+                .add("Priority", priority())
+                .add("Ethernet type", ethernetTypeValue())
+                .add("Ethernet address source", ethernetSrcAddress())
+                .add("Ethernet address destination", ethernetDstAddress())
+                .add("IP protocol", ipv4Protocol())
+                .add("IP address source", ipv4SrcAddress())
+                .add("IP mask source", ipv4SrcMask())
+                .add("IP address destination", ipv4DstAddress())
+                .add("IP mask destination", ipv4DstMask())
+                .add("Source port", sourcePort())
+                .add("Destination port", destinationPort())
+                .add("Actions", actions())
+                .toString();
+    }
+
+
+    public abstract static class Builder implements NicFlowRule.Builder {
+
+        protected FlowRule flowRule;
+
+        protected String trafficClassId;
+        protected String interfaceName;
+        protected long interfaceNumber;
+        protected long cpuCoreIndex;
+        protected NicRuleScope scope;
+
+        protected EthTypeCriterion ethTypeCriterion;
+        protected EthCriterion ethSrcAddrCriterion;
+        protected EthCriterion ethDstAddrCriterion;
+
+        protected IPProtocolCriterion ipv4ProtoCriterion;
+        protected IPCriterion ipv4SrcAddrCriterion;
+        protected IPCriterion ipv4SrcMaskCriterion;
+        protected IPCriterion ipv4DstAddrCriterion;
+        protected IPCriterion ipv4DstMaskCriterion;
+
+        protected UdpPortCriterion udpSrcPortCriterion;
+        protected UdpPortCriterion udpDstPortCriterion;
+        protected TcpPortCriterion tcpSrcPortCriterion;
+        protected TcpPortCriterion tcpDstPortCriterion;
+
+        protected Set<NicRuleAction> actions;
+
+        protected static final String DEFAULT_TRAFFIC_CLASS_ID = "tc:00001";
+        protected static final long DEFAULT_INTERFACE_NB = (long) 0;
+        protected static final long DEFAULT_CPU_CORE_INDEX = (long) 0;
+        protected static final NicRuleScope DEFAULT_RULE_SCOPE =
+            NicRuleScope.INGRESS;
+
+        protected Builder() {
+            this.flowRule = null;
+
+            this.trafficClassId = null;
+            this.interfaceName = "";
+            this.interfaceNumber = DEFAULT_INTERFACE_NB;
+            this.cpuCoreIndex = DEFAULT_CPU_CORE_INDEX;
+            this.scope = DEFAULT_RULE_SCOPE;
+
+            this.ethTypeCriterion = null;
+            this.ethSrcAddrCriterion = null;
+            this.ethDstAddrCriterion = null;
+            this.ipv4ProtoCriterion = null;
+            this.ipv4SrcAddrCriterion = null;
+            this.ipv4SrcMaskCriterion = null;
+            this.ipv4DstAddrCriterion = null;
+            this.ipv4DstMaskCriterion = null;
+            this.udpSrcPortCriterion = null;
+            this.udpDstPortCriterion = null;
+            this.tcpSrcPortCriterion = null;
+            this.tcpDstPortCriterion = null;
+
+            this.actions = new HashSet<NicRuleAction>();
+        }
+
+        @Override
+        public Builder fromFlowRule(FlowRule flowRule) {
+            this.flowRule = flowRule;
+            return this;
+        }
+
+        @Override
+        public Builder withTrafficClassId(String trafficClassId) {
+            this.trafficClassId = trafficClassId;
+            return this;
+        }
+
+        @Override
+        public Builder withInterfaceName(String interfaceName) {
+            this.interfaceName = interfaceName;
+            return this;
+        }
+
+        @Override
+        public Builder withInterfaceNumber(long interfaceNumber) {
+            this.interfaceNumber = interfaceNumber;
+            return this;
+        }
+
+        @Override
+        public Builder assignedToCpuCore(long cpuCoreIndex) {
+            this.cpuCoreIndex = cpuCoreIndex;
+            return this;
+        }
+
+        @Override
+        public Builder withScope(NicRuleScope scope) {
+            this.scope = scope;
+            return this;
+        }
+
+        @Override
+        public abstract NicFlowRule build();
+
+    }
+
+}
diff --git a/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/FlowRxFilterValue.java b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/FlowRxFilterValue.java
new file mode 100644
index 0000000..64c792b
--- /dev/null
+++ b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/FlowRxFilterValue.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright 2018-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.server.devices.nic;
+
+import java.util.Objects;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * A flow rule-based Rx filter value.
+ */
+public final class FlowRxFilterValue extends RxFilterValue
+        implements Comparable {
+
+    private long cpuCoreId;
+    private String flowRule;
+
+    /**
+     * Constructs a flow-based Rx filter.
+     */
+    public FlowRxFilterValue() {
+        super();
+        setValue(0);
+        setRule("");
+    }
+
+    /**
+     * Constructs a flow-based Rx filter with CPU core ID.
+     *
+     * @param cpuCoreId a CPU core ID when the flow ends up
+     */
+    public FlowRxFilterValue(long cpuCoreId) {
+        super();
+        setValue(cpuCoreId);
+        setRule("");
+    }
+
+    /**
+     * Constructs a flow-based Rx filter with CPU core ID
+     * and an associated rule.
+     *
+     * @param cpuCoreId a CPU core ID
+     * @param flowRule a flow rule as a string
+     */
+    public FlowRxFilterValue(long cpuCoreId, String flowRule) {
+        super();
+        setValue(cpuCoreId);
+        setRule(flowRule);
+    }
+
+    /**
+     * Constructs a flow-based Rx filter out of an existing one.
+     *
+     * @param other a source FlowRxFilterValue object
+     */
+    public FlowRxFilterValue(FlowRxFilterValue other) {
+        super();
+        setValue(other.value());
+        setRule(other.rule());
+    }
+
+    /**
+     * Returns the value of this Rx filter.
+     *
+     * @return Flow Rx filter value
+     */
+    public long value() {
+        return this.cpuCoreId;
+    }
+
+    /**
+     * Sets the value of this Rx filter.
+     *
+     * @param cpuCoreId a CPU core ID for this Rx filter
+     */
+    public void setValue(long cpuCoreId) {
+        checkArgument(cpuCoreId >= 0,
+            "NIC flow Rx filter has invalid CPU core ID");
+        this.cpuCoreId = cpuCoreId;
+    }
+
+    /**
+     * Returns the rule of this Rx filter.
+     *
+     * @return Flow Rx filter rule
+     */
+    public String rule() {
+        return this.flowRule;
+    }
+
+    /**
+     * Sets the rule of this Rx filter.
+     *
+     * @param flowRule Flow Rx filter rule as a string
+     */
+    public void setRule(String flowRule) {
+        checkNotNull(flowRule,
+            "NIC flow Rx filter rule is NULL");
+        this.flowRule = flowRule;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.cpuCoreId, this.flowRule);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+
+        if ((obj == null) || (!(obj instanceof FlowRxFilterValue))) {
+            return false;
+        }
+
+        FlowRxFilterValue other = (FlowRxFilterValue) obj;
+
+        return (this.value() == other.value()) &&
+                this.rule().equals(other.rule());
+    }
+
+    @Override
+    public int compareTo(Object other) {
+        if (this == other) {
+            return 0;
+        }
+
+        if (other == null) {
+            return -1;
+        }
+
+        if (other instanceof FlowRxFilterValue) {
+            FlowRxFilterValue otherRxVal = (FlowRxFilterValue) other;
+
+            long thisCoreId  = this.value();
+            long otherCoreId = otherRxVal.value();
+
+            if (thisCoreId > otherCoreId) {
+                return 1;
+            } else if (thisCoreId < otherCoreId) {
+                return -1;
+            } else {
+                return 0;
+            }
+        }
+
+        return -1;
+    }
+
+    @Override
+    public String toString() {
+        return Long.toString(this.value());
+    }
+
+}
diff --git a/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/MacRxFilterValue.java b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/MacRxFilterValue.java
index dec0276..2676f65 100644
--- a/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/MacRxFilterValue.java
+++ b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/MacRxFilterValue.java
@@ -24,20 +24,33 @@
 /**
  * A MAC Rx filter value.
  */
-public class MacRxFilterValue extends RxFilterValue implements Comparable {
+public final class MacRxFilterValue extends RxFilterValue implements Comparable {
 
     private MacAddress mac;
 
+    /**
+     * Constructs a MAC-based Rx filter.
+     */
     public MacRxFilterValue() {
         super();
         this.mac = null;
     }
 
+    /**
+     * Constructs a MAC-based Rx filter with specific MAC address.
+     *
+     * @param mac a MAC address to use as a filter
+     */
     public MacRxFilterValue(MacAddress mac) {
         super();
         setValue(mac);
     }
 
+    /**
+     * Constructs a MAC-based Rx filter out of an existing one.
+     *
+     * @param other a source MacRxFilterValue object
+     */
     public MacRxFilterValue(MacRxFilterValue other) {
         super();
         setValue(other.value());
diff --git a/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/MplsRxFilterValue.java b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/MplsRxFilterValue.java
index 1d4c155..2b5112f 100644
--- a/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/MplsRxFilterValue.java
+++ b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/MplsRxFilterValue.java
@@ -24,20 +24,33 @@
 /**
  * An MPLS Rx filter value.
  */
-public class MplsRxFilterValue extends RxFilterValue {
+public final class MplsRxFilterValue extends RxFilterValue {
 
     private MplsLabel mplsLabel;
 
+    /**
+     * Constructs an MPLS-based Rx filter.
+     */
     public MplsRxFilterValue() {
         super();
         this.mplsLabel = null;
     }
 
+    /**
+     * Constructs an MPLS-based Rx filter with specific label.
+     *
+     * @param mplsLabel an MPLS label to use as a filter
+     */
     public MplsRxFilterValue(MplsLabel mplsLabel) {
         super();
         setValue(mplsLabel);
     }
 
+    /**
+     * Constructs an MPLS-based Rx filter out of an existing one.
+     *
+     * @param other a source MplsRxFilterValue object
+     */
     public MplsRxFilterValue(MplsRxFilterValue other) {
         super();
         setValue(other.value());
diff --git a/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/NicFlowRule.java b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/NicFlowRule.java
new file mode 100644
index 0000000..57ade4e
--- /dev/null
+++ b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/NicFlowRule.java
@@ -0,0 +1,312 @@
+/*
+ * Copyright 2018-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.server.devices.nic;
+
+import org.onosproject.net.flow.FlowRule;
+
+import org.onlab.packet.EthType;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.Ip4Prefix;
+
+import java.util.Set;
+
+/**
+ * Definition of a network interface card (NIC) flow rule.
+ */
+public interface NicFlowRule extends FlowRule {
+
+    /**
+     * Returns parent FlowRule object associated with this NIC rule.
+     *
+     * @return FlowRule object
+     */
+    FlowRule flowRule();
+
+    /**
+     * Returns the traffic class ID associated with this NIC rule.
+     * This ID is related to the software module that processes the
+     * traffic matched by this rule.
+     *
+     * @return traffic class ID
+     */
+    String trafficClassId();
+
+    /**
+     * Returns the NIC's interface name to accommodate this rule.
+     *
+     * @return NIC's interface name
+     */
+    String interfaceName();
+
+    /**
+     * Returns the NIC's interface number to accommodate this rule.
+     *
+     * @return NIC's interface number
+     */
+    long interfaceNumber();
+
+    /**
+     * Returns the CPU core index that handles the traffic matched
+     * by this NIC rule.
+     *
+     * @return CPU core index
+     */
+    long cpuCoreIndex();
+
+    /**
+     * Returns the scope of this rule.
+     *
+     * @return rule scope
+     */
+    NicRuleScope scope();
+
+    /**
+     * Returns the Ethernet type field of this rule
+     * or NULL if no Ethernet type exists in the traffic selector.
+     *
+     * @return Ethernet type field
+     */
+    EthType ethernetType();
+
+    /**
+     * Returns the Ethernet type value field of this rule
+     * or negative if no Ethernet type value exists in the traffic selector.
+     *
+     * @return Ethernet type value field
+     */
+    short ethernetTypeValue();
+
+    /**
+     * Returns the source MAC address field of this rule
+     * or NULL if no source MAC address exists in the traffic selector.
+     *
+     * @return source MAC address field
+     */
+    MacAddress ethernetSrcAddress();
+
+    /**
+     * Returns the destination MAC address field of this rule
+     * or NULL if no destination MAC address exists in the traffic selector.
+     *
+     * @return destination MAC address field
+     */
+    MacAddress ethernetDstAddress();
+
+    /**
+     * Returns whether Ethernet fields are present in this rule.
+     *
+     * @return boolean Ethernet fields' presence
+     */
+    boolean hasEthernet();
+
+    /**
+     * Returns the IP protocol field of this rule
+     * or negative if no IP protocol field exists in the traffic selector.
+     *
+     * @return IP protocol field
+     */
+    short ipv4Protocol();
+
+    /**
+     * Returns the source IP address field of this rule
+     * or null if no source IP address field exists in the traffic selector.
+     *
+     * @return source IP address field
+     */
+    Ip4Prefix ipv4SrcAddress();
+
+    /**
+     * Returns the source IP mask field of this rule
+     * or null if no source IP mask exists in the traffic selector.
+     *
+     * @return source IP mask field
+     */
+    Ip4Prefix ipv4SrcMask();
+
+    /**
+     * Returns the destination IP address field of this rule
+     * or null if no destination IP address field exists in the traffic selector.
+     *
+     * @return destination IP address field
+     */
+    Ip4Prefix ipv4DstAddress();
+
+    /**
+     * Returns the destination IP mask field of this rule
+     * or null if no destination IP mask exists in the traffic selector.
+     *
+     * @return destination IP mask field
+     */
+    Ip4Prefix ipv4DstMask();
+
+    /**
+     * Returns whether IPv4 fields are present in this rule.
+     *
+     * @return boolean IPv4 fields' presence
+     */
+    boolean hasIpv4();
+
+    /**
+     * Returns whether IPv6 fields are present in this rule.
+     *
+     * @return boolean IPv6 fields' presence
+     */
+    boolean hasIpv6();
+
+    /**
+     * Returns the source port field of this rule
+     * or negative if no source port field exists in the traffic selector.
+     *
+     * @return source port field
+     */
+    int sourcePort();
+
+    /**
+     * Returns the destination port field of this rule
+     * or negative if no destination port field exists in the traffic selector.
+     *
+     * @return destination port field
+     */
+    int destinationPort();
+
+    /**
+     * Returns whether UDP header fields are present in this rule.
+     *
+     * @return boolean UDP header fields' presence
+     */
+    boolean hasUdp();
+
+    /**
+     * Returns whether TCP header fields are present in this rule.
+     *
+     * @return boolean TCP header fields' presence
+     */
+    boolean hasTcp();
+
+    /**
+     * Returns whether transport header fields are present in this rule.
+     *
+     * @return boolean transport header fields' presence
+     */
+    boolean hasTransport();
+
+    /**
+     * Returns the set of actions of this rule.
+     *
+     * @return rule's set of actions
+     */
+    Set<NicRuleAction> actions();
+
+    /**
+     * Adds a new action to the set of actions of this rule.
+     *
+     * @param action rule action
+     */
+    void addAction(NicRuleAction action);
+
+    /**
+     * Returns the queue number of this rule's action (if any).
+     *
+     * @return rule action's queue number
+     */
+    long queueNumber();
+
+    /**
+     * Creates rule using NIC-specific rule format.
+     *
+     * @return rule creation command as a string
+     */
+    abstract String createRule();
+
+    /**
+     * Removes rule using NIC-specific rule format.
+     *
+     * @return rule removal command as a string
+     */
+    abstract String removeRule();
+
+    /**
+     * Forms a NIC rule body.
+     *
+     * @return rule body as a string
+     */
+    abstract String ruleBody();
+
+    /**
+     * A builder for NIC rules.
+     */
+    interface Builder {
+
+        /**
+         * Creates a NIC rule out of an ONOS FlowRule.
+         *
+         * @param flowRule an ONOS FlowRule object
+         * @return this
+         */
+        Builder fromFlowRule(FlowRule flowRule);
+
+        /**
+         * Creates a NIC rule with a given traffic class ID.
+         *
+         * @param trafficClassId a traffic class ID
+         * @return this
+         */
+        Builder withTrafficClassId(String trafficClassId);
+
+        /**
+         * Sets the interface name for this NIC rule.
+         *
+         * @param interfaceName an interface's name
+         * @return this
+         */
+        Builder withInterfaceName(String interfaceName);
+
+        /**
+         * Sets the interface number for this NIC rule.
+         *
+         * @param interfaceNumber an interface's number
+         * @return this
+         */
+        Builder withInterfaceNumber(long interfaceNumber);
+
+        /**
+         * Sets the CPU core index to accommodate the traffic
+         * matched by this NIC rule.
+         *
+         * @param cpuCoreIndex a CPU core index
+         * @return this
+         */
+        Builder assignedToCpuCore(long cpuCoreIndex);
+
+        /**
+         * Sets the scope for this NIC rule.
+         *
+         * @param scope an NIC rule scope
+         * @return this
+         */
+        Builder withScope(NicRuleScope scope);
+
+        /**
+         * Builds a NIC rule object.
+         *
+         * @return a NIC rule.
+         */
+        abstract NicFlowRule build();
+
+    }
+
+}
diff --git a/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/NicRuleAction.java b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/NicRuleAction.java
new file mode 100644
index 0000000..3ec13c3
--- /dev/null
+++ b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/NicRuleAction.java
@@ -0,0 +1,302 @@
+/*
+ * Copyright 2018-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.server.devices.nic;
+
+import java.util.Objects;
+import java.util.HashMap;
+import java.util.Map;
+
+import static com.google.common.base.MoreObjects.toStringHelper;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+
+/**
+ * Definition of network interface card (NIC) rule action.
+ * This class acts as a translator from FlowRule objects
+ * to NicFlowRule objects and vice versa.
+ */
+public class NicRuleAction {
+
+    /**
+     * Set of possible NIC rule actions.
+     * Source: https://doc.dpdk.org/guides/prog_guide/rte_flow.html
+     */
+    public enum Action {
+        /**
+         * Leaves traffic up for additional processing
+         * by subsequent flow rules.
+         */
+        PASSTHRU("passthru"),
+        /**
+         * The packet must be redirected to a group on this NIC.
+         */
+        JUMP("jump"),
+        /**
+         * The packet must be marked with a specific value.
+         */
+        MARK("mark"),
+        /**
+         * The packet must be marked without a specific value.
+         */
+        FLAG("flag"),
+        /**
+         * The packet must be counted.
+         */
+        COUNT("count"),
+        /**
+         * The packet must be placed into a hardware queue.
+         * This field is then used by a NIC's Flow Director component.
+         */
+        QUEUE("queue"),
+        /**
+         * The packet must be placed into a hardware queue.
+         * This field is then used by a NIC's RSS component.
+         */
+        RSS("rss"),
+        /**
+         * The packet must be sent to the physical function of the NIC.
+         */
+        PF("pf"),
+        /**
+         * The packet must be sent to a virtual function of the NIC.
+         */
+        VF("vf"),
+        /**
+         * The packet must be sent to a physical port index of the NIC.
+         */
+        PHY_PORT("phy-port"),
+        /**
+         * The packet must be sent to a NIC port ID.
+         */
+        PORT_ID("port-id"),
+        /**
+         * The packet must undergo a stage of metering and policing.
+         */
+        METER("meter"),
+        /**
+         * The packet must undergo a security action.
+         */
+        SECURITY("security"),
+        /**
+         * Sets the MPLS TTL as defined by the OpenFlow Switch Specification.
+         */
+        OF_SET_MPLS_TTL("of_set_mpls_ttl"),
+        /**
+         * Decrements the MPLS TTL as defined by the OpenFlow Switch Specification.
+         */
+        OF_DEC_MPLS_TTL("of_dec_mpls_ttl"),
+        /**
+         * Sets the IP TTL as defined by the OpenFlow Switch Specification.
+         */
+        OF_SET_NW_TTL("of_set_nw_ttl"),
+        /**
+         * Decrements the IP TTL as defined by the OpenFlow Switch Specification.
+         */
+        OF_DEC_NW_TTL("of_dec_nw_ttl"),
+        /**
+         * Implements OFPAT_COPY_TTL_IN (“copy TTL “inwards” – from outermost to next-to-outermost”)
+         * as defined by the OpenFlow Switch Specification.
+         */
+        OF_COPY_TTL_IN("of_copy_ttl_in"),
+        /**
+         * Implements OFPAT_COPY_TTL_OUT (“copy TTL “outwards” – from next-to-outermost to outermost”)
+         * as defined by the OpenFlow Switch Specification.
+         */
+        OF_COPY_TTL_OUT("of_copy_ttl_out"),
+        /**
+         * Pops the outer MPLS tag as defined by the OpenFlow Switch Specification.
+         */
+        OF_POP_MPLS("of_pop_mpls"),
+        /**
+         * Pushes a new MPLS tag as defined by the OpenFlow Switch Specification.
+         */
+        OF_PUSH_MPLS("of_push_mpls"),
+        /**
+         * Pops the outer VLAN tag as defined by the OpenFlow Switch Specification.
+         */
+        OF_POP_VLAN("of_pop_vlan"),
+        /**
+         * Pushes a new VLAN tag as defined by the OpenFlow Switch Specification.
+         */
+        OF_PUSH_VLAN("of_push_vlan"),
+        /**
+         * Sets the 802.1q VLAN ID as defined by the OpenFlow Switch Specification.
+         */
+        OF_SET_VLAN_VID("of_set_vlan_vid"),
+        /**
+         * Sets the 802.1q VLAN priority as defined by the OpenFlow Switch Specification.
+         */
+        OF_SET_VLAN_PCP("of_set_vlan_pcp"),
+        /**
+         * Performs a VXLAN encapsulation action by encapsulating the matched flow
+         * in an VXLAN tunnel.
+         */
+        VXLAN_ENCAP("vxlan_encap"),
+        /**
+         * Performs a decapsulation action by stripping all headers of the VXLAN tunnel
+         * network overlay from the matched flow.
+         */
+        VXLAN_DECAP("vxlan_decap"),
+        /**
+         * Performs a NVGRE encapsulation action by encapsulating the matched flow
+         * in an NVGRE tunnel.
+         */
+        NVGRE_ENCAP("nvgre_encap"),
+        /**
+         * Performs a decapsulation action by stripping all headers of the NVGRE tunnel
+         * network overlay from the matched flow.
+         */
+        NVGRE_DECAP("nvgre_decap"),
+        /**
+         * The packet must be dropped.
+         */
+        DROP("drop"),
+        /**
+         * Denotes end of actions.
+         */
+        END("end");
+
+        protected String action;
+
+        private Action(String action) {
+            this.action = action.toLowerCase();
+        }
+
+        @Override
+        public String toString() {
+            return action;
+        }
+
+    }
+
+    private final Action actionType;
+    private final long actionValue;
+
+    // Statically maps NIC rule action types to their fields
+    private static final Map<Action, String> ACTION_FIELD =
+        new HashMap<Action, String>();
+
+    static {
+        ACTION_FIELD.put(Action.PASSTHRU, "");
+        ACTION_FIELD.put(Action.JUMP, "group");
+        ACTION_FIELD.put(Action.MARK, "id");
+        ACTION_FIELD.put(Action.FLAG, "");
+        ACTION_FIELD.put(Action.COUNT, "id");
+        ACTION_FIELD.put(Action.QUEUE, "index");
+        ACTION_FIELD.put(Action.RSS, "queue");
+        ACTION_FIELD.put(Action.PF, "");
+        ACTION_FIELD.put(Action.VF, "id");
+        ACTION_FIELD.put(Action.PHY_PORT, "index");
+        ACTION_FIELD.put(Action.PORT_ID, "id");
+        ACTION_FIELD.put(Action.METER, "mtr_id");
+        ACTION_FIELD.put(Action.SECURITY, "security_session");
+        ACTION_FIELD.put(Action.OF_SET_MPLS_TTL, "mpls_ttl");
+        ACTION_FIELD.put(Action.OF_DEC_MPLS_TTL, "");
+        ACTION_FIELD.put(Action.OF_SET_NW_TTL, "nw_ttl");
+        ACTION_FIELD.put(Action.OF_DEC_NW_TTL, "");
+        ACTION_FIELD.put(Action.OF_COPY_TTL_IN, "");
+        ACTION_FIELD.put(Action.OF_COPY_TTL_OUT, "");
+        ACTION_FIELD.put(Action.OF_POP_MPLS, "ethertype");
+        ACTION_FIELD.put(Action.OF_PUSH_MPLS, "ethertype");
+        ACTION_FIELD.put(Action.OF_POP_VLAN, "");
+        ACTION_FIELD.put(Action.OF_PUSH_VLAN, "ethertype");
+        ACTION_FIELD.put(Action.OF_SET_VLAN_VID, "vlan_vid");
+        ACTION_FIELD.put(Action.OF_SET_VLAN_PCP, "vlan_pcp");
+        ACTION_FIELD.put(Action.VXLAN_ENCAP, "definition");
+        ACTION_FIELD.put(Action.VXLAN_DECAP, "");
+        ACTION_FIELD.put(Action.NVGRE_ENCAP, "definition");
+        ACTION_FIELD.put(Action.NVGRE_DECAP, "");
+        ACTION_FIELD.put(Action.DROP, "");
+        ACTION_FIELD.put(Action.END, "");
+    }
+
+    public static final long DEF_ACTION_VALUE = (long) 0;
+    public static final long NO_ACTION_VALUE  = (long) -1;
+
+    public NicRuleAction(Action actionType, long actionValue) {
+        checkNotNull(actionType, "NIC rule action type is NULL");
+        checkArgument(actionValue >= 0,
+            "NIC rule action " + actionType + " requires an action value");
+
+        this.actionType = actionType;
+        this.actionValue = actionValue;
+    }
+
+    public NicRuleAction(Action actionType) {
+        checkNotNull(actionType, "NIC rule action type is NULL");
+
+        this.actionType = actionType;
+        this.actionValue = NO_ACTION_VALUE;
+    }
+
+    /**
+     * Returns the NIC's action type associated with a rule.
+     *
+     * @return NIC's rule action type
+     */
+    public Action actionType() {
+        return actionType;
+    }
+
+    /**
+     * Returns the NIC's action value associated with a rule.
+     *
+     * @return NIC's rule action value
+     */
+    public long actionValue() {
+        return actionValue;
+    }
+
+    /**
+     * Returns the NIC's action field associated with its action type.
+     *
+     * @return NIC's rule action field
+     */
+    public String actionField() {
+        return ACTION_FIELD.get(actionType);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(actionType, actionValue);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+
+        if (obj instanceof NicRuleAction) {
+            NicRuleAction that = (NicRuleAction) obj;
+            return  Objects.equals(actionType, that.actionType) &&
+                    Objects.equals(actionValue, that.actionValue);
+        }
+
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return toStringHelper(this)
+                .add("NIC rule action type", actionType())
+                .add("NIC rule action value", actionValue())
+                .toString();
+    }
+
+}
diff --git a/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/NicRuleScope.java b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/NicRuleScope.java
new file mode 100644
index 0000000..e9a89db
--- /dev/null
+++ b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/NicRuleScope.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2018-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.server.devices.nic;
+
+import com.google.common.base.Strings;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+
+/**
+* Definition of network interface card's (NIC) rule's scope.
+*/
+public enum NicRuleScope {
+    /**
+     * A NIC rules is applied to the ingress traffic.
+     */
+    INGRESS("ingress"),
+    /**
+     * A NIC rules is applied to the egress traffic.
+     */
+    EGRESS("egress");
+
+    protected String scope;
+
+    private NicRuleScope(String scope) {
+        checkArgument(!Strings.isNullOrEmpty(scope),
+            "NIC rule scope is NULL or empty");
+        this.scope = scope.toLowerCase();
+    }
+
+    @Override
+    public String toString() {
+        return scope;
+    }
+
+}
diff --git a/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/RssRxFilterValue.java b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/RssRxFilterValue.java
new file mode 100644
index 0000000..08f2a46
--- /dev/null
+++ b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/RssRxFilterValue.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2018-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.server.devices.nic;
+
+import java.util.Objects;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+/**
+ * A Receice-Side Scaling (RSS)-based Rx filter value.
+ */
+public final class RssRxFilterValue extends RxFilterValue implements Comparable {
+
+    private int rssHash;
+
+    /**
+     * Constructs an RSS-based Rx filter.
+     */
+    public RssRxFilterValue() {
+        super();
+        setValue(0);
+    }
+
+    /**
+     * Constructs an RSS-based Rx filter with specific hash.
+     *
+     * @param rssHash a hash value
+     */
+    public RssRxFilterValue(int rssHash) {
+        super();
+        setValue(rssHash);
+    }
+
+    /**
+     * Constructs an RSS-based Rx filter out of an existing one.
+     *
+     * @param other a source RssRxFilterValue object
+     */
+    public RssRxFilterValue(RssRxFilterValue other) {
+        super();
+        setValue(other.value());
+    }
+
+    /**
+     * Returns the value of this Rx filter.
+     *
+     * @return Flow rule as a string
+     */
+    public int value() {
+        return this.rssHash;
+    }
+
+    /**
+     * Sets the value of this Rx filter.
+     *
+     * @param rssHash the RSS hash
+     */
+    public void setValue(int rssHash) {
+        checkArgument(rssHash >= 0, "Invalid RSS Rx filter " + rssHash);
+        this.rssHash = rssHash;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.rssHash);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+
+        if ((obj == null) || (!(obj instanceof RssRxFilterValue))) {
+            return false;
+        }
+
+        RssRxFilterValue other = (RssRxFilterValue) obj;
+
+        return this.value() == other.value();
+    }
+
+    @Override
+    public int compareTo(Object other) {
+        if (this == other) {
+            return 0;
+        }
+
+        if (other == null) {
+            return -1;
+        }
+
+        if (other instanceof RssRxFilterValue) {
+            RssRxFilterValue otherRxVal = (RssRxFilterValue) other;
+
+            int thisHash  = this.value();
+            int otherHash = otherRxVal.value();
+
+            if (thisHash > otherHash) {
+                return 1;
+            } else if (thisHash < otherHash) {
+                return -1;
+            } else {
+                return 0;
+            }
+        }
+
+        return -1;
+    }
+
+    @Override
+    public String toString() {
+        return Integer.toString(this.value());
+    }
+
+}
diff --git a/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/VlanRxFilterValue.java b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/VlanRxFilterValue.java
index 86cec25..18a99be 100644
--- a/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/VlanRxFilterValue.java
+++ b/drivers/server/src/main/java/org/onosproject/drivers/server/devices/nic/VlanRxFilterValue.java
@@ -28,16 +28,29 @@
 
     private VlanId vlanId;
 
+    /**
+     * Constructs a VLAN-based Rx filter.
+     */
     public VlanRxFilterValue() {
         super();
         this.vlanId = VlanId.NONE;
     }
 
+    /**
+     * Constructs a VLAN-based Rx filter with specific ID.
+     *
+     * @param vlanId a VLAN ID to use as a filter
+     */
     public VlanRxFilterValue(VlanId vlanId) {
         super();
         setValue(vlanId);
     }
 
+    /**
+     * Constructs a VLAN-based Rx filter out of an existing one.
+     *
+     * @param other a source VlanRxFilterValue object
+     */
     public VlanRxFilterValue(VlanRxFilterValue other) {
         super();
         setValue(other.value());
@@ -59,7 +72,6 @@
      */
     public void setValue(VlanId vlanId) {
         checkNotNull(vlanId, "VLAN ID of Rx filter is NULL");
-
         this.vlanId = vlanId;
     }
 
diff --git a/drivers/server/src/main/resources/server-drivers.xml b/drivers/server/src/main/resources/server-drivers.xml
index 3c97a9d..9058fa1 100644
--- a/drivers/server/src/main/resources/server-drivers.xml
+++ b/drivers/server/src/main/resources/server-drivers.xml
@@ -33,6 +33,9 @@
 
         <behaviour api="org.onosproject.drivers.server.behavior.MonitoringStatisticsDiscovery"
                    impl="org.onosproject.drivers.server.ServerDevicesDiscovery"/>
+
+        <behaviour api="org.onosproject.net.flow.FlowRuleProgrammable"
+                   impl="org.onosproject.drivers.server.FlowRuleProgrammableServerImpl"/>
     </driver>
 </drivers>