A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame^] | 1 | # |
Chetan Gaonker | cfcce78 | 2016-05-10 10:10:42 -0700 | [diff] [blame] | 2 | # Copyright 2016-present Ciena Corporation |
| 3 | # |
| 4 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | # you may not use this file except in compliance with the License. |
| 6 | # You may obtain a copy of the License at |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame^] | 7 | # |
Chetan Gaonker | cfcce78 | 2016-05-10 10:10:42 -0700 | [diff] [blame] | 8 | # http://www.apache.org/licenses/LICENSE-2.0 |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame^] | 9 | # |
Chetan Gaonker | cfcce78 | 2016-05-10 10:10:42 -0700 | [diff] [blame] | 10 | # Unless required by applicable law or agreed to in writing, software |
| 11 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | # See the License for the specific language governing permissions and |
| 14 | # limitations under the License. |
| 15 | # |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 16 | import unittest |
| 17 | from nose.tools import * |
| 18 | from scapy.all import * |
| 19 | from OnosCtrl import OnosCtrl |
| 20 | from OltConfig import OltConfig |
| 21 | from OnosFlowCtrl import OnosFlowCtrl, get_mac |
| 22 | from onosclidriver import OnosCliDriver |
Chetan Gaonker | 6cf6e47 | 2016-04-26 14:41:51 -0700 | [diff] [blame] | 23 | from CordContainer import Container, Onos, Quagga |
| 24 | from CordTestServer import cord_test_onos_restart, cord_test_quagga_restart |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 25 | from portmaps import g_subscriber_port_map |
| 26 | import threading |
| 27 | import time |
| 28 | import os |
| 29 | import json |
| 30 | log.setLevel('INFO') |
| 31 | |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 32 | class QuaggaStopWrapper(Container): |
| 33 | |
| 34 | def __init__(self, name = 'cord-quagga', image = 'cord-test/quagga', tag = 'latest'): |
| 35 | super(QuaggaStopWrapper, self).__init__(name, image, tag = tag) |
| 36 | if self.exists(): |
| 37 | self.kill() |
| 38 | |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 39 | class vrouter_exchange(unittest.TestCase): |
| 40 | |
| 41 | apps = ('org.onosproject.vrouter', 'org.onosproject.fwd') |
| 42 | device_id = 'of:' + get_mac('ovsbr0') |
| 43 | vrouter_device_dict = { "devices" : { |
| 44 | "{}".format(device_id) : { |
| 45 | "basic" : { |
| 46 | "driver" : "softrouter" |
| 47 | } |
| 48 | } |
| 49 | }, |
| 50 | } |
| 51 | zebra_conf = ''' |
| 52 | password zebra |
| 53 | log stdout |
| 54 | service advanced-vty |
| 55 | ! |
Chetan Gaonker | fd3d650 | 2016-05-03 13:23:07 -0700 | [diff] [blame] | 56 | !debug zebra rib |
| 57 | !debug zebra kernel |
| 58 | !debug zebra fpm |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 59 | ! |
| 60 | !interface eth1 |
| 61 | ! ip address 10.10.0.3/16 |
| 62 | line vty |
| 63 | exec-timeout 0 0 |
| 64 | ''' |
| 65 | test_path = os.path.dirname(os.path.realpath(__file__)) |
| 66 | quagga_config_path = os.path.join(test_path, '..', 'setup/quagga-config') |
| 67 | onos_config_path = os.path.join(test_path, '..', 'setup/onos-config') |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 68 | GATEWAY = '192.168.10.50' |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 69 | INGRESS_PORT = 1 |
| 70 | EGRESS_PORT = 2 |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 71 | MAX_PORTS = 100 |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 72 | peer_list = [ ('192.168.10.1', '00:00:00:00:00:01'), ('192.168.11.1', '00:00:00:00:02:01'), ] |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 73 | network_list = [] |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 74 | |
| 75 | @classmethod |
| 76 | def setUpClass(cls): |
| 77 | ''' Activate the vrouter apps''' |
| 78 | cls.olt = OltConfig() |
| 79 | cls.port_map = cls.olt.olt_port_map() |
| 80 | if not cls.port_map: |
| 81 | cls.port_map = g_subscriber_port_map |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 82 | #cls.vrouter_host_load(host = cls.GATEWAY) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 83 | time.sleep(3) |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame^] | 84 | |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 85 | @classmethod |
| 86 | def tearDownClass(cls): |
| 87 | '''Deactivate the vrouter apps''' |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 88 | #cls.vrouter_host_unload() |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 89 | |
| 90 | def cliEnter(self): |
| 91 | retries = 0 |
| 92 | while retries < 3: |
| 93 | self.cli = OnosCliDriver(connect = True) |
| 94 | if self.cli.handle: |
| 95 | break |
| 96 | else: |
| 97 | retries += 1 |
| 98 | time.sleep(2) |
| 99 | |
| 100 | def cliExit(self): |
| 101 | self.cli.disconnect() |
| 102 | |
| 103 | @classmethod |
| 104 | def onos_load_config(cls, config): |
| 105 | status, code = OnosCtrl.config(config) |
| 106 | if status is False: |
| 107 | log.info('JSON request returned status %d' %code) |
| 108 | assert_equal(status, True) |
| 109 | |
| 110 | @classmethod |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 111 | def vrouter_config_get(cls, networks = 4, peers = 1): |
| 112 | vrouter_configs = cls.generate_vrouter_conf(networks = networks, peers = peers) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 113 | return vrouter_configs |
| 114 | ##ONOS router does not support dynamic reconfigurations |
| 115 | #for config in vrouter_configs: |
| 116 | # cls.onos_load_config(config) |
| 117 | # time.sleep(5) |
| 118 | |
| 119 | @classmethod |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 120 | def vrouter_host_load(cls): |
| 121 | index = 1 |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 122 | for host,_ in cls.peer_list: |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 123 | iface = cls.port_map[index] |
| 124 | index += 1 |
| 125 | config_cmds = ( 'ifconfig {0} {1}'.format(iface, host), |
| 126 | 'arping -I {0} {1} -c 2'.format(iface, host), |
| 127 | ) |
| 128 | for cmd in config_cmds: |
| 129 | os.system(cmd) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 130 | |
| 131 | @classmethod |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 132 | def vrouter_host_unload(cls): |
| 133 | index = 1 |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 134 | for host,_ in cls.peer_list: |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 135 | iface = cls.port_map[index] |
| 136 | index += 1 |
| 137 | config_cmds = ('ifconfig {} 0'.format(iface), ) |
| 138 | for cmd in config_cmds: |
| 139 | os.system(cmd) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 140 | |
| 141 | @classmethod |
| 142 | def start_onos(cls, network_cfg = None): |
| 143 | if type(network_cfg) is tuple: |
| 144 | res = [] |
| 145 | for v in network_cfg: |
| 146 | res += v.items() |
| 147 | config = dict(res) |
| 148 | else: |
| 149 | config = network_cfg |
| 150 | log.info('Restarting ONOS with new network configuration') |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame^] | 151 | return cord_test_onos_restart(config = config) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 152 | |
| 153 | @classmethod |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 154 | def start_quagga(cls, networks = 4): |
Chetan Gaonker | 6cf6e47 | 2016-04-26 14:41:51 -0700 | [diff] [blame] | 155 | log.info('Restarting Quagga container with configuration for %d networks' %(networks)) |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 156 | config = cls.generate_conf(networks = networks) |
Chetan Gaonker | fd3d650 | 2016-05-03 13:23:07 -0700 | [diff] [blame] | 157 | if networks <= 10000: |
| 158 | boot_delay = 25 |
| 159 | else: |
Chetan Gaonker | 37ad23f | 2016-05-03 17:37:59 -0700 | [diff] [blame] | 160 | delay_map = [60, 100, 150, 200, 300, 450, 600, 800, 1000, 1200] |
| 161 | n = min(networks/100000, len(delay_map)-1) |
| 162 | boot_delay = delay_map[n] |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame^] | 163 | cord_test_quagga_restart(config = config, boot_delay = boot_delay) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 164 | |
| 165 | @classmethod |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 166 | def zgenerate_vrouter_conf(cls, networks = 4): |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 167 | num = 0 |
| 168 | start_network = ( 11 << 24) | ( 0 << 16) | ( 0 << 8) | 0 |
| 169 | end_network = ( 200 << 24 ) | ( 0 << 16) | (0 << 8) | 0 |
| 170 | ports_dict = { 'ports' : {} } |
| 171 | interface_list = [] |
| 172 | for n in xrange(start_network, end_network): |
| 173 | if n & 255 == 0: |
| 174 | port_map = ports_dict['ports'] |
| 175 | port = num + 1 if num < cls.MAX_PORTS - 1 else cls.MAX_PORTS - 1 |
| 176 | device_port_key = '{0}/{1}'.format(cls.device_id, port) |
| 177 | try: |
| 178 | interfaces = port_map[device_port_key]['interfaces'] |
| 179 | except: |
| 180 | port_map[device_port_key] = { 'interfaces' : [] } |
| 181 | interfaces = port_map[device_port_key]['interfaces'] |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame^] | 182 | |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 183 | ips = '%d.%d.%d.2/24'%( (n >> 24) & 0xff, ( ( n >> 16) & 0xff ), ( (n >> 8 ) & 0xff ) ) |
| 184 | if num < cls.MAX_PORTS - 1: |
| 185 | interface_dict = { 'name' : 'b1-{}'.format(port), 'ips': [ips], 'mac' : '00:00:00:00:00:01' } |
| 186 | interfaces.append(interface_dict) |
| 187 | interface_list.append(interface_dict['name']) |
| 188 | else: |
| 189 | interfaces[0]['ips'].append(ips) |
| 190 | num += 1 |
| 191 | if num == networks: |
| 192 | break |
| 193 | quagga_dict = { 'apps': { 'org.onosproject.router' : { 'router' : {} } } } |
| 194 | quagga_router_dict = quagga_dict['apps']['org.onosproject.router']['router'] |
| 195 | quagga_router_dict['ospfEnabled'] = True |
| 196 | quagga_router_dict['interfaces'] = interface_list |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame^] | 197 | quagga_router_dict['controlPlaneConnectPoint'] = '{0}/{1}'.format(cls.device_id, |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 198 | networks + 1 if networks < cls.MAX_PORTS else cls.MAX_PORTS ) |
| 199 | return (cls.vrouter_device_dict, ports_dict, quagga_dict) |
| 200 | |
| 201 | @classmethod |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 202 | def generate_vrouter_conf(cls, networks = 4, peers = 1): |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 203 | num = 0 |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 204 | start_peer = ( 192 << 24) | ( 168 << 16) | (10 << 8) | 0 |
| 205 | end_peer = ( 200 << 24 ) | (168 << 16) | (10 << 8) | 0 |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 206 | local_network = end_peer + 1 |
| 207 | ports_dict = { 'ports' : {} } |
| 208 | interface_list = [] |
| 209 | peer_list = [] |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 210 | for n in xrange(start_peer, end_peer, 256): |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 211 | port_map = ports_dict['ports'] |
| 212 | port = num + 1 if num < cls.MAX_PORTS - 1 else cls.MAX_PORTS - 1 |
| 213 | device_port_key = '{0}/{1}'.format(cls.device_id, port) |
| 214 | try: |
| 215 | interfaces = port_map[device_port_key]['interfaces'] |
| 216 | except: |
| 217 | port_map[device_port_key] = { 'interfaces' : [] } |
| 218 | interfaces = port_map[device_port_key]['interfaces'] |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 219 | ip = n + 2 |
| 220 | peer_ip = n + 1 |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 221 | ips = '%d.%d.%d.%d/24'%( (ip >> 24) & 0xff, ( (ip >> 16) & 0xff ), ( (ip >> 8 ) & 0xff ), ip & 0xff) |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 222 | peer = '%d.%d.%d.%d' % ( (peer_ip >> 24) & 0xff, ( ( peer_ip >> 16) & 0xff ), ( (peer_ip >> 8 ) & 0xff ), peer_ip & 0xff ) |
| 223 | mac = RandMAC()._fix() |
| 224 | peer_list.append((peer, mac)) |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 225 | if num < cls.MAX_PORTS - 1: |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 226 | interface_dict = { 'name' : 'b1-{}'.format(port), 'ips': [ips], 'mac' : mac } |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 227 | interfaces.append(interface_dict) |
| 228 | interface_list.append(interface_dict['name']) |
| 229 | else: |
| 230 | interfaces[0]['ips'].append(ips) |
| 231 | num += 1 |
| 232 | if num == peers: |
| 233 | break |
| 234 | quagga_dict = { 'apps': { 'org.onosproject.router' : { 'router' : {}, 'bgp' : { 'bgpSpeakers' : [] } } } } |
| 235 | quagga_router_dict = quagga_dict['apps']['org.onosproject.router']['router'] |
| 236 | quagga_router_dict['ospfEnabled'] = True |
| 237 | quagga_router_dict['interfaces'] = interface_list |
| 238 | quagga_router_dict['controlPlaneConnectPoint'] = '{0}/{1}'.format(cls.device_id, peers + 1) |
| 239 | |
| 240 | #bgp_speaker_dict = { 'apps': { 'org.onosproject.router' : { 'bgp' : { 'bgpSpeakers' : [] } } } } |
| 241 | bgp_speakers_list = quagga_dict['apps']['org.onosproject.router']['bgp']['bgpSpeakers'] |
| 242 | speaker_dict = {} |
| 243 | speaker_dict['name'] = 'bgp{}'.format(peers+1) |
| 244 | speaker_dict['connectPoint'] = '{0}/{1}'.format(cls.device_id, peers + 1) |
| 245 | speaker_dict['peers'] = peer_list |
| 246 | bgp_speakers_list.append(speaker_dict) |
| 247 | cls.peer_list = peer_list |
| 248 | return (cls.vrouter_device_dict, ports_dict, quagga_dict) |
| 249 | |
| 250 | @classmethod |
| 251 | def generate_conf(cls, networks = 4): |
| 252 | num = 0 |
| 253 | start_network = ( 11 << 24) | ( 10 << 16) | ( 10 << 8) | 0 |
| 254 | end_network = ( 172 << 24 ) | ( 0 << 16) | (0 << 8) | 0 |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 255 | net_list = [] |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 256 | peer_list = cls.peer_list |
| 257 | network_list = [] |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 258 | for n in xrange(start_network, end_network, 256): |
| 259 | net = '%d.%d.%d.0'%( (n >> 24) & 0xff, ( ( n >> 16) & 0xff ), ( (n >> 8 ) & 0xff ) ) |
| 260 | network_list.append(net) |
| 261 | gateway = peer_list[num % len(peer_list)][0] |
| 262 | net_route = 'ip route {0}/24 {1}'.format(net, gateway) |
| 263 | net_list.append(net_route) |
| 264 | num += 1 |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 265 | if num == networks: |
| 266 | break |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 267 | cls.network_list = network_list |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 268 | zebra_routes = '\n'.join(net_list) |
Chetan Gaonker | 68d9517 | 2016-05-03 11:16:59 -0700 | [diff] [blame] | 269 | #log.info('Zebra routes: \n:%s\n' %cls.zebra_conf + zebra_routes) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 270 | return cls.zebra_conf + zebra_routes |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame^] | 271 | |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 272 | @classmethod |
| 273 | def vrouter_activate(cls, deactivate = False): |
| 274 | app = 'org.onosproject.vrouter' |
| 275 | onos_ctrl = OnosCtrl(app) |
| 276 | if deactivate is True: |
| 277 | onos_ctrl.deactivate() |
| 278 | else: |
| 279 | onos_ctrl.activate() |
| 280 | time.sleep(3) |
| 281 | |
| 282 | @classmethod |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 283 | def vrouter_configure(cls, networks = 4, peers = 1): |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 284 | ##Deactivate vrouter |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 285 | vrouter_configs = cls.vrouter_config_get(networks = networks, peers = peers) |
Chetan Gaonker | 46b62d5 | 2016-04-26 10:08:42 -0700 | [diff] [blame] | 286 | cls.start_onos(network_cfg = vrouter_configs) |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 287 | cls.vrouter_host_load() |
Chetan Gaonker | 02236ba | 2016-04-26 11:24:34 -0700 | [diff] [blame] | 288 | ##Start quagga |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 289 | cls.start_quagga(networks = networks) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 290 | return vrouter_configs |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame^] | 291 | |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 292 | def vrouter_port_send_recv(self, ingress, egress, dst_mac, dst_ip, positive_test = True): |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 293 | src_mac = '00:00:00:00:00:02' |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 294 | src_ip = '1.1.1.1' |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 295 | self.success = False if positive_test else True |
Chetan Gaonker | 68d9517 | 2016-05-03 11:16:59 -0700 | [diff] [blame] | 296 | timeout = 10 if positive_test else 1 |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 297 | count = 2 if positive_test else 1 |
Chetan Gaonker | 68d9517 | 2016-05-03 11:16:59 -0700 | [diff] [blame] | 298 | self.start_sending = True |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 299 | def recv_task(): |
| 300 | def recv_cb(pkt): |
| 301 | log.info('Pkt seen with ingress ip %s, egress ip %s' %(pkt[IP].src, pkt[IP].dst)) |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 302 | self.success = True if positive_test else False |
| 303 | sniff(count=count, timeout=timeout, |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 304 | lfilter = lambda p: IP in p and p[IP].dst == dst_ip and p[IP].src == src_ip, |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 305 | prn = recv_cb, iface = self.port_map[ingress]) |
Chetan Gaonker | 68d9517 | 2016-05-03 11:16:59 -0700 | [diff] [blame] | 306 | self.start_sending = False |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 307 | |
| 308 | t = threading.Thread(target = recv_task) |
| 309 | t.start() |
| 310 | L2 = Ether(src = src_mac, dst = dst_mac) |
| 311 | L3 = IP(src = src_ip, dst = dst_ip) |
| 312 | pkt = L2/L3 |
| 313 | log.info('Sending a packet with dst ip %s, dst mac %s on port %s to verify if flows are correct' % |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 314 | (dst_ip, dst_mac, self.port_map[egress])) |
Chetan Gaonker | 68d9517 | 2016-05-03 11:16:59 -0700 | [diff] [blame] | 315 | while self.start_sending is True: |
| 316 | sendp(pkt, count=50, iface = self.port_map[egress]) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 317 | t.join() |
| 318 | assert_equal(self.success, True) |
| 319 | |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 320 | def vrouter_traffic_verify(self, positive_test = True): |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 321 | peers = len(self.peer_list) |
| 322 | egress = peers + 1 |
| 323 | num = 0 |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 324 | num_hosts = 5 if positive_test else 1 |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 325 | for network in self.network_list: |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 326 | num_ips = num_hosts |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 327 | octets = network.split('.') |
| 328 | for i in xrange(num_ips): |
| 329 | octets[-1] = str(int(octets[-1]) + 1) |
| 330 | dst_ip = '.'.join(octets) |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 331 | dst_mac = self.peer_list[ num % peers ] [1] |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 332 | port = (num % peers) |
| 333 | ingress = port + 1 |
| 334 | #Since peers are on the same network |
| 335 | ##Verify if flows are setup by sending traffic across |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 336 | self.vrouter_port_send_recv(ingress, egress, dst_mac, dst_ip, positive_test = positive_test) |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 337 | num += 1 |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame^] | 338 | |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 339 | def __vrouter_network_verify(self, networks, peers = 1, positive_test = True): |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 340 | _, ports_map, egress_map = self.vrouter_configure(networks = networks, peers = peers) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 341 | self.cliEnter() |
| 342 | ##Now verify |
| 343 | hosts = json.loads(self.cli.hosts(jsonFormat = True)) |
| 344 | log.info('Discovered hosts: %s' %hosts) |
Chetan Gaonker | 68d9517 | 2016-05-03 11:16:59 -0700 | [diff] [blame] | 345 | ##We read from cli if we expect less number of routes to avoid cli timeouts |
| 346 | if networks <= 10000: |
| 347 | routes = json.loads(self.cli.routes(jsonFormat = True)) |
| 348 | #log.info('Routes: %s' %routes) |
| 349 | assert_equal(len(routes['routes4']), networks) |
| 350 | flows = json.loads(self.cli.flows(jsonFormat = True)) |
| 351 | flows = filter(lambda f: f['flows'], flows) |
| 352 | #log.info('Flows: %s' %flows) |
| 353 | assert_not_equal(len(flows), 0) |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 354 | self.vrouter_traffic_verify() |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 355 | if positive_test is False: |
| 356 | self.__vrouter_network_verify_negative(networks, peers = peers) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 357 | self.cliExit() |
Chetan Gaonker | fe551a2 | 2016-04-29 17:34:57 -0700 | [diff] [blame] | 358 | self.vrouter_host_unload() |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 359 | return True |
| 360 | |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 361 | def __vrouter_network_verify_negative(self, networks, peers = 1): |
| 362 | ##Stop quagga. Test traffic again to see if flows were removed |
| 363 | log.info('Stopping Quagga container') |
| 364 | quaggaStop = QuaggaStopWrapper() |
| 365 | time.sleep(2) |
Chetan Gaonker | 68d9517 | 2016-05-03 11:16:59 -0700 | [diff] [blame] | 366 | if networks <= 10000: |
| 367 | routes = json.loads(self.cli.routes(jsonFormat = True)) |
| 368 | #Verify routes have been removed |
| 369 | if routes and routes.has_key('routes4'): |
| 370 | assert_equal(len(routes['routes4']), 0) |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 371 | self.vrouter_traffic_verify(positive_test = False) |
| 372 | log.info('OVS flows have been removed successfully after Quagga was stopped') |
| 373 | self.start_quagga(networks = networks) |
| 374 | ##Verify the flows again after restarting quagga back |
Chetan Gaonker | 68d9517 | 2016-05-03 11:16:59 -0700 | [diff] [blame] | 375 | if networks <= 10000: |
| 376 | routes = json.loads(self.cli.routes(jsonFormat = True)) |
| 377 | assert_equal(len(routes['routes4']), networks) |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 378 | self.vrouter_traffic_verify() |
| 379 | log.info('OVS flows have been successfully reinstalled after Quagga was restarted') |
| 380 | |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 381 | def test_vrouter_1(self): |
| 382 | '''Test vrouter with 5 routes''' |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 383 | res = self.__vrouter_network_verify(5, peers = 1) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 384 | assert_equal(res, True) |
| 385 | |
| 386 | def test_vrouter_2(self): |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 387 | '''Test vrouter with 5 routes with 2 peers''' |
| 388 | res = self.__vrouter_network_verify(5, peers = 2) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 389 | assert_equal(res, True) |
| 390 | |
| 391 | def test_vrouter_3(self): |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 392 | '''Test vrouter with 6 routes with 3 peers''' |
| 393 | res = self.__vrouter_network_verify(6, peers = 3) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 394 | assert_equal(res, True) |
| 395 | |
| 396 | def test_vrouter_4(self): |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 397 | '''Test vrouter with 50 routes''' |
| 398 | res = self.__vrouter_network_verify(50, peers = 1) |
Chetan Gaonker | 3533faa | 2016-04-25 17:50:14 -0700 | [diff] [blame] | 399 | assert_equal(res, True) |
Chetan Gaonker | 6cf6e47 | 2016-04-26 14:41:51 -0700 | [diff] [blame] | 400 | |
Chetan Gaonker | 6cf6e47 | 2016-04-26 14:41:51 -0700 | [diff] [blame] | 401 | def test_vrouter_5(self): |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 402 | '''Test vrouter with 50 routes and 5 peers''' |
| 403 | res = self.__vrouter_network_verify(50, peers = 5) |
| 404 | assert_equal(res, True) |
| 405 | |
| 406 | def test_vrouter_6(self): |
| 407 | '''Test vrouter with 100 routes''' |
| 408 | res = self.__vrouter_network_verify(100, peers = 1) |
| 409 | assert_equal(res, True) |
| 410 | |
| 411 | def test_vrouter_7(self): |
| 412 | '''Test vrouter with 100 routes and 10 peers''' |
| 413 | res = self.__vrouter_network_verify(100, peers = 10) |
| 414 | assert_equal(res, True) |
| 415 | |
| 416 | def test_vrouter_8(self): |
| 417 | '''Test vrouter with 300 routes''' |
| 418 | res = self.__vrouter_network_verify(300, peers = 1) |
| 419 | assert_equal(res, True) |
| 420 | |
| 421 | def test_vrouter_9(self): |
Chetan Gaonker | 6cf6e47 | 2016-04-26 14:41:51 -0700 | [diff] [blame] | 422 | '''Test vrouter with 1000 routes''' |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 423 | res = self.__vrouter_network_verify(1000, peers = 1) |
Chetan Gaonker | 6cf6e47 | 2016-04-26 14:41:51 -0700 | [diff] [blame] | 424 | assert_equal(res, True) |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame^] | 425 | |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 426 | def test_vrouter_10(self): |
Chetan Gaonker | 6cf6e47 | 2016-04-26 14:41:51 -0700 | [diff] [blame] | 427 | '''Test vrouter with 10000 routes''' |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 428 | res = self.__vrouter_network_verify(10000, peers = 1) |
Chetan Gaonker | 6cf6e47 | 2016-04-26 14:41:51 -0700 | [diff] [blame] | 429 | assert_equal(res, True) |
A R Karthick | 81acbff | 2016-06-17 14:45:16 -0700 | [diff] [blame^] | 430 | |
Chetan Gaonker | 6cf6e47 | 2016-04-26 14:41:51 -0700 | [diff] [blame] | 431 | @nottest |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 432 | def test_vrouter_11(self): |
Chetan Gaonker | 6cf6e47 | 2016-04-26 14:41:51 -0700 | [diff] [blame] | 433 | '''Test vrouter with 100000 routes''' |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 434 | res = self.__vrouter_network_verify(100000, peers = 1) |
Chetan Gaonker | 6cf6e47 | 2016-04-26 14:41:51 -0700 | [diff] [blame] | 435 | assert_equal(res, True) |
| 436 | |
| 437 | @nottest |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 438 | def test_vrouter_12(self): |
Chetan Gaonker | 6cf6e47 | 2016-04-26 14:41:51 -0700 | [diff] [blame] | 439 | '''Test vrouter with 1000000 routes''' |
Chetan Gaonker | 8e25e1b | 2016-05-02 13:42:21 -0700 | [diff] [blame] | 440 | res = self.__vrouter_network_verify(1000000, peers = 1) |
Chetan Gaonker | 6cf6e47 | 2016-04-26 14:41:51 -0700 | [diff] [blame] | 441 | assert_equal(res, True) |
Chetan Gaonker | b6064fa | 2016-05-02 16:29:57 -0700 | [diff] [blame] | 442 | |
| 443 | def test_vrouter_13(self): |
| 444 | '''Test vrouter by installing 5 routes, removing Quagga and re-starting Quagga back''' |
| 445 | res = self.__vrouter_network_verify(5, peers = 1, positive_test = False) |
| 446 | |
| 447 | def test_vrouter_14(self): |
| 448 | '''Test vrouter by installing 50 routes, removing Quagga and re-starting Quagga back''' |
| 449 | res = self.__vrouter_network_verify(50, peers = 1, positive_test = False) |