diff --git a/TestON/drivers/common/cli/emulator/remotemininetdriver.py b/TestON/drivers/common/cli/emulator/remotemininetdriver.py
index 48d3389..a8aedea 100644
--- a/TestON/drivers/common/cli/emulator/remotemininetdriver.py
+++ b/TestON/drivers/common/cli/emulator/remotemininetdriver.py
@@ -1,14 +1,14 @@
 #!/usr/bin/env python
-'''
+"""
 Created on 26-Oct-2012
 
-@author: Anil Kumar (anilkumar.s@paxterrasolutions.com)
+author:: Anil Kumar ( anilkumar.s@paxterrasolutions.com )
 
 
     TestON is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation, either version 2 of the License, or
-    (at your option) any later version.
+    ( at your option ) any later version.
 
     TestON is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -20,449 +20,536 @@
 
 
 MininetCliDriver is the basic driver which will handle the Mininet functions
-'''
+"""
 import traceback
 import pexpect
 import re
 import sys
-sys.path.append("../")
+sys.path.append( "../" )
 from drivers.common.cli.emulatordriver import Emulator
 
-class RemoteMininetDriver(Emulator):
-    '''
+
+class RemoteMininetDriver( Emulator ):
+
+    """
     RemoteMininetCliDriver is the basic driver which will handle the Mininet functions
     The main different between this and the MininetCliDriver is that this one does not build the mininet.
     It assumes that there is already a mininet running on the target.
-    '''
-    def __init__(self):
-        super(Emulator, self).__init__()
+    """
+    def __init__( self ):
+        super( Emulator, self ).__init__()
         self.handle = self
-        self.wrapped = sys.modules[__name__]
+        self.wrapped = sys.modules[ __name__ ]
         self.flag = 0
 
-    def connect(self, **connectargs):
-        #,user_name, ip_address, pwd,options):
-        # Here the main is the TestON instance after creating all the log handles.
+    def connect( self, **connectargs ):
+        #,user_name, ip_address, pwd,options ):
+        # Here the main is the TestON instance after creating all the log
+        # handles.
         for key in connectargs:
-            vars(self)[key] = connectargs[key]
+            vars( self )[ key ] = connectargs[ key ]
 
-        self.name = self.options['name']
-        self.handle = super(RemoteMininetDriver, self).connect(user_name = self.user_name, ip_address = self.ip_address,port = None, pwd = self.pwd)
+        self.name = self.options[ 'name' ]
+        self.handle = super(
+            RemoteMininetDriver,
+            self ).connect(
+            user_name=self.user_name,
+            ip_address=self.ip_address,
+            port=None,
+            pwd=self.pwd )
 
         self.ssh_handle = self.handle
 
         # Copying the readme file to process the
-        if self.handle :
+        if self.handle:
             return main.TRUE
 
-        else :
-            main.log.error("Connection failed to the host "+self.user_name+"@"+self.ip_address)
-            main.log.error("Failed to connect to the Mininet")
+        else:
+            main.log.error(
+                "Connection failed to the host " +
+                self.user_name +
+                "@" +
+                self.ip_address )
+            main.log.error( "Failed to connect to the Mininet" )
             return main.FALSE
 
-#*********************************************************************************************
-#*********************************************************************************************
+#*************************************************************************
+#*************************************************************************
 # checkForLoss will determine if any of the pings had any packets lost during the course of
 # the pingLong.
-#*********************************************************************************************
-#*********************************************************************************************
+#*************************************************************************
+#*************************************************************************
 
-    def checkForLoss(self, pingList):
-        '''
+    def checkForLoss( self, pingList ):
+        """
         Returns main.FALSE for 0% packet loss and
         Returns main.ERROR if "found multiple mininet" is found and
         Returns main.TRUE else
-        '''
-        #TODO: maybe we want to return the % loss instead? This way we can set an acceptible loss %.
-        #EX: 393 packets transmitted, 380 received, 3% packet loss, time 78519ms
+        """
+        # TODO: maybe we want to return the % loss instead? This way we can set an acceptible loss %.
+        # EX: 393 packets transmitted, 380 received, 3% packet loss, time 78519ms
         # we may need to return a float to get around rounding errors
 
-        self.handle.sendline("")
-        self.handle.expect("\$")
-        #Clear any output waiting in the bg from killing pings
-        self.handle.sendline("")
-        self.handle.expect("\$")
-        self.handle.sendline("cat " + pingList)
-        self.handle.expect(pingList)
-        self.handle.expect("\$")
+        self.handle.sendline( "" )
+        self.handle.expect( "\$" )
+        # Clear any output waiting in the bg from killing pings
+        self.handle.sendline( "" )
+        self.handle.expect( "\$" )
+        self.handle.sendline( "cat " + pingList )
+        self.handle.expect( pingList )
+        self.handle.expect( "\$" )
         outputs = self.handle.before + self.handle.after
