#!/usr/bin/python

"""
Start up the SDN-IP demo topology
"""

"""
AS1 = 64513, (SDN AS)
AS2 = 64514, reachable by 192.168.10.1, 192.168.20.1
AS3 = 64516, reachable by 192.168.30.1
AS4 = 64517, reachable by 192.168.40.1
AS6 = 64520, reachable by 192.168.60.2, (route server 192.168.60.1)
"""

from mininet.node import Host
from mininet.net import Mininet
from mininet.node import Controller, RemoteController
from mininet.log import setLogLevel, info
from mininet.cli import CLI
from mininet.topo import Topo
from mininet.util import quietRun
from mininet.moduledeps import pathCheck

import os.path
import time
import sys
from subprocess import Popen, STDOUT, PIPE

QUAGGA_DIR = '/usr/lib/quagga'
#QUAGGA_DIR = '/usr/local/sbin'
QUAGGA_RUN_DIR = '/usr/local/var/run/quagga'

QUAGGA_CONFIG_FILE_DIR = '/home/tutorial1/ONLabTest/TestON/tests/PeeringRouterTest/mininet'

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

    def config( self, vlan=10, intf2 = '', ip2 = 0, vlan2 = 0, **params):
        """Configure VLANHost according to (optional) parameters:
           vlan: VLAN ID for default interface"""

        r = super( VLANHost, self ).config( **params )

        intf = params['inf']
        # remove IP from default, "physical" interface
        self.cmd( 'ifconfig %s inet 0' % intf )
        # create VLAN interface
        self.cmd( 'vconfig add %s %d' % ( intf, vlan ) )
        # assign the host's IP to the VLAN interface
        self.cmd( 'ifconfig %s.%d inet %s' % ( intf, vlan, params['ip'] ) )
        # update the intf name and host's intf map
        newName = '%s.%d' % ( intf, vlan )
        # update the (Mininet) interface to refer to VLAN interface name
        defaultIntf = self.defaultIntf()
        defaultIntf.name = newName
        # add VLAN interface to host's name to intf map
        self.nameToIntf[ newName ] = defaultIntf

        return r

class SDNIpModifiedTopo( Topo ):
    "SDN Ip Modified Topology"
    
    def __init__( self, *args, **kwargs ):
        global numHost101 
        global numHost200
        numHost101 = 101
        numHost200 = 200
        Topo.__init__( self, *args, **kwargs )
        sw1 = self.addSwitch('sw1', dpid='0000000000000001')
        sw2 = self.addSwitch('sw2', dpid='0000000000000002')
        #add a switch for 3 quagga hosts
        swTestOn = self.addSwitch('swTestOn', dpid='0000000000000102')
        #Note this switch isn't part of the SDN topology
        #We'll use the ovs-controller to turn this into a learning switch
        as6sw = self.addSwitch('as6sw', dpid='00000000000000a7')

        host1 = self.addHost( 'host1' )
        root1 = self.addHost( 'root1', inNamespace=False , ip='0')
        rootTestOn = self.addHost( 'rootTestOn', inNamespace=False, ip='0' )

        #AS2 host
        host3 = self.addHost( 'host3', cls=VLANHost, vlan=10, inf="host3-eth0", ip="192.168.10.1")
        
        as2host = self.addHost( 'as2host' )
        #AS3 host
        host4 = self.addHost( 'host4', cls=VLANHost, vlan=30, inf="host4-eth0", ip="192.168.30.1" )
        as3host = self.addHost( 'as3host' )
        #AS6 host
        as6rs = self.addHost( 'as6rs', cls=VLANHost, vlan=60, inf="as6rs-eth0", ip="192.168.60.1" )
        host5 = self.addHost( 'host5', cls=VLANHost, vlan=60, inf="host5-eth0", ip="192.168.60.2" )
        as6host = self.addHost( 'as6host' )

        self.addLink( host1, sw2 )
        #Links to the multihomed AS
        self.addLink( host3, sw1 )
        self.addLink( host3, sw1 )
        self.addLink( as2host, host3 )
        #Single links to the remaining two ASes
        self.addLink( host4, sw1 )
        self.addLink( as3host, host4 )
          
        #AS3-AS4 link
        #self.addLink( host4, host5)
        #Add new AS6 to its bridge
        self.addLink( as6rs, as6sw )
        self.addLink( host5, as6sw )
        self.addLink( as6host, host5 )
        #Backup link from router5 to router4
        self.addLink( host4, host5)
        #test the host behind the router(behind the router server)
