diff --git a/src/python/oftest/controller.py b/src/python/oftest/controller.py
old mode 100644
new mode 100755
index acbe3fc..23d031b
--- a/src/python/oftest/controller.py
+++ b/src/python/oftest/controller.py
@@ -43,30 +43,34 @@
 # Configured openflow version
 import ofp as cfg_ofp
 
-FILTER=''.join([(len(repr(chr(x)))==3) and chr(x) or '.' 
-                for x in range(256)])
+FILTER = ''.join( [ (len( repr( chr( x ) ) ) == 3) and chr( x ) or '.'
+                    for x in range( 256 ) ] )
 
-def hex_dump_buffer(src, length=16):
+
+def hex_dump_buffer( src, length=16 ):
     """
     Convert src to a hex dump string and return the string
     @param src The source buffer
     @param length The number of bytes shown in each line
     @returns A string showing the hex dump
     """
-    result = ["\n"]
-    for i in xrange(0, len(src), length):
-       chars = src[i:i+length]
-       hex = ' '.join(["%02x" % ord(x) for x in chars])
-       printable = ''.join(["%s" % ((ord(x) <= 127 and
-                                     FILTER[ord(x)]) or '.') for x in chars])
-       result.append("%04x  %-*s  %s\n" % (i, length*3, hex, printable))
-    return ''.join(result)
+    result = [ "\n" ]
+    for i in xrange( 0, len( src ), length ):
+        chars = src[ i:i + length ]
+        hex = ' '.join( [ "%02x" % ord( x ) for x in chars ] )
+        printable = ''.join( [ "%s" % ((ord( x ) <= 127 and
+                                        FILTER[ ord( x ) ]) or '.') for x in
+                               chars ] )
+        result.append( "%04x  %-*s  %s\n" % (i, length * 3, hex, printable) )
+    return ''.join( result )
+
 
 ##@todo Find a better home for these identifiers (controller)
 RCV_SIZE_DEFAULT = 32768
 LISTEN_QUEUE_SIZE = 1
 
-class Controller(Thread):
+
+class Controller( Thread ):
     """
     Class abstracting the control interface to the switch.  
 
@@ -97,19 +101,20 @@
     @var dbg_state Debug indication of state
     """
 
-    def __init__(self, switch=None, host='127.0.0.1', port=6653, max_pkts=1024):
-        Thread.__init__(self)
+    def __init__( self, switch=None, host='127.0.0.1', port=6653, max_pkts=1024,
+                  force=False ):
+        Thread.__init__( self )
         # Socket related
         self.rcv_size = RCV_SIZE_DEFAULT
         self.listen_socket = None
         self.switch_socket = None
         self.switch_addr = None
-        self.connect_cv = Condition()
-        self.message_cv = Condition()
-        self.tx_lock = Lock()
+        self.connect_cv = Condition( )
+        self.message_cv = Condition( )
+        self.tx_lock = Lock( )
 
         # Used to wake up the event loop from another thread
-        self.waker = ofutils.EventDescriptor()
+        self.waker = ofutils.EventDescriptor( )
 
         # Counters
         self.socket_errors = 0
@@ -120,37 +125,38 @@
         self.poll_discards = 0
 
         # State
-        self.sync = Lock()
-        self.handlers = {}
+        self.sync = Lock( )
+        self.handlers = { }
         self.keep_alive = False
         self.active = True
         self.initial_hello = True
 
         # OpenFlow message/packet queue
         # Protected by the packets_cv lock / condition variable
-        self.packets = []
-        self.packets_cv = Condition()
+        self.packets = [ ]
+        self.packets_cv = Condition( )
         self.packet_in_count = 0
 
         # Settings
         self.max_pkts = max_pkts
         self.switch = switch
         self.passive = not self.switch
+        self.force = force
         self.host = host
         self.port = port
         self.dbg_state = "init"