-        if re.search(" 0% packet loss",outputs):
+        if re.search( " 0% packet loss", outputs ):
             return main.FALSE
-        elif re.search("found multiple mininet",outputs):
+        elif re.search( "found multiple mininet", outputs ):
             return main.ERROR
         else:
-            main.log.error("Error, unexpected output in the ping file")
+            main.log.error( "Error, unexpected output in the ping file" )
             main.log.warn( outputs )
             return main.TRUE
 
-
-
-    def pingLong(self,**pingParams):
-        '''
+    def pingLong( self, **pingParams ):
+        """
         Starts a continuous ping on the mininet host outputing to a file in the /tmp dir.
-        '''
-        self.handle.sendline("")
-        self.handle.expect("\$")
-        args = utilities.parse_args(["SRC","TARGET","PINGTIME"],**pingParams)
-        precmd = "sudo rm /tmp/ping." + args["SRC"]
-        self.execute(cmd=precmd,prompt="(.*)",timeout=10)
-        command = "sudo mininet/util/m " + args["SRC"] + " ping "+args ["TARGET"]+" -i .2 -w " + str(args['PINGTIME']) + " -D > /tmp/ping." + args["SRC"] + " &"
+        """
+        self.handle.sendline( "" )
+        self.handle.expect( "\$" )
+        args = utilities.parse_args(
+            [ "SRC", "TARGET", "PINGTIME" ], **pingParams )
+        precmd = "sudo rm /tmp/ping." + args[ "SRC" ]
+        self.execute( cmd=precmd, prompt="(.*)", timeout=10 )
+        command = "sudo mininet/util/m " + args[ "SRC" ] + " ping " + args[
+            "TARGET" ] + " -i .2 -w " + str( args[ 'PINGTIME' ] ) + " -D > /tmp/ping." + args[ "SRC" ] + " &"
         main.log.info( command )
-        self.execute(cmd=command,prompt="(.*)",timeout=10)
-        self.handle.sendline("")
-        self.handle.expect("\$")
+        self.execute( cmd=command, prompt="(.*)", timeout=10 )
+        self.handle.sendline( "" )
+        self.handle.expect( "\$" )
         return main.TRUE
 
-    def pingstatus(self,**pingParams):
-        '''
+    def pingstatus( self, **pingParams ):
+        """
         Tails the respective ping output file and check that there is a moving "64 bytes"
-        '''
-        self.handle.sendline("")
-        self.handle.expect("\$")
-        args = utilities.parse_args(["SRC"],**pingParams)
-        self.handle.sendline("tail /tmp/ping." + args["SRC"])
-        self.handle.expect("tail")
-        self.handle.expect("\$")
+        """
+        self.handle.sendline( "" )
+        self.handle.expect( "\$" )
+        args = utilities.parse_args( [ "SRC" ], **pingParams )
+        self.handle.sendline( "tail /tmp/ping." + args[ "SRC" ] )
+        self.handle.expect( "tail" )
+        self.handle.expect( "\$" )
         result = self.handle.before + self.handle.after
-        self.handle.sendline("")
-        self.handle.expect("\$")
-        if re.search('Unreachable', result ):
-            main.log.info("Unreachable found in ping logs...")
+        self.handle.sendline( "" )
+        self.handle.expect( "\$" )
+        if re.search( 'Unreachable', result ):
+            main.log.info( "Unreachable found in ping logs..." )
             return main.FALSE
-        elif re.search('64\sbytes', result):
-            main.log.info("Pings look good")
+        elif re.search( '64\sbytes', result ):
+            main.log.info( "Pings look good" )
             return main.TRUE
         else:
-            main.log.info("No, or faulty ping data...")
+            main.log.info( "No, or faulty ping data..." )
             return main.FALSE
 
-    def pingKill(self, testONUser, testONIP):
-        '''
+    def pingKill( self, testONUser, testONIP ):
+        """
         Kills all continuous ping processes.
         Then copies all the ping files to the TestStation.
-        '''
-        self.handle.sendline("")
-        self.handle.expect("\$")
+        """
+        self.handle.sendline( "" )
+        self.handle.expect( "\$" )
         command = "sudo kill -SIGINT `pgrep ping`"
         main.log.info( command )
-        self.execute(cmd=command,prompt="(.*)",timeout=10)
+        self.execute( cmd=command, prompt="(.*)", timeout=10 )
 
         main.log.info( "Transferring ping files to TestStation" )
