diff --git a/TestON/drivers/common/cli/onosclusterdriver.py b/TestON/drivers/common/cli/onosclusterdriver.py
index eebc5ad..8b25d22 100755
--- a/TestON/drivers/common/cli/onosclusterdriver.py
+++ b/TestON/drivers/common/cli/onosclusterdriver.py
@@ -54,7 +54,7 @@
         name. This method should return the (computed) attribute value
         or raise an AttributeError exception.
 
-        We will look into each of the node's component handles to try to find the attreibute, looking at REST first
+        We will look into each of the node's component handles to try to find the attribute, looking at REST first
         """
         if hasattr( self.REST, name ):
             main.log.debug( "%s: Using Rest driver's attribute for '%s'" % ( self.name, name ) )
@@ -65,10 +65,13 @@
         if hasattr( self.Bench, name ):
             main.log.debug( "%s: Using Bench driver's attribute for '%s'" % ( self.name, name ) )
             return getattr( self.Bench, name )
+        if hasattr( self.p4rtUp4, name ):
+            main.log.debug( "%s: Using UP4 driver's attribute for '%s'" % ( self.name, name ) )
+            return getattr( self.p4rtUp4, name )
         raise AttributeError( "Could not find the attribute %s in %r or it's component handles" % ( name, self ) )
 
     def __init__( self, name, ipAddress, CLI=None, REST=None, Bench=None, pos=None,
-                  userName=None, server=None, k8s=None, dockerPrompt=None ):
+                  userName=None, server=None, k8s=None, p4rtUp4=None, dockerPrompt=None ):
         # TODO: validate these arguments
         self.name = str( name )
         self.ipAddress = ipAddress
@@ -81,6 +84,7 @@
         self.user_name = userName
         self.server = server
         self.k8s = k8s
+        self.p4rtUp4 = p4rtUp4
         self.dockerPrompt = dockerPrompt
 
 class OnosClusterDriver( CLI ):
@@ -101,6 +105,7 @@
         self.nodeUser = None
         self.nodePass = None
         self.nodes = []
+        self.up4Port = None
         super( OnosClusterDriver, self ).__init__()
 
     def connect( self, **connectargs ):
@@ -145,6 +150,9 @@
                     self.maxNodes = self.options[ key ]
                 elif key == "kubeConfig":
                     self.kubeConfig = self.options[ key ]
+                elif key == "up4_port":
+                    # Defining up4_port triggers the creation of the P4RuntimeCliDriver component
+                    self.up4Port = self.options[ key ]
 
             self.home = self.checkOptions( self.home, "~/onos" )
             self.karafUser = self.checkOptions( self.karafUser, self.user_name )
@@ -160,6 +168,7 @@
             self.dockerPrompt = self.checkOptions( self.dockerPrompt, "~/onos#" )
             self.maxNodes = int( self.checkOptions( self.maxNodes, 100 ) )
             self.kubeConfig = self.checkOptions( self.kubeConfig, None )
+            self.up4Port = self.checkOptions(self.up4Port, None)
 
             self.name = self.options[ 'name' ]
 
@@ -243,14 +252,19 @@
                         # Setup port-forwarding and save the local port
                         guiPort = 8181
                         cliPort = 8101
+                        fwdPorts = [ guiPort, cliPort ]
+                        if self.up4Port:
+                            fwdPorts.append( int( self.up4Port ) )
                         portsList = ""
-                        for port in [ guiPort, cliPort ]:
+                        for port in fwdPorts:
                             localPort = port + index + 1
                             portsList += "%s:%s " % ( localPort, port )
                             if port == cliPort:
                                 node.CLI.karafPort = localPort
                             elif port == guiPort:
                                 node.REST.port = localPort
+                            elif self.up4Port and port == int( self.up4Port ):
+                                node.p4rtUp4.p4rtPort = localPort
                         main.log.info( "Setting up port forward for pod %s: [ %s ]" % ( self.podNames[ index ], portsList ) )
                         pf = kubectl.kubectlPortForward( self.podNames[ index ],
                                                          portsList,
@@ -466,6 +480,51 @@
             main.log.error( name + " component already exists!" )
             main.cleanAndExit()
 
+    def setP4rtCLIOptions( self, name, ipAddress ):
+        """
+        Parse the cluster options to create an UP4 component with the given name
+
+        Arguments:
+            name - The name of the P4RuntimeCLI component
+            ipAddress - The ip address of the ONOS instance
+        """
+        main.componentDictionary[name] = main.componentDictionary[self.name].copy()
+        main.componentDictionary[name]['type'] = "P4RuntimeCliDriver"
+        main.componentDictionary[name]['host'] = ipAddress
+        port = main.componentDictionary[name]['COMPONENTS'].get( "p4rt_port", "9559" )
+        main.componentDictionary[name]['p4rt_port'] = self.checkOptions( port, "9559" )
+        main.componentDictionary[name]['connect_order'] = str( int( main.componentDictionary[name]['connect_order'] ) + 1 )
+
+    def createP4rtCLIComponent( self, name, ipAddress ):
+        """
+        Creates a new P4Runtime CLI component. This will be connected to the node
+        ONOS is running on.
+
+        Arguments:
+            name - The string of the name of this component. The new component
+                   will be assigned to main.<name> .
+                   In addition, main.<name>.name = str( name )
+            ipAddress - The ip address of the server
+        """
+        try:
+            # look to see if this component already exists
+            getattr( main, name )
+        except AttributeError:
+            # namespace is clear, creating component
+            self.setP4rtCLIOptions( name, ipAddress )
+            return main.componentInit( name )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
+            main.cleanAndExit()
+        except Exception:
+            main.log.exception( self.name + ": Uncaught exception!" )
+            main.cleanAndExit()
+        else:
+            # namespace is not clear!
+            main.log.error( name + " component already exists!" )
+            main.cleanAndExit()
+
     def createComponents( self, prefix='', createServer=True ):
         """
         Creates a CLI and REST component for each nodes in the cluster
