NePA TesT: Community Network Emulator

from time import sleep

from mininet.cli import CLI

from mininet.node import KernelSwitch, OVSKernelSwitch

from mininet.util import quietRun, fixLimits

from mininet.util import makeIntfPair, moveIntf

        # for now, assume one interface per host.

        host.intfs.append( 'h_' + self.topo.name( dpid ) + '-eth0' )

        self.nodes[ dpid ] = host

    def _addSwitch( self, dpid ):

        """Add switch.

        dstNode.intfs.append( dstIntf )

        srcNode.ports[ srcPort ] = srcIntf

        dstNode.ports[ dstPort ] = dstIntf

        if srcNode.inNamespace:

            moveIntf( srcIntf, srcNode )

        if dstNode.inNamespace:

            moveIntf( dstIntf, dstNode )

        srcNode.connection[ srcIntf ] = ( dstNode, dstIntf )

        dstNode.connection[ dstIntf ] = ( srcNode, srcIntf )

           For use with the user datapath only right now.

           TODO( brandonh ) test this code!

           """

        # params were: controller, switches, ips

        controller = self.controllers[ 'c0' ]

        for switchDpid in self.topo.switches():

            switch = self.nodes[ switchDpid ]

            sip = self.topo.ip( switchDpid )#ips.next()

            sintf = switch.intfs[ 0 ]

            node, cintf = switch.connection[ sintf ]

            if node != controller:

                         'controller' %

                         switch.name )

                exit( 1 )

            switch.setIP( sintf, sip, '/' + self.cparams.subnetSize )

            controller.setHostRoute( sip, cintf )

            switch.setHostRoute( self.cparams.ip, sintf )

        while not controller.intfIsUp( controller.intfs[ 0 ] ):

                controller.intfs[ 0 ] )

            sleep( 1 )

        for switchDpid in self.topo.switches():

            switch = self.nodes[ switchDpid ]

            while not switch.intfIsUp( switch.intfs[ 0 ] ):

                    switch.intfs[ 0 ] )

                sleep( 1 )

            if self.ping( hosts=[ switch, controller ] ) != 0:

                exit( 1 )

    def _configHosts( self ):

        "Configure a set of hosts."

            host.setDefaultRoute( hintf )

            # You're low priority, dude!

            quietRun( 'renice +18 -p ' + repr( host.pid ) )

    def build( self ):

        """Build mininet.

        if self.cleanup:

            pass # cleanup

        # validate topo?

        self._addController( self.controller )

        for host in sorted( self.topo.hosts() ):

            self._addHost( host )

        for switch in sorted( self.topo.switches() ):

            self._addSwitch( switch )

        for src, dst in sorted( self.topo.edges() ):

            self._addLink( src, dst )

        if self.inNamespace:

            self._configureControlNetwork()

        self._configHosts()

        if self.xterms:

    def startXterms( self ):

        "Start an xterm for each node in the topo."

        cleanUpScreens()

        self.terms += makeXterms( self.controllers.values(), 'controller' )

        self.terms += makeXterms( self.switchNodes(), 'switch' )

                    srcNode.setARP( dst, dst )

    def start( self ):

        for cnode in self.controllers.values():

            cnode.start()

        for switchDpid in self.topo.switches():

            switch = self.nodes[ switchDpid ]

            switch.start( self.controllers )

    def stop( self ):

        if self.terms:

            self.stopXterms()

        for hostDpid in self.topo.hosts():

            host = self.nodes[ hostDpid ]

            host.terminate()

        for switchDpid in self.topo.switches():

            switch = self.nodes[ switchDpid ]

            switch.stop()

        for cnode in self.controllers.values():

            cnode.stop()

    def run( self, test, **params ):

        "Perform a complete start/test/stop cycle."

        self.start()

        result = getattr( self, test )( **params )

        self.stop()

        return result

        r = r'(\d+) packets transmitted, (\d+) received'

        m = re.search( r, pingOutput )

        if m == None:

                     pingOutput )

            exit( 1 )

        sent, received = int( m.group( 1 ) ), int( m.group( 2 ) )

        ploss = None

        if not hosts:

            hosts = self.topo.hosts()

        for nodeDpid in hosts:

            node = self.nodes[ nodeDpid ]

            for destDpid in hosts:

                dest = self.nodes[ destDpid ]

                if node != dest:

                    sent, received = self._parsePing( result )

                    packets += sent

                    if received > sent:

                        node.cmdPrint( 'route' )

                        exit( 1 )

                    lost += sent - received

            ploss = 100 * lost / packets

                ( ploss, lost, packets ) )

        return ploss

            assert len( hosts ) == 2

        host0 = self.nodes[ hosts[ 0 ] ]

        host1 = self.nodes[ hosts[ 1 ] ]

        host0.cmd( 'killall -9 iperf' )

        iperfArgs = 'iperf '

        bwArgs = ''

            raise Exception( 'Unexpected l4 type: %s' % l4Type )

        server = host0.cmd( iperfArgs + '-s &' )

        if verbose:

        client = host1.cmd( iperfArgs + '-t 5 -c ' + host0.IP() + ' ' +

                           bwArgs )

        if verbose:

        server = host0.cmd( 'killall -9 iperf' )

        if verbose:

        result = [ self._parseIperf( server ), self._parseIperf( client ) ]

        if l4Type == 'UDP':

            result.insert( 0, udpBw )

        return result

    def iperfUdp( self, udpBw='10M' ):