First commit
diff --git a/examples/README b/examples/README
new file mode 100644
index 0000000..dd71bea
--- /dev/null
+++ b/examples/README
@@ -0,0 +1,102 @@
+
+Mininet Examples
+
+These examples are intended to help you get started using
+Mininet's Python API.
+
+---
+
+baresshd.py:
+
+This example uses Mininet's medium-level API to create an sshd
+process running in a namespace. Doesn't use OpenFlow.
+
+consoles.py:
+
+This example creates a grid of console windows, one for each node,
+and allows interaction with and monitoring of each console, including
+graphical monitoring.
+
+controllers.py:
+
+This example creates a network and adds multiple controllers to it.
+
+cpu.py:
+
+This example tests iperf bandwidth for varying CPU limits.
+
+emptynet.py:
+
+This example demonstrates creating an empty network (i.e. with no
+topology object) and adding nodes to it.
+
+hwintf.py:
+
+This example shows how to add an interface (for example a real
+hardware interface) to a network after the network is created.
+
+limit.py:
+
+This example shows how to use link and CPU limits.
+
+linearbandwidth.py:
+
+This example shows how to create a custom topology programatically
+by subclassing Topo, and how to run a series of tests on it.
+
+miniedit.py:
+
+This example demonstrates creating a network via a graphical editor.
+
+multiping.py:
+
+This example demonstrates one method for
+monitoring output from multiple hosts, using node.monitor().
+
+multipoll.py:
+
+This example demonstrates monitoring output files from multiple hosts.
+
+multitest.py:
+
+This example creates a network and runs multiple tests on it.
+
+popen.py:
+
+This example monitors a number of hosts using host.popen() and
+pmonitor().
+
+popenpoll.py:
+
+This example demonstrates monitoring output from multiple hosts using
+the node.popen() interface (which returns Popen objects) and pmonitor().
+
+scratchnet.py, scratchnetuser.py:
+
+These two examples demonstrate how to create a network by using the lowest-
+level Mininet functions. Generally the higher-level API is easier to use,
+but scratchnet shows what is going on behind the scenes.
+
+simpleperf.py:
+
+A simple example of configuring network and CPU bandwidth limits.
+
+sshd.py:
+
+This example shows how to run an sshd process in each host, allowing
+you to log in via ssh. This requires connecting the Mininet data network
+to an interface in the root namespace (generaly the control network
+already lives in the root namespace, so it does not need to be explicitly
+connected.)
+
+treeping64.py:
+
+This example creates a 64-host tree network, and attempts to check full
+connectivity using ping, for different switch/datapath types.
+
+tree1024.py:
+
+This example attempts to create a 1024-host network, and then runs the
+CLI on it. It may run into scalability limits, depending on available
+memory and sysctl configuration (see INSTALL.)
+
diff --git a/examples/baresshd.py b/examples/baresshd.py
new file mode 100644
index 0000000..a714edb
--- /dev/null
+++ b/examples/baresshd.py
@@ -0,0 +1,32 @@
+#!/usr/bin/python
+
+"This example doesn't use OpenFlow, but attempts to run sshd in a namespace."
+
+from mininet.node import Host
+from mininet.util import ensureRoot
+
+ensureRoot()
+
+print "*** Creating nodes"
+h1 = Host( 'h1' )
+
+root = Host( 'root', inNamespace=False )
+
+print "*** Creating links"
+h1.linkTo( root )
+
+print h1
+
+print "*** Configuring nodes"
+h1.setIP( '10.0.0.1', 8 )
+root.setIP( '10.0.0.2', 8 )
+
+print "*** Creating banner file"
+f = open( '/tmp/%s.banner' % h1.name, 'w' )
+f.write( 'Welcome to %s at %s\n' % ( h1.name, h1.IP() ) )
+f.close()
+
+print "*** Running sshd"
+h1.cmd( '/usr/sbin/sshd -o "Banner /tmp/%s.banner"' % h1.name )
+
+print "*** You may now ssh into", h1.name, "at", h1.IP()
diff --git a/examples/consoles.py b/examples/consoles.py
new file mode 100644
index 0000000..ea2e28d
--- /dev/null
+++ b/examples/consoles.py
@@ -0,0 +1,456 @@
+#!/usr/bin/python
+
+"""
+consoles.py: bring up a bunch of miniature consoles on a virtual network
+
+This demo shows how to monitor a set of nodes by using
+Node's monitor() and Tkinter's createfilehandler().
+
+We monitor nodes in a couple of ways:
+
+- First, each individual node is monitored, and its output is added
+ to its console window
+
+- Second, each time a console window gets iperf output, it is parsed
+ and accumulated. Once we have output for all consoles, a bar is
+ added to the bandwidth graph.
+
+The consoles also support limited interaction:
+
+- Pressing "return" in a console will send a command to it
+
+- Pressing the console's title button will open up an xterm
+
+Bob Lantz, April 2010
+
+"""
+
+import re
+
+from Tkinter import Frame, Button, Label, Text, Scrollbar, Canvas, Wm, READABLE
+
+from mininet.log import setLogLevel
+from mininet.topolib import TreeNet
+from mininet.term import makeTerms, cleanUpScreens
+from mininet.util import quietRun
+
+class Console( Frame ):
+ "A simple console on a host."
+
+ def __init__( self, parent, net, node, height=10, width=32, title='Node' ):
+ Frame.__init__( self, parent )
+
+ self.net = net
+ self.node = node
+ self.prompt = node.name + '# '
+ self.height, self.width, self.title = height, width, title
+
+ # Initialize widget styles
+ self.buttonStyle = { 'font': 'Monaco 7' }
+ self.textStyle = {
+ 'font': 'Monaco 7',
+ 'bg': 'black',
+ 'fg': 'green',
+ 'width': self.width,
+ 'height': self.height,
+ 'relief': 'sunken',
+ 'insertbackground': 'green',
+ 'highlightcolor': 'green',
+ 'selectforeground': 'black',
+ 'selectbackground': 'green'
+ }
+
+ # Set up widgets
+ self.text = self.makeWidgets( )
+ self.bindEvents()
+ self.sendCmd( 'export TERM=dumb' )
+
+ self.outputHook = None
+
+ def makeWidgets( self ):
+ "Make a label, a text area, and a scroll bar."
+
+ def newTerm( net=self.net, node=self.node, title=self.title ):
+ "Pop up a new terminal window for a node."
+ net.terms += makeTerms( [ node ], title )
+ label = Button( self, text=self.node.name, command=newTerm,
+ **self.buttonStyle )
+ label.pack( side='top', fill='x' )
+ text = Text( self, wrap='word', **self.textStyle )
+ ybar = Scrollbar( self, orient='vertical', width=7,
+ command=text.yview )
+ text.configure( yscrollcommand=ybar.set )
+ text.pack( side='left', expand=True, fill='both' )
+ ybar.pack( side='right', fill='y' )
+ return text
+
+ def bindEvents( self ):
+ "Bind keyboard and file events."
+ # The text widget handles regular key presses, but we
+ # use special handlers for the following:
+ self.text.bind( '<Return>', self.handleReturn )
+ self.text.bind( '<Control-c>', self.handleInt )
+ self.text.bind( '<KeyPress>', self.handleKey )
+ # This is not well-documented, but it is the correct
+ # way to trigger a file event handler from Tk's
+ # event loop!
+ self.tk.createfilehandler( self.node.stdout, READABLE,
+ self.handleReadable )
+
+ # We're not a terminal (yet?), so we ignore the following
+ # control characters other than [\b\n\r]
+ ignoreChars = re.compile( r'[\x00-\x07\x09\x0b\x0c\x0e-\x1f]+' )
+
+ def append( self, text ):
+ "Append something to our text frame."
+ text = self.ignoreChars.sub( '', text )
+ self.text.insert( 'end', text )
+ self.text.mark_set( 'insert', 'end' )
+ self.text.see( 'insert' )
+ outputHook = lambda x, y: True # make pylint happier
+ if self.outputHook:
+ outputHook = self.outputHook
+ outputHook( self, text )
+
+ def handleKey( self, event ):
+ "If it's an interactive command, send it to the node."
+ char = event.char
+ if self.node.waiting:
+ self.node.write( char )
+
+ def handleReturn( self, event ):
+ "Handle a carriage return."
+ cmd = self.text.get( 'insert linestart', 'insert lineend' )
+ # Send it immediately, if "interactive" command
+ if self.node.waiting:
+ self.node.write( event.char )
+ return
+ # Otherwise send the whole line to the shell
+ pos = cmd.find( self.prompt )
+ if pos >= 0:
+ cmd = cmd[ pos + len( self.prompt ): ]
+ self.sendCmd( cmd )
+
+ # Callback ignores event
+ def handleInt( self, _event=None ):
+ "Handle control-c."
+ self.node.sendInt()
+
+ def sendCmd( self, cmd ):
+ "Send a command to our node."
+ if not self.node.waiting:
+ self.node.sendCmd( cmd )
+
+ def handleReadable( self, _fds, timeoutms=None ):
+ "Handle file readable event."
+ data = self.node.monitor( timeoutms )
+ self.append( data )
+ if not self.node.waiting:
+ # Print prompt
+ self.append( self.prompt )
+
+ def waiting( self ):
+ "Are we waiting for output?"
+ return self.node.waiting
+
+ def waitOutput( self ):
+ "Wait for any remaining output."
+ while self.node.waiting:
+ # A bit of a trade-off here...
+ self.handleReadable( self, timeoutms=1000)
+ self.update()
+
+ def clear( self ):
+ "Clear all of our text."
+ self.text.delete( '1.0', 'end' )
+
+
+class Graph( Frame ):
+
+ "Graph that we can add bars to over time."
+
+ def __init__( self, parent=None, bg = 'white', gheight=200, gwidth=500,
+ barwidth=10, ymax=3.5,):
+
+ Frame.__init__( self, parent )
+
+ self.bg = bg
+ self.gheight = gheight
+ self.gwidth = gwidth
+ self.barwidth = barwidth
+ self.ymax = float( ymax )
+ self.xpos = 0
+
+ # Create everything
+ self.title, self.scale, self.graph = self.createWidgets()
+ self.updateScrollRegions()
+ self.yview( 'moveto', '1.0' )
+
+ def createScale( self ):
+ "Create a and return a new canvas with scale markers."
+ height = float( self.gheight )
+ width = 25
+ ymax = self.ymax
+ scale = Canvas( self, width=width, height=height,
+ background=self.bg )
+ opts = { 'fill': 'red' }
+ # Draw scale line
+ scale.create_line( width - 1, height, width - 1, 0, **opts )
+ # Draw ticks and numbers
+ for y in range( 0, int( ymax + 1 ) ):
+ ypos = height * (1 - float( y ) / ymax )
+ scale.create_line( width, ypos, width - 10, ypos, **opts )
+ scale.create_text( 10, ypos, text=str( y ), **opts )
+ return scale
+
+ def updateScrollRegions( self ):
+ "Update graph and scale scroll regions."
+ ofs = 20
+ height = self.gheight + ofs
+ self.graph.configure( scrollregion=( 0, -ofs,
+ self.xpos * self.barwidth, height ) )
+ self.scale.configure( scrollregion=( 0, -ofs, 0, height ) )
+
+ def yview( self, *args ):
+ "Scroll both scale and graph."
+ self.graph.yview( *args )
+ self.scale.yview( *args )
+
+ def createWidgets( self ):
+ "Create initial widget set."
+
+ # Objects
+ title = Label( self, text='Bandwidth (Gb/s)', bg=self.bg )
+ width = self.gwidth
+ height = self.gheight
+ scale = self.createScale()
+ graph = Canvas( self, width=width, height=height, background=self.bg)
+ xbar = Scrollbar( self, orient='horizontal', command=graph.xview )
+ ybar = Scrollbar( self, orient='vertical', command=self.yview )
+ graph.configure( xscrollcommand=xbar.set, yscrollcommand=ybar.set,
+ scrollregion=(0, 0, width, height ) )
+ scale.configure( yscrollcommand=ybar.set )
+
+ # Layout
+ title.grid( row=0, columnspan=3, sticky='new')
+ scale.grid( row=1, column=0, sticky='nsew' )
+ graph.grid( row=1, column=1, sticky='nsew' )
+ ybar.grid( row=1, column=2, sticky='ns' )
+ xbar.grid( row=2, column=0, columnspan=2, sticky='ew' )
+ self.rowconfigure( 1, weight=1 )
+ self.columnconfigure( 1, weight=1 )
+ return title, scale, graph
+
+ def addBar( self, yval ):
+ "Add a new bar to our graph."
+ percent = yval / self.ymax
+ c = self.graph
+ x0 = self.xpos * self.barwidth
+ x1 = x0 + self.barwidth
+ y0 = self.gheight
+ y1 = ( 1 - percent ) * self.gheight
+ c.create_rectangle( x0, y0, x1, y1, fill='green' )
+ self.xpos += 1
+ self.updateScrollRegions()
+ self.graph.xview( 'moveto', '1.0' )
+
+ def clear( self ):
+ "Clear graph contents."
+ self.graph.delete( 'all' )
+ self.xpos = 0
+
+ def test( self ):
+ "Add a bar for testing purposes."
+ ms = 1000
+ if self.xpos < 10:
+ self.addBar( self.xpos / 10 * self.ymax )
+ self.after( ms, self.test )
+
+ def setTitle( self, text ):
+ "Set graph title"
+ self.title.configure( text=text, font='Helvetica 9 bold' )
+
+
+class ConsoleApp( Frame ):
+
+ "Simple Tk consoles for Mininet."
+
+ menuStyle = { 'font': 'Geneva 7 bold' }
+
+ def __init__( self, net, parent=None, width=4 ):
+ Frame.__init__( self, parent )
+ self.top = self.winfo_toplevel()
+ self.top.title( 'Mininet' )
+ self.net = net
+ self.menubar = self.createMenuBar()
+ cframe = self.cframe = Frame( self )
+ self.consoles = {} # consoles themselves
+ titles = {
+ 'hosts': 'Host',
+ 'switches': 'Switch',
+ 'controllers': 'Controller'
+ }
+ for name in titles:
+ nodes = getattr( net, name )
+ frame, consoles = self.createConsoles(
+ cframe, nodes, width, titles[ name ] )
+ self.consoles[ name ] = Object( frame=frame, consoles=consoles )
+ self.selected = None
+ self.select( 'hosts' )
+ self.cframe.pack( expand=True, fill='both' )
+ cleanUpScreens()
+ # Close window gracefully
+ Wm.wm_protocol( self.top, name='WM_DELETE_WINDOW', func=self.quit )
+
+ # Initialize graph
+ graph = Graph( cframe )
+ self.consoles[ 'graph' ] = Object( frame=graph, consoles=[ graph ] )
+ self.graph = graph
+ self.graphVisible = False
+ self.updates = 0
+ self.hostCount = len( self.consoles[ 'hosts' ].consoles )
+ self.bw = 0
+
+ self.pack( expand=True, fill='both' )
+
+ def updateGraph( self, _console, output ):
+ "Update our graph."
+ m = re.search( r'(\d+) Mbits/sec', output )
+ if not m:
+ return
+ self.updates += 1
+ self.bw += .001 * float( m.group( 1 ) )
+ if self.updates >= self.hostCount:
+ self.graph.addBar( self.bw )
+ self.bw = 0
+ self.updates = 0
+
+ def setOutputHook( self, fn=None, consoles=None ):
+ "Register fn as output hook [on specific consoles.]"
+ if consoles is None:
+ consoles = self.consoles[ 'hosts' ].consoles
+ for console in consoles:
+ console.outputHook = fn
+
+ def createConsoles( self, parent, nodes, width, title ):
+ "Create a grid of consoles in a frame."
+ f = Frame( parent )
+ # Create consoles
+ consoles = []
+ index = 0
+ for node in nodes:
+ console = Console( f, self.net, node, title=title )
+ consoles.append( console )
+ row = index / width
+ column = index % width
+ console.grid( row=row, column=column, sticky='nsew' )
+ index += 1
+ f.rowconfigure( row, weight=1 )
+ f.columnconfigure( column, weight=1 )
+ return f, consoles
+
+ def select( self, groupName ):
+ "Select a group of consoles to display."
+ if self.selected is not None:
+ self.selected.frame.pack_forget()
+ self.selected = self.consoles[ groupName ]
+ self.selected.frame.pack( expand=True, fill='both' )
+
+ def createMenuBar( self ):
+ "Create and return a menu (really button) bar."
+ f = Frame( self )
+ buttons = [
+ ( 'Hosts', lambda: self.select( 'hosts' ) ),
+ ( 'Switches', lambda: self.select( 'switches' ) ),
+ ( 'Controllers', lambda: self.select( 'controllers' ) ),
+ ( 'Graph', lambda: self.select( 'graph' ) ),
+ ( 'Ping', self.ping ),
+ ( 'Iperf', self.iperf ),
+ ( 'Interrupt', self.stop ),
+ ( 'Clear', self.clear ),
+ ( 'Quit', self.quit )
+ ]
+ for name, cmd in buttons:
+ b = Button( f, text=name, command=cmd, **self.menuStyle )
+ b.pack( side='left' )
+ f.pack( padx=4, pady=4, fill='x' )
+ return f
+
+ def clear( self ):
+ "Clear selection."
+ for console in self.selected.consoles:
+ console.clear()
+
+ def waiting( self, consoles=None ):
+ "Are any of our hosts waiting for output?"
+ if consoles is None:
+ consoles = self.consoles[ 'hosts' ].consoles
+ for console in consoles:
+ if console.waiting():
+ return True
+ return False
+
+ def ping( self ):
+ "Tell each host to ping the next one."
+ consoles = self.consoles[ 'hosts' ].consoles
+ if self.waiting( consoles ):
+ return
+ count = len( consoles )
+ i = 0
+ for console in consoles:
+ i = ( i + 1 ) % count
+ ip = consoles[ i ].node.IP()
+ console.sendCmd( 'ping ' + ip )
+
+ def iperf( self ):
+ "Tell each host to iperf to the next one."
+ consoles = self.consoles[ 'hosts' ].consoles
+ if self.waiting( consoles ):
+ return
+ count = len( consoles )
+ self.setOutputHook( self.updateGraph )
+ for console in consoles:
+ console.node.cmd( 'iperf -sD' )
+ i = 0
+ for console in consoles:
+ i = ( i + 1 ) % count
+ ip = consoles[ i ].node.IP()
+ console.sendCmd( 'iperf -t 99999 -i 1 -c ' + ip )
+
+ def stop( self, wait=True ):
+ "Interrupt all hosts."
+ consoles = self.consoles[ 'hosts' ].consoles
+ for console in consoles:
+ console.handleInt()
+ if wait:
+ for console in consoles:
+ console.waitOutput()
+ self.setOutputHook( None )
+ # Shut down any iperfs that might still be running
+ quietRun( 'killall -9 iperf' )
+
+ def quit( self ):
+ "Stop everything and quit."
+ self.stop( wait=False)
+ Frame.quit( self )
+
+
+# Make it easier to construct and assign objects
+
+def assign( obj, **kwargs ):
+ "Set a bunch of fields in an object."
+ obj.__dict__.update( kwargs )
+
+class Object( object ):
+ "Generic object you can stuff junk into."
+ def __init__( self, **kwargs ):
+ assign( self, **kwargs )
+
+
+if __name__ == '__main__':
+ setLogLevel( 'info' )
+ network = TreeNet( depth=2, fanout=4 )
+ network.start()
+ app = ConsoleApp( network, width=4 )
+ app.mainloop()
+ network.stop()
diff --git a/examples/controllers.py b/examples/controllers.py
new file mode 100644
index 0000000..6eeef0e
--- /dev/null
+++ b/examples/controllers.py
@@ -0,0 +1,64 @@
+#!/usr/bin/python
+
+"""
+This example creates a multi-controller network from
+semi-scratch; note a topo object could also be used and
+would be passed into the Mininet() constructor.
+"""
+
+from mininet.net import Mininet
+from mininet.node import Controller, OVSKernelSwitch
+from mininet.cli import CLI
+from mininet.log import setLogLevel
+
+Switch = OVSKernelSwitch
+
+def addHost( net, N ):
+ "Create host hN and add to net."
+ name = 'h%d' % N
+ ip = '10.0.0.%d' % N
+ return net.addHost( name, ip=ip )
+
+def multiControllerNet():
+ "Create a network with multiple controllers."
+
+ net = Mininet( controller=Controller, switch=Switch)
+
+ print "*** Creating controllers"
+ c1 = net.addController( 'c1', port=6633 )
+ c2 = net.addController( 'c2', port=6634 )
+
+ print "*** Creating switches"
+ s1 = net.addSwitch( 's1' )
+ s2 = net.addSwitch( 's2' )
+
+ print "*** Creating hosts"
+ hosts1 = [ addHost( net, n ) for n in 3, 4 ]
+ hosts2 = [ addHost( net, n ) for n in 5, 6 ]
+
+ print "*** Creating links"
+ for h in hosts1:
+ s1.linkTo( h )
+ for h in hosts2:
+ s2.linkTo( h )
+ s1.linkTo( s2 )
+
+ print "*** Starting network"
+ net.build()
+ c1.start()
+ c2.start()
+ s1.start( [ c1 ] )
+ s2.start( [ c2 ] )
+
+ print "*** Testing network"
+ net.pingAll()
+
+ print "*** Running CLI"
+ CLI( net )
+
+ print "*** Stopping network"
+ net.stop()
+
+if __name__ == '__main__':
+ setLogLevel( 'info' ) # for CLI output
+ multiControllerNet()
diff --git a/examples/cpu.py b/examples/cpu.py
new file mode 100644
index 0000000..6dfc936
--- /dev/null
+++ b/examples/cpu.py
@@ -0,0 +1,81 @@
+#!/usr/bin/python
+
+"""
+cpu.py: test iperf bandwidth for varying cpu limits
+"""
+
+from mininet.net import Mininet
+from mininet.node import CPULimitedHost
+from mininet.topolib import TreeTopo
+from mininet.util import custom
+from mininet.log import setLogLevel, output
+
+from time import sleep
+
+def waitListening(client, server, port):
+ "Wait until server is listening on port"
+ if not client.cmd('which telnet'):
+ raise Exception('Could not find telnet')
+ cmd = ('sh -c "echo A | telnet -e A %s %s"' %
+ (server.IP(), port))
+ while 'Connected' not in client.cmd(cmd):
+ output('waiting for', server,
+ 'to listen on port', port, '\n')
+ sleep(.5)
+
+
+def bwtest( cpuLimits, period_us=100000, seconds=5 ):
+ """Example/test of link and CPU bandwidth limits
+ cpu: cpu limit as fraction of overall CPU time"""
+
+ topo = TreeTopo( depth=1, fanout=2 )
+
+ results = {}
+
+ for sched in 'rt', 'cfs':
+ print '*** Testing with', sched, 'bandwidth limiting'
+ for cpu in cpuLimits:
+ host = custom( CPULimitedHost, sched=sched,
+ period_us=period_us,
+ cpu=cpu )
+ net = Mininet( topo=topo, host=host )
+ net.start()
+ net.pingAll()
+ hosts = [ net.getNodeByName( h ) for h in topo.hosts() ]
+ client, server = hosts[ 0 ], hosts[ -1 ]
+ server.cmd( 'iperf -s -p 5001 &' )
+ waitListening( client, server, 5001 )
+ result = client.cmd( 'iperf -yc -t %s -c %s' % (
+ seconds, server.IP() ) ).split( ',' )
+ bps = float( result[ -1 ] )
+ server.cmdPrint( 'kill %iperf' )
+ net.stop()
+ updated = results.get( sched, [] )
+ updated += [ ( cpu, bps ) ]
+ results[ sched ] = updated
+
+ return results
+
+
+def dump( results ):
+ "Dump results"
+
+ fmt = '%s\t%s\t%s'
+
+ print
+ print fmt % ( 'sched', 'cpu', 'client MB/s' )
+ print
+
+ for sched in sorted( results.keys() ):
+ entries = results[ sched ]
+ for cpu, bps in entries:
+ pct = '%.2f%%' % ( cpu * 100 )
+ mbps = bps / 1e6
+ print fmt % ( sched, pct, mbps )
+
+
+if __name__ == '__main__':
+ setLogLevel( 'info' )
+ limits = [ .45, .4, .3, .2, .1 ]
+ out = bwtest( limits )
+ dump( out )
diff --git a/examples/emptynet.py b/examples/emptynet.py
new file mode 100644
index 0000000..9f57855
--- /dev/null
+++ b/examples/emptynet.py
@@ -0,0 +1,44 @@
+#!/usr/bin/python
+
+"""
+This example shows how to create an empty Mininet object
+(without a topology object) and add nodes to it manually.
+"""
+
+from mininet.net import Mininet
+from mininet.node import Controller
+from mininet.cli import CLI
+from mininet.log import setLogLevel, info
+
+def emptyNet():
+
+ "Create an empty network and add nodes to it."
+
+ net = Mininet( controller=Controller )
+
+ info( '*** Adding controller\n' )
+ net.addController( 'c0' )
+
+ info( '*** Adding hosts\n' )
+ h1 = net.addHost( 'h1', ip='10.0.0.1' )
+ h2 = net.addHost( 'h2', ip='10.0.0.2' )
+
+ info( '*** Adding switch\n' )
+ s3 = net.addSwitch( 's3' )
+
+ info( '*** Creating links\n' )
+ h1.linkTo( s3 )
+ h2.linkTo( s3 )
+
+ info( '*** Starting network\n')
+ net.start()
+
+ info( '*** Running CLI\n' )
+ CLI( net )
+
+ info( '*** Stopping network' )
+ net.stop()
+
+if __name__ == '__main__':
+ setLogLevel( 'info' )
+ emptyNet()
diff --git a/examples/hwintf.py b/examples/hwintf.py
new file mode 100644
index 0000000..e5960d9
--- /dev/null
+++ b/examples/hwintf.py
@@ -0,0 +1,48 @@
+#!/usr/bin/python
+
+"""
+This example shows how to add an interface (for example a real
+hardware interface) to a network after the network is created.
+"""
+
+import re
+
+from mininet.cli import CLI
+from mininet.log import setLogLevel, info, error
+from mininet.net import Mininet
+from mininet.link import Intf
+from mininet.topolib import TreeTopo
+from mininet.util import quietRun
+
+def checkIntf( intf ):
+ "Make sure intf exists and is not configured."
+ if ( ' %s:' % intf ) not in quietRun( 'ip link show' ):
+ error( 'Error:', intf, 'does not exist!\n' )
+ exit( 1 )
+ ips = re.findall( r'\d+\.\d+\.\d+\.\d+', quietRun( 'ifconfig ' + intf ) )
+ if ips:
+ error( 'Error:', intf, 'has an IP address,'
+ 'and is probably in use!\n' )
+ exit( 1 )
+
+if __name__ == '__main__':
+ setLogLevel( 'info' )
+
+ intfName = 'eth1'
+ info( '*** Checking', intfName, '\n' )
+ checkIntf( intfName )
+
+ info( '*** Creating network\n' )
+ net = Mininet( topo=TreeTopo( depth=1, fanout=2 ) )
+
+ switch = net.switches[ 0 ]
+ info( '*** Adding hardware interface', intfName, 'to switch',
+ switch.name, '\n' )
+ _intf = Intf( intfName, node=switch )
+
+ info( '*** Note: you may need to reconfigure the interfaces for '
+ 'the Mininet hosts:\n', net.hosts, '\n' )
+
+ net.start()
+ CLI( net )
+ net.stop()
diff --git a/examples/limit.py b/examples/limit.py
new file mode 100644
index 0000000..0b23ca1
--- /dev/null
+++ b/examples/limit.py
@@ -0,0 +1,53 @@
+#!/usr/bin/python
+
+"""
+limit.py: example of using link and CPU limits
+"""
+
+from mininet.net import Mininet
+from mininet.link import TCIntf
+from mininet.node import CPULimitedHost
+from mininet.topolib import TreeTopo
+from mininet.util import custom
+from mininet.log import setLogLevel
+
+
+def testLinkLimit( net, bw ):
+ "Run bandwidth limit test"
+ print '*** Testing network %.2f Mbps bandwidth limit' % bw
+ net.iperf( )
+
+
+def limit( bw=10, cpu=.1 ):
+ """Example/test of link and CPU bandwidth limits
+ bw: interface bandwidth limit in Mbps
+ cpu: cpu limit as fraction of overall CPU time"""
+ intf = custom( TCIntf, bw=bw )
+ myTopo = TreeTopo( depth=1, fanout=2 )
+ for sched in 'rt', 'cfs':
+ print '*** Testing with', sched, 'bandwidth limiting'
+ host = custom( CPULimitedHost, sched=sched, cpu=cpu )
+ net = Mininet( topo=myTopo, intf=intf, host=host )
+ net.start()
+ testLinkLimit( net, bw=bw )
+ net.runCpuLimitTest( cpu=cpu )
+ net.stop()
+
+def verySimpleLimit( bw=150 ):
+ "Absurdly simple limiting test"
+ intf = custom( TCIntf, bw=bw )
+ net = Mininet( intf=intf )
+ h1, h2 = net.addHost( 'h1' ), net.addHost( 'h2' )
+ net.addLink( h1, h2 )
+ net.start()
+ net.pingAll()
+ net.iperf()
+ h1.cmdPrint( 'tc -s qdisc ls dev', h1.defaultIntf() )
+ h2.cmdPrint( 'tc -d class show dev', h2.defaultIntf() )
+ h1.cmdPrint( 'tc -s qdisc ls dev', h1.defaultIntf() )
+ h2.cmdPrint( 'tc -d class show dev', h2.defaultIntf() )
+ net.stop()
+
+if __name__ == '__main__':
+ setLogLevel( 'info' )
+ limit()
diff --git a/examples/linearbandwidth.py b/examples/linearbandwidth.py
new file mode 100644
index 0000000..3fd06c7
--- /dev/null
+++ b/examples/linearbandwidth.py
@@ -0,0 +1,110 @@
+#!/usr/bin/python
+
+"""
+Test bandwidth (using iperf) on linear networks of varying size,
+using both kernel and user datapaths.
+
+We construct a network of N hosts and N-1 switches, connected as follows:
+
+h1 <-> s1 <-> s2 .. sN-1
+ | | |
+ h2 h3 hN
+
+WARNING: by default, the reference controller only supports 16
+switches, so this test WILL NOT WORK unless you have recompiled
+your controller to support 100 switches (or more.)
+
+In addition to testing the bandwidth across varying numbers
+of switches, this example demonstrates:
+
+- creating a custom topology, LinearTestTopo
+- using the ping() and iperf() tests from Mininet()
+- testing both the kernel and user switches
+
+"""
+
+from mininet.net import Mininet
+from mininet.node import UserSwitch, OVSKernelSwitch
+from mininet.topo import Topo
+from mininet.log import lg
+from mininet.util import irange
+
+import sys
+flush = sys.stdout.flush
+
+class LinearTestTopo( Topo ):
+ "Topology for a string of N hosts and N-1 switches."
+
+ def __init__( self, N, **params ):
+
+ # Initialize topology
+ Topo.__init__( self, **params )
+
+ # Create switches and hosts
+ hosts = [ self.addHost( 'h%s' % h )
+ for h in irange( 1, N ) ]
+ switches = [ self.addSwitch( 's%s' % s )
+ for s in irange( 1, N - 1 ) ]
+
+ # Wire up switches
+ last = None
+ for switch in switches:
+ if last:
+ self.addLink( last, switch )
+ last = switch
+
+ # Wire up hosts
+ self.addLink( hosts[ 0 ], switches[ 0 ] )
+ for host, switch in zip( hosts[ 1: ], switches ):
+ self.addLink( host, switch )
+
+
+def linearBandwidthTest( lengths ):
+
+ "Check bandwidth at various lengths along a switch chain."
+
+ results = {}
+ switchCount = max( lengths )
+ hostCount = switchCount + 1
+
+ switches = { 'reference user': UserSwitch,
+ 'Open vSwitch kernel': OVSKernelSwitch }
+
+ topo = LinearTestTopo( hostCount )
+
+ for datapath in switches.keys():
+ print "*** testing", datapath, "datapath"
+ Switch = switches[ datapath ]
+ results[ datapath ] = []
+ net = Mininet( topo=topo, switch=Switch )
+ net.start()
+ print "*** testing basic connectivity"
+ for n in lengths:
+ net.ping( [ net.hosts[ 0 ], net.hosts[ n ] ] )
+ print "*** testing bandwidth"
+ for n in lengths:
+ src, dst = net.hosts[ 0 ], net.hosts[ n ]
+ print "testing", src.name, "<->", dst.name,
+ bandwidth = net.iperf( [ src, dst ] )
+ print bandwidth
+ flush()
+ results[ datapath ] += [ ( n, bandwidth ) ]
+ net.stop()
+
+ for datapath in switches.keys():
+ print
+ print "*** Linear network results for", datapath, "datapath:"
+ print
+ result = results[ datapath ]
+ print "SwitchCount\tiperf Results"
+ for switchCount, bandwidth in result:
+ print switchCount, '\t\t',
+ print bandwidth[ 0 ], 'server, ', bandwidth[ 1 ], 'client'
+ print
+ print
+
+if __name__ == '__main__':
+ lg.setLogLevel( 'info' )
+ sizes = [ 1, 10, 20, 40, 60, 80, 100 ]
+ print "*** Running linearBandwidthTest", sizes
+ linearBandwidthTest( sizes )
diff --git a/examples/miniedit.py b/examples/miniedit.py
new file mode 100644
index 0000000..c17cf3d
--- /dev/null
+++ b/examples/miniedit.py
@@ -0,0 +1,771 @@
+#!/usr/bin/python
+
+"""
+MiniEdit: a simple network editor for Mininet
+
+This is a simple demonstration of how one might build a
+GUI application using Mininet as the network model.
+
+Development version - not entirely functional!
+
+Bob Lantz, April 2010
+"""
+import optparse
+
+from Tkinter import Frame, Button, Label, Scrollbar, Canvas
+from Tkinter import Menu, BitmapImage, PhotoImage, Wm, Toplevel
+
+# someday: from ttk import *
+
+from mininet.log import setLogLevel
+from mininet.net import Mininet
+from mininet.util import ipStr
+from mininet.term import makeTerm, cleanUpScreens
+
+
+def parse_args():
+ usage="""Usage: miniccnxedit [template_file]
+ If no template_file is given, generated template will be written
+ to the file topo.miniccnx in the current directory.
+ """
+
+ parser = optparse.OptionParser(usage)
+
+ #parser.add_option("-t", "--template", help="template file name")
+ _, arg = parser.parse_args()
+
+ return arg
+
+class MiniEdit( Frame ):
+
+ "A simple network editor for Mininet."
+
+ def __init__( self, parent=None, cheight=200, cwidth=500, template_file='topo.miniccnx' ):
+
+ Frame.__init__( self, parent )
+ self.action = None
+ self.appName = 'Mini-CCNx'
+ self.template_file = template_file
+
+ # Style
+ self.font = ( 'Geneva', 9 )
+ self.smallFont = ( 'Geneva', 7 )
+ self.bg = 'white'
+
+ # Title
+ self.top = self.winfo_toplevel()
+ self.top.title( self.appName )
+
+ # Menu bar
+ self.createMenubar()
+
+ # Editing canvas
+ self.cheight, self.cwidth = cheight, cwidth
+ self.cframe, self.canvas = self.createCanvas()
+
+ # Toolbar
+ self.images = miniEditImages()
+ self.buttons = {}
+ self.active = None
+ self.tools = ( 'Select', 'Host', 'Switch', 'Link' )
+ self.customColors = { 'Switch': 'darkGreen', 'Host': 'blue' }
+ self.toolbar = self.createToolbar()
+
+ # Layout
+ self.toolbar.grid( column=0, row=0, sticky='nsew')
+ self.cframe.grid( column=1, row=0 )
+ self.columnconfigure( 1, weight=1 )
+ self.rowconfigure( 0, weight=1 )
+ self.pack( expand=True, fill='both' )
+
+ # About box
+ self.aboutBox = None
+
+ # Initialize node data
+ self.nodeBindings = self.createNodeBindings()
+ self.nodePrefixes = { 'Switch': 's', 'Host': 'h' }
+ self.widgetToItem = {}
+ self.itemToWidget = {}
+
+ # Initialize link tool
+ self.link = self.linkWidget = None
+
+ # Selection support
+ self.selection = None
+
+ # Keyboard bindings
+ self.bind( '<Control-q>', lambda event: self.quit() )
+ self.bind( '<KeyPress-Delete>', self.deleteSelection )
+ self.bind( '<KeyPress-BackSpace>', self.deleteSelection )
+ self.focus()
+
+ # Event handling initalization
+ self.linkx = self.linky = self.linkItem = None
+ self.lastSelection = None
+
+ # Model initialization
+ self.links = {}
+ self.nodeCount = 0
+ self.net = None
+
+ # Close window gracefully
+ Wm.wm_protocol( self.top, name='WM_DELETE_WINDOW', func=self.quit )
+
+ def quit( self ):
+ "Stop our network, if any, then quit."
+ self.stop()
+ Frame.quit( self )
+
+ def createMenubar( self ):
+ "Create our menu bar."
+
+ font = self.font
+
+ mbar = Menu( self.top, font=font )
+ self.top.configure( menu=mbar )
+
+ # Application menu
+ appMenu = Menu( mbar, tearoff=False )
+ mbar.add_cascade( label=self.appName, font=font, menu=appMenu )
+ appMenu.add_command( label='About Mini-CCNx', command=self.about,
+ font=font)
+ appMenu.add_separator()
+ appMenu.add_command( label='Quit', command=self.quit, font=font )
+
+ #fileMenu = Menu( mbar, tearoff=False )
+ #mbar.add_cascade( label="File", font=font, menu=fileMenu )
+ #fileMenu.add_command( label="Load...", font=font )
+ #fileMenu.add_separator()
+ #fileMenu.add_command( label="Save", font=font )
+ #fileMenu.add_separator()
+ #fileMenu.add_command( label="Print", font=font )
+
+ editMenu = Menu( mbar, tearoff=False )
+ mbar.add_cascade( label="Edit", font=font, menu=editMenu )
+ editMenu.add_command( label="Cut", font=font,
+ command=lambda: self.deleteSelection( None ) )
+
+ # runMenu = Menu( mbar, tearoff=False )
+ # mbar.add_cascade( label="Run", font=font, menu=runMenu )
+ # runMenu.add_command( label="Run", font=font, command=self.doRun )
+ # runMenu.add_command( label="Stop", font=font, command=self.doStop )
+ # runMenu.add_separator()
+ # runMenu.add_command( label='Xterm', font=font, command=self.xterm )
+
+ # Canvas
+
+ def createCanvas( self ):
+ "Create and return our scrolling canvas frame."
+ f = Frame( self )
+
+ canvas = Canvas( f, width=self.cwidth, height=self.cheight,
+ bg=self.bg )
+
+ # Scroll bars
+ xbar = Scrollbar( f, orient='horizontal', command=canvas.xview )
+ ybar = Scrollbar( f, orient='vertical', command=canvas.yview )
+ canvas.configure( xscrollcommand=xbar.set, yscrollcommand=ybar.set )
+
+ # Resize box
+ resize = Label( f, bg='white' )
+
+ # Layout
+ canvas.grid( row=0, column=1, sticky='nsew')
+ ybar.grid( row=0, column=2, sticky='ns')
+ xbar.grid( row=1, column=1, sticky='ew' )
+ resize.grid( row=1, column=2, sticky='nsew' )
+
+ # Resize behavior
+ f.rowconfigure( 0, weight=1 )
+ f.columnconfigure( 1, weight=1 )
+ f.grid( row=0, column=0, sticky='nsew' )
+ f.bind( '<Configure>', lambda event: self.updateScrollRegion() )
+
+ # Mouse bindings
+ canvas.bind( '<ButtonPress-1>', self.clickCanvas )
+ canvas.bind( '<B1-Motion>', self.dragCanvas )
+ canvas.bind( '<ButtonRelease-1>', self.releaseCanvas )
+
+ return f, canvas
+
+ def updateScrollRegion( self ):
+ "Update canvas scroll region to hold everything."
+ bbox = self.canvas.bbox( 'all' )
+ if bbox is not None:
+ self.canvas.configure( scrollregion=( 0, 0, bbox[ 2 ],
+ bbox[ 3 ] ) )
+
+ def canvasx( self, x_root ):
+ "Convert root x coordinate to canvas coordinate."
+ c = self.canvas
+ return c.canvasx( x_root ) - c.winfo_rootx()
+
+ def canvasy( self, y_root ):
+ "Convert root y coordinate to canvas coordinate."
+ c = self.canvas
+ return c.canvasy( y_root ) - c.winfo_rooty()
+
+ # Toolbar
+
+ def activate( self, toolName ):
+ "Activate a tool and press its button."
+ # Adjust button appearance
+ if self.active:
+ self.buttons[ self.active ].configure( relief='raised' )
+ self.buttons[ toolName ].configure( relief='sunken' )
+ # Activate dynamic bindings
+ self.active = toolName
+
+ def createToolbar( self ):
+ "Create and return our toolbar frame."
+
+ toolbar = Frame( self )
+
+ # Tools
+ for tool in self.tools:
+ cmd = ( lambda t=tool: self.activate( t ) )
+ b = Button( toolbar, text=tool, font=self.smallFont, command=cmd)
+ if tool in self.images:
+ b.config( height=50, image=self.images[ tool ] )
+ # b.config( compound='top' )
+ b.pack( fill='x' )
+ self.buttons[ tool ] = b
+ self.activate( self.tools[ 0 ] )
+
+ # Spacer
+ Label( toolbar, text='' ).pack()
+
+ # Commands
+ #for cmd, color in [ ( 'Stop', 'darkRed' ), ( 'Run', 'darkGreen' ) ]:
+ # doCmd = getattr( self, 'do' + cmd )
+ # b = Button( toolbar, text=cmd, font=self.smallFont,
+ # fg=color, command=doCmd )
+ # b.pack( fill='x', side='bottom' )
+
+ for cmd, color in [ ( 'Generate', 'darkGreen' ) ]:
+ doCmd = getattr( self, 'do' + cmd )
+ b = Button( toolbar, text=cmd, font=self.smallFont,
+ fg=color, command=doCmd )
+ b.pack( fill='x', side='bottom' )
+
+
+ return toolbar
+
+ def doGenerate( self ):
+ "Generate template."
+ self.activate( 'Select' )
+ for tool in self.tools:
+ self.buttons[ tool ].config( state='disabled' )
+
+ self.buildTemplate()
+
+ for tool in self.tools:
+ self.buttons[ tool ].config( state='normal' )
+
+ def doStop( self ):
+ "Stop command."
+ self.stop()
+ for tool in self.tools:
+ self.buttons[ tool ].config( state='normal' )
+
+ def buildTemplate( self ):
+ "Generate template"
+
+ template = open(self.template_file, 'w')
+
+ # hosts
+ template.write('[hosts]\n')
+ for widget in self.widgetToItem:
+ name = widget[ 'text' ]
+ tags = self.canvas.gettags( self.widgetToItem[ widget ] )
+ if 'Host' in tags:
+ template.write(name + ':\n')
+
+ # switches/routers
+ template.write('[routers]\n')
+ for widget in self.widgetToItem:
+ name = widget[ 'text' ]
+ tags = self.canvas.gettags( self.widgetToItem[ widget ] )
+ if 'Switch' in tags:
+ template.write(name + ':\n')
+
+ # Make links
+ template.write('[links]\n')
+ for link in self.links.values():
+ ( src, dst ) = link
+ srcName, dstName = src[ 'text' ], dst[ 'text' ]
+ template.write(srcName + ':' + dstName + '\n')
+
+ template.close()
+
+
+ # Generic canvas handler
+ #
+ # We could have used bindtags, as in nodeIcon, but
+ # the dynamic approach used here
+ # may actually require less code. In any case, it's an
+ # interesting introspection-based alternative to bindtags.
+
+ def canvasHandle( self, eventName, event ):
+ "Generic canvas event handler"
+ if self.active is None:
+ return
+ toolName = self.active
+ handler = getattr( self, eventName + toolName, None )
+ if handler is not None:
+ handler( event )
+
+ def clickCanvas( self, event ):
+ "Canvas click handler."
+ self.canvasHandle( 'click', event )
+
+ def dragCanvas( self, event ):
+ "Canvas drag handler."
+ self.canvasHandle( 'drag', event )
+
+ def releaseCanvas( self, event ):
+ "Canvas mouse up handler."
+ self.canvasHandle( 'release', event )
+
+ # Currently the only items we can select directly are
+ # links. Nodes are handled by bindings in the node icon.
+
+ def findItem( self, x, y ):
+ "Find items at a location in our canvas."
+ items = self.canvas.find_overlapping( x, y, x, y )
+ if len( items ) == 0:
+ return None
+ else:
+ return items[ 0 ]
+
+ # Canvas bindings for Select, Host, Switch and Link tools
+
+ def clickSelect( self, event ):
+ "Select an item."
+ self.selectItem( self.findItem( event.x, event.y ) )
+
+ def deleteItem( self, item ):
+ "Delete an item."
+ # Don't delete while network is running
+ if self.buttons[ 'Select' ][ 'state' ] == 'disabled':
+ return
+ # Delete from model
+ if item in self.links:
+ self.deleteLink( item )
+ if item in self.itemToWidget:
+ self.deleteNode( item )
+ # Delete from view
+ self.canvas.delete( item )
+
+ def deleteSelection( self, _event ):
+ "Delete the selected item."
+ if self.selection is not None:
+ self.deleteItem( self.selection )
+ self.selectItem( None )
+
+ def nodeIcon( self, node, name ):
+ "Create a new node icon."
+ icon = Button( self.canvas, image=self.images[ node ],
+ text=name, compound='top' )
+ # Unfortunately bindtags wants a tuple
+ bindtags = [ str( self.nodeBindings ) ]
+ bindtags += list( icon.bindtags() )
+ icon.bindtags( tuple( bindtags ) )
+ return icon
+
+ def newNode( self, node, event ):
+ "Add a new node to our canvas."
+ c = self.canvas
+ x, y = c.canvasx( event.x ), c.canvasy( event.y )
+ self.nodeCount += 1
+ name = self.nodePrefixes[ node ] + str( self.nodeCount )
+ icon = self.nodeIcon( node, name )
+ item = self.canvas.create_window( x, y, anchor='c', window=icon,
+ tags=node )
+ self.widgetToItem[ icon ] = item
+ self.itemToWidget[ item ] = icon
+ self.selectItem( item )
+ icon.links = {}
+
+ def clickHost( self, event ):
+ "Add a new host to our canvas."
+ self.newNode( 'Host', event )
+
+ def clickSwitch( self, event ):
+ "Add a new switch to our canvas."
+ self.newNode( 'Switch', event )
+
+ def dragLink( self, event ):
+ "Drag a link's endpoint to another node."
+ if self.link is None:
+ return
+ # Since drag starts in widget, we use root coords
+ x = self.canvasx( event.x_root )
+ y = self.canvasy( event.y_root )
+ c = self.canvas
+ c.coords( self.link, self.linkx, self.linky, x, y )
+
+ def releaseLink( self, _event ):
+ "Give up on the current link."
+ if self.link is not None:
+ self.canvas.delete( self.link )
+ self.linkWidget = self.linkItem = self.link = None
+
+ # Generic node handlers
+
+ def createNodeBindings( self ):
+ "Create a set of bindings for nodes."
+ bindings = {
+ '<ButtonPress-1>': self.clickNode,
+ '<B1-Motion>': self.dragNode,
+ '<ButtonRelease-1>': self.releaseNode,
+ '<Enter>': self.enterNode,
+ '<Leave>': self.leaveNode,
+ '<Double-ButtonPress-1>': self.xterm
+ }
+ l = Label() # lightweight-ish owner for bindings
+ for event, binding in bindings.items():
+ l.bind( event, binding )
+ return l
+
+ def selectItem( self, item ):
+ "Select an item and remember old selection."
+ self.lastSelection = self.selection
+ self.selection = item
+
+ def enterNode( self, event ):
+ "Select node on entry."
+ self.selectNode( event )
+
+ def leaveNode( self, _event ):
+ "Restore old selection on exit."
+ self.selectItem( self.lastSelection )
+
+ def clickNode( self, event ):
+ "Node click handler."
+ if self.active is 'Link':
+ self.startLink( event )
+ else:
+ self.selectNode( event )
+ return 'break'
+
+ def dragNode( self, event ):
+ "Node drag handler."
+ if self.active is 'Link':
+ self.dragLink( event )
+ else:
+ self.dragNodeAround( event )
+
+ def releaseNode( self, event ):
+ "Node release handler."
+ if self.active is 'Link':
+ self.finishLink( event )
+
+ # Specific node handlers
+
+ def selectNode( self, event ):
+ "Select the node that was clicked on."
+ item = self.widgetToItem.get( event.widget, None )
+ self.selectItem( item )
+
+ def dragNodeAround( self, event ):
+ "Drag a node around on the canvas."
+ c = self.canvas
+ # Convert global to local coordinates;
+ # Necessary since x, y are widget-relative
+ x = self.canvasx( event.x_root )
+ y = self.canvasy( event.y_root )
+ w = event.widget
+ # Adjust node position
+ item = self.widgetToItem[ w ]
+ c.coords( item, x, y )
+ # Adjust link positions
+ for dest in w.links:
+ link = w.links[ dest ]
+ item = self.widgetToItem[ dest ]
+ x1, y1 = c.coords( item )
+ c.coords( link, x, y, x1, y1 )
+
+ def startLink( self, event ):
+ "Start a new link."
+ if event.widget not in self.widgetToItem:
+ # Didn't click on a node
+ return
+ w = event.widget
+ item = self.widgetToItem[ w ]
+ x, y = self.canvas.coords( item )
+ self.link = self.canvas.create_line( x, y, x, y, width=4,
+ fill='blue', tag='link' )
+ self.linkx, self.linky = x, y
+ self.linkWidget = w
+ self.linkItem = item
+
+ # Link bindings
+ # Selection still needs a bit of work overall
+ # Callbacks ignore event
+
+ def select( _event, link=self.link ):
+ "Select item on mouse entry."
+ self.selectItem( link )
+
+ def highlight( _event, link=self.link ):
+ "Highlight item on mouse entry."
+ # self.selectItem( link )
+ self.canvas.itemconfig( link, fill='green' )
+
+ def unhighlight( _event, link=self.link ):
+ "Unhighlight item on mouse exit."
+ self.canvas.itemconfig( link, fill='blue' )
+ # self.selectItem( None )
+
+ self.canvas.tag_bind( self.link, '<Enter>', highlight )
+ self.canvas.tag_bind( self.link, '<Leave>', unhighlight )
+ self.canvas.tag_bind( self.link, '<ButtonPress-1>', select )
+
+ def finishLink( self, event ):
+ "Finish creating a link"
+ if self.link is None:
+ return
+ source = self.linkWidget
+ c = self.canvas
+ # Since we dragged from the widget, use root coords
+ x, y = self.canvasx( event.x_root ), self.canvasy( event.y_root )
+ target = self.findItem( x, y )
+ dest = self.itemToWidget.get( target, None )
+ if ( source is None or dest is None or source == dest
+ or dest in source.links or source in dest.links ):
+ self.releaseLink( event )
+ return
+ # For now, don't allow hosts to be directly linked
+# stags = self.canvas.gettags( self.widgetToItem[ source ] )
+# dtags = self.canvas.gettags( target )
+# if 'Host' in stags and 'Host' in dtags:
+# self.releaseLink( event )
+# return
+ x, y = c.coords( target )
+ c.coords( self.link, self.linkx, self.linky, x, y )
+ self.addLink( source, dest )
+ # We're done
+ self.link = self.linkWidget = None
+
+ # Menu handlers
+
+ def about( self ):
+ "Display about box."
+ about = self.aboutBox
+ if about is None:
+ bg = 'white'
+ about = Toplevel( bg='white' )
+ about.title( 'About' )
+ info = self.appName + ': a simple network editor for Mini-CCNx - based on Miniedit '
+ warning = 'Development version - not entirely functional!'
+ author = 'Carlos Cabral, Jan 2013'
+ author2 = 'Miniedit by Bob Lantz <rlantz@cs>, April 2010'
+ line1 = Label( about, text=info, font='Helvetica 10 bold', bg=bg )
+ line2 = Label( about, text=warning, font='Helvetica 9', bg=bg )
+ line3 = Label( about, text=author, font='Helvetica 9', bg=bg )
+ line4 = Label( about, text=author2, font='Helvetica 9', bg=bg )
+ line1.pack( padx=20, pady=10 )
+ line2.pack(pady=10 )
+ line3.pack(pady=10 )
+ line4.pack(pady=10 )
+ hide = ( lambda about=about: about.withdraw() )
+ self.aboutBox = about
+ # Hide on close rather than destroying window
+ Wm.wm_protocol( about, name='WM_DELETE_WINDOW', func=hide )
+ # Show (existing) window
+ about.deiconify()
+
+ def createToolImages( self ):
+ "Create toolbar (and icon) images."
+
+ # Model interface
+ #
+ # Ultimately we will either want to use a topo or
+ # mininet object here, probably.
+
+ def addLink( self, source, dest ):
+ "Add link to model."
+ source.links[ dest ] = self.link
+ dest.links[ source ] = self.link
+ self.links[ self.link ] = ( source, dest )
+
+ def deleteLink( self, link ):
+ "Delete link from model."
+ pair = self.links.get( link, None )
+ if pair is not None:
+ source, dest = pair
+ del source.links[ dest ]
+ del dest.links[ source ]
+ if link is not None:
+ del self.links[ link ]
+
+ def deleteNode( self, item ):
+ "Delete node (and its links) from model."
+ widget = self.itemToWidget[ item ]
+ for link in widget.links.values():
+ # Delete from view and model
+ self.deleteItem( link )
+ del self.itemToWidget[ item ]
+ del self.widgetToItem[ widget ]
+
+ def build( self ):
+ "Build network based on our topology."
+
+ net = Mininet( topo=None )
+
+ # Make controller
+ net.addController( 'c0' )
+ # Make nodes
+ for widget in self.widgetToItem:
+ name = widget[ 'text' ]
+ tags = self.canvas.gettags( self.widgetToItem[ widget ] )
+ nodeNum = int( name[ 1: ] )
+ if 'Switch' in tags:
+ net.addSwitch( name )
+ elif 'Host' in tags:
+ net.addHost( name, ip=ipStr( nodeNum ) )
+ else:
+ raise Exception( "Cannot create mystery node: " + name )
+ # Make links
+ for link in self.links.values():
+ ( src, dst ) = link
+ srcName, dstName = src[ 'text' ], dst[ 'text' ]
+ src, dst = net.nameToNode[ srcName ], net.nameToNode[ dstName ]
+ src.linkTo( dst )
+
+ # Build network (we have to do this separately at the moment )
+ net.build()
+
+ return net
+
+ def start( self ):
+ "Start network."
+ if self.net is None:
+ self.net = self.build()
+ self.net.start()
+
+ def stop( self ):
+ "Stop network."
+ if self.net is not None:
+ self.net.stop()
+ cleanUpScreens()
+ self.net = None
+
+ def xterm( self, _ignore=None ):
+ "Make an xterm when a button is pressed."
+ if ( self.selection is None or
+ self.net is None or
+ self.selection not in self.itemToWidget ):
+ return
+ name = self.itemToWidget[ self.selection ][ 'text' ]
+ if name not in self.net.nameToNode:
+ return
+ term = makeTerm( self.net.nameToNode[ name ], 'Host' )
+ self.net.terms.append( term )
+
+
+def miniEditImages():
+ "Create and return images for MiniEdit."
+
+ # Image data. Git will be unhappy. However, the alternative
+ # is to keep track of separate binary files, which is also
+ # unappealing.
+
+ return {
+ 'Select': BitmapImage(
+ file='/usr/include/X11/bitmaps/left_ptr' ),
+
+ 'Switch' : PhotoImage( data=r"""
+ R0lGODlhOgArAMIEAB8aFwB7tQCb343L8P///////////////yH+GlNvZnR3YXJlOiBNaWNyb3NvZnQgT2ZmaWNlACwAAAAAOgArAAAD/ki63P4wykmrvTjr3YYfQigKH7d5Y6qmnjmBayyHg8vAAqDPaUTbowaA13OIahqcyEgEQEbIi7LIGA1FzsaSQK0QfbnH10sMa83VsqX53HLL7sgUTudR5s367F7PEq4CYDJRcngqfgshiAqAMwF3AYdWTCERjSoBjy+ZVItvMg6XIZmaEgOkSmJwlKOkkKSRlaqraaewr7ABhnqBNLmZuL+6vCzCrpvGsB9EH8m5wc7R0sbQ09bT1dOEBLbXwMjeEN7HpuO6Dt3hFObi7Ovj7d7bEOnYD+4V8PfqF/wN/lKsxZPmop6wBwaFzTsRbVvCWzYQmlMW0UKzZCUqatzICLGjx48gKyYAADs=
+"""),
+ 'Host' : PhotoImage( data=r"""
+ R0lGODlhKQAyAMIHAJyeoK+wsrW2uMHCxM7P0Ozt7fn5+f///yH+EUNyZWF0ZWQgd2l0aCBHSU1QACwAAAAAKQAyAAAD63i63P4wykmrvS4cwLv/IEhxRxGeKGBM3pa+X9QeBmxrT3gMNpyLrt6rgcJgisKXgIFMopaLpjMEVUinn2pQ1ImSrN8uGKCVegHn8bl8CqbV7jFbJ47H650592sX4zl6MX9ocIOBLYNvhkxtiYV8eYx0kJSEi2d7WFmSmZqRmIKeHoddoqOcoaZkqIiqq6CtqqQkrq9jnaKzaLW6Wy8DBMHCp7ClPT+ArMY2t1u9Qs3Et6k+W87KtMfW0r6x1d7P2uDYu+LLtt3nQ9ufxeXM7MkOuCnR7UTe6/jyEOqeWj/SYQEowxXBfgYPJAAAOw==
+"""),
+ 'Hosti': PhotoImage( data=r"""
+ R0lGODlhIAAYAPcAMf//////zP//mf//Zv//M///AP/M///MzP/M
+ mf/MZv/MM//MAP+Z//+ZzP+Zmf+ZZv+ZM/+ZAP9m//9mzP9mmf9m
+ Zv9mM/9mAP8z//8zzP8zmf8zZv8zM/8zAP8A//8AzP8Amf8AZv8A
+ M/8AAMz//8z/zMz/mcz/Zsz/M8z/AMzM/8zMzMzMmczMZszMM8zM
+ AMyZ/8yZzMyZmcyZZsyZM8yZAMxm/8xmzMxmmcxmZsxmM8xmAMwz
+ /8wzzMwzmcwzZswzM8wzAMwA/8wAzMwAmcwAZswAM8wAAJn//5n/
+ zJn/mZn/Zpn/M5n/AJnM/5nMzJnMmZnMZpnMM5nMAJmZ/5mZzJmZ
+ mZmZZpmZM5mZAJlm/5lmzJlmmZlmZplmM5lmAJkz/5kzzJkzmZkz
+ ZpkzM5kzAJkA/5kAzJkAmZkAZpkAM5kAAGb//2b/zGb/mWb/Zmb/
+ M2b/AGbM/2bMzGbMmWbMZmbMM2bMAGaZ/2aZzGaZmWaZZmaZM2aZ
+ AGZm/2ZmzGZmmWZmZmZmM2ZmAGYz/2YzzGYzmWYzZmYzM2YzAGYA
+ /2YAzGYAmWYAZmYAM2YAADP//zP/zDP/mTP/ZjP/MzP/ADPM/zPM
+ zDPMmTPMZjPMMzPMADOZ/zOZzDOZmTOZZjOZMzOZADNm/zNmzDNm
+ mTNmZjNmMzNmADMz/zMzzDMzmTMzZjMzMzMzADMA/zMAzDMAmTMA
+ ZjMAMzMAAAD//wD/zAD/mQD/ZgD/MwD/AADM/wDMzADMmQDMZgDM
+ MwDMAACZ/wCZzACZmQCZZgCZMwCZAABm/wBmzABmmQBmZgBmMwBm
+ AAAz/wAzzAAzmQAzZgAzMwAzAAAA/wAAzAAAmQAAZgAAM+4AAN0A
+ ALsAAKoAAIgAAHcAAFUAAEQAACIAABEAAADuAADdAAC7AACqAACI
+ AAB3AABVAABEAAAiAAARAAAA7gAA3QAAuwAAqgAAiAAAdwAAVQAA
+ RAAAIgAAEe7u7t3d3bu7u6qqqoiIiHd3d1VVVURERCIiIhEREQAA
+ ACH5BAEAAAAALAAAAAAgABgAAAiNAAH8G0iwoMGDCAcKTMiw4UBw
+ BPXVm0ixosWLFvVBHFjPoUeC9Tb+6/jRY0iQ/8iVbHiS40CVKxG2
+ HEkQZsyCM0mmvGkw50uePUV2tEnOZkyfQA8iTYpTKNOgKJ+C3AhO
+ p9SWVaVOfWj1KdauTL9q5UgVbFKsEjGqXVtP40NwcBnCjXtw7tx/
+ C8cSBBAQADs=
+ """ ),
+
+ 'Switchi': PhotoImage( data=r"""
+ R0lGODlhIAAYAPcAMf//////zP//mf//Zv//M///AP/M///MzP/M
+ mf/MZv/MM//MAP+Z//+ZzP+Zmf+ZZv+ZM/+ZAP9m//9mzP9mmf9m
+ Zv9mM/9mAP8z//8zzP8zmf8zZv8zM/8zAP8A//8AzP8Amf8AZv8A
+ M/8AAMz//8z/zMz/mcz/Zsz/M8z/AMzM/8zMzMzMmczMZszMM8zM
+ AMyZ/8yZzMyZmcyZZsyZM8yZAMxm/8xmzMxmmcxmZsxmM8xmAMwz
+ /8wzzMwzmcwzZswzM8wzAMwA/8wAzMwAmcwAZswAM8wAAJn//5n/
+ zJn/mZn/Zpn/M5n/AJnM/5nMzJnMmZnMZpnMM5nMAJmZ/5mZzJmZ
+ mZmZZpmZM5mZAJlm/5lmzJlmmZlmZplmM5lmAJkz/5kzzJkzmZkz
+ ZpkzM5kzAJkA/5kAzJkAmZkAZpkAM5kAAGb//2b/zGb/mWb/Zmb/
+ M2b/AGbM/2bMzGbMmWbMZmbMM2bMAGaZ/2aZzGaZmWaZZmaZM2aZ
+ AGZm/2ZmzGZmmWZmZmZmM2ZmAGYz/2YzzGYzmWYzZmYzM2YzAGYA
+ /2YAzGYAmWYAZmYAM2YAADP//zP/zDP/mTP/ZjP/MzP/ADPM/zPM
+ zDPMmTPMZjPMMzPMADOZ/zOZzDOZmTOZZjOZMzOZADNm/zNmzDNm
+ mTNmZjNmMzNmADMz/zMzzDMzmTMzZjMzMzMzADMA/zMAzDMAmTMA
+ ZjMAMzMAAAD//wD/zAD/mQD/ZgD/MwD/AADM/wDMzADMmQDMZgDM
+ MwDMAACZ/wCZzACZmQCZZgCZMwCZAABm/wBmzABmmQBmZgBmMwBm
+ AAAz/wAzzAAzmQAzZgAzMwAzAAAA/wAAzAAAmQAAZgAAM+4AAN0A
+ ALsAAKoAAIgAAHcAAFUAAEQAACIAABEAAADuAADdAAC7AACqAACI
+ AAB3AABVAABEAAAiAAARAAAA7gAA3QAAuwAAqgAAiAAAdwAAVQAA
+ RAAAIgAAEe7u7t3d3bu7u6qqqoiIiHd3d1VVVURERCIiIhEREQAA
+ ACH5BAEAAAAALAAAAAAgABgAAAhwAAEIHEiwoMGDCBMqXMiwocOH
+ ECNKnEixosWB3zJq3Mixo0eNAL7xG0mypMmTKPl9Cznyn8uWL/m5
+ /AeTpsyYI1eKlBnO5r+eLYHy9Ck0J8ubPmPOrMmUpM6UUKMa/Ui1
+ 6saLWLNq3cq1q9evYB0GBAA7
+ """ ),
+
+ 'Link': PhotoImage( data=r"""
+ R0lGODlhFgAWAPcAMf//////zP//mf//Zv//M///AP/M///MzP/M
+ mf/MZv/MM//MAP+Z//+ZzP+Zmf+ZZv+ZM/+ZAP9m//9mzP9mmf9m
+ Zv9mM/9mAP8z//8zzP8zmf8zZv8zM/8zAP8A//8AzP8Amf8AZv8A
+ M/8AAMz//8z/zMz/mcz/Zsz/M8z/AMzM/8zMzMzMmczMZszMM8zM
+ AMyZ/8yZzMyZmcyZZsyZM8yZAMxm/8xmzMxmmcxmZsxmM8xmAMwz
+ /8wzzMwzmcwzZswzM8wzAMwA/8wAzMwAmcwAZswAM8wAAJn//5n/
+ zJn/mZn/Zpn/M5n/AJnM/5nMzJnMmZnMZpnMM5nMAJmZ/5mZzJmZ
+ mZmZZpmZM5mZAJlm/5lmzJlmmZlmZplmM5lmAJkz/5kzzJkzmZkz
+ ZpkzM5kzAJkA/5kAzJkAmZkAZpkAM5kAAGb//2b/zGb/mWb/Zmb/
+ M2b/AGbM/2bMzGbMmWbMZmbMM2bMAGaZ/2aZzGaZmWaZZmaZM2aZ
+ AGZm/2ZmzGZmmWZmZmZmM2ZmAGYz/2YzzGYzmWYzZmYzM2YzAGYA
+ /2YAzGYAmWYAZmYAM2YAADP//zP/zDP/mTP/ZjP/MzP/ADPM/zPM
+ zDPMmTPMZjPMMzPMADOZ/zOZzDOZmTOZZjOZMzOZADNm/zNmzDNm
+ mTNmZjNmMzNmADMz/zMzzDMzmTMzZjMzMzMzADMA/zMAzDMAmTMA
+ ZjMAMzMAAAD//wD/zAD/mQD/ZgD/MwD/AADM/wDMzADMmQDMZgDM
+ MwDMAACZ/wCZzACZmQCZZgCZMwCZAABm/wBmzABmmQBmZgBmMwBm
+ AAAz/wAzzAAzmQAzZgAzMwAzAAAA/wAAzAAAmQAAZgAAM+4AAN0A
+ ALsAAKoAAIgAAHcAAFUAAEQAACIAABEAAADuAADdAAC7AACqAACI
+ AAB3AABVAABEAAAiAAARAAAA7gAA3QAAuwAAqgAAiAAAdwAAVQAA
+ RAAAIgAAEe7u7t3d3bu7u6qqqoiIiHd3d1VVVURERCIiIhEREQAA
+ ACH5BAEAAAAALAAAAAAWABYAAAhIAAEIHEiwoEGBrhIeXEgwoUKG
+ Cx0+hGhQoiuKBy1irChxY0GNHgeCDAlgZEiTHlFuVImRJUWXEGEy
+ lBmxI8mSNknm1Dnx5sCAADs=
+ """ )
+ }
+
+if __name__ == '__main__':
+ setLogLevel( 'info' )
+ temp_file = parse_args()[0]
+ app = MiniEdit(template_file=temp_file)
+ app.mainloop()
diff --git a/examples/multiping.py b/examples/multiping.py
new file mode 100644
index 0000000..3bd231c
--- /dev/null
+++ b/examples/multiping.py
@@ -0,0 +1,86 @@
+#!/usr/bin/python
+
+"""
+multiping.py: monitor multiple sets of hosts using ping
+
+This demonstrates how one may send a simple shell script to
+multiple hosts and monitor their output interactively for a period=
+of time.
+"""
+
+from mininet.net import Mininet
+from mininet.node import Node
+from mininet.topo import SingleSwitchTopo
+from mininet.log import setLogLevel
+
+from select import poll, POLLIN
+from time import time
+
+def chunks( l, n ):
+ "Divide list l into chunks of size n - thanks Stackoverflow"
+ return [ l[ i: i + n ] for i in range( 0, len( l ), n ) ]
+
+def startpings( host, targetips ):
+ "Tell host to repeatedly ping targets"
+
+ targetips.append( '10.0.0.200' )
+
+ targetips = ' '.join( targetips )
+
+ # BL: Not sure why loopback intf isn't up!
+ host.cmd( 'ifconfig lo up' )
+
+ # Simple ping loop
+ cmd = ( 'while true; do '
+ ' for ip in %s; do ' % targetips +
+ ' echo -n %s "->" $ip ' % host.IP() +
+ ' `ping -c1 -w 1 $ip | grep packets` ;'
+ ' sleep 1;'
+ ' done; '
+ 'done &' )
+
+ print ( '*** Host %s (%s) will be pinging ips: %s' %
+ ( host.name, host.IP(), targetips ) )
+
+ host.cmd( cmd )
+
+def multiping( netsize, chunksize, seconds):
+ "Ping subsets of size chunksize in net of size netsize"
+
+ # Create network and identify subnets
+ topo = SingleSwitchTopo( netsize )
+ net = Mininet( topo=topo )
+ net.start()
+ hosts = net.hosts
+ subnets = chunks( hosts, chunksize )
+
+ # Create polling object
+ fds = [ host.stdout.fileno() for host in hosts ]
+ poller = poll()
+ for fd in fds:
+ poller.register( fd, POLLIN )
+
+ # Start pings
+ for subnet in subnets:
+ ips = [ host.IP() for host in subnet ]
+ for host in subnet:
+ startpings( host, ips )
+
+ # Monitor output
+ endTime = time() + seconds
+ while time() < endTime:
+ readable = poller.poll(1000)
+ for fd, _mask in readable:
+ node = Node.outToNode[ fd ]
+ print '%s:' % node.name, node.monitor().strip()
+
+ # Stop pings
+ for host in hosts:
+ host.cmd( 'kill %while' )
+
+ net.stop()
+
+
+if __name__ == '__main__':
+ setLogLevel( 'info' )
+ multiping( netsize=20, chunksize=4, seconds=10 )
diff --git a/examples/multipoll.py b/examples/multipoll.py
new file mode 100644
index 0000000..aef1b10
--- /dev/null
+++ b/examples/multipoll.py
@@ -0,0 +1,81 @@
+#!/usr/bin/python
+
+"""
+Simple example of sending output to multiple files and
+monitoring them
+"""
+
+from mininet.topo import SingleSwitchTopo
+from mininet.net import Mininet
+from mininet.log import setLogLevel
+
+from time import time
+from select import poll, POLLIN
+from subprocess import Popen, PIPE
+
+def monitorFiles( outfiles, seconds, timeoutms ):
+ "Monitor set of files and return [(host, line)...]"
+ devnull = open( '/dev/null', 'w' )
+ tails, fdToFile, fdToHost = {}, {}, {}
+ for h, outfile in outfiles.iteritems():
+ tail = Popen( [ 'tail', '-f', outfile ],
+ stdout=PIPE, stderr=devnull )
+ fd = tail.stdout.fileno()
+ tails[ h ] = tail
+ fdToFile[ fd ] = tail.stdout
+ fdToHost[ fd ] = h
+ # Prepare to poll output files
+ readable = poll()
+ for t in tails.values():
+ readable.register( t.stdout.fileno(), POLLIN )
+ # Run until a set number of seconds have elapsed
+ endTime = time() + seconds
+ while time() < endTime:
+ fdlist = readable.poll(timeoutms)
+ if fdlist:
+ for fd, _flags in fdlist:
+ f = fdToFile[ fd ]
+ host = fdToHost[ fd ]
+ # Wait for a line of output
+ line = f.readline().strip()
+ yield host, line
+ else:
+ # If we timed out, return nothing
+ yield None, ''
+ for t in tails.values():
+ t.terminate()
+ devnull.close() # Not really necessary
+
+
+def monitorTest( N=3, seconds=3 ):
+ "Run pings and monitor multiple hosts"
+ topo = SingleSwitchTopo( N )
+ net = Mininet( topo )
+ net.start()
+ hosts = net.hosts
+ print "Starting test..."
+ server = hosts[ 0 ]
+ outfiles, errfiles = {}, {}
+ for h in hosts:
+ # Create and/or erase output files
+ outfiles[ h ] = '/tmp/%s.out' % h.name
+ errfiles[ h ] = '/tmp/%s.err' % h.name
+ h.cmd( 'echo >', outfiles[ h ] )
+ h.cmd( 'echo >', errfiles[ h ] )
+ # Start pings
+ h.cmdPrint('ping', server.IP(),
+ '>', outfiles[ h ],
+ '2>', errfiles[ h ],
+ '&' )
+ print "Monitoring output for", seconds, "seconds"
+ for h, line in monitorFiles( outfiles, seconds, timeoutms=500 ):
+ if h:
+ print '%s: %s' % ( h.name, line )
+ for h in hosts:
+ h.cmd('kill %ping')
+ net.stop()
+
+
+if __name__ == '__main__':
+ setLogLevel('info')
+ monitorTest()
diff --git a/examples/multitest.py b/examples/multitest.py
new file mode 100644
index 0000000..bcb40f7
--- /dev/null
+++ b/examples/multitest.py
@@ -0,0 +1,35 @@
+#!/usr/bin/python
+
+"""
+This example shows how to create a network and run multiple tests.
+For a more complicated test example, see udpbwtest.py.
+"""
+
+from mininet.cli import CLI
+from mininet.log import lg, info
+from mininet.net import Mininet
+from mininet.node import OVSKernelSwitch
+from mininet.topolib import TreeTopo
+
+def ifconfigTest( net ):
+ "Run ifconfig on all hosts in net."
+ hosts = net.hosts
+ for host in hosts:
+ info( host.cmd( 'ifconfig' ) )
+
+if __name__ == '__main__':
+ lg.setLogLevel( 'info' )
+ info( "*** Initializing Mininet and kernel modules\n" )
+ OVSKernelSwitch.setup()
+ info( "*** Creating network\n" )
+ network = Mininet( TreeTopo( depth=2, fanout=2 ), switch=OVSKernelSwitch)
+ info( "*** Starting network\n" )
+ network.start()
+ info( "*** Running ping test\n" )
+ network.pingAll()
+ info( "*** Running ifconfig test\n" )
+ ifconfigTest( network )
+ info( "*** Starting CLI (type 'exit' to exit)\n" )
+ CLI( network )
+ info( "*** Stopping network\n" )
+ network.stop()
diff --git a/examples/popen.py b/examples/popen.py
new file mode 100644
index 0000000..332822f
--- /dev/null
+++ b/examples/popen.py
@@ -0,0 +1,36 @@
+#!/usr/bin/python
+
+"""
+This example monitors a number of hosts using host.popen() and
+pmonitor()
+"""
+
+from mininet.net import Mininet
+from mininet.node import CPULimitedHost
+from mininet.topo import SingleSwitchTopo
+from mininet.log import setLogLevel
+from mininet.util import custom, pmonitor
+
+def monitorhosts( hosts=5, sched='cfs' ):
+ "Start a bunch of pings and monitor them using popen"
+ mytopo = SingleSwitchTopo( hosts )
+ cpu = .5 / hosts
+ myhost = custom( CPULimitedHost, cpu=cpu, sched=sched )
+ net = Mininet( topo=mytopo, host=myhost )
+ net.start()
+ # Start a bunch of pings
+ popens = {}
+ last = net.hosts[ -1 ]
+ for host in net.hosts:
+ popens[ host ] = host.popen( "ping -c5 %s" % last.IP() )
+ last = host
+ # Monitor them and print output
+ for host, line in pmonitor( popens ):
+ if host:
+ print "<%s>: %s" % ( host.name, line.strip() )
+ # Done
+ net.stop()
+
+if __name__ == '__main__':
+ setLogLevel( 'info' )
+ monitorhosts( hosts=5 )
diff --git a/examples/popenpoll.py b/examples/popenpoll.py
new file mode 100644
index 0000000..c581c27
--- /dev/null
+++ b/examples/popenpoll.py
@@ -0,0 +1,33 @@
+#!/usr/bin/python
+
+"Monitor multiple hosts using popen()/pmonitor()"
+
+from mininet.net import Mininet
+from mininet.topo import SingleSwitchTopo
+from mininet.util import pmonitor
+from time import time
+from signal import SIGINT
+
+def pmonitorTest( N=3, seconds=10 ):
+ "Run pings and monitor multiple hosts using pmonitor"
+ topo = SingleSwitchTopo( N )
+ net = Mininet( topo )
+ net.start()
+ hosts = net.hosts
+ print "Starting test..."
+ server = hosts[ 0 ]
+ popens = {}
+ for h in hosts:
+ popens[ h ] = h.popen('ping', server.IP() )
+ print "Monitoring output for", seconds, "seconds"
+ endTime = time() + seconds
+ for h, line in pmonitor( popens, timeoutms=500 ):
+ if h:
+ print '%s: %s' % ( h.name, line ),
+ if time() >= endTime:
+ for p in popens.values():
+ p.send_signal( SIGINT )
+ net.stop()
+
+if __name__ == '__main__':
+ pmonitorTest()
diff --git a/examples/router.gif b/examples/router.gif
new file mode 100644
index 0000000..a670ac7
--- /dev/null
+++ b/examples/router.gif
Binary files differ
diff --git a/examples/scratchnet.py b/examples/scratchnet.py
new file mode 100644
index 0000000..966a183
--- /dev/null
+++ b/examples/scratchnet.py
@@ -0,0 +1,68 @@
+#!/usr/bin/python
+
+"""
+Build a simple network from scratch, using mininet primitives.
+This is more complicated than using the higher-level classes,
+but it exposes the configuration details and allows customization.
+
+For most tasks, the higher-level API will be preferable.
+"""
+
+from mininet.net import Mininet
+from mininet.node import Node
+from mininet.link import Link
+from mininet.log import setLogLevel, info
+from mininet.util import quietRun
+
+from time import sleep
+
+def scratchNet( cname='controller', cargs='-v ptcp:' ):
+ "Create network from scratch using Open vSwitch."
+
+ info( "*** Creating nodes\n" )
+ controller = Node( 'c0', inNamespace=False )
+ switch = Node( 's0', inNamespace=False )
+ h0 = Node( 'h0' )
+ h1 = Node( 'h1' )
+
+ info( "*** Creating links\n" )
+ Link( h0, switch )
+ Link( h1, switch )
+
+ info( "*** Configuring hosts\n" )
+ h0.setIP( '192.168.123.1/24' )
+ h1.setIP( '192.168.123.2/24' )
+ info( str( h0 ) + '\n' )
+ info( str( h1 ) + '\n' )
+
+ info( "*** Starting network using Open vSwitch\n" )
+ controller.cmd( cname + ' ' + cargs + '&' )
+ switch.cmd( 'ovs-vsctl del-br dp0' )
+ switch.cmd( 'ovs-vsctl add-br dp0' )
+ for intf in switch.intfs.values():
+ print switch.cmd( 'ovs-vsctl add-port dp0 %s' % intf )
+
+ # Note: controller and switch are in root namespace, and we
+ # can connect via loopback interface
+ switch.cmd( 'ovs-vsctl set-controller dp0 tcp:127.0.0.1:6633' )
+
+ info( '*** Waiting for switch to connect to controller' )
+ while 'is_connected' not in quietRun( 'ovs-vsctl show' ):
+ sleep( 1 )
+ info( '.' )
+ info( '\n' )
+
+ info( "*** Running test\n" )
+ h0.cmdPrint( 'ping -c1 ' + h1.IP() )
+
+ info( "*** Stopping network\n" )
+ controller.cmd( 'kill %' + cname )
+ switch.cmd( 'ovs-vsctl del-br dp0' )
+ switch.deleteIntfs()
+ info( '\n' )
+
+if __name__ == '__main__':
+ setLogLevel( 'info' )
+ info( '*** Scratch network demo (kernel datapath)\n' )
+ Mininet.init()
+ scratchNet()
diff --git a/examples/scratchnetuser.py b/examples/scratchnetuser.py
new file mode 100644
index 0000000..ccd20e9
--- /dev/null
+++ b/examples/scratchnetuser.py
@@ -0,0 +1,73 @@
+#!/usr/bin/python
+
+"""
+Build a simple network from scratch, using mininet primitives.
+This is more complicated than using the higher-level classes,
+but it exposes the configuration details and allows customization.
+
+For most tasks, the higher-level API will be preferable.
+
+This version uses the user datapath and an explicit control network.
+"""
+
+from mininet.net import Mininet
+from mininet.node import Node
+from mininet.link import Link
+from mininet.log import setLogLevel, info
+
+def linkIntfs( node1, node2 ):
+ "Create link from node1 to node2 and return intfs"
+ link = Link( node1, node2 )
+ return link.intf1, link.intf2
+
+def scratchNetUser( cname='controller', cargs='ptcp:' ):
+ "Create network from scratch using user switch."
+
+ # It's not strictly necessary for the controller and switches
+ # to be in separate namespaces. For performance, they probably
+ # should be in the root namespace. However, it's interesting to
+ # see how they could work even if they are in separate namespaces.
+
+ info( '*** Creating Network\n' )
+ controller = Node( 'c0' )
+ switch = Node( 's0')
+ h0 = Node( 'h0' )
+ h1 = Node( 'h1' )
+ cintf, sintf = linkIntfs( controller, switch )
+ h0intf, sintf1 = linkIntfs( h0, switch )
+ h1intf, sintf2 = linkIntfs( h1, switch )
+
+ info( '*** Configuring control network\n' )
+ controller.setIP( '10.0.123.1/24', intf=cintf )
+ switch.setIP( '10.0.123.2/24', intf=sintf)
+
+ info( '*** Configuring hosts\n' )
+ h0.setIP( '192.168.123.1/24', intf=h0intf )
+ h1.setIP( '192.168.123.2/24', intf=h1intf )
+
+ info( '*** Network state:\n' )
+ for node in controller, switch, h0, h1:
+ info( str( node ) + '\n' )
+
+ info( '*** Starting controller and user datapath\n' )
+ controller.cmd( cname + ' ' + cargs + '&' )
+ switch.cmd( 'ifconfig lo 127.0.0.1' )
+ intfs = [ str( i ) for i in sintf1, sintf2 ]
+ switch.cmd( 'ofdatapath -i ' + ','.join( intfs ) + ' ptcp: &' )
+ switch.cmd( 'ofprotocol tcp:' + controller.IP() + ' tcp:localhost &' )
+
+ info( '*** Running test\n' )
+ h0.cmdPrint( 'ping -c1 ' + h1.IP() )
+
+ info( '*** Stopping network\n' )
+ controller.cmd( 'kill %' + cname )
+ switch.cmd( 'kill %ofdatapath' )
+ switch.cmd( 'kill %ofprotocol' )
+ switch.deleteIntfs()
+ info( '\n' )
+
+if __name__ == '__main__':
+ setLogLevel( 'info' )
+ info( '*** Scratch network demo (user datapath)\n' )
+ Mininet.init()
+ scratchNetUser()
diff --git a/examples/server.gif b/examples/server.gif
new file mode 100644
index 0000000..b16b0da
--- /dev/null
+++ b/examples/server.gif
Binary files differ
diff --git a/examples/simpleperf.py b/examples/simpleperf.py
new file mode 100644
index 0000000..1da4b66
--- /dev/null
+++ b/examples/simpleperf.py
@@ -0,0 +1,49 @@
+#!/usr/bin/python
+
+"""
+Simple example of setting network and CPU parameters
+
+NOTE: link params limit BW, add latency, and loss.
+There is a high chance that pings WILL fail and that
+iperf will hang indefinitely if the TCP handshake fails
+to complete.
+"""
+
+from mininet.topo import Topo
+from mininet.net import Mininet
+from mininet.node import CPULimitedHost
+from mininet.link import TCLink
+from mininet.util import dumpNodeConnections
+from mininet.log import setLogLevel
+
+class SingleSwitchTopo(Topo):
+ "Single switch connected to n hosts."
+ def __init__(self, n=2, **opts):
+ Topo.__init__(self, **opts)
+ switch = self.addSwitch('s1')
+ for h in range(n):
+ # Each host gets 50%/n of system CPU
+ host = self.addHost('h%s' % (h + 1),
+ cpu=.5 / n)
+ # 10 Mbps, 5ms delay, 10% loss
+ self.addLink(host, switch,
+ bw=10, delay='5ms', loss=10, use_htb=True)
+
+def perfTest():
+ "Create network and run simple performance test"
+ topo = SingleSwitchTopo(n=4)
+ net = Mininet(topo=topo,
+ host=CPULimitedHost, link=TCLink)
+ net.start()
+ print "Dumping host connections"
+ dumpNodeConnections(net.hosts)
+ print "Testing network connectivity"
+ net.pingAll()
+ print "Testing bandwidth between h1 and h4"
+ h1, h4 = net.getNodeByName('h1', 'h4')
+ net.iperf((h1, h4))
+ net.stop()
+
+if __name__ == '__main__':
+ setLogLevel('info')
+ perfTest()
diff --git a/examples/sshd.py b/examples/sshd.py
new file mode 100644
index 0000000..2bedb9c
--- /dev/null
+++ b/examples/sshd.py
@@ -0,0 +1,71 @@
+#!/usr/bin/python
+
+"""
+Create a network and start sshd(8) on each host.
+
+While something like rshd(8) would be lighter and faster,
+(and perfectly adequate on an in-machine network)
+the advantage of running sshd is that scripts can work
+unchanged on mininet and hardware.
+
+In addition to providing ssh access to hosts, this example
+demonstrates:
+
+- creating a convenience function to construct networks
+- connecting the host network to the root namespace
+- running server processes (sshd in this case) on hosts
+"""
+
+from mininet.net import Mininet
+from mininet.cli import CLI
+from mininet.log import lg
+from mininet.node import Node, OVSKernelSwitch
+from mininet.topolib import TreeTopo
+from mininet.link import Link
+
+def TreeNet( depth=1, fanout=2, **kwargs ):
+ "Convenience function for creating tree networks."
+ topo = TreeTopo( depth, fanout )
+ return Mininet( topo, **kwargs )
+
+def connectToRootNS( network, switch, ip, prefixLen, routes ):
+ """Connect hosts to root namespace via switch. Starts network.
+ network: Mininet() network object
+ switch: switch to connect to root namespace
+ ip: IP address for root namespace node
+ prefixLen: IP address prefix length (e.g. 8, 16, 24)
+ routes: host networks to route to"""
+ # Create a node in root namespace and link to switch 0
+ root = Node( 'root', inNamespace=False )
+ intf = Link( root, switch ).intf1
+ root.setIP( ip, prefixLen, intf )
+ # Start network that now includes link to root namespace
+ network.start()
+ # Add routes from root ns to hosts
+ for route in routes:
+ root.cmd( 'route add -net ' + route + ' dev ' + str( intf ) )
+
+def sshd( network, cmd='/usr/sbin/sshd', opts='-D' ):
+ "Start a network, connect it to root ns, and run sshd on all hosts."
+ switch = network.switches[ 0 ] # switch to use
+ ip = '10.123.123.1' # our IP address on host network
+ routes = [ '10.0.0.0/8' ] # host networks to route to
+ connectToRootNS( network, switch, ip, 8, routes )
+ for host in network.hosts:
+ host.cmd( cmd + ' ' + opts + '&' )
+ print
+ print "*** Hosts are running sshd at the following addresses:"
+ print
+ for host in network.hosts:
+ print host.name, host.IP()
+ print
+ print "*** Type 'exit' or control-D to shut down network"
+ CLI( network )
+ for host in network.hosts:
+ host.cmd( 'kill %' + cmd )
+ network.stop()
+
+if __name__ == '__main__':
+ lg.setLogLevel( 'info')
+ net = TreeNet( depth=1, fanout=4, switch=OVSKernelSwitch )
+ sshd( net )
diff --git a/examples/tree1024.py b/examples/tree1024.py
new file mode 100644
index 0000000..9397131
--- /dev/null
+++ b/examples/tree1024.py
@@ -0,0 +1,18 @@
+#!/usr/bin/python
+
+"""
+Create a 1024-host network, and run the CLI on it.
+If this fails because of kernel limits, you may have
+to adjust them, e.g. by adding entries to /etc/sysctl.conf
+and running sysctl -p. Check util/sysctl_addon.
+"""
+
+from mininet.cli import CLI
+from mininet.log import setLogLevel
+from mininet.node import OVSKernelSwitch
+from mininet.topolib import TreeNet
+
+if __name__ == '__main__':
+ setLogLevel( 'info' )
+ network = TreeNet( depth=2, fanout=32, switch=OVSKernelSwitch )
+ network.run( CLI, network )
diff --git a/examples/treeping64.py b/examples/treeping64.py
new file mode 100644
index 0000000..ba60f1b
--- /dev/null
+++ b/examples/treeping64.py
@@ -0,0 +1,32 @@
+#!/usr/bin/python
+
+"Create a 64-node tree network, and test connectivity using ping."
+
+from mininet.log import setLogLevel
+from mininet.node import UserSwitch, OVSKernelSwitch # , KernelSwitch
+from mininet.topolib import TreeNet
+
+def treePing64():
+ "Run ping test on 64-node tree networks."
+
+ results = {}
+ switches = { # 'reference kernel': KernelSwitch,
+ 'reference user': UserSwitch,
+ 'Open vSwitch kernel': OVSKernelSwitch }
+
+ for name in switches:
+ print "*** Testing", name, "datapath"
+ switch = switches[ name ]
+ network = TreeNet( depth=2, fanout=8, switch=switch )
+ result = network.run( network.pingAll )
+ results[ name ] = result
+
+ print
+ print "*** Tree network ping results:"
+ for name in switches:
+ print "%s: %d%% packet loss" % ( name, results[ name ] )
+ print
+
+if __name__ == '__main__':
+ setLogLevel( 'info' )
+ treePing64()