-        self.logger = logging.getLogger("controller")
-        self.filter_packet_in = False # Drop "excessive" packet ins
-        self.pkt_in_run = 0 # Count on run of packet ins
-        self.pkt_in_filter_limit = 50 # Count on run of packet ins
-        self.pkt_in_dropped = 0 # Total dropped packet ins
-        self.transact_to = 15 # Transact timeout default value; add to config
+        self.logger = logging.getLogger( "controller" )
+        self.filter_packet_in = False  # Drop "excessive" packet ins
+        self.pkt_in_run = 0  # Count on run of packet ins
+        self.pkt_in_filter_limit = 50  # Count on run of packet ins
+        self.pkt_in_dropped = 0  # Total dropped packet ins
+        self.transact_to = 15  # Transact timeout default value; add to config
 
         # Transaction and message type waiting variables 
         #   xid_cv: Condition variable (semaphore) for packet waiters
         #   xid: Transaction ID being waited on
         #   xid_response: Transaction response message
-        self.xid_cv = Condition()
+        self.xid_cv = Condition( )
         self.xid = None
         self.xid_response = None
 
@@ -158,19 +164,19 @@
 
         # Create listen socket
         if self.passive:
-            self.logger.info("Create/listen at " + self.host + ":" +
-                             str(self.port))
-            ai = socket.getaddrinfo(self.host, self.port, socket.AF_UNSPEC,
-                                    socket.SOCK_STREAM, 0, socket.AI_PASSIVE)
+            self.logger.info( "Create/listen at " + self.host + ":" +
+                              str( self.port ) )
+            ai = socket.getaddrinfo( self.host, self.port, socket.AF_UNSPEC,
+                                     socket.SOCK_STREAM, 0, socket.AI_PASSIVE )
             # Use first returned addrinfo
-            (family, socktype, proto, name, sockaddr) = ai[0]
-            self.listen_socket = socket.socket(family, socktype)
-            self.listen_socket.setsockopt(socket.SOL_SOCKET,
-                                          socket.SO_REUSEADDR, 1)
-            self.listen_socket.bind(sockaddr)
-            self.listen_socket.listen(LISTEN_QUEUE_SIZE)
+            (family, socktype, proto, name, sockaddr) = ai[ 0 ]
+            self.listen_socket = socket.socket( family, socktype )
+            self.listen_socket.setsockopt( socket.SOL_SOCKET,
+                                           socket.SO_REUSEADDR, 1 )
+            self.listen_socket.bind( sockaddr )
+            self.listen_socket.listen( LISTEN_QUEUE_SIZE )
 
-    def filter_packet(self, rawmsg, hdr):
+    def filter_packet( self, rawmsg, hdr ):
         """
         Check if packet should be filtered
 
@@ -184,15 +190,15 @@
             # If we were dropping packets, report number dropped
             # TODO dont drop expected packet ins
             if self.pkt_in_run > self.pkt_in_filter_limit:
-                self.logger.debug("Dropped %d packet ins (%d total)"
-                            % ((self.pkt_in_run - 
-                                self.pkt_in_filter_limit),
-                                self.pkt_in_dropped))
+                self.logger.debug( "Dropped %d packet ins (%d total)"
+                                   % ((self.pkt_in_run -
+                                       self.pkt_in_filter_limit),
+                                      self.pkt_in_dropped) )
             self.pkt_in_run = 0
 
         return False
 
-    def _pkt_handle(self, pkt):
+    def _pkt_handle( self, pkt ):
         """
         Check for all packet handling conditions
 
@@ -214,52 +220,55 @@
 
         # Process each of the OF msgs inside the pkt
         offset = 0
-        while offset < len(pkt):
-            if offset + 8 > len(pkt):
+        while offset < len( pkt ):
+            if offset + 8 > len( pkt ):
                 break
 
             # Parse the header to get type
-            hdr_version, hdr_type, hdr_length, hdr_xid = cfg_ofp.message.parse_header(pkt[offset:])
+            hdr_version, hdr_type, hdr_length, hdr_xid = cfg_ofp.message.parse_header(
+                    pkt[ offset: ] )
 
             # Use loxi to resolve to ofp of matching version