-        command = "scp /tmp/ping.* "+ str(testONUser) + "@" + str(testONIP) + ":/tmp/"
-        self.execute(cmd=command,prompt="100%",timeout=20)
-        #Make sure the output is cleared
-        self.handle.sendline("")
-        self.handle.expect("\$")
-        self.handle.sendline("")
-        self.handle.expect("\$")
-        self.handle.sendline("")
-        i=self.handle.expect(["password","\$"])
+        command = "scp /tmp/ping.* " + \
+            str( testONUser ) + "@" + str( testONIP ) + ":/tmp/"
+        self.execute( cmd=command, prompt="100%", timeout=20 )
+        # Make sure the output is cleared
+        self.handle.sendline( "" )
+        self.handle.expect( "\$" )
+        self.handle.sendline( "" )
+        self.handle.expect( "\$" )
+        self.handle.sendline( "" )
+        i = self.handle.expect( [ "password", "\$" ] )
         if i == 0:
-            main.log.error("Error, sudo asking for password")
-            main.log.error(self.handle.before)
+            main.log.error( "Error, sudo asking for password" )
+            main.log.error( self.handle.before )
             return main.FALSE
         else:
             return main.TRUE
 
-    def pingLongKill(self):
-        self.handle.sendline("")
-        self.handle.expect("\$")
+    def pingLongKill( self ):
+        self.handle.sendline( "" )
+        self.handle.expect( "\$" )
         command = "sudo kill -SIGING `pgrep ping`"
-        main.log.info(command)
-        self.execute(cmd=command,prompt="(.*)",timeout=10)
-        self.handle.sendline("")
-        self.handle.expect("\$")
+        main.log.info( command )
+        self.execute( cmd=command, prompt="(.*)", timeout=10 )
+        self.handle.sendline( "" )
+        self.handle.expect( "\$" )
         return main.TRUE
 
-    def pingHostOptical(self,**pingParams):
-        '''
+    def pingHostOptical( self, **pingParams ):
+        """
         This function is only for Packey Optical related ping
-        Use the next pingHost() function for all normal scenarios)
+        Use the next pingHost() function for all normal scenarios )
         Ping from one mininet host to another
         Currently the only supported Params: SRC and TARGET
-        '''
-        args = utilities.parse_args(["SRC","TARGET"],**pingParams)
-        #command = args["SRC"] + " ping -" + args["CONTROLLER"] + " " +args ["TARGET"]
-        command = args["SRC"] + " ping "+args ["TARGET"]+" -c 1 -i 1 -W 8"
+        """
+        args = utilities.parse_args( [ "SRC", "TARGET" ], **pingParams )
+        #command = args[ "SRC" ] + " ping -" + args[ "CONTROLLER" ] + " " +args [ "TARGET" ]
+        command = args[ "SRC" ] + " ping " + \
+            args[ "TARGET" ] + " -c 1 -i 1 -W 8"
         try:
-            main.log.warn("Sending: " + command)
-            #response = self.execute(cmd=command,prompt="mininet",timeout=10 )
-            self.handle.sendline(command)
-            i = self.handle.expect([command,pexpect.TIMEOUT])
+            main.log.warn( "Sending: " + command )
+            #response = self.execute( cmd=command,prompt="mininet",timeout=10 )
+            self.handle.sendline( command )
+            i = self.handle.expect( [ command, pexpect.TIMEOUT ] )
             if i == 1:
-                main.log.error(self.name + ": timeout when waiting for response from mininet")
-                main.log.error("response: " + str(self.handle.before))
-            i = self.handle.expect(["mininet>",pexpect.TIMEOUT])
+                main.log.error(
+                    self.name +
+                    ": timeout when waiting for response from mininet" )
+                main.log.error( "response: " + str( self.handle.before ) )
+            i = self.handle.expect( [ "mininet>", pexpect.TIMEOUT ] )
             if i == 1:
-                main.log.error(self.name + ": timeout when waiting for response from mininet")
-                main.log.error("response: " + str(self.handle.before))
+                main.log.error(
+                    self.name +
+                    ": timeout when waiting for response from mininet" )
+                main.log.error( "response: " + str( self.handle.before ) )
             response = self.handle.before
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
-        main.log.info(self.name+": Ping Response: "+ response )
-        #if utilities.assert_matches(expect=',\s0\%\spacket\sloss',actual=response,onpass="No Packet loss",onfail="Host is not reachable"):
-        if re.search(',\s0\%\spacket\sloss',response):
-            main.log.info(self.name+": no packets lost, host is reachable")
+        main.log.info( self.name + ": Ping Response: " + response )
+        # if utilities.assert_matches(
+        # expect=',\s0\%\spacket\sloss',actual=response,onpass="No Packet
+        # loss",onfail="Host is not reachable" ):
+        if re.search( ',\s0\%\spacket\sloss', response ):
+            main.log.info( self.name + ": no packets lost, host is reachable" )
             main.last_result = main.TRUE
             return main.TRUE
-        else :
-            main.log.error(self.name+": PACKET LOST, HOST IS NOT REACHABLE")
+        else:
+            main.log.error(
+                self.name +
+                ": PACKET LOST, HOST IS NOT REACHABLE" )
             main.last_result = main.FALSE
             return main.FALSE
 
-    def pingHost(self,**pingParams):
-        '''
+    def pingHost( self, **pingParams ):
+        """
         Pings between two hosts on remote mininet
