| #!/usr/bin/env python |
| """ |
| Created on 26-Oct-2012 |
| |
| 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 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/>. |
| |
| |
| MininetCliDriver is the basic driver which will handle the Mininet functions |
| |
| Some functions rely on a modified version of Mininet. These functions |
| should all be noted in the comments. To get this MN version run these commands |
| from within your Mininet folder: |
| |
| git remote add jhall11 https://github.com/jhall11/sts.git |
| git fetch jhall11 |
| git checkout -b jhall11/topology_refactoring2 remotes/jhall11/topology_refactoring2 |
| git pull |
| |
| Note that you may need to run 'sudo make develop' if your mnexec.c file |
| changed when switching branches.""" |
| import traceback |
| import pexpect |
| import re |
| import sys |
| 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__() |
| self.handle = self |
| 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.""" |
| for key in connectargs: |
| 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.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... " ) |
| |
| 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( "," ) |
| global topoArgList |
| topoArgList = argList[ 0 ].split( " " ) |
| argList = map( int, argList[ 1: ] ) |
| topoArgList = topoArgList[ 1: ] + argList |
| |
| 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..." ) |
| return main.FALSE |
| 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... " ) |
| return main.FALSE |
| 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" ) |
| return main.FALSE |
| |
| def num_switches_n_links( self, topoType, depth, fanout ): |
| if topoType == 'tree': |
| # 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 |
| 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 |
| num_links = count * fanout |
| # print "num_switches for %s(%d,%d) = %d and links=%d" %( |
| # topoType,depth,fanout,num_switches,num_links ) |
| |
| 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 ) |
| topoDict = {} |
| 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 ) |
| 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" ) |
| try: |
| 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.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" ) |
| 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>" ) |
| return main.FALSE |
| 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" ) |
| return main.FALSE |
| 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 ) |
| 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[ "TARGET" ] + " -c 1 -i 1 -W 8" |
| try: |
| 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 ] ) |
| if i == 1: |
| 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.cleanup() |
| main.exit() |
| 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" ) |
| main.last_result = main.FALSE |
| return main.FALSE |
| |
| 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 ) |
| 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\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" ) |
| return main.FALSE |
| else: |
| main.log.error( self.name + ": Connection failed to the host" ) |
| |
| 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 ) |
| for key in connectargs: |
| 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.cleanup() |
| main.exit() |
| import time |
| time.sleep( 20 ) |
| if self.flag == 0: |
| self.flag = 1 |
| return main.FALSE |
| 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""" |
| if self.handle: |
| try: |
| 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 ) |
| return main.TRUE |
| except pexpect.EOF: |
| 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""" |
| if self.handle: |
| try: |
| 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 ) |
| return main.TRUE |
| except pexpect.EOF: |
| 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""" |
| 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>" ) |
| response = self.handle.before |
| 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 ) |
| return main.FALSE |
| |
| 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>" ) |
| response = self.handle.before |
| 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 ) |
| return main.FALSE |
| |
| 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 ) |
| 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 ) |
| 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 ) |
| 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" ) |
| |
| 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 ) |
| 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'^(?P<dpid>\w)+' |
| result = re.search( pattern, response, re.MULTILINE ) |
| if result is None: |
| main.log.info( |
| "Couldn't find DPID for switch %s, found: %s" % |
| ( switch, response ) ) |
| return main.FALSE |
| return str( result.group( 0 ) ).lower() |
| else: |
| main.log.error( "Connection failed to the host" ) |
| |
| def getDPID( self, switch ): |
| if self.handle: |
| 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.handle.before |
| return response |
| except pexpect.EOF: |
| 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())' |
| cmd += ' for i in %s.intfs.values()])' % node |
| try: |
| 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.cleanup() |
| main.exit() |
| return response |
| else: |
| main.log.error( "Connection failed to the node" ) |
| |
| def dump( self ): |
| main.log.info( self.name + ": Dump node info" ) |
| try: |
| 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.cleanup() |
| main.exit() |
| return response |
| |
| def intfs( self ): |
| main.log.info( self.name + ": List interfaces" ) |
| try: |
| 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.cleanup() |
| main.exit() |
| return response |
| |
| def net( self ): |
| main.log.info( self.name + ": List network connections" ) |
| try: |
| 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.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>" ) |
| response = self.handle.before |
| 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 |
| except pexpect.EOF: |
| 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" ) |
| try: |
| 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.cleanup() |
| main.exit() |
| return response |
| |
| def nodes( self ): |
| main.log.info( self.name + ": List all nodes." ) |
| try: |
| 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.cleanup() |
| main.exit() |
| return response |
| |
| def pingpair( self ): |
| main.log.info( self.name + ": Ping between first two hosts" ) |
| try: |
| 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.cleanup() |
| main.exit() |
| |
| 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" ) |
| 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" ] 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: |
| 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.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" ] 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 ) |
| 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" ] 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 ) |
| 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 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() |
| pattern = 'Mininet\s\w\.\w\.\w\w*' |
| for line in open( file_input, 'r' ).readlines(): |
| result = re.match( pattern, line ) |
| if result: |
| version = result.group( 0 ) |
| return version |
| |
| 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 ) |
| try: |
| 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.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 |
| |
| argstring = "SW" |
| 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" ] 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 ) ] 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 ) |
| except pexpect.EOF: |
| 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 + ":" * 50 ) |
| main.log.error( traceback.print_exc() ) |
| 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 ) |
| 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() |
| else: |
| main.log.info( response ) |
| |
| def add_switch( self, sw, **kwargs ): |
| """ |
| adds a switch to the mininet topology |
| NOTE: This uses a custom mn function. MN repo should be on |
| jhall11/topology_refactoring2 branch |
| NOTE: cannot currently specify what type of switch |
| required params: |
| switchname = name of the new switch as a string |
| optional keyvalues: |
| dpid = "dpid" |
| returns: main.FASLE on an error, else main.TRUE |
| """ |
| 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 ) |
| return main.FALSE |
| elif re.search( "Error", response ): |
| main.log.warn( response ) |
| return main.FALSE |
| 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.cleanup() |
| main.exit() |
| |
| def del_switch( self, sw ): |
| """ |
| delete a switch from the mininet topology |
| NOTE: This uses a custom mn function. MN repo should be on |
| jhall11/topology_refactoring2 branch |
| required params: |
| switchname = name of the switch as a string |
| 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 ) |
| return main.FALSE |
| elif re.search( "Error", response ): |
| main.log.warn( response ) |
| return main.FALSE |
| 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.cleanup() |
| main.exit() |
| |
| def add_link( self, node1, node2 ): |
| """ |
| add a link to the mininet topology |
| NOTE: This uses a custom mn function. MN repo should be on |
| jhall11/topology_refactoring2 branch |
| 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 ) |
| return main.FALSE |
| elif re.search( "Error", response ): |
| main.log.warn( response ) |
| return main.FALSE |
| 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.cleanup() |
| main.exit() |
| |
| def del_link( self, node1, node2 ): |
| """ |
| delete a link from the mininet topology |
| NOTE: This uses a custom mn function. MN repo should be on |
| jhall11/topology_refactoring2 branch |
| 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 ) |
| return main.FALSE |
| elif re.search( "Error", response ): |
| main.log.warn( response ) |
| return main.FALSE |
| 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.cleanup() |
| main.exit() |
| |
| def add_host( self, hostname, **kwargs ): |
| """ |
| Add a host to the mininet topology |
| NOTE: This uses a custom mn function. MN repo should be on |
| jhall11/topology_refactoring2 branch |
| NOTE: cannot currently specify what type of host |
| required params: |
| hostname = the string hostname |
| optional key-value params |
| switch = "switch name" |
| returns: main.FASLE on an error, else main.TRUE |
| """ |
| 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 ) |
| return main.FALSE |
| elif re.search( "doesnt exists!", response ): |
| main.log.warn( response ) |
| return main.FALSE |
| elif re.search( "Error", response ): |
| main.log.warn( response ) |
| return main.FALSE |
| 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.cleanup() |
| main.exit() |
| |
| def del_host( self, hostname ): |
| """ |
| delete a host from the mininet topology |
| NOTE: This uses a custom mn function. MN repo should be on |
| jhall11/topology_refactoring2 branch |
| 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 ) |
| return main.FALSE |
| elif re.search( "Error", response ): |
| main.log.warn( response ) |
| return main.FALSE |
| 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.cleanup() |
| main.exit() |
| |
| 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 = main.TRUE |
| except pexpect.EOF: |
| 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" ) |
| response = main.FALSE |
| return response |
| |
| def arping( self, src, dest, destmac ): |
| self.handle.sendline( '' ) |
| self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] ) |
| |
| 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 ] ) |
| return main.TRUE |
| except: |
| main.log.warn( self.name + ": ARP FAILURE" ) |
| self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] ) |
| return main.FALSE |
| |
| def decToHex( self, num ): |
| return hex( num ).split( 'x' )[ 1 ] |
| |
| 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 ) |
| except pexpect.EOF: |
| 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 ) |
| if result is None: |
| main.log.info( |
| "Couldn't find flows on switch %s, found: %s" % |
| ( switch, response ) ) |
| return main.FALSE |
| return result.group( 1 ) |
| else: |
| main.log.error( "Connection failed to the Mininet host" ) |
| |
| def check_flows( self, sw, dump_format=None ): |
| if dump_format: |
| command = "sh ovs-ofctl -F " + \ |
| dump_format + " dump-flows " + str( sw ) |
| else: |
| command = "sh ovs-ofctl dump-flows " + str( sw ) |
| try: |
| 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.cleanup() |
| main.exit() |
| else: |
| 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""" |
| 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>" ) |
| if i == 0: |
| 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 ) |
| return main.TRUE |
| elif i == 2: |
| 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 ) |
| return main.TRUE |
| else: |
| 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.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + ":" * 50 ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info(":" * 50 ) |
| main.cleanup() |
| main.exit() |
| |
| 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>" ) |
| except pexpect.EOF: |
| 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 + ":" * 50 ) |
| main.log.error( traceback.print_exc() ) |
| 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 |
| |
| 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 } ) |
| |
| # 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.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" ) |
| return main.FALSE |
| onos = switches_json |
| onosDPIDs = [] |
| for switch in onos: |
| 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 |
| |
| if mnDPIDs != onosDPIDs: |
| switch_results = main.FALSE |
| 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 ): |
| """ |
| Compare mn and onos ports |
| topo: sts TestONTopology object |
| ports_json: parsed json object from the onos ports api |
| |
| Dependencies: |
| 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 |
| from numpy import uint64 |
| ports_results = main.TRUE |
| 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='' ) |
| 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 |
| |
| ports.append( tmp_port ) |
| tmp_switch = {} |
| tmp_switch[ 'name' ] = switch.name |
| tmp_switch[ 'dpid' ] = str( switch.dpid ).zfill( 16 ) |
| tmp_switch[ 'ports' ] = ports |
| |
| output[ 'switches' ].append( tmp_switch ) |
| |
| # PORTS |
| for mn_switch in output[ 'switches' ]: |
| mn_ports = [] |
| onos_ports = [] |
| switch_result = main.TRUE |
| 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' ]: |
| 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' ] ) ) |
| 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_log = mn_ports |
| onos_ports_log = 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 ) ) |
| 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 |
| # So ignoring these for now |
| # 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 |
| 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 |
| switch_result = main.FALSE |
| 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 ) ) |
| 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 |
| |
| 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": [] } |
| onos = links_json |
| # 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 |
| |
| 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 ) ) ) |
| |
| # 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 |
| 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' ] |
| 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 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' ] |
| |
| # 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 ): |
| 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 ) ) |
| |
| # 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 ) ): |
| 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 |
| pass |
| if not first_dir: |
| 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 ) ) |
| 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>" ) |
| |
| 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.rstrip() |
| |
| 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( "," ) |
| |
| 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" ) |
| try: |
| self.handle.sendline( "" ) |
| self.handle.expect( "mininet>" ) |
| |
| self.handle.sendline( "update" ) |
| self.handle.expect( "update" ) |
| 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.cleanup() |
| main.exit() |
| |
| if __name__ != "__main__": |
| import sys |
| sys.modules[ __name__ ] = MininetCliDriver() |