-            ofp = loxi.protocol(hdr_version)
+            ofp = loxi.protocol( hdr_version )
 
             # Extract the raw message bytes
-            if (offset + hdr_length) > len(pkt):
+            if (offset + hdr_length) > len( pkt ):
                 break
-            rawmsg = pkt[offset : offset + hdr_length]
+            rawmsg = pkt[ offset: offset + hdr_length ]
             offset += hdr_length
 
-            #if self.filter_packet(rawmsg, hdr):
+            # if self.filter_packet(rawmsg, hdr):
             #    continue
 
-            msg = ofp.message.parse_message(rawmsg)
+            msg = ofp.message.parse_message( rawmsg )
             if not msg:
                 self.parse_errors += 1
-                self.logger.warn("Could not parse message")
+                self.logger.warn( "Could not parse message" )
                 continue
 
-            self.logger.debug("Msg in: version %d class %s len %d xid %d",
-                              hdr_version, type(msg).__name__, hdr_length, hdr_xid)
+            self.logger.debug( "Msg in: version %d class %s len %d xid %d",
+                               hdr_version, type( msg ).__name__, hdr_length,
+                               hdr_xid )
 
             with self.sync:
                 # Check if transaction is waiting
                 with self.xid_cv:
                     if self.xid and hdr_xid == self.xid:
-                        self.logger.debug("Matched expected XID " + str(hdr_xid))
+                        self.logger.debug(
+                                "Matched expected XID " + str( hdr_xid ) )
                         self.xid_response = (msg, rawmsg)
                         self.xid = None
-                        self.xid_cv.notify()
+                        self.xid_cv.notify( )
                         continue
 
                 # Check if keep alive is set; if so, respond to echo requests
                 if self.keep_alive:
                     if hdr_type == ofp.OFPT_ECHO_REQUEST:
-                        self.logger.debug("Responding to echo request")
-                        rep = ofp.message.echo_reply()
+                        self.logger.debug( "Responding to echo request" )
+                        rep = ofp.message.echo_reply( )
                         rep.xid = hdr_xid
                         # Ignoring additional data
-                        self.message_send(rep)
+                        self.message_send( rep )
                         continue
 
                 # Generalize to counters for all packet types?
@@ -267,10 +276,10 @@
                     self.packet_in_count += 1
 
                 # Log error messages
-                if isinstance(msg, ofp.message.error_msg):
-                    #pylint: disable=E1103
+                if isinstance( msg, ofp.message.error_msg ):
+                    # pylint: disable=E1103
                     if msg.err_type in ofp.ofp_error_type_map:
-                        type_str = ofp.ofp_error_type_map[msg.err_type]
+                        type_str = ofp.ofp_error_type_map[ msg.err_type ]
                         if msg.err_type == ofp.OFPET_HELLO_FAILED:
                             code_map = ofp.ofp_hello_failed_code_map
                         elif msg.err_type == ofp.OFPET_BAD_REQUEST:
@@ -287,41 +296,43 @@
                             code_map = None
 
                         if code_map and msg.code in code_map:
-                            code_str = code_map[msg.code]
+                            code_str = code_map[ msg.code ]
                         else:
                             code_str = "unknown"
                     else:
                         type_str = "unknown"
                         code_str = "unknown"
-                    self.logger.warn("Received error message: xid=%d type=%s (%d) code=%s (%d)",
-                                     hdr_xid, type_str, msg.err_type, code_str, msg.code)
+                    self.logger.warn(
+                            "Received error message: xid=%d type=%s (%d) code=%s (%d)",
+                            hdr_xid, type_str, msg.err_type, code_str,
+                            msg.code )
 
                 # Now check for message handlers; preference is given to
                 # handlers for a specific packet
                 handled = False