-        '''
-        self.handle.sendline("")
-        self.handle.expect("\$")
-        args = utilities.parse_args(["SRC","TARGET"],**pingParams)
-        #command = "mininet/util/m " + args["SRC"] + " ping "+args ["TARGET"]+" -c 4 -W 1 -i .2"
-        command = "mininet/util/m " + args["SRC"] + " ping "+args ["TARGET"]+" -c 4 -W 1 -i .2"
-        main.log.info ( command )
-        response = self.execute(cmd=command,prompt="rtt",timeout=10 )
-        #self.handle.sendline("")
-        #self.handle.expect("\$")
-        if utilities.assert_matches(expect=',\s0\%\spacket\sloss',actual=response,onpass="No Packet loss",onfail="Host is not reachable"):
-            main.log.info("NO PACKET LOSS, HOST IS REACHABLE")
+        """
+        self.handle.sendline( "" )
+        self.handle.expect( "\$" )
+        args = utilities.parse_args( [ "SRC", "TARGET" ], **pingParams )
+        #command = "mininet/util/m " + args[ "SRC" ] + " ping "+args [ "TARGET" ]+" -c 4 -W 1 -i .2"
+        command = "mininet/util/m " + \
+            args[ "SRC" ] + " ping " + args[ "TARGET" ] + " -c 4 -W 1 -i .2"
+        main.log.info( command )
+        response = self.execute( cmd=command, prompt="rtt", timeout=10 )
+        # self.handle.sendline( "" )
+        # self.handle.expect( "\$" )
+        if utilities.assert_matches(
+                expect=',\s0\%\spacket\sloss',
+                actual=response,
+                onpass="No Packet loss",
+                onfail="Host is not reachable" ):
+            main.log.info( "NO PACKET LOSS, HOST IS REACHABLE" )
             main.last_result = main.TRUE
             return main.TRUE
-        else :
-            main.log.error("PACKET LOST, HOST IS NOT REACHABLE")
+        else:
+            main.log.error( "PACKET LOST, HOST IS NOT REACHABLE" )
             main.last_result = main.FALSE
             return main.FALSE
 
-
-    def checknum(self,num):
-        '''
+    def checknum( self, num ):
+        """
         Verifies the correct number of switches are running
-        '''
-        if self.handle :
-            self.handle.sendline("")
-            self.handle.expect("\$")
-            self.handle.sendline('ifconfig -a | grep "sw.. " | wc -l')
-            self.handle.expect("wc")
-            self.handle.expect("\$")
+        """
+        if self.handle:
+            self.handle.sendline( "" )
+            self.handle.expect( "\$" )
+            self.handle.sendline( 'ifconfig -a | grep "sw.. " | wc -l' )
+            self.handle.expect( "wc" )
+            self.handle.expect( "\$" )
             response = self.handle.before
-            self.handle.sendline('ps -ef | grep "bash -ms mininet:sw" | grep -v color | wc -l')
-            self.handle.expect("color")
-            self.handle.expect("\$")
+            self.handle.sendline(
+                'ps -ef | grep "bash -ms mininet:sw" | grep -v color | wc -l' )
+            self.handle.expect( "color" )
+            self.handle.expect( "\$" )
             response2 = self.handle.before
 
-            if re.search(num, response):
-                if re.search(num, response2):
+            if re.search( num, response ):
+                if re.search( num, response2 ):
                     return main.TRUE
                 else:
                     return main.FALSE
             else:
                 return main.FALSE
-        else :
-            main.log.error("Connection failed to the host")
+        else:
+            main.log.error( "Connection failed to the host" )
 
