コード例 #1
0
    def __init__(self):
        """Initialize a Quagga topology with 5 routers, configure their IP
           addresses, loop back interfaces, and paths to their private
           configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'

        # List of Quagga host configs
        quaggaHosts = []
        quaggaHosts.append(
            QuaggaHost(name='a1', ip='172.0.1.1/16', loIP='10.0.1.1/24'))
        quaggaHosts.append(
            QuaggaHost(name='b1', ip='172.0.2.1/16', loIP='10.0.2.1/24'))
        quaggaHosts.append(
            QuaggaHost(name='c1', ip='172.0.3.2/16', loIP='10.0.3.1/24'))
        quaggaHosts.append(
            QuaggaHost(name='c2', ip='172.0.3.1/16', loIP='10.0.3.1/24'))
        quaggaHosts.append(
            QuaggaHost(name='d1', ip='172.0.4.1/16', loIP='10.0.4.1/24'))
        quaggaHosts.append(
            QuaggaHost(name='rs', ip='172.0.254.254/16', loIP=None))

        # Add switch for IXP fabric
        ixpfabric = self.addSwitch('fabric-sw1')

        # Setup each Quagga router, add a link between it and the IXP fabric
        for host in quaggaHosts:

            # Create an instance of a host, called a quaggaContainer
            quaggaContainer = self.addHost(name=host.name,
                                           ip=host.ip,
                                           hostname=host.name,
                                           privateLogDir=True,
                                           privateRunDir=True,
                                           inMountNamespace=True,
                                           inPIDNamespace=True,
                                           inUTSNamespace=True)

            # Add a loopback interface with an IP in router's announced range
            self.addNodeLoopbackIntf(node=host.name, ip=host.loIP)

            # Configure and setup the Quagga service for this node
            quaggaSvcConfig = \
                {'quaggaConfigPath': quaggaBaseConfigPath + host.name}
            self.addNodeService(node=host.name,
                                service=quaggaSvc,
                                nodeConfig=quaggaSvcConfig)

            # Attach the quaggaContainer to the IXP Fabric Switch
            self.addLink(quaggaContainer, ixpfabric)
コード例 #2
0
    def __init__(self):
        """Initialize a Quagga topology with 5 routers, configure their IP
           addresses, loop back interfaces, and paths to their private
           configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'

        # List of Quagga host configs
        quaggaHosts = []
        quaggaHosts.append(
            QuaggaHost(name='H1',
                       ip='192.168.101.128/24',
                       DG='via 192.168.101.1'))
        quaggaHosts.append(QuaggaHost(name='R1', ip='192.168.101.1/24', DG=''))
        quaggaHosts.append(QuaggaHost(name='R2', ip='192.168.102.1/24', DG=''))
        quaggaHosts.append(QuaggaHost(name='R3', ip='192.168.103.1/24', DG=''))
        quaggaHosts.append(QuaggaHost(name='R4', ip='192.168.106.1/24', DG=''))
        quaggaHosts.append(
            QuaggaHost(name='H2',
                       ip='192.168.106.128/24',
                       DG='via 192.168.106.1'))

        # Setup each Quagga router, add a link between it and the IXP fabric
        quaggaContainer = {}
        for host in quaggaHosts:
            # Create an instance of a host, called a quaggaContainer
            quaggaContainer[host.name] = self.addHost(name=host.name,
                                                      ip=host.ip,
                                                      hostname=host.name,
                                                      defaultRoute=host.DG,
                                                      privateLogDir=True,
                                                      privateRunDir=True,
                                                      inMountNamespace=True,
                                                      inPIDNamespace=True,
                                                      inUTSNamespace=True)

            # Configure and setup the Quagga service for this node
            quaggaSvcConfig = \
                {'quaggaConfigPath': quaggaBaseConfigPath + host.name}
            self.addNodeService(node=host.name,
                                service=quaggaSvc,
                                nodeConfig=quaggaSvcConfig)

        # Attach the quaggaContainer to the IXP Fabric Switch
        self.addLink(quaggaContainer['R1'], quaggaContainer['H1'])
        self.addLink(quaggaContainer['R1'], quaggaContainer['R2'])
        self.addLink(quaggaContainer['R1'], quaggaContainer['R3'])
        self.addLink(quaggaContainer['R4'], quaggaContainer['H2'])
        self.addLink(quaggaContainer['R4'], quaggaContainer['R2'])
        self.addLink(quaggaContainer['R4'], quaggaContainer['R3'])
コード例 #3
0
ファイル: mtd_mininet.py プロジェクト: ltanguay/NDS
    def __init__(self):
        super(QuaggaTopo, self).__init__()

        script_dir = os.path.dirname(os.path.abspath(__file__))
        quagga_svc = QuaggaService(autoStop=False)
        quagga_base_config_path = os.path.join(script_dir, 'quaggacfgs')

        quagga_hosts = [
            QuaggaHost('a1', '172.0.0.1/16', '08:00:27:89:3b:9f', 1),
            QuaggaHost('b1', '172.0.0.11/16', '08:00:27:92:18:1f', 2)
        ]

        # a switch to connect hosts
        switch = self.addSwitch('s1')

        for host in quagga_hosts:
            quagga_svc_config = {
                'quaggaConfigPath': os.path.join(quagga_base_config_path, host.name)
            }
            quagga_container = self.addHost(
                name=host.name,
                ip=host.ip,
                mac=host.mac,
                privateLogDir=True,
                privateRunDir=True,
                inMountNamespace=True,
                inPIDNamespace=True
            )
            self.addNodeService(node=host.name, service=quagga_svc,
                                nodeConfig=quagga_svc_config)

            self.addLink(quagga_container, switch, port2=host.port)
コード例 #4
0
ファイル: topo.py プロジェクト: rubiruchi/DHT
    def __init__(self, total_nodes_to_create):
        """Initialize a Quagga topology with 5 routers, configure their IP
           addresses, loop back interfaces, and paths to their private
           configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        self.quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        self.quaggaBaseConfigPath = selfPath + '/configs/'

        # List of Quagga host configs
        self.base_ip_address = [172, 0, 1, 1]
        self.subnet_mask = 16
        self.loopback_address = '127.0.0.1/24'
        self.host_prefix = 'a'
        self.total_nodes = 0

        # Add switch for IXP fabric
        self.ixpfabric = self.addSwitch('fabric-sw1')

        for i in range(total_nodes_to_create):
            self.add_node()
コード例 #5
0
    def __init__(self):
        """Initialize a Quagga topology with 5 routers, configure their IP
           addresses, loop back interfaces, and paths to their private
           configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'

        # List of Quagga host configs
        quaggaHosts = []
        quaggaHosts.append(
            QuaggaHost(name='H1', ip='192.0.1.1/24', loIP='10.0.1.1/24'))
        quaggaHosts.append(QuaggaHost(name='R1', ip='192.0.1.2/24', loIP=None))
        quaggaHosts.append(QuaggaHost(name='R2', ip='192.0.2.2/24', loIP=None))
        quaggaHosts.append(
            QuaggaHost(name='R3', ip='192.0.3.2/24', loIP='10.0.3.1/24'))
        quaggaHosts.append(
            QuaggaHost(name='R4', ip='192.0.6.1/24', loIP='10.0.4.1/24'))
        quaggaHosts.append(QuaggaHost(name='H2', ip='192.0.6.2/24', loIP=None))

        hostList = []
        print("Arun :Creating a list of hosts ")
        for host in quaggaHosts:

            # Create an instance of a host and append it to the hostList
            hostList.append(
                self.addHost(name=host.name,
                             ip=host.ip,
                             hostname=host.name,
                             privateLogDir=True,
                             privateRunDir=True,
                             inMountNamespace=True,
                             inPIDNamespace=True,
                             inUTSNamespace=True))

            # Add a loopback interface with an IP in router's announced range
            #self.addNodeLoopbackIntf(node=host.name, ip=host.loIP)

            # Configure and setup the Quagga service for this node
            quaggaSvcConfig = \
                {'quaggaConfigPath': quaggaBaseConfigPath + host.name}
            self.addNodeService(node=host.name,
                                service=quaggaSvc,
                                nodeConfig=quaggaSvcConfig)
        self.addLink(hostList[0], hostList[1])
        self.addLink(hostList[1], hostList[2])
        self.addLink(hostList[1], hostList[3])
        self.addLink(hostList[4], hostList[5])
        self.addLink(hostList[2], hostList[4])
        self.addLink(hostList[3], hostList[4])