-                if hdr_type in self.handlers.keys():
-                    handled = self.handlers[hdr_type](self, msg, rawmsg)
-                if not handled and ("all" in self.handlers.keys()):
-                    handled = self.handlers["all"](self, msg, rawmsg)
+                if hdr_type in self.handlers.keys( ):
+                    handled = self.handlers[ hdr_type ]( self, msg, rawmsg )
+                if not handled and ("all" in self.handlers.keys( )):
+                    handled = self.handlers[ "all" ]( self, msg, rawmsg )
 
-                if not handled: # Not handled, enqueue
+                if not handled:  # Not handled, enqueue
                     with self.packets_cv:
-                        if len(self.packets) >= self.max_pkts:
-                            self.packets.pop(0)
+                        if len( self.packets ) >= self.max_pkts:
+                            self.packets.pop( 0 )
                             self.packets_expired += 1
-                        self.packets.append((msg, rawmsg))
-                        self.packets_cv.notify_all()
+                        self.packets.append( (msg, rawmsg) )
+                        self.packets_cv.notify_all( )
                     self.packets_total += 1
                 else:
                     self.packets_handled += 1
-                    self.logger.debug("Message handled by callback")
+                    self.logger.debug( "Message handled by callback" )
 
         # end of 'while offset < len(pkt)'
         #   note that if offset = len(pkt), this is
         #   appends a harmless empty string
-        self.buffered_input += pkt[offset:]
+        self.buffered_input += pkt[ offset: ]
 
-    def _socket_ready_handle(self, s):
+    def _socket_ready_handle( self, s ):
         """
         Handle an input-ready socket
 
@@ -331,91 +342,93 @@
 
         if self.passive and s and s == self.listen_socket:
             if self.switch_socket:
-                self.logger.warning("Ignoring incoming connection; already connected to switch")
-                (sock, addr) = self.listen_socket.accept()
-                sock.close()
+                self.logger.warning(
+                        "Ignoring incoming connection; already connected to switch" )
+                (sock, addr) = self.listen_socket.accept( )
+                sock.close( )
                 return 0
 
             try:
-                (sock, addr) = self.listen_socket.accept()
+                (sock, addr) = self.listen_socket.accept( )
             except:
-                self.logger.warning("Error on listen socket accept")
+                self.logger.warning( "Error on listen socket accept" )
                 return -1
-            self.logger.info(self.host+":"+str(self.port)+": Incoming connection from "+str(addr))
+            self.logger.info( self.host + ":" + str(
+                    self.port ) + ": Incoming connection from " + str( addr ) )
 
             with self.connect_cv:
                 (self.switch_socket, self.switch_addr) = (sock, addr)
-                self.switch_socket.setsockopt(socket.IPPROTO_TCP,
-                                              socket.TCP_NODELAY, True)
+                self.switch_socket.setsockopt( socket.IPPROTO_TCP,
+                                               socket.TCP_NODELAY, True )
                 if self.initial_hello:
-                    self.message_send(cfg_ofp.message.hello())
-                self.connect_cv.notify() # Notify anyone waiting
+                    self.message_send( cfg_ofp.message.hello( ) )
+                self.connect_cv.notify( )  # Notify anyone waiting
 
             # Prevent further connections
-            self.listen_socket.close()
+            self.listen_socket.close( )
             self.listen_socket = None
         elif s and s == self.switch_socket:
-            for idx in range(3): # debug: try a couple of times
+            for idx in range( 3 ):  # debug: try a couple of times
                 try:
-                    pkt = self.switch_socket.recv(self.rcv_size)
+                    pkt = self.switch_socket.recv( self.rcv_size )
                 except:
-                    self.logger.warning("Error on switch read")
+                    self.logger.warning( "Error on switch read" )
                     return -1
-      
+
                 if not self.active:
                     return 0
-      
-                if len(pkt) == 0:
-                    self.logger.warning("Zero-length switch read, %d" % idx)
+
+                if len( pkt ) == 0:
+                    self.logger.warning( "Zero-length switch read, %d" % idx )
                 else:
                     break
 
-            if len(pkt) == 0: # Still no packet
-                self.logger.warning("Zero-length switch read; closing cxn")
-                self.logger.info(str(self))
+            if len( pkt ) == 0:  # Still no packet
+                self.logger.warning( "Zero-length switch read; closing cxn" )
+                self.logger.info( str( self ) )
                 return -1
 
-            self._pkt_handle(pkt)
+            self._pkt_handle( pkt )
         elif s and s == self.waker:
-            self.waker.wait()
+            self.waker.wait( )
         else:
-            self.logger.error("Unknown socket ready: " + str(s))
+            self.logger.error( "Unknown socket ready: " + str( s ) )
             return -1
 
         return 0
 
-    def active_connect(self):
+    def active_connect( self ):
         """
         Actively connect to a switch IP addr
         """
         try:
-            self.logger.info("Trying active connection to %s" % self.switch)
-            soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            soc.connect((self.switch, self.port))
-            self.logger.info("Connected to " + self.switch + " on " +
-                         str(self.port))
-            soc.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, True)
+            self.logger.info( "Trying active connection to %s" % self.switch )
+            soc = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
+            soc.connect( (self.switch, self.port) )
+            self.logger.info( "Connected to " + self.switch + " on " +
+                              str( self.port ) )
+            soc.setsockopt( socket.IPPROTO_TCP, socket.TCP_NODELAY, True )
             self.switch_addr = (self.switch, self.port)
             return soc
         except (StandardError, socket.error), e:
-            self.logger.error("Could not connect to %s at %d:: %s" % 
-                              (self.switch, self.port, str(e)))
+            self.logger.error( "Could not connect to %s at %d:: %s" %
+                               (self.switch, self.port, str( e )) )
         return None
 
-    def wakeup(self):
+    def wakeup( self ):
         """
         Wake up the event loop, presumably from another thread.
         """
-        self.waker.notify()
+        self.waker.notify( )
 
-    def sockets(self):
+    def sockets( self ):
         """
         Return list of sockets to select on.
         """
-        socs = [self.listen_socket, self.switch_socket, self.waker]
-        return [x for x in socs if x]
+        socs = [ self.listen_socket, self.switch_socket, self.waker ]
+        return [ x for x in socs if x ]
 
-    def run(self):
+    def run( self ):
         """
         Activity function for class
 
