blob: 15232ac9047e93af1fa849024f2417567534e691 [file] [log] [blame]
#!/usr/bin/python
"""
onos.py: ONOS cluster and control network in Mininet
With onos.py, you can use Mininet to create a complete
ONOS network, including an ONOS cluster with a modeled
control network as well as the usual data nework.
This is intended to be useful for distributed ONOS
development and testing in the case that you require
a modeled control network.
Invocation (using OVS as default switch):
mn --custom onos.py --controller onos,3 --topo torus,4,4
Or with the user switch (or CPqD if installed):
mn --custom onos.py --controller onos,3 \
--switch onosuser --topo torus,4,4
Currently you meed to use a custom switch class
because Mininet's Switch() class does't (yet?) handle
controllers with multiple IP addresses directly.
The classes may also be imported and used via Mininet's
python API.
Bugs/Gripes:
- We need --switch onosuser for the user switch because
Switch() doesn't currently handle Controller objects
with multiple IP addresses.
- ONOS startup and configuration is painful/undocumented.
- Too many ONOS environment vars - do we need them all?
- ONOS cluster startup is very, very slow. If Linux can
boot in 4 seconds, why can't ONOS?
- It's a pain to mess with the control network from the
CLI
- Setting a default controller for Mininet should be easier
"""
from mininet.node import Controller, OVSSwitch, UserSwitch
from mininet.nodelib import LinuxBridge
from mininet.net import Mininet
from mininet.topo import SingleSwitchTopo, Topo
from mininet.log import setLogLevel, info, warn, error, debug
from mininet.cli import CLI
from mininet.util import quietRun, specialClass
from mininet.examples.controlnet import MininetFacade
from os import environ
from os.path import dirname, join, isfile
from sys import argv
from glob import glob
import time
from functools import partial
### ONOS Environment
KarafPort = 8101 # ssh port indicating karaf is running
GUIPort = 8181 # GUI/REST port
OpenFlowPort = 6653 # OpenFlow port
CopycatPort = 9876 # Copycat port
DebugPort = 5005 # JVM debug port
def defaultUser():
"Return a reasonable default user"
if 'SUDO_USER' in environ:
return environ[ 'SUDO_USER' ]
try:
user = quietRun( 'who am i' ).split()[ 0 ]
except:
user = 'nobody'
return user
# Module vars, initialized below
HOME = ONOS_ROOT = ONOS_USER = None
ONOS_APPS = ONOS_WEB_USER = ONOS_WEB_PASS = ONOS_TAR = JAVA_OPTS = None
def initONOSEnv():
"""Initialize ONOS environment (and module) variables
This is ugly and painful, but they have to be set correctly
in order for the onos-setup-karaf script to work.
nodes: list of ONOS nodes
returns: ONOS environment variable dict"""
# pylint: disable=global-statement
global HOME, ONOS_ROOT, ONOS_USER
global ONOS_APPS, ONOS_WEB_USER, ONOS_WEB_PASS
env = {}
def sd( var, val ):
"Set default value for environment variable"
env[ var ] = environ.setdefault( var, val )
return env[ var ]
assert environ[ 'HOME' ]
HOME = sd( 'HOME', environ[ 'HOME' ] )
ONOS_ROOT = sd( 'ONOS_ROOT', join( HOME, 'onos' ) )
environ[ 'ONOS_USER' ] = defaultUser()
ONOS_USER = sd( 'ONOS_USER', defaultUser() )
ONOS_APPS = sd( 'ONOS_APPS',
'drivers,openflow,fwd,proxyarp,mobility' )
JAVA_OPTS = sd( 'JAVA_OPTS', '-Xms128m -Xmx512m' )
# ONOS_WEB_{USER,PASS} isn't respected by onos-karaf:
environ.update( ONOS_WEB_USER='karaf', ONOS_WEB_PASS='karaf' )
ONOS_WEB_USER = sd( 'ONOS_WEB_USER', 'karaf' )
ONOS_WEB_PASS = sd( 'ONOS_WEB_PASS', 'karaf' )
return env
def updateNodeIPs( env, nodes ):
"Update env dict and environ with node IPs"
# Get rid of stale junk
for var in 'ONOS_NIC', 'ONOS_CELL', 'ONOS_INSTANCES':
env[ var ] = ''
for var in environ.keys():
if var.startswith( 'OC' ):
env[ var ] = ''
for index, node in enumerate( nodes, 1 ):
var = 'OC%d' % index
env[ var ] = node.IP()
if nodes:
env[ 'OCI' ] = env[ 'OCN' ] = env[ 'OC1' ]
env[ 'ONOS_INSTANCES' ] = '\n'.join(
node.IP() for node in nodes )
environ.update( env )
return env
tarDefaultPath = "bazel-out/k8-fastbuild/bin/onos.tar.gz"
def unpackONOS( destDir='/tmp', run=quietRun ):
"Unpack ONOS and return its location"
global ONOS_TAR
environ.setdefault( 'ONOS_TAR', join( ONOS_ROOT, tarDefaultPath ) )
ONOS_TAR = environ[ 'ONOS_TAR' ]
tarPath = ONOS_TAR
if not isfile( tarPath ):
raise Exception( 'Missing ONOS tarball %s - run buck build onos?'
% tarPath )
info( '(unpacking %s)' % destDir)
success = '*** SUCCESS ***'
cmds = ( 'mkdir -p "%s" && cd "%s" && tar xzf "%s" && echo "%s"'
% ( destDir, destDir, tarPath, success ) )
result = run( cmds, shell=True, verbose=True )
if success not in result:
raise Exception( 'Failed to unpack ONOS archive %s in %s:\n%s\n' %
( tarPath, destDir, result ) )
# We can use quietRun for this usually
tarOutput = quietRun( 'tar tzf "%s" | head -1' % tarPath, shell=True)
tarOutput = tarOutput.split()[ 0 ].strip()
assert '/' in tarOutput
onosDir = join( destDir, dirname( tarOutput ) )
# Add symlink to log file
run( 'cd %s; ln -s onos*/apache* karaf;'
'ln -s karaf/data/log/karaf.log log' % destDir,
shell=True )
return onosDir
def waitListening( server, port=80, callback=None, sleepSecs=.5,
proc='java' ):
"Simplified netstat version of waitListening"
while True:
lines = server.cmd( 'netstat -natp' ).strip().split( '\n' )
entries = [ line.split() for line in lines ]
portstr = ':%s' % port
listening = [ entry for entry in entries
if len( entry ) > 6 and portstr in entry[ 3 ]
and proc in entry[ 6 ] ]
if listening:
break
info( '.' )
if callback:
callback()
time.sleep( sleepSecs )
### Mininet classes
def RenamedTopo( topo, *args, **kwargs ):
"""Return specialized topo with renamed hosts
topo: topo class/class name to specialize
args, kwargs: topo args
sold: old switch name prefix (default 's')
snew: new switch name prefix
hold: old host name prefix (default 'h')
hnew: new host name prefix
This may be used from the mn command, e.g.
mn --topo renamed,single,spref=sw,hpref=host"""
sold = kwargs.pop( 'sold', 's' )
hold = kwargs.pop( 'hold', 'h' )
snew = kwargs.pop( 'snew', 'cs' )
hnew = kwargs.pop( 'hnew' ,'ch' )
topos = {} # TODO: use global TOPOS dict
if isinstance( topo, str ):
# Look up in topo directory - this allows us to
# use RenamedTopo from the command line!
if topo in topos:
topo = topos.get( topo )
else:
raise Exception( 'Unknown topo name: %s' % topo )
# pylint: disable=no-init
class RenamedTopoCls( topo ):
"Topo subclass with renamed nodes"
def addNode( self, name, *args, **kwargs ):
"Add a node, renaming if necessary"
if name.startswith( sold ):
name = snew + name[ len( sold ): ]
elif name.startswith( hold ):
name = hnew + name[ len( hold ): ]
return topo.addNode( self, name, *args, **kwargs )
return RenamedTopoCls( *args, **kwargs )
# We accept objects that "claim" to be a particular class,
# since the class definitions can be both execed (--custom) and
# imported (in another custom file), which breaks isinstance().
# In order for this to work properly, a class should not be
# renamed so as to inappropriately omit or include the class
# name text. Note that mininet.util.specialClass renames classes
# by adding the specialized parameter names and values.
def isONOSNode( obj ):
"Does obj claim to be some kind of ONOSNode?"
return ( isinstance( obj, ONOSNode) or
'ONOSNode' in type( obj ).__name__ )
def isONOSCluster( obj ):
"Does obj claim to be some kind of ONOSCluster?"
return ( isinstance( obj, ONOSCluster ) or
'ONOSCluster' in type( obj ).__name__ )
class ONOSNode( Controller ):
"ONOS cluster node"
def __init__( self, name, **kwargs ):
"alertAction: exception|ignore|warn|exit (exception)"
kwargs.update( inNamespace=True )
self.alertAction = kwargs.pop( 'alertAction', 'exception' )
Controller.__init__( self, name, **kwargs )
self.dir = '/tmp/%s' % self.name
self.client = self.dir + '/karaf/bin/client'
self.ONOS_HOME = '/tmp'
self.cmd( 'rm -rf', self.dir )
self.ONOS_HOME = unpackONOS( self.dir, run=self.ucmd )
self.ONOS_ROOT = ONOS_ROOT
# pylint: disable=arguments-differ
def start( self, env=None, nodes=(), debug=False ):
"""Start ONOS on node
env: environment var dict
nodes: all nodes in cluster"""
if env is not None:
self.genStartConfig(env, nodes)
self.cmd( 'cd', self.ONOS_HOME )
info( '(starting %s debug: %s)' % ( self, debug ) )
service = join( self.ONOS_HOME, 'bin/onos-service' )
if debug:
self.ucmd( service, 'server debug 1>../onos.log 2>../onos.log'
' & echo $! > onos.pid; ln -s `pwd`/onos.pid ..' )
else:
self.ucmd( service, 'server 1>../onos.log 2>../onos.log'
' & echo $! > onos.pid; ln -s `pwd`/onos.pid ..' )
self.onosPid = int( self.cmd( 'cat onos.pid' ).strip() )
self.warningCount = 0
# pylint: disable=arguments-differ
def genStartConfig( self, env, nodes=() ):
"""generate a start config"""
env = dict( env )
env.update( ONOS_HOME=self.ONOS_HOME )
self.updateEnv( env )
karafbin = glob( '%s/apache*/bin' % self.ONOS_HOME )[ 0 ]
onosbin = join( ONOS_ROOT, 'tools/test/bin' )
self.cmd( 'export PATH=%s:%s:$PATH' % ( onosbin, karafbin ) )
self.cmd( 'cd', self.ONOS_HOME )
self.ucmd( 'mkdir -p config && '
'onos-gen-default-cluster config/cluster.json --nodes ',
' '.join( node.IP() for node in nodes ) )
def intfsDown( self ):
"""Bring all interfaces down"""
for intf in self.intfs.values():
cmdOutput = intf.ifconfig( 'down' )
# no output indicates success
if cmdOutput:
error( "Error setting %s down: %s " % ( intf.name, cmdOutput ) )
def intfsUp( self ):
"""Bring all interfaces up"""
for intf in self.intfs.values():
cmdOutput = intf.ifconfig( 'up' )
if cmdOutput:
error( "Error setting %s up: %s " % ( intf.name, cmdOutput ) )
def kill( self ):
"""Kill ONOS process"""
self.cmd( 'kill %d && wait' % ( self.onosPid ) )
def stop( self ):
# XXX This will kill all karafs - too bad!
self.cmd( 'pkill -HUP -f karaf.jar && wait' )
self.cmd( 'rm -rf', self.dir )
def sanityAlert( self, *args ):
"Alert to raise on sanityCheck failure"
info( '\n' )
if self.alertAction == 'exception':
raise Exception( *args )
if self.alertAction == 'warn':
warn( *args + ( '\n', ) )
elif self.alertAction == 'exit':
error( '***', *args +
( '\nExiting. Run "sudo mn -c" to clean up.\n', ) )
exit( 1 )
def isRunning( self ):
"Is our ONOS process still running?"
cmd = ( 'ps -p %d >/dev/null 2>&1 && echo "running" ||'
'echo "not running"' )
return self.cmd( cmd % self.onosPid ).strip() == 'running'
def checkLog( self ):
"Return log file errors and warnings"
log = join( self.dir, 'log' )
errors, warnings = [], []
if isfile( log ):
lines = open( log ).read().split( '\n' )
errors = [ line for line in lines if 'ERROR' in line ]
warnings = [ line for line in lines if 'WARN'in line ]
return errors, warnings
def memAvailable( self ):
"Return available memory in KB (or -1 if we can't tell)"
lines = open( '/proc/meminfo' ).read().strip().split( '\n' )
entries = map( str.split, lines )
index = { entry[ 0 ]: entry for entry in entries }
# Check MemAvailable if present
default = ( None, '-1', 'kB' )
_name, count, unit = index.get( 'MemAvailable:', default )
if unit.lower() == 'kb':
return int( count )
return -1
def sanityCheck( self, lowMem=100000 ):
"""Check whether we've quit or are running out of memory
lowMem: low memory threshold in KB (100000)"""
# Are we still running?
if not self.isRunning():
self.sanityAlert( 'ONOS node %s has died' % self.name )
# Are there errors in the log file?
errors, warnings = self.checkLog()
if errors:
self.sanityAlert( 'ONOS startup errors:\n<<%s>>' %
'\n'.join( errors ) )
warningCount = len( warnings )
if warnings and warningCount > self.warningCount:
warn( '(%d warnings)' % len( warnings ) )
self.warningCount = warningCount
# Are we running out of memory?
mem = self.memAvailable()
if mem > 0 and mem < lowMem:
self.sanityAlert( 'Running out of memory (only %d KB available)'
% mem )
def waitStarted( self ):
"Wait until we've really started"
info( '(checking: karaf' )
while True:
status = self.ucmd( 'karaf status' ).lower()
if 'running' in status and 'not running' not in status:
break
info( '.' )
self.sanityCheck()
time.sleep( 1 )
info( ' ssh-port' )
waitListening( server=self, port=KarafPort, callback=self.sanityCheck )
info( ' protocol' )
while True:
result = quietRun( '%s -h %s "apps -a"' %
( self.client, self.IP() ), shell=True )
if 'openflow' in result or 'p4runtime' in result:
break
info( '.' )
self.sanityCheck()
time.sleep( 1 )
info( ' node-status' )
while True:
result = quietRun( '%s -h %s "nodes"' %
( self.client, self.IP() ), shell=True )
nodeStr = 'id=%s, address=%s:%s, state=READY' %\
( self.IP(), self.IP(), CopycatPort )
if nodeStr in result:
break
# just break if state is active
if "state=ACTIVE" in result:
break
info( '.' )
self.sanityCheck()
time.sleep( 1 )
info( ')\n' )
def updateEnv( self, envDict ):
"Update environment variables"
cmd = ';'.join( ( 'export %s="%s"' % ( var, val )
if val else 'unset %s' % var )
for var, val in envDict.iteritems() )
self.cmd( cmd )
def ucmd( self, *args, **_kwargs ):
"Run command as $ONOS_USER using sudo -E -u"
if ONOS_USER != 'root': # don't bother with sudo
args = [ "sudo -E -u $ONOS_USER PATH=$PATH "
"bash -c '%s'" % ' '.join( args ) ]
return self.cmd( *args )
class ONOSCluster( Controller ):
"ONOS Cluster"
# Offset for port forwarding
portOffset = 0
def __init__( self, *args, **kwargs ):
"""name: (first parameter)
*args: topology class parameters
ipBase: IP range for ONOS nodes
forward: default port forwarding list
portOffset: offset to port base (optional)
topo: topology class or instance
nodeOpts: ONOSNode options
debug: enabling debug mode or not
**kwargs: additional topology parameters
By default, multiple ONOSClusters will increment
the portOffset automatically; alternately, it can
be specified explicitly.
"""
args = list( args )
name = args.pop( 0 )
topo = kwargs.pop( 'topo', None )
self.nat = kwargs.pop( 'nat', 'nat0' )
nodeOpts = kwargs.pop( 'nodeOpts', {} )
self.portOffset = kwargs.pop( 'portOffset', ONOSCluster.portOffset )
# Pass in kwargs to the ONOSNodes instead of the cluster
"alertAction: exception|ignore|warn|exit (exception)"
alertAction = kwargs.pop( 'alertAction', None )
if alertAction:
nodeOpts[ 'alertAction'] = alertAction
# Default: single switch with 1 ONOS node
if not topo:
topo = SingleSwitchTopo
if not args:
args = ( 1, )
if not isinstance( topo, Topo ):
topo = RenamedTopo( topo, *args, hnew='onos', **kwargs )
self.ipBase = kwargs.pop( 'ipBase', '192.168.123.0/24' )
self.forward = kwargs.pop( 'forward',
[ KarafPort, GUIPort, OpenFlowPort, DebugPort ] )
self.debug = kwargs.pop('debug', 'False') == 'True'
super( ONOSCluster, self ).__init__( name, inNamespace=False )
fixIPTables()
self.env = initONOSEnv()
self.net = Mininet( topo=topo, ipBase=self.ipBase,
host=partial( ONOSNode, **nodeOpts ),
switch=LinuxBridge,
controller=None )
if self.nat:
self.net.addNAT( self.nat ).configDefault()
updateNodeIPs( self.env, self.nodes() )
self._remoteControllers = []
# Update port offset for more ONOS clusters
ONOSCluster.portOffset += len( self.nodes() )
def start( self ):
"Start up ONOS cluster"
info( '*** ONOS_APPS = %s\n' % ONOS_APPS )
self.net.start()
for node in self.nodes():
node.start( self.env, self.nodes(), self.debug )
info( '\n' )
self.configPortForwarding( ports=self.forward, action='A' )
self.waitStarted()
return
def waitStarted( self ):
"Wait until all nodes have started"
startTime = time.time()
for node in self.nodes():
info( node )
node.waitStarted()
info( '*** Waited %.2f seconds for ONOS startup' %
( time.time() - startTime ) )
def stop( self ):
"Shut down ONOS cluster"
self.configPortForwarding( ports=self.forward, action='D' )
for node in self.nodes():
node.stop()
self.net.stop()
def nodes( self ):
"Return list of ONOS nodes"
return [ h for h in self.net.hosts if isONOSNode( h ) ]
def configPortForwarding( self, ports=[], action='A' ):
"""Start or stop port forwarding (any intf) for all nodes
ports: list of ports to forward
action: A=add/start, D=delete/stop (default: A)"""
self.cmd( 'iptables -' + action, 'FORWARD -d', self.ipBase,
'-j ACCEPT' )
for port in ports:
for index, node in enumerate( self.nodes() ):
ip, inport = node.IP(), port + self.portOffset + index
# Configure a destination NAT rule
self.cmd( 'iptables -t nat -' + action,
'PREROUTING -t nat -p tcp --dport', inport,
'-j DNAT --to-destination %s:%s' % ( ip, port ) )
def getONOSNode( self, instance ):
"""Return ONOS node which name is 'instance'
instance: ONOS instance name"""
try:
onos = self.net.getNodeByName( instance )
if isONOSNode( onos ):
return onos
else:
info( 'instance %s is not ONOS.\n' % instance )
except KeyError:
info( 'No such ONOS instance %s.\n' % instance )
class ONOSSwitchMixin( object ):
"Mixin for switches that connect to an ONOSCluster"
def start( self, controllers ):
"Connect to ONOSCluster"
self.controllers = controllers
assert ( len( controllers ) is 1 and
isONOSCluster( controllers[ 0 ] ) )
clist = controllers[ 0 ].nodes()
return super( ONOSSwitchMixin, self ).start( clist )
class ONOSOVSSwitch( ONOSSwitchMixin, OVSSwitch ):
"OVSSwitch that can connect to an ONOSCluster"
pass
class ONOSUserSwitch( ONOSSwitchMixin, UserSwitch):
"UserSwitch that can connect to an ONOSCluster"
pass
### Ugly utility routines
def fixIPTables():
"Fix LinuxBridge warning"
for s in 'arp', 'ip', 'ip6':
quietRun( 'sysctl net.bridge.bridge-nf-call-%stables=0' % s )
### Test code
def test( serverCount ):
"Test this setup"
setLogLevel( 'info' )
net = Mininet( topo=SingleSwitchTopo( 3 ),
controller=[ ONOSCluster( 'c0', serverCount ) ],
switch=ONOSOVSSwitch )
net.start()
net.waitConnected()
CLI( net )
net.stop()
### CLI Extensions
OldCLI = CLI
class ONOSCLI( OldCLI ):
"CLI Extensions for ONOS"
prompt = 'mininet-onos> '
def __init__( self, net, **kwargs ):
clusters = [ c.net for c in net.controllers
if isONOSCluster( c ) ]
net = MininetFacade( net, *clusters )
OldCLI.__init__( self, net, **kwargs )
def onos1( self ):
"Helper function: return default ONOS node"
return self.mn.controllers[ 0 ].net.hosts[ 0 ]
def do_onos( self, line ):
"Send command to ONOS CLI"
c0 = self.mn.controllers[ 0 ]
if isONOSCluster( c0 ):
# cmdLoop strips off command name 'onos'
if line.startswith( ':' ):
line = 'onos' + line
onos1 = self.onos1().name
if line:
line = '"%s"' % line
cmd = '%s client -h %s %s' % ( onos1, onos1, line )
quietRun( 'stty -echo' )
self.default( cmd )
quietRun( 'stty echo' )
def do_wait( self, line ):
"Wait for switches to connect"
self.mn.waitConnected()
def do_balance( self, line ):
"Balance switch mastership"
self.do_onos( ':balance-masters' )
def do_log( self, line ):
"Run tail -f /tmp/onos1/log; press control-C to stop"
self.default( '%s tail -f /tmp/%s/log' %
( self.onos1(), self.onos1() ) )
def do_status( self, line ):
"Return status of ONOS cluster(s)"
for c in self.mn.controllers:
if isONOSCluster( c ):
for node in c.net.hosts:
if isONOSNode( node ):
errors, warnings = node.checkLog()
running = ( 'Running' if node.isRunning()
else 'Exited' )
status = ''
if errors:
status += '%d ERRORS ' % len( errors )
if warnings:
status += '%d warnings' % len( warnings )
status = status if status else 'OK'
info( node, '\t', running, '\t', status, '\n' )
def do_arp( self, line ):
"Send gratuitous arps from all data network hosts"
startTime = time.time()
try:
count = int( line )
except:
count = 1
# Technically this check should be on the host
if '-U' not in quietRun( 'arping -h', shell=True ):
warn( 'Please install iputils-arping.\n' )
return
# This is much faster if we do it in parallel
for host in self.mn.net.hosts:
intf = host.defaultIntf()
# -b: keep using broadcasts; -f: quit after 1 reply
# -U: gratuitous ARP update
host.sendCmd( 'arping -bf -c', count, '-U -I',
intf.name, intf.IP() )
for host in self.mn.net.hosts:
# We could check the output here if desired
host.waitOutput()
info( '.' )
info( '\n' )
elapsed = time.time() - startTime
debug( 'Completed in %.2f seconds\n' % elapsed )
def onosupdown( self, cmd, instance ):
if not instance:
info( 'Provide the name of an ONOS instance.\n' )
return
c0 = self.mn.controllers[ 0 ]
if isONOSCluster( c0 ):
onos = c0.getONOSNode( instance )
if onos:
info('Bringing %s %s...\n' % ( instance, cmd ) )
if cmd == 'up':
onos.intfsUp()
else:
onos.intfsDown()
def do_onosdown( self, instance=None ):
"""Disconnects an ONOS instance from the network"""
self.onosupdown( 'down', instance )
def do_onosup( self, instance=None ):
""""Connects an ONOS instance to the network"""
self.onosupdown( 'up', instance )
def do_start( self, instance=None ):
"""Start ONOS instance"""
if not instance:
info( 'Provide the name of an ONOS instance.\n' )
return
c0 = self.mn.controllers[ 0 ]
if isONOSCluster( c0 ):
onos = c0.getONOSNode( instance )
if onos:
info('Starting %s...\n' % ( instance ) )
onos.start( debug=c0.debug )
def do_kill( self, instance=None ):
"""Kill ONOS instance"""
if not instance:
info( 'Provide the name of an ONOS instance.\n' )
return
c0 = self.mn.controllers[ 0 ]
if isONOSCluster( c0 ):
onos = c0.getONOSNode( instance )
if onos:
info('Killing %s...\n' % ( instance ) )
onos.kill()
# For interactive use, exit on error
exitOnError = dict( nodeOpts={ 'alertAction': 'exit' } )
ONOSClusterInteractive = specialClass( ONOSCluster, defaults=exitOnError )
### Exports for bin/mn
CLI = ONOSCLI
controllers = { 'onos': ONOSClusterInteractive,
'default': ONOSClusterInteractive }
# XXX Hack to change default controller as above doesn't work
findController = lambda: controllers[ 'default' ]
switches = { 'onos': ONOSOVSSwitch,
'onosovs': ONOSOVSSwitch,
'onosuser': ONOSUserSwitch,
'default': ONOSOVSSwitch }
# Null topology so we can control an external/hardware network
topos = { 'none': Topo }
if __name__ == '__main__':
if len( argv ) != 2:
test( 3 )
else:
test( int( argv[ 1 ] ) )