Brandon Heller
1f1d590c7a
Also a more complete ping test that parses all output to the CLI. These tests expand the hifi-specific ones to not just cover whether a topology can be created with options, but whether those options are properly implemented within some tolerance, like CPU limits, link bandwidth, delays, and even drops.
367 lines
12 KiB
Python
367 lines
12 KiB
Python
"""
|
|
A simple command-line interface for Mininet.
|
|
|
|
The Mininet CLI provides a simple control console which
|
|
makes it easy to talk to nodes. For example, the command
|
|
|
|
mininet> h27 ifconfig
|
|
|
|
runs 'ifconfig' on host h27.
|
|
|
|
Having a single console rather than, for example, an xterm for each
|
|
node is particularly convenient for networks of any reasonable
|
|
size.
|
|
|
|
The CLI automatically substitutes IP addresses for node names,
|
|
so commands like
|
|
|
|
mininet> h2 ping h3
|
|
|
|
should work correctly and allow host h2 to ping host h3
|
|
|
|
Several useful commands are provided, including the ability to
|
|
list all nodes ('nodes'), to print out the network topology
|
|
('net') and to check connectivity ('pingall', 'pingpair')
|
|
and bandwidth ('iperf'.)
|
|
"""
|
|
|
|
from subprocess import call
|
|
from cmd import Cmd
|
|
from os import isatty
|
|
from select import poll, POLLIN
|
|
import sys
|
|
import time
|
|
|
|
from mininet.log import info, output, error
|
|
from mininet.term import makeTerms
|
|
from mininet.util import quietRun, isShellBuiltin, dumpNodeConnections
|
|
|
|
class CLI( Cmd ):
|
|
"Simple command-line interface to talk to nodes."
|
|
|
|
prompt = 'mininet> '
|
|
|
|
def __init__( self, mininet, stdin=sys.stdin, script=None ):
|
|
self.mn = mininet
|
|
self.nodelist = self.mn.controllers + self.mn.switches + self.mn.hosts
|
|
self.nodemap = {} # map names to Node objects
|
|
for node in self.nodelist:
|
|
self.nodemap[ node.name ] = node
|
|
# Local variable bindings for py command
|
|
self.locals = { 'net': mininet }
|
|
self.locals.update( self.nodemap )
|
|
# Attempt to handle input
|
|
self.stdin = stdin
|
|
self.inPoller = poll()
|
|
self.inPoller.register( stdin )
|
|
self.inputFile = script
|
|
Cmd.__init__( self )
|
|
info( '*** Starting CLI:\n' )
|
|
if self.inputFile:
|
|
self.do_source( self.inputFile )
|
|
return
|
|
while True:
|
|
try:
|
|
# Make sure no nodes are still waiting
|
|
for node in self.nodelist:
|
|
while node.waiting:
|
|
node.sendInt()
|
|
node.monitor()
|
|
if self.isatty():
|
|
quietRun( 'stty sane' )
|
|
self.cmdloop()
|
|
break
|
|
except KeyboardInterrupt:
|
|
output( '\nInterrupt\n' )
|
|
|
|
def emptyline( self ):
|
|
"Don't repeat last command when you hit return."
|
|
pass
|
|
|
|
# Disable pylint "Unused argument: 'arg's'" messages, as well as
|
|
# "method could be a function" warning, since each CLI function
|
|
# must have the same interface
|
|
# pylint: disable-msg=R0201
|
|
|
|
helpStr = (
|
|
'You may also send a command to a node using:\n'
|
|
' <node> command {args}\n'
|
|
'For example:\n'
|
|
' mininet> h1 ifconfig\n'
|
|
'\n'
|
|
'The interpreter automatically substitutes IP addresses\n'
|
|
'for node names when a node is the first arg, so commands\n'
|
|
'like\n'
|
|
' mininet> h2 ping h3\n'
|
|
'should work.\n'
|
|
'\n'
|
|
'Some character-oriented interactive commands require\n'
|
|
'noecho:\n'
|
|
' mininet> noecho h2 vi foo.py\n'
|
|
'However, starting up an xterm/gterm is generally better:\n'
|
|
' mininet> xterm h2\n\n'
|
|
)
|
|
|
|
def do_help( self, line ):
|
|
"Describe available CLI commands."
|
|
Cmd.do_help( self, line )
|
|
if line is '':
|
|
output( self.helpStr )
|
|
|
|
def do_nodes( self, _line ):
|
|
"List all nodes."
|
|
nodes = ' '.join( [ node.name for node in sorted( self.nodelist ) ] )
|
|
output( 'available nodes are: \n%s\n' % nodes )
|
|
|
|
def do_net( self, _line ):
|
|
"List network connections."
|
|
dumpNodeConnections( self.nodelist )
|
|
|
|
def do_sh( self, line ):
|
|
"Run an external shell command"
|
|
call( line, shell=True )
|
|
|
|
# do_py() needs to catch any exception during eval()
|
|
# pylint: disable-msg=W0703
|
|
|
|
def do_py( self, line ):
|
|
"""Evaluate a Python expression.
|
|
Node names may be used, e.g.: h1.cmd('ls')"""
|
|
try:
|
|
result = eval( line, globals(), self.locals )
|
|
if not result:
|
|
return
|
|
elif isinstance( result, str ):
|
|
output( result + '\n' )
|
|
else:
|
|
output( repr( result ) + '\n' )
|
|
except Exception, e:
|
|
output( str( e ) + '\n' )
|
|
|
|
# pylint: enable-msg=W0703
|
|
|
|
def do_pingall( self, _line ):
|
|
"Ping between all hosts."
|
|
self.mn.pingAll()
|
|
|
|
def do_pingpair( self, _line ):
|
|
"Ping between first two hosts, useful for testing."
|
|
self.mn.pingPair()
|
|
|
|
def do_pingallfull( self, _line ):
|
|
"Ping between first two hosts, returns all ping results."
|
|
self.mn.pingAllFull()
|
|
|
|
def do_pingpairfull( self, _line ):
|
|
"Ping between first two hosts, returns all ping results."
|
|
self.mn.pingPairFull()
|
|
|
|
def do_iperf( self, line ):
|
|
"Simple iperf TCP test between two (optionally specified) hosts."
|
|
args = line.split()
|
|
if not args:
|
|
self.mn.iperf()
|
|
elif len(args) == 2:
|
|
hosts = []
|
|
err = False
|
|
for arg in args:
|
|
if arg not in self.nodemap:
|
|
err = True
|
|
error( "node '%s' not in network\n" % arg )
|
|
else:
|
|
hosts.append( self.nodemap[ arg ] )
|
|
if not err:
|
|
self.mn.iperf( hosts )
|
|
else:
|
|
error( 'invalid number of args: iperf src dst\n' )
|
|
|
|
def do_iperfudp( self, line ):
|
|
"Simple iperf TCP test between two (optionally specified) hosts."
|
|
args = line.split()
|
|
if not args:
|
|
self.mn.iperf( l4Type='UDP' )
|
|
elif len(args) == 3:
|
|
udpBw = args[ 0 ]
|
|
hosts = []
|
|
err = False
|
|
for arg in args[ 1:3 ]:
|
|
if arg not in self.nodemap:
|
|
err = True
|
|
error( "node '%s' not in network\n" % arg )
|
|
else:
|
|
hosts.append( self.nodemap[ arg ] )
|
|
if not err:
|
|
self.mn.iperf( hosts, l4Type='UDP', udpBw=udpBw )
|
|
else:
|
|
error( 'invalid number of args: iperfudp bw src dst\n' +
|
|
'bw examples: 10M\n' )
|
|
|
|
def do_intfs( self, _line ):
|
|
"List interfaces."
|
|
for node in self.nodelist:
|
|
output( '%s: %s\n' %
|
|
( node.name, ','.join( node.intfNames() ) ) )
|
|
|
|
def do_dump( self, _line ):
|
|
"Dump node info."
|
|
for node in self.nodelist:
|
|
output( '%s\n' % repr( node ) )
|
|
|
|
def do_link( self, line ):
|
|
"Bring link(s) between two nodes up or down."
|
|
args = line.split()
|
|
if len(args) != 3:
|
|
error( 'invalid number of args: link end1 end2 [up down]\n' )
|
|
elif args[ 2 ] not in [ 'up', 'down' ]:
|
|
error( 'invalid type: link end1 end2 [up down]\n' )
|
|
else:
|
|
self.mn.configLinkStatus( *args )
|
|
|
|
def do_xterm( self, line, term='xterm' ):
|
|
"Spawn xterm(s) for the given node(s)."
|
|
args = line.split()
|
|
if not args:
|
|
error( 'usage: %s node1 node2 ...\n' % term )
|
|
else:
|
|
for arg in args:
|
|
if arg not in self.nodemap:
|
|
error( "node '%s' not in network\n" % arg )
|
|
else:
|
|
node = self.nodemap[ arg ]
|
|
self.mn.terms += makeTerms( [ node ], term = term )
|
|
|
|
def do_gterm( self, line ):
|
|
"Spawn gnome-terminal(s) for the given node(s)."
|
|
self.do_xterm( line, term='gterm' )
|
|
|
|
def do_exit( self, _line ):
|
|
"Exit"
|
|
return 'exited by user command'
|
|
|
|
def do_quit( self, line ):
|
|
"Exit"
|
|
return self.do_exit( line )
|
|
|
|
def do_EOF( self, line ):
|
|
"Exit"
|
|
output( '\n' )
|
|
return self.do_exit( line )
|
|
|
|
def isatty( self ):
|
|
"Is our standard input a tty?"
|
|
return isatty( self.stdin.fileno() )
|
|
|
|
def do_noecho( self, line ):
|
|
"Run an interactive command with echoing turned off."
|
|
if self.isatty():
|
|
quietRun( 'stty -echo' )
|
|
self.default( line )
|
|
if self.isatty():
|
|
quietRun( 'stty echo' )
|
|
|
|
def do_source( self, line ):
|
|
"Read commands from an input file."
|
|
args = line.split()
|
|
if len(args) != 1:
|
|
error( 'usage: source <file>\n' )
|
|
return
|
|
try:
|
|
self.inputFile = open( args[ 0 ] )
|
|
while True:
|
|
line = self.inputFile.readline()
|
|
if len( line ) > 0:
|
|
self.onecmd( line )
|
|
else:
|
|
break
|
|
except IOError:
|
|
error( 'error reading file %s\n' % args[ 0 ] )
|
|
self.inputFile = None
|
|
|
|
def do_dpctl( self, line ):
|
|
"Run dpctl command on all switches."
|
|
args = line.split()
|
|
if len(args) < 1:
|
|
error( 'usage: dpctl command [arg1] [arg2] ...\n' )
|
|
return
|
|
for sw in self.mn.switches:
|
|
output( '*** ' + sw.name + ' ' + ('-' * 72) + '\n' )
|
|
output( sw.dpctl( *args ) )
|
|
|
|
def do_time( self, line ):
|
|
"Measure time taken for any command in Mininet."
|
|
start = time.time()
|
|
self.onecmd(line)
|
|
elapsed = time.time() - start
|
|
self.stdout.write("*** Elapsed time: %0.6f secs\n" % elapsed)
|
|
|
|
def default( self, line ):
|
|
"""Called on an input line when the command prefix is not recognized.
|
|
Overridden to run shell commands when a node is the first CLI argument.
|
|
Past the first CLI argument, node names are automatically replaced with
|
|
corresponding IP addrs."""
|
|
|
|
first, args, line = self.parseline( line )
|
|
if not args:
|
|
return
|
|
if args and len(args) > 0 and args[ -1 ] == '\n':
|
|
args = args[ :-1 ]
|
|
rest = args.split( ' ' )
|
|
|
|
if first in self.nodemap:
|
|
node = self.nodemap[ first ]
|
|
# Substitute IP addresses for node names in command
|
|
rest = [ self.nodemap[ arg ].IP()
|
|
if arg in self.nodemap else arg
|
|
for arg in rest ]
|
|
rest = ' '.join( rest )
|
|
# Run cmd on node:
|
|
builtin = isShellBuiltin( first )
|
|
node.sendCmd( rest, printPid=( not builtin ) )
|
|
self.waitForNode( node )
|
|
else:
|
|
error( '*** Unknown command: %s\n' % first )
|
|
|
|
# pylint: enable-msg=R0201
|
|
|
|
def waitForNode( self, node ):
|
|
"Wait for a node to finish, and print its output."
|
|
# Pollers
|
|
nodePoller = poll()
|
|
nodePoller.register( node.stdout )
|
|
bothPoller = poll()
|
|
bothPoller.register( self.stdin, POLLIN )
|
|
bothPoller.register( node.stdout, POLLIN )
|
|
if self.isatty():
|
|
# Buffer by character, so that interactive
|
|
# commands sort of work
|
|
quietRun( 'stty -icanon min 1' )
|
|
while True:
|
|
try:
|
|
bothPoller.poll()
|
|
# XXX BL: this doesn't quite do what we want.
|
|
if False and self.inputFile:
|
|
key = self.inputFile.read( 1 )
|
|
if key is not '':
|
|
node.write(key)
|
|
else:
|
|
self.inputFile = None
|
|
if isReadable( self.inPoller ):
|
|
key = self.stdin.read( 1 )
|
|
node.write( key )
|
|
if isReadable( nodePoller ):
|
|
data = node.monitor()
|
|
output( data )
|
|
if not node.waiting:
|
|
break
|
|
except KeyboardInterrupt:
|
|
node.sendInt()
|
|
|
|
# Helper functions
|
|
|
|
def isReadable( poller ):
|
|
"Check whether a Poll object has a readable fd."
|
|
for fdmask in poller.poll( 0 ):
|
|
mask = fdmask[ 1 ]
|
|
if mask & POLLIN:
|
|
return True
|