@@ -476,6 +535,7 @@
         benchPrefix = prefix + "bench"
         serverPrefix = prefix + "server"
         k8sPrefix = prefix + "k8s"
+        up4Prefix = prefix + "up4cl"
         for i in xrange( 1, self.maxNodes + 1 ):
             cliName = cliPrefix + str( i  )
             restName = restPrefix + str( i )
@@ -483,6 +543,8 @@
             serverName = serverPrefix + str( i )
             if self.kubeConfig:
                 k8sName = k8sPrefix + str( i )
+            if self.up4Port:
+                up4Name = up4Prefix + str( i )
 
             # Unfortunately this means we need to have a cell set beofre running TestON,
             # Even if it is just the entire possible cluster size
@@ -493,9 +555,10 @@
             bench = self.createBenchComponent( benchName )
             server = self.createServerComponent( serverName, ip ) if createServer else None
             k8s = self.createServerComponent( k8sName, ip ) if self.kubeConfig else None
+            p4rtUp4 = self.createP4rtCLIComponent( up4Name, ip ) if self.up4Port else None
             if self.kubeConfig:
                 k8s.kubeConfig = self.kubeConfig
                 k8s.podName = None
             self.nodes.append( Controller( prefix + str( i ), ip, cli, rest, bench, i - 1,
                                            self.user_name, server=server, k8s=k8s,
-                                           dockerPrompt=self.dockerPrompt ) )
+                                           p4rtUp4=p4rtUp4, dockerPrompt=self.dockerPrompt ) )
diff --git a/TestON/drivers/common/cli/p4runtimeclidriver.py b/TestON/drivers/common/cli/p4runtimeclidriver.py
new file mode 100644
index 0000000..6728cba
--- /dev/null
+++ b/TestON/drivers/common/cli/p4runtimeclidriver.py
@@ -0,0 +1,361 @@
+"""
+Copyright 2021 Open Networking Foundation (ONF)
+
+Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>,
+the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>,
+or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg>
+
+"""
+
+import pexpect
+import os
+from drivers.common.clidriver import CLI
+
+
+class P4RuntimeCliDriver(CLI):
+    """
+    Implements a P4Runtime Client CLI-based driver to control devices that uses
+    the P4Runtime Protocol, using the P4Runtime shell CLI.
+
+    This driver requires that P4Runtime CLI is configured to not generated colored
+    text. To do so, add the following lines to a file in
+    ~/.ipython/profile_default/ipython_config.py:
+        c.InteractiveShell.color_info = False
+        c.InteractiveShell.colors = 'NoColor'
+        c.TerminalInteractiveShell.color_info = False
+        c.TerminalInteractiveShell.colors = 'NoColor'
+    """
+
+    def __init__(self):
+        """
+        Initialize client
+        """
+        super(P4RuntimeCliDriver, self).__init__()
+        self.name = None
+        self.handle = None
+        self.p4rtAddress = "localhost"
+        self.p4rtPort = "9559"  # Default P4RT server port
+        self.prompt = "\$"
+        self.p4rtShPrompt = ">>>"
+        self.p4rtDeviceId = "1"
+        self.p4rtElectionId = "0,100"  # (high,low)
+        self.p4rtConfig = None  # Can be used to pass a path to the P4Info and pipeline config
+
+    def connect(self, **connectargs):
+        """
+        Creates the ssh handle for the P4Runtime CLI
+        The ip_address would come from the topo file using the host tag, the
+        value can be an environment variable as well as a "localhost" to get
+        the ip address needed to ssh to the "bench"
+        """
+        try:
+            for key in connectargs:
+                vars(self)[key] = connectargs[key]
+            self.name = self.options.get("name", "")
+            self.p4rtAddress = self.options.get("p4rt_address", "localhost")
+            self.p4rtPort = self.options.get("p4rt_port", "9559")
+            self.p4rtShPrompt = self.options.get("p4rt_sh_prompt", ">>>")
+            self.p4rtDeviceId = self.options.get("p4rt_device_id", "1")
+            self.p4rtElectionId = self.options.get("p4rt_election_id", "0,100")
+            self.p4rtConfig = self.options.get("p4rt_config", None)
+            try:
+                if os.getenv(str(self.ip_address)) is not None:
+                    self.ip_address = os.getenv(str(self.ip_address))
+                else:
+                    main.log.info(self.name + ": ip set to " + self.ip_address)
+            except KeyError:
+                main.log.info(self.name + ": Invalid host name," +
+                              "defaulting to 'localhost' instead")
+                self.ip_address = 'localhost'
+            except Exception as inst:
+                main.log.error("Uncaught exception: " + str(inst))
+
+            self.handle = super(P4RuntimeCliDriver, self).connect(
+                user_name=self.user_name,
+                ip_address=self.ip_address,
+                port=None,
+                pwd=self.pwd)
+            if self.handle:
+                main.log.info("Connection successful to the host " +
+                              self.user_name +
+                              "@" +
+                              self.ip_address)
+                self.handle.sendline("")
+                self.handle.expect(self.prompt)
+                return main.TRUE
+            else:
+                main.log.error("Connection failed to " +
+                               self.user_name +
+                               "@" +
+                               self.ip_address)
+                return main.FALSE
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":     " + self.handle.before)
+            main.cleanAndExit()
+        except Exception:
+            main.log.exception(self.name + ": Uncaught exception!")
+            main.cleanAndExit()
+
+    def startP4RtClient(self, pushConfig=False):
+        """
+        Start the P4Runtime shell CLI client
+
+        :param pushConfig: True if you want to push the pipeline config, False otherwise
+            requires the p4rt_config configuration parameter to be set
+        :return:
+        """
+        try:
+            main.log.debug(self.name + ": Starting P4Runtime Shell CLI")
+            grpcAddr = "%s:%s" % (self.p4rtAddress, self.p4rtPort)
+            startP4RtShLine = "python3 -m p4runtime_sh --grpc-addr " + grpcAddr + \
+                              " --device-id " + self.p4rtDeviceId + \
+                              " --election-id " + self.p4rtElectionId
+            if pushConfig:
+                if self.p4rtConfig:
+                    startP4RtShLine += " --config " + self.p4rtConfig
+                else:
+                    main.log.error(
+                        "You should provide a P4 Runtime config to push!")
+                    main.cleanAndExit()
+            response = self.__clearSendAndExpect(startP4RtShLine)
+            self.preDisconnect = self.stopP4RtClient
+        except pexpect.TIMEOUT:
+            main.log.exception(self.name + ": Command timed out")
+            return main.FALSE
+        except pexpect.EOF:
+            main.log.exception(self.name + ": connection closed.")
+            main.cleanAndExit()
+        except Exception:
+            main.log.exception(self.name + ": Uncaught exception!")
+            main.cleanAndExit()
+
+    def stopP4RtClient(self):
+        """
+        Exit the P4Runtime shell CLI
+        """
+        try:
+            main.log.debug(self.name + ": Stopping P4Runtime Shell CLI")
+            self.handle.sendline("exit")
+            self.handle.expect(self.prompt)
+            return main.TRUE
+        except pexpect.TIMEOUT:
+            main.log.exception(self.name + ": Command timed out")
+            return main.FALSE
+        except pexpect.EOF:
+            main.log.exception(self.name + ": connection closed.")
+            main.cleanAndExit()
+        except Exception:
+            main.log.exception(self.name + ": Uncaught exception!")
+            main.cleanAndExit()
+
+    def pushTableEntry(self, tableEntry=None, debug=True):
+        """
+        Push a table entry with either the given table entry or use the saved
+        table entry in the variable 'te'.
+
+        Example of a valid tableEntry string:
+        te = table_entry["FabricIngress.forwarding.routing_v4"](action="set_next_id_routing_v4"); te.action["next_id"] = "10"; te.match["ipv4_dst"] = "10.0.0.0" # nopep8
+
+        :param tableEntry: the string table entry, if None it uses the table
+            entry saved in the 'te' variable
+        :param debug: True to enable debug logging, False otherwise
+        :return: main.TRUE or main.FALSE on error
+        """
+        try:
+            main.log.debug(self.name + ": Pushing Table Entry")
+            if debug:
+                self.handle.sendline("te")
+                self.handle.expect(self.p4rtShPrompt)
+            pushCmd = ""
+            if tableEntry:
+                pushCmd = tableEntry + ";"
+            pushCmd += "te.insert()"
+            response = self.__clearSendAndExpect(pushCmd)
+            if "Traceback" in response or "Error" in response:
+                # TODO: other possibile errors?
+                # NameError...
+                main.log.error(
+                    self.name + ": Error in pushing table entry: " + response)
+                return main.FALSE
+            return main.TRUE
+        except pexpect.TIMEOUT:
+            main.log.exception(self.name + ": Command timed out")
+            return main.FALSE
+        except pexpect.EOF:
+            main.log.exception(self.name + ": connection closed.")
+            main.cleanAndExit()
+        except Exception:
+            main.log.exception(self.name + ": Uncaught exception!")
+            main.cleanAndExit()
+
+    def deleteTableEntry(self, tableEntry=None, debug=True):
+        """
+        Deletes a table entry with either the given table entry or use the saved
+        table entry in the variable 'te'.
+
+        Example of a valid tableEntry string:
+        te = table_entry["FabricIngress.forwarding.routing_v4"](action="set_next_id_routing_v4"); te.action["next_id"] = "10"; te.match["ipv4_dst"] = "10.0.0.0" # nopep8
+
+        :param tableEntry: the string table entry, if None it uses the table
+            entry saved in the 'te' variable
+        :param debug: True to enable debug logging, False otherwise
+        :return: main.TRUE or main.FALSE on error
+        """
+        try:
+            main.log.debug(self.name + ": Deleting Table Entry")
+            if debug:
+                self.__clearSendAndExpect("te")
+            pushCmd = ""
+            if tableEntry:
+                pushCmd = tableEntry + ";"
+            pushCmd += "te.delete()"
+            response = self.__clearSendAndExpect(pushCmd)
+            main.log.debug(
+                self.name + ": Delete table entry response: {}".format(
+                    response))
+            if "Traceback" in response or "Error" in response:
+                # TODO: other possibile errors?
+                # NameError...
+                main.log.error(
+                    self.name + ": Error in deleting table entry: " + response)
+                return main.FALSE
+            return main.TRUE
+        except pexpect.TIMEOUT:
+            main.log.exception(self.name + ": Command timed out")
+            return main.FALSE
+        except pexpect.EOF:
+            main.log.exception(self.name + ": connection closed.")
+            main.cleanAndExit()
+        except Exception:
+            main.log.exception(self.name + ": Uncaught exception!")
+            main.cleanAndExit()
+
+    def buildP4RtTableEntry(self, tableName, actionName, actionParams={},
+                            matchFields={}):
+        """
+        Build a Table Entry
+        :param tableName: The name of table
+        :param actionName: The name of the action
+        :param actionParams: A dictionary containing name and values for the action parameters
+        :param matchFields: A dictionary containing name and values for the match fields
+        :return: main.TRUE or main.FALSE on error
+        """
+        # TODO: improve error checking when creating the table entry, add
+        #  params, and match fields.
+        try:
+            main.log.debug(self.name + ": Building P4RT Table Entry")
+            cmd = 'te = table_entry["%s"](action="%s"); ' % (
+                tableName, actionName)
+
+            # Action Parameters
+            for name, value in actionParams.items():
+                cmd += 'te.action["%s"]="%s";' % (name, str(value))
+
+            # Match Fields
+            for name, value in matchFields.items():
+                cmd += 'te.match["%s"]="%s";' % (name, str(value))
+
+            response = self.__clearSendAndExpect(cmd)
+            if "Unknown action" in response:
+                main.log.error("Unknown action: " + response)
+                return main.FALSE
+            if "AttributeError" in response:
+                main.log.error("Wrong action: " + response)
+                return main.FALSE
+            if "Invalid value" in response:
+                main.log.error("Invalid action value: " + response)
+                return main.FALSE
+            if "Action parameter value must be a string" in response:
+                main.log.error(
+                    "Action parameter value must be a string: " + response)
+                return main.FALSE
+            if "table" in response and "does not exist" in response:
+                main.log.error("Unknown table: " + response)
+                return main.FALSE
+            if "not a valid match field name" in response:
+                main.log.error("Invalid match field name: " + response)
+                return main.FALSE
+            if "is not a valid" in response:
+                main.log.error("Invalid match field: " + response)
+                return main.FALSE
+            if "Traceback" in response:
+                main.log.error("Error in creating the table entry: " + response)
+                return main.FALSE
+            return main.TRUE
+        except pexpect.TIMEOUT:
+            main.log.exception(self.name + ": Command timed out")
+            return main.FALSE
+        except pexpect.EOF:
+            main.log.exception(self.name + ": connection closed.")
+            main.cleanAndExit()
+        except Exception:
+            main.log.exception(self.name + ": Uncaught exception!")
+            main.cleanAndExit()
+
+    def disconnect(self):
+        """
+        Called at the end of the test to stop the p4rt CLI component and
+        disconnect the handle.
+        """
+        response = main.TRUE
+        try:
+            if self.handle:
+                self.handle.sendline("")
+                i = self.handle.expect([self.p4rtShPrompt, pexpect.TIMEOUT],
+                                       timeout=2)
+                if i != 1:
+                    # If the p4rtShell is still connected make sure to
+                    # disconnect it before
+                    self.stopP4RtClient()
+                i = self.handle.expect([self.prompt, pexpect.TIMEOUT],
+                                       timeout=2)
+                if i == 1:
+                    main.log.warn(
+                        self.name + ": timeout when waiting for response")
+                    main.log.warn(
+                        self.name + ": response: " + str(self.handle.before))
+                self.handle.sendline("exit")
+                i = self.handle.expect(["closed", pexpect.TIMEOUT], timeout=2)
+                if i == 1:
+                    main.log.warn(
+                        self.name + ": timeout when waiting for response")
+                    main.log.warn(
+                        self.name + ": response: " + str(self.handle.before))
+            return main.TRUE
+        except TypeError:
+            main.log.exception(self.name + ": Object not as expected")
+            response = main.FALSE
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":     " + self.handle.before)
+        except ValueError:
+            main.log.exception("Exception in disconnect of " + self.name)
+            response = main.TRUE
+        except Exception:
+            main.log.exception(self.name + ": Connection failed to the host")
+            response = main.FALSE
+        return response
+
+    def __clearSendAndExpect(self, cmd):
+        self.clearBuffer()
+        self.handle.sendline(cmd)
+        self.handle.expect(self.p4rtShPrompt)
+        return self.handle.before
+
+    def clearBuffer(self, debug=False):
+        """
+        Keep reading from buffer until it's empty
+        """
+        i = 0
+        response = ''
+        while True:
+            try:
+                i += 1
+                # clear buffer
+                if debug:
+                    main.log.warn("%s expect loop iteration" % i)
+                self.handle.expect(self.p4rtShPrompt, timeout=5)
+                response += self.cleanOutput(self.handle.before, debug)
+            except pexpect.TIMEOUT:
+                return response