#        for i in range(1, 10):
 #           host = self.addHost('as6host%d' % i)
  #          self.addLink(host, as6router)

        ## Internal Connection To Hosts ##
        self.addLink( root1, host1 )

 #       self.addLink( sw1, sw2 )
 #       self.addLink( sw1, sw3 )
 #       self.addLink( sw2, sw4 )
 #       self.addLink( sw3, sw4 )
 #       self.addLink( sw3, sw5 )
 #       self.addLink( sw4, sw6 )
 #       self.addLink( sw5, sw6 )
        self.addLink( as6sw, sw1 )
        
        
        self.addLink(swTestOn, rootTestOn)
        #self.addLink(swTestOn, host1)
        self.addLink(swTestOn, host3)
        self.addLink(swTestOn, host4)
        self.addLink(swTestOn, host5)
        self.addLink(swTestOn, as2host)
        self.addLink(swTestOn, as6rs)
        
        
        #self.addLink(rootTestOn, host4)

def startsshd( host ):
    "Start sshd on host"
    info( '*** Starting sshd\n' )
    name, intf, ip = host.name, host.defaultIntf(), host.IP()
    banner = '/tmp/%s.banner' % name
    host.cmd( 'echo "Welcome to %s at %s" >  %s' % ( name, ip, banner ) )
    host.cmd( '/usr/sbin/sshd -o "Banner %s"' % banner, '-o "UseDNS no"' )
    info( '***', host.name, 'is running sshd on', intf, 'at', ip, '\n' )

def startsshds ( hosts ):
    for h in hosts:
        startsshd( h )

def stopsshd( ):
    "Stop *all* sshd processes with a custom banner"
    info( '*** Shutting down stale sshd/Banner processes ',
          quietRun( "pkill -9 -f Banner" ), '\n' )

def startquagga( host, num, config_file ):
    info( '*** Starting Quagga on %s\n' % host )
    zebra_cmd = 'sudo %s/zebra -d -f  %s/zebra.conf -z %s/zserv%s.api -i %s/zebra%s.pid' % (QUAGGA_DIR, QUAGGA_CONFIG_FILE_DIR, QUAGGA_RUN_DIR, num, QUAGGA_RUN_DIR, num)
    quagga_cmd = 'sudo %s/bgpd -d -f %s -z %s/zserv%s.api -i %s/bgpd%s.pid' % (QUAGGA_DIR, config_file, QUAGGA_RUN_DIR, num, QUAGGA_RUN_DIR, num)
    
    print zebra_cmd
    print quagga_cmd

    host.cmd( zebra_cmd )
    host.cmd( quagga_cmd )
    
def startquaggahost5( host, num ):
    info( '*** Starting Quagga on %s\n' % host )
    zebra_cmd = 'sudo %s/zebra -d -f %s/zebra.conf -z %s/zserv%s.api -i %s/zebra%s.pid' % (QUAGGA_DIR, QUAGGA_CONFIG_FILE_DIR, QUAGGA_RUN_DIR, num, QUAGGA_RUN_DIR, num)
    quagga_cmd = 'sudo %s/bgpd -d -f ./as4quaggas/quagga%s.conf -z %s/zserv%s.api -i %s/bgpd%s.pid' % (QUAGGA_DIR, num, QUAGGA_RUN_DIR, num, QUAGGA_RUN_DIR, num)
   
    host.cmd( zebra_cmd )
    host.cmd( quagga_cmd )    
    