@@ -435,26 +448,27 @@
         while self.active:
             try:
                 sel_in, sel_out, sel_err = \
-                    select.select(self.sockets(), [], self.sockets(), 1)
+                    select.select( self.sockets( ), [ ], self.sockets( ), 1 )
             except:
-                print sys.exc_info()
-                self.logger.error("Select error, disconnecting")
-                self.disconnect()
+                print sys.exc_info( )
+                self.logger.error( "Select error, disconnecting" )
+                self.disconnect( )
 
             for s in sel_err:
-                self.logger.error("Got socket error on: " + str(s) + ", disconnecting")
-                self.disconnect()
+                self.logger.error(
+                        "Got socket error on: " + str( s ) + ", disconnecting" )
+                self.disconnect( )
 
             for s in sel_in:
-                if self._socket_ready_handle(s) == -1:
-                    self.disconnect()
+                if self._socket_ready_handle( s ) == -1:
+                    self.disconnect( )
 
         # End of main loop
         self.dbg_state = "closing"
-        self.logger.info("Exiting controller thread")
-        self.shutdown()
+        self.logger.info( "Exiting controller thread" )
+        self.shutdown( )
 
-    def connect(self, timeout=-1):
+    def connect( self, timeout=-1 ):
         """
         Connect to the switch
 
@@ -463,63 +477,63 @@
         """
 
         if not self.passive:  # Do active connection now
-            self.logger.info("Attempting to connect to %s on port %s" %
-                             (self.switch, str(self.port)))
-            soc = self.active_connect()
+            self.logger.info( "Attempting to connect to %s on port %s" %
+                                  (self.switch, str( self.port )) )
+            soc = self.active_connect( )
             if soc:
