Buffered output. Added net.monitor() and node.readline()

Moved monitor() and readline() into net.py and node.py respectively,
which will hopefully be useful for monitoring large sets of hosts,
as is done in udpbwtest.py.

Changed iperf to use interactive command infrastructure (such as it
is), which may make it more reliable. Hopefully it's a bit clearer
as well, although it is slightly more complicated.

examples/udpbwtest.py

@@ -18,7 +18,6 @@
 
 import os
 import re
-import select
 import sys
 from time import time
 
@@ -30,37 +29,6 @@
 from mininet.topolib import TreeTopo
 from mininet.util import quietRun
 
-# Some useful stuff: buffered readline and host monitoring
-
-def readline( host, buf ):
-    "Read a line from a host, buffering with buffer."
-    buf += host.read( 1024 )
-    if '\n' not in buf:
-        return None, buf
-    pos = buf.find( '\n' )
-    line = buf[ 0 : pos ]
-    rest = buf[ pos + 1: ]
-    return line, rest
-
-def monitor( hosts, seconds ):
-    "Monitor a set of hosts and yield their output."
-    poller = select.poll()
-    Node = hosts[ 0 ] # so we can call class method fdToNode
-    buffers = {}
-    for host in hosts:
-        poller.register( host.stdout )
-        buffers[ host ] = ''
-    quitTime = time() + seconds
-    while time() < quitTime:
-        ready = poller.poll()
-        for fd, event in ready:
-            host = Node.fdToNode( fd )
-            if event & select.POLLIN:
-                line, buffers[ host ] = readline( host, buffers[ host ] )
-                if line:
-                    yield host, line
-    yield None, ''
-
 # bwtest support
 
 def parsebwtest( line,
@@ -111,8 +79,9 @@ def udpbwtest( net, seconds ):
     print
     results = {}
     print "*** Monitoring hosts"
-    output = monitor( hosts, seconds )
-    while True:
+    output = net.monitor( hosts )
+    quitTime = time() + seconds
+    while time() < quitTime:
         host, line = output.next()
         if host is None:
             break

mininet/net.py

@@ -85,6 +85,7 @@
 
 import os
 import re
+import select
 import signal
 from time import sleep
 
@@ -382,6 +383,25 @@ def run( self, test, **params ):
         self.stop()
         return result
 
+    def monitor( self, hosts=None ):
+        """Monitor a set of hosts (or all hosts by default),
+           and return their output, a line at a time.
+           returns: host, line"""
+        if hosts is None:
+            hosts = self.hosts
+        poller = select.poll()
+        Node = hosts[ 0 ] # so we can call class method fdToNode
+        for host in hosts:
+            poller.register( host.stdout )
+        while True:
+            ready = poller.poll()
+            for fd, event in ready:
+                host = Node.fdToNode( fd )
+                if event & select.POLLIN:
+                    line = host.readline()
+                    if line:
+                        yield host, line
+
     @staticmethod
     def _parsePing( pingOutput ):
         "Parse ping output and return packets sent, received."
@@ -460,10 +480,10 @@ def iperf( self, hosts=None, l4Type='TCP', udpBw='10M' ):
             hosts = [ self.hosts[ 0 ], self.hosts[ -1 ] ]
         else:
             assert len( hosts ) == 2
-        host0, host1 = hosts
+        client, server = hosts
         output( '*** Iperf: testing ' + l4Type + ' bandwidth between ' )
-        output( "%s and %s\n" % ( host0.name, host1.name ) )
-        host0.cmd( 'killall -9 iperf' )
+        output( "%s and %s\n" % ( client.name, server.name ) )
+        server.cmd( 'killall -9 iperf' )
         iperfArgs = 'iperf '
         bwArgs = ''
         if l4Type == 'UDP':
@@ -471,14 +491,17 @@ def iperf( self, hosts=None, l4Type='TCP', udpBw='10M' ):
             bwArgs = '-b ' + udpBw + ' '
         elif l4Type != 'TCP':
             raise Exception( 'Unexpected l4 type: %s' % l4Type )
-        server = host0.cmd( iperfArgs + '-s &' )
-        debug( '%s\n' % server )
-        client = host1.cmd( iperfArgs + '-t 5 -c ' + host0.IP() + ' ' +
+        server.sendCmd( iperfArgs + '-s', printPid=True )
+        servout = ''
+        while server.lastPid is None:
+            servout += server.monitor()
+        cliout = client.cmd( iperfArgs + '-t 5 -c ' + server.IP() + ' ' +
                            bwArgs )
-        debug( '%s\n' % client )
-        server = host0.cmd( 'killall -9 iperf' )
-        debug( '%s\n' % server )
-        result = [ self._parseIperf( server ), self._parseIperf( client ) ]
+        debug( 'Client output: %s\n' % cliout )
+        server.sendInt()
+        servout += server.waitOutput()
+        debug( 'Server output: %s\n' % servout )
+        result = [ self._parseIperf( servout ), self._parseIperf( cliout ) ]
         if l4Type == 'UDP':
             result.insert( 0, udpBw )
         output( '*** Results: %s\n' % result )

mininet/node.py

@@ -94,11 +94,7 @@ def __init__( self, name, inNamespace=True,
         self.defaultMAC = defaultMAC
         self.lastCmd = None
         self.lastPid = None
-        # Grab PID
-        self.waiting = True
-        while self.lastPid is None:
-            self.monitor()
-        self.pid = self.lastPid
+        self.readbuf = ''
         self.waiting = False
 
     @classmethod
@@ -115,9 +111,30 @@ def cleanup( self ):
 
     # Subshell I/O, commands and control
     def read( self, bytes ):
-        """Read from a node.
-           bytes: maximum number of bytes to read"""
-        return os.read( self.stdout.fileno(), bytes )
+        """Buffered read from node, non-blocking.
+           bytes: maximum number of bytes to return"""
+        count = len( self.readbuf )
+        if count < bytes:
+            data = os.read( self.stdout.fileno(), bytes - count )
+            self.readbuf += data
+        if bytes >= len( self.readbuf ):
+            result = self.readbuf
+            self.readbuf = ''
+        else:
+            result = self.readbuf[ :bytes ]
+            self.readbuf = self.readbuf[ bytes: ]
+        return result
+
+    def readline( self ):
+        """Buffered readline from node, non-blocking.
+           returns: line (minus newline) or None"""
+        self.readbuf += self.read( 1024 )
+        if '\n' not in self.readbuf:
+            return None
+        pos = self.readbuf.find( '\n' )
+        line = self.readbuf[ 0 : pos ]
+        self.readbuf = self.readbuf[ pos + 1: ]
+        return line
 
     def write( self, data ):
         """Write data to node.
@@ -135,7 +152,8 @@ def stop( self ):
 
     def waitReadable( self ):
         "Wait until node's output is readable."
-        self.pollOut.poll()
+        if len( self.readbuf ) == 0:
+            self.pollOut.poll()
 
     def sendCmd( self, cmd, printPid=False ):
         """Send a command, followed by a command to echo a sentinel,
@@ -155,10 +173,10 @@ def sendCmd( self, cmd, printPid=False ):
         self.lastPid = None
         self.waiting = True
 
-    def sendInt( self ):
+    def sendInt( self, sig=signal.SIGINT ):
         "Interrupt running command."
         if self.lastPid:
-            os.kill( self.lastPid, signal.SIGINT )
+            os.kill( self.lastPid, sig )
 
     def monitor( self ):
         """Monitor and return the output of a command.
@@ -315,7 +333,7 @@ def setHostRoute( self, ip, intf ):
     def setDefaultRoute( self, intf ):
         """Set the default route to go through intf.
            intf: string, interface name"""
-        self.cmd( 'ip route flush' )
+        self.cmd( 'ip route flush root 0/0' )
         return self.cmd( 'route add default ' + intf )
 
     def IP( self, intf=None ):