-    def start_tcpdump(self, filename, intf = "eth0", port = "port 6633", user="admin"):
-        '''
+    def start_tcpdump(
+            self,
+            filename,
+            intf="eth0",
+            port="port 6633",
+            user="admin" ):
+        """
         Runs tpdump on an intferface and saves the file
         intf can be specified, or the default eth0 is used
-        '''
+        """
         try:
-            self.handle.sendline("")
-            self.handle.sendline("sudo tcpdump -n -i "+ intf + " " + port + " -w " + filename.strip() + " -Z " + user + "  &")
-            self.handle.sendline("")
-            self.handle.sendline("")
-            i=self.handle.expect(['No\ssuch\device','listening\son',pexpect.TIMEOUT,"\$"],timeout=10)
-            main.log.warn(self.handle.before + self.handle.after)
+            self.handle.sendline( "" )
+            self.handle.sendline(
+                "sudo tcpdump -n -i " +
+                intf +
+                " " +
+                port +
+                " -w " +
+                filename.strip() +
+                " -Z " +
+                user +
+                "  &" )
+            self.handle.sendline( "" )
+            self.handle.sendline( "" )
+            i = self.handle.expect(
+                [ 'No\ssuch\device', 'listening\son', pexpect.TIMEOUT, "\$" ], timeout=10 )
+            main.log.warn( self.handle.before + self.handle.after )
             if i == 0:
-                main.log.error(self.name + ": tcpdump - No such device exists. tcpdump attempted on: " + intf)
+                main.log.error(
+                    self.name +
+                    ": tcpdump - No such device exists. tcpdump attempted on: " +
+                    intf )
                 return main.FALSE
             elif i == 1:
-                main.log.info(self.name + ": tcpdump started on " + intf)
+                main.log.info( self.name + ": tcpdump started on " + intf )
                 return main.TRUE
             elif i == 2:
-                main.log.error(self.name + ": tcpdump command timed out! Check interface name, given interface was: " + intf)
+                main.log.error(
+                    self.name +
+                    ": tcpdump command timed out! Check interface name, given interface was: " +
+                    intf )
                 return main.FALSE
-            elif i ==3:
-                main.log.info(self.name +": " +  self.handle.before)
+            elif i == 3:
+                main.log.info( self.name + ": " + self.handle.before )
                 return main.TRUE
             else:
-                main.log.error(self.name + ": tcpdump - unexpected response")
+                main.log.error( self.name + ": tcpdump - unexpected response" )
             return main.FALSE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         except:
-            main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info(
+                self.name +
+                ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::" )
             main.log.error( traceback.print_exc() )
-            main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info(
+                ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::" )
             main.cleanup()
             main.exit()
 
-    def stop_tcpdump(self):
+    def stop_tcpdump( self ):
         "pkills tcpdump"
         try:
-            self.handle.sendline("sudo pkill tcpdump")
-            self.handle.sendline("")
-            self.handle.sendline("")
-            self.handle.expect("\$")
+            self.handle.sendline( "sudo pkill tcpdump" )
+            self.handle.sendline( "" )
+            self.handle.sendline( "" )
+            self.handle.expect( "\$" )
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         except:
-            main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info(
+                self.name +
+                ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::" )
             main.log.error( traceback.print_exc() )
-            main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info(
+                ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::" )
             main.cleanup()
             main.exit()
 
-    def run_optical_mn_script(self):
-        '''
+    def run_optical_mn_script( self ):
+        """
             This function is only meant for Packet Optical.
-            It runs the python script "optical.py" to create the packet layer(mn)
+            It runs the python script "optical.py" to create the packet layer( mn )
             topology
-        '''
+        """
         try:
-            self.handle.sendline("")
-            self.handle.expect("\$")
-            self.handle.sendline("cd ~")
-            self.handle.expect("\$")
-            self.handle.sendline("sudo python optical.py")
-            self.handle.expect(">")
+            self.handle.sendline( "" )
+            self.handle.expect( "\$" )
+            self.handle.sendline( "cd ~" )
+            self.handle.expect( "\$" )
+            self.handle.sendline( "sudo python optical.py" )
+            self.handle.expect( ">" )
             return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             return main.FALSE
 
-    def disconnect(self):
-        '''
+    def disconnect( self ):
+        """
         Called at the end of the test to disconnect the handle.
-        '''
+        """
         response = ''
-        #print "Disconnecting Mininet"
+        # print "Disconnecting Mininet"
         if self.handle:
-            self.handle.sendline("exit")
-            self.handle.expect("exit")
-            self.handle.expect("(.*)")
+            self.handle.sendline( "exit" )
+            self.handle.expect( "exit" )
+            self.handle.expect( "(.*)" )
             response = self.handle.before
 
-        else :
-            main.log.error("Connection failed to the host")
+        else:
+            main.log.error( "Connection failed to the host" )
             response = main.FALSE
         return response
 