-                self.logger.info("Connected to %s", self.switch)
+                self.logger.info( "Connected to %s", self.switch )
                 self.dbg_state = "running"
                 self.switch_socket = soc
-                self.wakeup()
+                self.wakeup( )
                 with self.connect_cv:
                     if self.initial_hello:
-                        self.message_send(cfg_ofp.message.hello())
-                    self.connect_cv.notify() # Notify anyone waiting
+                        self.message_send( cfg_ofp.message.hello( ) )
+                    self.connect_cv.notify( )  # Notify anyone waiting
             else:
-                self.logger.error("Could not actively connect to switch %s",
-                                  self.switch)
+                self.logger.error( "Could not actively connect to switch %s",
+                                   self.switch )
                 self.active = False
         else:
             with self.connect_cv:
-                ofutils.timed_wait(self.connect_cv, lambda: self.switch_socket,
-                                   timeout=timeout)
+                ofutils.timed_wait( self.connect_cv, lambda: self.switch_socket,
+                                    timeout=timeout )
 
         return self.switch_socket is not None
-        
-    def disconnect(self, timeout=-1):
+
+    def disconnect( self, timeout=-1 ):
         """
         If connected to a switch, disconnect.
         """
         if self.switch_socket:
-            self.switch_socket.close()
+            self.switch_socket.close( )
             self.switch_socket = None
             self.switch_addr = None
             with self.packets_cv:
-                self.packets = []
+                self.packets = [ ]
             with self.connect_cv:
-                self.connect_cv.notifyAll()
+                self.connect_cv.notifyAll( )
 
-    def wait_disconnected(self, timeout=-1):
+    def wait_disconnected( self, timeout=-1 ):
         """
         @param timeout Block for up to timeout seconds. Pass -1 for the default.
         @return Boolean, True if disconnected
         """
 
         with self.connect_cv:
-            ofutils.timed_wait(self.connect_cv, 
-                               lambda: True if not self.switch_socket else None, 
-                               timeout=timeout)
+            ofutils.timed_wait( self.connect_cv,
+                                lambda: True if not self.switch_socket else None,
+                                timeout=timeout )
         return self.switch_socket is None
-        
-    def kill(self):
+
+    def kill( self ):
         """
         Force the controller thread to quit
         """
         self.active = False
-        self.wakeup()
-        self.join()
+        self.wakeup( )
+        self.join( )
 
-    def shutdown(self):
+    def shutdown( self ):
         """
         Shutdown the controller closing all sockets
 
@@ -528,28 +542,28 @@
 
         self.active = False
         try:
-            self.switch_socket.shutdown(socket.SHUT_RDWR)
+            self.switch_socket.shutdown( socket.SHUT_RDWR )
         except:
-            self.logger.info("Ignoring switch soc shutdown error")
+            self.logger.info( "Ignoring switch soc shutdown error" )
         self.switch_socket = None
 
         try:
-            self.listen_socket.shutdown(socket.SHUT_RDWR)
+            self.listen_socket.shutdown( socket.SHUT_RDWR )
         except:
-            self.logger.info("Ignoring listen soc shutdown error")
+            self.logger.info( "Ignoring listen soc shutdown error" )
         self.listen_socket = None
 
         # Wakeup condition variables on which controller may be wait
         with self.xid_cv:
-            self.xid_cv.notifyAll()
+            self.xid_cv.notifyAll( )
 
         with self.connect_cv:
-            self.connect_cv.notifyAll()
+            self.connect_cv.notifyAll( )
 
-        self.wakeup()
+        self.wakeup( )
         self.dbg_state = "down"
 
-    def register(self, msg_type, handler):
+    def register( self, msg_type, handler ):
         """
         Register a callback to receive a specific message type.
 