コード例 #6
0
    def __init__(self):
        """Initialize a Quagga topology with 5 routers, configure their IP
           addresses, loop back interfaces, and paths to their private
           configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'

        # List of Quagga host configs
        quaggaHosts = []
        quaggaHosts.append(
            QuaggaHost(name='H1', ip='162.0.0.1/20', loIP='10.0.1.1/20'))
        quaggaHosts.append(
            QuaggaHost(name='R1', ip='162.0.0.2/20', loIP='10.0.2.1/20'))
        quaggaHosts.append(
            QuaggaHost(name='R2', ip='163.0.0.1/20', loIP='10.0.3.1/20'))
        quaggaHosts.append(
            QuaggaHost(name='R3', ip='164.0.0.1/20', loIP='10.0.3.1/20'))
        quaggaHosts.append(
            QuaggaHost(name='R4', ip='167.0.0.2/20', loIP='10.0.4.1/20'))
        quaggaHosts.append(
            QuaggaHost(name='H2', ip='167.0.0.1/20', loIP='10.0.5.1/20'))
        nodes = []
        # Setup each Quagga router, add a link between it and the IXP fabric
        for host in quaggaHosts:

            # Create an instance of a host, called a quaggaContainer
            nodes.append(
                self.addHost(name=host.name,
                             ip=host.ip,
                             hostname=host.name,
                             privateLogDir=True,
                             privateRunDir=True,
                             inMountNamespace=True,
                             inPIDNamespace=True,
                             inUTSNamespace=True))

            # Configure and setup the Quagga service for this node
            quaggaSvcConfig = \
                {'quaggaConfigPath': quaggaBaseConfigPath + host.name}
            self.addNodeService(node=host.name,
                                service=quaggaSvc,
                                nodeConfig=quaggaSvcConfig)

        self.addLink(nodes[0], nodes[1])
        self.addLink(nodes[1], nodes[2])
        self.addLink(nodes[1], nodes[3])
        self.addLink(nodes[5], nodes[4])
        self.addLink(nodes[2], nodes[4])
        self.addLink(nodes[3], nodes[4])
コード例 #7
0
    def __init__(self):
        """Initialize a Quagga topology with 5 routers, configure their IP
           addresses, loop back interfaces, and paths to their private
           configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'

        # List of Quagga host configs
        quaggaHosts = []
        quaggaHosts.append(QuaggaHost(name='r1', ip='223.1.1.1/24'))
        quaggaHosts.append(QuaggaHost(name='r2', ip='223.1.2.1/24'))
        quaggaHosts.append(QuaggaHost(name='r3', ip='223.1.1.2/24'))
        quaggaHosts.append(QuaggaHost(name='r4', ip='223.1.3.2/24'))
        quaggaHosts.append(QuaggaHost(name='h1', ip='223.1.5.10/24'))
        quaggaHosts.append(QuaggaHost(name='h2', ip='223.1.6.10/24'))

        quaggas = {}

        # Setup each Quagga router
        for host in quaggaHosts:

            # Create an instance of a host, called a quaggaContainer
            quaggaContainer = self.addHost(name=host.name,
                                           ip=host.ip,
                                           hostname=host.name,
                                           privateLogDir=True,
                                           privateRunDir=True,
                                           inMountNamespace=True,
                                           inPIDNamespace=True,
                                           inUTSNamespace=True)

            # Configure and setup the Quagga service for this node
            quaggaSvcConfig = {
                'quaggaConfigPath': quaggaBaseConfigPath + host.name
            }
            self.addNodeService(node=host.name,
                                service=quaggaSvc,
                                nodeConfig=quaggaSvcConfig)

            quaggas[host.name] = quaggaContainer

        # Add the links
        self.addLink(quaggas['h1'], quaggas['r1'])  # h1-eth0 : r1-eth0
        self.addLink(quaggas['h2'], quaggas['r4'])  # h2-eth0 : r4-eth0
        self.addLink(quaggas['r1'], quaggas['r2'])  # r1-eth1 : r2-eth0
        self.addLink(quaggas['r3'], quaggas['r4'])  # r3-eth0 : r4-eth1
        self.addLink(quaggas['r1'], quaggas['r3'])  # r1-eth2 : r3-eth1
        self.addLink(quaggas['r2'], quaggas['r4'])  # r2-eth1 : r4-eth2
