TestON/tests/USECASE/SegmentRouting/dependencies/cord_fabric.py

#!/usr/bin/python

import os
import re
import math
from optparse import OptionParser
from ipaddress import IPv6Network, IPv4Network
from mininet.net import Mininet
from mininet.topo import Topo
from mininet.node import RemoteController, UserSwitch, Host, OVSBridge
from mininet.link import TCLink
from mininet.log import setLogLevel
from mininet.cli import CLI


# Parse command line options and dump results
def parseOptions( ):
    """Parse command line options"""
    parser = OptionParser( )
    parser.add_option( '--spine', dest='spine', type='int', default=2,
                       help='number of spine switches, default=2' )
    parser.add_option( '--leaf', dest='leaf', type='int', default=2,
                       help='number of leaf switches, default=2' )
    parser.add_option( '--fanout', dest='fanout', type='int', default=2,
                       help='number of hosts per leaf switch, default=2' )
    parser.add_option( '--onos', dest='onos', type='int', default=0,
                       help='number of ONOS Instances, default=0, 0 means localhost, 1 will use OC1 and so on' )
    parser.add_option( '--vlan', dest='vlan', type='int', default=-1,
                       help='vid of cross connect, default=-1, -1 means utilize default value' )
    parser.add_option( '--ipv6', action="store_true", dest='ipv6',
                       help='hosts are capable to use also ipv6' )
    (options, args) = parser.parse_args( )
    return options, args


opts, args = parseOptions( )

IP6_SUBNET_CLASS = 120
IP4_SUBNET_CLASS = 24

class LeafAndSpine6( Topo ):
    """
    Create Leaf and Spine Topology for IPv4/IPv6 tests.
    """
    def __init__( self, spine=2, leaf=2, fanout=2, **opts ):
        Topo.__init__( self, **opts )
        spines          = {}
        leafs           = {}
        """
        We calculate the offset from /120 and from /24 in order to have
        a number of /120 and /24 subnets == leaf
        """
        offset          = int(math.ceil(math.sqrt( leaf )))
        """
        We calculate the subnets to use and set options
        """
        ipv6SubnetClass = unicode('2000::/%s' % (IP6_SUBNET_CLASS - offset))
        ipv6Subnets     = list(IPv6Network(ipv6SubnetClass).subnets( new_prefix = IP6_SUBNET_CLASS ))
        ipv4SubnetClass = unicode('10.0.0.0/%s' % (IP4_SUBNET_CLASS - offset))
        ipv4Subnets     = list(IPv4Network(ipv4SubnetClass).subnets( new_prefix = IP4_SUBNET_CLASS ))
        linkopts        = dict( bw=100 )
        """
        We create the spine switches
        """
        for s in range( spine ):
            spines[ s ] = self.addSwitch( 'spine10%s' % (s + 1),
                                          dpid="00000000010%s" % (s + 1) )
        """
        We create the leaf switches
        """
        for ls in range( leaf ):
            leafs[ ls ] = self.addSwitch( 'leaf%s' % (ls + 1),
                                          dpid="00000000000%s" % (1 + ls) )
            ipv6Subnet  = ipv6Subnets[ ls ]
            ipv6Hosts   = list(ipv6Subnet.hosts())
            ipv4Subnet  = ipv4Subnets[ ls ]
            ipv4Hosts   = list(ipv4Subnet.hosts())
            """
            We add the hosts
            """
            for f in range( fanout ):
                ipv6 = ipv6Hosts[ f ]
                ipv6Gateway = ipv6Hosts[ len( ipv6Hosts ) - 1 ]
                ipv4 = ipv4Hosts[ f ]
                ipv4Gateway = ipv4Hosts[ len( ipv4Hosts ) - 1 ]
                host = self.addHost(
                    name='h%s' % (ls * fanout + f + 1),
                    cls=Ipv6Host,
                    ip="%s/%s" %(ipv4, IP4_SUBNET_CLASS),
                    gateway='%s' % ipv4Gateway,
                    ipv6="%s/%s" %(ipv6, IP6_SUBNET_CLASS),
                    ipv6Gateway="%s" % ipv6Gateway
                    )
                self.addLink( host, leafs[ ls ], **linkopts )
            """
            Connect leaf to all spines
            """
            for s in range( spine ):
                switch = spines[ s ]
                self.addLink( leafs[ ls ], switch, **linkopts )

class LeafAndSpine( Topo ):
    def __init__( self, spine=2, leaf=2, fanout=2, **opts ):
        "Create Leaf and Spine Topo."
        Topo.__init__( self, **opts )
        # Add spine switches
        spines = { }
        leafs = { }
        for s in range( spine ):
            spines[ s ] = self.addSwitch( 'spine10%s' % (s + 1),
                                          dpid="00000000010%s" % (s + 1) )
        # Set link speeds to 100Mb/s
        linkopts = dict( bw=100 )
        # Add Leaf switches
        for ls in range( leaf ):
            leafs[ ls ] = self.addSwitch( 'leaf%s' % (ls + 1),
                                          dpid="00000000000%s" % (1 + ls) )
            # Add hosts under a leaf, fanout hosts per leaf switch
            for f in range( fanout ):
                host = self.addHost( 'h%s' % (ls * fanout + f + 1),
                                     cls=IpHost,
                                     ip='10.0.%s.%s/24' % ((ls + 1), (f + 1)),
                                     gateway='10.0.%s.254' % (ls + 1) )
                self.addLink( host, leafs[ ls ], **linkopts )
                # Add Xconnect simulation
            if ls is 0:
                in1 = self.addHost( 'in1', cls=IpHost, ip='10.0.1.9/24', mac="00:00:00:00:00:09" )
                self.addLink( in1, leafs[0], **linkopts )
                out1 = self.addHost( 'out1', cls=IpHost, ip='10.0.9.1/24', mac="00:00:00:00:09:01" )
                self.addLink( out1, leafs[0], **linkopts )
                br1 = self.addSwitch( 'br1', cls=OVSBridge )
                self.addLink( br1, leafs[ 0 ], **linkopts )
                vlans = [ 1, 5, 10 ]
                for vid in vlans:
                    olt = self.addHost( 'olt%s' % vid, cls=VLANHost, vlan=vid,
                                        ip="10.%s.0.1/24" % vid
                                        , mac="00:00:%02d:00:00:01" % vid )
                    vsg = self.addHost( 'vsg%s' % vid, cls=VLANHost, vlan=vid,
                                        ip="10.%s.0.2/24" % vid
                                        , mac="00:00:%02d:00:00:02" % vid )
                    self.addLink( olt, leafs[ 0 ], **linkopts )
                    self.addLink( vsg, br1, **linkopts )
            # Connect leaf to all spines
            for s in range( spine ):
                switch = spines[ s ]
                self.addLink( leafs[ ls ], switch, **linkopts )