@@ -565,12 +579,12 @@
         type is received.
         """
         # Should check type is valid
-        if not handler and msg_type in self.handlers.keys():
-            del self.handlers[msg_type]
+        if not handler and msg_type in self.handlers.keys( ):
+            del self.handlers[ msg_type ]
             return
-        self.handlers[msg_type] = handler
+        self.handlers[ msg_type ] = handler
 
-    def poll(self, exp_msg=None, timeout=-1):
+    def poll( self, exp_msg=None, timeout=-1 ):
         """
         Wait for the next OF message received from the switch.
 
@@ -589,29 +603,30 @@
         """
 
         if exp_msg is None:
-            self.logger.warn("DEPRECATED polling for any message class")
+            self.logger.warn( "DEPRECATED polling for any message class" )
             klass = None
-        elif isinstance(exp_msg, int):
-            klass = cfg_ofp.message.message.subtypes[exp_msg]
-        elif issubclass(exp_msg, loxi.OFObject):
+        elif isinstance( exp_msg, int ):
+            klass = cfg_ofp.message.message.subtypes[ exp_msg ]
+        elif issubclass( exp_msg, loxi.OFObject ):
             klass = exp_msg
         else:
-            raise ValueError("Unexpected exp_msg argument %r" % exp_msg)
+            raise ValueError( "Unexpected exp_msg argument %r" % exp_msg )
 
-        self.logger.debug("Polling for %s", klass.__name__)
+        self.logger.debug( "Polling for %s", klass.__name__ )
 
         # Take the packet from the queue
-        def grab():
-            for i, (msg, pkt) in enumerate(self.packets):
-                if klass is None or isinstance(msg, klass):
-                    self.logger.debug("Got %s message", msg.__class__.__name__)
-                    return self.packets.pop(i)
+        def grab( ):
+            for i, (msg, pkt) in enumerate( self.packets ):
+                if klass is None or isinstance( msg, klass ):
+                    self.logger.debug( "Got %s message",
+                                       msg.__class__.__name__ )
+                    return self.packets.pop( i )
             # Not found
-            self.logger.debug("%s message not in queue", klass.__name__)
+            self.logger.debug( "%s message not in queue", klass.__name__ )
             return None
 
         with self.packets_cv:
-            ret = ofutils.timed_wait(self.packets_cv, grab, timeout=timeout)
+            ret = ofutils.timed_wait( self.packets_cv, grab, timeout=timeout )
 
         if ret != None:
             (msg, pkt) = ret
@@ -619,7 +634,7 @@
         else:
             return (None, None)
 
-    def transact(self, msg, timeout=-1):
+    def transact( self, msg, timeout=-1 ):
         """
         Run a message transaction with the switch
 
@@ -632,21 +647,22 @@
         """
 
         if msg.xid == None:
-            msg.xid = ofutils.gen_xid()
+            msg.xid = ofutils.gen_xid( )
 
-        self.logger.debug("Running transaction %d" % msg.xid)
+        self.logger.debug( "Running transaction %d" % msg.xid )
 
         with self.xid_cv:
             if self.xid:
-                self.logger.error("Can only run one transaction at a time")
+                self.logger.error( "Can only run one transaction at a time" )
                 return (None, None)
 
             self.xid = msg.xid
             self.xid_response = None
-            self.message_send(msg)
+            self.message_send( msg )
 
-            self.logger.debug("Waiting for transaction %d" % msg.xid)
-            ofutils.timed_wait(self.xid_cv, lambda: self.xid_response, timeout=timeout)
+            self.logger.debug( "Waiting for transaction %d" % msg.xid )
+            ofutils.timed_wait( self.xid_cv, lambda: self.xid_response,
+                                timeout=timeout )
 
             if self.xid_response:
                 (resp, pkt) = self.xid_response
@@ -655,10 +671,10 @@
                 (resp, pkt) = (None, None)
 
         if resp is None:
-            self.logger.warning("No response for xid " + str(self.xid))
+            self.logger.warning( "No response for xid " + str( self.xid ) )
         return (resp, pkt)
 
-    def message_send(self, msg):
+    def message_send( self, msg ):
         """
         Send the message to the switch
 
@@ -668,56 +684,58 @@
 
         if not self.switch_socket:
             # Sending a string indicates the message is ready to go