コード例 #8
0
ファイル: topo.py プロジェクト: wangyishuo123/mininet
    def __init__(self):
        """Initialize a Quagga topology with 4 routers and 2 hosts, configure their IP
           addresses, loop back interfaces, and paths to their private
           configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(os.path.abspath(
            inspect.getfile(inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'

        # List of Quagga host configs
        quaggaHosts = []
        quaggaHosts.append(QuaggaHost(name='H1', ip='170.1.1.1/24',DG='via 170.1.1.2',loIP=None))
        quaggaHosts.append(QuaggaHost(name='R1', ip='170.1.1.2/24',DG='',loIP=None))
        quaggaHosts.append(QuaggaHost(name='R2', ip='171.1.1.2/24',DG='',loIP=None))
        quaggaHosts.append(QuaggaHost(name='R3', ip='172.1.1.2/24',DG='',loIP=None))
        quaggaHosts.append(QuaggaHost(name='R4', ip='175.7.7.1/24',DG='',loIP=None))
        quaggaHosts.append(QuaggaHost(name='H2', ip='175.7.7.2/24',DG='via 175.7.7.1',loIP=None))

        hostList = []
        # Setup each Quagga router, add a link between it and the IXP fabric
        for host in quaggaHosts:
            # Create an instance of a host, called a quaggaContainer
            quaggaContainer = self.addHost(name=host.name,
                                           ip=host.ip,
                                           hostname=host.name,
                                           defaultRoute=host.DG,
                                           privateLogDir=True,
                                           privateRunDir=True,
                                           inMountNamespace=True,
                                           inPIDNamespace=True,
                                           inUTSNamespace=True)
            hostList.append(quaggaContainer)
            # Add a loopback interface with an IP in router's announced range
            self.addNodeLoopbackIntf(node=host.name, ip=host.loIP)
            # Configure and setup the Quagga service for this node
            quaggaSvcConfig ={'quaggaConfigPath': quaggaBaseConfigPath + host.name}
            self.addNodeService(node=host.name, service=quaggaSvc,nodeConfig=quaggaSvcConfig)

        self.addLink(hostList[0], hostList[1])#H1-R1
        self.addLink(hostList[1], hostList[2])#R1-R2
        self.addLink(hostList[1], hostList[3])#R1-R3
        self.addLink(hostList[5], hostList[4])#H2-R4
        self.addLink(hostList[2], hostList[4])#R2-R4
        self.addLink(hostList[3], hostList[4])#R3-R4
コード例 #9
0
    def __init__(self):
        Topo.__init__(self)
        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'

        # Initialize data structure to map each router with the port on the switch corresponding to incoming traffic
        self.in_interface = {}
        # saving speed of each interface
        self.intf_speed = {}
        outer = self.createQuaggRing(OUTER, quaggaSvc, quaggaBaseConfigPath)

        # inner = self.createQuaggRing(INNER, quaggaSvc, quaggaBaseConfigPath, r_name="ri{:d}", s_name="si{:d}")
        # test with different naming because of problem with contorller
        inner = self.createQuaggRing(INNER,
                                     quaggaSvc,
                                     quaggaBaseConfigPath,
                                     r_name="ri{:d}",
                                     count=OUTER,
                                     bw=IN_BW)

        # creating custom connections between inner and outer rings
        self.addLinkWithSwitch(outer[0], inner[1],
                               self.addSwitch("s11", protocols='OpenFlow13'))
        self.addLinkWithSwitch(outer[2], inner[1],
                               self.addSwitch("s12", protocols='OpenFlow13'))
        self.addLinkWithSwitch(outer[2], inner[2],
                               self.addSwitch("s13", protocols='OpenFlow13'))
        self.addLinkWithSwitch(outer[3], inner[3],
                               self.addSwitch("s14", protocols='OpenFlow13'))
        self.addLinkWithSwitch(outer[5], inner[3],
                               self.addSwitch("s15", protocols='OpenFlow13'))
        self.addLinkWithSwitch(outer[5], inner[0],
                               self.addSwitch("s16", protocols='OpenFlow13'))

        # saving mapping on file
        with open(OUT_DIR + 'switch_mapping.pkl', 'wb+') as f:
            pickle.dump(self.in_interface, f)

        # saving intf speed on file
        with open(OUT_DIR + 'intf_speed.pkl', 'wb+') as f:
            pickle.dump(self.intf_speed, f)
コード例 #10
0
    def __init__( self ):

        "Initialize topology"
        Topo.__init__( self )

        "Directory where this file / script is located"
        scriptdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) # script directory
        "Initialize a service helper for Quagga with default options"
        quaggaSvc = QuaggaService(autoStop=False)

        "Path configurations for mounts"
        quaggaBaseConfigPath=scriptdir + '/quaggacfgs/'

        "List of Quagga host configs"
        quaggaHosts = []
        quaggaHosts.append(QuaggaHost(name = 'a1', ip = '172.0.0.1/16', mac = '08:00:27:89:3b:9f', port = 1))
        quaggaHosts.append(QuaggaHost(name = 'b1', ip = '172.0.0.11/16', mac ='08:00:27:92:18:1f', port = 2))
        quaggaHosts.append(QuaggaHost(name = 'c1', ip = '172.0.0.21/16', mac = '08:00:27:54:56:ea', port = 3))
        quaggaHosts.append(QuaggaHost(name = 'c2', ip = '172.0.0.22/16', mac = '08:00:27:bd:f8:b2', port = 4))

        "Add switch for IXP fabric"
        ixpfabric = self.addSwitch( 's1' )


        "Setup each legacy router, add a link between it and the IXP fabric"
        for host in quaggaHosts:
            "Set Quagga service configuration for this node"
            quaggaSvcConfig = \
            { 'quaggaConfigPath' : scriptdir + '/quaggacfgs/' + host.name }

            quaggaContainer = self.addHost( name=host.name,
                                            ip=host.ip,
                                            mac=host.mac,
                                            privateLogDir=True,
                                            privateRunDir=True,
                                            inMountNamespace=True,
                                            inPIDNamespace=True)
            self.addNodeService(node=host.name, service=quaggaSvc,
                                nodeConfig=quaggaSvcConfig)
            "Attach the quaggaContainer to the IXP Fabric Switch"
            self.addLink( quaggaContainer, ixpfabric , port2=host.port)
        
        " Add root node for ExaBGP. ExaBGP acts as route server for SDX. "
        root = self.addHost('exabgp', ip = '172.0.255.254/16', inNamespace = False)
        self.addLink(root, ixpfabric, port2 = 5)
コード例 #11
0
ファイル: k.py プロジェクト: fengjiangwei65/test
    def __init__( self ):

        "Initialize topology"
        Topo.__init__( self )

        "Directory where this file / script is located"
        scriptdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) # script directory
        "Initialize a service helper for Quagga with default options"
        quaggaSvc = QuaggaService(autoStop=False)

        "Path configurations for mounts"
        quaggaBaseConfigPath=scriptdir + '/quaggacfgs/'

        "List of Quagga host configs"
        quaggaHosts = []
        quaggaHosts.append(QuaggaHost(name = 'a1', ip = '172.0.0.1/16', mac = '08:00:27:89:3b:9f', port = 1))
        quaggaHosts.append(QuaggaHost(name = 'b1', ip = '172.0.0.11/16', mac ='08:00:27:92:18:1f', port = 2))
 		quaggaHosts.append(QuaggaHost(name = 'c1', ip = '172.0.0.21/16', mac = '08:00:27:54:56:ea', port = 3))
コード例 #12
0
ファイル: topology.py プロジェクト: NeveIsa/cs651
    def __init__(self):
        """Initialize a Quagga topology based on the topology information"""
        Topo.__init__(self)

        # Initialize a service helper for Quagga with default options
        self.quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        self.quaggaBaseConfigPath = '/root/configs/'

        # Setup each Quagga router
        for router_name in nc_routers('i2'):
            info("\tAdding router %s\n" % (router_name))
            self.addHost(name=router_name,
                         hostname=router_name,
                         privateLogDir=True,
                         privateRunDir=True,
                         inMountNamespace=True,
                         inPIDNamespace=True,
                         inUTSNamespace=True)

            # Add a loopback interface with an IP in router's announced range
            self.addNodeLoopbackIntf(router_name, ip=nc_loopback(router_name))

            # Configure and setup the Quagga service for this node
            quaggaSvcConfig = \
                {'quaggaConfigPath': self.quaggaBaseConfigPath + router_name}
            self.addNodeService(node=router_name,
                                service=self.quaggaSvc,
                                nodeConfig=quaggaSvcConfig)

            # print self.quaggaBaseConfigPath + router_name

        # Create the normal host connected to the routers
        for host_name in nc_hosts('i2'):
            info("\tAdding hosts %s\n" % (host_name))
            self.addHost(name=host_name,
                         hostname=host_name,
                         privateLogDir=True,
                         privateRunDir=True,
                         inMountNamespace=True,
                         inPIDNamespace=True,
                         inUTSNamespace=True)
コード例 #13
0
    def __init__(self):
        """Initialize a Quagga topology with 5 routers, configure their IP
           addresses, loop back interfaces, and paths to their private
           configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'

        # List of Quagga host configs

        router = QuaggaHost(name='r1', ip='192.0.1.1/24', loIP=None)

        quaggaContainer1 = self.addHost(name=router.name,
                                        ip=router.ip,
                                        hostname=router.name,
                                        privateLogDir=True,
                                        privateRunDir=True,
                                        inMountNamespace=True,
                                        inPIDNamespace=True,
                                        inUTSNamespace=True)

        # Add a loopback interface with an IP in router's announced range

        # Configure and setup the Quagga service for this node
        quaggaSvcConfig= \
         {'quaggaConfigPath': quaggaBaseConfigPath + router.name}
        self.addNodeService(node=router.name,
                            service=quaggaSvc,
                            nodeConfig=quaggaSvcConfig)

        # Attach the quaggaContainer to the IXP Fabric Switch
        # self.addLink(quaggaContainer, ixpfabric)
        ##########################################################################
        router2 = QuaggaHost(name='r2', ip='192.0.2.1/24', loIP=None)

        quaggaContainer2 = self.addHost(name=router2.name,
                                        ip=router2.ip,
                                        hostname=router2.name,
                                        privateLogDir=True,
                                        privateRunDir=True,
                                        inMountNamespace=True,
                                        inPIDNamespace=True,
                                        inUTSNamespace=True)

        # Configure and setup the Quagga service for this node
        quaggaSvcConfig= \
                {'quaggaConfigPath': quaggaBaseConfigPath + router2.name}
        self.addNodeService(node=router2.name,
                            service=quaggaSvc,
                            nodeConfig=quaggaSvcConfig)
        ###############################################################################
        router3 = QuaggaHost(name='r3', ip='192.0.3.1/24', loIP=None)

        quaggaContainer3 = self.addHost(name=router3.name,
                                        ip=router3.ip,
                                        hostname=router3.name,
                                        privateLogDir=True,
                                        privateRunDir=True,
                                        inMountNamespace=True,
                                        inPIDNamespace=True,
                                        inUTSNamespace=True)

        # Configure and setup the Quagga service for this node
        quaggaSvcConfig= \
                {'quaggaConfigPath': quaggaBaseConfigPath + router3.name}
        self.addNodeService(node=router3.name,
                            service=quaggaSvc,
                            nodeConfig=quaggaSvcConfig)
        ##########################################################################
        router4 = QuaggaHost(name='r4', ip='192.0.4.1/24', loIP=None)

        quaggaContainer4 = self.addHost(name=router4.name,
                                        ip=router4.ip,
                                        hostname=router4.name,
                                        privateLogDir=True,
                                        privateRunDir=True,
                                        inMountNamespace=True,
                                        inPIDNamespace=True,
                                        inUTSNamespace=True)

        # Configure and setup the Quagga service for this node
        quaggaSvcConfig= \
                {'quaggaConfigPath': quaggaBaseConfigPath + router4.name}
        self.addNodeService(node=router4.name,
                            service=quaggaSvc,
                            nodeConfig=quaggaSvcConfig)

        ####################################################################
        host1 = QuaggaHost(name='h1', ip='192.0.1.16/24', loIP=None)

        quaggaContainerh1 = self.addHost(name=host1.name,
                                         ip=host1.ip,
                                         hostname=host1.name,
                                         privateLogDir=True,
                                         privateRunDir=True,
                                         inMountNamespace=True,
                                         inPIDNamespace=True,
                                         inUTSNamespace=True)

        # Configure and setup the Quagga service for this node
        quaggaSvcConfig= \
                {'quaggaConfigPath': quaggaBaseConfigPath + host1.name}
        self.addNodeService(node=host1.name,
                            service=quaggaSvc,
                            nodeConfig=quaggaSvcConfig)

        host2 = QuaggaHost(name='h2', ip='192.0.4.16/24', loIP=None)

        quaggaContainerh2 = self.addHost(name=host2.name,
                                         ip=host2.ip,
                                         hostname=host2.name,
                                         privateLogDir=True,
                                         privateRunDir=True,
                                         inMountNamespace=True,
                                         inPIDNamespace=True,
                                         inUTSNamespace=True)

        # Configure and setup the Quagga service for this node
        quaggaSvcConfig= \
                {'quaggaConfigPath': quaggaBaseConfigPath + host2.name}
        self.addNodeService(node=host2.name,
                            service=quaggaSvc,
                            nodeConfig=quaggaSvcConfig)

        self.addLink(quaggaContainerh1, quaggaContainer1)
        self.addLink(quaggaContainerh2, quaggaContainer4)
        self.addLink(quaggaContainer1, quaggaContainer2)
        #self.addLink( quaggaContainer2, quaggaContainer1 )

        self.addLink(quaggaContainer1, quaggaContainer3)
        self.addLink(quaggaContainer4, quaggaContainer3)
        self.addLink(quaggaContainer4, quaggaContainer2)