-    def get_flowTable(self, protoVersion, sw):
-        #TODO document usage
-        #TODO add option to look at cookies. ignoreing them for now
-        self.handle.sendline("cd")
-        self.handle.expect(["\$",pexpect.EOF,pexpect.TIMEOUT])
-        #print "get_flowTable(" + str(protoVersion) +" " + str(sw) +")"
-        #NOTE: Use format to force consistent flow table output across versions
-        if protoVersion==1.0:
-            command = "sudo ovs-ofctl dump-flows " + sw + " -F OpenFlow10-table_id | awk '{OFS=\",\" ; print $1  $3  $6  $7  $8}' | cut -d ',' -f 2- | sort -n -k1 -r"
-            self.handle.sendline(command)
-            self.handle.expect(["k1 -r",pexpect.EOF,pexpect.TIMEOUT])
-            self.handle.expect(["OFPST_FLOW",pexpect.EOF,pexpect.TIMEOUT])
+    def get_flowTable( self, protoVersion, sw ):
+        # TODO document usage
+        # TODO add option to look at cookies. ignoreing them for now
+        self.handle.sendline( "cd" )
+        self.handle.expect( [ "\$", pexpect.EOF, pexpect.TIMEOUT ] )
+        # print "get_flowTable(" + str( protoVersion ) +" " + str( sw ) +")"
+        # NOTE: Use format to force consistent flow table output across
+        # versions
+        if protoVersion == 1.0:
+            command = "sudo ovs-ofctl dump-flows " + sw + \
+                " -F OpenFlow10-table_id | awk '{OFS=\",\" ; print $1  $3  $6  $7  $8}' | cut -d ',' -f 2- | sort -n -k1 -r"
+            self.handle.sendline( command )
+            self.handle.expect( [ "k1 -r", pexpect.EOF, pexpect.TIMEOUT ] )
+            self.handle.expect(
+                [ "OFPST_FLOW", pexpect.EOF, pexpect.TIMEOUT ] )
             response = self.handle.before
-            #print "response=", response
+            # print "response=", response
             return response
-        elif protoVersion==1.3:
-            command = "sudo ovs-ofctl dump-flows " + sw + " -O OpenFlow13  | awk '{OFS=\",\" ; print $1  $3  $6  $7}' | cut -d ',' -f 2- | sort -n -k1 -r"
-            self.handle.sendline(command)
-            self.handle.expect(["k1 -r",pexpect.EOF,pexpect.TIMEOUT])
-            self.handle.expect(["OFPST_FLOW",pexpect.EOF,pexpect.TIMEOUT])
+        elif protoVersion == 1.3:
+            command = "sudo ovs-ofctl dump-flows " + sw + \
+                " -O OpenFlow13  | awk '{OFS=\",\" ; print $1  $3  $6  $7}' | cut -d ',' -f 2- | sort -n -k1 -r"
+            self.handle.sendline( command )
+            self.handle.expect( [ "k1 -r", pexpect.EOF, pexpect.TIMEOUT ] )
+            self.handle.expect(
+                [ "OFPST_FLOW", pexpect.EOF, pexpect.TIMEOUT ] )
             response = self.handle.before
-            #print "response=", response
+            # print "response=", response
             return response
         else:
-            main.log.error("Unknown  protoVersion in get_flowTable(). given: ("+str(type(protoVersion))+") '"+str(protoVersion)+"'")
+            main.log.error(
+                "Unknown  protoVersion in get_flowTable(). given: (" +
+                str(
+                    type( protoVersion ) ) +
+                ") '" +
+                str(protoVersion) +
+                "'" )
 
-
-    def flow_comp(self,flow1,flow2):
-        if flow1==flow2:
+    def flow_comp( self, flow1, flow2 ):
+        if flow1 == flow2:
             return main.TRUE
         else:
-            main.log.info("Flow tables do not match, printing tables:")
-            main.log.info("Flow Table 1:")
-            main.log.info(flow1)
-            main.log.info("Flow Table 2:")
-            main.log.info(flow2)
+            main.log.info( "Flow tables do not match, printing tables:" )
+            main.log.info( "Flow Table 1:" )
+            main.log.info( flow1 )
+            main.log.info( "Flow Table 2:" )
+            main.log.info( flow2 )
             return main.FALSE
 
