def connectToInternet( network ): "Connect the network to the internet" switch = network.switches[ 0 ] # switch to use ip = '10.0.0.254' # our IP address on host network routes = [ '10.0.0.0/24' ] # host networks to route to prefixLen = 24 # subnet mask length inetIface = "eth0" # host interface for internet connectivity # Create a node in root namespace and link to switch 0 root = Node( 'root', inNamespace=False ) intf = Link( root, switch ).intf1 #intf = createLink( root, switch )[ 0 ] #root.setIP( intf, ip, prefixLen ) root.setIP( ip, prefixLen, intf) # Start network that now includes link to root namespace network.start() # Start NAT and establish forwarding startNAT( inetIface, root ) # Establish routes from end hosts for host in network.hosts: host.cmd( 'ip route flush root 0/0' ) #host.cmd( 'route add -net 10.0.0.0/24 dev ' + host.intfs[0] ) host.cmd( 'route add -net 10.0.0.0/24 dev ' + host.intfs[0].name ) host.cmd( 'route add default gw ' + ip ) return root
def connectToRootNS(network, switch, ip, routes): root = Node('root', inNamespace=False) intf = network.addLink(root, switch).intf1 root.setIP(ip, intf=intf) network.start() for route in routes: root.cmd('route add -net {} dev {} '.format(route, intf))
class MyTopo(object): def __init__(self, cname='onos', cips=['10.0.3.1']): # Create network with multiple controllers self.net = Mininet(controller=RemoteController, switch=OVSKernelSwitch, build=False) # Add controllers with input IPs to the network ctrls = [RemoteController(cname, cip, 6633) for cip in cips] for ctrl in ctrls: print ctrl.ip self.net.addController(ctrl) # Add switch self.s2 = self.net.addSwitch('s2', dpid='00000000000000a2') # Connect root namespace to the switch self.root = Node('root', inNamespace=False) intf = self.net.addLink(self.root, self.s2).intf1 self.root.setIP('10.0.0.1/32', intf=intf) # Add host h2 = self.net.addHost('h2', ip='10.0.0.12/24', mac='00:00:00:00:00:02') self.net.addLink(h2, self.s2) def run(self): self.net.build() self.net.start() self.s2.cmd('ovs-vsctl set bridge s2 protocols=OpenFlow13') self.s2.cmd('ovs-vsctl add-port s2 vxlan2') self.s2.cmd('ovs-vsctl set interface vxlan2 type=vxlan option:remote_ip=104.236.158.75 option:key=flow') self.root.cmd('route add -net 10.0.0.0/24 dev root-eth0') CLI(self.net) self.net.stop()
def startNetwork(network, switch, ip, routes): root = Node('root', inNamespace=False) intf = Link(root, switch).intf1 root.setIP(ip, intf=intf) network.start() for route in routes: root.cmd( 'route add -net ' + route + ' dev ' + str( intf ) )
def connectToRootNS(net, ip='10.123.123.1', mac='00123456789A', prefixLen=8, routes=['10.0.0.0/8']): print "*** Creating controller" c0 = net.addController('c0', ip='127.0.0.1', port=6633) rootswitch = net.addSwitch('roots1', ) rootswitch.dpid = 'FFFFFFFFFFFFFFFF' # Connect hosts to root namespace via switch. Starts network. # network: Mininet() network object # ip: IP address for root namespace node # prefixLen: IP address prefix length (e.g. 8, 16, 24) # routes: host networks to route to" # Create a node in root namespace and link to switch 0 root = Node('root', inNamespace=False) intf = Link(root, rootswitch).intf1 intf.setMAC(mac) root.setIP(ip, prefixLen, intf) print "*** Added Interface", str(intf), "Connected To Root-NameSpace" fixNetworkManager(str(intf)) for host in net.hosts: net.addLink(host, rootswitch) # Add routes from root ns to hosts for route in routes: root.cmd('route add -net ' + route + ' dev ' + str(intf)) root.cmd('service network-manager restart') return rootswitch
def connectToRootNS(network, switch, ip, routes): root = Node('root', inNamespace=False) intf = network.addLink(root, switch).intf1 root.setIP(ip, intf=intf) network.start() for route in routes: root.cmd('route add -net ' + route + ' dev ' + str(intf))
def start(): global net, attacker, running if running: return '\nServer already running.\n' setLogLevel('info') topo = MixTopo() net = Mininet(topo=topo) s1 = net['s1'] plc2 = net['plc2'] plc3 = net['plc3'] s2, rtu2a, scada = net.get('s2', 'rtu2a', 'scada') rtu2b, attacker2 = net.get('rtu2b', 'attacker2') s3 = net.get('s3') # NOTE: root-eth0 interface on the host root = Node('root', inNamespace=False) intf = net.addLink(root, s3).intf1 print('DEBUG root intf: {}'.format(intf)) root.setIP('10.0.0.30', intf=intf) # NOTE: all packet from root to the 10.0.0.0 network root.cmd('route add -net ' + '10.0.0.0' + ' dev ' + str(intf)) net.start() info('Welcome') # NOTE: use for debugging #s1.cmd('tcpdump -i s1-eth1 -w /tmp/s1-eth1.pcap &') #s1.cmd('tcpdump -i s1-eth2 -w /tmp/s1-eth2.pcap &') SLEEP = 0.5 # NOTE: swat challenge 1 and 2 plc3.cmd(sys.executable + ' plc3.py &') sleep(SLEEP) plc2.cmd(sys.executable + ' plc2.py &') sleep(SLEEP) # NOTE: wadi challenge 1 scada.cmd(sys.executable + ' scada.py &') sleep(SLEEP) rtu2a.cmd(sys.executable + ' rtu2a.py &') sleep(SLEEP) # NOTE: wadi challenge 2 rtu2b.cmd(sys.executable + ' rtu2b.py &') sleep(SLEEP) running = True return '\nServer started.\n'
def sshd(net): root = Node('root', inNamespace=False) intf = net.addLink(root, net['s3']).intf1 root.setIP('10.0.0.4/24', intf=intf) net.start() root.cmd('route add -net 10.0.0.0/24 dev ' + str(intf)) for host in net.hosts: host.cmd('/usr/sbin/sshd -D -o UseDNS=no -u0&')
def scratchNet(cname='controller', cargs='-v ptcp:'): "Create network from scratch using Open vSwitch." info("*** Creating nodes\n") controller = Node('c0', inNamespace=False) switch = Node('s0', inNamespace=False) h0 = Node('h0') h1 = Node('h1') info("*** Creating links\n") Link(h0, switch) Link(h1, switch) info("*** Configuring hosts\n") h0.setIP('192.168.123.1/24') h1.setIP('192.168.123.2/24') info(str(h0) + '\n') info(str(h1) + '\n') info("*** Starting network using Open vSwitch\n") controller.cmd(cname + ' ' + cargs + '&') switch.cmd('ovs-vsctl del-br dp0') switch.cmd( 'ovs-vsctl add-br dp0 other-config:datapath-id={}'.format(datapath_id)) for intf in switch.intfs.values(): print switch.cmd('ovs-vsctl add-port dp0 %s' % intf) # Note: controller and switch are in root namespace, and we # can connect via loopback interface s_cmd = 'ovs-vsctl set-controller dp0 tcp:[{}]:{}'.format( CTLR_IP, CTLR_PRT) print s_cmd switch.cmd(s_cmd) ping_results = [ 'received,host,jitter,packet_loss,avgping,minping,time,sent,maxping\n' ] try: h0.cmd('echo "" > pings.txt') if mode == 0: step_wise_testing(h0, h1, ping_results) else: continuous_testing(h0, h1, ping_results) except KeyboardInterrupt: print "Warning: Caught KeyboardInterrupt, stopping network" tm_local = time.localtime() dt = time.gmtime() file_name = 'pings_{}_{}_{}-{}_{}_{}.csv'.format( dt.tm_year, dt.tm_mon, dt.tm_mday, tm_local.tm_hour, tm_local.tm_min, tm_local.tm_sec) f = open(file_name, 'w+') for item in ping_results: f.write(item) stop_net(controller, cname, switch)
def DeltaNetwork(): #Make topology net = Mininet(topo=None, controller=None, build=False) #Add switch proto = sys.argv[5] s0 = net.addSwitch('s0', dpid='00:00:00:00:00:01', protocols=proto) s1 = net.addSwitch('s1', dpid='00:00:00:00:00:02', protocols=proto) # for connections with DELTA #Add hosts h1 = net.addHost('h1', ip='10.0.0.1/24', mac='00:00:00:00:00:11') h2 = net.addHost('h2', ip='10.0.0.2/24', mac='00:00:00:00:00:22') #Add links net.addLink(s0, h1) net.addLink(s0, h2) net.addLink(s1, h1, intfName2='host-eth') root = Node('root', inNamespace=False) intf = net.addLink(root, s1).intf1 root.setIP('10.0.1.1', intf=intf) # net.build() net.start() f = os.popen( 'ifconfig eth0 | grep "inet\ addr" | cut -d: -f2 | cut -d" " -f1') ip = f.read()[:-1] root.cmd('route add -net 10.0.1.0/24 dev ' + str(intf)) h1.cmd("ifconfig host-eth 10.0.1.2/24 netmask 255.255.255.0") h1.cmd('route add -net 10.0.3.0/24 dev host-eth') h1.cmd('route add -net 10.0.3.0/24 gw ' + str(ip) + ' dev host-eth') #Set ip os.system( "sudo ovs-ofctl -O OpenFlow13 add-flow s1 in_port=1,actions=output:2") os.system( "sudo ovs-ofctl -O OpenFlow13 add-flow s1 in_port=2,actions=output:1") #h1.cmd("dhclient eth0") #connect a controller os.system("sudo ovs-vsctl set-controller s0 tcp:" + sys.argv[1] + ":" + sys.argv[2]) h1.cmd("java -jar $HOME/delta-agent-host-1.0-SNAPSHOT.jar " + sys.argv[3] + " " + sys.argv[4]) CLI(net) net.stop()
def enableSSH(self, net): print 'Enabling ssh' routes = ['10.0.0.0/24'] ip = '10.123.123.1/32' switch = self.CoreSwitchList[0] print switch switch = net[switch] root = Node('root', inNamespace=False) intf = Link(root, switch).intf1 root.setIP(ip, intf=intf) net.start() for route in routes: root.cmd('route add -net ' + route + ' dev ' + str(intf))
def sshd_connectToRootNS(args,network): #we create node root and attach it to a swtich switch = network.getNodeByName(args.names.sw_sshd[0]) #ip of root ip = '172.16.255.1/32' root = Node( 'root', inNamespace=False ) intf = Link( root, switch ).intf1 root.setIP( ip, intf=intf ) return root,intf
def connectToRootNS(network, switch, ip, routes): root = Node('root', inNamespace=False) intf = network.addLink(root, switch).intf1 root.setIP(ip, intf=intf) root.setMAC("10:00:00:00:00:00") network.start() sleep(10) for route in routes: root.cmd('route add -net ' + route + ' dev ' + str(intf)) print("route add completed=================") for route in routes: root.cmd('route add -net ' + route + ' dev ' + str(intf)) print("route add completed=================")
def scratchNet(cname='controller', cargs='-v ptcp:'): "Create network from scratch using Open vSwitch." info("*** Creating nodes\n") controller = Node('c0', inNamespace=False) switch = Node('s0', inNamespace=False) h0 = Node('h0') h1 = Node('h1') info("*** Creating links\n") Link(h0, switch) Link(h1, switch) info("*** Configuring hosts\n") h0.setIP('192.168.123.1/24') h1.setIP('192.168.123.2/24') info(str(h0) + '\n') info(str(h1) + '\n') info("*** Starting network using Open vSwitch\n") controller.cmd(cname + ' ' + cargs + '&') switch.cmd('ovs-vsctl del-br dp0') switch.cmd('ovs-vsctl add-br dp0') for intf in switch.intfs.values(): print switch.cmd('ovs-vsctl add-port dp0 %s' % intf) # Note: controller and switch are in root namespace, and we # can connect via loopback interface s_cmd = 'ovs-vsctl set-controller dp0 tcp:[{}]:{}'.format( CTLR_IP, CTLR_PRT) print s_cmd switch.cmd(s_cmd) info('*** Waiting for switch to connect to controller') try: while 'is_connected' not in quietRun('ovs-vsctl show'): sleep(1) info('.') info('\n') while True: info("*** Running test\n") h0.cmdPrint('ping -c1 ' + h1.IP()) info("*** Sleep\n") sleep(2) except KeyboardInterrupt: print "Warning: Caught KeyboardInterrupt, stopping network" stop_net(controller, cname, switch)
def scratchNet(cname='controller', cargs='-v ptcp:'): "Create network from scratch using Open vSwitch." info("*** Creating nodes\n") controller = Node('c0', inNamespace=False) switch0 = Node('s0', inNamespace=False) h0 = Node('h0') h1 = Node('h1') info("*** Creating links\n") Link(h0, switch0) Link(h1, switch0) info("*** Configuring hosts\n") h0.setIP('192.168.123.1/24') h1.setIP('192.168.123.2/24') info(str(h0) + '\n') info(str(h1) + '\n') info("*** Starting network using Open vSwitch\n") controller.cmd(cname + ' ' + cargs + '&') switch0.cmd('ovs-vsctl del-br dp0') switch0.cmd('ovs-vsctl add-br dp0') for intf in switch0.intfs.values(): print intf print switch0.cmd('ovs-vsctl add-port dp0 %s' % intf) # Note: controller and switch are in root namespace, and we # can connect via loopback interface switch0.cmd('ovs-vsctl set-controller dp0 tcp:127.0.0.1:6633') switch0.cmd('ovs-ofctl add-flow dp0 \"in_port=1 actions=output:2\"') switch0.cmd('ovs-ofctl add-flow dp0 \"in_port=2 actions=output:1\"') info('*** Waiting for switch to connect to controller') while 'is_connected' not in quietRun('ovs-vsctl show'): sleep(1) info('.') info('\n') info("*** Running test\n") h0.cmdPrint('ping -c3 ' + h1.IP()) h1.cmdPrint('ping -c3 ' + h0.IP()) info("*** Stopping network\n") controller.cmd('kill %' + cname) switch0.cmd('ovs-vsctl del-br dp0') switch0.deleteIntfs() info('\n')
def connectToRootNS( network, switch, ip, routes ): """Connect hosts to root namespace via switch. Starts network. network: Mininet() network object switch: switch to connect to root namespace ip: IP address for root namespace node routes: host networks to route to""" # Create a node in root namespace and link to switch 0 root = Node( 'root', inNamespace=False ) intf = network.addLink( root, switch ).intf1 root.setIP( ip, intf=intf ) # Start network that now includes link to root namespace network.start() # Add routes from root ns to hosts for route in routes: root.cmd( 'route add -net ' + route + ' dev ' + str( intf ) )
def connectToRootNS(network, switch, ip, routes): """Connect hosts to root namespace via switch. Starts network. network: Mininet() network object switch: switch to connect to root namespace ip: IP address for root namespace node routes: host networks to route to""" # Create a node in root namespace and link to switch 0 root = Node('root', inNamespace=False) intf = network.addLink(root, switch).intf1 root.setIP(ip, intf=intf) # Start network that now includes link to root namespace network.start() # Add routes from root ns to hosts for route in routes: root.cmd('route add -net ' + route + ' dev ' + str(intf))
def start_network(): ''' Start mininet network ''' lg.setLogLevel('info') topo = TreeTopo(1, options.hosts) net = Mininet(topo=topo, switch=OVSBridge, controller=None, waitConnected=True) switch = net['s1'] routes = ['10.0.0.0/24'] root = Node('root', inNamespace=False) interface = net.addLink(root, switch).intf1 root.setIP('10.123.123.1/32', intf=interface) net.start() for route in routes: root.cmd('route add -net {} dev {}'.format(route, interface)) return net
def connectToRootNS(network, switch, ip, prefixLen, routes): "Connect hosts to root namespace via switch. Starts network." "network: Mininet() network object" "switch: switch to connect to root namespace" "ip: IP address for root namespace node" "prefixLen: IP address prefix length (e.g. 8, 16, 24)" "routes: host networks to route to" # Create a node in root namespace and link to switch 0 root = Node('root', inNamespace=False) intf = TCLink(root, switch).intf1 root.setIP(ip, prefixLen, intf) # Start network that now includes link to root namespace network.start() # Add routes from root ns to hosts for route in routes: root.cmd('route add -net ' + route + ' dev ' + str(intf))
def connectToRootNS( network, switch, ip, prefixLen, routes ): "Connect hosts to root namespace via switch. Starts network." "network: Mininet() network object" "switch: switch to connect to root namespace" "ip: IP address for root namespace node" "prefixLen: IP address prefix length (e.g. 8, 16, 24)" "routes: host networks to route to" # Create a node in root namespace and link to switch 0 root = Node( 'root', inNamespace=False ) intf = TCLink( root, switch ).intf1 root.setIP( ip, prefixLen, intf ) # Start network that now includes link to root namespace network.start() # Add routes from root ns to hosts for route in routes: root.cmd( 'route add -net ' + route + ' dev ' + str( intf ) )
def scratchNet(cname='controller', cargs='-v ptcp:'): #create network from scratch using Open vswitch info("***Creating nodes\n") controller = Node('c0', inNamespace=False) switch0 = Node('s0', inNamespace=False) h0 = Node('h0') h1 = Node('h1') info("***Creating links\n") Link(h0, switch0) Link(h1, switch0) info(" ***Configuring hosts\n") h0.setIP('192.168.123.1/24') h1.setIP('192.168.123.2/24') info(str(h0) + '\n') info(str(h1) + '\n')
def run(): topo = MyTopo() net = Mininet(topo=topo, controller=None, link=TCLink) net.addController('c0', controller=RemoteController, ip='127.0.0.1', port=6633) print("=== Add root ===") root = Node('root', inNamespace=False) intf = net.addLink(root, net['s1']).intf1 root.setIP('192.168.44.100/32', intf=intf) net.start() s8 = net.getNodeByName('s8') h9 = net.getNodeByName('h9') net.configLinkStatus(s8, h9, 'down') print("=== Run apache server ===") portal = net.getNodeByName('portal') portal.cmdPrint('/etc/init.d/apache2 restart') print("=== Run DHCP server ===") dhcp = net.getNodeByName('dhcp') # dhcp.cmdPrint('service isc-dhcp-server restart &') dhcp.cmdPrint( '/usr/sbin/dhcpd -q 4 -pf /run/dhcp-server-dhcpd.pid -cf ./dhcpd.conf %s' % dhcp.defaultIntf()) print("=== Request IP ===") for host in net.hosts: if str(host) != 'portal' and str(host) != 'dhcp' and str( host) != 'web' and str(host) != 'h9': host.cmdPrint('dhclient ' + host.defaultIntf().name) print("=== Open simple HTTP server ===") web = net.getNodeByName('web') web.cmdPrint('python -m SimpleHTTPServer 80 &') print("=== Set route ===") for route in ['192.168.44.0/24']: root.cmd('route add -net ' + route + ' dev ' + str(intf)) CLI(net) net.stop()
def scratchNet( cname='controller', cargs='-v ptcp:' ): "Create network from scratch using Open vSwitch." info( "*** Creating nodes\n" ) controller = Node( 'c0', inNamespace=False ) switch = Node( 's0', inNamespace=False ) h0 = Node( 'h0' ) h1 = Node( 'h1' ) info( "*** Creating links\n" ) Link( h0, switch ) Link( h1, switch ) info( "*** Configuring hosts\n" ) h0.setIP( '192.168.123.1/24' ) h1.setIP( '192.168.123.2/24' ) info( str( h0 ) + '\n' ) info( str( h1 ) + '\n' ) info( "*** Starting network using Open vSwitch\n" ) controller.cmd( cname + ' ' + cargs + '&' ) switch.cmd( 'ovs-vsctl del-br dp0' ) switch.cmd( 'ovs-vsctl add-br dp0' ) for intf in switch.intfs.values(): print switch.cmd( 'ovs-vsctl add-port dp0 %s' % intf ) # Note: controller and switch are in root namespace, and we # can connect via loopback interface switch.cmd( 'ovs-vsctl set-controller dp0 tcp:127.0.0.1:6633' ) info( '*** Waiting for switch to connect to controller' ) while 'is_connected' not in quietRun( 'ovs-vsctl show' ): sleep( 1 ) info( '.' ) info( '\n' ) info( "*** Running test\n" ) h0.cmdPrint( 'ping -c1 ' + h1.IP() ) info( "*** Stopping network\n" ) controller.cmd( 'kill %' + cname ) switch.cmd( 'ovs-vsctl del-br dp0' ) switch.deleteIntfs() info( '\n' )
def scratchNet(cname="controller", cargs="-v ptcp:"): "Create network from scratch using Open vSwitch." info("*** Creating nodes\n") controller = Node("c0", inNamespace=False) switch = Node("s0", inNamespace=False) h0 = Node("h0") h1 = Node("h1") info("*** Creating links\n") Link(h0, switch) Link(h1, switch) info("*** Configuring hosts\n") h0.setIP("192.168.123.1/24") h1.setIP("192.168.123.2/24") info(str(h0) + "\n") info(str(h1) + "\n") info("*** Starting network using Open vSwitch\n") controller.cmd(cname + " " + cargs + "&") switch.cmd("ovs-vsctl del-br dp0") switch.cmd("ovs-vsctl add-br dp0") for intf in switch.intfs.values(): print(switch.cmd("ovs-vsctl add-port dp0 %s" % intf)) # Note: controller and switch are in root namespace, and we # can connect via loopback interface switch.cmd("ovs-vsctl set-controller dp0 tcp:127.0.0.1:6633") info("*** Waiting for switch to connect to controller") while "is_connected" not in quietRun("ovs-vsctl show"): sleep(1) info(".") info("\n") info("*** Running test\n") h0.cmdPrint("ping -c1 " + h1.IP()) info("*** Stopping network\n") controller.cmd("kill %" + cname) switch.cmd("ovs-vsctl del-br dp0") switch.deleteIntfs() info("\n")
def myNet(): "Create network from scratch using Open vSwitch." info( "*** Creating nodes\n" ) switch0 = Node( 's0', inNamespace=False ) h0 = Node( 'h0' ) h1 = Node( 'h1' ) h2 = Node( 'h2' ) info( "*** Creating links\n" ) Link( h0, switch0) Link( h1, switch0) Link( h2, switch0) info( "*** Configuring hosts\n" ) h0.setIP( '192.168.123.1/24' ) h1.setIP( '192.168.123.2/24' ) h2.setIP( '192.168.123.3/24' ) info( "*** Starting network using Open vSwitch\n" ) switch0.cmd( 'ovs-vsctl del-br dp0' ) switch0.cmd( 'ovs-vsctl add-br dp0' ) for intf in switch0.intfs.values(): print intf print switch0.cmd( 'ovs-vsctl add-port dp0 %s' % intf ) # Note: controller and switch are in root namespace, and we # can connect via loopback interface #switch0.cmd( 'ovs-vsctl set-controller dp0 tcp:127.0.0.1:6633' ) print switch0.cmd(r'ovs-vsctl show') print switch0.cmd(r'ovs-ofctl add-flow dp0 idle_timeout=0,priority=1,in_port=1,actions=flood' ) print switch0.cmd(r'ovs-ofctl add-flow dp0 idle_timeout=0,priority=1,in_port=2,actions=flood' ) print switch0.cmd(r'ovs-ofctl add-flow dp0 idle_timeout=0,priority=1,in_port=3,actions=flood' ) print switch0.cmd(r'ovs-ofctl add-flow dp0 idle_timeout=0,priority=10,ip,nw_dst=192.168.123.1,actions=output:1' ) print switch0.cmd(r'ovs-ofctl add-flow dp0 idle_timeout=0,priority=10,ip,nw_dst=192.168.123.2,actions=output:2' ) print switch0.cmd(r'ovs-ofctl add-flow dp0 idle_timeout=0,priority=10,ip,nw_dst=192.168.123.3,actions=output:3') #switch0.cmd('tcpdump -i s0-eth0 -U -w aaa &') #h0.cmd('tcpdump -i h0-eth0 -U -w aaa &') info( "*** Running test\n" ) h0.cmdPrint( 'ping -c 3 ' + h1.IP() ) h0.cmdPrint( 'ping -c 3 ' + h2.IP() ) #print switch0.cmd( 'ovs-ofctl show dp0' ) #print switch0.cmd( 'ovs-ofctl dump-tables dp0' ) #print switch0.cmd( 'ovs-ofctl dump-ports dp0' ) #print switch0.cmd( 'ovs-ofctl dump-flows dp0' ) #print switch0.cmd( 'ovs-ofctl dump-aggregate dp0' ) #print switch0.cmd( 'ovs-ofctl queue-stats dp0' ) info( "*** Stopping network\n" ) switch0.cmd( 'ovs-vsctl del-br dp0' ) switch0.deleteIntfs() info( '\n' )
def createAgentNet( k, routeIP ): net = Mininet( controller=Controller, switch=OVSBridge ) print "*** Creating agent network" sw = net.addSwitch( 's%s' % (k+1) ) for i in range( 1, k+1 ): host = net.addHost( 'agent%s' % i, ip='171.0.0.%s/16' % i ) intf = net.addLink( sw, host ).intf2 if routeIP != '127.0.0.1': # host.setHostRoute( routeIP, intf ) # this api does not work!!! host.cmd( 'ip route add %s dev %s' % ( routeIP, str( intf ) ) ) # c = net.addController('c1', controller=Controller, ip='127.0.0.1', port=6699) root = Node( 'root', inNamespace=False ) intf = net.addLink( root, sw ).intf1 root.setIP( '171.0.123.1/16', intf=intf ) # root.cmd( 'route add -net 171.0.0.0/16 dev ' + str( intf ) ) net.build() # c.start() sw.start( [] ) return net
def createAgentNet(k, routeIP): net = Mininet(controller=Controller, switch=OVSBridge) print "*** Creating agent network" sw = net.addSwitch('s%s' % (k + 1)) for i in range(1, k + 1): host = net.addHost('agent%s' % i, ip='171.0.0.%s/16' % i) intf = net.addLink(sw, host).intf2 if routeIP != '127.0.0.1': # host.setHostRoute( routeIP, intf ) # this api does not work!!! host.cmd('ip route add %s dev %s' % (routeIP, str(intf))) # c = net.addController('c1', controller=Controller, ip='127.0.0.1', port=6699) root = Node('root', inNamespace=False) intf = net.addLink(root, sw).intf1 root.setIP('171.0.123.1/16', intf=intf) # root.cmd( 'route add -net 171.0.0.0/16 dev ' + str( intf ) ) net.build() # c.start() sw.start([]) return net
def scratchNet(cname='controller', cargs='ptcp:'): "Create network from scratch using kernel switch." info("*** Creating nodes\n") controller = Node('c0', inNamespace=False) switch = Node('s0', inNamespace=False) h0 = Node('h0') h1 = Node('h1') info("*** Creating links\n") createLink(node1=h0, node2=switch, port1=0, port2=0) createLink(node1=h1, node2=switch, port1=0, port2=1) info("*** Configuring hosts\n") h0.setIP(h0.intfs[0], '192.168.123.1', 24) h1.setIP(h1.intfs[0], '192.168.123.2', 24) info(str(h0) + '\n') info(str(h1) + '\n') info("*** Starting network using Open vSwitch kernel datapath\n") controller.cmd(cname + ' ' + cargs + '&') switch.cmd('ovs-dpctl del-dp dp0') switch.cmd('ovs-dpctl add-dp dp0') for intf in switch.intfs.values(): print switch.cmd('ovs-dpctl add-if dp0 ' + intf) print switch.cmd('ovs-openflowd dp0 tcp:127.0.0.1 &') info("*** Running test\n") h0.cmdPrint('ping -c1 ' + h1.IP()) info("*** Stopping network\n") controller.cmd('kill %' + cname) switch.cmd('ovs-dpctl del-dp dp0') switch.cmd('kill %ovs-openflowd') switch.deleteIntfs() info('\n')
def scratchNet( cname='controller', cargs='ptcp:' ): "Create network from scratch using kernel switch." info( "*** Creating nodes\n" ) controller = Node( 'c0', inNamespace=False ) switch = Node( 's0', inNamespace=False ) h0 = Node( 'h0' ) h1 = Node( 'h1' ) info( "*** Creating links\n" ) createLink( node1=h0, node2=switch, port1=0, port2=0 ) createLink( node1=h1, node2=switch, port1=0, port2=1 ) info( "*** Configuring hosts\n" ) h0.setIP( h0.intfs[ 0 ], '192.168.123.1', 24 ) h1.setIP( h1.intfs[ 0 ], '192.168.123.2', 24 ) info( str( h0 ) + '\n' ) info( str( h1 ) + '\n' ) info( "*** Starting network using Open vSwitch kernel datapath\n" ) controller.cmd( cname + ' ' + cargs + '&' ) switch.cmd( 'ovs-dpctl del-dp dp0' ) switch.cmd( 'ovs-dpctl add-dp dp0' ) for intf in switch.intfs.values(): print switch.cmd( 'ovs-dpctl add-if dp0 ' + intf ) print switch.cmd( 'ovs-openflowd dp0 tcp:127.0.0.1 &' ) info( "*** Running test\n" ) h0.cmdPrint( 'ping -c1 ' + h1.IP() ) info( "*** Stopping network\n" ) controller.cmd( 'kill %' + cname ) switch.cmd( 'ovs-dpctl del-dp dp0' ) switch.cmd( 'kill %ovs-openflowd' ) switch.deleteIntfs() info( '\n' )
def connectToRootNS(net, num_cloudlets): root = Node('root', inNamespace=False) switch = net['cs0'] ip = config.master_root_ip main_intf = net.addLink(root, switch).intf1 root.setIP(ip, intf=main_intf) # TODO better id? dpid = '%010x' % 130013 device_switch = net.addSwitch('ds', dpid=dpid) intf = net.addLink(root, device_switch).intf1 root.setIP(config.master_to_device_ip, intf=intf) intf = net.addLink(net['device'], device_switch, intf1Name="dev_root", intf2Name="root_dev").intf1 net['device'].setIP(config.device_to_master_ip, intf=intf) # TODO do we need routing rules for device? routes = [ get_ip(a=x, suffix=16) for x in ( config.mesh_network_prefix, config.tower_network_prefix, ) ] for i in range(1, num_cloudlets): routes.append(get_ip(a=config.cloudlet_network_prefix, c=i, suffix=24)) default_route_ip = get_ip(a=config.cloudlet_network_prefix, d=1) print "root routes" for route in routes: print 'ip route add to %s via %s dev %s' % (route, default_route_ip, main_intf) root.cmd('ip route add to %s via %s dev %s' % (route, default_route_ip, main_intf))
def connectToRootNS( net, ip='10.123.123.1', mac='00123456789A', prefixLen=8, routes=['10.0.0.0/8']): print "*** Creating controller" c0 = net.addController( 'c0', ip='127.0.0.1', port=6633 ) rootswitch = net.addSwitch('roots1',) rootswitch.dpid = 'FFFFFFFFFFFFFFFF' # Connect hosts to root namespace via switch. Starts network. # network: Mininet() network object # ip: IP address for root namespace node # prefixLen: IP address prefix length (e.g. 8, 16, 24) # routes: host networks to route to" # Create a node in root namespace and link to switch 0 root = Node( 'root', inNamespace=False ) intf = Link( root, rootswitch ).intf1 intf.setMAC(mac) root.setIP( ip, prefixLen, intf ) print "*** Added Interface", str(intf), "Connected To Root-NameSpace" fixNetworkManager(str(intf)) for host in net.hosts: net.addLink(host,rootswitch) # Add routes from root ns to hosts for route in routes: root.cmd( 'route add -net ' + route + ' dev ' + str( intf ) ) root.cmd('service network-manager restart') return rootswitch
def scratchNetUser( cname='controller', cargs='ptcp:' ): "Create network from scratch using user switch." # It's not strictly necessary for the controller and switches # to be in separate namespaces. For performance, they probably # should be in the root namespace. However, it's interesting to # see how they could work even if they are in separate namespaces. info( '*** Creating Network\n' ) controller = Node( 'c0' ) switch = Node( 's0') h0 = Node( 'h0' ) h1 = Node( 'h1' ) cintf, sintf = createLink( controller, switch ) h0intf, sintf1 = createLink( h0, switch ) h1intf, sintf2 = createLink( h1, switch ) info( '*** Configuring control network\n' ) controller.setIP( cintf, '10.0.123.1', 24 ) switch.setIP( sintf, '10.0.123.2', 24 ) info( '*** Configuring hosts\n' ) h0.setIP( h0intf, '192.168.123.1', 24 ) h1.setIP( h1intf, '192.168.123.2', 24 ) info( '*** Network state:\n' ) for node in controller, switch, h0, h1: info( str( node ) + '\n' ) info( '*** Starting controller and user datapath\n' ) controller.cmd( cname + ' ' + cargs + '&' ) switch.cmd( 'ifconfig lo 127.0.0.1' ) intfs = [ sintf1, sintf2 ] switch.cmd( 'ofdatapath -i ' + ','.join( intfs ) + ' ptcp: &' ) switch.cmd( 'ofprotocol tcp:' + controller.IP() + ' tcp:localhost &' ) info( '*** Running test\n' ) h0.cmdPrint( 'ping -c1 ' + h1.IP() ) info( '*** Stopping network\n' ) controller.cmd( 'kill %' + cname ) switch.cmd( 'kill %ofdatapath' ) switch.cmd( 'kill %ofprotocol' ) switch.deleteIntfs() info( '\n' )
def scratchNetUser(cname='controller', cargs='ptcp:'): "Create network from scratch using user switch." # It's not strictly necessary for the controller and switches # to be in separate namespaces. For performance, they probably # should be in the root namespace. However, it's interesting to # see how they could work even if they are in separate namespaces. info('*** Creating Network\n') controller = Node('c0') switch = Node('s0') h0 = Node('h0') h1 = Node('h1') cintf, sintf = createLink(controller, switch) h0intf, sintf1 = createLink(h0, switch) h1intf, sintf2 = createLink(h1, switch) info('*** Configuring control network\n') controller.setIP(cintf, '10.0.123.1', 24) switch.setIP(sintf, '10.0.123.2', 24) info('*** Configuring hosts\n') h0.setIP(h0intf, '192.168.123.1', 24) h1.setIP(h1intf, '192.168.123.2', 24) info('*** Network state:\n') for node in controller, switch, h0, h1: info(str(node) + '\n') info('*** Starting controller and user datapath\n') controller.cmd(cname + ' ' + cargs + '&') switch.cmd('ifconfig lo 127.0.0.1') intfs = [sintf1, sintf2] switch.cmd('ofdatapath -i ' + ','.join(intfs) + ' ptcp: &') switch.cmd('ofprotocol tcp:' + controller.IP() + ' tcp:localhost &') info('*** Running test\n') h0.cmdPrint('ping -c1 ' + h1.IP()) info('*** Stopping network\n') controller.cmd('kill %' + cname) switch.cmd('kill %ofdatapath') switch.cmd('kill %ofprotocol') switch.deleteIntfs() info('\n')
def myNet(cname='controller', cargs='-v ptcp:'): "Create network from scratch using Open vSwitch." info( "*** Creating nodes\n" ) controller = Node( 'c0', inNamespace=False ) switch = Node( 's0', inNamespace=False ) h0 = Node( 'h0' ) h1 = Node( 'h1' ) h2 = Node( 'h2' ) info( "*** Creating links\n" ) linkopts0=dict(bw=100, delay='1ms', loss=0) TCLink( h0, switch, **linkopts0) TCLink( h1, switch, **linkopts0) TCLink( h2, switch, **linkopts0) info( "*** Configuring hosts\n" ) h0.setIP( '192.168.123.1/24' ) h1.setIP( '192.168.123.2/24' ) h2.setIP( '192.168.123.3/24' ) info( "*** Starting network using Open vSwitch\n" ) switch.cmd( 'ovs-vsctl del-br dp0' ) switch.cmd( 'ovs-vsctl add-br dp0' ) controller.cmd( cname + ' ' + cargs + '&' ) for intf in switch.intfs.values(): print intf print switch.cmd( 'ovs-vsctl add-port dp0 %s' % intf ) # Note: controller and switch are in root namespace, and we # can connect via loopback interface switch.cmd( 'ovs-vsctl set-controller dp0 tcp:127.0.0.1:6633' ) info( '*** Waiting for switch to connect to controller' ) while 'is_connected' not in quietRun( 'ovs-vsctl show' ): sleep( 1 ) info( '.' ) info( '\n' ) #info( "*** Running test\n" ) h0.cmdPrint( 'ping -c 3 ' + h1.IP() ) h0.cmdPrint( 'ping -c 3 ' + h2.IP() ) h2.cmdPrint( 'ping -c 3 ' + h1.IP() ) info( "*** Stopping network\n" ) controller.cmd( 'kill %' + cname ) switch.cmd( 'ovs-vsctl del-br dp0' ) switch.deleteIntfs() info( '\n' )
net.addLink(s1,s2) net.addLink(s2,s3) net.addLink(s2,s4) net.addLink(s4,p1s1) net.addLink(s4,p1s2) net.addLink(s3,p1s3) net.addLink(s3,p1s4) # # Connect to root namespace (borrowed from mininet/examples/sshd.py) root = Node( 'root', inNamespace=False ) intf = Link( root, net[ 's1' ] ).intf1 root.setIP( '10.10.10.10/8', intf=intf ) net.start() p1.setIP('10.1.0.1') p1s1.setIP('10.1.1.1') p1s2.setIP('10.1.1.2') p1s3.setIP('10.1.1.3') p1s4.setIP('10.1.1.4') # # Add route for multicast range 230.0.0.0/8 on hosts info( '*** Adding route for multicast range 230.0.0.0/8\n' )
class OpenstackManage(object): """ OpenstackManage is a singleton and management component for the emulator. It is the brain of the Openstack component and manages everything that is not datacenter specific like network chains or load balancers. """ __instance = None def __new__(cls): if OpenstackManage.__instance is None: OpenstackManage.__instance = object.__new__(cls) return OpenstackManage.__instance def __init__(self, ip="0.0.0.0", port=4000): # we are a singleton, only initialize once! self.lock = threading.Lock() with self.lock: if hasattr(self, "init"): return self.init = True self.endpoints = dict() self.cookies = set() self.cookies.add(0) self.ip = ip self.port = port self._net = None # to keep track which src_vnf(input port on the switch) handles a load balancer self.lb_flow_cookies = dict() self.chain_flow_cookies = dict() # for the visualization also store the complete chain data incl. paths self.full_chain_data = dict() self.full_lb_data = dict() # flow groups could be handled for each switch separately, but this global group counter should be easier to # debug and to maintain self.flow_groups = dict() # we want one global chain api. this should not be datacenter dependent! self.chain = chain_api.ChainApi(ip, port, self) self.thread = threading.Thread(target=self.chain._start_flask, args=()) self.thread.daemon = True self.thread.name = self.chain.__class__ self.thread.start() # floating ip network setup self.floating_switch = None self.floating_network = None self.floating_netmask = "192.168.100.0/24" self.floating_nodes = dict() self.floating_cookies = dict() self.floating_intf = None self.floating_links = dict() @property def net(self): return self._net @net.setter def net(self, value): if self._net is None: self._net = value self.init_floating_network() self._net = value def init_floating_network(self): """ Initialize the floating network component for the emulator. Will not do anything if already initialized. """ if self.net is not None and self.floating_switch is None: # create a floating network fn = self.floating_network = Net("default") fn.id = str(uuid.uuid4()) fn.set_cidr(self.floating_netmask) # create a subnet fn.subnet_id = str(uuid.uuid4()) fn.subnet_name = fn.name + "-sub" # create a port for the host port = Port("root-port") #port.id = str(uuid.uuid4()) port.net_name = fn.name # get next free ip root_ip = fn.get_new_ip_address(port.name) port.ip_address = root_ip # floating ip network setup # wierd way of getting a datacenter object first_dc = self.net.dcs.values()[0] # set a dpid for the switch. for this we have to get the id of the next possible dc self.floating_switch = self.net.addSwitch("fs1", dpid=hex(first_dc._get_next_dc_dpid())[2:]) # this is the interface appearing on the physical host self.floating_root = Node('root', inNamespace=False) self.net.hosts.append(self.floating_root) self.net.nameToNode['root'] = self.floating_root self.floating_intf = self.net.addLink(self.floating_root, self.floating_switch).intf1 self.floating_root.setIP(root_ip, intf=self.floating_intf) self.floating_nodes[(self.floating_root.name, root_ip)] = self.floating_root def stop_floating_network(self): self._net = None self.floating_switch = None def add_endpoint(self, ep): """ Registers an openstack endpoint with manage :param ep: Openstack API endpoint :type ep: :class:`heat.openstack_api_endpoint` """ key = "%s:%s" % (ep.ip, ep.port) self.endpoints[key] = ep def get_cookie(self): """ Get an unused cookie. :return: Cookie :rtype: ``int`` """ cookie = int(max(self.cookies) + 1) self.cookies.add(cookie) return cookie def get_flow_group(self, src_vnf_name, src_vnf_interface): """ Gets free group that is not currently used by any other flow for the specified interface / VNF. :param src_vnf_name: Source VNF name :type src_vnf_name: ``str`` :param src_vnf_interface: Source VNF interface name :type src_vnf_interface: ``str`` :return: Flow group identifier. :rtype: ``int`` """ if (src_vnf_name, src_vnf_interface) not in self.flow_groups: grp = int(len(self.flow_groups) + 1) self.flow_groups[(src_vnf_name, src_vnf_interface)] = grp else: grp = self.flow_groups[(src_vnf_name, src_vnf_interface)] return grp def check_vnf_intf_pair(self, vnf_name, vnf_intf_name): """ Checks if a VNF exists and has the given interface :param vnf_name: Name of the VNF to be checked :type vnf_name: ``str`` :param vnf_intf_name: Name of the interface that belongst to the VNF :type vnf_intf_name: ``str`` :return: ``True`` if it is valid pair, else ``False`` :rtype: ``bool`` """ if vnf_name in self.net: vnf = self.net.getNodeByName(vnf_name) return vnf_intf_name in vnf.nameToIntf def network_action_start(self, vnf_src_name, vnf_dst_name, **kwargs): """ Starts a network chain for a source destination pair :param vnf_src_name: Name of the source VNF :type vnf_src_name: ``str`` :param vnf_dst_name: Name of the source VNF interface :type vnf_dst_name: ``str`` :param \**kwargs: See below :Keyword Arguments: * *vnf_src_interface* (``str``): Name of source interface. * *vnf_dst_interface* (``str``): Name of destination interface. * *weight* (``int``): This value is fed into the shortest path computation if no path is specified. * *match* (``str``): A custom match entry for the openflow flow rules. Only vlanid or port possible. * *bidirectional* (``bool``): If set the chain will be set in both directions, else it will just set up \ from source to destination. * *cookie* (``int``): Cookie value used by openflow. Used to identify the flows in the switches to be \ able to modify the correct flows. * *no_route* (``bool``): If set a layer 3 route to the target interface will not be set up. :return: The cookie chosen for the flow. :rtype: ``int`` """ try: vnf_src_interface = kwargs.get('vnf_src_interface') vnf_dst_interface = kwargs.get('vnf_dst_interface') layer2 = kwargs.get('layer2', True) match = kwargs.get('match') flow = (vnf_src_name, vnf_src_interface, vnf_dst_name, vnf_dst_interface) if flow in self.chain_flow_cookies: raise Exception("There is already a chain at the specified src/dst pair!") # set up a layer 2 chain, this allows multiple chains for the same interface src_node = self.net.getNodeByName(vnf_src_name) dst_node = self.net.getNodeByName(vnf_dst_name) dst_intf = dst_node.intf(vnf_dst_interface) if layer2: switch, inport = self._get_connected_switch_data(vnf_src_name, vnf_src_interface) self.setup_arp_reply_at(switch, inport, dst_intf.IP(), dst_intf.MAC()) if isinstance(match, str): match += ",dl_dst=%s" % dst_intf.MAC() else: match = "dl_dst=%s" % dst_intf.MAC() cookie = kwargs.get('cookie', self.get_cookie()) self.cookies.add(cookie) c = self.net.setChain( vnf_src_name, vnf_dst_name, vnf_src_interface=vnf_src_interface, vnf_dst_interface=vnf_dst_interface, cmd='add-flow', weight=kwargs.get('weight'), match=match, bidirectional=False, cookie=cookie, path=kwargs.get('path')) # to keep this logic seperate of the core son-emu do the housekeeping here data = dict() data["src_vnf"] = vnf_src_name data["src_intf"] = vnf_src_interface data["dst_vnf"] = vnf_dst_name data["dst_intf"] = vnf_dst_interface data["cookie"] = cookie data["layer2"] = layer2 if kwargs.get('path') is not None: data["path"] = kwargs.get('path') else: data["path"] = self._get_path(vnf_src_name, vnf_dst_name, vnf_src_interface, vnf_dst_interface)[0] # add route to dst ip to this interface # this might block on containers that are still setting up, so start a new thread if not kwargs.get('no_route'): # son_emu does not like concurrent commands for a container so we need to lock this if multiple chains # on the same interface are created src_node.setHostRoute(dst_node.intf(vnf_dst_interface).IP(), vnf_src_interface) try: son_emu_data = json.loads(self.get_son_emu_chain_data(vnf_src_name)) except: son_emu_data = dict() if "son_emu_data" not in son_emu_data: son_emu_data["son_emu_data"] = dict() if "interfaces" not in son_emu_data["son_emu_data"]: son_emu_data["son_emu_data"]["interfaces"] = dict() if vnf_src_interface not in son_emu_data["son_emu_data"]["interfaces"]: son_emu_data["son_emu_data"]["interfaces"][vnf_src_interface] = list() son_emu_data["son_emu_data"]["interfaces"][vnf_src_interface].append(dst_intf.IP()) self.set_son_emu_chain_data(vnf_src_name, son_emu_data) if kwargs.get('bidirectional', False): # call the reverse direction path = kwargs.get('path') if path is not None: path = list(reversed(path)) self.network_action_start(vnf_dst_name, vnf_src_name, vnf_src_interface=vnf_dst_interface, vnf_dst_interface=vnf_src_interface, bidirectional=False, layer2=kwargs.get('layer2', False), path=path, no_route=kwargs.get('no_route')) self.full_chain_data[flow] = data self.chain_flow_cookies[flow] = cookie return cookie except Exception as ex: logging.exception("RPC error.") raise Exception(ex.message) def network_action_stop(self, vnf_src_name, vnf_dst_name, **kwargs): """ Starts a network chain for a source destination pair :param vnf_src_name: Name of the source VNF :type vnf_src_name: ``str`` :param vnf_dst_name: Name of the source VNF interface :type vnf_dst_name: ``str`` :param \**kwargs: See below :Keyword Arguments: * *vnf_src_interface* (``str``): Name of source interface. * *vnf_dst_interface* (``str``): Name of destination interface. * *bidirectional* (``bool``): If set the chain will be torn down in both directions, else it will just\ be torn down from source to destination. * *cookie* (``int``): Cookie value used by openflow. Used to identify the flows in the switches to be \ able to modify the correct flows. """ try: if 'cookie' in kwargs: return self.delete_flow_by_cookie(kwargs.get('cookie')) if kwargs.get('bidirectional', False): self.delete_chain_by_intf(vnf_dst_name, kwargs.get('vnf_dst_interface'), vnf_src_name, kwargs.get('vnf_src_interface')) return self.delete_chain_by_intf(vnf_src_name, kwargs.get('vnf_src_interface'), vnf_dst_name, kwargs.get('vnf_dst_interface')) except Exception as ex: logging.exception("RPC error.") return ex.message def set_son_emu_chain_data(self, vnf_name, data): """ Set son-emu chain data for this node. :param vnf_name: The name of the vnf where the data is stored. :type vnf_name: ``str`` :param data: Raw data to store on the node. :type data: ``str`` """ self.net.getNodeByName(vnf_name).cmd("echo \'%s\' > /tmp/son_emu_data.json" % json.dumps(data)) ip_list = [] for intf in data['son_emu_data']['interfaces'].values(): ip_list.extend(intf) self.net.getNodeByName(vnf_name).cmd("echo \'%s\' > /tmp/son_emu_data" % "\n".join(ip_list)) def get_son_emu_chain_data(self, vnf_name): """ Get the current son-emu chain data set for this node. :param vnf_name: The name of the vnf where the data is stored. :type vnf_name: ``str`` :return: raw data stored on the node :rtype: ``str`` """ return self.net.getNodeByName(vnf_name).cmd("cat /tmp/son_emu_data.json") def _get_connected_switch_data(self, vnf_name, vnf_interface): """ Get the switch an interface is connected to :param vnf_name: Name of the VNF :type vnf_name: ``str`` :param vnf_interface: Name of the VNF interface :type vnf_interface: ``str`` :return: List containing the switch, and the inport number :rtype: [``str``, ``int``] """ src_sw = None src_sw_inport_nr = None for connected_sw in self.net.DCNetwork_graph.neighbors(vnf_name): link_dict = self.net.DCNetwork_graph[vnf_name][connected_sw] for link in link_dict: if (link_dict[link]['src_port_id'] == vnf_interface or link_dict[link][ 'src_port_name'] == vnf_interface): # found the right link and connected switch src_sw = connected_sw src_sw_inport_nr = link_dict[link]['dst_port_nr'] break return src_sw, src_sw_inport_nr def _get_path(self, src_vnf, dst_vnf, src_vnf_intf, dst_vnf_intf): """ Own implementation of the get_path function from DCNetwork, because we just want the path and not set up flows on the way. :param src_vnf: Name of the source VNF :type src_vnf: ``str`` :param dst_vnf: Name of the destination VNF :type dst_vnf: ``str`` :param src_vnf_intf: Name of the source VNF interface :type src_vnf_intf: ``str`` :param dst_vnf_intf: Name of the destination VNF interface :type dst_vnf_intf: ``str`` :return: path, src_sw, dst_sw :rtype: ``list``, ``str``, ``str`` """ # modified version of the _chainAddFlow from emuvim.dcemulator.net._chainAddFlow src_sw = None dst_sw = None logging.debug("Find shortest path from vnf %s to %s", src_vnf, dst_vnf) for connected_sw in self.net.DCNetwork_graph.neighbors(src_vnf): link_dict = self.net.DCNetwork_graph[src_vnf][connected_sw] for link in link_dict: if (link_dict[link]['src_port_id'] == src_vnf_intf or link_dict[link][ 'src_port_name'] == src_vnf_intf): # found the right link and connected switch src_sw = connected_sw break for connected_sw in self.net.DCNetwork_graph.neighbors(dst_vnf): link_dict = self.net.DCNetwork_graph[connected_sw][dst_vnf] for link in link_dict: if link_dict[link]['dst_port_id'] == dst_vnf_intf or \ link_dict[link][ 'dst_port_name'] == dst_vnf_intf: # found the right link and connected dst_sw = connected_sw break logging.debug("From switch %s to %s " % (src_sw, dst_sw)) # get shortest path try: # returns the first found shortest path # if all shortest paths are wanted, use: all_shortest_paths path = nx.shortest_path(self.net.DCNetwork_graph, src_sw, dst_sw) except: logging.exception("No path could be found between {0} and {1} using src_sw={2} and dst_sw={3}".format( src_vnf, dst_vnf, src_sw, dst_sw)) logging.debug("Graph nodes: %r" % self.net.DCNetwork_graph.nodes()) logging.debug("Graph edges: %r" % self.net.DCNetwork_graph.edges()) for e, v in self.net.DCNetwork_graph.edges(): logging.debug("%r" % self.net.DCNetwork_graph[e][v]) return "No path could be found between {0} and {1}".format(src_vnf, dst_vnf) logging.info("Shortest path between {0} and {1}: {2}".format(src_vnf, dst_vnf, path)) return path, src_sw, dst_sw def add_loadbalancer(self, src_vnf_name, src_vnf_interface, lb_data): """ This function will set up a loadbalancer at the given interface. :param src_vnf_name: Name of the source VNF :type src_vnf_name: ``str`` :param src_vnf_interface: Name of the destination VNF :type src_vnf_interface: ``str`` :param lb_data: A dictionary containing the destination data as well as custom path settings :type lb_data: ``dict`` :Example: lbdata = {"dst_vnf_interfaces": {"dc2_man_web0": "port-man-2", "dc3_man_web0": "port-man-4","dc4_man_web0": "port-man-6"}, "path": {"dc2_man_web0": {"port-man-2": [ "dc1.s1",\ "s1", "dc2.s1"]}}} """ net = self.net src_sw_inport_nr = 0 src_sw = None dest_intfs_mapping = lb_data.get('dst_vnf_interfaces', dict()) # a custom path can be specified as a list of switches custom_paths = lb_data.get('path', dict()) dest_vnf_outport_nrs = list() logging.debug("Call to add_loadbalancer at %s intfs:%s" % (src_vnf_name, src_vnf_interface)) if not self.check_vnf_intf_pair(src_vnf_name, src_vnf_interface): raise Exception(u"Source VNF %s or intfs %s does not exist" % (src_vnf_name, src_vnf_interface)) # find the switch belonging to the source interface, as well as the inport nr for connected_sw in net.DCNetwork_graph.neighbors(src_vnf_name): link_dict = net.DCNetwork_graph[src_vnf_name][connected_sw] for link in link_dict: if link_dict[link]['src_port_name'] == src_vnf_interface: src_sw = connected_sw src_sw_inport_nr = link_dict[link]['dst_port_nr'] break if src_sw is None or src_sw_inport_nr == 0: raise Exception(u"Source VNF or interface can not be found.") # get all target interface outport numbers for vnf_name in dest_intfs_mapping: if vnf_name not in net.DCNetwork_graph: raise Exception(u"Target VNF %s is not known." % vnf_name) for connected_sw in net.DCNetwork_graph.neighbors(vnf_name): link_dict = net.DCNetwork_graph[vnf_name][connected_sw] for link in link_dict: if link_dict[link]['src_port_name'] == dest_intfs_mapping[vnf_name]: dest_vnf_outport_nrs.append(int(link_dict[link]['dst_port_nr'])) # get first switch if (src_vnf_name, src_vnf_interface) not in self.lb_flow_cookies: self.lb_flow_cookies[(src_vnf_name, src_vnf_interface)] = list() src_intf = None src_ip = None src_mac = None for intf in net[src_vnf_name].intfs.values(): if intf.name == src_vnf_interface: src_mac = intf.mac src_ip = intf.ip src_intf = intf # set up paths for each destination vnf individually index = 0 cookie = self.get_cookie() main_cmd = "add-flow -OOpenFlow13" self.lb_flow_cookies[(src_vnf_name, src_vnf_interface)].append(cookie) # bookkeeping data = dict() data["src_vnf"] = src_vnf_name data["src_intf"] = src_vnf_interface data["paths"] = list() data["cookie"] = cookie # lb mac for src -> target connections lb_mac = "31:33:70:%02x:%02x:%02x" % (random.randint(0, 255),random.randint(0, 255),random.randint(0, 255)) # calculate lb ip as src_intf.ip +1 octets = src_ip.split('.') octets[3] = str(int(octets[3]) + 1) plus_one = '.'.join(octets) # set up arp reply as well as add the route to the interface self.setup_arp_reply_at(src_sw, src_sw_inport_nr, plus_one, lb_mac, cookie=cookie) net.getNodeByName(src_vnf_name).setHostRoute(plus_one, src_vnf_interface) for dst_vnf_name, dst_vnf_interface in dest_intfs_mapping.items(): path, src_sw, dst_sw = self._get_path(src_vnf_name, dst_vnf_name, src_vnf_interface, dst_vnf_interface) # use custom path if one is supplied # json does not support hashing on tuples so we use nested dicts if custom_paths is not None and dst_vnf_name in custom_paths: if dst_vnf_interface in custom_paths[dst_vnf_name]: path = custom_paths[dst_vnf_name][dst_vnf_interface] logging.debug("Taking custom path from %s to %s: %s" % (src_vnf_name, dst_vnf_name, path)) if not self.check_vnf_intf_pair(dst_vnf_name, dst_vnf_interface): self.delete_loadbalancer(src_vnf_name, src_vnf_interface) raise Exception(u"VNF %s or intfs %s does not exist" % (dst_vnf_name, dst_vnf_interface)) if isinstance(path, dict): self.delete_loadbalancer(src_vnf_name, src_vnf_interface) raise Exception(u"Can not find a valid path. Are you specifying the right interfaces?.") target_mac = "fa:17:00:03:13:37" target_ip = "0.0.0.0" for intf in net[dst_vnf_name].intfs.values(): if intf.name == dst_vnf_interface: target_mac = str(intf.mac) target_ip = str(intf.ip) dst_sw_outport_nr = dest_vnf_outport_nrs[index] current_hop = src_sw switch_inport_nr = src_sw_inport_nr #self.setup_arp_reply_at(src_sw, src_sw_inport_nr, target_ip, target_mac, cookie=cookie) net.getNodeByName(dst_vnf_name).setHostRoute(src_ip, dst_vnf_interface) # choose free vlan if path contains more than 1 switch if len(path) > 1: vlan = net.vlans.pop() if vlan == 0: vlan = net.vlans.pop() else: vlan = None single_flow_data = dict() single_flow_data["dst_vnf"] = dst_vnf_name single_flow_data["dst_intf"] = dst_vnf_interface single_flow_data["path"] = path single_flow_data["vlan"] = vlan single_flow_data["cookie"] = cookie data["paths"].append(single_flow_data) # src to target for i in range(0, len(path)): if i < len(path) - 1: next_hop = path[i + 1] else: # last switch reached next_hop = dst_vnf_name next_node = net.getNodeByName(next_hop) if next_hop == dst_vnf_name: switch_outport_nr = dst_sw_outport_nr logging.info("end node reached: {0}".format(dst_vnf_name)) elif not isinstance(next_node, OVSSwitch): logging.info("Next node: {0} is not a switch".format(next_hop)) return "Next node: {0} is not a switch".format(next_hop) else: # take first link between switches by default index_edge_out = 0 switch_outport_nr = net.DCNetwork_graph[current_hop][next_hop][index_edge_out]['src_port_nr'] cmd = 'priority=1,in_port=%s,cookie=%s' % (switch_inport_nr, cookie) cmd_back = 'priority=1,in_port=%s,cookie=%s' % (switch_outport_nr, cookie) # if a vlan is picked, the connection is routed through multiple switches if vlan is not None: if path.index(current_hop) == 0: # first node # flow #index set up cmd = 'in_port=%s' % src_sw_inport_nr cmd += ',cookie=%s' % cookie cmd += ',table=%s' % cookie cmd += ',ip' cmd += ',reg1=%s' % index cmd += ',actions=' # set vlan id cmd += ',push_vlan:0x8100' masked_vlan = vlan | 0x1000 cmd += ',set_field:%s->vlan_vid' % masked_vlan cmd += ',set_field:%s->eth_dst' % target_mac cmd += ',set_field:%s->ip_dst' % target_ip cmd += ',output:%s' % switch_outport_nr # last switch for reverse route # remove any vlan tags cmd_back += ',dl_vlan=%s' % vlan cmd_back += ',actions=pop_vlan,output:%s' % switch_inport_nr elif next_hop == dst_vnf_name: # last switch # remove any vlan tags cmd += ',dl_vlan=%s' % vlan cmd += ',actions=pop_vlan,output:%s' % switch_outport_nr # set up arp replys at the port so the dst nodes know the src self.setup_arp_reply_at(current_hop, switch_outport_nr, src_ip, src_mac, cookie=cookie) # reverse route cmd_back = 'in_port=%s' % switch_outport_nr cmd_back += ',cookie=%s' % cookie cmd_back += ',ip' cmd_back += ',actions=' cmd_back += 'push_vlan:0x8100' masked_vlan = vlan | 0x1000 cmd_back += ',set_field:%s->vlan_vid' % masked_vlan cmd_back += ',set_field:%s->eth_src' % lb_mac cmd_back += ',set_field:%s->ip_src' % plus_one cmd_back += ',output:%s' % switch_inport_nr else: # middle nodes # if we have a circle in the path we need to specify this, as openflow will ignore the packet # if we just output it on the same port as it came in if switch_inport_nr == switch_outport_nr: cmd += ',dl_vlan=%s,actions=IN_PORT' % (vlan) cmd_back += ',dl_vlan=%s,actions=IN_PORT' % (vlan) else: cmd += ',dl_vlan=%s,actions=output:%s' % (vlan, switch_outport_nr) cmd_back += ',dl_vlan=%s,actions=output:%s' % (vlan, switch_inport_nr) # output the packet at the correct outport else: cmd = 'in_port=%s' % src_sw_inport_nr cmd += ',cookie=%s' % cookie cmd += ',table=%s' % cookie cmd += ',ip' cmd += ',reg1=%s' % index cmd += ',actions=' cmd += ',set_field:%s->eth_dst' % target_mac cmd += ',set_field:%s->ip_dst' % target_ip cmd += ',output:%s' % switch_outport_nr # reverse route cmd_back = 'in_port=%s' % switch_outport_nr cmd_back += ',cookie=%s' % cookie cmd_back += ',ip' cmd_back += ',actions=' cmd_back += ',set_field:%s->eth_src' % lb_mac cmd_back += ',set_field:%s->ip_src' % plus_one cmd_back += ',output:%s' % src_sw_inport_nr self.setup_arp_reply_at(current_hop, switch_outport_nr, src_ip, src_mac, cookie=cookie) # excecute the command on the target switch logging.debug(cmd) cmd = "\"%s\"" % cmd cmd_back = "\"%s\"" % cmd_back net[current_hop].dpctl(main_cmd, cmd) net[current_hop].dpctl(main_cmd, cmd_back) # set next hop for the next iteration step if isinstance(next_node, OVSSwitch): switch_inport_nr = net.DCNetwork_graph[current_hop][next_hop][0]['dst_port_nr'] current_hop = next_hop # advance to next destination index += 1 # set up the actual load balancing rule as a multipath on the very first switch cmd = '"in_port=%s' % src_sw_inport_nr cmd += ',cookie=%s' % (cookie) cmd += ',ip' cmd += ',actions=' # push 0x01 into the first register cmd += 'load:0x1->NXM_NX_REG0[]' # load balance modulo n over all dest interfaces # TODO: in newer openvswitch implementations this should be changed to symmetric_l3l4+udp # to balance any kind of traffic cmd += ',multipath(symmetric_l4,1024,modulo_n,%s,0,NXM_NX_REG1[0..12])' % len(dest_intfs_mapping) # reuse the cookie as table entry as it will be unique cmd += ',resubmit(, %s)"' % cookie # actually add the flow logging.debug("Switch: %s, CMD: %s" % (src_sw, cmd)) net[src_sw].dpctl(main_cmd, cmd) # finally add all flow data to the internal data storage self.full_lb_data[(src_vnf_name, src_vnf_interface)] = data def add_floating_lb(self, datacenter, lb_data): """ This function will set up a loadbalancer at the given datacenter. This function returns the floating ip assigned to the loadbalancer as multiple ones are possible. :param datacenter: The datacenter entrypoint :type datacenter: ``str`` :param lb_data: A dictionary containing the destination data as well as custom path settings :type lb_data: ``dict`` :Example: lbdata = {"dst_vnf_interfaces": {"dc2_man_web0": "port-man-2", "dc3_man_web0": "port-man-4","dc4_man_web0": "port-man-6"}, "path": {"dc2_man_web0": {"port-man-2": [ "dc1.s1",\ "s1", "dc2.s1"]}}} """ net = self.net src_sw_inport_nr = 1 src_sw = self.floating_switch.name dest_intfs_mapping = lb_data.get('dst_vnf_interfaces', dict()) # a custom path can be specified as a list of switches custom_paths = lb_data.get('path', dict()) dest_vnf_outport_nrs = list() if datacenter not in self.net.dcs: raise Exception(u"Source datacenter can not be found.") # get all target interface outport numbers for vnf_name in dest_intfs_mapping: if vnf_name not in net.DCNetwork_graph: raise Exception(u"Target VNF %s is not known." % vnf_name) for connected_sw in net.DCNetwork_graph.neighbors(vnf_name): link_dict = net.DCNetwork_graph[vnf_name][connected_sw] for link in link_dict: if link_dict[link]['src_port_name'] == dest_intfs_mapping[vnf_name]: dest_vnf_outport_nrs.append(int(link_dict[link]['dst_port_nr'])) if len(dest_vnf_outport_nrs) == 0: raise Exception("There are no paths specified for the loadbalancer") src_ip = self.floating_intf.IP() src_mac = self.floating_intf.MAC() # set up paths for each destination vnf individually index = 0 cookie = self.get_cookie() main_cmd = "add-flow -OOpenFlow13" floating_ip = self.floating_network.get_new_ip_address("floating-ip").split("/")[0] for dst_vnf_name, dst_vnf_interface in dest_intfs_mapping.items(): path = None # use custom path if one is supplied # json does not support hashing on tuples so we use nested dicts if custom_paths is not None and dst_vnf_name in custom_paths: if dst_vnf_interface in custom_paths[dst_vnf_name]: path = custom_paths[dst_vnf_name][dst_vnf_interface] logging.debug("Taking custom path to %s: %s" % (dst_vnf_name, path)) else: if datacenter not in self.floating_links: self.floating_links[datacenter] = \ net.addLink(self.floating_switch, datacenter) path = \ self._get_path(self.floating_root.name, dst_vnf_name, self.floating_intf.name, dst_vnf_interface)[0] if isinstance(path, dict): self.delete_flow_by_cookie(cookie) raise Exception(u"Can not find a valid path. Are you specifying the right interfaces?.") intf = net[dst_vnf_name].nameToIntf[dst_vnf_interface] target_mac = str(intf.MAC()) target_ip = str(intf.IP()) dst_sw_outport_nr = dest_vnf_outport_nrs[index] current_hop = src_sw switch_inport_nr = src_sw_inport_nr vlan = net.vlans.pop() # iterate all switches on the path for i in range(0, len(path)): if i < len(path) - 1: next_hop = path[i + 1] else: # last switch reached next_hop = dst_vnf_name next_node = net.getNodeByName(next_hop) # sanity checks if next_hop == dst_vnf_name: switch_outport_nr = dst_sw_outport_nr logging.info("end node reached: {0}".format(dst_vnf_name)) elif not isinstance(next_node, OVSSwitch): logging.info("Next node: {0} is not a switch".format(next_hop)) return "Next node: {0} is not a switch".format(next_hop) else: # take first link between switches by default index_edge_out = 0 switch_outport_nr = net.DCNetwork_graph[current_hop][next_hop][index_edge_out]['src_port_nr'] # default filters, just overwritten on the first node and last node cmd = 'priority=1,in_port=%s,cookie=%s' % (switch_inport_nr, cookie) cmd_back = 'priority=1,in_port=%s,cookie=%s' % (switch_outport_nr, cookie) if i == 0: # first node cmd = 'in_port=%s' % src_sw_inport_nr cmd += ',cookie=%s' % cookie cmd += ',table=%s' % cookie cmd += ',ip' cmd += ',ip_dst=%s' % floating_ip cmd += ',reg1=%s' % index cmd += ',actions=' # set vlan id cmd += ',push_vlan:0x8100' masked_vlan = vlan | 0x1000 cmd += ',set_field:%s->vlan_vid' % masked_vlan cmd += ',set_field:%s->eth_dst' % target_mac cmd += ',set_field:%s->ip_dst' % target_ip cmd += ',output:%s' % switch_outport_nr # last switch for reverse route # remove any vlan tags cmd_back += ',dl_vlan=%s' % vlan cmd_back += ',actions=pop_vlan,output:%s' % switch_inport_nr self.setup_arp_reply_at(current_hop, src_sw_inport_nr, floating_ip, target_mac, cookie=cookie) elif next_hop == dst_vnf_name: # last switch # remove any vlan tags cmd += ',dl_vlan=%s' % vlan cmd += ',actions=pop_vlan,output:%s' % switch_outport_nr # set up arp replys at the port so the dst nodes know the src self.setup_arp_reply_at(current_hop, switch_outport_nr, src_ip, src_mac, cookie=cookie) # reverse route cmd_back = 'in_port=%s' % switch_outport_nr cmd_back += ',cookie=%s' % cookie cmd_back += ',ip' cmd_back += ',actions=' cmd_back += 'push_vlan:0x8100' masked_vlan = vlan | 0x1000 cmd_back += ',set_field:%s->vlan_vid' % masked_vlan cmd_back += ',set_field:%s->eth_src' % src_mac cmd_back += ',set_field:%s->ip_src' % floating_ip cmd_back += ',output:%s' % switch_inport_nr net.getNodeByName(dst_vnf_name).setHostRoute(src_ip, dst_vnf_interface) else: # middle node # if we have a circle in the path we need to specify this, as openflow will ignore the packet # if we just output it on the same port as it came in if switch_inport_nr == switch_outport_nr: cmd += ',dl_vlan=%s,actions=IN_PORT' % (vlan) cmd_back += ',dl_vlan=%s,actions=IN_PORT' % (vlan) else: cmd += ',dl_vlan=%s,actions=output:%s' % (vlan, switch_outport_nr) cmd_back += ',dl_vlan=%s,actions=output:%s' % (vlan, switch_inport_nr) # excecute the command on the target switch logging.debug(cmd) cmd = "\"%s\"" % cmd cmd_back = "\"%s\"" % cmd_back net[current_hop].dpctl(main_cmd, cmd) net[current_hop].dpctl(main_cmd, cmd_back) # set next hop for the next iteration step if isinstance(next_node, OVSSwitch): switch_inport_nr = net.DCNetwork_graph[current_hop][next_hop][0]['dst_port_nr'] current_hop = next_hop # advance to next destination index += 1 # set up the actual load balancing rule as a multipath on the very first switch cmd = '"in_port=%s' % src_sw_inport_nr cmd += ',cookie=%s' % (cookie) cmd += ',ip' cmd += ',actions=' # push 0x01 into the first register cmd += 'load:0x1->NXM_NX_REG0[]' # load balance modulo n over all dest interfaces # TODO: in newer openvswitch implementations this should be changed to symmetric_l3l4+udp # to balance any kind of traffic cmd += ',multipath(symmetric_l4,1024,modulo_n,%s,0,NXM_NX_REG1[0..12])' % len(dest_intfs_mapping) # reuse the cookie as table entry as it will be unique cmd += ',resubmit(, %s)"' % cookie # actually add the flow logging.debug("Switch: %s, CMD: %s" % (src_sw, cmd)) net[src_sw].dpctl(main_cmd, cmd) self.floating_cookies[cookie] = floating_ip return cookie, floating_ip def setup_arp_reply_at(self, switch, port_nr, target_ip, target_mac, cookie=None): """ Sets up a custom ARP reply at a switch. An ARP request coming in on the `port_nr` for `target_ip` will be answered with target IP/MAC. :param switch: The switch belonging to the interface :type switch: ``str`` :param port_nr: The port number at the switch that is connected to the interface :type port_nr: ``int`` :param target_ip: The IP for which to set up the ARP reply :type target_ip: ``str`` :param target_mac: The MAC address of the target interface :type target_mac: ``str`` :param cookie: cookie to identify the ARP request, if None a new one will be picked :type cookie: ``int`` or ``None`` :return: cookie :rtype: ``int`` """ if cookie is None: cookie = self.get_cookie() main_cmd = "add-flow -OOpenFlow13" # first set up ARP requests for the source node, so it will always 'find' a partner cmd = '"in_port=%s' % port_nr cmd += ',cookie=%s' % cookie cmd += ',arp' # only answer for target ip arp requests cmd += ',arp_tpa=%s' % target_ip cmd += ',actions=' # set message type to ARP reply cmd += 'load:0x2->NXM_OF_ARP_OP[]' # set src ip as dst ip cmd += ',move:NXM_OF_ETH_SRC[]->NXM_OF_ETH_DST[]' # set src mac cmd += ',set_field:%s->eth_src' % target_mac # set src as target cmd += ',move:NXM_NX_ARP_SHA[]->NXM_NX_ARP_THA[], move:NXM_OF_ARP_SPA[]->NXM_OF_ARP_TPA[]' # set target mac as hex cmd += ',load:0x%s->NXM_NX_ARP_SHA[]' % "".join(target_mac.split(':')) # set target ip as hex octets = target_ip.split('.') dst_ip_hex = '{:02X}{:02X}{:02X}{:02X}'.format(*map(int, octets)) cmd += ',load:0x%s->NXM_OF_ARP_SPA[]' % dst_ip_hex # output to incoming port remember the closing " cmd += ',IN_PORT"' self.net[switch].dpctl(main_cmd, cmd) logging.debug( "Set up ARP reply at %s port %s." % (switch, port_nr)) def delete_flow_by_cookie(self, cookie): """ Removes a flow identified by the cookie :param cookie: The cookie for the specified flow :type cookie: ``int`` :return: True if successful, else false :rtype: ``bool`` """ if not cookie: return False logging.debug("Deleting flow by cookie %d" % (cookie)) flows = list() # we have to call delete-group for each switch for node in self.net.switches: flow = dict() flow["dpid"] = int(node.dpid, 16) flow["cookie"] = cookie flow['cookie_mask'] = int('0xffffffffffffffff', 16) flows.append(flow) for flow in flows: logging.debug("Deleting flowentry with cookie %d" % ( flow["cookie"])) if self.net.controller == RemoteController: self.net.ryu_REST('stats/flowentry/delete', data=flow) self.cookies.remove(cookie) return True def delete_chain_by_intf(self, src_vnf_name, src_vnf_intf, dst_vnf_name, dst_vnf_intf): """ Removes a flow identified by the vnf_name/vnf_intf pairs :param src_vnf_name: The vnf name for the specified flow :type src_vnf_name: ``str`` :param src_vnf_intf: The interface name for the specified flow :type src_vnf_intf: ``str`` :param dst_vnf_name: The vnf name for the specified flow :type dst_vnf_name: ``str`` :param dst_vnf_intf: The interface name for the specified flow :type dst_vnf_intf: ``str`` :return: True if successful, else false :rtype: ``bool`` """ logging.debug("Deleting flow for vnf/intf pair %s %s" % (src_vnf_name, src_vnf_intf)) if not self.check_vnf_intf_pair(src_vnf_name, src_vnf_intf): return False if not self.check_vnf_intf_pair(dst_vnf_name, dst_vnf_intf): return False target_flow = (src_vnf_name, src_vnf_intf, dst_vnf_name, dst_vnf_intf) if not target_flow in self.chain_flow_cookies: return False success = self.delete_flow_by_cookie(self.chain_flow_cookies[target_flow]) if success: del self.chain_flow_cookies[target_flow] del self.full_chain_data[target_flow] return True return False def delete_loadbalancer(self, vnf_src_name, vnf_src_interface): ''' Removes a loadbalancer that is configured for the node and interface :param src_vnf_name: Name of the source VNF :param src_vnf_interface: Name of the destination VNF ''' flows = list() # we have to call delete-group for each switch delete_group = list() group_id = self.get_flow_group(vnf_src_name, vnf_src_interface) for node in self.net.switches: for cookie in self.lb_flow_cookies[(vnf_src_name, vnf_src_interface)]: flow = dict() flow["dpid"] = int(node.dpid, 16) flow["cookie"] = cookie flow['cookie_mask'] = int('0xffffffffffffffff', 16) flows.append(flow) group_del = dict() group_del["dpid"] = int(node.dpid, 16) group_del["group_id"] = group_id delete_group.append(group_del) for flow in flows: logging.debug("Deleting flowentry with cookie %d belonging to lb at %s:%s" % ( flow["cookie"], vnf_src_name, vnf_src_interface)) if self.net.controller == RemoteController: self.net.ryu_REST('stats/flowentry/delete', data=flow) logging.debug("Deleting group with id %s" % group_id) for switch_del_group in delete_group: if self.net.controller == RemoteController: self.net.ryu_REST("stats/groupentry/delete", data=switch_del_group) # unmap groupid from the interface target_pair = (vnf_src_name, vnf_src_interface) if target_pair in self.flow_groups: del self.flow_groups[target_pair] if target_pair in self.full_lb_data: del self.full_lb_data[target_pair] def delete_floating_lb(self, cookie): """ Delete a floating loadbalancer. Floating loadbalancers are different from normal ones as there are multiple ones on the same interface. :param cookie: The cookie of the loadbalancer :type cookie: ``int`` """ cookie = int(cookie) if cookie not in self.floating_cookies: raise Exception("Can not delete floating loadbalancer as the flowcookie is not known") self.delete_flow_by_cookie(cookie) floating_ip = self.floating_cookies[cookie] self.floating_network.withdraw_ip_address(floating_ip) def set_arp_entry(self, vnf_name, vnf_interface, ip, mac): """ Sets an arp entry on the specified VNF. This is done on the node directly and not by open vswitch! :param vnf_name: Name of the VNF :type vnf_name: ``str`` :param vnf_interface: Name of the interface :type vnf_interface: ``str`` :param ip: IP to reply to :type ip: ``str`` :param mac: Answer with this MAC :type mac: ``str`` """ node = self.net.getNodeByName(vnf_name) node.cmd("arp -i %s -s %s %s" % (vnf_interface, ip, mac))
def myNet(cname='controller', cargs='-v ptcp:'): "Create network from scratch using Open vSwitch." info("*** Creating nodes\n") controller = Node('c0', inNamespace=False) switch = Node('s0', inNamespace=False) switch1 = Node('s1', inNamespace=False) h0 = Node('h0') h1 = Node('h1') info("*** Creating links\n") linkopts0 = dict(bw=100, delay='1ms', loss=0) linkopts1 = dict(bw=100, delay='10ms', loss=0) link0 = TCLink(h0, switch, **linkopts0) #initially, the delay from switch to switch1 is 10ms link1 = TCLink(switch, switch1, **linkopts1) link2 = TCLink(h1, switch1, **linkopts0) #print link0.intf1, link0.intf2 link0.intf2.setMAC("0:0:0:0:0:1") link1.intf1.setMAC("0:0:0:0:0:2") link1.intf2.setMAC("0:1:0:0:0:1") link2.intf2.setMAC("0:1:0:0:0:2") info("*** Configuring hosts\n") h0.setIP('192.168.123.1/24') h1.setIP('192.168.123.2/24') h0.setMAC("a:a:a:a:a:a") h1.setMAC("8:8:8:8:8:8") info("*** Starting network using Open vSwitch\n") switch.cmd('ovs-vsctl del-br dp0') switch.cmd('ovs-vsctl add-br dp0') switch1.cmd('ovs-vsctl del-br dp1') switch1.cmd('ovs-vsctl add-br dp1') controller.cmd(cname + ' ' + cargs + '&') for intf in switch.intfs.values(): print intf print switch.cmd('ovs-vsctl add-port dp0 %s' % intf) for intf in switch1.intfs.values(): print intf print switch1.cmd('ovs-vsctl add-port dp1 %s' % intf) # Note: controller and switch are in root namespace, and we # can connect via loopback interface switch.cmd('ovs-vsctl set-controller dp0 tcp:127.0.0.1:6633') switch1.cmd('ovs-vsctl set-controller dp1 tcp:127.0.0.1:6633') info('*** Waiting for switch to connect to controller') while 'is_connected' not in quietRun('ovs-vsctl show'): sleep(1) info('.') info('\n') def cDelay1(): switch.cmdPrint('ethtool -K s0-eth1 gro off') switch.cmdPrint('tc qdisc del dev s0-eth1 root') switch.cmdPrint( 'tc qdisc add dev s0-eth1 root handle 10: netem delay 50ms') switch1.cmdPrint('ethtool -K s1-eth0 gro off') switch1.cmdPrint('tc qdisc del dev s1-eth0 root') switch1.cmdPrint( 'tc qdisc add dev s1-eth0 root handle 10: netem delay 50ms') def cDelay2(): switch.cmdPrint('ethtool -K s0-eth1 gro off') switch.cmdPrint('tc qdisc del dev s0-eth1 root') switch.cmdPrint( 'tc qdisc add dev s0-eth1 root handle 10: netem delay 200ms') switch1.cmdPrint('ethtool -K s1-eth0 gro off') switch1.cmdPrint('tc qdisc del dev s1-eth0 root') switch1.cmdPrint( 'tc qdisc add dev s1-eth0 root handle 10: netem delay 200ms') # 15 seconds later, the delay from switch to switch 1 will change to 50ms t1 = Timer(15, cDelay1) t1.start() # 30 seconds later, the delay from switch to switch 1 will change to 200ms t2 = Timer(30, cDelay2) t2.start() #info( "*** Running test\n" ) h0.cmdPrint('ping -i 1 -c 45 ' + h1.IP()) sleep(1) info("*** Stopping network\n") controller.cmd('kill %' + cname) switch.cmd('ovs-vsctl del-br dp0') switch.deleteIntfs() switch1.cmd('ovs-vsctl del-br dp1') switch1.deleteIntfs() info('\n')
h2 = Node( 'h2' ) net.hosts.append( h0 ) net.hosts.append( h1 ) net.hosts.append( h2 ) wifi = WIFISegment() wifi.addAp( h0 ) wifi.addSta( h1 ) wifi.addSta( h2 ) wifi.phyhelper.EnablePcap( "Ap-trace.pcap", h0.nsNode.GetDevice( 0 ), True, True ); info( '*** Configuring hosts\n' ) h0.setIP( '192.168.123.1/24' ) h1.setIP( '192.168.123.2/24') h2.setIP( '192.168.123.3/24') mininet.ns3.start() info( '*** Network state:\n' ) for node in h0, h1, h2: info( str( node ) + '\n' ) info( '*** Running test\n' ) h0.cmdPrint( 'ping -c1 ' + h1.IP() ) h0.cmdPrint( 'ping -c1 ' + h2.IP() ) CLI(net)
def myNet(cname='controller', cargs='-v ptcp:'): "Create network from scratch using Open vSwitch." info( "*** Creating nodes\n" ) controller = Node( 'c0', inNamespace=False ) s0 = Node( 's0', inNamespace=False ) s1 = Node( 's1', inNamespace=False ) h0 = Node( 'h0' ) h1 = Node( 'h1' ) h2 = Node( 'h2' ) info( "*** Creating links..." ) linkopts0=dict(bw=10, delay='1ms', loss=0) info( '\nLink h0-s0 | ' ) TCLink( h0, s0, **linkopts0) info( '\nLink h1-s0 | ' ) TCLink( h1, s0, **linkopts0) info( '\nLink s0-s1 | ' ) TCLink( s0, s1, **linkopts0) info( '\nLink s1-h2 | ' ) TCLink( s1, h2, **linkopts0) info( '\n' ) info( "*** Configuring hosts...\n" ) h0.setIP( '192.168.1.1/24' ) h1.setIP( '192.168.1.2/24' ) h2.setIP( '192.168.1.3/24' ) info( "*** Starting network using Open vSwitch...\n" ) s0.cmd( 'ovs-vsctl del-br s0' ) s0.cmd( 'ovs-vsctl add-br s0' ) s1.cmd( 'ovs-vsctl del-br s1' ) s1.cmd( 'ovs-vsctl add-br s1' ) controller.cmd( cname + ' ' + cargs + '&' ) for intf in s0.intfs.values(): print intf print s0.cmd( 'ovs-vsctl add-port s0 %s' % intf ) for intf in s1.intfs.values(): print intf print s1.cmd( 'ovs-vsctl add-port s1 %s' % intf ) # Note: controller and switch are in root namespace, and we # can connect via loopback interface info( '*** Connect to controller with tcp port...' ) s0.cmd( 'ovs-vsctl set-controller s0 tcp:127.0.0.1:6633' ) s1.cmd( 'ovs-vsctl set-controller s0 tcp:127.0.0.1:6633' ) info( '\n' ) info( '*** Waiting for switch to connect to controller..' ) while 'is_connected' not in quietRun( 'ovs-vsctl show' ): sleep( 1 ) info( '.' ) info( 'connected!\n' ) #print s0.cmd('ovs-ofctl show dp0') info( "*** Running test...\n" ) info( '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n' ) h0.cmdPrint( 'ping -c 2 ' + h2.IP() ) info( '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n' ) h1.cmdPrint( 'ping -c 2 ' + h2.IP() ) info( '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n' ) info( '*** Starting iperf Server...\n' ) h2.cmdPrint('iperf -s -i 1 > bandwidth_result &') info( '*** Original link bandwidth testing...\n' ) print "iperf: h0--s0--s1--h2" h0.cmdPrint('iperf -c 192.168.1.3 -t 15') info( '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n' ) print "iperf: h1--s0--s1--h2" h1.cmdPrint('iperf -c 192.168.1.3 -t 15') info( '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n' ) print "!!! Limiting the bandwidth for flow entry [h0] -> [h2]" s0.cmdPrint('ethtool -K s0-eth2 gro off') s0.cmdPrint('tc qdisc del dev s0-eth2 root') s0.cmdPrint('tc qdisc add dev s0-eth2 root handle 1: cbq avpkt 1000 bandwidth 10Mbit') s0.cmdPrint('tc class add dev s0-eth2 parent 1: classid 1:1 cbq rate 512kbit allot 1500 prio 5 bounded isolated') s0.cmdPrint('tc filter add dev s0-eth2 parent 1: protocol ip prio 16 u32 match ip src 192.168.1.1 flowid 1:1') s0.cmdPrint('tc qdisc add dev s0-eth2 parent 1:1 sfq perturb 10') info( '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' ) info( '\n*** Limited link bandwidth testing...\n' ) print "iperf: h0--s0--s1--h2" h0.cmdPrint('iperf -c 192.168.1.3 -t 15') info( '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n' ) print "iperf: h1--s0--s1--h2" h1.cmdPrint('iperf -c 192.168.1.3 -t 15') info( '*** Done...\n' ) info( "*** Stopping network...\n" ) controller.cmd( 'kill %' + cname ) s0.cmd( 'ovs-vsctl del-br s0' ) s0.deleteIntfs() s1.cmd( 'ovs-vsctl del-br s1' ) s1.deleteIntfs() info( '\n' )
def scratchNet(cname='controller', cargs='-v ptcp:'): "Create network from scratch using Open vSwitch." info("*** Creating nodes\n") controller = Node('c0', inNamespace=False) switch = Node('s0', inNamespace=False) switch1 = Node('s1', inNamespace=False) h0 = Node('h0') h1 = Node('h1') h2 = Node('h2') h3 = Node('h3') h4 = Node('h4') h5 = Node('h5') h6 = Node('h6') h7 = Node('h7') info("*** Creating links\n") Link(h0, switch) Link(h1, switch) Link(h2, switch) Link(h3, switch) Link(h4, switch1) Link(h5, switch1) Link(h6, switch1) Link(h7, switch1) info("*** Configuring hosts\n") h0.setIP('192.168.123.1/24') h1.setIP('192.168.123.2/24') h2.setIP('192.168.123.3/24') h3.setIP('192.168.123.4/24') h4.setIP('192.168.123.5/24') h5.setIP('192.168.123.6/24') h6.setIP('192.168.123.7/24') h7.setIP('192.168.123.8/24') info(str(h0) + '\n') info(str(h1) + '\n') info(str(h2) + '\n') info(str(h3) + '\n') info(str(h4) + '\n') info(str(h5) + '\n') info(str(h6) + '\n') info(str(h7) + '\n') info("*** Starting network using Open vSwitch\n") controller.cmd(cname + ' ' + cargs + '&') switch.cmd('ovs-vsctl del-br dp0') switch.cmd('ovs-vsctl add-br dp0') switch1.cmd('ovs-vsctl del-br dp0') switch1.cmd('ovs-vsctl add-br dp0') net.addLink(switch, switch1, delay='5ms', loss=20) for intf in switch.intfs.values(): print switch.cmd('ovs-vsctl add-port dp0 %s' % intf) for intf in switch1.intfs.values(): print switch1.cmd('ovs-vsctl add-port dp0 %s' % intf) # Note: controller and switch are in root namespace, and we # can connect via loopback interface switch.cmd('ovs-vsctl set-controller dp0 tcp:127.0.0.1:6633') switch1.cmd('ovs-vsctl set-controller dp0 tcp:127.0.0.1:6633') linkopts = dict(bw=10, delay='5ms', loss=20, max_queue_size=1000, use_htb=True) info('*** Waiting for switch to connect to controller') while 'is_connected' not in quietRun('ovs-vsctl show'): sleep(1) info('.') info('\n') info("*** Running test\n") h0.sendCmd( ' /home/amellalghamdi/Desktop/cse223bFinalProject/lib/kv_server 1 239.0.2.1 9000 1 2 3 4 >&1 > `ifconfig | grep eth | cut -f1 -d`.out1`' ) h1.cmdPrint( ' /home/amellalghamdi/Desktop/cse223bFinalProject/lib/kv_server 2 239.0.2.1 9000 1 2 3 4 >&1 > `ifconfig | grep eth | cut -f1 -d`.out2`' ) h2.cmdPrint( '/home/amellalghamdi/Desktop/cse223bFinalProject/lib/kv_server 3 239.0.2.1 9000 1 2 3 4 >&1 > `ifconfig | grep eth | cut -f1 -d`.out3' ) h3.cmdPrint( ' /home/amellalghamdi/Desktop/cse223bFinalProject/lib/kv_server 4 239.0.2.1 9000 1 2 3 4 >&1 > `ifconfig | grep eth | cut -f1 -d`.out4' ) info("*** Stopping network\n") #controller.cmd( 'kill %' + cname ) #switch.cmd( 'ovs-vsctl del-br dp0' ) #switch.deleteIntfs() #switch1.cmd( 'ovs-vsctl del-br dp0' ) #switch1.deleteIntfs() info('\n')
def scratchNet( cname='controller', cargs='-v ptcp:' ): "Create network from scratch using Open vSwitch." info( "*** Creating nodes\n" ) controller = Node( 'c0', inNamespace=False ) s1 = Node( 's0', inNamespace=False ) s2 = Node( 's1', inNamespace=False ) s3 = Node( 's2', inNamespace=False ) s4 = Node( 's3', inNamespace=False ) s5 = Node( 's4', inNamespace=False ) s6 = Node( 's5', inNamespace=False ) s7 = Node( 's6', inNamespace=False ) s8 = Node( 's7', inNamespace=False ) s9 = Node( 's8', inNamespace=False ) s10 = Node( 's9', inNamespace=False ) s11 = Node( 's10', inNamespace=False ) s12 = Node( 's11', inNamespace=False ) s13 = Node( 's12', inNamespace=False ) s14 = Node( 's13', inNamespace=False ) s15 = Node( 's14', inNamespace=False ) s16 = Node( 's15', inNamespace=False ) h1 = Node( 'h1' ) h2 = Node( 'h2' ) h3 = Node( 'h3' ) h4 = Node( 'h4' ) h5 = Node( 'h5' ) h6 = Node( 'h6' ) h7 = Node( 'h7' ) h8 = Node( 'h8' ) h9 = Node( 'h9' ) h10 = Node( 'h10' ) h11 = Node( 'h11' ) h12 = Node( 'h12' ) h13 = Node( 'h13' ) h14 = Node( 'h14' ) h15 = Node( 'h15' ) h16 = Node( 'h16' ) info( "*** Creating Host-Switch links\n" ) Link( h1, s1 ) Link( h2, s2 ) Link( h3, s3 ) Link( h4, s4 ) Link( h5, s5 ) Link( h6, s6 ) Link( h7, s7 ) Link( h8, s8 ) Link( h9, s9 ) Link( h10, s10 ) Link( h11, s11 ) Link( h12, s12 ) Link( h13, s13 ) Link( h14, s14 ) Link( h15, s15 ) Link( h16, s16 ) info( "*** Creating Switch-Switch links\n" ) Link( s1, s2 ) Link( s2, s3 ) Link( s3, s4 ) Link( s4, s5 ) Link( s5, s6 ) Link( s6, s7 ) Link( s7, s8 ) Link( s8, s9 ) Link( s9, s10 ) Link( s10, s11 ) Link( s11, s12 ) Link( s12, s13 ) Link( s13, s14 ) Link( s14, s15 ) Link( s15, s16 ) info( "*** Configuring hosts\n" ) h1.setIP( '192.168.123.1/24' ) h2.setIP( '192.168.123.2/24' ) h3.setIP( '192.168.123.3/24' ) h4.setIP( '192.168.123.4/24' ) h5.setIP( '192.168.123.5/24' ) h6.setIP( '192.168.123.6/24' ) h7.setIP( '192.168.123.7/24' ) h8.setIP( '192.168.123.8/24' ) h9.setIP( '192.168.123.9/24' ) h10.setIP( '192.168.123.10/24' ) h11.setIP( '192.168.123.11/24' ) h12.setIP( '192.168.123.12/24' ) h13.setIP( '192.168.123.13/24' ) h14.setIP( '192.168.123.14/24' ) h15.setIP( '192.168.123.15/24' ) h16.setIP( '192.168.123.16/24' ) info( str( h1 ) + '\n' ) info( str( h2 ) + '\n' ) info( str( h3 ) + '\n' ) info( str( h4 ) + '\n' ) info( str( h5 ) + '\n' ) info( str( h6 ) + '\n' ) info( str( h7 ) + '\n' ) info( str( h8 ) + '\n' ) info( str( h9 ) + '\n' ) info( str( h10 ) + '\n' ) info( str( h11 ) + '\n' ) info( str( h12 ) + '\n' ) info( str( h13 ) + '\n' ) info( str( h14 ) + '\n' ) info( str( h15 ) + '\n' ) info( str( h16 ) + '\n' ) info( "*** Running test\n" ) h1.cmdPrint( 'iperf -s &') h16.cmdPrint( 'time iperf -c ' + h1.IP() + ' -t2 -n 100M &') h16.cmdPrint( 'ping -c100 ' + h1.IP() + ' &') info( "*** Stopping network\n" ) controller.cmd( 'kill %' + cname ) info( '\n' )
def myNet(): "Defines a custom topology on mininet." print "*** Starting MyNet ***" cParams = ControllerParams( '10.0.3.0', 24 ) net = Mininet( controller=RemoteController, switch=OVSKernelSwitch, cparams=cParams ) print "** Adding controller" c = net.addController( 'c0' ) print "** Adding switches" s1 = net.addSwitch( 's1' ) s2 = net.addSwitch( 's2' ) s3 = net.addSwitch( 's3' ) s4 = net.addSwitch( 's4' ) s5 = net.addSwitch( 's5' ) s6 = net.addSwitch( 's6' ) s7 = net.addSwitch( 's7' ) s8 = net.addSwitch( 's8' ) s9 = net.addSwitch( 's9' ) s10 = net.addSwitch( 's10' ) print "** Adding hosts" h1 = net.addHost( 'h1', ip='10.0.3.1' ) h2 = net.addHost( 'h2', ip='10.0.3.2' ) h3 = net.addHost( 'h3', ip='10.0.3.3' ) h4 = net.addHost( 'h4', ip='10.0.3.4' ) h5 = net.addHost( 'h5', ip='10.0.3.5' ) h6 = net.addHost( 'h6', ip='10.0.3.6' ) h7 = net.addHost( 'h7', ip='10.0.3.7' ) h8 = net.addHost( 'h8', ip='10.0.3.8' ) h9 = net.addHost( 'h9', ip='10.0.3.9' ) h10 = net.addHost( 'h10', ip='10.0.3.10' ) h11 = net.addHost( 'h11', ip='10.0.3.11' ) h12 = net.addHost( 'h12', ip='10.0.3.12' ) h13 = net.addHost( 'h13', ip='10.0.3.13' ) h14 = net.addHost( 'h14', ip='10.0.3.14' ) h15 = net.addHost( 'h15', ip='10.0.3.15' ) h16 = net.addHost( 'h16', ip='10.0.3.16' ) h17 = net.addHost( 'h17', ip='10.0.3.17' ) h18 = net.addHost( 'h18', ip='10.0.3.18' ) h19 = net.addHost( 'h19', ip='10.0.3.19' ) h20 = net.addHost( 'h20', ip='10.0.3.20' ) print "** Linking switches and hosts" # S1 s1.linkTo( s2 ) s1.linkTo( h1 ) s1.linkTo( h2 ) s1.linkTo( h3 ) # S2 s2.linkTo( s3 ) s2.linkTo( s4 ) s2.linkTo( s5 ) # S3 s3.linkTo( s6 ) s3.linkTo( h4 ) s3.linkTo( h5 ) # S4 s4.linkTo( s8 ) s4.linkTo( h6 ) s4.linkTo( h7 ) s4.linkTo( h8 ) # S5 s5.linkTo( s9 ) s5.linkTo( s10 ) s5.linkTo( h9 ) s5.linkTo( h10 ) # S6 s6.linkTo( s7 ) s6.linkTo( h11 ) s6.linkTo( h12 ) s6.linkTo( h13 ) # S7 s7.linkTo( h14 ) s7.linkTo( h15 ) s7.linkTo( h16 ) # S8 s8.linkTo( h17 ) s8.linkTo( h18 ) # S9 s9.linkTo( h19 ) # S10 s10.linkTo( h20 ) print "** Creating extra node to enable access to others" # Create a node in root namespace and link to switch 0 root = Node( 'root', inNamespace=False ) root.linkTo( s1 ) root.setMAC( root.defaultIntf(), "00:00:00:11:00:64" ) root.setIP( root.defaultIntf(), "10.0.3.100", 24 ) # Configure everything s1.setMAC ( 's1-eth1', '00:00:00:10:01:01' ) s1.setMAC ( 's1-eth2', '00:00:00:10:01:02' ) s1.setMAC ( 's1-eth3', '00:00:00:10:01:03' ) s1.setMAC ( 's1-eth4', '00:00:00:10:01:04' ) s1.setMAC ( 's1-eth5', '00:00:00:10:01:05' ) # Extra for the root s2.setMAC ( 's2-eth1', '00:00:00:10:02:01' ) s2.setMAC ( 's2-eth2', '00:00:00:10:02:02' ) s2.setMAC ( 's2-eth3', '00:00:00:10:02:03' ) s2.setMAC ( 's2-eth4', '00:00:00:10:02:04' ) s3.setMAC ( 's3-eth1', '00:00:00:10:03:01' ) s3.setMAC ( 's3-eth2', '00:00:00:10:03:02' ) s3.setMAC ( 's3-eth3', '00:00:00:10:03:03' ) s3.setMAC ( 's3-eth4', '00:00:00:10:03:04' ) s4.setMAC ( 's4-eth1', '00:00:00:10:04:01' ) s4.setMAC ( 's4-eth2', '00:00:00:10:04:02' ) s4.setMAC ( 's4-eth3', '00:00:00:10:04:03' ) s4.setMAC ( 's4-eth4', '00:00:00:10:04:04' ) s4.setMAC ( 's4-eth5', '00:00:00:10:04:05' ) s5.setMAC ( 's5-eth1', '00:00:00:10:05:01' ) s5.setMAC ( 's5-eth2', '00:00:00:10:05:02' ) s5.setMAC ( 's5-eth3', '00:00:00:10:05:03' ) s5.setMAC ( 's5-eth4', '00:00:00:10:05:04' ) s5.setMAC ( 's5-eth5', '00:00:00:10:05:05' ) s6.setMAC ( 's6-eth1', '00:00:00:10:06:01' ) s6.setMAC ( 's6-eth2', '00:00:00:10:06:02' ) s6.setMAC ( 's6-eth3', '00:00:00:10:06:03' ) s6.setMAC ( 's6-eth4', '00:00:00:10:06:04' ) s6.setMAC ( 's6-eth5', '00:00:00:10:06:05' ) s7.setMAC ( 's7-eth1', '00:00:00:10:07:01' ) s7.setMAC ( 's7-eth2', '00:00:00:10:07:02' ) s7.setMAC ( 's7-eth3', '00:00:00:10:07:03' ) s7.setMAC ( 's7-eth4', '00:00:00:10:07:04' ) s8.setMAC ( 's8-eth1', '00:00:00:10:08:01' ) s8.setMAC ( 's8-eth2', '00:00:00:10:08:02' ) s8.setMAC ( 's8-eth3', '00:00:00:10:08:03' ) s9.setMAC ( 's9-eth1', '00:00:00:10:09:01' ) s9.setMAC ( 's9-eth2', '00:00:00:10:09:02' ) s10.setMAC ( 's10-eth1', '00:00:00:10:10:01' ) s10.setMAC ( 's10-eth2', '00:00:00:10:10:02' ) s1.setIP ( s1.defaultIntf(), '10.0.3.101', 24 ) s2.setIP ( s2.defaultIntf(), '10.0.3.102', 24 ) s3.setIP ( s3.defaultIntf(), '10.0.3.103', 24 ) s4.setIP ( s4.defaultIntf(), '10.0.3.104', 24 ) s5.setIP ( s5.defaultIntf(), '10.0.3.105', 24 ) s6.setIP ( s6.defaultIntf(), '10.0.3.106', 24 ) s7.setIP ( s7.defaultIntf(), '10.0.3.107', 24 ) s8.setIP ( s8.defaultIntf(), '10.0.3.108', 24 ) s9.setIP ( s9.defaultIntf(), '10.0.3.109', 24 ) s10.setIP ( s10.defaultIntf(), '10.0.3.110', 24 ) h1.setMAC( h1.defaultIntf(), "00:00:00:11:00:01" ) h2.setMAC( h2.defaultIntf(), "00:00:00:11:00:02" ) h3.setMAC( h3.defaultIntf(), "00:00:00:11:00:03" ) h4.setMAC( h4.defaultIntf(), "00:00:00:11:00:04" ) h5.setMAC( h5.defaultIntf(), "00:00:00:11:00:05" ) h6.setMAC( h6.defaultIntf(), "00:00:00:11:00:06" ) h7.setMAC( h7.defaultIntf(), "00:00:00:11:00:07" ) h8.setMAC( h8.defaultIntf(), "00:00:00:11:00:08" ) h9.setMAC( h9.defaultIntf(), "00:00:00:11:00:09" ) h10.setMAC( h10.defaultIntf(), "00:00:00:11:00:10" ) h11.setMAC( h11.defaultIntf(), "00:00:00:11:00:11" ) h12.setMAC( h12.defaultIntf(), "00:00:00:11:00:12" ) h13.setMAC( h13.defaultIntf(), "00:00:00:11:00:13" ) h14.setMAC( h14.defaultIntf(), "00:00:00:11:00:14" ) h15.setMAC( h15.defaultIntf(), "00:00:00:11:00:15" ) h16.setMAC( h16.defaultIntf(), "00:00:00:11:00:16" ) h17.setMAC( h17.defaultIntf(), "00:00:00:11:00:17" ) h18.setMAC( h18.defaultIntf(), "00:00:00:11:00:18" ) h19.setMAC( h19.defaultIntf(), "00:00:00:11:00:19" ) h20.setMAC( h20.defaultIntf(), "00:00:00:11:00:20" ) print "** Firing up the network" net.build() c.start() for s in net.switches: s.start( [ c ] ) print "** Starting SSH Server in every host" sshpids = {} for h in net.hosts: h.cmd( '/usr/sbin/sshd -D &' ) time.sleep(0.5) # Whait for the daemon to come up so we can see its pid (this is not very safe) output = h.cmd( 'cat /var/run/sshd.pid' ) sshpids[h.name] = output.rstrip() print "** Starting Libvirt in every host" for h in net.hosts: ip = h.IP() h.cmd( 'ip addr flush ' + h.defaultIntf() ) if not os.path.exists( '/usr/local/etc/openvswitch/' + h.name + '-conf.db' ): h.cmd( 'ovsdb-tool create /usr/local/etc/openvswitch/' + h.name + '-conf.db /home/jwickboldt/openvswitch-1.10.0/vswitchd/vswitch.ovsschema' ) h.cmd( 'ovsdb-server /usr/local/etc/openvswitch/' + h.name + '-conf.db --remote=punix:/usr/local/var/run/openvswitch/' + h.name + '-db.sock --pidfile=/usr/local/var/run/openvswitch/' + h.name + '-ovsdb-server.pid --detach' ) h.cmd( 'ovs-vsctl --db=unix:/usr/local/var/run/openvswitch/' + h.name + '-db.sock --no-wait init' ) h.cmd( 'ovs-vswitchd unix:/usr/local/var/run/openvswitch/' + h.name + '-db.sock --pidfile=/usr/local/var/run/openvswitch/' + h.name + '-ovs-vswitchd.pid --detach' ) h.cmd( 'ovs-vsctl --db=unix:/usr/local/var/run/openvswitch/' + h.name + '-db.sock add-br virbr1' ) h.cmd( 'ovs-vsctl --db=unix:/usr/local/var/run/openvswitch/' + h.name + '-db.sock add-port virbr1 ' + h.defaultIntf() ) h.cmd( 'ovs-vsctl --db=unix:/usr/local/var/run/openvswitch/' + h.name + '-db.sock set-controller virbr1 tcp:10.0.3.100:6633' ) h.cmd( 'ip link set dev virbr1 up' ) h.setIP( 'virbr1', ip, 24 ) # Default route through root-eth0 h.cmd ( 'route add default gw 10.0.3.100' ) h.cmd ( 'libvirtd-' + h.name + ' -d -l' ) #print "** Testing network" #net.pingAll() print "** Running CLI" CLI( net ) print "** Killing daemons" for h in net.hosts: h.cmd( 'kill `pidof libvirtd-' + h.name + '`' ) h.cmd( 'ovs-vsctl --db=unix:/usr/local/var/run/openvswitch/' + h.name + '-db.sock del-br virbr1' ) h.cmd( 'kill $(cat /usr/local/var/run/openvswitch/' + h.name + '-ovsdb-server.pid)' ) h.cmd( 'kill $(cat /usr/local/var/run/openvswitch/' + h.name + '-ovs-vswitchd.pid)' ) if len( sshpids[h.name] ) < 7: h.cmd( 'kill ' + sshpids[h.name] ) print "** Stopping network" net.stop()
def myNet(): "Defines a custom topology on mininet." print "*** Starting MyNet ***" cParams = ControllerParams( '10.0.3.0', 24 ) net = Mininet( controller=RemoteController, switch=OVSKernelSwitch, cparams=cParams ) print "** Adding controller" c = net.addController( 'c0' ) print "** Adding switches" s1 = net.addSwitch( 's1' ) s2 = net.addSwitch( 's2' ) s3 = net.addSwitch( 's3' ) s4 = net.addSwitch( 's4' ) print "** Adding hosts" h5 = net.addHost( 'h5', ip='10.0.3.5' ) h6 = net.addHost( 'h6', ip='10.0.3.6' ) h7 = net.addHost( 'h7', ip='10.0.3.7' ) h8 = net.addHost( 'h8', ip='10.0.3.8' ) h9 = net.addHost( 'h9', ip='10.0.3.9' ) print "** Linking switches together" s1.linkTo( s2 ) s2.linkTo( s3 ) s2.linkTo( s4 ) print "** Linking hosts to switches" h5.linkTo( s1 ) h6.linkTo( s3 ) h7.linkTo( s3 ) h8.linkTo( s4 ) h9.linkTo( s4 ) #print "** Setting up IP addresses" #h5.setIP( h5.defaultIntf(), '10.0.3.5', 24) #extraPort1 = s1.newPort() #extraPortName1 = s1.intfName( extraPort1 ) #print "** Adding extra port to s1 - " + extraPortName1 #s1.addIntf( extraPortName1, extraPort1 ) #print "** Linking xeth0 to s1 port " + extraPortName1 #makeIntfPair( "xeth0", extraPortName1 ) #extraPort2 = s4.newPort() #extraPortName2 = s4.intfName( extraPort2 ) #print "** Adding extra port to s4 - " + extraPortName2 #s4.addIntf( extraPortName2, extraPort2 ) #print "** Linking xeth1 to s4 port " + extraPortName2 #makeIntfPair( "xeth1", extraPortName2 ) print "** Creating extra node to enable access to others" # Create a node in root namespace and link to switch 0 root = Node( 'root', inNamespace=False ) root.linkTo( s1 ) root.setMAC( root.defaultIntf(), "00:00:00:10:00:64" ) root.setIP( root.defaultIntf(), "10.0.3.100", 24 ) #Configure everything s1.setMAC ( 's1-eth1', '00:00:00:10:01:01' ) s1.setMAC ( 's1-eth2', '00:00:00:10:01:02' ) s1.setMAC ( 's1-eth3', '00:00:00:10:01:03' ) s2.setMAC ( 's2-eth1', '00:00:00:10:02:01' ) s2.setMAC ( 's2-eth2', '00:00:00:10:02:02' ) s2.setMAC ( 's2-eth3', '00:00:00:10:02:03' ) s3.setMAC ( 's3-eth1', '00:00:00:10:03:01' ) s3.setMAC ( 's3-eth2', '00:00:00:10:03:02' ) s3.setMAC ( 's3-eth3', '00:00:00:10:03:03' ) s4.setMAC ( 's4-eth1', '00:00:00:10:04:01' ) s4.setMAC ( 's4-eth2', '00:00:00:10:04:02' ) s4.setMAC ( 's4-eth3', '00:00:00:10:04:03' ) s1.setIP ( s1.defaultIntf(), '10.0.3.1', 24 ) s2.setIP ( s2.defaultIntf(), '10.0.3.2', 24 ) s3.setIP ( s3.defaultIntf(), '10.0.3.3', 24 ) s4.setIP ( s4.defaultIntf(), '10.0.3.4', 24 ) h5.setMAC( h5.defaultIntf(), "00:00:00:10:00:05" ) h6.setMAC( h6.defaultIntf(), "00:00:00:10:00:06" ) h7.setMAC( h7.defaultIntf(), "00:00:00:10:00:07" ) h8.setMAC( h8.defaultIntf(), "00:00:00:10:00:08" ) h9.setMAC( h9.defaultIntf(), "00:00:00:10:00:09" ) print "** Firing up the network" net.build() # Try to add eth1 into s1 #print s1.cmd( 'ovs-dpctl add-if dp0 eth1' ) c.start() s1.start( [ c ] ) s2.start( [ c ] ) s3.start( [ c ] ) s4.start( [ c ] ) print "** Starting SSH Server in every host" sshpids = {} for h in net.hosts: h.cmd( '/usr/sbin/sshd -D &' ) time.sleep(2) # Whait for the daemon to come up so we can see its pid (this is not very safe) output = h.cmd( 'cat /var/run/sshd.pid' ) sshpids[h.name] = output.rstrip() print "** Starting Libvirt in every host" for h in net.hosts: ip = h.IP() h.cmd( 'ip addr flush ' + h.defaultIntf() ) h.cmd( 'brctl addbr virbr1' ) h.cmd( 'brctl addif virbr1 ' + h.defaultIntf() ) h.cmd( 'ip link set dev virbr1 up' ) h.setIP( 'virbr1', ip, 24 ) h.cmd( '/home/juliano/' + h.name + '/sbin/libvirtd -d -l -p /home/juliano/' + h.name + '/var/run/libvirtd.pid -f /home/juliano/' + h.name + '/etc/libvirt/libvirtd.conf' ) print "** Testing network" # net.pingAll() print "** Running CLI" CLI( net ) print "** Killing daemons" for h in net.hosts: h.cmd( 'kill `cat /home/juliano/' + h.name + '/var/run/libvirtd.pid`' ) if len( sshpids[h.name] ) < 7: h.cmd( 'kill ' + sshpids[h.name] ) print "** Stopping network" net.stop()
net = Mininet(topo=topo) s1 = net['s1'] plc2 = net['plc2'] plc3 = net['plc3'] s2, rtu2a, scada = net.get('s2', 'rtu2a', 'scada') rtu2b, attacker2 = net.get('rtu2b', 'attacker2') s3 = net.get('s3') # NOTE: root-eth0 interface on the host root = Node('root', inNamespace=False) intf = net.addLink(root, s3).intf1 print('DEBUG root intf: {}'.format(intf)) root.setIP('10.0.0.30', intf=intf) # NOTE: all packet from root to the 10.0.0.0 network root.cmd('route add -net ' + '10.0.0.0' + ' dev ' + str(intf)) net.start() # NOTE: use for debugging #s1.cmd('tcpdump -i s1-eth1 -w /tmp/s1-eth1.pcap &') #s1.cmd('tcpdump -i s1-eth2 -w /tmp/s1-eth2.pcap &') SLEEP = 0.5 # NOTE: swat challenge 1 and 2 plc3.cmd(sys.executable + ' plc3.py &') sleep(SLEEP)
def myNet(): "Create network from scratch using Open vSwitch." info( "*** Creating nodes\n" ) switch0 = Node( 's0', inNamespace=False ) switch1 = Node( 's1', inNamespace=False ) switch2 = Node( 's2', inNamespace=False ) switch3 = Node( 's3', inNamespace=False ) switch4 = Node( 's4', inNamespace=False ) h0 = Node( 'h0' ) h1 = Node( 'h1' ) info( "*** Creating links\n" ) linkopts0=dict(bw=100, delay='1ms', loss=0) linkopts1=dict(bw=1, delay='100ms', loss=0) linkopts2=dict(bw=10, delay='50ms', loss=0) linkopts3=dict(bw=100, delay='1ms', loss=0) link1=TCLink( h0, switch0, **linkopts0) TCLink( switch0, switch1, **linkopts0) TCLink( switch0, switch2, **linkopts0) TCLink( switch0, switch3, **linkopts0) TCLink( switch1, switch4,**linkopts1) TCLink( switch2, switch4,**linkopts2) TCLink( switch3, switch4,**linkopts3) link2=TCLink( h1, switch4, **linkopts0) info( "*** Configuring hosts\n" ) h0.setIP( '192.168.123.1/24' ) h1.setIP( '192.168.123.2/24' ) info( str( h0 ) + '\n' ) info( str( h1 ) + '\n' ) info( "*** Starting network using Open vSwitch\n" ) switch0.cmd( 'ovs-vsctl del-br dp0' ) switch0.cmd( 'ovs-vsctl add-br dp0' ) switch1.cmd( 'ovs-vsctl del-br dp1' ) switch1.cmd( 'ovs-vsctl add-br dp1' ) switch2.cmd( 'ovs-vsctl del-br dp2' ) switch2.cmd( 'ovs-vsctl add-br dp2' ) switch3.cmd( 'ovs-vsctl del-br dp3' ) switch3.cmd( 'ovs-vsctl add-br dp3' ) switch4.cmd( 'ovs-vsctl del-br dp4' ) switch4.cmd( 'ovs-vsctl add-br dp4' ) for intf in switch0.intfs.values(): print intf print switch0.cmd( 'ovs-vsctl add-port dp0 %s' % intf ) for intf in switch1.intfs.values(): print intf print switch1.cmd( 'ovs-vsctl add-port dp1 %s' % intf ) for intf in switch2.intfs.values(): print intf print switch2.cmd( 'ovs-vsctl add-port dp2 %s' % intf ) for intf in switch3.intfs.values(): print intf print switch3.cmd( 'ovs-vsctl add-port dp3 %s' % intf ) for intf in switch4.intfs.values(): print intf print switch4.cmd( 'ovs-vsctl add-port dp4 %s' % intf ) print switch1.cmd(r'ovs-ofctl add-flow dp1 idle_timeout=0,priority=1,in_port=1,actions=flood' ) print switch1.cmd(r'ovs-ofctl add-flow dp1 idle_timeout=0,priority=1,in_port=1,actions=output:2' ) print switch1.cmd(r'ovs-ofctl add-flow dp1 idle_timeout=0,priority=1,in_port=2,actions=output:1' ) print switch2.cmd(r'ovs-ofctl add-flow dp2 idle_timeout=0,priority=1,in_port=1,actions=output:2' ) print switch2.cmd(r'ovs-ofctl add-flow dp2 idle_timeout=0,priority=1,in_port=2,actions=output:1' ) print switch3.cmd(r'ovs-ofctl add-flow dp3 idle_timeout=0,priority=1,in_port=1,actions=output:2' ) print switch3.cmd(r'ovs-ofctl add-flow dp3 idle_timeout=0,priority=1,in_port=2,actions=output:1' ) print switch4.cmd(r'ovs-ofctl add-flow dp4 idle_timeout=0,priority=1,in_port=1,actions=output:4' ) print switch4.cmd(r'ovs-ofctl add-flow dp4 idle_timeout=0,priority=1,in_port=2,actions=output:4' ) print switch4.cmd(r'ovs-ofctl add-flow dp4 idle_timeout=0,priority=1,in_port=3,actions=output:4' ) print switch4.cmd(r'ovs-ofctl add-flow dp4 idle_timeout=0,priority=1,in_port=4,actions=output:3' ) #print switch0.cmd(r'ovs-ofctl add-flow dp0 idle_timeout=0,priority=10,ip,nw_dst=192.168.123.2,actions=output:4') print switch0.cmd(r'ovs-ofctl add-flow dp0 idle_timeout=0,priority=10,ip,nw_dst=192.168.123.2,nw_tos=0x10,actions=output:2') print switch0.cmd(r'ovs-ofctl add-flow dp0 idle_timeout=0,priority=10,ip,nw_dst=192.168.123.2,nw_tos=0x20,actions=output:3') print switch0.cmd(r'ovs-ofctl add-flow dp0 idle_timeout=0,priority=10,ip,nw_dst=192.168.123.2,nw_tos=0x30,actions=output:4') #print switch0.cmd(r'ovs-ofctl add-flow dp0 idle_timeout=0,priority=10,ip,nw_dst=192.168.123.1,actions=output:1') #switch0.cmd('tcpdump -i s0-eth0 -U -w aaa &') #h0.cmd('tcpdump -i h0-eth0 -U -w aaa &') def cDelay1(): h1.cmdPrint('ethtool -K h1-eth0 gro off') h1.cmdPrint('tc qdisc del dev h1-eth0 root') h1.cmdPrint('tc qdisc add dev h1-eth0 root handle 10: netem delay 100ms') def hello(a, b='4'): print a print b #t=Timer(3.0, hello, args=('aaaa',),kwargs={'b':'7'}) t=Timer(5.0, cDelay1) t.start() info( "*** Running test\n" ) #h0.cmdPrint( 'ping -Q 0x10 -c 3 ' + h1.IP() ) #h0.cmdPrint( 'ping -Q 0x20 -c 3 ' + h1.IP() ) h0.cmdPrint( 'ping -Q 0x30 -c 10 ' + h1.IP() ) #link2.intf1.config(delay='100ms') #h1.cmdPrint('ifconfig -a') #h1.cmdPrint('tc qdisc show dev h1-eth0') #h1.cmdPrint('ethtook -K h1-eth0 gro off') #h1.cmdPrint('tc qdisc del dev h1-eth0 root') #h1.cmdPrint('tc qdisc add dev h1-eth0 root handle 10: netem delay 100ms') #h1.cmdPrint('ifconfig -a') #h1.cmdPrint('tc qdisc show dev h1-eth0') #h1.cmdPrint('tc -s qdisc ls dev h1-eth0') #h0.cmdPrint( 'ping -Q 0x30 -c 5 ' + h1.IP() ) #print switch0.cmd( 'ovs-ofctl show dp0' ) #print switch1.cmd( 'ovs-ofctl show dp1' ) #print switch2.cmd( 'ovs-ofctl show dp2' ) #print switch3.cmd( 'ovs-ofctl show dp3' ) #print switch4.cmd( 'ovs-ofctl show dp4' ) #print switch0.cmd( 'ovs-ofctl dump-tables dp0' ) #print switch0.cmd( 'ovs-ofctl dump-ports dp0' ) #print switch0.cmd( 'ovs-ofctl dump-flows dp0' ) #print switch0.cmd( 'ovs-ofctl dump-aggregate dp0' ) #print switch0.cmd( 'ovs-ofctl queue-stats dp0' ) #print "Testing video transmission between h1 and h2" #h1.cmd('./myrtg_svc -u > myrd &') #h0.cmd('./mystg_svc -trace st 192.168.123.2') info( "*** Stopping network\n" ) switch0.cmd( 'ovs-vsctl del-br dp0' ) switch0.deleteIntfs() switch1.cmd( 'ovs-vsctl del-br dp1' ) switch1.deleteIntfs() switch2.cmd( 'ovs-vsctl del-br dp2' ) switch2.deleteIntfs() switch3.cmd( 'ovs-vsctl del-br dp3' ) switch3.deleteIntfs() switch4.cmd( 'ovs-vsctl del-br dp4' ) switch4.deleteIntfs() info( '\n' )
def scratchNet(cname='controller', cargs='-v ptcp:'): "Create network from scratch using Open vSwitch." info("*** Creating nodes\n") controller = Node('c0', inNamespace=False) switch = Node('s0', inNamespace=False) h0 = Node('h0') h1 = Node('h1') info("*** Creating links\n") Link(h0, switch) Link(h1, switch) info("*** Configuring hosts\n") h0.setIP('192.168.123.1/24') h1.setIP('192.168.123.2/24') info(str(h0) + '\n') info(str(h1) + '\n') info("*** Starting network using Open vSwitch\n") controller.cmd(cname + ' ' + cargs + '&') #issue_switch_cmd(switch, 'ovs-vsctl del-br br-ex') issue_switch_cmd(switch, 'ovs-vsctl del-br br-int') #issue_switch_cmd(switch, 'ovs-vsctl add-br br-ex') issue_switch_cmd(switch, 'ovs-vsctl add-br br-int') # CONCLUSION # ovs-vsctl add-br br-ex # ovs-vsctl add-port br-ex {external_nic} # ovs-vsctl add-br br-int # ovs-vsctl add-port br-int {internal_nic} # ovs-vsctl --no-wait set bridge br-int fail-mode=secure other-config:disable-in-band=true # ovs-vsctl set bridge br-int protocols=OpenFlow10,OpenFlow13 # ovs-vsctl set-manager ptcp:6640:0.0.0.0 for intf in switch.intfs.values(): print issue_switch_cmd(switch, 'ovs-vsctl add-port br-int %s' % intf) # for intf in switch.intfs.values(): # print issue_switch_cmd(switch, 'ovs-vsctl add-port br-ex %s' % intf) issue_switch_cmd(switch, 'ovs-vsctl --no-wait set bridge br-int fail-mode=secure other-config:disable-in-band=true') issue_switch_cmd(switch, 'ovs-vsctl set bridge br-int protocols=OpenFlow10,OpenFlow13') #issue_switch_cmd(switch, 'ovs-vsctl set-manager ptcp:6640:0.0.0.0') # issue_switch_cmd(switch, 'ovs-ofctl -O OpenFlow13 dump-flows br-int') # Note: controller and switch are in root namespace, and we # can connect via loopback interface s_cmd = 'ovs-vsctl set-controller br-int tcp:{}:{}'.format(CTLR_IP, CTLR_PRT) issue_switch_cmd(switch, s_cmd) ping_results = ['received,host,jitter,packet_loss,avgping,minping,time,sent,maxping\n'] try: h0.cmd('echo "" > pings.txt') if mode == 0: step_wise_testing(h0, h1, ping_results) else: continuous_testing(h0, h1, ping_results) except KeyboardInterrupt: print "Warning: Caught KeyboardInterrupt, stopping network" tm_local = time.localtime() dt = time.gmtime() file_name = 'pings_{}_{}_{}-{}_{}_{}.csv'.format(dt.tm_year, dt.tm_mon, dt.tm_mday, tm_local.tm_hour, tm_local.tm_min, tm_local.tm_sec) f = open(file_name, 'w+') for item in ping_results: f.write(item) stop_net(controller, cname, switch)
info( '*** Creating Network\n' ) h0 = Node( 'h0' ) h1 = Node( 'h1' ) net.hosts.append( h0 ) net.hosts.append( h1 ) link = CSMALink( h0, h1, DataRate="10Mbps") ns.csma.CsmaHelper().EnablePcap( "h0-trace.pcap", h0.nsNode.GetDevice( 0 ), True, True ); ns.csma.CsmaHelper().EnablePcap( "h1-trace.pcap", h1.nsNode.GetDevice( 0 ), True, True ); mininet.ns3.start() info( '*** Configuring hosts\n' ) h0.setIP( '192.168.123.1/24' ) h1.setIP( '192.168.123.2/24') info( 'Testing network connectivity\n' ) net.pingAll() info( 'Testing bandwidth between h0 and h1\n' ) net.iperf( ( h0, h1 ) ) mininet.ns3.clear() net.stop() info( "Run: \"wireshark h0-trace.pcap\" to see packets captured in ns device\n" )