コード例 #14
0
    def __init__(self):
        """Initialize a Quagga topology with 4 routers and 2 hosts, 
           configure their IP addresses, loop back interfaces, 
           and paths to their private configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'

        # List of Quagga host configs
        quaggaHosts = []
        quaggaHosts.append(
            QuaggaHost(name='r1',
                       ip='172.0.1.2/24',
                       loIP='10.0.1.1/24',
                       type='host'))
        quaggaHosts.append(
            QuaggaHost(name='r2',
                       ip='172.0.2.2/24',
                       loIP='10.0.2.1/24',
                       type='host'))
        quaggaHosts.append(
            QuaggaHost(name='r3',
                       ip='172.0.3.2/24',
                       loIP='10.0.3.1/24',
                       type='host'))
        quaggaHosts.append(
            QuaggaHost(name='r4',
                       ip='172.0.4.2/24',
                       loIP='10.0.4.1/24',
                       type='host'))

        quaggaHosts.append(
            QuaggaHost(name='h1',
                       ip='172.0.1.1/24',
                       loIP='10.0.1.1/24',
                       type='host'))
        quaggaHosts.append(
            QuaggaHost(name='h2',
                       ip='172.0.6.2/24',
                       loIP='10.0.6.1/24',
                       type='host'))

        # Add switch for IXP fabric
        #ixpfabric = self.addSwitch('fabric-sw1')

        containers = []

        # Setup each Quagga router
        for host in quaggaHosts:

            # Create an instance of a host, called a quaggaContainer
            if host.type == 'host':
                quaggaContainer = self.addHost(name=host.name,
                                               ip=host.ip,
                                               hostname=host.name,
                                               privateLogDir=True,
                                               privateRunDir=True,
                                               inMountNamespace=True,
                                               inPIDNamespace=True,
                                               inUTSNamespace=True)
            else:
                quaggaContainer = self.addSwitch(name=host.name,
                                                 ip=host.ip,
                                                 hostname=host.name,
                                                 privateLogDir=True,
                                                 privateRunDir=True,
                                                 inMountNamespace=True,
                                                 inPIDNamespace=True,
                                                 inUTSNamespace=True)

            containers.append(quaggaContainer)

            # Add a loopback interface with an IP in router's announced range
            self.addNodeLoopbackIntf(node=host.name, ip=host.loIP)

            # Configure and setup the Quagga service for this node
            quaggaSvcConfig = \
                {'quaggaConfigPath': quaggaBaseConfigPath + host.name}
            self.addNodeService(node=host.name,
                                service=quaggaSvc,
                                nodeConfig=quaggaSvcConfig)

        # Attach the quaggaContainer to the IXP Fabric Switch
        #self.addLink(quaggaContainer, ixpfabric)

# Manually assign links
        self.addLink(containers[0], containers[4])
        self.addLink(containers[0], containers[1])
        self.addLink(containers[0], containers[2])
        self.addLink(containers[1], containers[3])
        self.addLink(containers[2], containers[3])
        self.addLink(containers[3], containers[5])
コード例 #15
0
    def __init__(self):
        """Initialize a Quagga topology with 5 routers, configure
           their IP addresses, loop back interfaces, and paths to
           their private configuration directories. Also start a redis
           sever at IP address 172.1.1.1.  Chain topology is A -> B ->
           C -> D -> E."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)
        #       redisSvc = RedisService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'
        #        redisBaseConfigPath = selfPath + '/configs/'

        # Add switch for IXP fabric
        ixpfabricA = self.addSwitch('fabric-sw1')
        ixpfabricB = self.addSwitch('fabric-sw2')
        ixpfabricC = self.addSwitch('fabric-sw3')

        self.addLink(ixpfabricA, ixpfabricB)
        self.addLink(ixpfabricB, ixpfabricC)

        # List of Quagga host configs
        quaggaHosts = []
        # 0
        quaggaHosts.append(
            QuaggaHost(name='a1',
                       ip='172.0.1.1/8',
                       loIP='10.0.1.1/24',
                       switch=ixpfabricA))
        quaggaHosts.append(
            QuaggaHost(name='a2',
                       ip='172.0.2.1/8',
                       loIP='10.0.2.1/24',
                       switch=ixpfabricA))
        # 2
        quaggaHosts.append(
            QuaggaHost(name='b1',
                       ip='172.1.1.1/8',
                       loIP='10.1.1.1/24',
                       switch=ixpfabricB))
        quaggaHosts.append(
            QuaggaHost(name='b2',
                       ip='172.1.2.1/8',
                       loIP='10.1.2.1/24',
                       switch=ixpfabricB))
        quaggaHosts.append(
            QuaggaHost(name='b3',
                       ip='172.1.3.1/8',
                       loIP='10.1.3.1/24',
                       switch=ixpfabricB))
        quaggaHosts.append(
            QuaggaHost(name='b4',
                       ip='172.1.4.1/8',
                       loIP='10.1.4.1/24',
                       switch=ixpfabricB))
        quaggaHosts.append(
            QuaggaHost(name='b5',
                       ip='172.1.5.1/8',
                       loIP='10.1.5.1/24',
                       switch=ixpfabricB))
        # 7
        quaggaHosts.append(
            QuaggaHost(name='c1',
                       ip='172.2.1.1/8',
                       loIP='10.2.1.1/24',
                       switch=ixpfabricC))
        quaggaHosts.append(
            QuaggaHost(name='c2',
                       ip='172.2.2.1/8',
                       loIP='10.2.2.1/24',
                       switch=ixpfabricC))
        quaggaHosts.append(
            QuaggaHost(name='c3',
                       ip='172.2.3.1/8',
                       loIP='10.2.3.1/24',
                       switch=ixpfabricC))
        quaggaHosts.append(
            QuaggaHost(name='c4',
                       ip='172.2.4.1/8',
                       loIP='10.2.4.1/24',
                       switch=ixpfabricC))

        loadHosts = []

        # load generators
        # (no)

        #        testHost = self.addHost(name='test')

        # Setup each Quagga router, add a link between it and the IXP fabric
        for host in quaggaHosts:

            # Create an instance of a host, called a quaggaContainer
            quaggaContainer = self.addHost(name=host.name,
                                           ip=host.ip,
                                           hostname=host.name,
                                           privateLogDir=True,
                                           privateRunDir=True,
                                           inMountNamespace=True,
                                           inPIDNamespace=True,
                                           inUTSNamespace=True)

            # Add a loopback interface with an IP in router's announced range
            self.addNodeLoopbackIntf(node=host.name, ip=host.loIP)

            # Configure and setup the Quagga service for this node
            quaggaSvcConfig = \
                {'quaggaConfigPath': quaggaBaseConfigPath + host.name}
            self.addNodeService(node=host.name,
                                service=quaggaSvc,
                                nodeConfig=quaggaSvcConfig)

            # Attach the quaggaContainer to the IXP Fabric Switch
            self.addLink(host.switch, quaggaContainer)
コード例 #16
0
ファイル: topo.py プロジェクト: chuzirui/swift
    def __init__(self):
        """Initialize a Quagga topology with 5 routers, configure their IP
           addresses, loop back interfaces, and paths to their private
           configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'

        # List of Quagga host configs
        quaggaHosts = {}
        #quaggaHosts['r1'] = (QuaggaHost(name='r1', ip='172.0.1.1/16', loIP='10.0.1.1/24'))
        quaggaHosts['r2'] = QuaggaHost(name='r2',
                                       ip='172.0.2.1/16',
                                       loIP='10.0.2.1/24')
        quaggaHosts['r3'] = QuaggaHost(name='r3',
                                       ip='172.0.3.1/16',
                                       loIP='10.0.3.1/24')
        quaggaHosts['r4'] = QuaggaHost(name='r4',
                                       ip='172.0.4.1/16',
                                       loIP='10.0.4.1/24')
        quaggaHosts['r5'] = QuaggaHost(name='r5',
                                       ip='172.0.5.1/16',
                                       loIP='10.0.5.1/24')
        #quaggaHosts['r6'] = (QuaggaHost(name='r6', ip='172.0.6.1/16', loIP='10.0.6.1/24'))

        # Add the switch for the SWIFTED router
        ovs_switch = self.addSwitch('s1', dpid='1')

        # Setup each Quagga router, add a link between it and the IXP fabric
        for name, host in quaggaHosts.iteritems():

            # Create an instance of a host, called a quaggaContainer
            quaggaContainer = self.addHost(name=host.name,
                                           ip=host.ip,
                                           hostname=host.name,
                                           privateLogDir=True,
                                           privateRunDir=True,
                                           inMountNamespace=True,
                                           inPIDNamespace=True,
                                           inUTSNamespace=True)

            # Add a loopback interface with an IP in router's announced range
            self.addNodeLoopbackIntf(node=host.name, ip=host.loIP)

            # Configure and setup the Quagga service for this node
            quaggaSvcConfig = \
                {'quaggaConfigPath': quaggaBaseConfigPath + host.name}
            self.addNodeService(node=host.name,
                                service=quaggaSvc,
                                nodeConfig=quaggaSvcConfig)

        r6 = self.addHost(name='r6',
                          ip='172.0.6.1/16',
                          hostname='r6',
                          privateLogDir=True,
                          privateRunDir=True,
                          inMountNamespace=True,
                          inPIDNamespace=True,
                          inUTSNamespace=True)

        r1 = self.addHost(name='r1',
                          ip='172.0.1.1/16',
                          hostname='r1',
                          privateLogDir=True,
                          privateRunDir=True,
                          inMountNamespace=True,
                          inPIDNamespace=True,
                          inUTSNamespace=True)

        # Attach the quaggaContainer to the IXP Fabric Switch
        self.addLink('r1', ovs_switch, intfName1="s1", intfName2='r1-ovs')
        self.addLink('r2', ovs_switch, intfName1="s1", intfName2='r2-ovs')
        self.addLink('r3', ovs_switch, intfName1="s1", intfName2='r3-ovs')
        self.addLink('r4', ovs_switch, intfName1="s1", intfName2='r4-ovs')
コード例 #17
0
ファイル: topo.py プロジェクト: PranaviDadireddy/Mininets
    def __init__(self):
        """Initialize a Quagga topology with 5 routers, configure their IP
           addresses, loop back interfaces, and paths to their private
           configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        zebraConf = '%s/zebra.conf' % CONFIG_DIR

        #Adding Host 1
        h1 = self.addHost('h1',
                          cls=MyHost,
                          ip='192.168.1.1/24',
                          route='192.168.1.12')

        #Adding Host 2
        h2 = self.addHost('h2',
                          cls=MyHost,
                          ip='192.168.6.12/24',
                          route='192.168.6.1')

        #Adding Router 1
        eth0 = {'ipAddrs': ['192.168.1.12/24']}
        eth1 = {'ipAddrs': ['192.168.2.1/24']}
        eth2 = {'ipAddrs': ['192.168.4.1/24']}

        intfs = {'r1-eth0': eth0, 'r1-eth1': eth1, 'r1-eth2': eth2}

        quaggaConf = '%s/quagga1.conf' % CONFIG_DIR

        r1 = self.addHost('r1',
                          cls=MyRouter,
                          quaggaConfFile=quaggaConf,
                          zebraConfFile=zebraConf,
                          intfDict=intfs)

        #Adding Router 2
        eth0 = {'ipAddrs': ['192.168.2.12/24']}
        eth1 = {'ipAddrs': ['192.168.3.1/24']}

        intfs = {'r2-eth0': eth0, 'r2-eth1': eth1}

        quaggaConf = '%s/quagga2.conf' % CONFIG_DIR

        r2 = self.addHost('r2',
                          cls=MyRouter,
                          quaggaConfFile=quaggaConf,
                          zebraConfFile=zebraConf,
                          intfDict=intfs)

        #Adding Router 3
        eth0 = {'ipAddrs': ['192.168.4.12/24']}
        eth1 = {'ipAddrs': ['192.168.5.1/24']}

        intfs = {'r3-eth0': eth0, 'r3-eth1': eth1}

        quaggaConf = '%s/quagga3.conf' % CONFIG_DIR

        r3 = self.addHost('r3',
                          cls=MyRouter,
                          quaggaConfFile=quaggaConf,
                          zebraConfFile=zebraConf,
                          intfDict=intfs)

        #Adding Router 4
        eth0 = {'ipAddrs': ['192.168.3.12/24']}
        eth1 = {'ipAddrs': ['192.168.5.12/24']}
        eth2 = {'ipAddrs': ['192.168.6.1/24']}

        intfs = {'r4-eth0': eth0, 'r4-eth1': eth1, 'r4-eth2': eth2}

        quaggaConf = '%s/quagga4.conf' % CONFIG_DIR

        r4 = self.addHost('r4',
                          cls=MyRouter,
                          quaggaConfFile=quaggaConf,
                          zebraConfFile=zebraConf,
                          intfDict=intfs)

        self.addLink(h1, r1)
        self.addLink(r1, r2)
        self.addLink(r1, r3)
        self.addLink(r2, r4)
        self.addLink(r3, r4)
        self.addLink(r4, h2)