-    def setIpTablesOUTPUT(self, dst_ip, dst_port, action='add', packet_type='tcp',rule='DROP'):
-        '''
+    def setIpTablesOUTPUT(
+            self,
+            dst_ip,
+            dst_port,
+            action='add',
+            packet_type='tcp',
+            rule='DROP' ):
+        """
         Description:
-            add or remove iptables rule to DROP (default)  packets from specific IP and PORT
+            add or remove iptables rule to DROP ( default )  packets from specific IP and PORT
         Usage:
-        * specify action ('add' or 'remove')
+        * specify action ( 'add' or 'remove' )
           when removing, pass in the same argument as you would add. It will
           delete that specific rule.
         * specify the destination ip to block with dst_ip
         * specify destination port to block to dst_port
-        * optional packet type to block (default tcp)
-        * optional iptables rule (default DROP)
+        * optional packet type to block ( default tcp )
+        * optional iptables rule ( default DROP )
         WARNING:
         * This function uses root privilege iptables command which may result in
           unwanted network errors. USE WITH CAUTION
-        '''
+        """
         import re
         import time
 
-        #NOTE*********
+        # NOTE*********
         #   The strict checking methods of this driver function is intentional
         #   to discourage any misuse or error of iptables, which can cause
         #   severe network errors
         #*************
 
-        #NOTE: Sleep needed to give some time for rule to be added and registered
+        # NOTE: Sleep needed to give some time for rule to be added and registered
         #      to the instance
-        time.sleep(5)
+        time.sleep( 5 )
 
         action_type = action.lower()
-        if action_type != 'add' and action_type !='remove':
-            main.log.error("Invalid action type. 'add' or 'remove' table rule")
+        if action_type != 'add' and action_type != 'remove':
+            main.log.error(
+                "Invalid action type. 'add' or 'remove' table rule" )
             if rule != 'DROP' and rule != 'ACCEPT' and rule != 'LOG':
-                #NOTE: Currently only supports rules DROP, ACCEPT, and LOG
-                main.log.error("Invalid rule. 'DROP' or 'ACCEPT' or 'LOG' only.")
+                # NOTE: Currently only supports rules DROP, ACCEPT, and LOG
+                main.log.error(
+                    "Invalid rule. 'DROP' or 'ACCEPT' or 'LOG' only." )
                 return
             return
         else:
 
-            #If there is no existing rule in the iptables, we will see an
+            # If there is no existing rule in the iptables, we will see an
             #'iptables:'... message. We expect to see this message.
-            #Otherwise, if there IS an existing rule, we will get the prompt
+            # Otherwise, if there IS an existing rule, we will get the prompt
             # back, hence why we expect $ for remove type. We want to remove
             # an already existing rule
 
             if action_type == 'add':
-                #NOTE: "iptables:" expect is a result of return from the command
+                # NOTE: "iptables:" expect is a result of return from the command
                 #      iptables -C ...
                 #      Any changes by the iptables command return string
-                #      will result in failure of the function. (deemed unlikely
-                #      at the time of writing this function)
-                #Check for existing rules on current input
-                self.handle.sendline("")
-                self.handle.expect("\$")
-                self.handle.sendline("sudo iptables -C OUTPUT -p "+str(packet_type)+
-                        " -d "+ str(dst_ip)+" --dport "+str(dst_port)+" -j "+str(rule))
-                i = self.handle.expect(["iptables:", "\$"])
+                #      will result in failure of the function. ( deemed unlikely
+                #      at the time of writing this function )
+                # Check for existing rules on current input
+                self.handle.sendline( "" )
+                self.handle.expect( "\$" )
+                self.handle.sendline(
+                    "sudo iptables -C OUTPUT -p " +
+                    str( packet_type ) +
+                    " -d " +
+                    str( dst_ip ) +
+                    " --dport " +
+                    str( dst_port ) +
+                    " -j " +
+                    str( rule ) )
+                i = self.handle.expect( [ "iptables:", "\$" ] )
                 print i
                 print self.handle.before
                 print "after: "
                 print self.handle.after
 
             elif action_type == 'remove':
-                #Check for existing rules on current input
-                self.handle.sendline("")
-                self.handle.expect("\$")
-                self.handle.sendline("sudo iptables -C OUTPUT -p "+str(packet_type)+
-                        " -d "+ str(dst_ip)+" --dport "+str(dst_port)+" -j "+str(rule))
-                self.handle.expect("\$")
+                # Check for existing rules on current input
+                self.handle.sendline( "" )
+                self.handle.expect( "\$" )
+                self.handle.sendline(
+                    "sudo iptables -C OUTPUT -p " +
+                    str( packet_type ) +
+                    " -d " +
+                    str( dst_ip ) +
+                    " --dport " +
+                    str( dst_port ) +
+                    " -j " +
+                    str( rule ) )
+                self.handle.expect( "\$" )
             print "before: "
             print self.handle.before
             actual_string = self.handle.after
@@ -470,73 +557,104 @@
             print "Actual String:"
             print actual_string
 
-            if re.search(expect_string, actual_string):
+            if re.search( expect_string, actual_string ):
                 match_result = main.TRUE
             else:
                 match_result = main.FALSE
-            #If match_result is main.TRUE, it means there is no matching rule.
+            # If match_result is main.TRUE, it means there is no matching rule.
 
-            #If tables does not exist and expected prompt is returned, go ahead and
-            #add iptables rule
+            # If tables does not exist and expected prompt is returned, go ahead and
+            # add iptables rule
             if match_result == main.TRUE:
-                #Ensure action type is add
+                # Ensure action type is add
                 if action_type == 'add':
                     #-A is the 'append' action of iptables
                     action_add = '-A'
                     try:
-                        self.handle.sendline("")
-                        self.handle.sendline("sudo iptables "+action_add+" OUTPUT -p "+str(packet_type)+
-                            " -d "+ str(dst_ip)+" --dport "+str(dst_port)+" -j "+str(rule))
+                        self.handle.sendline( "" )
+                        self.handle.sendline(
+                            "sudo iptables " +
+                            action_add +
+                            " OUTPUT -p " +
+                            str( packet_type ) +
+                            " -d " +
+                            str( dst_ip ) +
+                            " --dport " +
+                            str( dst_port ) +
+                            " -j " +
+                            str( rule ) )
 
-                        info_string = "Rules added to "+str(self.name)
-                        info_string += "iptable rule added to block IP: "+str(dst_ip)
-                        info_string += "Port: "+str(dst_port)+" Rule: "+str(rule)
+                        info_string = "Rules added to " + str( self.name )
+                        info_string += "iptable rule added to block IP: " + \
+                            str( dst_ip )
+                        info_string += "Port: " + \
+                            str( dst_port ) + " Rule: " + str( rule )
 
-                        main.log.info(info_string)
+                        main.log.info( info_string )
 
-                        self.handle.expect(["\$",pexpect.EOF,pexpect.TIMEOUT])
+                        self.handle.expect(
+                            [ "\$", pexpect.EOF, pexpect.TIMEOUT ] )
                     except pexpect.TIMEOUT:
-                        main.log.error(self.name + ": Timeout exception in setIpTables function")
+                        main.log.error(
+                            self.name +
+                            ": Timeout exception in setIpTables function" )
                     except:
-                        main.log.error( traceback.print_exc())
+                        main.log.error( traceback.print_exc() )
                         main.cleanup()
                         main.exit()
                 else:
-                    main.log.error("Given rule already exists, but attempted to add it")
-            #If match_result is 0, it means there IS a matching rule provided
+                    main.log.error(
+                        "Given rule already exists, but attempted to add it" )
+            # If match_result is 0, it means there IS a matching rule provided
             elif match_result == main.FALSE:
-                #Ensure action type is remove
+                # Ensure action type is remove
                 if action_type == 'remove':
                     #-D is the 'delete' rule of iptables
                     action_remove = '-D'
                     try:
-                        self.handle.sendline("")
-                        #Delete a specific rule specified into the function
-                        self.handle.sendline("sudo iptables "+action_remove+" OUTPUT -p "+str(packet_type)+
-                            " -d "+ str(dst_ip)+" --dport "+str(dst_port)+" -j "+str(rule))
+                        self.handle.sendline( "" )
+                        # Delete a specific rule specified into the function
+                        self.handle.sendline(
+                            "sudo iptables " +
+                            action_remove +
+                            " OUTPUT -p " +
+                            str( packet_type ) +
+                            " -d " +
+                            str( dst_ip ) +
+                            " --dport " +
+                            str( dst_port ) +
+                            " -j " +
+                            str( rule ) )
 
-                        info_string = "Rules removed from "+str(self.name)
-                        info_string += " iptables rule removed from blocking IP: "+str(dst_ip)
-                        info_string += " Port: "+str(dst_port)+" Rule: "+str(rule)
+                        info_string = "Rules removed from " + str( self.name )
+                        info_string += " iptables rule removed from blocking IP: " + \
+                            str( dst_ip )
+                        info_string += " Port: " + \
+                            str( dst_port ) + " Rule: " + str( rule )
 
-                        main.log.info(info_string)
+                        main.log.info( info_string )
 
-                        self.handle.expect(["\$",pexpect.EOF,pexpect.TIMEOUT])
+                        self.handle.expect(
+                            [ "\$", pexpect.EOF, pexpect.TIMEOUT ] )
                     except pexpect.TIMEOUT:
-                        main.log.error(self.name + ": Timeout exception in setIpTables function")
+                        main.log.error(
+                            self.name +
+                            ": Timeout exception in setIpTables function" )
                     except:
-                        main.log.error( traceback.print_exc())
+                        main.log.error( traceback.print_exc() )
                         main.cleanup()
                         main.exit()
                 else:
-                    main.log.error("Given rule does not exist, but attempted to remove it")
+                    main.log.error(
+                        "Given rule does not exist, but attempted to remove it" )
             else:
-                #NOTE: If a bad usage of this function occurs, exit the entire test
-                main.log.error("Bad rule given for iptables. Exiting...")
+                # NOTE: If a bad usage of this function occurs, exit the entire
+                # test
+                main.log.error( "Bad rule given for iptables. Exiting..." )
                 main.cleanup()
                 main.exit()
 
 
 if __name__ != "__main__":
     import sys
-    sys.modules[__name__] = RemoteMininetDriver()
+    sys.modules[ __name__ ] = RemoteMininetDriver()