Fix format of mininetclidriver
-Remove some old comments
-Conform to Mininet python style guide
-Fix some minor typos
-Remove some unused imports
diff --git a/TestON/drivers/common/cli/emulator/mininetclidriver.py b/TestON/drivers/common/cli/emulator/mininetclidriver.py
index 52754df..c125fca 100644
--- a/TestON/drivers/common/cli/emulator/mininetclidriver.py
+++ b/TestON/drivers/common/cli/emulator/mininetclidriver.py
@@ -1,762 +1,896 @@
#!/usr/bin/env python
-'''
+"""
Created on 26-Oct-2012
-@author: Anil Kumar (anilkumar.s@paxterrasolutions.com)
+author:: Anil Kumar ( anilkumar.s@paxterrasolutions.com )
- TestON is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 2 of the License, or
- (at your option) any later version.
+TestON is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+( at your option ) any later version.
- TestON is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
+TestON is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with TestON. If not, see <http://www.gnu.org/licenses/>.
+You should have received a copy of the GNU General Public License
+along with TestON. If not, see <http://www.gnu.org/licenses/>.
-MininetCliDriver is the basic driver which will handle the Mininet functions
-'''
+MininetCliDriver is the basic driver which will handle the Mininet functions"""
import traceback
import pexpect
import re
import sys
-sys.path.append("../")
+sys.path.append( "../" )
from math import pow
from drivers.common.cli.emulatordriver import Emulator
-class MininetCliDriver(Emulator):
- '''
- MininetCliDriver is the basic driver which will handle the Mininet functions
- '''
- def __init__(self):
- super(Emulator, self).__init__()
+
+class MininetCliDriver( Emulator ):
+
+ """
+ MininetCliDriver is the basic driver which will handle
+ the Mininet functions"""
+ def __init__( self ):
+ super( Emulator, self ).__init__()
self.handle = self
- self.wrapped = sys.modules[__name__]
+ self.wrapped = sys.modules[ __name__ ]
self.flag = 0
- def connect(self, **connectargs):
- '''
- Here the main is the TestON instance after creating all the log handles.
- '''
+ def connect( self, **connectargs ):
+ """
+ Here the main is the TestON instance after creating
+ all the log handles."""
for key in connectargs:
- vars(self)[key] = connectargs[key]
+ vars( self )[ key ] = connectargs[ key ]
- self.name = self.options['name']
- self.handle = super(MininetCliDriver, self).connect(user_name = self.user_name, ip_address = self.ip_address,port = None, pwd = self.pwd)
+ self.name = self.options[ 'name' ]
+ self.handle = super(
+ MininetCliDriver,
+ self ).connect(
+ user_name=self.user_name,
+ ip_address=self.ip_address,
+ port=None,
+ pwd=self.pwd )
self.ssh_handle = self.handle
- if self.handle :
- main.log.info(self.name+": Clearing any residual state or processes")
- self.handle.sendline("sudo mn -c")
- i=self.handle.expect(['password\sfor\s','Cleanup\scomplete',pexpect.EOF,pexpect.TIMEOUT],120)
- if i==0:
- main.log.info(self.name+": Sending sudo password")
- self.handle.sendline(self.pwd)
- i=self.handle.expect(['%s:'%(self.user),'\$',pexpect.EOF,pexpect.TIMEOUT],120)
- if i==1:
- main.log.info(self.name+": Clean")
- elif i==2:
- main.log.error(self.name+": Connection terminated")
- elif i==3: #timeout
- main.log.error(self.name+": Something while cleaning MN took too long... " )
+ if self.handle:
+ main.log.info(
+ self.name +
+ ": Clearing any residual state or processes" )
+ self.handle.sendline( "sudo mn -c" )
+ i = self.handle.expect( [ 'password\sfor\s',
+ 'Cleanup\scomplete',
+ pexpect.EOF,
+ pexpect.TIMEOUT ],
+ 120 )
+ if i == 0:
+ main.log.info( self.name + ": Sending sudo password" )
+ self.handle.sendline( self.pwd )
+ i = self.handle.expect( [ '%s:' % ( self.user ),
+ '\$',
+ pexpect.EOF,
+ pexpect.TIMEOUT ],
+ 120 )
+ if i == 1:
+ main.log.info( self.name + ": Clean" )
+ elif i == 2:
+ main.log.error( self.name + ": Connection terminated" )
+ elif i == 3: # timeout
+ main.log.error(
+ self.name +
+ ": Something while cleaning MN took too long... " )
- main.log.info(self.name+": building fresh mininet")
- #### for reactive/PARP enabled tests
- cmdString = "sudo mn " + self.options['arg1'] + " " + self.options['arg2'] + " --mac --controller " + self.options['controller'] + " " + self.options['arg3']
+ main.log.info( self.name + ": building fresh mininet" )
+ # for reactive/PARP enabled tests
+ cmdString = "sudo mn " + self.options[ 'arg1' ] +\
+ " " + self.options[ 'arg2' ] +\
+ " --mac --controller " +\
+ self.options[ 'controller' ] + " " +\
+ self.options[ 'arg3' ]
- argList = self.options['arg1'].split(",")
+ argList = self.options[ 'arg1' ].split( "," )
global topoArgList
- topoArgList = argList[0].split(" ")
- argList = map(int, argList[1:])
- topoArgList = topoArgList[1:] + argList
+ topoArgList = argList[ 0 ].split( " " )
+ argList = map( int, argList[ 1: ] )
+ topoArgList = topoArgList[ 1: ] + argList
- #### for proactive flow with static ARP entries
- #cmdString = "sudo mn " + self.options['arg1'] + " " + self.options['arg2'] + " --mac --arp --controller " + self.options['controller'] + " " + self.options['arg3']
- self.handle.sendline(cmdString)
- self.handle.expect(["sudo mn",pexpect.EOF,pexpect.TIMEOUT])
- while 1:
- i=self.handle.expect(['mininet>','\*\*\*','Exception',pexpect.EOF,pexpect.TIMEOUT],300)
- if i==0:
- main.log.info(self.name+": mininet built")
+ self.handle.sendline( cmdString )
+ self.handle.expect( [ "sudo mn", pexpect.EOF, pexpect.TIMEOUT ] )
+ while True:
+ i = self.handle.expect( [ 'mininet>',
+ '\*\*\*',
+ 'Exception',
+ pexpect.EOF,
+ pexpect.TIMEOUT ],
+ 300 )
+ if i == 0:
+ main.log.info( self.name + ": mininet built" )
return main.TRUE
- if i==1:
- self.handle.expect(["\n",pexpect.EOF,pexpect.TIMEOUT])
- main.log.info(self.handle.before)
- elif i==2:
- main.log.error(self.name+": Launching mininet failed...")
+ if i == 1:
+ self.handle.expect(
+ [ "\n", pexpect.EOF, pexpect.TIMEOUT ] )
+ main.log.info( self.handle.before )
+ elif i == 2:
+ main.log.error(
+ self.name +
+ ": Launching mininet failed..." )
return main.FALSE
- elif i==3:
- main.log.error(self.name+": Connection timeout")
+ elif i == 3:
+ main.log.error( self.name + ": Connection timeout" )
return main.FALSE
- elif i==4: #timeout
- main.log.error(self.name+": Something took too long... " )
+ elif i == 4: # timeout
+ main.log.error(
+ self.name +
+ ": Something took too long... " )
return main.FALSE
- #if utilities.assert_matches(expect=patterns,actual=resultCommand,onpass="Network is being launched",onfail="Network launching is being failed "):
return main.TRUE
- else:#if no handle
- main.log.error(self.name+": Connection failed to the host "+self.user_name+"@"+self.ip_address)
- main.log.error(self.name+": Failed to connect to the Mininet")
+ else: # if no handle
+ main.log.error(
+ self.name +
+ ": Connection failed to the host " +
+ self.user_name +
+ "@" +
+ self.ip_address )
+ main.log.error( self.name + ": Failed to connect to the Mininet" )
return main.FALSE
- def num_switches_n_links(self,topoType,depth,fanout):
+ def num_switches_n_links( self, topoType, depth, fanout ):
if topoType == 'tree':
- if fanout is None: #In tree topology, if fanout arg is not given, by default it is 2
+ # In tree topology, if fanout arg is not given, by default it is 2
+ if fanout is None:
fanout = 2
k = 0
count = 0
- while(k <= depth-1):
- count = count + pow(fanout,k)
- k = k+1
+ while( k <= depth - 1 ):
+ count = count + pow( fanout, k )
+ k = k + 1
num_switches = count
- while(k <= depth-2):
- '''depth-2 gives you only core links and not considering edge links as seen by ONOS
- If all the links including edge links are required, do depth-1
- '''
- count = count + pow(fanout,k)
- k = k+1
+ while( k <= depth - 2 ):
+ # depth-2 gives you only core links and not considering
+ # edge links as seen by ONOS. If all the links including
+ # edge links are required, do depth-1
+ count = count + pow( fanout, k )
+ k = k + 1
num_links = count * fanout
- #print "num_switches for %s(%d,%d) = %d and links=%d" %(topoType,depth,fanout,num_switches,num_links)
+ # print "num_switches for %s(%d,%d) = %d and links=%d" %(
+ # topoType,depth,fanout,num_switches,num_links )
- elif topoType =='linear':
- if fanout is None: #In linear topology, if fanout or num_hosts_per_sw is not given, by default it is 1
+ elif topoType == 'linear':
+ # In linear topology, if fanout or num_hosts_per_sw is not given,
+ # by default it is 1
+ if fanout is None:
fanout = 1
num_switches = depth
num_hosts_per_sw = fanout
total_num_hosts = num_switches * num_hosts_per_sw
- num_links = total_num_hosts + (num_switches - 1)
- print "num_switches for %s(%d,%d) = %d and links=%d" %(topoType,depth,fanout,num_switches,num_links)
+ num_links = total_num_hosts + ( num_switches - 1 )
+ print "num_switches for %s(%d,%d) = %d and links=%d" %\
+ ( topoType, depth, fanout, num_switches, num_links )
topoDict = {}
- topoDict = {"num_switches":int(num_switches), "num_corelinks":int(num_links)}
+ topoDict = {
+ "num_switches": int( num_switches ),
+ "num_corelinks": int( num_links ) }
return topoDict
-
- def calculate_sw_and_links(self):
- topoDict = self.num_switches_n_links(*topoArgList)
+ def calculate_sw_and_links( self ):
+ topoDict = self.num_switches_n_links( *topoArgList )
return topoDict
- def pingall(self, timeout=300):
- '''
- Verifies the reachability of the hosts using pingall command.
- Optional parameter timeout allows you to specify how long to wait for pingall to complete
- Returns:
- main.TRUE if pingall completes with no pings dropped
- otherwise main.FALSE
- '''
- if self.handle :
- main.log.info(self.name+": Checking reachabilty to the hosts using pingall")
+ def pingall( self, timeout=300 ):
+ """
+ Verifies the reachability of the hosts using pingall command.
+ Optional parameter timeout allows you to specify how long to
+ wait for pingall to complete
+ Returns:
+ main.TRUE if pingall completes with no pings dropped
+ otherwise main.FALSE"""
+ if self.handle:
+ main.log.info(
+ self.name +
+ ": Checking reachabilty to the hosts using pingall" )
try:
- response = self.execute(cmd="pingall",prompt="mininet>",timeout=int(timeout))
+ response = self.execute(
+ cmd="pingall",
+ prompt="mininet>",
+ timeout=int( timeout ) )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
except pexpect.TIMEOUT:
- #We may not want to kill the test if pexpect times out
- main.log.error(self.name + ": TIMEOUT exception found")
- main.log.error(self.name + ": " + str(self.handle.before) )
- #NOTE: mininet's pingall rounds, so we will check the number of passed and number of failed
- pattern = "Results\:\s0\%\sdropped\s\((?P<passed>[\d]+)/(?P=passed)"
- if re.search(pattern,response):
- main.log.info(self.name+": All hosts are reachable")
+ # We may not want to kill the test if pexpect times out
+ main.log.error( self.name + ": TIMEOUT exception found" )
+ main.log.error( self.name +
+ ": " +
+ str( self.handle.before ) )
+ # NOTE: mininet's pingall rounds, so we will check the number of
+ # passed and number of failed
+ pattern = "Results\:\s0\%\sdropped\s\(" +\
+ "(?P<passed>[\d]+)/(?P=passed)"
+ if re.search( pattern, response ):
+ main.log.info( self.name + ": All hosts are reachable" )
return main.TRUE
else:
- main.log.error(self.name+": Unable to reach all the hosts")
- main.log.info("Pingall ouput: " + str(response))
- #NOTE: Send ctrl-c to make sure pingall is done
- self.handle.send("\x03")
- self.handle.expect("Interrupt")
- self.handle.expect("mininet>")
+ main.log.error( self.name + ": Unable to reach all the hosts" )
+ main.log.info( "Pingall ouput: " + str( response ) )
+ # NOTE: Send ctrl-c to make sure pingall is done
+ self.handle.send( "\x03" )
+ self.handle.expect( "Interrupt" )
+ self.handle.expect( "mininet>" )
return main.FALSE
- else :
- main.log.error(self.name+": Connection failed to the host")
+ else:
+ main.log.error( self.name + ": Connection failed to the host" )
main.cleanup()
main.exit()
- def fpingHost(self,**pingParams):
- '''
- Uses the fping package for faster pinging...
- *requires fping to be installed on machine running mininet
- '''
- args = utilities.parse_args(["SRC","TARGET"],**pingParams)
- command = args["SRC"] + " fping -i 100 -t 20 -C 1 -q "+args["TARGET"]
- self.handle.sendline(command)
- self.handle.expect([args["TARGET"],pexpect.EOF,pexpect.TIMEOUT])
- self.handle.expect(["mininet",pexpect.EOF,pexpect.TIMEOUT])
- response = self.handle.before
- if re.search(":\s-" ,response):
- main.log.info(self.name+": Ping fail")
+ def fpingHost( self, **pingParams ):
+ """
+ Uses the fping package for faster pinging...
+ *requires fping to be installed on machine running mininet"""
+ args = utilities.parse_args( [ "SRC", "TARGET" ], **pingParams )
+ command = args[ "SRC" ] + \
+ " fping -i 100 -t 20 -C 1 -q " + args[ "TARGET" ]
+ self.handle.sendline( command )
+ self.handle.expect(
+ [ args[ "TARGET" ], pexpect.EOF, pexpect.TIMEOUT ] )
+ self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
+ response = self.handle.before
+ if re.search( ":\s-", response ):
+ main.log.info( self.name + ": Ping fail" )
return main.FALSE
- elif re.search(":\s\d{1,2}\.\d\d", response):
- main.log.info(self.name+": Ping good!")
+ elif re.search( ":\s\d{1,2}\.\d\d", response ):
+ main.log.info( self.name + ": Ping good!" )
return main.TRUE
- main.log.info(self.name+": Install fping on mininet machine... ")
- main.log.info(self.name+": \n---\n"+response)
+ main.log.info( self.name + ": Install fping on mininet machine... " )
+ main.log.info( self.name + ": \n---\n" + response )
return main.FALSE
- def pingHost(self,**pingParams):
- '''
- Ping from one mininet host to another
- Currently the only supported Params: SRC and TARGET
- '''
- args = utilities.parse_args(["SRC","TARGET"],**pingParams)
- #command = args["SRC"] + " ping -" + args["CONTROLLER"] + " " +args ["TARGET"]
- command = args["SRC"] + " ping "+args ["TARGET"]+" -c 1 -i 1 -W 8"
+ def pingHost( self, **pingParams ):
+ """
+ Ping from one mininet host to another
+ Currently the only supported Params: SRC and TARGET"""
+ args = utilities.parse_args( [ "SRC", "TARGET" ], **pingParams )
+ command = args[ "SRC" ] + " ping " + \
+ args[ "TARGET" ] + " -c 1 -i 1 -W 8"
try:
- main.log.warn("Sending: " + command)
- #response = self.execute(cmd=command,prompt="mininet",timeout=10 )
- self.handle.sendline(command)
- i = self.handle.expect([command,pexpect.TIMEOUT])
+ main.log.warn( "Sending: " + command )
+ self.handle.sendline( command )
+ i = self.handle.expect( [ command, pexpect.TIMEOUT ] )
if i == 1:
- main.log.error(self.name + ": timeout when waiting for response from mininet")
- main.log.error("response: " + str(self.handle.before))
- i = self.handle.expect(["mininet>",pexpect.TIMEOUT])
+ main.log.error(
+ self.name +
+ ": timeout when waiting for response from mininet" )
+ main.log.error( "response: " + str( self.handle.before ) )
+ i = self.handle.expect( [ "mininet>", pexpect.TIMEOUT ] )
if i == 1:
- main.log.error(self.name + ": timeout when waiting for response from mininet")
- main.log.error("response: " + str(self.handle.before))
+ main.log.error(
+ self.name +
+ ": timeout when waiting for response from mininet" )
+ main.log.error( "response: " + str( self.handle.before ) )
response = self.handle.before
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
- main.log.info(self.name+": Ping Response: "+ response )
- #if utilities.assert_matches(expect=',\s0\%\spacket\sloss',actual=response,onpass="No Packet loss",onfail="Host is not reachable"):
- if re.search(',\s0\%\spacket\sloss',response):
- main.log.info(self.name+": no packets lost, host is reachable")
+ main.log.info( self.name + ": Ping Response: " + response )
+ if re.search( ',\s0\%\spacket\sloss', response ):
+ main.log.info( self.name + ": no packets lost, host is reachable" )
main.last_result = main.TRUE
return main.TRUE
- else :
- main.log.error(self.name+": PACKET LOST, HOST IS NOT REACHABLE")
+ else:
+ main.log.error(
+ self.name +
+ ": PACKET LOST, HOST IS NOT REACHABLE" )
main.last_result = main.FALSE
return main.FALSE
- def checkIP(self,host):
- '''
- Verifies the host's ip configured or not.
- '''
- if self.handle :
+ def checkIP( self, host ):
+ """
+ Verifies the host's ip configured or not."""
+ if self.handle:
try:
- response = self.execute(cmd=host+" ifconfig",prompt="mininet>",timeout=10)
+ response = self.execute(
+ cmd=host +
+ " ifconfig",
+ prompt="mininet>",
+ timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
- pattern = "inet\s(addr|Mask):([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2}).([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2}).([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2}).([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2})"
- #pattern = "inet addr:10.0.0.6"
- #if utilities.assert_matches(expect=pattern,actual=response,onpass="Host Ip configured properly",onfail="Host IP not found") :
- if re.search(pattern,response):
- main.log.info(self.name+": Host Ip configured properly")
+ pattern = "inet\s(addr|Mask):([0-1]{1}[0-9]{1,2}|" +\
+ "2[0-4][0-9]|25[0-5]|[0-9]{1,2}).([0-1]{1}" +\
+ "[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2})." +\
+ "([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|" +\
+ "[0-9]{1,2}).([0-1]{1}[0-9]{1,2}|2[0-4]" +\
+ "[0-9]|25[0-5]|[0-9]{1,2})"
+ # pattern = "inet addr:10.0.0.6"
+ if re.search( pattern, response ):
+ main.log.info( self.name + ": Host Ip configured properly" )
return main.TRUE
else:
- main.log.error(self.name+": Host IP not found")
+ main.log.error( self.name + ": Host IP not found" )
return main.FALSE
- else :
- main.log.error(self.name+": Connection failed to the host")
+ else:
+ main.log.error( self.name + ": Connection failed to the host" )
- def verifySSH(self,**connectargs):
+ def verifySSH( self, **connectargs ):
try:
- response = self.execute(cmd="h1 /usr/sbin/sshd -D&",prompt="mininet>",timeout=10)
- response = self.execute(cmd="h4 /usr/sbin/sshd -D&",prompt="mininet>",timeout=10)
+ response = self.execute(
+ cmd="h1 /usr/sbin/sshd -D&",
+ prompt="mininet>",
+ timeout=10 )
+ response = self.execute(
+ cmd="h4 /usr/sbin/sshd -D&",
+ prompt="mininet>",
+ timeout=10 )
for key in connectargs:
- vars(self)[key] = connectargs[key]
- response = self.execute(cmd="xterm h1 h4 ",prompt="mininet>",timeout=10)
+ vars( self )[ key ] = connectargs[ key ]
+ response = self.execute(
+ cmd="xterm h1 h4 ",
+ prompt="mininet>",
+ timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
import time
- time.sleep(20)
+ time.sleep( 20 )
if self.flag == 0:
self.flag = 1
return main.FALSE
- else :
+ else:
return main.TRUE
-
- def changeIP(self,host,intf,newIP,newNetmask):
- '''
- Changes the ip address of a host on the fly
- Ex: h2 ifconfig h2-eth0 10.0.1.2 netmask 255.255.255.0
- '''
+ def changeIP( self, host, intf, newIP, newNetmask ):
+ """
+ Changes the ip address of a host on the fly
+ Ex: h2 ifconfig h2-eth0 10.0.1.2 netmask 255.255.255.0"""
if self.handle:
try:
- cmd = host+" ifconfig "+intf+" "+newIP+" "+'netmask'+" "+newNetmask
- self.handle.sendline(cmd)
- self.handle.expect("mininet>")
+ cmd = host + " ifconfig " + intf + " " + \
+ newIP + " " + 'netmask' + " " + newNetmask
+ self.handle.sendline( cmd )
+ self.handle.expect( "mininet>" )
response = self.handle.before
- main.log.info("response = "+response)
- main.log.info("Ip of host "+host+" changed to new IP "+newIP)
+ main.log.info( "response = " + response )
+ main.log.info(
+ "Ip of host " +
+ host +
+ " changed to new IP " +
+ newIP )
return main.TRUE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
return main.FALSE
- def changeDefaultGateway(self,host,newGW):
- '''
- Changes the default gateway of a host
- Ex: h1 route add default gw 10.0.1.2
- '''
+ def changeDefaultGateway( self, host, newGW ):
+ """
+ Changes the default gateway of a host
+ Ex: h1 route add default gw 10.0.1.2"""
if self.handle:
try:
- cmd = host+" route add default gw "+newGW
- self.handle.sendline(cmd)
- self.handle.expect("mininet>")
+ cmd = host + " route add default gw " + newGW
+ self.handle.sendline( cmd )
+ self.handle.expect( "mininet>" )
response = self.handle.before
- main.log.info("response = "+response)
- main.log.info("Default gateway of host "+host+" changed to "+newGW)
+ main.log.info( "response = " + response )
+ main.log.info(
+ "Default gateway of host " +
+ host +
+ " changed to " +
+ newGW )
return main.TRUE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
return main.FALSE
- def addStaticMACAddress(self,host,GW,macaddr):
- '''
- Changes the mac address of a geateway host
- '''
+ def addStaticMACAddress( self, host, GW, macaddr ):
+ """
+ Changes the mac address of a geateway host"""
if self.handle:
try:
- #h1 arp -s 10.0.1.254 00:00:00:00:11:11
- cmd = host+" arp -s "+GW+" "+macaddr
- self.handle.sendline(cmd)
- self.handle.expect("mininet>")
+ # h1 arp -s 10.0.1.254 00:00:00:00:11:11
+ cmd = host + " arp -s " + GW + " " + macaddr
+ self.handle.sendline( cmd )
+ self.handle.expect( "mininet>" )
response = self.handle.before
- main.log.info("response = "+response)
- main.log.info("Mac adrress of gateway "+GW+" changed to "+macaddr)
+ main.log.info( "response = " + response )
+ main.log.info(
+ "Mac adrress of gateway " +
+ GW +
+ " changed to " +
+ macaddr )
return main.TRUE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
return main.FALSE
- def verifyStaticGWandMAC(self,host):
- '''
- Verify if the static gateway and mac address assignment
- '''
+ def verifyStaticGWandMAC( self, host ):
+ """
+ Verify if the static gateway and mac address assignment"""
if self.handle:
try:
- #h1 arp -an
- cmd = host+" arp -an "
- self.handle.sendline(cmd)
- self.handle.expect("mininet>")
+ # h1 arp -an
+ cmd = host + " arp -an "
+ self.handle.sendline( cmd )
+ self.handle.expect( "mininet>" )
response = self.handle.before
- main.log.info(host+" arp -an = "+response)
+ main.log.info( host + " arp -an = " + response )
return main.TRUE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
return main.FALSE
-
-
- def getMacAddress(self,host):
- '''
- Verifies the host's ip configured or not.
- '''
- if self.handle :
+ def getMacAddress( self, host ):
+ """
+ Verifies the host's ip configured or not."""
+ if self.handle:
try:
- response = self.execute(cmd=host+" ifconfig",prompt="mininet>",timeout=10)
+ response = self.execute(
+ cmd=host +
+ " ifconfig",
+ prompt="mininet>",
+ timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
pattern = r'HWaddr\s([0-9A-F]{2}[:-]){5}([0-9A-F]{2})'
- mac_address_search = re.search(pattern, response, re.I)
- mac_address = mac_address_search.group().split(" ")[1]
- main.log.info(self.name+": Mac-Address of Host "+ host + " is " + mac_address)
- return mac_address
- else :
- main.log.error(self.name+": Connection failed to the host")
-
- def getInterfaceMACAddress(self,host, interface):
- '''
- Return the IP address of the interface on the given host
- '''
- if self.handle :
- try:
- response = self.execute(cmd=host+" ifconfig " + interface,
- prompt="mininet>",timeout=10)
- except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
- main.cleanup()
- main.exit()
-
- pattern = r'HWaddr\s([0-9A-F]{2}[:-]){5}([0-9A-F]{2})'
- mac_address_search = re.search(pattern, response, re.I)
- if mac_address_search is None:
- main.log.info("No mac address found in %s" % response)
- return main.FALSE
- mac_address = mac_address_search.group().split(" ")[1]
- main.log.info("Mac-Address of "+ host + ":"+ interface + " is " + mac_address)
+ mac_address_search = re.search( pattern, response, re.I )
+ mac_address = mac_address_search.group().split( " " )[ 1 ]
+ main.log.info(
+ self.name +
+ ": Mac-Address of Host " +
+ host +
+ " is " +
+ mac_address )
return mac_address
else:
- main.log.error("Connection failed to the host")
+ main.log.error( self.name + ": Connection failed to the host" )
- def getIPAddress(self,host):
- '''
- Verifies the host's ip configured or not.
- '''
- if self.handle :
+ def getInterfaceMACAddress( self, host, interface ):
+ """
+ Return the IP address of the interface on the given host"""
+ if self.handle:
try:
- response = self.execute(cmd=host+" ifconfig",prompt="mininet>",timeout=10)
+ response = self.execute( cmd=host + " ifconfig " + interface,
+ prompt="mininet>", timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
+ main.cleanup()
+ main.exit()
+
+ pattern = r'HWaddr\s([0-9A-F]{2}[:-]){5}([0-9A-F]{2})'
+ mac_address_search = re.search( pattern, response, re.I )
+ if mac_address_search is None:
+ main.log.info( "No mac address found in %s" % response )
+ return main.FALSE
+ mac_address = mac_address_search.group().split( " " )[ 1 ]
+ main.log.info(
+ "Mac-Address of " +
+ host +
+ ":" +
+ interface +
+ " is " +
+ mac_address )
+ return mac_address
+ else:
+ main.log.error( "Connection failed to the host" )
+
+ def getIPAddress( self, host ):
+ """
+ Verifies the host's ip configured or not."""
+ if self.handle:
+ try:
+ response = self.execute(
+ cmd=host +
+ " ifconfig",
+ prompt="mininet>",
+ timeout=10 )
+ except pexpect.EOF:
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
pattern = "inet\saddr:(\d+\.\d+\.\d+\.\d+)"
- ip_address_search = re.search(pattern, response)
- main.log.info(self.name+": IP-Address of Host "+host +" is "+ip_address_search.group(1))
- return ip_address_search.group(1)
- else :
- main.log.error(self.name+": Connection failed to the host")
+ ip_address_search = re.search( pattern, response )
+ main.log.info(
+ self.name +
+ ": IP-Address of Host " +
+ host +
+ " is " +
+ ip_address_search.group( 1 ) )
+ return ip_address_search.group( 1 )
+ else:
+ main.log.error( self.name + ": Connection failed to the host" )
- def getSwitchDPID(self,switch):
- '''
- return the datapath ID of the switch
- '''
- if self.handle :
+ def getSwitchDPID( self, switch ):
+ """
+ return the datapath ID of the switch"""
+ if self.handle:
cmd = "py %s.dpid" % switch
try:
- response = self.execute(cmd=cmd,prompt="mininet>",timeout=10)
+ response = self.execute(
+ cmd=cmd,
+ prompt="mininet>",
+ timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
pattern = r'^(?P<dpid>\w)+'
- result = re.search(pattern, response, re.MULTILINE)
+ result = re.search( pattern, response, re.MULTILINE )
if result is None:
- main.log.info("Couldn't find DPID for switch '', found: %s" % (switch, response))
+ main.log.info(
+ "Couldn't find DPID for switch %s, found: %s" %
+ ( switch, response ) )
return main.FALSE
- return str(result.group(0)).lower()
+ return str( result.group( 0 ) ).lower()
else:
- main.log.error("Connection failed to the host")
+ main.log.error( "Connection failed to the host" )
- def getDPID(self, switch):
+ def getDPID( self, switch ):
if self.handle:
- self.handle.sendline("")
- self.expect("mininet>")
- cmd = "py %s.dpid" %switch
+ self.handle.sendline( "" )
+ self.expect( "mininet>" )
+ cmd = "py %s.dpid" % switch
try:
- response = self.execute(cmd=cmd,prompt="mininet>",timeout=10)
- self.handle.expect("mininet>")
+ response = self.execute(
+ cmd=cmd,
+ prompt="mininet>",
+ timeout=10 )
+ self.handle.expect( "mininet>" )
response = self.handle.before
return response
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
-
- def getInterfaces(self, node):
- '''
- return information dict about interfaces connected to the node
- '''
- if self.handle :
- cmd = 'py "\\n".join(["name=%s,mac=%s,ip=%s,enabled=%s" % (i.name, i.MAC(), i.IP(), i.isUp())'
+ def getInterfaces( self, node ):
+ """
+ return information dict about interfaces connected to the node"""
+ if self.handle:
+ cmd = 'py "\\n".join(["name=%s,mac=%s,ip=%s,enabled=%s"' +\
+ ' % (i.name, i.MAC(), i.IP(), i.isUp())'
cmd += ' for i in %s.intfs.values()])' % node
try:
- response = self.execute(cmd=cmd,prompt="mininet>",timeout=10)
+ response = self.execute(
+ cmd=cmd,
+ prompt="mininet>",
+ timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
return response
else:
- main.log.error("Connection failed to the node")
+ main.log.error( "Connection failed to the node" )
- def dump(self):
- main.log.info(self.name+": Dump node info")
+ def dump( self ):
+ main.log.info( self.name + ": Dump node info" )
try:
- response = self.execute(cmd = 'dump',prompt = 'mininet>',timeout = 10)
+ response = self.execute(
+ cmd='dump',
+ prompt='mininet>',
+ timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
return response
- def intfs(self):
- main.log.info(self.name+": List interfaces")
+ def intfs( self ):
+ main.log.info( self.name + ": List interfaces" )
try:
- response = self.execute(cmd = 'intfs',prompt = 'mininet>',timeout = 10)
+ response = self.execute(
+ cmd='intfs',
+ prompt='mininet>',
+ timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
return response
- def net(self):
- main.log.info(self.name+": List network connections")
+ def net( self ):
+ main.log.info( self.name + ": List network connections" )
try:
- response = self.execute(cmd = 'net',prompt = 'mininet>',timeout = 10)
+ response = self.execute( cmd='net', prompt='mininet>', timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
return response
- '''
- def iperf(self,host1,host2):
- main.log.info(self.name+": Simple iperf TCP test between two (optionally specified) hosts")
+
+ def iperf( self, host1, host2 ):
+ main.log.info(
+ self.name +
+ ": Simple iperf TCP test between two hosts" )
try:
- if not host1 and not host2:
- response = self.execute(cmd = 'iperf',prompt = 'mininet>',timeout = 10)
- else:
- cmd1 = 'iperf '+ host1 + " " + host2
- response = self.execute(cmd = cmd1, prompt = '>',timeout = 20)
- except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
- main.cleanup()
- main.exit()
- return response
- '''
- def iperf(self,host1,host2):
- main.log.info(self.name+": Simple iperf TCP test between two hosts")
- try:
- cmd1 = 'iperf '+ host1 + " " + host2
- self.handle.sendline(cmd1)
- self.handle.expect("mininet>")
+ cmd1 = 'iperf ' + host1 + " " + host2
+ self.handle.sendline( cmd1 )
+ self.handle.expect( "mininet>" )
response = self.handle.before
- if re.search('Results:',response):
- main.log.info(self.name+": iperf test succssful")
+ if re.search( 'Results:', response ):
+ main.log.info( self.name + ": iperf test succssful" )
return main.TRUE
else:
- main.log.error(self.name+": iperf test failed")
- return main.FALSE
+ main.log.error( self.name + ": iperf test failed" )
+ return main.FALSE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
- def iperfudp(self):
- main.log.info(self.name+": Simple iperf TCP test between two (optionally specified) hosts")
+ def iperfudp( self ):
+ main.log.info(
+ self.name +
+ ": Simple iperf TCP test between two " +
+ "(optionally specified) hosts" )
try:
- response = self.execute(cmd = 'iperfudp',prompt = 'mininet>',timeout = 10)
+ response = self.execute(
+ cmd='iperfudp',
+ prompt='mininet>',
+ timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
return response
- def nodes(self):
- main.log.info(self.name+": List all nodes.")
+ def nodes( self ):
+ main.log.info( self.name + ": List all nodes." )
try:
- response = self.execute(cmd = 'nodes',prompt = 'mininet>',timeout = 10)
+ response = self.execute(
+ cmd='nodes',
+ prompt='mininet>',
+ timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
return response
- def pingpair(self):
- main.log.info(self.name+": Ping between first two hosts")
+ def pingpair( self ):
+ main.log.info( self.name + ": Ping between first two hosts" )
try:
- response = self.execute(cmd = 'pingpair',prompt = 'mininet>',timeout = 20)
+ response = self.execute(
+ cmd='pingpair',
+ prompt='mininet>',
+ timeout=20 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
- #if utilities.assert_matches(expect='0% packet loss',actual=response,onpass="No Packet loss",onfail="Hosts not reachable"):
- if re.search(',\s0\%\spacket\sloss',response):
- main.log.info(self.name+": Ping between two hosts SUCCESSFUL")
+ if re.search( ',\s0\%\spacket\sloss', response ):
+ main.log.info( self.name + ": Ping between two hosts SUCCESSFUL" )
main.last_result = main.TRUE
return main.TRUE
- else :
- main.log.error(self.name+": PACKET LOST, HOSTS NOT REACHABLE")
+ else:
+ main.log.error( self.name + ": PACKET LOST, HOSTS NOT REACHABLE" )
main.last_result = main.FALSE
return main.FALSE
- def link(self,**linkargs):
- '''
- Bring link(s) between two nodes up or down
- '''
- args = utilities.parse_args(["END1","END2","OPTION"],**linkargs)
- end1 = args["END1"] if args["END1"] != None else ""
- end2 = args["END2"] if args["END2"] != None else ""
- option = args["OPTION"] if args["OPTION"] != None else ""
- main.log.info("Bring link between '"+ end1 +"' and '" + end2 + "' '" + option + "'")
- command = "link "+str(end1) + " " + str(end2)+ " " + str(option)
+ def link( self, **linkargs ):
+ """
+ Bring link( s ) between two nodes up or down"""
+ args = utilities.parse_args( [ "END1", "END2", "OPTION" ], **linkargs )
+ end1 = args[ "END1" ] if args[ "END1" ] is not None else ""
+ end2 = args[ "END2" ] if args[ "END2" ] is not None else ""
+ option = args[ "OPTION" ] if args[ "OPTION" ] is not None else ""
+ main.log.info(
+ "Bring link between '" +
+ end1 +
+ "' and '" +
+ end2 +
+ "' '" +
+ option +
+ "'" )
+ command = "link " + \
+ str( end1 ) + " " + str( end2 ) + " " + str( option )
try:
- #response = self.execute(cmd=command,prompt="mininet>",timeout=10)
- self.handle.sendline(command)
- self.handle.expect("mininet>")
+ self.handle.sendline( command )
+ self.handle.expect( "mininet>" )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
return main.TRUE
-
- def yank(self,**yankargs):
- '''
- yank a mininet switch interface to a host
- '''
- main.log.info('Yank the switch interface attached to a host')
- args = utilities.parse_args(["SW","INTF"],**yankargs)
- sw = args["SW"] if args["SW"] !=None else ""
- intf = args["INTF"] if args["INTF"] != None else ""
- command = "py "+ str(sw) + '.detach("' + str(intf) + '")'
+ def yank( self, **yankargs ):
+ """
+ yank a mininet switch interface to a host"""
+ main.log.info( 'Yank the switch interface attached to a host' )
+ args = utilities.parse_args( [ "SW", "INTF" ], **yankargs )
+ sw = args[ "SW" ] if args[ "SW" ] is not None else ""
+ intf = args[ "INTF" ] if args[ "INTF" ] is not None else ""
+ command = "py " + str( sw ) + '.detach("' + str(intf) + '")'
try:
- response = self.execute(cmd=command,prompt="mininet>",timeout=10)
+ response = self.execute(
+ cmd=command,
+ prompt="mininet>",
+ timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
- main.cleanup()
- main.exit()
- return main.TRUE
-
- def plug(self, **plugargs):
- '''
- plug the yanked mininet switch interface to a switch
- '''
- main.log.info('Plug the switch interface attached to a switch')
- args = utilities.parse_args(["SW","INTF"],**plugargs)
- sw = args["SW"] if args["SW"] !=None else ""
- intf = args["INTF"] if args["INTF"] != None else ""
- command = "py "+ str(sw) + '.attach("' + str(intf) + '")'
- try:
- response = self.execute(cmd=command,prompt="mininet>",timeout=10)
- except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
return main.TRUE
-
-
- def dpctl(self,**dpctlargs):
- '''
- Run dpctl command on all switches.
- '''
- main.log.info('Run dpctl command on all switches')
- args = utilities.parse_args(["CMD","ARGS"],**dpctlargs)
- cmd = args["CMD"] if args["CMD"] != None else ""
- cmdargs = args["ARGS"] if args["ARGS"] != None else ""
- command = "dpctl "+cmd + " " + str(cmdargs)
+ def plug( self, **plugargs ):
+ """
+ plug the yanked mininet switch interface to a switch"""
+ main.log.info( 'Plug the switch interface attached to a switch' )
+ args = utilities.parse_args( [ "SW", "INTF" ], **plugargs )
+ sw = args[ "SW" ] if args[ "SW" ] is not None else ""
+ intf = args[ "INTF" ] if args[ "INTF" ] is not None else ""
+ command = "py " + str( sw ) + '.attach("' + str(intf) + '")'
try:
- response = self.execute(cmd=command,prompt="mininet>",timeout=10)
+ response = self.execute(
+ cmd=command,
+ prompt="mininet>",
+ timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
return main.TRUE
+ def dpctl( self, **dpctlargs ):
+ """
+ Run dpctl command on all switches."""
+ main.log.info( 'Run dpctl command on all switches' )
+ args = utilities.parse_args( [ "CMD", "ARGS" ], **dpctlargs )
+ cmd = args[ "CMD" ] if args[ "CMD" ] is not None else ""
+ cmdargs = args[ "ARGS" ] if args[ "ARGS" ] is not None else ""
+ command = "dpctl " + cmd + " " + str( cmdargs )
+ try:
+ response = self.execute(
+ cmd=command,
+ prompt="mininet>",
+ timeout=10 )
+ except pexpect.EOF:
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
+ main.cleanup()
+ main.exit()
+ return main.TRUE
- def get_version(self):
- file_input = path+'/lib/Mininet/INSTALL'
- version = super(Mininet, self).get_version()
+ def get_version( self ):
+ file_input = path + '/lib/Mininet/INSTALL'
+ version = super( Mininet, self ).get_version()
pattern = 'Mininet\s\w\.\w\.\w\w*'
- for line in open(file_input,'r').readlines():
- result = re.match(pattern, line)
+ for line in open( file_input, 'r' ).readlines():
+ result = re.match( pattern, line )
if result:
- version = result.group(0)
+ version = result.group( 0 )
return version
- def get_sw_controller(self, sw):
- '''
+ def get_sw_controller( self, sw ):
+ """
Parameters:
sw: The name of an OVS switch. Example "s1"
Return:
- The output of the command from the mininet cli or main.FALSE on timeout
- '''
- command = "sh ovs-vsctl get-controller "+str(sw)
+ The output of the command from the mininet cli
+ or main.FALSE on timeout"""
+ command = "sh ovs-vsctl get-controller " + str( sw )
try:
- response = self.execute(cmd=command, prompt="mininet>", timeout=10)
+ response = self.execute(
+ cmd=command,
+ prompt="mininet>",
+ timeout=10 )
if response:
return response
else:
return main.FALSE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
- def assign_sw_controller(self,**kwargs):
- '''
- count is only needed if there is more than 1 controller
- '''
- args = utilities.parse_args(["COUNT"],**kwargs)
- count = args["COUNT"] if args!={} else 1
+ def assign_sw_controller( self, **kwargs ):
+ """
+ count is only needed if there is more than 1 controller"""
+ args = utilities.parse_args( [ "COUNT" ], **kwargs )
+ count = args[ "COUNT" ] if args != {} else 1
argstring = "SW"
- for j in range(count):
- argstring = argstring + ",IP" + str(j+1) + ",PORT" + str(j+1)
- args = utilities.parse_args(argstring.split(","),**kwargs)
+ for j in range( count ):
+ argstring = argstring + ",IP" + \
+ str( j + 1 ) + ",PORT" + str( j + 1 )
+ args = utilities.parse_args( argstring.split( "," ), **kwargs )
- sw = args["SW"] if args["SW"] != None else ""
- ptcpA = int(args["PORT1"])+int(sw) if args["PORT1"] != None else ""
- ptcpB = "ptcp:"+str(ptcpA) if ptcpA != "" else ""
+ sw = args[ "SW" ] if args[ "SW" ] is not None else ""
+ ptcpA = int( args[ "PORT1" ] ) + \
+ int( sw ) if args[ "PORT1" ] is not None else ""
+ ptcpB = "ptcp:" + str( ptcpA ) if ptcpA != "" else ""
- command = "sh ovs-vsctl set-controller s" + str(sw) + " " + ptcpB + " "
- for j in range(count):
- i=j+1
- args = utilities.parse_args(["IP"+str(i),"PORT"+str(i)],**kwargs)
- ip = args["IP"+str(i)] if args["IP"+str(i)] != None else ""
- port = args["PORT" + str(i)] if args["PORT" + str(i)] != None else ""
- tcp = "tcp:" + str(ip) + ":" + str(port) + " " if ip != "" else ""
+ command = "sh ovs-vsctl set-controller s" + \
+ str( sw ) + " " + ptcpB + " "
+ for j in range( count ):
+ i = j + 1
+ args = utilities.parse_args(
+ [ "IP" + str( i ), "PORT" + str( i ) ], **kwargs )
+ ip = args[
+ "IP" +
+ str( i ) ] if args[
+ "IP" +
+ str( i ) ] is not None else ""
+ port = args[
+ "PORT" +
+ str( i ) ] if args[
+ "PORT" +
+ str( i ) ] is not None else ""
+ tcp = "tcp:" + str( ip ) + ":" + str( port ) + \
+ " " if ip != "" else ""
command = command + tcp
try:
- self.execute(cmd=command,prompt="mininet>",timeout=5)
+ self.execute( cmd=command, prompt="mininet>", timeout=5 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
except:
- main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+ main.log.info( self.name + ":" * 50 )
main.log.error( traceback.print_exc() )
- main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+ main.log.info(":" * 50 )
main.cleanup()
main.exit()
- def delete_sw_controller(self,sw):
- '''
- Removes the controller target from sw
- '''
-
- command = "sh ovs-vsctl del-controller "+str(sw)
+ def delete_sw_controller( self, sw ):
+ """
+ Removes the controller target from sw"""
+ command = "sh ovs-vsctl del-controller " + str( sw )
try:
- response = self.execute(cmd=command,prompt="mininet>",timeout=10)
+ response = self.execute(
+ cmd=command,
+ prompt="mininet>",
+ timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
else:
- main.log.info(response)
+ main.log.info( response )
def add_switch( self, sw, **kwargs ):
- '''
+ """
adds a switch to the mininet topology
NOTE: this uses a custom mn function
NOTE: cannot currently specify what type of switch
@@ -765,117 +899,126 @@
optional keyvalues:
dpid = "dpid"
returns: main.FASLE on an error, else main.TRUE
- '''
- dpid = kwargs.get('dpid', '')
+ """
+ dpid = kwargs.get( 'dpid', '' )
command = "addswitch " + str( sw ) + " " + str( dpid )
try:
- response = self.execute(cmd=command,prompt="mininet>",timeout=10)
- if re.search("already exists!", response):
- main.log.warn(response)
+ response = self.execute(
+ cmd=command,
+ prompt="mininet>",
+ timeout=10 )
+ if re.search( "already exists!", response ):
+ main.log.warn( response )
return main.FALSE
- elif re.search("Error", response):
- main.log.warn(response)
+ elif re.search( "Error", response ):
+ main.log.warn( response )
return main.FALSE
- elif re.search("usage:", response):
- main.log.warn(response)
+ elif re.search( "usage:", response ):
+ main.log.warn( response )
return main.FALSE
else:
return main.TRUE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
def del_switch( self, sw ):
- '''
- delete a switch from the mininet topology
- NOTE: this uses a custom mn function
- required params:
+ """
+ delete a switch from the mininet topology
+ NOTE: this uses a custom mn function
+ required params:
switchname = name of the switch as a string
- returns: main.FASLE on an error, else main.TRUE
- '''
+ returns: main.FASLE on an error, else main.TRUE"""
command = "delswitch " + str( sw )
try:
- response = self.execute(cmd=command,prompt="mininet>",timeout=10)
- if re.search("no switch named", response):
- main.log.warn(response)
+ response = self.execute(
+ cmd=command,
+ prompt="mininet>",
+ timeout=10 )
+ if re.search( "no switch named", response ):
+ main.log.warn( response )
return main.FALSE
- elif re.search("Error", response):
- main.log.warn(response)
+ elif re.search( "Error", response ):
+ main.log.warn( response )
return main.FALSE
- elif re.search("usage:", response):
- main.log.warn(response)
+ elif re.search( "usage:", response ):
+ main.log.warn( response )
return main.FALSE
else:
return main.TRUE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
def add_link( self, node1, node2 ):
- '''
- add a link to the mininet topology
- NOTE: this uses a custom mn function
- NOTE: cannot currently specify what type of link
- required params:
- node1 = the string node name of the first endpoint of the link
- node2 = the string node name of the second endpoint of the link
- returns: main.FASLE on an error, else main.TRUE
- '''
+ """
+ add a link to the mininet topology
+ NOTE: this uses a custom mn function
+ NOTE: cannot currently specify what type of link
+ required params:
+ node1 = the string node name of the first endpoint of the link
+ node2 = the string node name of the second endpoint of the link
+ returns: main.FASLE on an error, else main.TRUE"""
command = "addlink " + str( node1 ) + " " + str( node2 )
try:
- response = self.execute(cmd=command,prompt="mininet>",timeout=10)
- if re.search("doesnt exist!", response):
- main.log.warn(response)
+ response = self.execute(
+ cmd=command,
+ prompt="mininet>",
+ timeout=10 )
+ if re.search( "doesnt exist!", response ):
+ main.log.warn( response )
return main.FALSE
- elif re.search("Error", response):
- main.log.warn(response)
+ elif re.search( "Error", response ):
+ main.log.warn( response )
return main.FALSE
- elif re.search("usage:", response):
- main.log.warn(response)
+ elif re.search( "usage:", response ):
+ main.log.warn( response )
return main.FALSE
else:
return main.TRUE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
def del_link( self, node1, node2 ):
- '''
- delete a link from the mininet topology
- NOTE: this uses a custom mn function
- required params:
- node1 = the string node name of the first endpoint of the link
- node2 = the string node name of the second endpoint of the link
- returns: main.FASLE on an error, else main.TRUE
- '''
+ """
+ delete a link from the mininet topology
+ NOTE: this uses a custom mn function
+ required params:
+ node1 = the string node name of the first endpoint of the link
+ node2 = the string node name of the second endpoint of the link
+ returns: main.FASLE on an error, else main.TRUE"""
command = "dellink " + str( node1 ) + " " + str( node2 )
try:
- response = self.execute(cmd=command,prompt="mininet>",timeout=10)
- if re.search("no node named", response):
- main.log.warn(response)
+ response = self.execute(
+ cmd=command,
+ prompt="mininet>",
+ timeout=10 )
+ if re.search( "no node named", response ):
+ main.log.warn( response )
return main.FALSE
- elif re.search("Error", response):
- main.log.warn(response)
+ elif re.search( "Error", response ):
+ main.log.warn( response )
return main.FALSE
- elif re.search("usage:", response):
- main.log.warn(response)
+ elif re.search( "usage:", response ):
+ main.log.warn( response )
return main.FALSE
else:
return main.TRUE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
def add_host( self, hostname, **kwargs ):
- '''
+ """
Add a host to the mininet topology
NOTE: this uses a custom mn function
NOTE: cannot currently specify what type of host
@@ -884,255 +1027,308 @@
optional key-value params
switch = "switch name"
returns: main.FASLE on an error, else main.TRUE
- '''
- switch = kwargs.get('switch', '')
+ """
+ switch = kwargs.get( 'switch', '' )
command = "addhost " + str( hostname ) + " " + str( switch )
try:
- response = self.execute(cmd=command,prompt="mininet>",timeout=10)
- if re.search("already exists!", response):
- main.log.warn(response)
+ response = self.execute(
+ cmd=command,
+ prompt="mininet>",
+ timeout=10 )
+ if re.search( "already exists!", response ):
+ main.log.warn( response )
return main.FALSE
- elif re.search("doesnt exists!", response):
- main.log.warn(response)
+ elif re.search( "doesnt exists!", response ):
+ main.log.warn( response )
return main.FALSE
- elif re.search("Error", response):
- main.log.warn(response)
+ elif re.search( "Error", response ):
+ main.log.warn( response )
return main.FALSE
- elif re.search("usage:", response):
- main.log.warn(response)
+ elif re.search( "usage:", response ):
+ main.log.warn( response )
return main.FALSE
else:
return main.TRUE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
def del_host( self, hostname ):
- '''
- delete a host from the mininet topology
- NOTE: this uses a custom mn function
- required params:
- hostname = the string hostname
- returns: main.FASLE on an error, else main.TRUE
- '''
+ """
+ delete a host from the mininet topology
+ NOTE: this uses a custom mn function
+ required params:
+ hostname = the string hostname
+ returns: main.FASLE on an error, else main.TRUE"""
command = "delhost " + str( hostname )
try:
- response = self.execute(cmd=command,prompt="mininet>",timeout=10)
- if re.search("no host named", response):
- main.log.warn(response)
+ response = self.execute(
+ cmd=command,
+ prompt="mininet>",
+ timeout=10 )
+ if re.search( "no host named", response ):
+ main.log.warn( response )
return main.FALSE
- elif re.search("Error", response):
- main.log.warn(response)
+ elif re.search( "Error", response ):
+ main.log.warn( response )
return main.FALSE
- elif re.search("usage:", response):
- main.log.warn(response)
+ elif re.search( "usage:", response ):
+ main.log.warn( response )
return main.FALSE
else:
return main.TRUE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
- def disconnect(self):
- main.log.info(self.name+": Disconnecting mininet...")
+ def disconnect( self ):
+ main.log.info( self.name + ": Disconnecting mininet..." )
response = ''
if self.handle:
try:
- response = self.execute(cmd="exit",prompt="(.*)",timeout=120)
- response = self.execute(cmd="exit",prompt="(.*)",timeout=120)
- self.handle.sendline("sudo mn -c")
+ response = self.execute(
+ cmd="exit",
+ prompt="(.*)",
+ timeout=120 )
+ response = self.execute(
+ cmd="exit",
+ prompt="(.*)",
+ timeout=120 )
+ self.handle.sendline( "sudo mn -c" )
response = main.TRUE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
- else :
- main.log.error(self.name+": Connection failed to the host")
+ else:
+ main.log.error( self.name + ": Connection failed to the host" )
response = main.FALSE
return response
- def arping(self, src, dest, destmac):
- self.handle.sendline('')
- self.handle.expect(["mininet",pexpect.EOF,pexpect.TIMEOUT])
+ def arping( self, src, dest, destmac ):
+ self.handle.sendline( '' )
+ self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
- self.handle.sendline(src + ' arping ' + dest)
+ self.handle.sendline( src + ' arping ' + dest )
try:
- self.handle.expect([destmac,pexpect.EOF,pexpect.TIMEOUT])
- main.log.info(self.name+": ARP successful")
- self.handle.expect(["mininet",pexpect.EOF,pexpect.TIMEOUT])
+ self.handle.expect( [ destmac, pexpect.EOF, pexpect.TIMEOUT ] )
+ main.log.info( self.name + ": ARP successful" )
+ self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
return main.TRUE
except:
- main.log.warn(self.name+": ARP FAILURE")
- self.handle.expect(["mininet",pexpect.EOF,pexpect.TIMEOUT])
+ main.log.warn( self.name + ": ARP FAILURE" )
+ self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
return main.FALSE
- def decToHex(num):
- return hex(num).split('x')[1]
+ def decToHex( self, num ):
+ return hex( num ).split( 'x' )[ 1 ]
- def getSwitchFlowCount(self, switch):
- '''
- return the Flow Count of the switch
- '''
+ def getSwitchFlowCount( self, switch ):
+ """
+ return the Flow Count of the switch"""
if self.handle:
cmd = "sh ovs-ofctl dump-aggregate %s" % switch
try:
- response = self.execute(cmd=cmd, prompt="mininet>", timeout=10)
+ response = self.execute(
+ cmd=cmd,
+ prompt="mininet>",
+ timeout=10 )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + " " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + " " + self.handle.before )
main.cleanup()
main.exit()
pattern = "flow_count=(\d+)"
- result = re.search(pattern, response, re.MULTILINE)
+ result = re.search( pattern, response, re.MULTILINE )
if result is None:
- main.log.info("Couldn't find flows on switch '', found: %s" % (switch, response))
+ main.log.info(
+ "Couldn't find flows on switch %s, found: %s" %
+ ( switch, response ) )
return main.FALSE
- return result.group(1)
+ return result.group( 1 )
else:
- main.log.error("Connection failed to the Mininet host")
+ main.log.error( "Connection failed to the Mininet host" )
- def check_flows(self, sw, dump_format=None):
+ def check_flows( self, sw, dump_format=None ):
if dump_format:
- command = "sh ovs-ofctl -F " + dump_format + " dump-flows " + str(sw)
+ command = "sh ovs-ofctl -F " + \
+ dump_format + " dump-flows " + str( sw )
else:
- command = "sh ovs-ofctl dump-flows "+str(sw)
+ command = "sh ovs-ofctl dump-flows " + str( sw )
try:
- response=self.execute(cmd=command,prompt="mininet>",timeout=10)
+ response = self.execute(
+ cmd=command,
+ prompt="mininet>",
+ timeout=10 )
return response
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
else:
- main.log.info(response)
+ main.log.info( response )
- def start_tcpdump(self, filename, intf = "eth0", port = "port 6633"):
- '''
- Runs tpdump on an intferface and saves the file
- intf can be specified, or the default eth0 is used
- '''
+ def start_tcpdump( self, filename, intf="eth0", port="port 6633" ):
+ """
+ Runs tpdump on an intferface and saves the file
+ intf can be specified, or the default eth0 is used"""
try:
- self.handle.sendline("")
- self.handle.expect("mininet>")
- self.handle.sendline("sh sudo tcpdump -n -i "+ intf + " " + port + " -w " + filename.strip() + " &")
- self.handle.sendline("")
- i=self.handle.expect(['No\ssuch\device','listening\son',pexpect.TIMEOUT,"mininet>"],timeout=10)
- main.log.warn(self.handle.before + self.handle.after)
- self.handle.sendline("")
- self.handle.expect("mininet>")
+ self.handle.sendline( "" )
+ self.handle.expect( "mininet>" )
+ self.handle.sendline(
+ "sh sudo tcpdump -n -i " +
+ intf +
+ " " +
+ port +
+ " -w " +
+ filename.strip() +
+ " &" )
+ self.handle.sendline( "" )
+ i = self.handle.expect( [ 'No\ssuch\device',
+ 'listening\son',
+ pexpect.TIMEOUT,
+ "mininet>" ],
+ timeout=10 )
+ main.log.warn( self.handle.before + self.handle.after )
+ self.handle.sendline( "" )
+ self.handle.expect( "mininet>" )
if i == 0:
- main.log.error(self.name + ": tcpdump - No such device exists. tcpdump attempted on: " + intf)
+ main.log.error(
+ self.name +
+ ": tcpdump - No such device exists. " +
+ "tcpdump attempted on: " +
+ intf )
return main.FALSE
elif i == 1:
- main.log.info(self.name + ": tcpdump started on " + intf)
+ main.log.info( self.name + ": tcpdump started on " + intf )
return main.TRUE
elif i == 2:
- main.log.error(self.name + ": tcpdump command timed out! Check interface name, given interface was: " + intf)
+ main.log.error(
+ self.name +
+ ": tcpdump command timed out! Check interface name," +
+ " given interface was: " +
+ intf )
return main.FALSE
- elif i ==3:
- main.log.info(self.name +": " + self.handle.before)
+ elif i == 3:
+ main.log.info( self.name + ": " + self.handle.before )
return main.TRUE
else:
- main.log.error(self.name + ": tcpdump - unexpected response")
+ main.log.error( self.name + ": tcpdump - unexpected response" )
return main.FALSE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
except:
- main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+ main.log.info( self.name + ":" * 50 )
main.log.error( traceback.print_exc() )
- main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+ main.log.info(":" * 50 )
main.cleanup()
main.exit()
- def stop_tcpdump(self):
+ def stop_tcpdump( self ):
"pkills tcpdump"
try:
- self.handle.sendline("sh sudo pkill tcpdump")
- self.handle.expect("mininet>")
- self.handle.sendline("")
- self.handle.expect("mininet>")
+ self.handle.sendline( "sh sudo pkill tcpdump" )
+ self.handle.expect( "mininet>" )
+ self.handle.sendline( "" )
+ self.handle.expect( "mininet>" )
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
except:
- main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+ main.log.info( self.name + ":" * 50 )
main.log.error( traceback.print_exc() )
- main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+ main.log.info(":" * 50 )
main.cleanup()
main.exit()
- def compare_switches(self, topo, switches_json):
- '''
- Compare mn and onos switches
- topo: sts TestONTopology object
- switches_json: parsed json object from the onos devices api
+ def compare_switches( self, topo, switches_json ):
+ """
+ Compare mn and onos switches
+ topo: sts TestONTopology object
+ switches_json: parsed json object from the onos devices api
- This uses the sts TestONTopology object
-
- '''
- import json
- #main.log.debug("Switches_json string: ", switches_json)
- output = {"switches":[]}
- for switch in topo.graph.switches: #iterate through the MN topology and pull out switches and and port info
+ This uses the sts TestONTopology object"""
+ # main.log.debug( "Switches_json string: ", switches_json )
+ output = { "switches": [] }
+ # iterate through the MN topology and pull out switches and and port
+ # info
+ for switch in topo.graph.switches:
ports = []
for port in switch.ports.values():
- ports.append({'of_port': port.port_no, 'mac': str(port.hw_addr).replace('\'',''), 'name': port.name})
- output['switches'].append({"name": switch.name, "dpid": str(switch.dpid).zfill(16), "ports": ports })
+ ports.append( { 'of_port': port.port_no,
+ 'mac': str( port.hw_addr ).replace( '\'',
+ ''),
+ 'name': port.name } )
+ output[ 'switches' ].append( {
+ "name": switch.name,
+ "dpid": str( switch.dpid ).zfill( 16 ),
+ "ports": ports } )
- #print "mn"
- #print json.dumps(output, sort_keys=True,indent=4,separators=(',', ': '))
- #print "onos"
- #print json.dumps(switches_json, sort_keys=True,indent=4,separators=(',', ': '))
-
+ # print "mn"
+ # print json.dumps( output,
+ # sort_keys=True,
+ # indent=4,
+ # separators=( ',', ': ' ) )
+ # print "onos"
+ # print json.dumps( switches_json,
+ # sort_keys=True,
+ # indent=4,
+ # separators=( ',', ': ' ) )
# created sorted list of dpid's in MN and ONOS for comparison
- mnDPIDs=[]
- for switch in output['switches']:
- mnDPIDs.append(switch['dpid'].lower())
+ mnDPIDs = []
+ for switch in output[ 'switches' ]:
+ mnDPIDs.append( switch[ 'dpid' ].lower() )
mnDPIDs.sort()
- #print "List of Mininet switch DPID's"
- #print mnDPIDs
- if switches_json == "":#if rest call fails
- main.log.error(self.name + ".compare_switches(): Empty JSON object given from ONOS")
+ # print "List of Mininet switch DPID's"
+ # print mnDPIDs
+ if switches_json == "": # if rest call fails
+ main.log.error(
+ self.name +
+ ".compare_switches(): Empty JSON object given from ONOS" )
return main.FALSE
- onos=switches_json
- onosDPIDs=[]
+ onos = switches_json
+ onosDPIDs = []
for switch in onos:
- if switch['available'] == True:
- onosDPIDs.append(switch['id'].replace(":",'').replace("of",'').lower())
- #else:
- #print "Switch is unavailable:"
- #print switch
+ if switch[ 'available' ]:
+ onosDPIDs.append(
+ switch[ 'id' ].replace(
+ ":",
+ '' ).replace(
+ "of",
+ '' ).lower() )
+ # else:
+ # print "Switch is unavailable:"
+ # print switch
onosDPIDs.sort()
- #print "List of ONOS switch DPID's"
- #print onosDPIDs
+ # print "List of ONOS switch DPID's"
+ # print onosDPIDs
- if mnDPIDs!=onosDPIDs:
+ if mnDPIDs != onosDPIDs:
switch_results = main.FALSE
- main.log.report( "Switches in MN but not in ONOS:")
- main.log.report( str([switch for switch in mnDPIDs if switch not in onosDPIDs]))
- main.log.report( "Switches in ONOS but not in MN:")
- main.log.report( str([switch for switch in onosDPIDs if switch not in mnDPIDs]))
- else:#list of dpid's match in onos and mn
- #main.log.report("DEBUG: The dpid's of the switches in Mininet and ONOS match")
+ main.log.report( "Switches in MN but not in ONOS:" )
+ list1 = [ switch for switch in mnDPIDs if switch not in onosDPIDs ]
+ main.log.report( str( list1 ) )
+ main.log.report( "Switches in ONOS but not in MN:" )
+ list2 = [ switch for switch in onosDPIDs if switch not in mnDPIDs ]
+ main.log.report(str( list2 ) )
+ else: # list of dpid's match in onos and mn
switch_results = main.TRUE
return switch_results
-
-
- def compare_ports(self, topo, ports_json):
- '''
+ def compare_ports( self, topo, ports_json ):
+ """
Compare mn and onos ports
topo: sts TestONTopology object
ports_json: parsed json object from the onos ports api
@@ -1141,258 +1337,293 @@
1. This uses the sts TestONTopology object
2. numpy - "sudo pip install numpy"
- '''
- #FIXME: this does not look for extra ports in ONOS, only checks that ONOS has what is in MN
- import json
+ """
+ # FIXME: this does not look for extra ports in ONOS, only checks that
+ # ONOS has what is in MN
from numpy import uint64
ports_results = main.TRUE
- output = {"switches":[]}
- for switch in topo.graph.switches: #iterate through the MN topology and pull out switches and and port info
+ output = { "switches": [] }
+ # iterate through the MN topology and pull out switches and and port
+ # info
+ for switch in topo.graph.switches:
ports = []
for port in switch.ports.values():
- #print port.hw_addr.toStr(separator = '')
+ # print port.hw_addr.toStr( separator='' )
tmp_port = {}
- tmp_port['of_port'] = port.port_no
- tmp_port['mac'] = str(port.hw_addr).replace('\'','')
- tmp_port['name'] = port.name
- tmp_port['enabled'] = port.enabled
+ tmp_port[ 'of_port' ] = port.port_no
+ tmp_port[ 'mac' ] = str( port.hw_addr ).replace( '\'', '' )
+ tmp_port[ 'name' ] = port.name
+ tmp_port[ 'enabled' ] = port.enabled
- ports.append(tmp_port)
+ ports.append( tmp_port )
tmp_switch = {}
- tmp_switch['name'] = switch.name
- tmp_switch['dpid'] = str(switch.dpid).zfill(16)
- tmp_switch['ports'] = ports
+ tmp_switch[ 'name' ] = switch.name
+ tmp_switch[ 'dpid' ] = str( switch.dpid ).zfill( 16 )
+ tmp_switch[ 'ports' ] = ports
- output['switches'].append(tmp_switch)
+ output[ 'switches' ].append( tmp_switch )
-
- ################ports#############
- for mn_switch in output['switches']:
+ # PORTS
+ for mn_switch in output[ 'switches' ]:
mn_ports = []
onos_ports = []
switch_result = main.TRUE
- for port in mn_switch['ports']:
- if port['enabled'] == True:
- mn_ports.append(port['of_port'])
- #else: #DEBUG only
- # main.log.warn("Port %s on switch %s is down" % ( str(port['of_port']) , str(mn_switch['name'])) )
+ for port in mn_switch[ 'ports' ]:
+ if port[ 'enabled' ]:
+ mn_ports.append( port[ 'of_port' ] )
for onos_switch in ports_json:
- #print "Iterating through a new switch as seen by ONOS"
- #print onos_switch
- if onos_switch['device']['available'] == True:
- if onos_switch['device']['id'].replace(':','').replace("of", '') == mn_switch['dpid']:
- for port in onos_switch['ports']:
- if port['isEnabled']:
- #print "Iterating through available ports on the switch"
- #print port
- if port['port'] == 'local':
- #onos_ports.append('local')
- onos_ports.append(long(uint64(-2)))
+ # print "Iterating through a new switch as seen by ONOS"
+ # print onos_switch
+ if onos_switch[ 'device' ][ 'available' ]:
+ if onos_switch[ 'device' ][ 'id' ].replace(
+ ':',
+ '' ).replace(
+ "of",
+ '' ) == mn_switch[ 'dpid' ]:
+ for port in onos_switch[ 'ports' ]:
+ if port[ 'isEnabled' ]:
+ if port[ 'port' ] == 'local':
+ # onos_ports.append( 'local' )
+ onos_ports.append( long( uint64( -2 ) ) )
else:
- onos_ports.append(int(port['port']))
- '''
- else: #This is likely a new reserved port implemented
- main.log.error("unkown port '" + str(port['port']) )
- '''
- #else: #DEBUG
- # main.log.warn("Port %s on switch %s is down" % ( str(port['port']) , str(onos_switch['device']['id'])) )
+ onos_ports.append( int( port[ 'port' ] ) )
break
- mn_ports.sort(key=float)
- onos_ports.sort(key=float)
- #print "\nPorts for Switch %s:" % (mn_switch['name'])
- #print "\tmn_ports[] = ", mn_ports
- #print "\tonos_ports[] = ", onos_ports
+ mn_ports.sort( key=float )
+ onos_ports.sort( key=float )
+ # print "\nPorts for Switch %s:" % ( mn_switch[ 'name' ] )
+ # print "\tmn_ports[] = ", mn_ports
+ # print "\tonos_ports[] = ", onos_ports
mn_ports_log = mn_ports
onos_ports_log = onos_ports
- mn_ports = [x for x in mn_ports]
- onos_ports = [x for x in onos_ports]
+ mn_ports = [ x for x in mn_ports ]
+ onos_ports = [ x for x in onos_ports ]
- #TODO: handle other reserved port numbers besides LOCAL
- #NOTE: Reserved ports
- # Local port: -2 in Openflow, ONOS shows 'local', we store as long(uint64(-2))
+ # TODO: handle other reserved port numbers besides LOCAL
+ # NOTE: Reserved ports
+ # Local port: -2 in Openflow, ONOS shows 'local', we store as
+ # long( uint64( -2 ) )
for mn_port in mn_ports_log:
if mn_port in onos_ports:
- #don't set results to true here as this is just one of many checks and it might override a failure
- mn_ports.remove(mn_port)
- onos_ports.remove(mn_port)
- #NOTE: OVS reports this as down since there is no link
+ # don't set results to true here as this is just one of
+ # many checks and it might override a failure
+ mn_ports.remove( mn_port )
+ onos_ports.remove( mn_port )
+ # NOTE: OVS reports this as down since there is no link
# So ignoring these for now
- #TODO: Come up with a better way of handling these
+ # TODO: Come up with a better way of handling these
if 65534 in mn_ports:
- mn_ports.remove(65534)
- if long(uint64(-2)) in onos_ports:
- onos_ports.remove( long(uint64(-2)) )
- if len(mn_ports): #the ports of this switch don't match
+ mn_ports.remove( 65534 )
+ if long( uint64( -2 ) ) in onos_ports:
+ onos_ports.remove( long( uint64( -2 ) ) )
+ if len( mn_ports ): # the ports of this switch don't match
switch_result = main.FALSE
- main.log.warn("Ports in MN but not ONOS: " + str(mn_ports) )
- if len(onos_ports): #the ports of this switch don't match
+ main.log.warn( "Ports in MN but not ONOS: " + str( mn_ports ) )
+ if len( onos_ports ): # the ports of this switch don't match
switch_result = main.FALSE
- main.log.warn("Ports in ONOS but not MN: " + str(onos_ports) )
+ main.log.warn(
+ "Ports in ONOS but not MN: " +
+ str( onos_ports ) )
if switch_result == main.FALSE:
- main.log.report("The list of ports for switch %s(%s) does not match:" % (mn_switch['name'], mn_switch['dpid']) )
- main.log.warn("mn_ports[] = " + str(mn_ports_log))
- main.log.warn("onos_ports[] = " + str(onos_ports_log))
+ main.log.report(
+ "The list of ports for switch %s(%s) does not match:" %
+ ( mn_switch[ 'name' ], mn_switch[ 'dpid' ] ) )
+ main.log.warn( "mn_ports[] = " + str( mn_ports_log ) )
+ main.log.warn( "onos_ports[] = " + str( onos_ports_log ) )
ports_results = ports_results and switch_result
return ports_results
+ def compare_links( self, topo, links_json ):
+ """
+ Compare mn and onos links
+ topo: sts TestONTopology object
+ links_json: parsed json object from the onos links api
-
-
- def compare_links(self, topo, links_json):
- '''
- Compare mn and onos links
- topo: sts TestONTopology object
- links_json: parsed json object from the onos links api
-
- This uses the sts TestONTopology object
-
- '''
- #FIXME: this does not look for extra links in ONOS, only checks that ONOS has what is in MN
- import json
+ This uses the sts TestONTopology object"""
+ # FIXME: this does not look for extra links in ONOS, only checks that
+ # ONOS has what is in MN
link_results = main.TRUE
- output = {"switches":[]}
+ output = { "switches": [] }
onos = links_json
- for switch in topo.graph.switches: #iterate through the MN topology and pull out switches and and port info
+ # iterate through the MN topology and pull out switches and and port
+ # info
+ for switch in topo.graph.switches:
# print "Iterating though switches as seen by Mininet"
# print switch
ports = []
for port in switch.ports.values():
- #print port.hw_addr.toStr(separator = '')
- ports.append({'of_port': port.port_no, 'mac': str(port.hw_addr).replace('\'',''), 'name': port.name})
- output['switches'].append({"name": switch.name, "dpid": str(switch.dpid).zfill(16), "ports": ports })
- #######Links########
+ # print port.hw_addr.toStr( separator='' )
+ ports.append( { 'of_port': port.port_no,
+ 'mac': str( port.hw_addr ).replace( '\'',
+ ''),
+ 'name': port.name } )
+ output[ 'switches' ].append( {
+ "name": switch.name,
+ "dpid": str( switch.dpid ).zfill( 16 ),
+ "ports": ports } )
+ # LINKS
- mn_links = [link for link in topo.patch_panel.network_links if (link.port1.enabled and link.port2.enabled)]
- #print "mn_links:"
- #print mn_links
- if 2*len(mn_links) == len(onos):
+ mn_links = [
+ link for link in topo.patch_panel.network_links if (
+ link.port1.enabled and link.port2.enabled ) ]
+ if 2 * len( mn_links ) == len( onos ):
link_results = main.TRUE
else:
link_results = main.FALSE
- main.log.report("Mininet has %i bidirectional links and ONOS has %i unidirectional links" % (len(mn_links), len(onos) ))
+ main.log.report(
+ "Mininet has %i bidirectional links and " +
+ "ONOS has %i unidirectional links" %
+ ( len( mn_links ), len( onos ) ) )
-
- # iterate through MN links and check if an ONOS link exists in both directions
- # NOTE: Will currently only show mn links as down if they are cut through STS.
- # We can either do everything through STS or wait for up_network_links
- # and down_network_links to be fully implemented.
+ # iterate through MN links and check if an ONOS link exists in
+ # both directions
+ # NOTE: Will currently only show mn links as down if they are
+ # cut through STS. We can either do everything through STS or
+ # wait for up_network_links and down_network_links to be
+ # fully implemented.
for link in mn_links:
- #print "Link: %s" % link
- #TODO: Find a more efficient search method
+ # print "Link: %s" % link
+ # TODO: Find a more efficient search method
node1 = None
port1 = None
node2 = None
port2 = None
first_dir = main.FALSE
second_dir = main.FALSE
- for switch in output['switches']:
- #print "Switch: %s" % switch['name']
- if switch['name'] == link.node1.name:
- node1 = switch['dpid']
- for port in switch['ports']:
- if str(port['name']) == str(link.port1):
- port1 = port['of_port']
+ for switch in output[ 'switches' ]:
+ # print "Switch: %s" % switch[ 'name' ]
+ if switch[ 'name' ] == link.node1.name:
+ node1 = switch[ 'dpid' ]
+ for port in switch[ 'ports' ]:
+ if str( port[ 'name' ] ) == str( link.port1 ):
+ port1 = port[ 'of_port' ]
if node1 is not None and node2 is not None:
break
- if switch['name'] == link.node2.name:
- node2 = switch['dpid']
- for port in switch['ports']:
- if str(port['name']) == str(link.port2):
- port2 = port['of_port']
+ if switch[ 'name' ] == link.node2.name:
+ node2 = switch[ 'dpid' ]
+ for port in switch[ 'ports' ]:
+ if str( port[ 'name' ] ) == str( link.port2 ):
+ port2 = port[ 'of_port' ]
if node1 is not None and node2 is not None:
break
-
for onos_link in onos:
- onos_node1 = onos_link['src']['device'].replace(":",'').replace("of", '')
- onos_node2 = onos_link['dst']['device'].replace(":",'').replace("of", '')
- onos_port1 = onos_link['src']['port']
- onos_port2 = onos_link['dst']['port']
+ onos_node1 = onos_link[ 'src' ][ 'device' ].replace(
+ ":",
+ '' ).replace(
+ "of",
+ '' )
+ onos_node2 = onos_link[ 'dst' ][ 'device' ].replace(
+ ":",
+ '' ).replace(
+ "of",
+ '' )
+ onos_port1 = onos_link[ 'src' ][ 'port' ]
+ onos_port2 = onos_link[ 'dst' ][ 'port' ]
- #print "Checking ONOS for link %s/%s -> %s/%s and" % (node1, port1, node2, port2)
- #print "Checking ONOS for link %s/%s -> %s/%s" % (node2, port2, node1, port1)
# check onos link from node1 to node2
- if str(onos_node1) == str(node1) and str(onos_node2) == str(node2):
- if int(onos_port1) == int(port1) and int(onos_port2) == int(port2):
+ if str( onos_node1 ) == str( node1 ) and str(
+ onos_node2 ) == str( node2 ):
+ if int( onos_port1 ) == int( port1 ) and int(
+ onos_port2 ) == int( port2 ):
first_dir = main.TRUE
else:
- main.log.warn('The port numbers do not match for ' +str(link) +\
- ' between ONOS and MN. When cheking ONOS for link '+\
- '%s/%s -> %s/%s' % (node1, port1, node2, port2)+\
- ' ONOS has the values %s/%s -> %s/%s' %\
- (onos_node1, onos_port1, onos_node2, onos_port2))
+ main.log.warn(
+ 'The port numbers do not match for ' +
+ str( link ) +
+ ' between ONOS and MN. When cheking ONOS for ' +
+ 'link %s/%s -> %s/%s' %
+ ( node1,
+ port1,
+ node2,
+ port2 ) +
+ ' ONOS has the values %s/%s -> %s/%s' %
+ ( onos_node1,
+ onos_port1,
+ onos_node2,
+ onos_port2 ) )
# check onos link from node2 to node1
- elif ( str(onos_node1) == str(node2) and str(onos_node2) == str(node1) ):
- if ( int(onos_port1) == int(port2) and int(onos_port2) == int(port1) ):
+ elif ( str( onos_node1 ) == str( node2 ) and
+ str( onos_node2 ) == str( node1 ) ):
+ if ( int( onos_port1 ) == int( port2 )
+ and int( onos_port2 ) == int( port1 ) ):
second_dir = main.TRUE
else:
- main.log.warn('The port numbers do not match for ' +str(link) +\
- ' between ONOS and MN. When cheking ONOS for link '+\
- '%s/%s -> %s/%s' % (node2, port2, node1, port1)+\
- ' ONOS has the values %s/%s -> %s/%s' %\
- (onos_node2, onos_port2, onos_node1, onos_port1))
- else:#this is not the link you're looking for
+ main.log.warn(
+ 'The port numbers do not match for ' +
+ str( link ) +
+ ' between ONOS and MN. When cheking ONOS for ' +
+ 'link %s/%s -> %s/%s' %
+ ( node2,
+ port2,
+ node1,
+ port1 ) +
+ ' ONOS has the values %s/%s -> %s/%s' %
+ ( onos_node2,
+ onos_port2,
+ onos_node1,
+ onos_port1 ) )
+ else: # this is not the link you're looking for
pass
if not first_dir:
- main.log.report('ONOS does not have the link %s/%s -> %s/%s' % (node1, port1, node2, port2))
+ main.log.report(
+ 'ONOS does not have the link %s/%s -> %s/%s' %
+ ( node1, port1, node2, port2 ) )
if not second_dir:
- main.log.report('ONOS does not have the link %s/%s -> %s/%s' % (node2, port2, node1, port1))
+ main.log.report(
+ 'ONOS does not have the link %s/%s -> %s/%s' %
+ ( node2, port2, node1, port1 ) )
link_results = link_results and first_dir and second_dir
return link_results
+ def get_hosts( self ):
+ """
+ Returns a list of all hosts
+ Don't ask questions just use it"""
+ self.handle.sendline( "" )
+ self.handle.expect( "mininet>" )
- def get_hosts(self):
- '''
- Returns a list of all hosts
- Don't ask questions just use it
- '''
- self.handle.sendline("")
- self.handle.expect("mininet>")
-
- self.handle.sendline("py [ host.name for host in net.hosts ]")
- self.handle.expect("mininet>")
+ self.handle.sendline( "py [ host.name for host in net.hosts ]" )
+ self.handle.expect( "mininet>" )
handle_py = self.handle.before
- handle_py = handle_py.split("]\r\n",1)[1]
+ handle_py = handle_py.split( "]\r\n", 1 )[ 1 ]
handle_py = handle_py.rstrip()
- self.handle.sendline("")
- self.handle.expect("mininet>")
+ self.handle.sendline( "" )
+ self.handle.expect( "mininet>" )
- host_str = handle_py.replace("]", "")
- host_str = host_str.replace("'", "")
- host_str = host_str.replace("[", "")
- host_list = host_str.split(",")
+ host_str = handle_py.replace( "]", "" )
+ host_str = host_str.replace( "'", "" )
+ host_str = host_str.replace( "[", "" )
+ host_list = host_str.split( "," )
return host_list
-
- def update(self):
- '''
- updates the port address and status information for each port in mn
- '''
- #TODO: Add error checking. currently the mininet command has no output
- main.log.info("Updateing MN port information")
+ def update( self ):
+ """
+ updates the port address and status information for
+ each port in mn"""
+ # TODO: Add error checking. currently the mininet command has no output
+ main.log.info( "Updateing MN port information" )
try:
- self.handle.sendline("")
- self.handle.expect("mininet>")
+ self.handle.sendline( "" )
+ self.handle.expect( "mininet>" )
- self.handle.sendline("update")
- self.handle.expect("update")
- self.handle.expect("mininet>")
+ self.handle.sendline( "update" )
+ self.handle.expect( "update" )
+ self.handle.expect( "mininet>" )
- self.handle.sendline("")
- self.handle.expect("mininet>")
+ self.handle.sendline( "" )
+ self.handle.expect( "mininet>" )
return main.TRUE
except pexpect.EOF:
- main.log.error(self.name + ": EOF exception found")
- main.log.error(self.name + ": " + self.handle.before)
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
if __name__ != "__main__":
import sys
- sys.modules[__name__] = MininetCliDriver()
-
+ sys.modules[ __name__ ] = MininetCliDriver()