def stopquagga( ):
    quietRun( 'sudo pkill -9 -f bgpd' )
    quietRun( 'sudo pkill -9 -f zebra' )

def sdn1net():
    topo = SDNIpModifiedTopo()
    info( '*** Creating network\n' )
    net = Mininet( topo=topo, controller=RemoteController )
    net = Mininet( topo=topo, controller=RemoteController )

    host1, host3, host4, host5 = net.get( 'host1', 'host3', 'host4', 'host5' )
    
        #host100.setIP('1.168.30.' + str(i), 24, str(host100) + "-eth2")  
         
        #host500.setMAC('00:00:00:00:04:%d' % (i-101), 'host%d-eth0' %(i))
        #add IP prefixes
        #for j in range(0,121):
            #host100.cmd('sudo ip addr add %s.0.40.%s/24 dev host%s-eth0' %(i,j,i))

    ## Adding 2nd, 3rd and 4th interface to host1 connected to sw1 (for another BGP peering)
    #sw1 = net.get('sw1')
    host1.setMAC('00:00:00:00:00:01', 'host1-eth0')
    #host1.cmd('ip addr add 192.168.20.101/24 dev host1-eth0')
    #host1.cmd('ip addr add 192.168.30.101/24 dev host1-eth0')
    #host1.cmd('ip addr add 192.168.60.101/24 dev host1-eth0')

    # Net has to be start after adding the above link
    net.start()

    # Set up as6sw as a learning switch as quickly as possible so it 
    # hopefully doesn't connect to the actual controller
    # TODO figure out how to change controller before starting switch
    as6sw = net.get('as6sw')
    as6sw.cmd('ovs-vsctl set-controller as6sw none')
    as6sw.cmd('ovs-vsctl set-fail-mode as6sw standalone')
    
    as6sw.cmd( 'sudo ovs-vsctl set port as6sw-eth1 trunk=60')
    as6sw.cmd( 'sudo ovs-vsctl set port as6sw-eth2 trunk=60')


    sw1 = net.get('sw1')
    sw1.cmd('ovs-vsctl set-controller sw1 tcp:127.0.0.1:6633')
    
    swTestOn = net.get('swTestOn')
    swTestOn.cmd('ovs-vsctl set-controller swTestOn none')
    swTestOn.cmd('ovs-vsctl set-fail-mode swTestOn standalone')

    #host1.defaultIntf().setIP('192.168.10.101/24') 
    
    host1.cmd( 'ifconfig host1-eth0 inet 0')
    host1.cmd( 'vconfig add host1-eth0 10')
    host1.cmd( 'ifconfig host1-eth0.10 inet 192.168.10.101')
    
    host1.cmd( 'vconfig add host1-eth0 20')
    host1.cmd( 'ifconfig host1-eth0.20 inet 192.168.20.101')
    
    host1.cmd( 'vconfig add host1-eth0 30')
    host1.cmd( 'ifconfig host1-eth0.30 inet 192.168.30.101')
    
    host1.cmd( 'vconfig add host1-eth0 60')
    host1.cmd( 'ifconfig host1-eth0.60 inet 192.168.60.101')

    # Run BGPd
    #host1.cmd('%s -d -f %s' % (BGPD, BGPD_CONF))
    #host1.cmd('/sbin/route add default gw 192.168.10.254 dev %s-eth0' % (host1.name))
    
    # Configure new host interfaces
    #host2.defaultIntf().setIP('172.16.10.2/24')
    #host2.defaultIntf().setMAC('00:00:00:00:01:02') 
    #host2.cmd('/sbin/route add default gw 172.16.10.254 dev %s-eth0' % (host2.name))

    # Set up AS2
    # add additional VLAN interface
    host3.cmd( 'ifconfig host3-eth1 inet 0')
    host3.cmd( 'vconfig add host3-eth1 20')
    host3.cmd( 'ifconfig host3-eth1.20 inet 192.168.20.1')
    # change the interface for the sencond connection to sw1 to vlan interface
    newName = "host3-eth1.20"
    secondIntf = host3.intf("host3-eth1")
    secondIntf.name = newName
    host3.nameToIntf[ newName ] = secondIntf
    
    host3.setMAC('00:00:00:00:02:01', 'host3-eth0.10')
    host3.setMAC('00:00:00:00:02:02', 'host3-eth1.20')
    
    #host3.setIP('172.16.20.254', 24, 'host3-eth2')
    host3.setIP('3.0.0.254', 8, 'host3-eth2')
    host3.cmd('sysctl net.ipv4.conf.all.forwarding=1')
    
    host3.setIP('1.168.30.2', 24, 'host3-eth3')   
    host3.cmd('sysctl net.ipv4.conf.all.arp_ignore=1')
    host3.cmd('sysctl net.ipv4.conf.all.arp_announce=1')
    as2host = net.get('as2host')
    #as2host.defaultIntf().setIP('172.16.20.1/24')
    for i in range(0, 20):
        as2host.cmd('sudo ip addr add 3.0.%d.1/24 dev as2host-eth0' %i)
    as2host.setIP('1.168.30.100', 24, 'as2host-eth1')
    
    as2host.cmd('ip route add default via 3.0.0.254')
    
    # Set up AS3
    host4.setMAC('00:00:00:00:03:01', 'host4-eth0.30')
    host4.setIP('4.0.0.254', 8, 'host4-eth1')
    host4.setMAC('00:00:00:00:03:99', 'host4-eth1')
    host4.cmd('sysctl net.ipv4.conf.all.forwarding=1')
    as3host = net.get('as3host')
    for i in range(0, 20):
        as3host.cmd('sudo ip addr add 4.0.%d.1/24 dev as3host-eth0' %i)
    as3host.cmd('ip route add default via 4.0.0.254')
    
    host4.setIP('10.0.0.4', 24, 'host4-eth2')
    host4.setMAC('00:00:00:00:03:33', 'host4-eth2')
    
    #root space
    host4.setIP('1.168.30.3', 24, 'host4-eth3')
    host4.setMAC('00:00:00:00:03:03', 'host4-eth3')
    
    # Set up AS4
    #as4host = net.get('as4host')
    #as4host.defaultIntf().setIP('172.16.40.1/24')
    #as4host.cmd('ip route add default via 172.16.40.254')
    
    # setup interface address for 100 quagga hosts
    time.sleep(10)
    #for i in range(numHost101, numHost200 + 1):
        #host100 = net.get('host' + str(i))
        #host100.cmd(str(i)+'.0.1.254', 24, 'host'+str(i)+'-eth1')
        #as4host100 = net.get('as4host%s' %(i))
        #as4host100.defaultIntf().setIP(str(i) + '.0.0.1/24')
        #as4host100.cmd('ip route add default via ' + str(i) + '.0.0.254')
        #for j in range(0, 100):
            #as4host100.cmd('sudo ip addr add %d.0.%d.1/24 dev %s-eth0' %(i, j, as4host100))

    # Set up AS6 - This has a router and a route server
    as6rs, host5 = net.get('as6rs', 'host5')

    as6rs.setMAC('00:00:00:06:06:01', 'as6rs-eth0')
    as6rs.setIP('1.168.30.6', 24, 'as6rs-eth1')
    as6rs.setMAC('00:00:00:06:06:06', 'as6rs-eth1')

    host5.setMAC('00:00:00:00:06:02', 'host5-eth0.60')
    #as6router.setIP('172.16.60.254', 24, 'as6router-eth1')
    host5.setIP('5.0.0.254', 8, 'host5-eth1')
    host5.cmd('sysctl net.ipv4.conf.all.forwarding=1')
    host5.setIP('10.0.0.5', 24, 'host5-eth2')
    host5.setMAC('00:00:00:00:06:66', 'host5-eth2')
    host5.setIP('1.168.30.5', 24, 'host5-eth3')
    host5.setMAC('00:00:00:00:06:05', 'host5-eth3')

    as6host = net.get('as6host')
    #as6host.defaultIntf().setIP('5.0.0.1/24')
    for i in range(0, 10):
        as6host.cmd('sudo ip addr add 5.0.%d.1/24 dev as6host-eth0' %i)
    as6host.cmd('ip route add default via 5.0.0.254')

    # test the host in the as6
    #for i in range(1, 10):
    #    baseip = (i-1)*4
    #    host = net.get('as6host%d' % i)
    #    host.defaultIntf().setIP('172.16.70.%d/24' % (baseip+1))
    #    host.cmd('ip route add default via 172.16.70.%d' % (baseip+2))
     #   as6router.setIP('172.16.70.%d' % (baseip+2), 30, 'as6router-eth%d' % (i+1))

    # Start Quagga on border routers
    startquagga(host3, 1, QUAGGA_CONFIG_FILE_DIR + '/quagga1.conf')
    startquagga(host4, 2, QUAGGA_CONFIG_FILE_DIR + '/quagga2.conf')
    #for i in range(numHost101, numHost200 + 1):
        #host100=net.get('host%d' % (i))
        #startquaggahost5(host100, i)

    startquagga(as6rs, 4, QUAGGA_CONFIG_FILE_DIR + '/quagga-as6-rs.conf')
    startquagga(host5, 5, QUAGGA_CONFIG_FILE_DIR + '/quagga-as6.conf')

    #root1, root2, rootTestOn  = net.get( 'root1', 'root2', 'rootTestOn' )
    root1, rootTestOn  = net.get( 'root1', 'rootTestOn' )
    host1.intf('host1-eth1').setIP('1.1.1.1/24')
    root1.intf('root1-eth0').setIP('1.1.1.2/24')
    #host2.intf('host2-eth1').setIP('1.1.2.1/24')
    #root2.intf('root2-eth0').setIP('1.1.2.2/24')
    
    #rootTestOn.cmd('ip addr add 1.168.30.102/24 dev rootTestOn-eth0')
    rootTestOn.cmd('ip addr add 1.168.30.99/24 dev rootTestOn-eth0')
    
    stopsshd()    

    startquagga(host1, 100, QUAGGA_CONFIG_FILE_DIR + '/quagga-sdn-modified.conf')    
    hosts = [ host1, host3, host4, host5, as2host, as6rs ];
    #sshdHosts = sshdHosts + hosts
    startsshds( hosts )
    #
    onos1 = '127.0.0.1'
    forwarding1 = '%s:2000:%s:2000' % ('1.1.1.2', onos1)
    root1.cmd( 'ssh -nNT -o "PasswordAuthentication no" -o "StrictHostKeyChecking no" -l sdn -L %s %s & ' % (forwarding1, onos1) )

    # Forward 2605 to root namespace for easier access to SDN domain BGPd
    # If root can ssh to itself without a password this should work
    root1.cmd('ssh -N -o "PasswordAuthentication no" -o "StrictHostKeyChecking no" -L 2605:1.1.1.1:2605 1.1.1.1 &')
    #time.sleep(3000000000)
    CLI( net )

    # Close the ssh port forwarding
    #quietRun('sudo pkill -f 1.1.1.1')

    stopsshd()
    stopquagga()
    net.stop()

if __name__ == '__main__':
    setLogLevel( 'debug' )
    if len(sys.argv) > 1:
        QUAGGA_CONFIG_FILE_DIR = sys.argv[1]
    sdn1net()