#!/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"""
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
        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
           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
           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
           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
        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
           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()