-            raise Exception("no socket")
+            raise Exception( "no socket" )
 
         if msg.xid == None:
-            msg.xid = ofutils.gen_xid()
+            msg.xid = ofutils.gen_xid( )
 
-        outpkt = msg.pack()
+        outpkt = msg.pack( )
 
-        self.logger.debug("Msg out: version %d class %s len %d xid %d",
-                          msg.version, type(msg).__name__, len(outpkt), msg.xid)
+        self.logger.debug( "Msg out: version %d class %s len %d xid %d",
+                           msg.version, type( msg ).__name__, len( outpkt ),
+                           msg.xid )
 
         with self.tx_lock:
-            if self.switch_socket.sendall(outpkt) is not None:
-                raise AssertionError("failed to send message to switch")
+            if self.switch_socket.sendall( outpkt ) is not None:
+                raise AssertionError( "failed to send message to switch" )
 
-        return 0 # for backwards compatibility
+        return 0  # for backwards compatibility
 
-    def clear_queue(self):
+    def clear_queue( self ):
         """
         Clear the input queue and report the number of messages
         that were in it
         """
-        enqueued_pkt_count = len(self.packets)
+        enqueued_pkt_count = len( self.packets )
         with self.packets_cv:
-            self.packets = []
+            self.packets = [ ]
         return enqueued_pkt_count
 
-    def __str__(self):
+    def __str__( self ):
         string = "Controller:\n"
         string += "  state           " + self.dbg_state + "\n"
-        string += "  switch_addr     " + str(self.switch_addr) + "\n"
-        string += "  pending pkts    " + str(len(self.packets)) + "\n"
-        string += "  total pkts      " + str(self.packets_total) + "\n"
-        string += "  expired pkts    " + str(self.packets_expired) + "\n"
-        string += "  handled pkts    " + str(self.packets_handled) + "\n"
-        string += "  poll discards   " + str(self.poll_discards) + "\n"
-        string += "  parse errors    " + str(self.parse_errors) + "\n"
-        string += "  sock errrors    " + str(self.socket_errors) + "\n"
-        string += "  max pkts        " + str(self.max_pkts) + "\n"
-        string += "  target switch   " + str(self.switch) + "\n"
-        string += "  host            " + str(self.host) + "\n"
-        string += "  port            " + str(self.port) + "\n"
-        string += "  keep_alive      " + str(self.keep_alive) + "\n"
-        string += "  pkt_in_run      " + str(self.pkt_in_run) + "\n"
-        string += "  pkt_in_dropped  " + str(self.pkt_in_dropped) + "\n"
+        string += "  switch_addr     " + str( self.switch_addr ) + "\n"
+        string += "  pending pkts    " + str( len( self.packets ) ) + "\n"
+        string += "  total pkts      " + str( self.packets_total ) + "\n"
+        string += "  expired pkts    " + str( self.packets_expired ) + "\n"
+        string += "  handled pkts    " + str( self.packets_handled ) + "\n"
+        string += "  poll discards   " + str( self.poll_discards ) + "\n"
+        string += "  parse errors    " + str( self.parse_errors ) + "\n"
+        string += "  sock errrors    " + str( self.socket_errors ) + "\n"
+        string += "  max pkts        " + str( self.max_pkts ) + "\n"
+        string += "  target switch   " + str( self.switch ) + "\n"
+        string += "  host            " + str( self.host ) + "\n"
+        string += "  port            " + str( self.port ) + "\n"
+        string += "  keep_alive      " + str( self.keep_alive ) + "\n"
+        string += "  pkt_in_run      " + str( self.pkt_in_run ) + "\n"
+        string += "  pkt_in_dropped  " + str( self.pkt_in_dropped ) + "\n"
         return string
 
-    def show(self):
-        print str(self)
+    def show( self ):
+        print str( self )
 
-def sample_handler(controller, msg, pkt):
+
+def sample_handler( controller, msg, pkt ):
     """
     Sample message handler