class IpHost( Host ):
    def __init__( self, name, *args, **kwargs ):
        super( IpHost, self ).__init__( name, *args, **kwargs )
        gateway = re.split('\.|/', kwargs['ip'])
        gateway[3] = '254'
        self.gateway = '.'.join(gateway[0:4])

    def config( self, **kwargs ):
        Host.config( self, **kwargs )
        mtu = "ifconfig " + self.name + "-eth0 mtu 1490"
        self.cmd( mtu )
        self.cmd( 'ip route add default via %s' % self.gateway )

class Ipv6Host( IpHost ):
    """
    Abstraction to model an augmented host with a ipv6
    functionalities as well
    """
    def __init__( self, name, *args, **kwargs ):
        IpHost.__init__(self, name, *args, **kwargs)

    def config( self, **kwargs ):
        IpHost.config( self, **kwargs )
        ipv6Cmd         = 'ifconfig %s-eth0 inet6 add %s' % (self.name, kwargs['ipv6'])
        ipv6GatewayCmd  = 'ip -6 route add default via %s' % kwargs['ipv6Gateway']
        ipv6MtuCmd      = 'ifconfig %s-eth0 inet6 mtu 1490' % (self.name)
        self.cmd( ipv6Cmd )
        self.cmd( ipv6GatewayCmd )
        self.cmd( ipv6MtuCmd )

class VLANHost( Host ):
    "Host connected to VLAN interface"

    def config( self, vlan=100, **params ):
        """Configure VLANHost according to (optional) parameters:
           vlan: VLAN ID for default interface"""
        r = super( VLANHost, self ).config( **params )
        intf = self.defaultIntf( )
        # remove IP from default, "physical" interface
        self.cmd( 'ifconfig %s inet 0' % intf )
        intf = self.defaultIntf( )
        # create VLAN interface
        self.cmd( 'vconfig add %s %d' % (intf, vlan) )
        self.cmd( 'ifconfig %s.%d %s' % (intf, vlan, params[ 'ip' ]) )
        # update the intf name and host's intf map
        self.cmd( 'ifconfig %s.%d mtu 1480' % (intf, vlan) )
        newName = '%s.%d' % (intf, vlan)
        # update the (Mininet) interface to refer to VLAN interface name
        intf.name = newName
        # add VLAN interface to host's name to intf map
        self.nameToIntf[ newName ] = intf

class ExtendedCLI( CLI ):
    """
    Extends mininet CLI with the following commands:
    addvlanhost
    addiphost
    """
    def do_addhost( self, line ):
        #Parsing args from CLI
        args = line.split( )
        if len( args ) < 3 or len( args ) :
            "usage: addhost hostname switch **params"
        hostname, switch = args[0],  args[1]
        params = eval(line.split( ' ', 3 )[2])
        if 'cls' in params:
            params['cls'] = eval( params[ 'cls' ] )
        if hostname in self.mn:
            #error( '%s already exists!\n' % hostname )
            return
        if switch not in self.mn:
            #error( '%s does not exist!\n' % switch )
            return
        print params
        host = self.mn.addHostCfg( hostname, **params )
        #switch.attach( link.intf2 )
        #host.config()
        link = self.mn.addLink( host, switch )
        host.config(**params)

    def do_pingall6( self, line ):
        "Ping6 between all hosts."
        self.mn.pingAll6( line )

def config( opts ):
    spine = opts.spine
    leaf = opts.leaf
    fanout = opts.fanout
    vlan = opts.vlan
    ipv6 = opts.ipv6
    controllers = [ os.environ[ 'OC%s' % i ] for i in
                    range( 1, opts.onos + 1 ) ] if (opts.onos) else [
        '127.0.0.1' ]
    if not ipv6:
        topo = LeafAndSpine(
            spine=spine,
            leaf=leaf,
            fanout=fanout,
            vlan=vlan,
            )
    else:
        topo = LeafAndSpine6(
            spine=spine,
            leaf=leaf,
            fanout=fanout,
            vlan=vlan,
            ipv6=ipv6
            )
    net = Mininet( topo=topo, link=TCLink, build=False,
                   switch=UserSwitch, controller=None, autoSetMacs=True )
    i = 0
    for ip in controllers:
        net.addController( "c%s" % (i), controller=RemoteController, ip=ip )
        i += 1;
    net.build( )
    net.start( )
    if not ipv6:
        out1 = net.get( 'out1' )
        out1.cmd( "arp -s 10.0.9.254 10:00:00:00:00:01 -i %s " % (out1.intf()) )
    ExtendedCLI(net)
    net.stop( )

if __name__ == '__main__':
    setLogLevel( 'info' )
    config( opts )
    os.system( 'sudo mn -c' )