コード例 #18
0
ファイル: topo.py プロジェクト: arsheth/mininet
    def __init__(self):
        """Initialize a Quagga topology with 5 routers, configure their IP
           addresses, loop back interfaces, and paths to their private
           configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'

        # List of Quagga host configs
        h1 = self.addHost('h1',
                          cls=QuaggaHost,
                          ip='150.100.1.11/24',
                          route='150.100.1.254')
        #	print self
        #	self.cmd('h1 route add deault gw 150.100.1.254')
        h2 = self.addHost('h2',
                          cls=QuaggaHost,
                          ip='150.100.2.12/24',
                          route='150.100.2.254')
        #	h2.cmd('route add default gw 150.100.2.254')

        eth0 = {'mac': '00:00:00:01:01', 'ipAddrs': ['150.100.1.254/24']}
        eth1 = {'ipAddrs': ['172.16.1.1/24']}
        eth2 = {'ipAddrs': ['172.16.2.1/24']}
        intfs = {'r1-eth0': eth0, 'r1-eth1': eth1, 'r1-eth2': eth2}
        quaggaConf = '%s/quagga1.conf' % (CONFIG_DIR)
        dests = ['150.100.2.0', '150.100.2.0']
        gws = ['172.16.1.254', '172.16.2.254']
        ports = ['r1-eth1', 'r1-eth2']
        r1 = self.addHost('r1',
                          cls=Router,
                          quaggaConfFile=quaggaConf,
                          intfDict=intfs)  #, dests=dests,gws=gws,ports=ports)
        #	r1.cmd('route add -net 150.100.2.0 gw 172.16.1.254 netmask 255.255.255.0 r1-eth1')
        #	r1.cmd('route add -net 150.100.2.0 gw 172.16.2.254 netmask 255.255.255.0 r1-eth2')

        eth0 = {'mac': '00:00:00:02:01', 'ipAddrs': ['172.16.1.254/24']}
        eth1 = {'ipAddrs': ['172.16.3.1/24']}
        intfs = {'r2-eth0': eth0, 'r2-eth1': eth1}
        quaggaConf = '%s/quagga2.conf' % (CONFIG_DIR)

        dests = ['150.100.2.0', '150.100.1.0']
        gws = ['172.16.3.254', '172.16.1.1']
        ports = ['r2-eth1', 'r2-eth0']
        r2 = self.addHost('r2',
                          cls=Router,
                          quaggaConfFile=quaggaConf,
                          intfDict=intfs)  #,dests=dests,gws=gws,ports=ports)
        #	r2.cmd('route add -net 150.100.2.0 gw 172.16.3.254 netmask 255.255.255.0 r2-eth1')
        #	r2.cmd('route add -net 150.100.1.0 gw 172.16.1.1 netmask 255.255.255.0 r2-eth0')

        eth0 = {'mac': '00:00:00:03:01', 'ipAddrs': ['172.16.2.254/24']}
        eth1 = {'ipAddrs': ['172.16.4.1/24']}
        intfs = {'r3-eth0': eth0, 'r3-eth1': eth1}
        quaggaConf = '%s/quagga3.conf' % (CONFIG_DIR)

        dests = ['150.100.2.0', '150.100.1.0']
        gws = ['172.16.4.254', '172.16.2.1']
        ports = ['r3-eth1', 'r3-eth0']
        r3 = self.addHost('r3',
                          cls=Router,
                          quaggaConfFile=quaggaConf,
                          intfDict=intfs)  #,dests=dests,gws=gws,ports=ports)
        #r3.cmd('route add -net 150.100.2.0 gw 172.16.4.254 netmask 255.255.255.0 r3-eth1')
        #r3.cmd('route add -net 150.100.1.0 gw 172.16.2.1 netmask 255.255.255.0 r3-eth0')

        eth1 = {'ipAddrs': ['172.16.4.254/24']}
        eth0 = {'mac': '00:00:00:04:01', 'ipAddrs': ['172.16.3.254/24']}
        eth2 = {'ipAddrs': ['150.100.2.254/24']}
        intfs = {'r4-eth0': eth0, 'r4-eth1': eth1, 'r4-eth2': eth2}
        quaggaConf = '%s/quagga4.conf' % (CONFIG_DIR)
        #	dests = ['150.100.1.0','150.100.1.0']
        #	gws = ['172.16.2.1','172.16.4.1']
        #	ports = ['r4-eth0','r4-eth1']
        r4 = self.addHost('r4',
                          cls=Router,
                          quaggaConfFile=quaggaConf,
                          intfDict=intfs)  #,dests=dests,gws=gws,ports=ports)
        #r4.cmd('route add -net 150.100.1.0 gw 172.16.2.1 netmask 255.255.255.0 r4-eth0')
        #r4.cmd('route add -net 150.100.1.0 gw 172.16.4.1 netmask 255.255.255.0 r4-eth1')
        '''
        quaggaHosts = []
        quaggaHosts.append(QuaggaHost(name='h1', ip='192.168.1.1/24',
                                     loIP = '127.0.0.1'))
        quaggaHosts.append(QuaggaHost(name='h2', ip='192.168.2.100/16',
                                      loIP='127.0.0.1'))
        quaggaHosts.append(QuaggaHost(name='r1'))
        quaggaHosts.append(QuaggaHost(name='r2'))
        quaggaHosts.append(QuaggaHost(name='r3'))
        quaggaHosts.append(QuaggaHost(name='r4'))
	'''
        self.addLink(h1, r1)
        self.addLink(r1, r2)
        self.addLink(r1, r3)
        self.addLink(r2, r4)
        self.addLink(r3, r4)
        self.addLink(r4, h2)
コード例 #19
0
    def __init__(self, topo_info, router_lo):
        """Initialize a Quagga topology based on the topology information"""
        Topo.__init__(self)

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = '/root/configs/'

        # Dictionnary used to store the hosts
        quagga_hosts = {}

        normal_hosts = {}

        # Setup each Quagga router
        for router_name in topo_info:
            # Create the quagga hosts
            quagga_hosts[router_name] = self.addHost(name=router_name,
                                                     hostname=router_name,
                                                     privateLogDir=True,
                                                     privateRunDir=True,
                                                     inMountNamespace=True,
                                                     inPIDNamespace=True,
                                                     inUTSNamespace=True)

            # Create the normal host connected to the quagga host above
            normal_hosts[router_name + '-host'] = self.addHost(
                name=router_name + '-host',
                hostname=router_name + '-host',
                privateLogDir=True,
                privateRunDir=True,
                inMountNamespace=True,
                inPIDNamespace=True,
                inUTSNamespace=True)

            # Add a loopback interface with an IP in router's announced range
            self.addNodeLoopbackIntf(router_name, ip=router_lo[router_name])

            # Configure and setup the Quagga service for this node
            quaggaSvcConfig = \
                {'quaggaConfigPath': quaggaBaseConfigPath + router_name}
            self.addNodeService(node=router_name,
                                service=quaggaSvc,
                                nodeConfig=quaggaSvcConfig)

            print quaggaBaseConfigPath + router_name

        # Create an open v switch to connect the network to the ouside world
        ovs_switch = self.addSwitch('EBGP_PEER', dpid='1')

        # Connect all the routers to OVS, for potentiel future ebgp sessions
        for router_name in topo_info:
            if router_name != 'HOUS':
                self.addLink(quagga_hosts[router_name],
                             ovs_switch,
                             intfName1=router_name.lower() + "-ovs",
                             intfName2="ebgp_peer")

# Add the management interface to HOUS
        self.addLink(quagga_hosts['HOUS'],
                     ovs_switch,
                     intfName1='hous-mgt-ovs',
                     intfName2='mgt')

        # Setup each link between two Quagga routers
        """links_set = Set()
        i = 0
        for router_name, ngh_list in topo_info.items():
            for ngh_ip in ngh_list:
                ngh = ngh_ip[0]
                print 'Link added between '+str(router_name)+' and '+str(ngh)

                # Make sure to only create one link between two routers
                if ngh+router_name not in links_set:
                    self.addLink(quagga_hosts[router_name], quagga_hosts[ngh], \
                        intfName1=ngh.lower()+str(i), intfName2=router_name.lower()+str(i))
                    links_set.add(router_name+ngh)

            i += 0
        # List of Quagga host configs"""
        """quaggaHosts = []
コード例 #20
0
    def __init__(self):
        """Initialize a Quagga topology with 5 routers, configure their IP
           addresses, loop back interfaces, and paths to their private
           configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(os.path.abspath(
            inspect.getfile(inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'

	# Save order of node numeber/order to node name
	h1 = 0
	r1 = 1
	r2 = 2
	r3 = 3
	r4 = 4
	h2 = 5


        # List of Quagga host configs
        quaggaHosts = []
        quaggaHosts.append(QuaggaHost(name='h1', ip='10.10.11.1/24',
                                      loIP=None))
	quaggaHosts.append(QuaggaHost(name='r1', ip='10.10.11.2/24',
                                      loIP=None))
        quaggaHosts.append(QuaggaHost(name='r2', ip='10.10.12.2/24',
                                      loIP=None))
        quaggaHosts.append(QuaggaHost(name='r3', ip='10.10.13.2/24',
                                      loIP=None))
        quaggaHosts.append(QuaggaHost(name='r4', ip='10.10.14.2/24',
                                      loIP=None))
        quaggaHosts.append(QuaggaHost(name='h2', ip='10.10.16.2/24',
                                      loIP=None))



	quaggaContainers =[]
        # Setup each Quagga router, add a link between it and the IXP fabric
        for host in quaggaHosts:

            # Create an instance of a host, called a quaggaContainer
            quaggaContainers.append(self.addHost(name=host.name,
                                           ip=host.ip,
                                           hostname=host.name,
                                           privateLogDir=True,
                                           privateRunDir=True,
                                           inMountNamespace=True,
                                           inPIDNamespace=True,
                                           inUTSNamespace=True))


            # Configure and setup the Quagga service for this node
            quaggaSvcConfig = \
                {'quaggaConfigPath': quaggaBaseConfigPath + host.name}
            self.addNodeService(node=host.name, service=quaggaSvc,
                                nodeConfig=quaggaSvcConfig)

	# Link between h1 r1
        self.addLink(quaggaContainers[h1],quaggaContainers[r1], params1={'ip':'10.10.11.1/24'}, params2={'ip':'10.10.11.2/24'})
        self.addLink(quaggaContainers[r1],quaggaContainers[r2], params1={'ip':'10.10.12.1/24'}, params2={'ip':'10.10.12.2/24'})
        self.addLink(quaggaContainers[r1],quaggaContainers[r3], params1={'ip':'10.10.13.1/24'}, params2={'ip':'10.10.13.2/24'})
        self.addLink(quaggaContainers[r2],quaggaContainers[r4], params1={'ip':'10.10.14.1/24'}, params2={'ip':'10.10.14.2/24'})
        self.addLink(quaggaContainers[h2],quaggaContainers[r4], params1={'ip':'10.10.16.2/24'}, params2={'ip':'10.10.16.1/24'})
        self.addLink(quaggaContainers[r3],quaggaContainers[r4], params1={'ip':'10.10.15.1/24'}, params2={'ip':'10.10.15.2/24'})
コード例 #21
0
ファイル: topo.py プロジェクト: mfalgert/ews
#!/usr/bin/python

import inspect
import os
from mininext.topo import Topo
from mininext.services.quagga import QuaggaService
from collections import namedtuple

QuaggaHost = namedtuple("QuaggaHost", "name ip mac")
net = None
# Directory where this file / script is located
selfPath = os.path.dirname(
    os.path.abspath(inspect.getfile(
        inspect.currentframe())))  # script directory
# Initialize a service helper for Quagga with default options
quaggaSvc = QuaggaService(autoStop=False)
# Path configurations for mounts
quaggaBaseConfigPath = selfPath + "/configs/"


class QuaggaTopo(Topo):
    def addQuaggaLinks(self, quaggas):
        self.addLink(quaggas["100_r2"], quaggas["200_r1"], delay="10ms")
        self.addLink(quaggas["100_r2"], quaggas["5100_rt"], delay="10ms")
        self.addLink(quaggas["100_r2"], quaggas["700_r1"], delay="10ms")
        self.addLink(quaggas["100_r1"], quaggas["100_r2"], delay="2ms")
        self.addLink(quaggas["200_r2"], quaggas["300_r1"], delay="10ms")
        self.addLink(quaggas["200_r2"], quaggas["5200_rt"], delay="10ms")
        self.addLink(quaggas["200_r1"], quaggas["200_r2"], delay="2ms")
        self.addLink(quaggas["300_r2"], quaggas["400_r1"], delay="10ms")
        self.addLink(quaggas["300_r2"], quaggas["5300_rt"], delay="10ms")
コード例 #22
0
    def __init__(self):
        """Initialize a Quagga topology with 5 routers, configure their IP
           addresses, loop back interfaces, and paths to their private
           configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'

        # List of Quagga host configs
        quaggaHosts = []

        # Add switch for IXP fabric
        #ixpfabric = self.addSwitch('fabric-sw1')

        H1 = QuaggaHost(name='h1', ip='172.0.1.1/24', loIP='10.0.1.1/24')
        R1 = QuaggaHost(name='r1', ip='172.0.1.2/24', loIP='10.0.1.2/24')
        H2 = QuaggaHost(name='h2', ip='172.0.6.2/24', loIP='10.0.6.2/24')
        R4 = QuaggaHost(name='r4', ip='172.0.4.2/24', loIP='10.0.4.2/24')
        R2 = QuaggaHost(name='r2', ip='172.0.2.2/24', loIP='10.0.2.2/24')
        R3 = QuaggaHost(name='r3', ip='172.0.3.2/24', loIP='10.0.3.2/24')

        quaggaHosts.append(H1)
        quaggaHosts.append(R1)
        quaggaHosts.append(H2)
        quaggaHosts.append(R4)
        quaggaHosts.append(R2)
        quaggaHosts.append(R3)

        quaggaNodes = []

        # Setup each Quagga router, add a link between it and the IXP fabric
        for host in quaggaHosts:

            # Create an instance of a host, called a quaggaContainer
            quaggaContainer = self.addHost(name=host.name,
                                           ip=host.ip,
                                           hostname=host.name,
                                           privateLogDir=True,
                                           privateRunDir=True,
                                           inMountNamespace=True,
                                           inPIDNamespace=True,
                                           inUTSNamespace=True)

            quaggaNodes.append(quaggaContainer)

            # Add a loopback interface with an IP in router's announced range
            self.addNodeLoopbackIntf(node=host.name, ip=host.loIP)

            # Configure and setup the Quagga service for this node
            quaggaSvcConfig = \
                {'quaggaConfigPath': quaggaBaseConfigPath + host.name}
            self.addNodeService(node=host.name,
                                service=quaggaSvc,
                                nodeConfig=quaggaSvcConfig)

            # Attach the quaggaContainer to the IXP Fabric Switch
            #self.addLink(quaggaContainer, ixpfabric)

        self.addLink(quaggaNodes[0],
                     quaggaNodes[1],
                     intfName1='h1-eth0',
                     params1={'ip': '172.0.1.1/24'},
                     intfName2='r1-eth0',
                     params2={'ip': '172.0.1.2/24'})

        self.addLink(quaggaNodes[1],
                     quaggaNodes[4],
                     intfName1='r1-eth1',
                     params1={'ip': '172.0.2.1/24'},
                     intfName2='r2-eth0',
                     params2={'ip': '172.0.2.2/24'})
        self.addLink(quaggaNodes[1],
                     quaggaNodes[5],
                     intfName1='r1-eth2',
                     params1={'ip': '172.0.3.1/24'},
                     intfName2='r3-eth0',
                     params2={'ip': '172.0.3.2/24'})

        self.addLink(quaggaNodes[4],
                     quaggaNodes[3],
                     intfName1='r2-eth1',
                     params1={'ip': '172.0.4.1/24'},
                     intfName2='r4-eth0',
                     params2={'ip': '172.0.4.2/24'})

        self.addLink(quaggaNodes[5],
                     quaggaNodes[3],
                     intfName1='r3-eth1',
                     params1={'ip': '172.0.5.1/24'},
                     intfName2='r4-eth1',
                     params2={'ip': '172.0.5.2/24'})

        self.addLink(quaggaNodes[2],
                     quaggaNodes[3],
                     intfName1='h2-eth0',
                     params1={'ip': '172.0.6.2/24'},
                     intfName2='r4-eth2',
                     params2={'ip': '172.0.6.1/24'})
コード例 #23
0
ファイル: jamtopo.py プロジェクト: anrl/JAMEmulator
    def __init__(self, config):
        Topo.__init__(self)
        checkDupEth(config)
        groups = ["cloud", "fog", "device"]
        nodes = dict()

        for i in groups:
            if (i in config):
                for j in config[i]: 
                    # Check if the CPU resources available to host are restricted
                    cpu = j["cpu"] if "cpu" in j else 1.0
                    if ("ip" in j): 
                        self.addHost(j["name"], ip=ip, cpu=cpu)
                    else:
                        self.addHost(j["name"], cpu=cpu)


        if (not "switch" in config or len(config["switch"]) == 0):
            raise RuntimeError("Topology must have at least one switch")
        else:
            for i in config["switch"]:
                self.addSwitch(i["name"])

        if ("router" in config):
            # Directory where this file / script is located"
            selfPath = os.path.dirname(os.path.abspath(
            inspect.getfile(inspect.currentframe())))  # script directory
            # Initialize a service helper for Quagga with default options
            quaggaSvc = QuaggaService(autoStop=False)
            # Path configurations for mounts
            quaggaBaseConfigPath = selfPath + "/configs/"
            
            for i in config["router"]:
                # Create an instance of a host, called a quaggaContainer
                self.addHost(name=i["name"],
                             hostname=i["name"],
                             privateLogDir=True,
                             privateRunDir=True,
                             inMountNamespace=True,
                             inPIDNamespace=True,
                             inUTSNamespace=True)

                # Configure and setup the Quagga service for this node
                quaggaSvcConfig = \
                    {"quaggaConfigPath": quaggaBaseConfigPath + i["name"]}
                self.addNodeService(node=i["name"], service=quaggaSvc,
                                    nodeConfig=quaggaSvcConfig)
        
        if ("link" in config):
            for i in config["link"]:            
                bw = i["bw"] if "bw" in i else 100
                delay = i["delay"] if "delay" in i else "0ms"
                loss = i["loss"] if "loss" in i else 0     

                if isinstance(i["node1"], dict): 
                    name1 = i["node1"]["name"]
                else: 
                    name1 = i["node1"]
                if isinstance(i["node2"], dict): 
                    name2 = i["node2"]["name"]
                else: 
                    name2 = i["node2"]    
                self.addLink(name1, name2, bw=bw, delay=delay, loss=loss)
コード例 #24
0
    def __init__(self):
        """Initialize a Quagga topology with 4 routers and 2 hosts, configure their IP
           addresses, loop back interfaces, and paths to their private
           configuration directories."""
        Topo.__init__(self)

        # Directory where this file / script is located"
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(
                inspect.currentframe())))  # script directory

        # Initialize a service helper for Quagga with default options
        quaggaSvc = QuaggaService(autoStop=False)

        # Path configurations for mounts
        quaggaBaseConfigPath = selfPath + '/configs/'

        # List of Quagga host configs
        quaggaHosts = []
        # quaggaHosts.append(QuaggaHost(name='S1', ip='192.168.1.2/24',
        #                               loIP='127.0.0.1', mac = 'aa:aa:aa:aa:aa:aa'))
        # quaggaHosts.append(QuaggaHost(name='CA', ip='192.168.1.1/26',
        #                               loIP='127.0.0.1', mac = 'bb:bb:bb:bb:bb:bb'))
        # quaggaHosts.append(QuaggaHost(name='H2', ip='192.168.1.64/26',
        #                               loIP='127.0.0.1', mac = 'cc:cc:cc:cc:cc:cc'))
        # quaggaHosts.append(QuaggaHost(name='Target', ip='192.168.1.128/26',
        #                               loIP='127.0.0.1', mac = 'dd:dd:dd:dd:dd:dd'))
        # quaggaHosts.append(QuaggaHost(name='H4', ip='192.168.1.192/26',
        #                               loIP='127.0.0.1', mac = 'ee:ee:ee:ee:ee:ee'))

        quaggaHosts.append(
            QuaggaHost(name='S1',
                       ip='192.168.1.2/24',
                       loIP='127.0.0.1',
                       mac='aa:aa:aa:aa:aa:aa'))
        quaggaHosts.append(
            QuaggaHost(name='CA',
                       ip='192.168.1.1/24',
                       loIP='127.0.0.1',
                       mac='bb:bb:bb:bb:bb:bb'))
        quaggaHosts.append(
            QuaggaHost(name='Victim',
                       ip='192.168.1.64/24',
                       loIP='127.0.0.1',
                       mac='cc:cc:cc:cc:cc:cc'))
        quaggaHosts.append(
            QuaggaHost(name='Target',
                       ip='192.168.1.128/24',
                       loIP='127.0.0.1',
                       mac='dd:dd:dd:dd:dd:dd'))
        quaggaHosts.append(
            QuaggaHost(name='Attacker',
                       ip='192.168.1.192/24',
                       loIP='127.0.0.1',
                       mac='ee:ee:ee:ee:ee:ee'))

        hostDict = dict()

        # Setup each Quagga router, add a link between it
        for host in quaggaHosts:

            if host.name == 'S1':
                # Create an instance of a host, called a quaggaContainer
                quaggaContainer = self.addSwitch(name=host.name,
                                                 ip=host.ip,
                                                 mac=host.mac,
                                                 hostname=host.name,
                                                 privateLogDir=True,
                                                 privateRunDir=True,
                                                 inMountNamespace=True,
                                                 inPIDNamespace=True,
                                                 inUTSNamespace=True)
            else:
                # Create an instance of a host, called a quaggaContainer
                quaggaContainer = self.addHost(name=host.name,
                                               ip=host.ip,
                                               mac=host.mac,
                                               hostname=host.name,
                                               privateLogDir=True,
                                               privateRunDir=True,
                                               inMountNamespace=True,
                                               inPIDNamespace=True,
                                               inUTSNamespace=True)

            hostDict[host.name] = quaggaContainer

            # Add a loopback interface with an IP in router's announced range
            self.addNodeLoopbackIntf(node=host.name, ip=host.loIP)

            # Configure and setup the Quagga service for this node
            quaggaSvcConfig = \
                {'quaggaConfigPath': quaggaBaseConfigPath + host.name}
            self.addNodeService(node=host.name,
                                service=quaggaSvc,
                                nodeConfig=quaggaSvcConfig)

        # CA <-> S1
        self.addLink(hostDict["S1"], hostDict["CA"])
        # R1 <-> Victim
        self.addLink(hostDict["S1"], hostDict["Victim"])
        # S1 <-> Target
        self.addLink(hostDict["S1"], hostDict["Target"])
        # S1 <-> Attacker
        self.addLink(hostDict["S1"], hostDict["Attacker"])
コード例 #25
0
ファイル: sdx_mininext.py プロジェクト: ckannan/iSDX
    def __init__(self):

        "Initialize topology"
        Topo.__init__(self)

        # location of config dir
        configdir = os.path.abspath(sys.argv[1])

        "Initialize a service helper for Quagga with default options"
        quaggaSvc = QuaggaService(autoStop=False)

        "Path configurations for mounts"
        quaggaBaseConfigPath = configdir

        "List of Quagga host configs"
        quaggaHosts = []
        quaggaHosts.append(
            QuaggaHost(name='a1',
                       ip='172.0.0.1/16',
                       mac='08:00:27:89:3b:9f',
                       port=3))
        quaggaHosts.append(
            QuaggaHost(name='b1',
                       ip='172.0.0.11/16',
                       mac='08:00:27:92:18:1f',
                       port=4))
        quaggaHosts.append(
            QuaggaHost(name='c1',
                       ip='172.0.0.21/16',
                       mac='08:00:27:54:56:ea',
                       port=5))
        quaggaHosts.append(
            QuaggaHost(name='c2',
                       ip='172.0.0.22/16',
                       mac='08:00:27:bd:f8:b2',
                       port=6))

        "Add switch for IXP fabric"
        main_switch = self.addSwitch('s1')
        arp_switch = self.addSwitch('s2')
        self.addLink(main_switch, arp_switch, 1, 1)

        # Add node for central Route Server"
        route_server = self.addHost('x1',
                                    ip='172.0.255.254/16',
                                    mac='08:00:27:89:3b:ff',
                                    inNamespace=False)
        self.addLink(main_switch, route_server, 2)

        # Add node for ARP Proxy"
        arp_proxy = self.addHost('x2',
                                 ip='172.0.255.253/16',
                                 mac='08:00:27:89:33:ff',
                                 inNamespace=False)
        self.addLink(arp_switch, arp_proxy, 2)

        "Setup each legacy router, add a link between it and the IXP fabric"
        for host in quaggaHosts:
            "Set Quagga service configuration for this node"
            quaggaSvcConfig = \
            { 'quaggaConfigPath' : os.path.join(configdir, host.name) }

            quaggaContainer = self.addHost(name=host.name,
                                           ip=host.ip,
                                           mac=host.mac,
                                           privateLogDir=True,
                                           privateRunDir=True,
                                           inMountNamespace=True,
                                           inPIDNamespace=True)
            self.addNodeService(node=host.name,
                                service=quaggaSvc,
                                nodeConfig=quaggaSvcConfig)
            "Attach the quaggaContainer to the IXP Fabric Switch"
            self.addLink(quaggaContainer, main_switch, port2=host.port)
コード例 #26
0
ファイル: lab4_topo.py プロジェクト: dtsbourg/TCPIP-Labs
	def __init__(self):
		"""Initialize a Quagga topology with 2 hosts, 5 routers, 7 switches, quagga service, in a topology according to
	Fig 1. of Lab4"""
		Topo.__init__(self)

		info( '*** Creating Quagga Routers\n' )
		# Absolute path to this python script
		selfPath = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))

		# Initialize the Quagga Service
		# autoStart=True (default) --> starts automatically quagga on the host
		# autoStop=True (default) --> stops automatically quagga (we don't want this)
		quaggaSvc = QuaggaService(autoStart=True, autoStop=False) 

		# Configuration file path for quagga routers
		# We require a "config" folder in the same path of the lab4_topo file, and within
		# the config folder, we require one folder for each host, named as the host itself.
		# with the corresponding daemons, zebra.conf, ripd.conf and ripngd.conf files
		quaggaBaseConfigPath = selfPath + '/configs/'

		# Initializing local variables
		netHosts = []
		NodeList = []

		# List of all hosts in the network.
		# Note that each node requires at least one IP address to avoid
		# Mininet's automatic IP address assignment
		netHosts.append(NetworkHosts(name='h1', IP='10.10.11.10/24', DG='via 10.10.11.1'))
		netHosts.append(NetworkHosts(name='h2', IP='10.10.22.20/24', DG='via 10.10.22.2'))
		netHosts.append(NetworkHosts(name='r1', IP='10.10.11.1/24', DG=''))
		netHosts.append(NetworkHosts(name='r2', IP='10.10.12.2/24', DG=''))
		netHosts.append(NetworkHosts(name='r3', IP='10.10.23.3/24', DG=''))
		netHosts.append(NetworkHosts(name='r4', IP='10.10.14.4/24', DG=''))
		netHosts.append(NetworkHosts(name='r5', IP='10.10.25.5/24', DG=''))

		for host in netHosts:
			# We create a list of node names
			NodeList.append(host.name)
			if host.name in ['h1','h2']:
				# We configure PCs with default gateway and without quagga service
				AddPCHost = self.addHost(name=host.name, ip=host.IP, defaultRoute=host.DG, hostname=host.name,  privateLogDir=True, privateRunDir=True, inMountNamespace=True, inPIDNamespace=True, inUTSNamespace=True)
			else :
				# We configure routers with quagga service without default gateway
				AddQuaggaHost = self.addHost(name=host.name, ip=host.IP, hostname=host.name,  privateLogDir=True, privateRunDir=True, inMountNamespace=True, inPIDNamespace=True, inUTSNamespace=True)
				# We setup Quagga service and path to config files
				# Note that we require one folder for each host, named as the host itself
				quaggaSvcConfig = {'quaggaConfigPath': quaggaBaseConfigPath + host.name}
				self.addNodeService(node=host.name, service=quaggaSvc, nodeConfig=quaggaSvcConfig)

		# Adding switches to the network, we specify OpenFlow v1.3 for better IPv6 multicast support
		SW1 = self.addSwitch('SW1', protocols='OpenFlow13')
		SW2 = self.addSwitch('SW2', protocols='OpenFlow13')
		SW3 = self.addSwitch('SW3', protocols='OpenFlow13')
		SW4 = self.addSwitch('SW4', protocols='OpenFlow13')
		SW5 = self.addSwitch('SW5', protocols='OpenFlow13')
		SW6 = self.addSwitch('SW6', protocols='OpenFlow13')
		SW7 = self.addSwitch('SW7', protocols='OpenFlow13')
		SW8 = self.addSwitch('SW8', protocols='OpenFlow13')
		# We add links between switches and routers according to Fig.1 of Lab 4
		info( '*** Creating links\n' )
		self.addLink( SW1, NodeList[0], intfName2='h1-eth1'  )
		self.addLink( SW1, NodeList[2], intfName2='r1-eth3'  )

		self.addLink( SW2, NodeList[2], intfName2='r1-eth1'  )
		self.addLink( SW2, NodeList[3], intfName2='r2-eth1'  )

		self.addLink( SW3, NodeList[3], intfName2='r2-eth2'  )
		self.addLink( SW3, NodeList[4], intfName2='r3-eth1'  )

		self.addLink( SW4, NodeList[2], intfName2='r1-eth2'  )
		self.addLink( SW4, NodeList[5], intfName2='r4-eth1'  )

		self.addLink( SW5, NodeList[3], intfName2='r2-eth3'  )
		self.addLink( SW5, NodeList[6], intfName2='r5-eth1'  )

		self.addLink( SW6, NodeList[5], intfName2='r4-eth2'  )
		self.addLink( SW6, NodeList[6], intfName2='r5-eth3'  )

		self.addLink( SW7, NodeList[4], intfName2='r3-eth2'  )
		self.addLink( SW7, NodeList[6], intfName2='r5-eth2'  )

		self.addLink( SW8, NodeList[3], intfName2='r2-eth4'  )
		self.addLink( SW8, NodeList[1], intfName2='h2-eth1'  )
コード例 #27
0
    def __init__(self):
        #Initialize a topology of 3 hosts, 5 routers, 4 switches
        Topo.__init__(self)

        info('*** Creating Quagga Routers\n')
        # Absolute path to this python script
        selfPath = os.path.dirname(
            os.path.abspath(inspect.getfile(inspect.currentframe())))

        # Initialize the Quagga Service
        # autoStart=True (default) --> starts automatically quagga on the host
        # autoStop=True (default) --> stops automatically quagga (we don't want this)
        quaggaSvc = QuaggaService(autoStop=False)

        # Configuration file path for quagga routers
        quaggaBaseConfigPath = selfPath + '/configs/'

        # Initializing local variables
        netHosts = []
        NodeList = []

        # List of all hosts in the network.
        # Note that each node requires at least one IP address.
        netHosts.append(
            NetworkHosts(name='h1', IP='192.10.10.10/24',
                         DG='via 192.10.10.1'))
        netHosts.append(
            NetworkHosts(name='h2', IP='192.20.20.20/24',
                         DG='via 192.20.20.2'))
        netHosts.append(
            NetworkHosts(name='h5', IP='192.50.50.50/24',
                         DG='via 192.50.50.5'))
        netHosts.append(NetworkHosts(name='r1', IP='192.10.10.1/24', DG=''))
        netHosts.append(NetworkHosts(name='r2', IP='192.20.20.2/24', DG=''))
        netHosts.append(NetworkHosts(name='r3', IP='192.13.13.3/24', DG=''))
        netHosts.append(NetworkHosts(name='r4', IP='192.24.24.4/24', DG=''))
        netHosts.append(NetworkHosts(name='r5', IP='192.50.50.5/24', DG=''))

        for host in netHosts:
            # We create a list of node names
            NodeList.append(host.name)
            if host.name in ['h1', 'h2', 'h5']:
                # We configure PCs with default gateway and without quagga service
                AddPCHost = self.addHost(name=host.name,
                                         ip=host.IP,
                                         defaultRoute=host.DG,
                                         hostname=host.name,
                                         privateLogDir=True,
                                         privateRunDir=True,
                                         inMountNamespace=True,
                                         inPIDNamespace=True,
                                         inUTSNamespace=True)
            else:
                # We configure routers with quagga service without default gateway
                AddQuaggaHost = self.addHost(name=host.name,
                                             ip=host.IP,
                                             hostname=host.name,
                                             privateLogDir=True,
                                             privateRunDir=True,
                                             inMountNamespace=True,
                                             inPIDNamespace=True,
                                             inUTSNamespace=True)
                # We setup Quagga service and path to config files
                quaggaSvcConfig = {
                    'quaggaConfigPath': quaggaBaseConfigPath + host.name
                }
                self.addNodeService(node=host.name,
                                    service=quaggaSvc,
                                    nodeConfig=quaggaSvcConfig)
        # Adding switches to the network, we specify OpenFlow v1.3 for IPv6 suppport
        SW1 = self.addSwitch('SW1', protocols='OpenFlow13')
        SW2 = self.addSwitch('SW2', protocols='OpenFlow13')
        SW5 = self.addSwitch('SW5', protocols='OpenFlow13')
        SW12 = self.addSwitch('SW12', protocols='OpenFlow13')
        SW13 = self.addSwitch('SW13', protocols='OpenFlow13')
        SW24 = self.addSwitch('SW24', protocols='OpenFlow13')
        SW345 = self.addSwitch('SW345', protocols='OpenFlow13')
        # We add links between switches and routers according to Fig.1 of Lab 4
        info('*** Creating links\n')
        self.addLink(SW1, NodeList[0], intfName2='h1-eth1')
        self.addLink(SW1, NodeList[3], intfName2='r1-eth3')

        self.addLink(SW2, NodeList[1], intfName2='h2-eth1')
        self.addLink(SW2, NodeList[4], intfName2='r2-eth3')

        self.addLink(SW5, NodeList[2], intfName2='h5-eth1')
        self.addLink(SW5, NodeList[7], intfName2='r5-eth1')

        self.addLink(SW12, NodeList[3], intfName2='r1-eth2')
        self.addLink(SW12, NodeList[4], intfName2='r2-eth2')

        self.addLink(SW13, NodeList[3], intfName2='r1-eth1')
        self.addLink(SW13, NodeList[5], intfName2='r3-eth1')

        self.addLink(SW24, NodeList[4], intfName2='r2-eth1')
        self.addLink(SW24, NodeList[6], intfName2='r4-eth1')

        self.addLink(SW345, NodeList[5], intfName2='r3-eth2')
        self.addLink(SW345, NodeList[6], intfName2='r4-eth2')
        self.addLink(SW345, NodeList[7], intfName2='r5-eth2')