diff --git a/protocols/bmv2/ctl/pom.xml b/protocols/bmv2/ctl/pom.xml
new file mode 100644
index 0000000..5e8ae37
--- /dev/null
+++ b/protocols/bmv2/ctl/pom.xml
@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ Copyright 2016-present Open Networking Laboratory
+  ~
+  ~ 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.
+  -->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>onos-bmv2-protocol</artifactId>
+        <groupId>org.onosproject</groupId>
+        <version>1.6.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>onos-bmv2-protocol-ctl</artifactId>
+
+    <packaging>bundle</packaging>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.thrift</groupId>
+            <artifactId>libthrift</artifactId>
+            <version>0.9.3</version>
+        </dependency>
+        <dependency>
+            <groupId>org.onosproject</groupId>
+            <artifactId>onos-bmv2-protocol-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.onosproject</groupId>
+            <artifactId>onos-bmv2-protocol-thrift-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.felix</groupId>
+            <artifactId>org.apache.felix.scr.annotations</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.onosproject</groupId>
+            <artifactId>onos-core-serializers</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.felix</groupId>
+                <artifactId>maven-scr-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.onosproject</groupId>
+                <artifactId>onos-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+
+
+</project>
\ No newline at end of file
diff --git a/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2ControllerImpl.java b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2ControllerImpl.java
new file mode 100644
index 0000000..caee250
--- /dev/null
+++ b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2ControllerImpl.java
@@ -0,0 +1,327 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.bmv2.ctl;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.google.common.cache.RemovalListener;
+import com.google.common.cache.RemovalNotification;
+import com.google.common.collect.Maps;
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.apache.felix.scr.annotations.Service;
+import org.apache.thrift.TException;
+import org.apache.thrift.TProcessor;
+import org.apache.thrift.protocol.TBinaryProtocol;
+import org.apache.thrift.protocol.TMultiplexedProtocol;
+import org.apache.thrift.protocol.TProtocol;
+import org.apache.thrift.server.TThreadPoolServer;
+import org.apache.thrift.transport.TServerSocket;
+import org.apache.thrift.transport.TServerTransport;
+import org.apache.thrift.transport.TSocket;
+import org.apache.thrift.transport.TTransport;
+import org.apache.thrift.transport.TTransportException;
+import org.onlab.util.ImmutableByteSequence;
+import org.onosproject.bmv2.api.service.Bmv2Controller;
+import org.onosproject.bmv2.api.runtime.Bmv2Device;
+import org.onosproject.bmv2.api.runtime.Bmv2DeviceAgent;
+import org.onosproject.bmv2.api.service.Bmv2DeviceListener;
+import org.onosproject.bmv2.api.service.Bmv2PacketListener;
+import org.onosproject.bmv2.api.runtime.Bmv2RuntimeException;
+import org.onosproject.bmv2.thriftapi.ControlPlaneService;
+import org.onosproject.bmv2.thriftapi.SimpleSwitch;
+import org.onosproject.bmv2.thriftapi.Standard;
+import org.onosproject.core.CoreService;
+import org.onosproject.net.DeviceId;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.ByteBuffer;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.onlab.util.Tools.groupedThreads;
+
+/**
+ * Default implementation of a BMv2 controller.
+ */
+@Component(immediate = true)
+@Service
+public class Bmv2ControllerImpl implements Bmv2Controller {
+
+    private static final String APP_ID = "org.onosproject.bmv2";
+
+    // Seconds after a client is expired (and connection closed) in the cache.
+    private static final int CLIENT_CACHE_TIMEOUT = 60;
+    // Number of connection retries after a network error.
+    private static final int NUM_CONNECTION_RETRIES = 2;
+    // Time between retries in milliseconds.
+    private static final int TIME_BETWEEN_RETRIES = 10;
+
+    private final Logger log = LoggerFactory.getLogger(this.getClass());
+
+    // Cache where clients are removed after a predefined timeout.
+    private final LoadingCache<DeviceId, Pair<TTransport, Bmv2DeviceThriftClient>> agentCache =
+            CacheBuilder.newBuilder()
+                    .expireAfterAccess(CLIENT_CACHE_TIMEOUT, TimeUnit.SECONDS)
+                    .removalListener(new ClientRemovalListener())
+                    .build(new ClientLoader());
+
+    private final InternalTrackingProcessor trackingProcessor = new InternalTrackingProcessor();
+
+    private final ExecutorService executorService = Executors
+            .newFixedThreadPool(16, groupedThreads("onos/bmv2", "controller", log));
+
+    private final Set<Bmv2DeviceListener> deviceListeners = new CopyOnWriteArraySet<>();
+    private final Set<Bmv2PacketListener> packetListeners = new CopyOnWriteArraySet<>();
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected CoreService coreService;
+
+    private TThreadPoolServer thriftServer;
+
+    // TODO: make it configurable trough component config
+    private int serverPort = DEFAULT_PORT;
+
+    @Activate
+    public void activate() {
+        coreService.registerApplication(APP_ID);
+        startServer(serverPort);
+        log.info("Activated");
+    }
+
+    @Deactivate
+    public void deactivate() {
+        stopServer();
+        log.info("Deactivated");
+    }
+
+    private void startServer(int port) {
+        try {
+            TServerTransport transport = new TServerSocket(port);
+            log.info("Starting server on port {}...", port);
+            this.thriftServer = new TThreadPoolServer(new TThreadPoolServer.Args(transport)
+                                                              .processor(trackingProcessor)
+                                                              .executorService(executorService));
+            executorService.execute(thriftServer::serve);
+        } catch (TTransportException e) {
+            log.error("Unable to start server", e);
+        }
+    }
+
+    private void stopServer() {
+        // Stop the server if running...
+        if (thriftServer != null && !thriftServer.isServing()) {
+            thriftServer.stop();
+        }
+        try {
+            executorService.shutdown();
+            executorService.awaitTermination(5, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+            List<Runnable> runningTasks = executorService.shutdownNow();
+            log.warn("Unable to stop server threads: {}", runningTasks);
+        }
+    }
+
+    @Override
+    public Bmv2DeviceAgent getAgent(DeviceId deviceId) throws Bmv2RuntimeException {
+        try {
+            checkNotNull(deviceId, "deviceId cannot be null");
+            return agentCache.get(deviceId).getRight();
+        } catch (ExecutionException e) {
+            throw new Bmv2RuntimeException(e);
+        }
+    }
+
+    @Override
+    public boolean isReacheable(DeviceId deviceId) {
+        try {
+            return getAgent(deviceId).ping();
+        } catch (Bmv2RuntimeException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public void addDeviceListener(Bmv2DeviceListener listener) {
+        if (!deviceListeners.contains(listener)) {
+            deviceListeners.add(listener);
+        }
+    }
+
+    @Override
+    public void removeDeviceListener(Bmv2DeviceListener listener) {
+        deviceListeners.remove(listener);
+    }
+
+    @Override
+    public void addPacketListener(Bmv2PacketListener listener) {
+        if (!packetListeners.contains(listener)) {
+            packetListeners.add(listener);
+        }
+    }
+
+    @Override
+    public void removePacketListener(Bmv2PacketListener listener) {
+        packetListeners.remove(listener);
+    }
+
+    /**
+     * Client cache removal listener. Close the connection on cache removal.
+     */
+    private static class ClientRemovalListener implements
+            RemovalListener<DeviceId, Pair<TTransport, Bmv2DeviceThriftClient>> {
+
+        @Override
+        public void onRemoval(RemovalNotification<DeviceId, Pair<TTransport, Bmv2DeviceThriftClient>> notification) {
+            // close the transport connection
+            Bmv2DeviceThriftClient client = notification.getValue().getRight();
+            TTransport transport = notification.getValue().getLeft();
+            // Locking here is ugly, but needed (see SafeThriftClient).
+            synchronized (transport) {
+                if (transport.isOpen()) {
+                    transport.close();
+                }
+            }
+        }
+    }
+
+    /**
+     * Handles Thrift calls from BMv2 devices using registered listeners.
+     */
+    private final class InternalServiceHandler implements ControlPlaneService.Iface {
+
+        private final TSocket socket;
+        private Bmv2Device remoteDevice;
+
+        private InternalServiceHandler(TSocket socket) {
+            this.socket = socket;
+        }
+
+        @Override
+        public boolean ping() {
+            return true;
+        }
+
+        @Override
+        public void hello(int thriftServerPort, int deviceId, int instanceId, String jsonConfigMd5) {
+            // Locally note the remote device for future uses.
+            String host = socket.getSocket().getInetAddress().getHostAddress();
+            remoteDevice = new Bmv2Device(host, thriftServerPort, deviceId);
+
+            if (deviceListeners.size() == 0) {
+                log.debug("Received hello, but there's no listener registered.");
+            } else {
+                deviceListeners.forEach(
+                        l -> executorService.execute(() -> l.handleHello(remoteDevice, instanceId, jsonConfigMd5)));
+            }
+        }
+
+        @Override
+        public void packetIn(int port, long reason, int tableId, int contextId, ByteBuffer packet) {
+            if (remoteDevice == null) {
+                log.debug("Received packet-in, but the remote device is still unknown. Need a hello first...");
+                return;
+            }
+
+            if (packetListeners.size() == 0) {
+                log.debug("Received packet-in, but there's no listener registered.");
+            } else {
+                packetListeners.forEach(
+                        l -> executorService.execute(() -> l.handlePacketIn(remoteDevice,
+                                                                            port,
+                                                                            reason,
+                                                                            tableId,
+                                                                            contextId,
+                                                                            ImmutableByteSequence.copyFrom(packet))));
+            }
+        }
+    }
+
+    /**
+     * Thrift Processor decorator. This class is needed in order to have access to the socket when handling a call.
+     * Socket is needed to get the IP address of the client originating the call (see InternalServiceHandler.hello())
+     */
+    private final class InternalTrackingProcessor implements TProcessor {
+
+        // Map sockets to processors.
+        // TODO: implement it as a cache so unused sockets are expired automatically
+        private final ConcurrentMap<TSocket, ControlPlaneService.Processor<InternalServiceHandler>> processors =
+                Maps.newConcurrentMap();
+
+        @Override
+        public boolean process(final TProtocol in, final TProtocol out) throws TException {
+            // Get the socket for this request.
+            TSocket socket = (TSocket) in.getTransport();
+            // Get or create a processor for this socket
+            ControlPlaneService.Processor<InternalServiceHandler> processor = processors.computeIfAbsent(socket, s -> {
+                InternalServiceHandler handler = new InternalServiceHandler(s);
+                return new ControlPlaneService.Processor<>(handler);
+            });
+            // Delegate to the processor we are decorating.
+            return processor.process(in, out);
+        }
+    }
+
+    /**
+     * Transport/client cache loader.
+     */
+    private class ClientLoader extends CacheLoader<DeviceId, Pair<TTransport, Bmv2DeviceThriftClient>> {
+
+        private final SafeThriftClient.Options options = new SafeThriftClient.Options(NUM_CONNECTION_RETRIES,
+                                                                                      TIME_BETWEEN_RETRIES);
+
+        @Override
+        public Pair<TTransport, Bmv2DeviceThriftClient> load(DeviceId deviceId)
+                throws TTransportException {
+            log.debug("Instantiating new client... > deviceId={}", deviceId);
+            // Make the expensive call
+            Bmv2Device device = Bmv2Device.of(deviceId);
+            TTransport transport = new TSocket(device.thriftServerHost(), device.thriftServerPort());
+            TProtocol protocol = new TBinaryProtocol(transport);
+            // Our BMv2 device implements multiple Thrift services, create a client for each one on the same transport.
+            Standard.Client standardClient = new Standard.Client(
+                    new TMultiplexedProtocol(protocol, "standard"));
+            SimpleSwitch.Client simpleSwitch = new SimpleSwitch.Client(
+                    new TMultiplexedProtocol(protocol, "simple_switch"));
+            // Wrap clients so to automatically have synchronization and resiliency to connectivity errors
+            Standard.Iface safeStandardClient = SafeThriftClient.wrap(standardClient,
+                                                                      Standard.Iface.class,
+                                                                      options);
+            SimpleSwitch.Iface safeSimpleSwitchClient = SafeThriftClient.wrap(simpleSwitch,
+                                                                              SimpleSwitch.Iface.class,
+                                                                              options);
+            Bmv2DeviceThriftClient client = new Bmv2DeviceThriftClient(deviceId,
+                                                                       transport,
+                                                                       safeStandardClient,
+                                                                       safeSimpleSwitchClient);
+            return Pair.of(transport, client);
+        }
+    }
+}
diff --git a/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2DefaultInterpreterImpl.java b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2DefaultInterpreterImpl.java
new file mode 100644
index 0000000..f5e95df
--- /dev/null
+++ b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2DefaultInterpreterImpl.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.bmv2.ctl;
+
+import com.google.common.collect.ImmutableBiMap;
+import org.onlab.util.ImmutableByteSequence;
+import org.onosproject.bmv2.api.context.Bmv2Configuration;
+import org.onosproject.bmv2.api.context.Bmv2Interpreter;
+import org.onosproject.bmv2.api.context.Bmv2InterpreterException;
+import org.onosproject.bmv2.api.runtime.Bmv2Action;
+import org.onosproject.bmv2.api.utils.Bmv2TranslatorUtils;
+import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.net.flow.criteria.Criterion;
+import org.onosproject.net.flow.instructions.Instruction;
+
+import static org.onosproject.net.PortNumber.CONTROLLER;
+import static org.onosproject.net.flow.instructions.Instructions.OutputInstruction;
+
+/**
+ * Implementation of a BMv2 interpreter for the BMv2 default.json configuration.
+ */
+public final class Bmv2DefaultInterpreterImpl implements Bmv2Interpreter {
+
+    public static final String TABLE0 = "table0";
+    public static final String SEND_TO_CPU = "send_to_cpu";
+    public static final String DROP = "_drop";
+    public static final String SET_EGRESS_PORT = "set_egress_port";
+
+    // Lazily populate field map.
+    private static final ImmutableBiMap<Criterion.Type, String> CRITERION_MAP = ImmutableBiMap.of(
+            Criterion.Type.IN_PORT, "standard_metadata.ingress_port",
+            Criterion.Type.ETH_DST, "ethernet.dstAddr",
+            Criterion.Type.ETH_SRC, "ethernet.srcAddr",
+            Criterion.Type.ETH_TYPE, "ethernet.etherType");
+
+    private static final ImmutableBiMap<Integer, String> TABLE_MAP = ImmutableBiMap.of(
+            0, TABLE0);
+
+    @Override
+    public ImmutableBiMap<Criterion.Type, String> criterionTypeMap() {
+        return CRITERION_MAP;
+    }
+
+    @Override
+    public ImmutableBiMap<Integer, String> tableIdMap() {
+        return TABLE_MAP;
+    }
+
+    @Override
+    public Bmv2Action mapTreatment(TrafficTreatment treatment, Bmv2Configuration configuration)
+            throws Bmv2InterpreterException {
+
+
+        if (treatment.allInstructions().size() == 0) {
+            // No instructions means drop for us.
+            return Bmv2Action.builder().withName(DROP).build();
+        } else if (treatment.allInstructions().size() > 1) {
+            // Otherwise, we understand treatments with only 1 instruction.
+            throw new Bmv2InterpreterException("Treatment has multiple instructions");
+        }
+
+        Instruction instruction = treatment.allInstructions().get(0);
+
+        switch (instruction.type()) {
+            case OUTPUT:
+                OutputInstruction outInstruction = (OutputInstruction) instruction;
+                if (outInstruction.port() == CONTROLLER) {
+                    return Bmv2Action.builder().withName(SEND_TO_CPU).build();
+                } else {
+                    return buildEgressAction(outInstruction, configuration);
+                }
+            case NOACTION:
+                return Bmv2Action.builder().withName(DROP).build();
+            default:
+                throw new Bmv2InterpreterException("Instruction type not supported: " + instruction.type().name());
+        }
+    }
+
+
+    /**
+     * Builds an egress action equivalent to the given output instruction for the given configuration.
+     *
+     * @param instruction   an output instruction
+     * @param configuration a configuration
+     * @return a BMv2 action
+     * @throws Bmv2InterpreterException if the instruction cannot be translated to a BMv2 action
+     */
+    private Bmv2Action buildEgressAction(OutputInstruction instruction, Bmv2Configuration configuration)
+            throws Bmv2InterpreterException {
+
+        Bmv2Action.Builder actionBuilder = Bmv2Action.builder();
+
+        actionBuilder.withName(SET_EGRESS_PORT);
+
+        if (instruction.port().isLogical()) {
+            throw new Bmv2InterpreterException("Output on logic port not supported: " + instruction);
+        }
+
+        // Get the byte sequence for the out port with the right length
+        long portNumber = instruction.port().toLong();
+        int bitWidth = configuration.action(SET_EGRESS_PORT).runtimeData("port").bitWidth();
+        try {
+            ImmutableByteSequence outPort = Bmv2TranslatorUtils.fitByteSequence(
+                    ImmutableByteSequence.copyFrom(portNumber), bitWidth);
+            return Bmv2Action.builder().withName(SET_EGRESS_PORT).addParameter(outPort).build();
+        } catch (Bmv2TranslatorUtils.ByteSequenceFitException e) {
+            throw new Bmv2InterpreterException(e.getMessage());
+        }
+    }
+}
diff --git a/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2DeviceContextServiceImpl.java b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2DeviceContextServiceImpl.java
new file mode 100644
index 0000000..bcdb939
--- /dev/null
+++ b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2DeviceContextServiceImpl.java
@@ -0,0 +1,238 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.bmv2.ctl;
+
+import com.eclipsesource.json.Json;
+import com.eclipsesource.json.JsonObject;
+import com.esotericsoftware.kryo.Kryo;
+import com.esotericsoftware.kryo.io.Input;
+import com.esotericsoftware.kryo.io.Output;
+import com.google.common.collect.Maps;
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.apache.felix.scr.annotations.Service;
+import org.onlab.util.KryoNamespace;
+import org.onlab.util.SharedExecutors;
+import org.onosproject.bmv2.api.context.Bmv2Configuration;
+import org.onosproject.bmv2.api.context.Bmv2DefaultConfiguration;
+import org.onosproject.bmv2.api.context.Bmv2DeviceContext;
+import org.onosproject.bmv2.api.context.Bmv2Interpreter;
+import org.onosproject.bmv2.api.runtime.Bmv2DeviceAgent;
+import org.onosproject.bmv2.api.runtime.Bmv2RuntimeException;
+import org.onosproject.bmv2.api.service.Bmv2Controller;
+import org.onosproject.bmv2.api.service.Bmv2DeviceContextService;
+import org.onosproject.net.DeviceId;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.ConsistentMap;
+import org.onosproject.store.service.Serializer;
+import org.onosproject.store.service.StorageService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+@Component(immediate = true)
+@Service
+public class Bmv2DeviceContextServiceImpl implements Bmv2DeviceContextService {
+
+    private static final String JSON_DEFAULT_CONFIG_PATH = "/default.json";
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    private StorageService storageService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    private Bmv2Controller controller;
+
+    private final ExecutorService executorService = SharedExecutors.getPoolThreadExecutor();
+
+    private ConsistentMap<DeviceId, Bmv2DeviceContext> contexts;
+    private Map<DeviceId, Bmv2DeviceContext> contextsMap;
+
+    private Map<String, ClassLoader> interpreterClassLoaders;
+
+    private Bmv2DeviceContext defaultContext;
+
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    @Activate
+    public void activate() {
+        KryoNamespace kryo = new KryoNamespace.Builder()
+                .register(KryoNamespaces.API)
+                .register(new BmvDeviceContextSerializer(), Bmv2DeviceContext.class)
+                .build();
+
+        this.contexts = storageService.<DeviceId, Bmv2DeviceContext>consistentMapBuilder()
+                .withSerializer(Serializer.using(kryo))
+                .withName("onos-bmv2-contexts")
+                .build();
+        contextsMap = contexts.asJavaMap();
+
+        interpreterClassLoaders = Maps.newConcurrentMap();
+
+        Bmv2Configuration defaultConfiguration = loadDefaultConfiguration();
+        Bmv2Interpreter defaultInterpreter = new Bmv2DefaultInterpreterImpl();
+        defaultContext = new Bmv2DeviceContext(defaultConfiguration, defaultInterpreter);
+
+        interpreterClassLoaders.put(defaultInterpreter.getClass().getName(), this.getClass().getClassLoader());
+
+        log.info("Started");
+    }
+
+    @Deactivate
+    public void deactivate() {
+        log.info("Stopped");
+    }
+
+    @Override
+    public Bmv2DeviceContext getContext(DeviceId deviceId) {
+        checkNotNull(deviceId, "device id cannot be null");
+        return contextsMap.get(deviceId);
+    }
+
+    @Override
+    public void triggerConfigurationSwap(DeviceId deviceId, Bmv2DeviceContext context) {
+        checkNotNull(deviceId, "device id cannot be null");
+        checkNotNull(context, "context cannot be null");
+        if (!interpreterClassLoaders.containsKey(context.interpreter().getClass().getName())) {
+            log.error("Unable to trigger configuration swap, missing class loader for context interpreter. " +
+                              "Please register it with registerInterpreterClassLoader()");
+        } else {
+            executorService.execute(() -> executeConfigurationSwap(deviceId, context));
+        }
+    }
+
+    @Override
+    public void registerInterpreterClassLoader(Class<? extends Bmv2Interpreter> interpreterClass, ClassLoader loader) {
+        interpreterClassLoaders.put(interpreterClass.getName(), loader);
+    }
+
+    private void executeConfigurationSwap(DeviceId deviceId, Bmv2DeviceContext context) {
+        contexts.compute(deviceId, (key, existingValue) -> {
+            if (context.equals(existingValue)) {
+                log.info("Dropping swap request as one has already been triggered for the given context.");
+                return existingValue;
+            }
+            try {
+                Bmv2DeviceAgent agent = controller.getAgent(deviceId);
+                String jsonString = context.configuration().json().toString();
+                agent.loadNewJsonConfig(jsonString);
+                agent.swapJsonConfig();
+                return context;
+            } catch (Bmv2RuntimeException e) {
+                log.error("Unable to swap configuration on {}: {}", deviceId, e.explain());
+                return existingValue;
+            }
+        });
+    }
+
+    @Override
+    public boolean notifyDeviceChange(DeviceId deviceId) {
+        checkNotNull(deviceId, "device id cannot be null");
+
+        Bmv2DeviceContext storedContext = getContext(deviceId);
+
+        if (storedContext == null) {
+            log.info("No context previously stored for {}, swapping to DEFAULT_CONTEXT.", deviceId);
+            triggerConfigurationSwap(deviceId, defaultContext);
+            // Device can be accepted.
+            return false;
+        } else {
+            Bmv2Configuration deviceConfiguration = loadDeviceConfiguration(deviceId);
+            if (deviceConfiguration == null) {
+                log.warn("Unable to load configuration from device {}", deviceId);
+                return false;
+            }
+            if (storedContext.configuration().equals(deviceConfiguration)) {
+                return true;
+            } else {
+                log.info("Device context is different from the stored one, triggering configuration swap for {}...",
+                         deviceId);
+                triggerConfigurationSwap(deviceId, storedContext);
+                return false;
+            }
+        }
+    }
+
+    /**
+     * Load and parse a BMv2 JSON configuration from the given device.
+     *
+     * @param deviceId a device id
+     * @return a BMv2 configuration
+     */
+    private Bmv2Configuration loadDeviceConfiguration(DeviceId deviceId) {
+        try {
+            String jsonString = controller.getAgent(deviceId).dumpJsonConfig();
+            return Bmv2DefaultConfiguration.parse(Json.parse(jsonString).asObject());
+        } catch (Bmv2RuntimeException e) {
+            log.warn("Unable to load JSON configuration from {}: {}", deviceId, e.explain());
+            return null;
+        }
+    }
+
+    /**
+     * Loads default configuration from file.
+     *
+     * @return a BMv2 configuration
+     */
+    protected static Bmv2DefaultConfiguration loadDefaultConfiguration() {
+        try {
+            JsonObject json = Json.parse(new BufferedReader(new InputStreamReader(
+                    Bmv2DeviceContextServiceImpl.class.getResourceAsStream(JSON_DEFAULT_CONFIG_PATH)))).asObject();
+            return Bmv2DefaultConfiguration.parse(json);
+        } catch (IOException e) {
+            throw new RuntimeException("Unable to load default configuration", e);
+        }
+    }
+
+    /**
+     * Internal BMv2 context serializer.
+     */
+    private class BmvDeviceContextSerializer extends com.esotericsoftware.kryo.Serializer<Bmv2DeviceContext> {
+
+        @Override
+        public void write(Kryo kryo, Output output, Bmv2DeviceContext context) {
+            kryo.writeObject(output, context.configuration().json().toString());
+            kryo.writeObject(output, context.interpreter().getClass().getName());
+        }
+
+        @Override
+        public Bmv2DeviceContext read(Kryo kryo, Input input, Class<Bmv2DeviceContext> type) {
+            String jsonStr = kryo.readObject(input, String.class);
+            String interpreterClassName = kryo.readObject(input, String.class);
+            Bmv2Configuration configuration = Bmv2DefaultConfiguration.parse(Json.parse(jsonStr).asObject());
+            ClassLoader loader = interpreterClassLoaders.get(interpreterClassName);
+            if (loader == null) {
+                throw new IllegalStateException("No class loader registered for interpreter: " + interpreterClassName);
+            }
+            try {
+                Bmv2Interpreter interpreter = (Bmv2Interpreter) loader.loadClass(interpreterClassName).newInstance();
+                return new Bmv2DeviceContext(configuration, interpreter);
+            } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
+                throw new RuntimeException("Unable to load interpreter class", e);
+            }
+        }
+    }
+}
diff --git a/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2DeviceThriftClient.java b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2DeviceThriftClient.java
new file mode 100644
index 0000000..ae852c3
--- /dev/null
+++ b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2DeviceThriftClient.java
@@ -0,0 +1,428 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.bmv2.ctl;
+
+import com.google.common.collect.Lists;
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.thrift.TException;
+import org.apache.thrift.transport.TTransport;
+import org.onlab.util.ImmutableByteSequence;
+import org.onosproject.bmv2.api.runtime.Bmv2Action;
+import org.onosproject.bmv2.api.runtime.Bmv2DeviceAgent;
+import org.onosproject.bmv2.api.runtime.Bmv2ExactMatchParam;
+import org.onosproject.bmv2.api.runtime.Bmv2LpmMatchParam;
+import org.onosproject.bmv2.api.runtime.Bmv2MatchKey;
+import org.onosproject.bmv2.api.runtime.Bmv2PortInfo;
+import org.onosproject.bmv2.api.runtime.Bmv2RuntimeException;
+import org.onosproject.bmv2.api.runtime.Bmv2TableEntry;
+import org.onosproject.bmv2.api.runtime.Bmv2TernaryMatchParam;
+import org.onosproject.bmv2.api.runtime.Bmv2ValidMatchParam;
+import org.onosproject.bmv2.thriftapi.BmAddEntryOptions;
+import org.onosproject.bmv2.thriftapi.BmCounterValue;
+import org.onosproject.bmv2.thriftapi.BmMatchParam;
+import org.onosproject.bmv2.thriftapi.BmMatchParamExact;
+import org.onosproject.bmv2.thriftapi.BmMatchParamLPM;
+import org.onosproject.bmv2.thriftapi.BmMatchParamTernary;
+import org.onosproject.bmv2.thriftapi.BmMatchParamType;
+import org.onosproject.bmv2.thriftapi.BmMatchParamValid;
+import org.onosproject.bmv2.thriftapi.SimpleSwitch;
+import org.onosproject.bmv2.thriftapi.Standard;
+import org.onosproject.net.DeviceId;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.onosproject.bmv2.ctl.Bmv2TExceptionParser.parseTException;
+
+/**
+ * Implementation of a Thrift client to control a BMv2 device.
+ */
+public final class Bmv2DeviceThriftClient implements Bmv2DeviceAgent {
+
+    private final Logger log = LoggerFactory.getLogger(this.getClass());
+
+    // FIXME: make context_id arbitrary for each call
+    // See: https://github.com/p4lang/behavioral-model/blob/master/modules/bm_sim/include/bm_sim/context.h
+    private static final int CONTEXT_ID = 0;
+
+    private final Standard.Iface standardClient;
+    private final SimpleSwitch.Iface simpleSwitchClient;
+    private final TTransport transport;
+    private final DeviceId deviceId;
+
+    // ban constructor
+    protected Bmv2DeviceThriftClient(DeviceId deviceId, TTransport transport, Standard.Iface standardClient,
+                                     SimpleSwitch.Iface simpleSwitchClient) {
+        this.deviceId = deviceId;
+        this.transport = transport;
+        this.standardClient = standardClient;
+        this.simpleSwitchClient = simpleSwitchClient;
+    }
+
+    @Override
+    public DeviceId deviceId() {
+        return deviceId;
+    }
+
+    @Override
+    public boolean ping() {
+        try {
+            return this.simpleSwitchClient.ping();
+        } catch (TException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public final long addTableEntry(Bmv2TableEntry entry) throws Bmv2RuntimeException {
+
+        log.debug("Adding table entry... > deviceId={}, entry={}", deviceId, entry);
+
+        long entryId = -1;
+
+        try {
+            BmAddEntryOptions options = new BmAddEntryOptions();
+
+            if (entry.hasPriority()) {
+                options.setPriority(entry.priority());
+            }
+
+            entryId = standardClient.bm_mt_add_entry(
+                    CONTEXT_ID,
+                    entry.tableName(),
+                    buildMatchParamsList(entry.matchKey()),
+                    entry.action().name(),
+                    buildActionParamsList(entry.action()),
+                    options);
+
+            if (entry.hasTimeout()) {
+                /* bmv2 accepts timeouts in milliseconds */
+                int msTimeout = (int) Math.round(entry.timeout() * 1_000);
+                standardClient.bm_mt_set_entry_ttl(
+                        CONTEXT_ID, entry.tableName(), entryId, msTimeout);
+            }
+
+            log.debug("Table entry added! > deviceId={}, entryId={}/{}", deviceId, entry.tableName(), entryId);
+
+            return entryId;
+
+        } catch (TException e) {
+            log.debug("Exception while adding table entry: {} > deviceId={}, tableName={}",
+                      e, deviceId, entry.tableName());
+            if (entryId != -1) {
+                // entry is in inconsistent state (unable to add timeout), remove it
+                try {
+                    deleteTableEntry(entry.tableName(), entryId);
+                } catch (Bmv2RuntimeException e1) {
+                    log.debug("Unable to remove failed table entry: {} > deviceId={}, tableName={}",
+                              e1, deviceId, entry.tableName());
+                }
+            }
+            throw parseTException(e);
+        }
+    }
+
+    @Override
+    public final void modifyTableEntry(String tableName,
+                                       long entryId, Bmv2Action action)
+            throws Bmv2RuntimeException {
+
+        log.debug("Modifying table entry... > deviceId={}, entryId={}/{}", deviceId, tableName, entryId);
+
+        try {
+            standardClient.bm_mt_modify_entry(
+                    CONTEXT_ID,
+                    tableName,
+                    entryId,
+                    action.name(),
+                    buildActionParamsList(action));
+            log.debug("Table entry modified! > deviceId={}, entryId={}/{}", deviceId, tableName, entryId);
+        } catch (TException e) {
+            log.debug("Exception while modifying table entry: {} > deviceId={}, entryId={}/{}",
+                      e, deviceId, tableName, entryId);
+            throw parseTException(e);
+        }
+    }
+
+    @Override
+    public final void deleteTableEntry(String tableName,
+                                       long entryId) throws Bmv2RuntimeException {
+
+        log.debug("Deleting table entry... > deviceId={}, entryId={}/{}", deviceId, tableName, entryId);
+
+        try {
+            standardClient.bm_mt_delete_entry(CONTEXT_ID, tableName, entryId);
+            log.debug("Table entry deleted! > deviceId={}, entryId={}/{}", deviceId, tableName, entryId);
+        } catch (TException e) {
+            log.debug("Exception while deleting table entry: {} > deviceId={}, entryId={}/{}",
+                      e, deviceId, tableName, entryId);
+            throw parseTException(e);
+        }
+    }
+
+    @Override
+    public final void setTableDefaultAction(String tableName, Bmv2Action action)
+            throws Bmv2RuntimeException {
+
+        log.debug("Setting table default... > deviceId={}, tableName={}, action={}", deviceId, tableName, action);
+
+        try {
+            standardClient.bm_mt_set_default_action(
+                    CONTEXT_ID,
+                    tableName,
+                    action.name(),
+                    buildActionParamsList(action));
+            log.debug("Table default set! > deviceId={}, tableName={}, action={}", deviceId, tableName, action);
+        } catch (TException e) {
+            log.debug("Exception while setting table default : {} > deviceId={}, tableName={}, action={}",
+                      e, deviceId, tableName, action);
+            throw parseTException(e);
+        }
+    }
+
+    @Override
+    public Collection<Bmv2PortInfo> getPortsInfo() throws Bmv2RuntimeException {
+
+        log.debug("Retrieving port info... > deviceId={}", deviceId);
+
+        try {
+            return standardClient.bm_dev_mgr_show_ports().stream()
+                    .map(p -> new Bmv2PortInfo(p.getIface_name(), p.getPort_num(), p.isIs_up()))
+                    .collect(Collectors.toList());
+        } catch (TException e) {
+            log.debug("Exception while retrieving port info: {} > deviceId={}", e, deviceId);
+            throw parseTException(e);
+        }
+    }
+
+    @Override
+    public String dumpTable(String tableName) throws Bmv2RuntimeException {
+
+        log.debug("Retrieving table dump... > deviceId={}, tableName={}", deviceId, tableName);
+
+        try {
+            String dump = standardClient.bm_dump_table(CONTEXT_ID, tableName);
+            log.debug("Table dump retrieved! > deviceId={}, tableName={}", deviceId, tableName);
+            return dump;
+        } catch (TException e) {
+            log.debug("Exception while retrieving table dump: {} > deviceId={}, tableName={}",
+                      e, deviceId, tableName);
+            throw parseTException(e);
+        }
+    }
+
+    @Override
+    public void transmitPacket(int portNumber, ImmutableByteSequence packet) throws Bmv2RuntimeException {
+
+        log.debug("Requesting packet transmission... > portNumber={}, packetSize={}", portNumber, packet.size());
+
+        try {
+
+            simpleSwitchClient.push_packet(portNumber, ByteBuffer.wrap(packet.asArray()));
+            log.debug("Packet transmission requested! > portNumber={}, packetSize={}", portNumber, packet.size());
+        } catch (TException e) {
+            log.debug("Exception while requesting packet transmission: {} > portNumber={}, packetSize={}",
+                      e, portNumber, packet.size());
+            throw parseTException(e);
+        }
+    }
+
+    @Override
+    public void resetState() throws Bmv2RuntimeException {
+
+        log.debug("Resetting device state... > deviceId={}", deviceId);
+
+        try {
+            standardClient.bm_reset_state();
+            log.debug("Device state reset! > deviceId={}", deviceId);
+        } catch (TException e) {
+            log.debug("Exception while resetting device state: {} > deviceId={}", e, deviceId);
+            throw parseTException(e);
+        }
+    }
+
+    @Override
+    public String dumpJsonConfig() throws Bmv2RuntimeException {
+
+        log.debug("Dumping device config... > deviceId={}", deviceId);
+
+        try {
+            String config = standardClient.bm_get_config();
+            log.debug("Device config dumped! > deviceId={}, configLength={}", deviceId, config.length());
+            return config;
+        } catch (TException e) {
+            log.debug("Exception while dumping device config: {} > deviceId={}", e, deviceId);
+            throw parseTException(e);
+        }
+    }
+
+    @Override
+    public Pair<Long, Long> readTableEntryCounter(String tableName, long entryId) throws Bmv2RuntimeException {
+
+        log.debug("Reading table entry counters... > deviceId={}, tableName={}, entryId={}",
+                  deviceId, tableName, entryId);
+
+        try {
+            BmCounterValue counterValue = standardClient.bm_mt_read_counter(CONTEXT_ID, tableName, entryId);
+            log.debug("Table entry counters retrieved! > deviceId={}, tableName={}, entryId={}, bytes={}, packets={}",
+                      deviceId, tableName, entryId, counterValue.bytes, counterValue.packets);
+            return Pair.of(counterValue.bytes, counterValue.packets);
+        } catch (TException e) {
+            log.debug("Exception while reading table counters: {} > deviceId={}, tableName={}, entryId={}",
+                      e.toString(), deviceId);
+            throw parseTException(e);
+        }
+    }
+
+    @Override
+    public Pair<Long, Long> readCounter(String counterName, int index) throws Bmv2RuntimeException {
+
+        log.debug("Reading table entry counters... > deviceId={}, counterName={}, index={}",
+                  deviceId, counterName, index);
+
+        try {
+            BmCounterValue counterValue = standardClient.bm_counter_read(CONTEXT_ID, counterName, index);
+            log.debug("Table entry counters retrieved! >deviceId={}, counterName={}, index={}, bytes={}, packets={}",
+                      deviceId, counterName, index, counterValue.bytes, counterValue.packets);
+            return Pair.of(counterValue.bytes, counterValue.packets);
+        } catch (TException e) {
+            log.debug("Exception while reading table counters: {} > deviceId={}, counterName={}, index={}",
+                      e.toString(), deviceId);
+            throw parseTException(e);
+        }
+    }
+
+    @Override
+    public int getProcessInstanceId() throws Bmv2RuntimeException {
+        log.debug("Getting process instance ID... > deviceId={}", deviceId);
+        try {
+            int instanceId = simpleSwitchClient.get_process_instance_id();
+            log.debug("TProcess instance ID retrieved! > deviceId={}, instanceId={}",
+                      deviceId, instanceId);
+            return instanceId;
+        } catch (TException e) {
+            log.debug("Exception while getting process instance ID: {} > deviceId={}", e.toString(), deviceId);
+            throw parseTException(e);
+        }
+    }
+
+    @Override
+    public String getJsonConfigMd5() throws Bmv2RuntimeException {
+
+        log.debug("Getting device config md5... > deviceId={}", deviceId);
+
+        try {
+            String md5 = standardClient.bm_get_config_md5();
+            log.debug("Device config md5 received! > deviceId={}, configMd5={}", deviceId, md5);
+            return md5;
+        } catch (TException e) {
+            log.debug("Exception while getting device config md5: {} > deviceId={}", e, deviceId);
+            throw parseTException(e);
+        }
+    }
+
+    @Override
+    public void loadNewJsonConfig(String jsonString) throws Bmv2RuntimeException {
+
+        log.debug("Loading new JSON config on device... > deviceId={}, jsonStringLength={}",
+                  deviceId, jsonString.length());
+
+        try {
+            standardClient.bm_load_new_config(jsonString);
+            log.debug("JSON config loaded! > deviceId={}", deviceId);
+        } catch (TException e) {
+            log.debug("Exception while loading JSON config: {} > deviceId={}", e, deviceId);
+            throw parseTException(e);
+        }
+    }
+
+    @Override
+    public void swapJsonConfig() throws Bmv2RuntimeException {
+
+        log.debug("Swapping JSON config on device... > deviceId={}", deviceId);
+
+        try {
+            standardClient.bm_swap_configs();
+            log.debug("JSON config swapped! > deviceId={}", deviceId);
+        } catch (TException e) {
+            log.debug("Exception while swapping JSON config: {} > deviceId={}", e, deviceId);
+            throw parseTException(e);
+        }
+    }
+
+    /**
+     * Builds a list of Bmv2/Thrift compatible match parameters.
+     *
+     * @param matchKey a bmv2 matchKey
+     * @return list of thrift-compatible bm match parameters
+     */
+    private static List<BmMatchParam> buildMatchParamsList(Bmv2MatchKey matchKey) {
+        List<BmMatchParam> paramsList = Lists.newArrayList();
+        matchKey.matchParams().forEach(x -> {
+            ByteBuffer value;
+            ByteBuffer mask;
+            switch (x.type()) {
+                case EXACT:
+                    value = ByteBuffer.wrap(((Bmv2ExactMatchParam) x).value().asArray());
+                    paramsList.add(
+                            new BmMatchParam(BmMatchParamType.EXACT)
+                                    .setExact(new BmMatchParamExact(value)));
+                    break;
+                case TERNARY:
+                    value = ByteBuffer.wrap(((Bmv2TernaryMatchParam) x).value().asArray());
+                    mask = ByteBuffer.wrap(((Bmv2TernaryMatchParam) x).mask().asArray());
+                    paramsList.add(
+                            new BmMatchParam(BmMatchParamType.TERNARY)
+                                    .setTernary(new BmMatchParamTernary(value, mask)));
+                    break;
+                case LPM:
+                    value = ByteBuffer.wrap(((Bmv2LpmMatchParam) x).value().asArray());
+                    int prefixLength = ((Bmv2LpmMatchParam) x).prefixLength();
+                    paramsList.add(
+                            new BmMatchParam(BmMatchParamType.LPM)
+                                    .setLpm(new BmMatchParamLPM(value, prefixLength)));
+                    break;
+                case VALID:
+                    boolean flag = ((Bmv2ValidMatchParam) x).flag();
+                    paramsList.add(
+                            new BmMatchParam(BmMatchParamType.VALID)
+                                    .setValid(new BmMatchParamValid(flag)));
+                    break;
+                default:
+                    // should never be here
+                    throw new RuntimeException("Unknown match param type " + x.type().name());
+            }
+        });
+        return paramsList;
+    }
+
+    /**
+     * Build a list of Bmv2/Thrift compatible action parameters.
+     *
+     * @param action an action object
+     * @return list of ByteBuffers
+     */
+    private static List<ByteBuffer> buildActionParamsList(Bmv2Action action) {
+        List<ByteBuffer> buffers = Lists.newArrayList();
+        action.parameters().forEach(p -> buffers.add(ByteBuffer.wrap(p.asArray())));
+        return buffers;
+    }
+}
diff --git a/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2FlowRuleTranslatorImpl.java b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2FlowRuleTranslatorImpl.java
new file mode 100644
index 0000000..b3c1e8a
--- /dev/null
+++ b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2FlowRuleTranslatorImpl.java
@@ -0,0 +1,394 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.bmv2.ctl;
+
+import com.google.common.annotations.Beta;
+import com.google.common.collect.Sets;
+import org.onlab.util.ImmutableByteSequence;
+import org.onosproject.bmv2.api.context.Bmv2ActionModel;
+import org.onosproject.bmv2.api.context.Bmv2Configuration;
+import org.onosproject.bmv2.api.context.Bmv2DeviceContext;
+import org.onosproject.bmv2.api.context.Bmv2FieldModel;
+import org.onosproject.bmv2.api.context.Bmv2FlowRuleTranslator;
+import org.onosproject.bmv2.api.context.Bmv2FlowRuleTranslatorException;
+import org.onosproject.bmv2.api.context.Bmv2Interpreter;
+import org.onosproject.bmv2.api.context.Bmv2InterpreterException;
+import org.onosproject.bmv2.api.context.Bmv2RuntimeDataModel;
+import org.onosproject.bmv2.api.context.Bmv2TableKeyModel;
+import org.onosproject.bmv2.api.context.Bmv2TableModel;
+import org.onosproject.bmv2.api.runtime.Bmv2Action;
+import org.onosproject.bmv2.api.runtime.Bmv2ExactMatchParam;
+import org.onosproject.bmv2.api.runtime.Bmv2ExtensionSelector;
+import org.onosproject.bmv2.api.runtime.Bmv2ExtensionTreatment;
+import org.onosproject.bmv2.api.runtime.Bmv2LpmMatchParam;
+import org.onosproject.bmv2.api.runtime.Bmv2MatchKey;
+import org.onosproject.bmv2.api.runtime.Bmv2MatchParam;
+import org.onosproject.bmv2.api.runtime.Bmv2TableEntry;
+import org.onosproject.bmv2.api.runtime.Bmv2TernaryMatchParam;
+import org.onosproject.bmv2.api.utils.Bmv2TranslatorUtils;
+import org.onosproject.net.flow.FlowRule;
+import org.onosproject.net.flow.TrafficSelector;
+import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.net.flow.criteria.Criterion;
+import org.onosproject.net.flow.criteria.EthCriterion;
+import org.onosproject.net.flow.criteria.EthTypeCriterion;
+import org.onosproject.net.flow.criteria.ExtensionCriterion;
+import org.onosproject.net.flow.criteria.PortCriterion;
+import org.onosproject.net.flow.instructions.ExtensionTreatment;
+import org.onosproject.net.flow.instructions.ExtensionTreatmentType.ExtensionTreatmentTypes;
+import org.onosproject.net.flow.instructions.Instruction;
+import org.onosproject.net.flow.instructions.Instructions;
+import org.onosproject.net.flow.instructions.Instructions.ExtensionInstructionWrapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.onosproject.bmv2.api.utils.Bmv2TranslatorUtils.roundToBytes;
+import static org.onosproject.net.flow.criteria.Criterion.Type.EXTENSION;
+import static org.onosproject.net.flow.criteria.ExtensionSelectorType.ExtensionSelectorTypes.BMV2_MATCH_PARAMS;
+
+/**
+ * Default implementation of a BMv2 flow rule translator.
+ */
+@Beta
+public class Bmv2FlowRuleTranslatorImpl implements Bmv2FlowRuleTranslator {
+
+    private final Logger log = LoggerFactory.getLogger(this.getClass());
+
+    @Override
+    public Bmv2TableEntry translate(FlowRule rule, Bmv2DeviceContext context)
+            throws Bmv2FlowRuleTranslatorException {
+
+        Bmv2Configuration configuration = context.configuration();
+        Bmv2Interpreter interpreter = context.interpreter();
+
+        int tableId = rule.tableId();
+        String tableName = interpreter.tableIdMap().get(tableId);
+
+        Bmv2TableModel table = (tableName == null) ? configuration.table(tableId) : configuration.table(tableName);
+
+        if (table == null) {
+            throw new Bmv2FlowRuleTranslatorException("Unknown table ID: " + tableId);
+        }
+
+        /* Translate selector */
+        Bmv2MatchKey bmv2MatchKey = buildMatchKey(interpreter, rule.selector(), table);
+
+        /* Translate treatment */
+        TrafficTreatment treatment = rule.treatment();
+        Bmv2Action bmv2Action = null;
+        // If treatment has only 1 instruction of type extension, use that
+        for (Instruction inst : treatment.allInstructions()) {
+            if (inst.type() == Instruction.Type.EXTENSION) {
+                if (treatment.allInstructions().size() == 1) {
+                    bmv2Action = getActionFromExtension((ExtensionInstructionWrapper) inst);
+                } else {
+                    throw new Bmv2FlowRuleTranslatorException("Unable to translate traffic treatment, found multiple " +
+                                                                      "instructions of which one is an extension: " +
+                                                                      treatment.toString());
+                }
+            }
+        }
+
+        if (bmv2Action == null) {
+            // No extension, use interpreter to build action.
+            try {
+                bmv2Action = interpreter.mapTreatment(treatment, configuration);
+            } catch (Bmv2InterpreterException e) {
+                throw new Bmv2FlowRuleTranslatorException("Unable to translate treatment. " + e.toString());
+            }
+        }
+
+        if (bmv2Action == null) {
+            // Interpreter returned null.
+            throw new Bmv2FlowRuleTranslatorException("Unable to translate treatment");
+        }
+
+        // Check action
+        Bmv2ActionModel actionModel = configuration.action(bmv2Action.name());
+        if (actionModel == null) {
+            throw new Bmv2FlowRuleTranslatorException("Unknown action " + bmv2Action.name());
+        }
+        if (!table.actions().contains(actionModel)) {
+            throw new Bmv2FlowRuleTranslatorException("Action " + bmv2Action.name()
+                                                              + " is not defined for table " + tableName);
+        }
+        if (actionModel.runtimeDatas().size() != bmv2Action.parameters().size()) {
+            throw new Bmv2FlowRuleTranslatorException("Wrong number of parameters for action "
+                                                              + actionModel.name() + ", expected "
+                                                              + actionModel.runtimeDatas().size() + ", but found "
+                                                              + bmv2Action.parameters().size());
+        }
+        for (int i = 0; i < actionModel.runtimeDatas().size(); i++) {
+            Bmv2RuntimeDataModel data = actionModel.runtimeDatas().get(i);
+            ImmutableByteSequence param = bmv2Action.parameters().get(i);
+            if (param.size() != roundToBytes(data.bitWidth())) {
+                throw new Bmv2FlowRuleTranslatorException("Wrong byte-width for parameter " + data.name()
+                                                                  + " of action " + actionModel.name()
+                                                                  + ", expected " + roundToBytes(data.bitWidth())
+                                                                  + " bytes, but found " + param.size());
+            }
+        }
+
+        Bmv2TableEntry.Builder tableEntryBuilder = Bmv2TableEntry.builder();
+
+        // In BMv2 0 is the highest priority.
+        int newPriority = Integer.MAX_VALUE - rule.priority();
+
+        tableEntryBuilder
+                .withTableName(table.name())
+                .withPriority(newPriority)
+                .withMatchKey(bmv2MatchKey)
+                .withAction(bmv2Action);
+
+        if (!rule.isPermanent()) {
+            if (table.hasTimeouts()) {
+                tableEntryBuilder.withTimeout((double) rule.timeout());
+            } else {
+                log.warn("Flow rule is temporary but table {} doesn't support timeouts, translating to permanent",
+                         table.name());
+            }
+
+        }
+
+        return tableEntryBuilder.build();
+    }
+
+    private Bmv2TernaryMatchParam buildTernaryParam(Bmv2FieldModel field, Criterion criterion, int bitWidth)
+            throws Bmv2FlowRuleTranslatorException {
+
+        // Value and mask will be filled according to criterion type
+        ImmutableByteSequence value;
+        ImmutableByteSequence mask = null;
+
+        int byteWidth = roundToBytes(bitWidth);
+
+        switch (criterion.type()) {
+            case IN_PORT:
+                long port = ((PortCriterion) criterion).port().toLong();
+                value = ImmutableByteSequence.copyFrom(port);
+                break;
+            case ETH_DST:
+                EthCriterion c = (EthCriterion) criterion;
+                value = ImmutableByteSequence.copyFrom(c.mac().toBytes());
+                if (c.mask() != null) {
+                    mask = ImmutableByteSequence.copyFrom(c.mask().toBytes());
+                }
+                break;
+            case ETH_SRC:
+                EthCriterion c2 = (EthCriterion) criterion;
+                value = ImmutableByteSequence.copyFrom(c2.mac().toBytes());
+                if (c2.mask() != null) {
+                    mask = ImmutableByteSequence.copyFrom(c2.mask().toBytes());
+                }
+                break;
+            case ETH_TYPE:
+                short ethType = ((EthTypeCriterion) criterion).ethType().toShort();
+                value = ImmutableByteSequence.copyFrom(ethType);
+                break;
+            // TODO: implement building for other criterion types (easy with DefaultCriterion of ONOS-4034)
+            default:
+                throw new Bmv2FlowRuleTranslatorException("Feature not implemented, ternary builder for criterion" +
+                                                                  "type: " + criterion.type().name());
+        }
+
+        // Fit byte sequence in field model bit-width.
+        try {
+            value = Bmv2TranslatorUtils.fitByteSequence(value, bitWidth);
+        } catch (Bmv2TranslatorUtils.ByteSequenceFitException e) {
+            throw new Bmv2FlowRuleTranslatorException(
+                    "Fit exception for criterion " + criterion.type().name() + " value, " + e.getMessage());
+        }
+
+        if (mask == null) {
+            // no mask, all ones
+            mask = ImmutableByteSequence.ofOnes(byteWidth);
+        } else {
+            try {
+                mask = Bmv2TranslatorUtils.fitByteSequence(mask, bitWidth);
+            } catch (Bmv2TranslatorUtils.ByteSequenceFitException e) {
+                throw new Bmv2FlowRuleTranslatorException(
+                        "Fit exception for criterion " + criterion.type().name() + " mask, " + e.getMessage());
+            }
+        }
+
+        return new Bmv2TernaryMatchParam(value, mask);
+    }
+
+    private Bmv2Action getActionFromExtension(Instructions.ExtensionInstructionWrapper inst)
+            throws Bmv2FlowRuleTranslatorException {
+
+        ExtensionTreatment extTreatment = inst.extensionInstruction();
+
+        if (extTreatment.type() == ExtensionTreatmentTypes.BMV2_ACTION.type()) {
+            if (extTreatment instanceof Bmv2ExtensionTreatment) {
+                return ((Bmv2ExtensionTreatment) extTreatment).getAction();
+            } else {
+                throw new Bmv2FlowRuleTranslatorException("Unable to decode treatment extension: " + extTreatment);
+            }
+        } else {
+            throw new Bmv2FlowRuleTranslatorException("Unsupported treatment extension type: " + extTreatment.type());
+        }
+    }
+
+    private Bmv2MatchKey buildMatchKey(Bmv2Interpreter interpreter, TrafficSelector selector, Bmv2TableModel tableModel)
+            throws Bmv2FlowRuleTranslatorException {
+
+        // Find a bmv2 extension selector (if any) and get the parameter map.
+        Optional<Bmv2ExtensionSelector> extSelector = selector.criteria().stream()
+                .filter(c -> c.type().equals(EXTENSION))
+                .map(c -> (ExtensionCriterion) c)
+                .map(ExtensionCriterion::extensionSelector)
+                .filter(c -> c.type().equals(BMV2_MATCH_PARAMS.type()))
+                .map(c -> (Bmv2ExtensionSelector) c)
+                .findFirst();
+        Map<String, Bmv2MatchParam> extParamMap =
+                (extSelector.isPresent()) ? extSelector.get().parameterMap() : Collections.emptyMap();
+
+        Set<Criterion> translatedCriteria = Sets.newHashSet();
+        Set<String> usedExtParams = Sets.newHashSet();
+
+        Bmv2MatchKey.Builder matchKeyBuilder = Bmv2MatchKey.builder();
+
+        keysLoop:
+        for (Bmv2TableKeyModel keyModel : tableModel.keys()) {
+
+            // use fieldName dot notation (e.g. ethernet.dstAddr)
+            String fieldName = keyModel.field().header().name() + "." + keyModel.field().type().name();
+
+            int bitWidth = keyModel.field().type().bitWidth();
+            int byteWidth = roundToBytes(bitWidth);
+
+            Criterion.Type criterionType = interpreter.criterionTypeMap().inverse().get(fieldName);
+
+            if (!extParamMap.containsKey(fieldName) &&
+                    (criterionType == null || selector.getCriterion(criterionType) == null)) {
+                // Neither an extension nor a mapping / criterion is available for this field.
+                switch (keyModel.matchType()) {
+                    case TERNARY:
+                        // Wildcard field
+                        matchKeyBuilder.withWildcard(byteWidth);
+                        break;
+                    case LPM:
+                        // LPM with prefix 0
+                        matchKeyBuilder.add(new Bmv2LpmMatchParam(ImmutableByteSequence.ofZeros(byteWidth), 0));
+                        break;
+                    default:
+                        throw new Bmv2FlowRuleTranslatorException("No value found for required match field "
+                                                                          + fieldName);
+                }
+                // Next key
+                continue keysLoop;
+            }
+
+            Bmv2MatchParam matchParam;
+
+            if (extParamMap.containsKey(fieldName)) {
+                // Parameter found in extension
+                if (criterionType != null && selector.getCriterion(criterionType) != null) {
+                    // Found also a criterion that can be mapped. This is bad.
+                    throw new Bmv2FlowRuleTranslatorException("Both an extension and a criterion mapping are defined " +
+                                                                      "for match field " + fieldName);
+                }
+
+                matchParam = extParamMap.get(fieldName);
+                usedExtParams.add(fieldName);
+
+                // Check parameter type and size
+                if (!keyModel.matchType().equals(matchParam.type())) {
+                    throw new Bmv2FlowRuleTranslatorException("Wrong match type for parameter " + fieldName
+                                                                      + ", expected " + keyModel.matchType().name()
+                                                                      + ", but found " + matchParam.type().name());
+                }
+                int foundByteWidth;
+                switch (keyModel.matchType()) {
+                    case EXACT:
+                        Bmv2ExactMatchParam m1 = (Bmv2ExactMatchParam) matchParam;
+                        foundByteWidth = m1.value().size();
+                        break;
+                    case TERNARY:
+                        Bmv2TernaryMatchParam m2 = (Bmv2TernaryMatchParam) matchParam;
+                        foundByteWidth = m2.value().size();
+                        break;
+                    case LPM:
+                        Bmv2LpmMatchParam m3 = (Bmv2LpmMatchParam) matchParam;
+                        foundByteWidth = m3.value().size();
+                        break;
+                    case VALID:
+                        foundByteWidth = -1;
+                        break;
+                    default:
+                        // should never be her
+                        throw new RuntimeException("Unrecognized match type " + keyModel.matchType().name());
+                }
+                if (foundByteWidth != -1 && foundByteWidth != byteWidth) {
+                    throw new Bmv2FlowRuleTranslatorException("Wrong byte-width for match parameter " + fieldName
+                                                                      + ", expected " + byteWidth + ", but found "
+                                                                      + foundByteWidth);
+                }
+
+            } else {
+                // A criterion mapping is available for this key
+                Criterion criterion = selector.getCriterion(criterionType);
+                translatedCriteria.add(criterion);
+                switch (keyModel.matchType()) {
+                    case TERNARY:
+                        matchParam = buildTernaryParam(keyModel.field(), criterion, bitWidth);
+                        break;
+                    default:
+                        // TODO: implement other match param builders (exact, LPM, etc.)
+                        throw new Bmv2FlowRuleTranslatorException("Feature not yet implemented, match param builder: "
+                                                                          + keyModel.matchType().name());
+                }
+            }
+
+            matchKeyBuilder.add(matchParam);
+        }
+
+        // Check if all criteria have been translated
+        Set<Criterion> ignoredCriteria = selector.criteria()
+                .stream()
+                .filter(c -> !c.type().equals(EXTENSION))
+                .filter(c -> !translatedCriteria.contains(c))
+                .collect(Collectors.toSet());
+
+        if (ignoredCriteria.size() > 0) {
+            throw new Bmv2FlowRuleTranslatorException("The following criteria cannot be translated for table "
+                                                              + tableModel.name() + ": " + ignoredCriteria.toString());
+        }
+
+        // Check is all extension parameters have been used
+        Set<String> ignoredExtParams = extParamMap.keySet()
+                .stream()
+                .filter(k -> !usedExtParams.contains(k))
+                .collect(Collectors.toSet());
+
+        if (ignoredExtParams.size() > 0) {
+            throw new Bmv2FlowRuleTranslatorException("The following extension match parameters cannot be used for " +
+                                                              "table " + tableModel.name() + ": "
+                                                              + ignoredExtParams.toString());
+        }
+
+        return matchKeyBuilder.build();
+    }
+
+}
diff --git a/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2TExceptionParser.java b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2TExceptionParser.java
new file mode 100644
index 0000000..6ce3fbd
--- /dev/null
+++ b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2TExceptionParser.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.bmv2.ctl;
+
+
+import org.apache.thrift.TException;
+import org.onosproject.bmv2.api.runtime.Bmv2RuntimeException;
+import org.onosproject.bmv2.thriftapi.InvalidCounterOperation;
+import org.onosproject.bmv2.thriftapi.InvalidDevMgrOperation;
+import org.onosproject.bmv2.thriftapi.InvalidLearnOperation;
+import org.onosproject.bmv2.thriftapi.InvalidMcOperation;
+import org.onosproject.bmv2.thriftapi.InvalidMeterOperation;
+import org.onosproject.bmv2.thriftapi.InvalidRegisterOperation;
+import org.onosproject.bmv2.thriftapi.InvalidSwapOperation;
+import org.onosproject.bmv2.thriftapi.InvalidTableOperation;
+
+import static org.onosproject.bmv2.api.runtime.Bmv2RuntimeException.Code;
+
+/**
+ * Utility class to translate a Thrift exception into a Bmv2RuntimeException.
+ */
+final class Bmv2TExceptionParser {
+
+    private Bmv2TExceptionParser() {
+        // ban constructor.
+    }
+
+    static Bmv2RuntimeException parseTException(TException cause) {
+        try {
+            return new Bmv2RuntimeException(getCode(cause));
+        } catch (ParserException e) {
+            return new Bmv2RuntimeException(e.codeString);
+        }
+    }
+
+    private static Code getCode(TException e) throws ParserException {
+        if (e instanceof InvalidTableOperation) {
+            InvalidTableOperation t = (InvalidTableOperation) e;
+            switch (t.getCode()) {
+                case TABLE_FULL:
+                    return Code.TABLE_FULL;
+                case INVALID_HANDLE:
+                    return Code.TABLE_INVALID_HANDLE;
+                case EXPIRED_HANDLE:
+                    return Code.TABLE_EXPIRED_HANDLE;
+                case COUNTERS_DISABLED:
+                    return Code.TABLE_COUNTERS_DISABLED;
+                case METERS_DISABLED:
+                    return Code.TABLE_METERS_DISABLED;
+                case AGEING_DISABLED:
+                    return Code.TABLE_AGEING_DISABLED;
+                case INVALID_TABLE_NAME:
+                    return Code.TABLE_INVALID_TABLE_NAME;
+                case INVALID_ACTION_NAME:
+                    return Code.TABLE_INVALID_ACTION_NAME;
+                case WRONG_TABLE_TYPE:
+                    return Code.TABLE_WRONG_TABLE_TYPE;
+                case INVALID_MBR_HANDLE:
+                    return Code.TABLE_INVALID_MBR_HANDLE;
+                case MBR_STILL_USED:
+                    return Code.TABLE_MBR_STILL_USED;
+                case MBR_ALREADY_IN_GRP:
+                    return Code.TABLE_MBR_ALREADY_IN_GRP;
+                case MBR_NOT_IN_GRP:
+                    return Code.TABLE_MBR_NOT_IN_GRP;
+                case INVALID_GRP_HANDLE:
+                    return Code.TABLE_INVALID_GRP_HANDLE;
+                case GRP_STILL_USED:
+                    return Code.TABLE_GRP_STILL_USED;
+                case EMPTY_GRP:
+                    return Code.TABLE_EMPTY_GRP;
+                case DUPLICATE_ENTRY:
+                    return Code.TABLE_DUPLICATE_ENTRY;
+                case BAD_MATCH_KEY:
+                    return Code.TABLE_BAD_MATCH_KEY;
+                case INVALID_METER_OPERATION:
+                    return Code.TABLE_INVALID_METER_OPERATION;
+                case DEFAULT_ACTION_IS_CONST:
+                    return Code.TABLE_DEFAULT_ACTION_IS_CONST;
+                case DEFAULT_ENTRY_IS_CONST:
+                    return Code.TABLE_DEFAULT_ENTRY_IS_CONST;
+                case ERROR:
+                    return Code.TABLE_GENERAL_ERROR;
+                default:
+                    return Code.TABLE_UNKNOWN_ERROR;
+            }
+        } else if (e instanceof InvalidCounterOperation) {
+            InvalidCounterOperation t = (InvalidCounterOperation) e;
+            switch (t.getCode()) {
+                case INVALID_COUNTER_NAME:
+                    return Code.COUNTER_INVALID_NAME;
+                case INVALID_INDEX:
+                    return Code.COUNTER_INVALID_INDEX;
+                case ERROR:
+                    return Code.COUNTER_ERROR_GENERAL;
+                default:
+                    return Code.COUNTER_ERROR_UNKNOWN;
+            }
+        } else if (e instanceof InvalidDevMgrOperation) {
+            InvalidDevMgrOperation t = (InvalidDevMgrOperation) e;
+            switch (t.getCode()) {
+                case ERROR:
+                    return Code.DEV_MGR_ERROR_GENERAL;
+                default:
+                    return Code.DEV_MGR_UNKNOWN;
+            }
+        } else if (e instanceof InvalidSwapOperation) {
+            InvalidSwapOperation t = (InvalidSwapOperation) e;
+            switch (t.getCode()) {
+                case CONFIG_SWAP_DISABLED:
+                    return Code.SWAP_CONFIG_DISABLED;
+                case ONGOING_SWAP:
+                    return Code.SWAP_ONGOING;
+                case NO_ONGOING_SWAP:
+                    return Code.SWAP_NO_ONGOING;
+                default:
+                    return Code.SWAP_ERROR_UKNOWN;
+            }
+        } else if (e instanceof InvalidMeterOperation) {
+            // TODO
+            throw new ParserException(e.toString());
+        } else if (e instanceof InvalidRegisterOperation) {
+            // TODO
+            throw new ParserException(e.toString());
+        } else if (e instanceof InvalidLearnOperation) {
+            // TODO
+            throw new ParserException(e.toString());
+        } else if (e instanceof InvalidMcOperation) {
+            // TODO
+            throw new ParserException(e.toString());
+        } else {
+            throw new ParserException(e.toString());
+        }
+    }
+
+    private static class ParserException extends Exception {
+
+        private String codeString;
+
+        public ParserException(String codeString) {
+            this.codeString = codeString;
+        }
+    }
+}
diff --git a/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2TableDumpParser.java b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2TableDumpParser.java
new file mode 100644
index 0000000..04e37e5
--- /dev/null
+++ b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2TableDumpParser.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.bmv2.ctl;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.CacheStats;
+import com.google.common.cache.LoadingCache;
+import com.google.common.collect.Lists;
+import org.apache.commons.lang3.tuple.Pair;
+import org.onlab.util.HexString;
+import org.onlab.util.ImmutableByteSequence;
+import org.onlab.util.SharedScheduledExecutors;
+import org.onosproject.bmv2.api.context.Bmv2ActionModel;
+import org.onosproject.bmv2.api.context.Bmv2Configuration;
+import org.onosproject.bmv2.api.runtime.Bmv2Action;
+import org.onosproject.bmv2.api.runtime.Bmv2ExactMatchParam;
+import org.onosproject.bmv2.api.runtime.Bmv2LpmMatchParam;
+import org.onosproject.bmv2.api.runtime.Bmv2MatchKey;
+import org.onosproject.bmv2.api.runtime.Bmv2ParsedTableEntry;
+import org.onosproject.bmv2.api.runtime.Bmv2TernaryMatchParam;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.onosproject.bmv2.api.utils.Bmv2TranslatorUtils.fitByteSequence;
+import static org.onosproject.bmv2.api.utils.Bmv2TranslatorUtils.ByteSequenceFitException;
+
+/**
+ * BMv2 table dump parser.
+ */
+public final class Bmv2TableDumpParser {
+
+    // Examples of a BMv2 table dump can be found in Bmv2TableDumpParserTest
+
+    // 1: entry id, 2: match string, 3: action string
+    private static final String ENTRY_PATTERN_REGEX = "(\\d+): (.*) => (.*)";
+    // 1: match values, 2: masks
+    private static final String MATCH_TERNARY_PATTERN_REGEX = "([0-9a-fA-F ]+) &&& ([0-9a-fA-F ]+)";
+    // 1: match values, 2: masks
+    private static final String MATCH_LPM_PATTERN_REGEX = "([0-9a-fA-F ]+) / ([0-9a-fA-F ]+)";
+    // 1: match values
+    private static final String MATCH_EXACT_PATTERN_REGEX = "([0-9a-fA-F ]+)";
+    // 1: action name, 2: action params
+    private static final String ACTION_PATTERN_REGEX = "(.+) - ?([0-9a-fA-F ,]*)";
+
+    private static final Pattern ENTRY_PATTERN = Pattern.compile(ENTRY_PATTERN_REGEX);
+    private static final Pattern MATCH_TERNARY_PATTERN = Pattern.compile(MATCH_TERNARY_PATTERN_REGEX);
+    private static final Pattern MATCH_LPM_PATTERN = Pattern.compile(MATCH_LPM_PATTERN_REGEX);
+    private static final Pattern MATCH_EXACT_PATTERN = Pattern.compile(MATCH_EXACT_PATTERN_REGEX);
+    private static final Pattern ACTION_PATTERN = Pattern.compile(ACTION_PATTERN_REGEX);
+
+    // Cache to avoid re-parsing known lines.
+    // The assumption here is that entries are not updated too frequently, so that the entry id doesn't change often.
+    // Otherwise, we should cache only the match and action strings...
+    private static final LoadingCache<Pair<String, Bmv2Configuration>, Optional<Bmv2ParsedTableEntry>> ENTRY_CACHE =
+            CacheBuilder.newBuilder()
+            .expireAfterAccess(60, TimeUnit.SECONDS)
+            .recordStats()
+            .build(new CacheLoader<Pair<String, Bmv2Configuration>, Optional<Bmv2ParsedTableEntry>>() {
+                @Override
+                public Optional<Bmv2ParsedTableEntry> load(Pair<String, Bmv2Configuration> key) throws Exception {
+                    // Very expensive call.
+                    return Optional.ofNullable(parseLine(key.getLeft(), key.getRight()));
+                }
+            });
+
+    private static final Logger log = LoggerFactory.getLogger(Bmv2TableDumpParser.class);
+
+    private static final long STATS_LOG_FREQUENCY = 3; // minutes
+
+    static {
+        SharedScheduledExecutors.getSingleThreadExecutor().scheduleAtFixedRate(
+                () -> reportStats(), 0, STATS_LOG_FREQUENCY, TimeUnit.MINUTES);
+    }
+
+    private Bmv2TableDumpParser() {
+        // Ban constructor.
+    }
+
+    /**
+     * Parse the given BMv2 table dump.
+     *
+     * @param tableDump a string value
+     * @return a list of {@link Bmv2ParsedTableEntry}
+     */
+    public static List<Bmv2ParsedTableEntry> parse(String tableDump, Bmv2Configuration configuration) {
+        checkNotNull(tableDump, "tableDump cannot be null");
+        // Parse all lines
+        List<Bmv2ParsedTableEntry> result = Arrays.stream(tableDump.split("\n"))
+                .map(line -> Pair.of(line, configuration))
+                .map(Bmv2TableDumpParser::loadFromCache)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .collect(Collectors.toList());
+        return result;
+    }
+
+    private static Optional<Bmv2ParsedTableEntry> loadFromCache(Pair<String, Bmv2Configuration> key) {
+        try {
+            return ENTRY_CACHE.get(key);
+        } catch (ExecutionException e) {
+            Throwable t = e.getCause();
+            if (t instanceof Bmv2TableDumpParserException) {
+                Bmv2TableDumpParserException parserException = (Bmv2TableDumpParserException) t;
+                log.warn("{}", parserException.getMessage());
+            } else {
+                log.error("Exception while parsing table dump line", e);
+            }
+            return Optional.empty();
+        }
+    }
+
+    private static void reportStats() {
+        CacheStats stats = ENTRY_CACHE.stats();
+        log.info("Cache stats: requestCount={}, hitRate={}, exceptionsCount={}, avgLoadPenalty={}",
+                 stats.requestCount(), stats.hitRate(), stats.loadExceptionCount(), stats.averageLoadPenalty());
+    }
+
+    private static Bmv2ParsedTableEntry parseLine(String line, Bmv2Configuration configuration)
+            throws Bmv2TableDumpParserException {
+        Matcher matcher = ENTRY_PATTERN.matcher(line);
+        if (matcher.find()) {
+            long entryId = parseEntryId(matcher, 1);
+            String matchString = parseMatchString(matcher, 2);
+            String actionString = parseActionString(matcher, 3);
+            Bmv2MatchKey matchKey = parseMatchKey(matchString);
+            Bmv2Action action = parseAction(actionString, configuration);
+            return new Bmv2ParsedTableEntry(entryId, matchKey, action);
+        } else {
+            // Not a table entry
+            return null;
+        }
+    }
+
+    private static Long parseEntryId(Matcher matcher, int groupIdx) throws Bmv2TableDumpParserException {
+        String str = matcher.group(groupIdx);
+        if (str == null) {
+            throw new Bmv2TableDumpParserException("Unable to find entry ID: " + matcher.group());
+        }
+        long entryId;
+        try {
+            entryId = Long.valueOf(str.trim());
+        } catch (NumberFormatException e) {
+            throw new Bmv2TableDumpParserException("Unable to parse entry id for string: " + matcher.group());
+        }
+        return entryId;
+    }
+
+    private static String parseMatchString(Matcher matcher, int groupIdx) throws Bmv2TableDumpParserException {
+        String str = matcher.group(groupIdx);
+        if (str == null) {
+            throw new Bmv2TableDumpParserException("Unable to find match string: " + matcher.group());
+        }
+        return str.trim();
+    }
+
+    private static String parseActionString(Matcher matcher, int groupIdx) throws Bmv2TableDumpParserException {
+        String str = matcher.group(groupIdx);
+        if (str == null) {
+            throw new Bmv2TableDumpParserException("Unable to find action string: " + matcher.group());
+        }
+        return str.trim();
+    }
+
+    private static Bmv2MatchKey parseMatchKey(String str) throws Bmv2TableDumpParserException {
+
+        Bmv2MatchKey.Builder builder = Bmv2MatchKey.builder();
+
+        // Try with ternary...
+        Matcher matcher = MATCH_TERNARY_PATTERN.matcher(str);
+        if (matcher.find()) {
+            // Ternary Match.
+            List<ImmutableByteSequence> values = parseMatchValues(matcher, 1);
+            List<ImmutableByteSequence> masks = parseMatchMasks(matcher, 2, values);
+            for (int i = 0; i < values.size(); i++) {
+                builder.add(new Bmv2TernaryMatchParam(values.get(i), masks.get(i)));
+            }
+            return builder.build();
+        }
+
+        // FIXME: LPM match parsing broken if table key contains also a ternary match
+        // Also it assumes the lpm parameter is the last one, which is wrong.
+        // Try with LPM...
+        matcher = MATCH_LPM_PATTERN.matcher(str);
+        if (matcher.find()) {
+            // Lpm Match.
+            List<ImmutableByteSequence> values = parseMatchValues(matcher, 1);
+            int prefixLength = parseLpmPrefix(matcher, 2);
+            for (int i = 0; i < values.size() - 1; i++) {
+                builder.add(new Bmv2ExactMatchParam(values.get(i)));
+            }
+            builder.add(new Bmv2LpmMatchParam(values.get(values.size() - 1), prefixLength));
+            return builder.build();
+        }
+
+        // Try with exact...
+        matcher = MATCH_EXACT_PATTERN.matcher(str);
+        if (matcher.find()) {
+            // Exact match.
+            parseMatchValues(matcher, 1)
+                    .stream()
+                    .map(Bmv2ExactMatchParam::new)
+                    .forEach(builder::add);
+            return builder.build();
+        }
+
+        throw new Bmv2TableDumpParserException("Unable to parse match string: " + str);
+    }
+
+    private static List<ImmutableByteSequence> parseMatchValues(Matcher matcher, int groupIdx)
+            throws Bmv2TableDumpParserException {
+        String matchString = matcher.group(groupIdx);
+        if (matchString == null) {
+            throw new Bmv2TableDumpParserException("Unable to find match params for string: " + matcher.group());
+        }
+        List<ImmutableByteSequence> result = Lists.newArrayList();
+        for (String paramString : matchString.split(" ")) {
+            byte[] bytes = HexString.fromHexString(paramString, null);
+            result.add(ImmutableByteSequence.copyFrom(bytes));
+        }
+        return result;
+    }
+
+    private static List<ImmutableByteSequence> parseMatchMasks(Matcher matcher, int groupIdx,
+                                                               List<ImmutableByteSequence> matchParams)
+            throws Bmv2TableDumpParserException {
+        String maskString = matcher.group(groupIdx);
+        if (maskString == null) {
+            throw new Bmv2TableDumpParserException("Unable to find mask for string: " + matcher.group());
+        }
+        List<ImmutableByteSequence> result = Lists.newArrayList();
+        /*
+        Mask here is a hex string with no spaces, hence individual mask params can be derived according
+        to given matchParam sizes.
+         */
+        byte[] maskBytes = HexString.fromHexString(maskString, null);
+        int startPosition = 0;
+        for (ImmutableByteSequence bs : matchParams) {
+            if (startPosition + bs.size() > maskBytes.length) {
+                throw new Bmv2TableDumpParserException("Invalid length for mask in string: " + matcher.group());
+            }
+            ImmutableByteSequence maskParam = ImmutableByteSequence.copyFrom(maskBytes,
+                                                                             startPosition,
+                                                                             startPosition + bs.size() - 1);
+            result.add(maskParam);
+            startPosition += bs.size();
+        }
+        return result;
+    }
+
+    private static int parseLpmPrefix(Matcher matcher, int groupIdx)
+            throws Bmv2TableDumpParserException {
+        String str = matcher.group(groupIdx);
+        if (str == null) {
+            throw new Bmv2TableDumpParserException("Unable to find LPM prefix for string: " + matcher.group());
+        }
+        // For some reason the dumped prefix has 16 bits more than the one programmed
+        try {
+            return Integer.valueOf(str.trim()) - 16;
+        } catch (NumberFormatException e) {
+            throw new Bmv2TableDumpParserException("Unable to parse LPM prefix from string: " + matcher.group());
+        }
+    }
+
+    private static Bmv2Action parseAction(String str, Bmv2Configuration configuration)
+            throws Bmv2TableDumpParserException {
+        Matcher matcher = ACTION_PATTERN.matcher(str);
+        if (matcher.find()) {
+            String actionName = parseActionName(matcher, 1);
+            Bmv2ActionModel actionModel = configuration.action(actionName);
+            if (actionModel == null) {
+                throw new Bmv2TableDumpParserException("Not such an action in configuration: " + actionName);
+            }
+            Bmv2Action.Builder builder = Bmv2Action.builder().withName(actionName);
+            List<ImmutableByteSequence> actionParams = parseActionParams(matcher, 2);
+            if (actionParams.size() != actionModel.runtimeDatas().size()) {
+                throw new Bmv2TableDumpParserException("Invalid number of parameters for action: " + actionName);
+            }
+            for (int i = 0; i < actionModel.runtimeDatas().size(); i++) {
+                try {
+                    // fit param byte-width according to configuration.
+                    builder.addParameter(fitByteSequence(actionParams.get(i),
+                                                         actionModel.runtimeDatas().get(i).bitWidth()));
+                } catch (ByteSequenceFitException e) {
+                    throw new Bmv2TableDumpParserException("Unable to parse action param: " + e.toString());
+                }
+            }
+            return builder.build();
+        }
+        throw new Bmv2TableDumpParserException("Unable to parse action string: " + str.trim());
+    }
+
+    private static String parseActionName(Matcher matcher, int groupIdx) throws Bmv2TableDumpParserException {
+        String actionName = matcher.group(groupIdx);
+        if (actionName == null) {
+            throw new Bmv2TableDumpParserException("Unable to find action name for string: " + matcher.group());
+        }
+        return actionName.trim();
+    }
+
+    private static List<ImmutableByteSequence> parseActionParams(Matcher matcher, int groupIdx)
+            throws Bmv2TableDumpParserException {
+        String paramsString = matcher.group(groupIdx);
+        if (paramsString == null) {
+            throw new Bmv2TableDumpParserException("Unable to find action params for string: " + matcher.group());
+        }
+        if (paramsString.length() == 0) {
+            return Collections.emptyList();
+        }
+        return Arrays.stream(paramsString.split(","))
+                .map(String::trim)
+                .map(s -> HexString.fromHexString(s, null))
+                .map(ImmutableByteSequence::copyFrom)
+                .collect(Collectors.toList());
+    }
+
+    public static class Bmv2TableDumpParserException extends Exception {
+        public Bmv2TableDumpParserException(String msg) {
+            super(msg);
+        }
+    }
+}
\ No newline at end of file
diff --git a/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2TableEntryServiceImpl.java b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2TableEntryServiceImpl.java
new file mode 100644
index 0000000..8258334
--- /dev/null
+++ b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/Bmv2TableEntryServiceImpl.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.bmv2.ctl;
+
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.apache.felix.scr.annotations.Service;
+import org.onlab.util.KryoNamespace;
+import org.onosproject.bmv2.api.context.Bmv2DeviceContext;
+import org.onosproject.bmv2.api.context.Bmv2FlowRuleTranslator;
+import org.onosproject.bmv2.api.service.Bmv2DeviceContextService;
+import org.onosproject.bmv2.api.service.Bmv2Controller;
+import org.onosproject.bmv2.api.runtime.Bmv2DeviceAgent;
+import org.onosproject.bmv2.api.runtime.Bmv2ExactMatchParam;
+import org.onosproject.bmv2.api.runtime.Bmv2FlowRuleWrapper;
+import org.onosproject.bmv2.api.runtime.Bmv2LpmMatchParam;
+import org.onosproject.bmv2.api.runtime.Bmv2MatchKey;
+import org.onosproject.bmv2.api.runtime.Bmv2ParsedTableEntry;
+import org.onosproject.bmv2.api.runtime.Bmv2RuntimeException;
+import org.onosproject.bmv2.api.runtime.Bmv2TableEntryReference;
+import org.onosproject.bmv2.api.service.Bmv2TableEntryService;
+import org.onosproject.bmv2.api.runtime.Bmv2TernaryMatchParam;
+import org.onosproject.bmv2.api.runtime.Bmv2ValidMatchParam;
+import org.onosproject.net.DeviceId;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.EventuallyConsistentMap;
+import org.onosproject.store.service.StorageService;
+import org.onosproject.store.service.WallClockTimestamp;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collections;
+import java.util.List;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Implementation of the Bmv2TableEntryService.
+ */
+@Component(immediate = true)
+@Service
+public class Bmv2TableEntryServiceImpl implements Bmv2TableEntryService {
+
+    private final Logger log = LoggerFactory.getLogger(this.getClass());
+
+    private final Bmv2FlowRuleTranslator translator = new Bmv2FlowRuleTranslatorImpl();
+
+    private EventuallyConsistentMap<Bmv2TableEntryReference, Bmv2FlowRuleWrapper> flowRules;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected StorageService storageService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected Bmv2Controller controller;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected Bmv2DeviceContextService contextService;
+
+
+    @Activate
+    public void activate() {
+        KryoNamespace kryo = new KryoNamespace.Builder()
+                .register(KryoNamespaces.API)
+                .register(Bmv2TableEntryReference.class)
+                .register(Bmv2MatchKey.class)
+                .register(Bmv2ExactMatchParam.class)
+                .register(Bmv2TernaryMatchParam.class)
+                .register(Bmv2LpmMatchParam.class)
+                .register(Bmv2ValidMatchParam.class)
+                .register(Bmv2FlowRuleWrapper.class)
+                .build();
+
+        flowRules = storageService.<Bmv2TableEntryReference, Bmv2FlowRuleWrapper>eventuallyConsistentMapBuilder()
+                .withSerializer(kryo)
+                .withTimestampProvider((k, v) -> new WallClockTimestamp())
+                .withName("onos-bmv2-flowrules")
+                .build();
+
+        log.info("Started");
+    }
+
+    @Deactivate
+    public void deactivate() {
+        log.info("Stopped");
+    }
+
+    @Override
+    public Bmv2FlowRuleTranslator getFlowRuleTranslator() {
+        return translator;
+    }
+
+    @Override
+    public List<Bmv2ParsedTableEntry> getTableEntries(DeviceId deviceId, String tableName) {
+        try {
+            Bmv2DeviceContext context = contextService.getContext(deviceId);
+            if (context == null) {
+                log.warn("Unable to get table entries, found null context for {}", deviceId);
+                return Collections.emptyList();
+            }
+            Bmv2DeviceAgent agent = controller.getAgent(deviceId);
+            String tableDump = agent.dumpTable(tableName);
+            return Bmv2TableDumpParser.parse(tableDump, context.configuration());
+        } catch (Bmv2RuntimeException e) {
+            log.warn("Unable to get table entries for {}: {}", deviceId, e.explain());
+            return Collections.emptyList();
+        }
+    }
+
+    @Override
+    public Bmv2FlowRuleWrapper lookupEntryReference(Bmv2TableEntryReference entryRef) {
+        checkNotNull(entryRef, "table entry reference cannot be null");
+        return flowRules.get(entryRef);
+    }
+
+    @Override
+    public void bindEntryReference(Bmv2TableEntryReference entryRef, Bmv2FlowRuleWrapper rule) {
+        checkNotNull(entryRef, "table entry reference cannot be null");
+        checkNotNull(rule, "bmv2 flow rule cannot be null");
+        flowRules.put(entryRef, rule);
+    }
+
+    @Override
+    public void unbindEntryReference(Bmv2TableEntryReference entryRef) {
+        checkNotNull(entryRef, "table entry reference cannot be null");
+        flowRules.remove(entryRef);
+    }
+}
diff --git a/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/SafeThriftClient.java b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/SafeThriftClient.java
new file mode 100644
index 0000000..f6e4813
--- /dev/null
+++ b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/SafeThriftClient.java
@@ -0,0 +1,250 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.
+ */
+
+/*
+ * Most of the code of this class was copied from:
+ * http://liveramp.com/engineering/reconnecting-thrift-client/
+ */
+
+package org.onosproject.bmv2.ctl;
+
+import com.google.common.collect.ImmutableSet;
+import org.apache.thrift.TServiceClient;
+import org.apache.thrift.transport.TTransport;
+import org.apache.thrift.transport.TTransportException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.Set;
+
+/**
+ * Thrift client wrapper that attempts a few reconnects before giving up a method call execution. It also provides
+ * synchronization between calls over the same transport.
+ */
+public final class SafeThriftClient {
+
+    private static final Logger LOG = LoggerFactory.getLogger(SafeThriftClient.class);
+
+    /**
+     * List of causes which suggest a restart might fix things (defined as constants in {@link TTransportException}).
+     */
+    private static final Set<Integer> RESTARTABLE_CAUSES = ImmutableSet.of(TTransportException.NOT_OPEN,
+                                                                           TTransportException.END_OF_FILE,
+                                                                           TTransportException.TIMED_OUT,
+                                                                           TTransportException.UNKNOWN);
+
+    private SafeThriftClient() {
+        // ban constructor.
+    }
+
+    /**
+     * Reflectively wraps an already existing Thrift client.
+     *
+     * @param baseClient      the client to wrap
+     * @param clientInterface the interface that the client implements
+     * @param options         options that control behavior of the reconnecting client
+     * @param <T>
+     * @param <C>
+     * @return
+     */
+    public static <T extends TServiceClient, C> C wrap(T baseClient, Class<C> clientInterface, Options options) {
+        Object proxyObject = Proxy.newProxyInstance(clientInterface.getClassLoader(),
+                                                    new Class<?>[]{clientInterface},
+                                                    new ReconnectingClientProxy<T>(baseClient,
+                                                                                   options.getNumRetries(),
+                                                                                   options.getTimeBetweenRetries()));
+
+        return (C) proxyObject;
+    }
+
+    /**
+     * Reflectively wraps an already existing Thrift client.
+     *
+     * @param baseClient the client to wrap
+     * @param options    options that control behavior of the reconnecting client
+     * @param <T>
+     * @param <C>
+     * @return
+     */
+    public static <T extends TServiceClient, C> C wrap(T baseClient, Options options) {
+        Class<?>[] interfaces = baseClient.getClass().getInterfaces();
+
+        for (Class<?> iface : interfaces) {
+            if (iface.getSimpleName().equals("Iface")
+                    && iface.getEnclosingClass().equals(baseClient.getClass().getEnclosingClass())) {
+                return (C) wrap(baseClient, iface, options);
+            }
+        }
+
+        throw new RuntimeException("Class needs to implement Iface directly. Use wrap(TServiceClient, Class) instead.");
+    }
+
+    /**
+     * Reflectively wraps an already existing Thrift client.
+     *
+     * @param baseClient      the client to wrap
+     * @param clientInterface the interface that the client implements
+     * @param <T>
+     * @param <C>
+     * @return
+     */
+    public static <T extends TServiceClient, C> C wrap(T baseClient, Class<C> clientInterface) {
+        return wrap(baseClient, clientInterface, Options.defaults());
+    }
+
+    /**
+     * Reflectively wraps an already existing Thrift client.
+     *
+     * @param baseClient the client to wrap
+     * @param <T>
+     * @param <C>
+     * @return
+     */
+    public static <T extends TServiceClient, C> C wrap(T baseClient) {
+        return wrap(baseClient, Options.defaults());
+    }
+
+    /**
+     * Reconnection options for {@link SafeThriftClient}.
+     */
+    public static class Options {
+        private int numRetries;
+        private long timeBetweenRetries;
+
+        /**
+         * Creates new options with the given parameters.
+         *
+         * @param numRetries         the maximum number of times to try reconnecting before giving up and throwing an
+         *                           exception
+         * @param timeBetweenRetries the number of milliseconds to wait in between reconnection attempts.
+         */
+        public Options(int numRetries, long timeBetweenRetries) {
+            this.numRetries = numRetries;
+            this.timeBetweenRetries = timeBetweenRetries;
+        }
+
+        private static Options defaults() {
+            return new Options(5, 10000L);
+        }
+
+        private int getNumRetries() {
+            return numRetries;
+        }
+
+        private long getTimeBetweenRetries() {
+            return timeBetweenRetries;
+        }
+    }
+
+    /**
+     * Helper proxy class. Attempts to call method on proxy object wrapped in try/catch. If it fails, it attempts a
+     * reconnect and tries the method again.
+     *
+     * @param <T>
+     */
+    private static class ReconnectingClientProxy<T extends TServiceClient> implements InvocationHandler {
+        private final T baseClient;
+        private final TTransport transport;
+        private final int maxRetries;
+        private final long timeBetweenRetries;
+
+        public ReconnectingClientProxy(T baseClient, int maxRetries, long timeBetweenRetries) {
+            this.baseClient = baseClient;
+            this.transport = baseClient.getInputProtocol().getTransport();
+            this.maxRetries = maxRetries;
+            this.timeBetweenRetries = timeBetweenRetries;
+        }
+
+        private void reconnectOrThrowException()
+                throws TTransportException {
+            int errors = 0;
+            try {
+                if (transport.isOpen()) {
+                    transport.close();
+                }
+            } catch (Exception e) {
+                // Thrift seems to have a bug where if the transport is already closed a SocketException is thrown.
+                // However, such an exception is not advertised by .close(), hence the general-purpose catch.
+                LOG.debug("Exception while closing transport", e);
+            }
+
+            while (errors < maxRetries) {
+                try {
+                    LOG.debug("Attempting to reconnect...");
+                    transport.open();
+                    LOG.debug("Reconnection successful");
+                    break;
+                } catch (TTransportException e) {
+                    LOG.debug("Error while reconnecting:", e);
+                    errors++;
+
+                    if (errors < maxRetries) {
+                        try {
+                            LOG.debug("Sleeping for {} milliseconds before retrying", timeBetweenRetries);
+                            Thread.sleep(timeBetweenRetries);
+                        } catch (InterruptedException e2) {
+                            Thread.currentThread().interrupt();
+                            throw new RuntimeException(e);
+                        }
+                    }
+                }
+            }
+
+            if (errors >= maxRetries) {
+                throw new TTransportException("Failed to reconnect");
+            }
+        }
+
+        @Override
+        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+
+            // Thrift transport layer is not thread-safe (it's a wrapper on a socket), hence we need locking.
+            synchronized (transport) {
+
+                LOG.debug("Invoking method... > fromThread={}, method={}, args={}",
+                          Thread.currentThread().getId(), method.getName(), args);
+
+                try {
+
+                    return method.invoke(baseClient, args);
+                } catch (InvocationTargetException e) {
+                    if (e.getTargetException() instanceof TTransportException) {
+                        TTransportException cause = (TTransportException) e.getTargetException();
+
+                        if (RESTARTABLE_CAUSES.contains(cause.getType())) {
+                            // Try to reconnect. If fail, a TTransportException will be thrown.
+                            reconnectOrThrowException();
+                            try {
+                                // If here, transport has been successfully open, hence new exceptions will be thrown.
+                                return method.invoke(baseClient, args);
+                            } catch (InvocationTargetException e1) {
+                                LOG.debug("Exception: {}", e1.getTargetException());
+                                throw e1.getTargetException();
+                            }
+                        }
+                    }
+                    // Target exception is neither a TTransportException nor a restartable cause.
+                    LOG.debug("Exception: {}", e.getTargetException());
+                    throw e.getTargetException();
+                }
+            }
+        }
+    }
+}
diff --git a/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/package-info.java b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/package-info.java
new file mode 100644
index 0000000..dcd9a28
--- /dev/null
+++ b/protocols/bmv2/ctl/src/main/java/org/onosproject/bmv2/ctl/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.
+ */
+
+/**
+ * BMv2 Thrift client implementation.
+ */
+package org.onosproject.bmv2.ctl;
\ No newline at end of file
diff --git a/protocols/bmv2/ctl/src/main/resources/default.json b/protocols/bmv2/ctl/src/main/resources/default.json
new file mode 100644
index 0000000..abc0452
--- /dev/null
+++ b/protocols/bmv2/ctl/src/main/resources/default.json
@@ -0,0 +1,730 @@
+{
+    "header_types": [
+        {
+            "name": "standard_metadata_t",
+            "id": 0,
+            "fields": [
+                [
+                    "ingress_port",
+                    9
+                ],
+                [
+                    "packet_length",
+                    32
+                ],
+                [
+                    "egress_spec",
+                    9
+                ],
+                [
+                    "egress_port",
+                    9
+                ],
+                [
+                    "egress_instance",
+                    32
+                ],
+                [
+                    "instance_type",
+                    32
+                ],
+                [
+                    "clone_spec",
+                    32
+                ],
+                [
+                    "_padding",
+                    5
+                ]
+            ],
+            "length_exp": null,
+            "max_length": null
+        },
+        {
+            "name": "intrinsic_metadata_t",
+            "id": 1,
+            "fields": [
+                [
+                    "ingress_global_timestamp",
+                    32
+                ],
+                [
+                    "lf_field_list",
+                    32
+                ],
+                [
+                    "mcast_grp",
+                    16
+                ],
+                [
+                    "egress_rid",
+                    16
+                ]
+            ],
+            "length_exp": null,
+            "max_length": null
+        },
+        {
+            "name": "ethernet_t",
+            "id": 2,
+            "fields": [
+                [
+                    "dstAddr",
+                    48
+                ],
+                [
+                    "srcAddr",
+                    48
+                ],
+                [
+                    "etherType",
+                    16
+                ]
+            ],
+            "length_exp": null,
+            "max_length": null
+        },
+        {
+            "name": "ipv4_t",
+            "id": 3,
+            "fields": [
+                [
+                    "version",
+                    4
+                ],
+                [
+                    "ihl",
+                    4
+                ],
+                [
+                    "diffserv",
+                    8
+                ],
+                [
+                    "totalLen",
+                    16
+                ],
+                [
+                    "identification",
+                    16
+                ],
+                [
+                    "flags",
+                    3
+                ],
+                [
+                    "fragOffset",
+                    13
+                ],
+                [
+                    "ttl",
+                    8
+                ],
+                [
+                    "protocol",
+                    8
+                ],
+                [
+                    "hdrChecksum",
+                    16
+                ],
+                [
+                    "srcAddr",
+                    32
+                ],
+                [
+                    "dstAddr",
+                    32
+                ]
+            ],
+            "length_exp": null,
+            "max_length": null
+        },
+        {
+            "name": "tcp_t",
+            "id": 4,
+            "fields": [
+                [
+                    "srcPort",
+                    16
+                ],
+                [
+                    "dstPort",
+                    16
+                ],
+                [
+                    "seqNo",
+                    32
+                ],
+                [
+                    "ackNo",
+                    32
+                ],
+                [
+                    "dataOffset",
+                    4
+                ],
+                [
+                    "res",
+                    3
+                ],
+                [
+                    "ecn",
+                    3
+                ],
+                [
+                    "ctrl",
+                    6
+                ],
+                [
+                    "window",
+                    16
+                ],
+                [
+                    "checksum",
+                    16
+                ],
+                [
+                    "urgentPtr",
+                    16
+                ]
+            ],
+            "length_exp": null,
+            "max_length": null
+        },
+        {
+            "name": "udp_t",
+            "id": 5,
+            "fields": [
+                [
+                    "srcPort",
+                    16
+                ],
+                [
+                    "dstPort",
+                    16
+                ],
+                [
+                    "length_",
+                    16
+                ],
+                [
+                    "checksum",
+                    16
+                ]
+            ],
+            "length_exp": null,
+            "max_length": null
+        }
+    ],
+    "headers": [
+        {
+            "name": "standard_metadata",
+            "id": 0,
+            "header_type": "standard_metadata_t",
+            "metadata": true
+        },
+        {
+            "name": "intrinsic_metadata",
+            "id": 1,
+            "header_type": "intrinsic_metadata_t",
+            "metadata": true
+        },
+        {
+            "name": "ethernet",
+            "id": 2,
+            "header_type": "ethernet_t",
+            "metadata": false
+        },
+        {
+            "name": "ipv4",
+            "id": 3,
+            "header_type": "ipv4_t",
+            "metadata": false
+        },
+        {
+            "name": "tcp",
+            "id": 4,
+            "header_type": "tcp_t",
+            "metadata": false
+        },
+        {
+            "name": "udp",
+            "id": 5,
+            "header_type": "udp_t",
+            "metadata": false
+        }
+    ],
+    "header_stacks": [],
+    "parsers": [
+        {
+            "name": "parser",
+            "id": 0,
+            "init_state": "start",
+            "parse_states": [
+                {
+                    "name": "start",
+                    "id": 0,
+                    "parser_ops": [],
+                    "transition_key": [],
+                    "transitions": [
+                        {
+                            "value": "default",
+                            "mask": null,
+                            "next_state": "parse_ethernet"
+                        }
+                    ]
+                },
+                {
+                    "name": "parse_ethernet",
+                    "id": 1,
+                    "parser_ops": [
+                        {
+                            "op": "extract",
+                            "parameters": [
+                                {
+                                    "type": "regular",
+                                    "value": "ethernet"
+                                }
+                            ]
+                        }
+                    ],
+                    "transition_key": [
+                        {
+                            "type": "field",
+                            "value": [
+                                "ethernet",
+                                "etherType"
+                            ]
+                        }
+                    ],
+                    "transitions": [
+                        {
+                            "value": "0x0800",
+                            "mask": null,
+                            "next_state": "parse_ipv4"
+                        },
+                        {
+                            "value": "default",
+                            "mask": null,
+                            "next_state": null
+                        }
+                    ]
+                },
+                {
+                    "name": "parse_ipv4",
+                    "id": 2,
+                    "parser_ops": [
+                        {
+                            "op": "extract",
+                            "parameters": [
+                                {
+                                    "type": "regular",
+                                    "value": "ipv4"
+                                }
+                            ]
+                        }
+                    ],
+                    "transition_key": [
+                        {
+                            "type": "field",
+                            "value": [
+                                "ipv4",
+                                "fragOffset"
+                            ]
+                        },
+                        {
+                            "type": "field",
+                            "value": [
+                                "ipv4",
+                                "protocol"
+                            ]
+                        }
+                    ],
+                    "transitions": [
+                        {
+                            "value": "0x000006",
+                            "mask": null,
+                            "next_state": "parse_tcp"
+                        },
+                        {
+                            "value": "0x000011",
+                            "mask": null,
+                            "next_state": "parse_udp"
+                        },
+                        {
+                            "value": "default",
+                            "mask": null,
+                            "next_state": null
+                        }
+                    ]
+                },
+                {
+                    "name": "parse_tcp",
+                    "id": 3,
+                    "parser_ops": [
+                        {
+                            "op": "extract",
+                            "parameters": [
+                                {
+                                    "type": "regular",
+                                    "value": "tcp"
+                                }
+                            ]
+                        }
+                    ],
+                    "transition_key": [],
+                    "transitions": [
+                        {
+                            "value": "default",
+                            "mask": null,
+                            "next_state": null
+                        }
+                    ]
+                },
+                {
+                    "name": "parse_udp",
+                    "id": 4,
+                    "parser_ops": [
+                        {
+                            "op": "extract",
+                            "parameters": [
+                                {
+                                    "type": "regular",
+                                    "value": "udp"
+                                }
+                            ]
+                        }
+                    ],
+                    "transition_key": [],
+                    "transitions": [
+                        {
+                            "value": "default",
+                            "mask": null,
+                            "next_state": null
+                        }
+                    ]
+                }
+            ]
+        }
+    ],
+    "deparsers": [
+        {
+            "name": "deparser",
+            "id": 0,
+            "order": [
+                "ethernet",
+                "ipv4",
+                "udp",
+                "tcp"
+            ]
+        }
+    ],
+    "meter_arrays": [],
+    "actions": [
+        {
+            "name": "_drop",
+            "id": 0,
+            "runtime_data": [],
+            "primitives": [
+                {
+                    "op": "modify_field",
+                    "parameters": [
+                        {
+                            "type": "field",
+                            "value": [
+                                "standard_metadata",
+                                "egress_spec"
+                            ]
+                        },
+                        {
+                            "type": "hexstr",
+                            "value": "0x1ff"
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "name": "count_packet",
+            "id": 1,
+            "runtime_data": [],
+            "primitives": [
+                {
+                    "op": "count",
+                    "parameters": [
+                        {
+                            "type": "counter_array",
+                            "value": "ingress_port_counter"
+                        },
+                        {
+                            "type": "field",
+                            "value": [
+                                "standard_metadata",
+                                "ingress_port"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "op": "count",
+                    "parameters": [
+                        {
+                            "type": "counter_array",
+                            "value": "egress_port_counter"
+                        },
+                        {
+                            "type": "field",
+                            "value": [
+                                "standard_metadata",
+                                "egress_spec"
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "name": "send_to_cpu",
+            "id": 2,
+            "runtime_data": [],
+            "primitives": [
+                {
+                    "op": "modify_field",
+                    "parameters": [
+                        {
+                            "type": "field",
+                            "value": [
+                                "standard_metadata",
+                                "egress_spec"
+                            ]
+                        },
+                        {
+                            "type": "hexstr",
+                            "value": "0xff"
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "name": "set_egress_port",
+            "id": 3,
+            "runtime_data": [
+                {
+                    "name": "port",
+                    "bitwidth": 9
+                }
+            ],
+            "primitives": [
+                {
+                    "op": "modify_field",
+                    "parameters": [
+                        {
+                            "type": "field",
+                            "value": [
+                                "standard_metadata",
+                                "egress_spec"
+                            ]
+                        },
+                        {
+                            "type": "runtime_data",
+                            "value": 0
+                        }
+                    ]
+                }
+            ]
+        }
+    ],
+    "pipelines": [
+        {
+            "name": "ingress",
+            "id": 0,
+            "init_table": "table0",
+            "tables": [
+                {
+                    "name": "port_count_table",
+                    "id": 0,
+                    "match_type": "exact",
+                    "type": "simple",
+                    "max_size": 16384,
+                    "with_counters": false,
+                    "direct_meters": null,
+                    "support_timeout": false,
+                    "key": [],
+                    "actions": [
+                        "count_packet"
+                    ],
+                    "next_tables": {
+                        "count_packet": null
+                    },
+                    "default_action": null,
+                    "base_default_next": null
+                },
+                {
+                    "name": "table0",
+                    "id": 1,
+                    "match_type": "ternary",
+                    "type": "simple",
+                    "max_size": 16384,
+                    "with_counters": true,
+                    "direct_meters": null,
+                    "support_timeout": true,
+                    "key": [
+                        {
+                            "match_type": "ternary",
+                            "target": [
+                                "standard_metadata",
+                                "ingress_port"
+                            ],
+                            "mask": null
+                        },
+                        {
+                            "match_type": "ternary",
+                            "target": [
+                                "ethernet",
+                                "dstAddr"
+                            ],
+                            "mask": null
+                        },
+                        {
+                            "match_type": "ternary",
+                            "target": [
+                                "ethernet",
+                                "srcAddr"
+                            ],
+                            "mask": null
+                        },
+                        {
+                            "match_type": "ternary",
+                            "target": [
+                                "ethernet",
+                                "etherType"
+                            ],
+                            "mask": null
+                        }
+                    ],
+                    "actions": [
+                        "set_egress_port",
+                        "send_to_cpu",
+                        "_drop"
+                    ],
+                    "next_tables": {
+                        "set_egress_port": "_condition_0",
+                        "send_to_cpu": "_condition_0",
+                        "_drop": "_condition_0"
+                    },
+                    "default_action": null,
+                    "base_default_next": "_condition_0"
+                }
+            ],
+            "conditionals": [
+                {
+                    "name": "_condition_0",
+                    "id": 0,
+                    "expression": {
+                        "type": "expression",
+                        "value": {
+                            "op": "<",
+                            "left": {
+                                "type": "field",
+                                "value": [
+                                    "standard_metadata",
+                                    "egress_spec"
+                                ]
+                            },
+                            "right": {
+                                "type": "hexstr",
+                                "value": "0xfe"
+                            }
+                        }
+                    },
+                    "true_next": "port_count_table",
+                    "false_next": null
+                }
+            ]
+        },
+        {
+            "name": "egress",
+            "id": 1,
+            "init_table": null,
+            "tables": [],
+            "conditionals": []
+        }
+    ],
+    "calculations": [],
+    "checksums": [],
+    "learn_lists": [],
+    "field_lists": [],
+    "counter_arrays": [
+        {
+            "name": "ingress_port_counter",
+            "id": 0,
+            "is_direct": false,
+            "size": 254
+        },
+        {
+            "name": "egress_port_counter",
+            "id": 1,
+            "is_direct": false,
+            "size": 254
+        },
+        {
+            "name": "table0_counter",
+            "id": 2,
+            "is_direct": true,
+            "binding": "table0"
+        }
+    ],
+    "register_arrays": [],
+    "force_arith": [
+        [
+            "standard_metadata",
+            "ingress_port"
+        ],
+        [
+            "standard_metadata",
+            "packet_length"
+        ],
+        [
+            "standard_metadata",
+            "egress_spec"
+        ],
+        [
+            "standard_metadata",
+            "egress_port"
+        ],
+        [
+            "standard_metadata",
+            "egress_instance"
+        ],
+        [
+            "standard_metadata",
+            "instance_type"
+        ],
+        [
+            "standard_metadata",
+            "clone_spec"
+        ],
+        [
+            "standard_metadata",
+            "_padding"
+        ],
+        [
+            "intrinsic_metadata",
+            "ingress_global_timestamp"
+        ],
+        [
+            "intrinsic_metadata",
+            "lf_field_list"
+        ],
+        [
+            "intrinsic_metadata",
+            "mcast_grp"
+        ],
+        [
+            "intrinsic_metadata",
+            "egress_rid"
+        ]
+    ]
+}
\ No newline at end of file
diff --git a/protocols/bmv2/ctl/src/test/java/org/onosproject/bmv2/ctl/Bmv2FlowRuleTranslatorImplTest.java b/protocols/bmv2/ctl/src/test/java/org/onosproject/bmv2/ctl/Bmv2FlowRuleTranslatorImplTest.java
new file mode 100644
index 0000000..41a774f
--- /dev/null
+++ b/protocols/bmv2/ctl/src/test/java/org/onosproject/bmv2/ctl/Bmv2FlowRuleTranslatorImplTest.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.bmv2.ctl;
+
+import com.google.common.testing.EqualsTester;
+import org.junit.Test;
+import org.onlab.packet.MacAddress;
+import org.onosproject.bmv2.api.context.Bmv2Configuration;
+import org.onosproject.bmv2.api.context.Bmv2DeviceContext;
+import org.onosproject.bmv2.api.context.Bmv2FlowRuleTranslator;
+import org.onosproject.bmv2.api.context.Bmv2Interpreter;
+import org.onosproject.bmv2.api.runtime.Bmv2TableEntry;
+import org.onosproject.bmv2.api.runtime.Bmv2TernaryMatchParam;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.DefaultApplicationId;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.PortNumber;
+import org.onosproject.net.flow.DefaultFlowRule;
+import org.onosproject.net.flow.DefaultTrafficSelector;
+import org.onosproject.net.flow.DefaultTrafficTreatment;
+import org.onosproject.net.flow.FlowRule;
+import org.onosproject.net.flow.TrafficSelector;
+import org.onosproject.net.flow.TrafficTreatment;
+
+import java.util.Random;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.onosproject.bmv2.ctl.Bmv2DefaultInterpreterImpl.TABLE0;
+
+/**
+ * Tests for {@link Bmv2FlowRuleTranslatorImpl}.
+ */
+public class Bmv2FlowRuleTranslatorImplTest {
+
+    private Random random = new Random();
+    private Bmv2Configuration configuration = Bmv2DeviceContextServiceImpl.loadDefaultConfiguration();
+    private Bmv2Interpreter interpreter = new Bmv2DefaultInterpreterImpl();
+    private Bmv2DeviceContext context = new Bmv2DeviceContext(configuration, interpreter);
+    private Bmv2FlowRuleTranslator translator = new Bmv2FlowRuleTranslatorImpl();
+
+    @Test
+    public void testTranslate() throws Exception {
+
+        DeviceId deviceId = DeviceId.NONE;
+        ApplicationId appId = new DefaultApplicationId(1, "test");
+        int tableId = 0;
+        MacAddress ethDstMac = MacAddress.valueOf(random.nextLong());
+        MacAddress ethSrcMac = MacAddress.valueOf(random.nextLong());
+        short ethType = (short) (0x0000FFFF & random.nextInt());
+        short outPort = (short) random.nextInt(65);
+        short inPort = (short) random.nextInt(65);
+        int timeout = random.nextInt(100);
+        int priority = random.nextInt(100);
+
+        TrafficSelector matchInPort1 = DefaultTrafficSelector
+                .builder()
+                .matchInPort(PortNumber.portNumber(inPort))
+                .matchEthDst(ethDstMac)
+                .matchEthSrc(ethSrcMac)
+                .matchEthType(ethType)
+                .build();
+
+        TrafficTreatment outPort2 = DefaultTrafficTreatment
+                .builder()
+                .setOutput(PortNumber.portNumber(outPort))
+                .build();
+
+        FlowRule rule1 = DefaultFlowRule.builder()
+                .forDevice(deviceId)
+                .forTable(tableId)
+                .fromApp(appId)
+                .withSelector(matchInPort1)
+                .withTreatment(outPort2)
+                .makeTemporary(timeout)
+                .withPriority(priority)
+                .build();
+
+        FlowRule rule2 = DefaultFlowRule.builder()
+                .forDevice(deviceId)
+                .forTable(tableId)
+                .fromApp(appId)
+                .withSelector(matchInPort1)
+                .withTreatment(outPort2)
+                .makeTemporary(timeout)
+                .withPriority(priority)
+                .build();
+
+        Bmv2TableEntry entry1 = translator.translate(rule1, context);
+        Bmv2TableEntry entry2 = translator.translate(rule1, context);
+
+        // check equality, i.e. same rules must produce same entries
+        new EqualsTester()
+                .addEqualityGroup(rule1, rule2)
+                .addEqualityGroup(entry1, entry2)
+                .testEquals();
+
+        int numMatchParams = configuration.table(TABLE0).keys().size();
+        // parse values stored in entry1
+        Bmv2TernaryMatchParam inPortParam = (Bmv2TernaryMatchParam) entry1.matchKey().matchParams().get(0);
+        Bmv2TernaryMatchParam ethDstParam = (Bmv2TernaryMatchParam) entry1.matchKey().matchParams().get(1);
+        Bmv2TernaryMatchParam ethSrcParam = (Bmv2TernaryMatchParam) entry1.matchKey().matchParams().get(2);
+        Bmv2TernaryMatchParam ethTypeParam = (Bmv2TernaryMatchParam) entry1.matchKey().matchParams().get(3);
+        double expectedTimeout = (double) (configuration.table(TABLE0).hasTimeouts() ? rule1.timeout() : -1);
+
+        // check that the number of parameters in the entry is the same as the number of table keys
+        assertThat("Incorrect number of match parameters",
+                   entry1.matchKey().matchParams().size(), is(equalTo(numMatchParams)));
+
+        // check that values stored in entry are the same used for the flow rule
+        assertThat("Incorrect inPort match param value",
+                   inPortParam.value().asReadOnlyBuffer().getShort(), is(equalTo(inPort)));
+        assertThat("Incorrect ethDestMac match param value",
+                   ethDstParam.value().asArray(), is(equalTo(ethDstMac.toBytes())));
+        assertThat("Incorrect ethSrcMac match param value",
+                   ethSrcParam.value().asArray(), is(equalTo(ethSrcMac.toBytes())));
+        assertThat("Incorrect ethType match param value",
+                   ethTypeParam.value().asReadOnlyBuffer().getShort(), is(equalTo(ethType)));
+        assertThat("Incorrect priority value",
+                   entry1.priority(), is(equalTo(Integer.MAX_VALUE - rule1.priority())));
+        assertThat("Incorrect timeout value",
+                   entry1.timeout(), is(equalTo(expectedTimeout)));
+
+    }
+}
\ No newline at end of file
diff --git a/protocols/bmv2/ctl/src/test/java/org/onosproject/bmv2/ctl/Bmv2TableDumpParserTest.java b/protocols/bmv2/ctl/src/test/java/org/onosproject/bmv2/ctl/Bmv2TableDumpParserTest.java
new file mode 100644
index 0000000..973fcd5
--- /dev/null
+++ b/protocols/bmv2/ctl/src/test/java/org/onosproject/bmv2/ctl/Bmv2TableDumpParserTest.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.bmv2.ctl;
+
+import org.junit.Test;
+import org.onosproject.bmv2.api.context.Bmv2Configuration;
+import org.onosproject.bmv2.api.runtime.Bmv2ParsedTableEntry;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.List;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+public class Bmv2TableDumpParserTest {
+
+    private Bmv2Configuration configuration = Bmv2DeviceContextServiceImpl.loadDefaultConfiguration();
+
+    @Test
+    public void testParse() throws Exception {
+        String text = readFile();
+        List<Bmv2ParsedTableEntry> result = Bmv2TableDumpParser.parse(text, configuration);
+        assertThat(result.size(), equalTo(10));
+    }
+
+    private String readFile()
+            throws IOException, URISyntaxException {
+        byte[] encoded = Files.readAllBytes(Paths.get(this.getClass().getResource("/tabledump.txt").toURI()));
+        return new String(encoded, Charset.defaultCharset());
+    }
+}
diff --git a/protocols/bmv2/ctl/src/test/resources/tabledump.txt b/protocols/bmv2/ctl/src/test/resources/tabledump.txt
new file mode 100644
index 0000000..392ceb8
--- /dev/null
+++ b/protocols/bmv2/ctl/src/test/resources/tabledump.txt
@@ -0,0 +1,10 @@
+0: 0000 000000000000 000000000000 0806 &&& 0000000000000000000000000000ffff => send_to_cpu -
+1: 0000 000000000000 000000000000 0800 &&& 0000000000000000000000000000ffff => send_to_cpu -
+2: 0000 000000000000 000000000000 88cc &&& 0000000000000000000000000000ffff => send_to_cpu -
+3: 0000 000000000000 000000000000 8942 &&& 0000000000000000000000000000ffff => send_to_cpu -
+4: 0001 000400000001 000400000000 0000 &&& ffffffffffffffffffffffffffff0000 => set_egress_port - 2,
+5: 0002 000400000000 000400000001 0000 &&& ffffffffffffffffffffffffffff0000 => set_egress_port - 1,
+51539607552: 0001 0000 => set_egress_port - 1,
+51539607553: 0001 0002 => set_egress_port - 3,
+51539607554: 0001 0001 => set_egress_port - 2,
+51539607555: 0001 0003 => set_egress_port - 4,
\ No newline at end of file