Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 1 | import unittest |
| 2 | from nose.tools import * |
| 3 | from nose.twistedtools import reactor, deferred |
| 4 | from twisted.internet import defer |
| 5 | from scapy.all import * |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 6 | import time, monotonic |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 7 | import os, sys |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 8 | import tempfile |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 9 | import random |
| 10 | import threading |
Chetan Gaonker | e88c95c | 2016-03-02 05:21:47 -0800 | [diff] [blame] | 11 | from IGMP import * |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 12 | from McastTraffic import * |
| 13 | from Stats import Stats |
Chetan Gaonker | 4a25e2b | 2016-03-04 14:45:15 -0800 | [diff] [blame] | 14 | from OnosCtrl import OnosCtrl |
Chetan Gaonker | 4eb1207 | 2016-03-28 15:04:15 -0700 | [diff] [blame] | 15 | from Channels import IgmpChannel |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 16 | log.setLevel('INFO') |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 17 | |
| 18 | class IGMPTestState: |
| 19 | |
| 20 | def __init__(self, groups = [], df = None, state = 0): |
| 21 | self.df = df |
| 22 | self.state = state |
| 23 | self.counter = 0 |
| 24 | self.groups = groups |
| 25 | self.group_map = {} ##create a send/recv count map |
| 26 | for g in groups: |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 27 | self.group_map[g] = (Stats(), Stats()) |
| 28 | |
| 29 | def update(self, group, tx = 0, rx = 0, t = 0): |
| 30 | self.counter += 1 |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 31 | index = 0 if rx == 0 else 1 |
| 32 | v = tx if rx == 0 else rx |
| 33 | if self.group_map.has_key(group): |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 34 | self.group_map[group][index].update(packets = v, t = t) |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 35 | |
| 36 | def update_state(self): |
| 37 | self.state = self.state ^ 1 |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 38 | |
| 39 | class igmp_exchange(unittest.TestCase): |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 40 | |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 41 | V_INF1 = 'veth0' |
| 42 | V_INF2 = 'veth1' |
| 43 | MGROUP1 = '239.1.2.3' |
| 44 | MGROUP2 = '239.2.2.3' |
| 45 | MMACGROUP1 = "01:00:5e:01:02:03" |
| 46 | MMACGROUP2 = "01:00:5e:02:02:03" |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame^] | 47 | MINVALIDGROUP1 = "255.255.255.255" |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 48 | IGMP_DST_MAC = "01:00:5e:00:01:01" |
| 49 | IGMP_SRC_MAC = "5a:e1:ac:ec:4d:a1" |
| 50 | IP_SRC = '1.2.3.4' |
| 51 | IP_DST = '224.0.1.1' |
| 52 | igmp_eth = Ether(dst = IGMP_DST_MAC, src = IGMP_SRC_MAC, type = ETH_P_IP) |
| 53 | igmp_ip = IP(dst = IP_DST, src = IP_SRC) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 54 | IGMP_TEST_TIMEOUT = 5 |
Chetan Gaonker | 1f7c3f8 | 2016-03-08 12:17:37 -0800 | [diff] [blame] | 55 | IGMP_QUERY_TIMEOUT = 30 |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 56 | MCAST_TRAFFIC_TIMEOUT = 10 |
Chetan Gaonker | 4eb1207 | 2016-03-28 15:04:15 -0700 | [diff] [blame] | 57 | PORT_TX_DEFAULT = 2 |
| 58 | PORT_RX_DEFAULT = 1 |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 59 | max_packets = 100 |
Chetan Gaonker | 4a25e2b | 2016-03-04 14:45:15 -0800 | [diff] [blame] | 60 | app = 'org.onosproject.igmp' |
| 61 | |
| 62 | def setUp(self): |
| 63 | ''' Activate the dhcp app''' |
| 64 | self.onos_ctrl = OnosCtrl(self.app) |
| 65 | status, _ = self.onos_ctrl.activate() |
| 66 | assert_equal(status, True) |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 67 | time.sleep(2) |
Chetan Gaonker | 4eb1207 | 2016-03-28 15:04:15 -0700 | [diff] [blame] | 68 | self.igmp_channel = IgmpChannel() |
Chetan Gaonker | 4a25e2b | 2016-03-04 14:45:15 -0800 | [diff] [blame] | 69 | |
| 70 | def teardown(self): |
| 71 | '''Deactivate the dhcp app''' |
| 72 | self.onos_ctrl.deactivate() |
| 73 | |
| 74 | def onos_load_config(self, config): |
Chetan Gaonker | a2b87df | 2016-03-31 15:41:31 -0700 | [diff] [blame] | 75 | status, code = OnosCtrl.config(config) |
Chetan Gaonker | 4a25e2b | 2016-03-04 14:45:15 -0800 | [diff] [blame] | 76 | if status is False: |
| 77 | log.info('JSON request returned status %d' %code) |
| 78 | assert_equal(status, True) |
| 79 | time.sleep(2) |
| 80 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 81 | def onos_ssm_table_load(self, groups, src_list): |
| 82 | ssm_dict = {'apps' : { 'org.onosproject.igmp' : { 'ssmTranslate' : [] } } } |
| 83 | ssm_xlate_list = ssm_dict['apps']['org.onosproject.igmp']['ssmTranslate'] |
| 84 | for g in groups: |
| 85 | for s in src_list: |
| 86 | d = {} |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 87 | d['source'] = s or '0.0.0.0' |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 88 | d['group'] = g |
| 89 | ssm_xlate_list.append(d) |
Chetan Gaonker | 4a25e2b | 2016-03-04 14:45:15 -0800 | [diff] [blame] | 90 | self.onos_load_config(ssm_dict) |
Chetan Gaonker | 4eb1207 | 2016-03-28 15:04:15 -0700 | [diff] [blame] | 91 | cord_port_map = {} |
| 92 | for g in groups: |
| 93 | cord_port_map[g] = (self.PORT_TX_DEFAULT, self.PORT_RX_DEFAULT) |
| 94 | self.igmp_channel.cord_port_table_load(cord_port_map) |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 95 | time.sleep(2) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 96 | |
| 97 | def igmp_verify_join(self, igmpStateList): |
| 98 | sendState, recvState = igmpStateList |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 99 | ## check if the send is received for the groups |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 100 | for g in sendState.groups: |
| 101 | tx_stats = sendState.group_map[g][0] |
| 102 | tx = tx_stats.count |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 103 | assert_greater(tx, 0) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 104 | rx_stats = recvState.group_map[g][1] |
| 105 | rx = rx_stats.count |
| 106 | assert_greater(rx, 0) |
| 107 | log.info('Receive stats %s for group %s' %(rx_stats, g)) |
| 108 | |
| 109 | log.info('IGMP test verification success') |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 110 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 111 | def igmp_verify_leave(self, igmpStateList, leave_groups): |
| 112 | sendState, recvState = igmpStateList[0], igmpStateList[1] |
| 113 | ## check if the send is received for the groups |
| 114 | for g in sendState.groups: |
| 115 | tx_stats = sendState.group_map[g][0] |
| 116 | rx_stats = recvState.group_map[g][1] |
| 117 | tx = tx_stats.count |
| 118 | rx = rx_stats.count |
| 119 | assert_greater(tx, 0) |
| 120 | if g not in leave_groups: |
| 121 | log.info('Received %d packets for group %s' %(rx, g)) |
| 122 | for g in leave_groups: |
| 123 | rx = recvState.group_map[g][1].count |
| 124 | assert_equal(rx, 0) |
| 125 | |
| 126 | log.info('IGMP test verification success') |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 127 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 128 | def mcast_traffic_timer(self): |
| 129 | self.mcastTraffic.stopReceives() |
| 130 | |
| 131 | def send_mcast_cb(self, send_state): |
| 132 | for g in send_state.groups: |
| 133 | send_state.update(g, tx = 1) |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 134 | return 0 |
| 135 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 136 | ##Runs in the context of twisted reactor thread |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 137 | def igmp_recv(self, igmpState, iface = 'veth0'): |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 138 | p = self.recv_socket.recv() |
| 139 | send_time = float(p.payload.load) |
| 140 | recv_time = monotonic.monotonic() |
| 141 | #log.info( 'Recv in %.6f secs' %(recv_time - send_time)) |
| 142 | igmpState.update(p.dst, rx = 1, t = recv_time - send_time) |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 143 | return 0 |
| 144 | |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 145 | def send_igmp_join(self, groups, src_list = ['1.2.3.4'], ip_pkt = None, iface = 'veth0', delay = 2): |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 146 | self.onos_ssm_table_load(groups, src_list) |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 147 | igmp = IGMPv3(type = IGMP_TYPE_V3_MEMBERSHIP_REPORT, max_resp_code=30, |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 148 | gaddr=self.IP_DST) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 149 | for g in groups: |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 150 | gr = IGMPv3gr(rtype=IGMP_V3_GR_TYPE_EXCLUDE, mcaddr=g) |
| 151 | gr.sources = src_list |
| 152 | igmp.grps.append(gr) |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 153 | if ip_pkt is None: |
| 154 | ip_pkt = self.igmp_eth/self.igmp_ip |
| 155 | pkt = ip_pkt/igmp |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 156 | IGMPv3.fixup(pkt) |
| 157 | sendp(pkt, iface=iface) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 158 | if delay != 0: |
| 159 | time.sleep(delay) |
| 160 | |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 161 | def send_igmp_leave(self, groups, src_list = ['1.2.3.4'], ip_pkt = None, iface = 'veth0', delay = 2): |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 162 | igmp = IGMPv3(type = IGMP_TYPE_V3_MEMBERSHIP_REPORT, max_resp_code=30, |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 163 | gaddr=self.IP_DST) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 164 | for g in groups: |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 165 | gr = IGMPv3gr(rtype=IGMP_V3_GR_TYPE_INCLUDE, mcaddr=g) |
| 166 | gr.sources = src_list |
| 167 | igmp.grps.append(gr) |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 168 | if ip_pkt is None: |
| 169 | ip_pkt = self.igmp_eth/self.igmp_ip |
| 170 | pkt = ip_pkt/igmp |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 171 | IGMPv3.fixup(pkt) |
| 172 | sendp(pkt, iface = iface) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 173 | if delay != 0: |
| 174 | time.sleep(delay) |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 175 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 176 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+10) |
| 177 | def test_igmp_join_verify_traffic(self): |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 178 | groups = ['224.0.1.1', '225.0.0.1'] |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 179 | df = defer.Deferred() |
| 180 | igmpState = IGMPTestState(groups = groups, df = df) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 181 | igmpStateRecv = IGMPTestState(groups = groups, df = df) |
| 182 | igmpStateList = (igmpState, igmpStateRecv) |
| 183 | mcastTraffic = McastTraffic(groups, iface= 'veth2', cb = self.send_mcast_cb, arg = igmpState) |
| 184 | self.df = df |
| 185 | self.mcastTraffic = mcastTraffic |
| 186 | self.recv_socket = L3PacketSocket(iface = 'veth0', type = ETH_P_IP) |
| 187 | |
| 188 | def igmp_srp_task(stateList): |
| 189 | igmpSendState, igmpRecvState = stateList |
| 190 | if not mcastTraffic.isRecvStopped(): |
| 191 | result = self.igmp_recv(igmpRecvState) |
| 192 | reactor.callLater(0, igmp_srp_task, stateList) |
| 193 | else: |
| 194 | self.mcastTraffic.stop() |
| 195 | self.recv_socket.close() |
| 196 | self.igmp_verify_join(stateList) |
| 197 | self.df.callback(0) |
| 198 | |
| 199 | self.send_igmp_join(groups) |
| 200 | mcastTraffic.start() |
| 201 | self.test_timer = reactor.callLater(self.MCAST_TRAFFIC_TIMEOUT, self.mcast_traffic_timer) |
| 202 | reactor.callLater(0, igmp_srp_task, igmpStateList) |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 203 | return df |
| 204 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 205 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+10) |
| 206 | def test_igmp_leave_verify_traffic(self): |
| 207 | groups = ['224.0.1.10', '225.0.0.10'] |
| 208 | leave_groups = ['224.0.1.10'] |
| 209 | df = defer.Deferred() |
| 210 | igmpState = IGMPTestState(groups = groups, df = df) |
| 211 | igmpStateRecv = IGMPTestState(groups = groups, df = df) |
| 212 | igmpStateList = (igmpState, igmpStateRecv) |
| 213 | mcastTraffic = McastTraffic(groups, iface= 'veth2', cb = self.send_mcast_cb, |
| 214 | arg = igmpState) |
| 215 | self.df = df |
| 216 | self.mcastTraffic = mcastTraffic |
| 217 | self.recv_socket = L3PacketSocket(iface = 'veth0', type = ETH_P_IP) |
| 218 | |
| 219 | def igmp_srp_task(stateList): |
| 220 | igmpSendState, igmpRecvState = stateList |
| 221 | if not mcastTraffic.isRecvStopped(): |
| 222 | result = self.igmp_recv(igmpRecvState) |
| 223 | reactor.callLater(0, igmp_srp_task, stateList) |
| 224 | else: |
| 225 | self.mcastTraffic.stop() |
| 226 | self.recv_socket.close() |
| 227 | self.igmp_verify_leave(stateList, leave_groups) |
| 228 | self.df.callback(0) |
| 229 | |
| 230 | self.send_igmp_join(groups) |
| 231 | self.send_igmp_leave(leave_groups, delay = 3) |
| 232 | mcastTraffic.start() |
| 233 | self.test_timer = reactor.callLater(self.MCAST_TRAFFIC_TIMEOUT, self.mcast_traffic_timer) |
| 234 | reactor.callLater(0, igmp_srp_task, igmpStateList) |
| 235 | return df |
| 236 | |
| 237 | @deferred(timeout=100) |
| 238 | def test_igmp_leave_join_loop(self): |
| 239 | self.groups = ['226.0.1.1', '227.0.0.1', '228.0.0.1', '229.0.0.1', '230.0.0.1' ] |
| 240 | self.src_list = ['3.4.5.6', '7.8.9.10'] |
| 241 | df = defer.Deferred() |
| 242 | self.df = df |
| 243 | self.iterations = 0 |
| 244 | self.num_groups = len(self.groups) |
| 245 | self.MAX_TEST_ITERATIONS = 10 |
| 246 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 247 | def igmp_srp_task(v): |
| 248 | if self.iterations < self.MAX_TEST_ITERATIONS: |
| 249 | if v == 1: |
| 250 | ##join test |
| 251 | self.num_groups = random.randint(0, len(self.groups)) |
| 252 | self.send_igmp_join(self.groups[:self.num_groups], |
| 253 | src_list = self.src_list, |
| 254 | iface = 'veth0', delay = 0) |
| 255 | else: |
| 256 | self.send_igmp_leave(self.groups[:self.num_groups], |
| 257 | src_list = self.src_list, |
| 258 | iface = 'veth0', delay = 0) |
| 259 | self.iterations += 1 |
| 260 | v ^= 1 |
| 261 | reactor.callLater(1.0 + 0.5*self.num_groups, |
| 262 | igmp_srp_task, v) |
| 263 | else: |
| 264 | self.df.callback(0) |
| 265 | |
| 266 | reactor.callLater(0, igmp_srp_task, 1) |
| 267 | return df |
| 268 | |
| 269 | def igmp_join_task(self, intf, groups, state, src_list = ['1.2.3.4']): |
| 270 | self.onos_ssm_table_load(groups, src_list) |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 271 | igmp = IGMPv3(type = IGMP_TYPE_V3_MEMBERSHIP_REPORT, max_resp_code=30, |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 272 | gaddr=self.IP_DST) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 273 | for g in groups: |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 274 | gr = IGMPv3gr(rtype = IGMP_V3_GR_TYPE_EXCLUDE, mcaddr = g) |
| 275 | gr.sources = src_list |
| 276 | igmp.grps.append(gr) |
| 277 | |
| 278 | for g in groups: |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 279 | state.group_map[g][0].update(1, t = monotonic.monotonic()) |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 280 | |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 281 | pkt = self.igmp_eth/self.igmp_ip/igmp |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 282 | IGMPv3.fixup(pkt) |
| 283 | sendp(pkt, iface=intf) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 284 | log.debug('Returning from join task') |
| 285 | |
| 286 | def igmp_recv_task(self, intf, groups, join_state): |
| 287 | recv_socket = L3PacketSocket(iface = intf, type = ETH_P_IP) |
| 288 | group_map = {} |
| 289 | for g in groups: |
| 290 | group_map[g] = [0,0] |
| 291 | |
| 292 | while True: |
| 293 | p = recv_socket.recv() |
| 294 | if p.dst in groups and group_map[p.dst][0] == 0: |
| 295 | group_map[p.dst][0] += 1 |
| 296 | group_map[p.dst][1] = monotonic.monotonic() |
| 297 | c = 0 |
| 298 | for g in groups: |
| 299 | c += group_map[g][0] |
| 300 | if c == len(groups): |
| 301 | break |
| 302 | for g in groups: |
| 303 | join_start = join_state.group_map[g][0].start |
| 304 | recv_time = group_map[g][1] * 1000000 |
| 305 | delta = (recv_time - join_start) |
| 306 | log.info('Join for group %s received in %.3f usecs' % |
| 307 | (g, delta)) |
| 308 | |
| 309 | recv_socket.close() |
| 310 | log.debug('Returning from recv task') |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 311 | |
| 312 | def igmp_not_recv_task(self, intf, groups, join_state): |
| 313 | recv_socket = L2Socket(iface = intf, type = ETH_P_IP) |
| 314 | group_map = {} |
| 315 | for g in groups: |
| 316 | group_map[g] = [0,0] |
| 317 | |
| 318 | log.info('Should not receive any multicast data') |
| 319 | status = 1 |
| 320 | def igmp_recv_cb(pkt): |
| 321 | log.info('Multicast packet %s received for left groups %s' %(pkt[IP].dst, groups)) |
| 322 | status = 2 |
| 323 | sniff(prn = igmp_recv_cb, count = 1, lfilter = lambda p: p[IP].dst in groups, |
| 324 | timeout = 3, opened_socket = recv_socket) |
| 325 | recv_socket.close() |
| 326 | return status |
| 327 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 328 | def group_latency_check(self, groups): |
| 329 | tasks = [] |
| 330 | self.send_igmp_leave(groups = groups) |
| 331 | join_state = IGMPTestState(groups = groups) |
| 332 | tasks.append(threading.Thread(target=self.igmp_join_task, args = ('veth0', groups, join_state,))) |
| 333 | traffic_state = IGMPTestState(groups = groups) |
| 334 | mcast_traffic = McastTraffic(groups, iface= 'veth2', cb = self.send_mcast_cb, |
| 335 | arg = traffic_state) |
| 336 | mcast_traffic.start() |
| 337 | tasks.append(threading.Thread(target=self.igmp_recv_task, args = ('veth0', groups, join_state))) |
| 338 | for t in tasks: |
| 339 | t.start() |
| 340 | for t in tasks: |
| 341 | t.join() |
| 342 | |
| 343 | mcast_traffic.stop() |
| 344 | self.send_igmp_leave(groups = groups) |
| 345 | return |
| 346 | |
| 347 | def test_igmp_1group_join_latency(self): |
| 348 | groups = ['239.0.1.1'] |
| 349 | self.group_latency_check(groups) |
| 350 | |
| 351 | def test_igmp_2group_join_latency(self): |
| 352 | groups = ['239.0.1.1', '240.0.1.1'] |
| 353 | self.group_latency_check(groups) |
| 354 | |
| 355 | def test_igmp_Ngroup_join_latency(self): |
| 356 | groups = ['239.0.1.1', '240.0.1.1', '241.0.1.1', '242.0.1.1'] |
| 357 | self.group_latency_check(groups) |
| 358 | |
| 359 | |
Chetan Gaonker | 1f7c3f8 | 2016-03-08 12:17:37 -0800 | [diff] [blame] | 360 | def test_igmp_join_rover(self): |
| 361 | '''Keep sending joins across multicast range of addresses''' |
| 362 | '''For now, restricting it to 50/100''' |
| 363 | s = (224 << 24) | 1 |
| 364 | #e = (225 << 24) | (255 << 16) | (255 << 16) | 255 |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 365 | e = (224 << 24) | 10 |
Chetan Gaonker | 1f7c3f8 | 2016-03-08 12:17:37 -0800 | [diff] [blame] | 366 | for i in xrange(s, e+1): |
| 367 | if i&0xff: |
| 368 | ip = '%d.%d.%d.%d'%((i>>24)&0xff, (i>>16)&0xff, (i>>8)&0xff, i&0xff) |
| 369 | self.send_igmp_join([ip], delay = 0) |
| 370 | |
| 371 | @deferred(timeout=IGMP_QUERY_TIMEOUT + 10) |
| 372 | def test_igmp_query(self): |
| 373 | groups = ['224.0.0.1'] ##igmp query group |
| 374 | df = defer.Deferred() |
| 375 | self.df = df |
| 376 | self.recv_socket = L2Socket(iface = 'veth0', type = ETH_P_IP) |
| 377 | |
| 378 | def igmp_query_timeout(): |
Chetan Gaonker | 1f7c3f8 | 2016-03-08 12:17:37 -0800 | [diff] [blame] | 379 | def igmp_query_cb(pkt): |
Chetan Gaonker | bd4390f | 2016-03-09 18:56:52 -0800 | [diff] [blame] | 380 | log.info('Got IGMP query packet from %s for %s' %(pkt[IP].src, pkt[IP].dst)) |
| 381 | assert_equal(pkt[IP].dst, '224.0.0.1') |
| 382 | |
| 383 | sniff(prn = igmp_query_cb, count=1, lfilter = lambda p: p[IP].dst in groups, |
| 384 | opened_socket = self.recv_socket) |
Chetan Gaonker | 1f7c3f8 | 2016-03-08 12:17:37 -0800 | [diff] [blame] | 385 | self.recv_socket.close() |
| 386 | self.df.callback(0) |
| 387 | |
| 388 | self.send_igmp_join(groups) |
| 389 | self.test_timer = reactor.callLater(self.IGMP_QUERY_TIMEOUT, igmp_query_timeout) |
| 390 | return df |
| 391 | |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 392 | def igmp_send_joins_different_groups_srclist(self, groups, sources, intf = V_INF1, delay = 2, ip_src = None): |
| 393 | g1 = groups[0] |
| 394 | g2 = groups[1] |
| 395 | sourcelist1 = sources[0] |
| 396 | sourcelist2 = sources[1] |
| 397 | eth = Ether(dst = self.MMACGROUP1, src = self.IGMP_SRC_MAC, type = ETH_P_IP) |
| 398 | src_ip = ip_src or self.IP_SRC |
| 399 | ip = IP(dst = g1, src = src_ip) |
| 400 | log.info('Sending join message for the group %s' %g1) |
| 401 | self.send_igmp_join((g1,), src_list = sourcelist1, ip_pkt = eth/ip, iface = intf, delay = 2) |
| 402 | eth = Ether(dst = self.MMACGROUP2, src = self.IGMP_SRC_MAC, type = ETH_P_IP) |
| 403 | ip = IP(dst = g2, src = src_ip) |
| 404 | log.info('Sending join message for group %s' %g2) |
| 405 | self.send_igmp_join((g2,), src_list = sourcelist2, ip_pkt = eth/ip, iface = intf, delay = 2) |
| 406 | |
| 407 | def igmp_joins_leave_functionality(self, again_join = False, df = None): |
| 408 | groups1 = (self.MGROUP1,) |
| 409 | groups2 = (self.MGROUP2,) |
| 410 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 411 | (['2.2.2.2'], ['2.2.2.2']), intf = self.V_INF1, delay = 2) |
| 412 | dst_mac = '01:00:5e:01:02:03' |
| 413 | src_ip = '2.2.2.2' |
| 414 | if df is None: |
| 415 | df = defer.Deferred() |
| 416 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 417 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 418 | igmpStateList1 = (igmpState1, igmpStateRecv1) |
| 419 | |
| 420 | igmpState2 = IGMPTestState(groups = groups2, df = df) |
| 421 | igmpStateRecv2 = IGMPTestState(groups = groups2, df = df) |
| 422 | igmpStateList2 = (igmpState2, igmpStateRecv2) |
| 423 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 424 | src_ip = src_ip, cb = self.send_mcast_cb, |
| 425 | arg = igmpState1) |
| 426 | dst_mac = '01:00:5e:02:02:03' |
| 427 | src_ip = '2.2.2.2' |
| 428 | mcastTraffic2 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 429 | src_ip = src_ip, cb = self.send_mcast_cb, |
| 430 | arg = igmpState2) |
| 431 | mcastTraffic1.start() |
| 432 | mcastTraffic2.start() |
| 433 | join_state1 = IGMPTestState(groups = groups1) |
| 434 | join_state2 = IGMPTestState(groups = groups2) |
| 435 | target1 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 436 | log.info('Interface is receiving multicast groups %s' %groups1) |
| 437 | target2 = self.igmp_recv_task(self.V_INF1, groups2, join_state2) |
| 438 | log.info('Interface is receiving multicast groups %s' %groups2) |
| 439 | log.info('Interface is sending leave message for groups %s now' %groups2) |
| 440 | self.send_igmp_leave(groups = groups2, src_list = ['2.2.2.2'], iface = self.V_INF1, delay = 2) |
| 441 | target3 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 442 | target4 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state2) |
| 443 | assert target4 == 1, 'EXPECTED FAILURE' |
| 444 | if again_join: |
| 445 | dst_mac = '01:00:5e:02:02:03' |
| 446 | ip_dst = '239.2.2.3' |
| 447 | eth = Ether(dst = dst_mac, src = self.IGMP_SRC_MAC, type = ETH_P_IP) |
| 448 | ip = IP(dst = ip_dst, src = self.IP_SRC) |
| 449 | log.info('Interface sending join message again for the groups %s' %groups2) |
| 450 | self.send_igmp_join(groups2, src_list = [src_ip], ip_pkt = eth/ip, iface = self.V_INF1, delay = 2) |
| 451 | target5 = self.igmp_recv_task(self.V_INF1, groups2, join_state2) |
| 452 | log.info('Interface is receiving multicast groups %s again' %groups2) |
| 453 | target6 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 454 | log.info('Interface is still receiving from multicast groups %s' %groups1) |
| 455 | else: |
| 456 | log.info('Ended test case') |
| 457 | mcastTraffic1.stop() |
| 458 | mcastTraffic2.stop() |
| 459 | self.onos_ctrl.deactivate() |
| 460 | |
| 461 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 462 | def test_igmp_2joins_1leave_functionality(self): |
| 463 | '''This test is subscribing to two channels and sending leave for one channel''' |
| 464 | df = defer.Deferred() |
| 465 | def test_igmp_2joins_1leave(): |
| 466 | self.igmp_joins_leave_functionality(again_join = False, df = df) |
| 467 | df.callback(0) |
| 468 | reactor.callLater(0, test_igmp_2joins_1leave) |
| 469 | return df |
| 470 | |
| 471 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+25) |
| 472 | def test_igmp_2joins_1leave_again_joins_functionality(self): |
| 473 | '''This test is subscribing to two channels and sending leave for one channel,again join to the same group''' |
| 474 | df = defer.Deferred() |
| 475 | def test_igmp_2joins_1leave_join_again(): |
| 476 | self.igmp_joins_leave_functionality(again_join = True, df = df) |
| 477 | df.callback(0) |
| 478 | reactor.callLater(0, test_igmp_2joins_1leave_join_again) |
| 479 | return df |
| 480 | |
| 481 | def igmp_not_src_list_functionality(self, df = None): |
| 482 | groups1 = (self.MGROUP1,) |
| 483 | groups2 = (self.MGROUP2,) |
| 484 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 485 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 486 | intf = self.V_INF1, delay = 2) |
| 487 | dst_mac = '01:00:5e:01:02:03' |
| 488 | src_ip = '6.6.6.6' |
| 489 | if df is None: |
| 490 | df = defer.Deferred() |
| 491 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 492 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 493 | mcastTraffic1 = McastTraffic(groups1, iface = 'veth2', dst_mac = dst_mac, |
| 494 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 495 | mcastTraffic1.start() |
| 496 | join_state1 = IGMPTestState(groups = groups1) |
| 497 | target1 = self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 498 | assert target1 == 1, 'EXPECTED FAILURE' |
| 499 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 500 | mcastTraffic1.stop() |
| 501 | self.onos_ctrl.deactivate() |
| 502 | |
| 503 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 504 | def test_igmp_not_src_list_functionality(self): |
| 505 | '''This test is sending join with source list A,B,C and exclude A,D''' |
| 506 | df = defer.Deferred() |
| 507 | def igmp_not_src_list_functionality(): |
| 508 | self.igmp_not_src_list_functionality(df = df) |
| 509 | df.callback(0) |
| 510 | reactor.callLater(0, igmp_not_src_list_functionality) |
| 511 | return df |
| 512 | |
| 513 | def igmp_change_to_exclude_src_list_functionality(self, df = None): |
| 514 | groups1 = (self.MGROUP1,) |
| 515 | groups2 = (self.MGROUP2,) |
| 516 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 517 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 518 | intf = self.V_INF1, delay = 2) |
| 519 | dst_mac = '01:00:5e:01:02:03' |
| 520 | src_ip = '2.2.2.2' |
| 521 | if df is None: |
| 522 | df = defer.Deferred() |
| 523 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 524 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 525 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 526 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 527 | mcastTraffic1.start() |
| 528 | join_state1 = IGMPTestState(groups = groups1) |
| 529 | target1 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 530 | self.send_igmp_leave(groups = groups1, src_list = ['2.2.2.2'], iface = self.V_INF1, delay =2) |
| 531 | target2 = self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 532 | assert target2 == 1, 'EXPECTED FAILURE' |
| 533 | log.info('Interface is not receiving from multicast groups %s after sending CHANGE_TO_EXCLUDE' %groups1) |
| 534 | mcastTraffic1.stop() |
| 535 | self.onos_ctrl.deactivate() |
| 536 | |
| 537 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+10) |
| 538 | def test_igmp_change_to_exclude_src_list_functionality(self): |
| 539 | '''This test is sending join with source list A,B,C and exclude A,D''' |
| 540 | df = defer.Deferred() |
| 541 | def igmp_change_to_exclude_src_list_functionality(): |
| 542 | self.igmp_change_to_exclude_src_list_functionality(df = df) |
| 543 | df.callback(0) |
| 544 | reactor.callLater(0, igmp_change_to_exclude_src_list_functionality) |
| 545 | return df |
| 546 | |
| 547 | def igmp_change_to_include_src_list_functionality(self, df = None): |
| 548 | groups1 = (self.MGROUP1,) |
| 549 | groups2 = (self.MGROUP2,) |
| 550 | self.send_igmp_leave(groups = groups1, src_list = ['2.2.2.2', '3.3.3.3', '4.4.4.4'], |
| 551 | iface = self.V_INF1, delay = 2) |
| 552 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 553 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['6.6.6.6', '5.5.5.5']), |
| 554 | intf = self.V_INF1, delay = 2) |
| 555 | dst_mac = '01:00:5e:01:02:03' |
| 556 | src_ip = '2.2.2.2' |
| 557 | if df is None: |
| 558 | df = defer.Deferred() |
| 559 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 560 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 561 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 562 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 563 | mcastTraffic1.start() |
| 564 | join_state1 = IGMPTestState(groups = groups1) |
| 565 | target1= self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 566 | assert target1 == 1, 'EXPECTED FAILURE' |
| 567 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 568 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 569 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['6.6.6.6', '5.5.5.5']), |
| 570 | intf = self.V_INF1, delay = 2) |
| 571 | target2 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 572 | log.info('Interface is receiving from multicast groups %s after send Change to include message' %groups1) |
| 573 | mcastTraffic1.stop() |
| 574 | self.onos_ctrl.deactivate() |
| 575 | |
| 576 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+10) |
| 577 | def test_igmp_change_to_include_src_list_functionality(self): |
| 578 | '''This test is sending join with source list A,B,C and exclude D,E''' |
| 579 | df = defer.Deferred() |
| 580 | def igmp_change_to_include_src_list_functionality(): |
| 581 | self.igmp_change_to_include_src_list_functionality(df = df) |
| 582 | df.callback(0) |
| 583 | reactor.callLater(0, igmp_change_to_include_src_list_functionality) |
| 584 | return df |
| 585 | |
| 586 | def igmp_new_src_list_functionality(self, df = None): |
| 587 | groups1 = (self.MGROUP1,) |
| 588 | groups2 = (self.MGROUP2,) |
| 589 | self.igmp_send_joins_different_groups_srclist(groups1+groups2, |
| 590 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 591 | intf = self.V_INF1, delay = 2) |
| 592 | dst_mac = '01:00:5e:01:02:03' |
| 593 | src_ip = '6.6.6.6' |
| 594 | if df is None: |
| 595 | df = defer.Deferred() |
| 596 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 597 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 598 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 599 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 600 | mcastTraffic1.start() |
| 601 | join_state1 = IGMPTestState(groups = groups1) |
| 602 | target1 = self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 603 | assert target1 == 1, 'EXPECTED FAILURE' |
| 604 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 605 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 606 | (['6.6.6.6', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 607 | intf = self.V_INF1, delay = 2) |
| 608 | target2 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 609 | log.info('Interface is receiving from multicast groups %s after sending join with new source list' %groups1) |
| 610 | mcastTraffic1.stop() |
| 611 | self.onos_ctrl.deactivate() |
| 612 | |
| 613 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+10) |
| 614 | def test_igmp_new_src_list_functionality(self): |
| 615 | '''This test is sending join with source list A,B,C and exclude A,D''' |
| 616 | df = defer.Deferred() |
| 617 | def igmp_new_src_list_functionality(): |
| 618 | self.igmp_new_src_list_functionality(df = df) |
| 619 | df.callback(0) |
| 620 | reactor.callLater(0, igmp_new_src_list_functionality) |
| 621 | return df |
| 622 | |
| 623 | def igmp_block_old_src_list_functionality(self, df = None): |
| 624 | groups1 = (self.MGROUP1,) |
| 625 | groups2 = (self.MGROUP2,) |
| 626 | groups = groups1 + groups2 |
| 627 | self.igmp_send_joins_different_groups_srclist(groups, |
| 628 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 629 | intf = self.V_INF1, delay = 2) |
| 630 | dst_mac = '01:00:5e:02:02:03' |
| 631 | src_ip = '5.5.5.5' |
| 632 | if df is None: |
| 633 | df = defer.Deferred() |
| 634 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 635 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 636 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 637 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 638 | mcastTraffic1.start() |
| 639 | join_state1 = IGMPTestState(groups = groups2) |
| 640 | target1 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
| 641 | log.info('Interface is receiving from multicast groups %s' %groups2) |
| 642 | self.igmp_send_joins_different_groups_srclist(groups, |
| 643 | (['6.6.6.6', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '7.7.7.7']), |
| 644 | intf = self.V_INF1, delay = 2) |
| 645 | target2 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 646 | assert target2 == 1, 'EXPECTED FAILURE' |
| 647 | log.info('Interface is not receiving from multicast groups %s after sending join with block old source list' %groups2) |
| 648 | mcastTraffic1.stop() |
| 649 | self.onos_ctrl.deactivate() |
| 650 | |
| 651 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 652 | def test_igmp_block_old_src_list_functionality(self): |
| 653 | '''This test is sending join with source list A,B,C and exclude A,D''' |
| 654 | df = defer.Deferred() |
| 655 | def igmp_block_old_src_list_functionality(): |
| 656 | self.igmp_block_old_src_list_functionality(df = df) |
| 657 | df.callback(0) |
| 658 | reactor.callLater(0, igmp_block_old_src_list_functionality) |
| 659 | return df |
| 660 | |
| 661 | def igmp_include_empty_src_list_functionality(self, df = None): |
| 662 | print'This test is sending join with source list A,B,C and exclude D,F,G' |
| 663 | groups1 = (self.MGROUP1,) |
| 664 | groups2 = (self.MGROUP2,) |
| 665 | groups = groups1 + groups2 |
| 666 | self.igmp_send_joins_different_groups_srclist(groups, |
| 667 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['']), |
| 668 | intf = self.V_INF1, delay = 2) |
| 669 | dst_mac = '01:00:5e:02:02:03' |
| 670 | src_ip = '5.5.5.5' |
| 671 | if df is None: |
| 672 | df = defer.Deferred() |
| 673 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 674 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 675 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 676 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 677 | mcastTraffic1.start() |
| 678 | join_state1 = IGMPTestState(groups = groups2) |
| 679 | target1 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 680 | assert target1==1, 'EXPECTED FAILURE' |
| 681 | log.info('Interface is not receiving from multicast groups %s when we sent join with source list is empty' %groups2) |
| 682 | mcastTraffic1.stop() |
| 683 | self.onos_ctrl.deactivate() |
| 684 | |
| 685 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 686 | def ztest_igmp_include_empty_src_list_functionality(self): |
| 687 | '''This test is sending join with source list A,B,C and exclude D,F,G''' |
| 688 | '''Disabling this test as scapy IGMP doesn't work with empty source lists''' |
| 689 | df = defer.Deferred() |
| 690 | def igmp_include_empty_src_list_functionality(): |
| 691 | self.igmp_include_empty_src_list_functionality(df = df) |
| 692 | df.callback(0) |
| 693 | reactor.callLater(0, igmp_include_empty_src_list_functionality) |
| 694 | return df |
| 695 | |
| 696 | def igmp_exclude_empty_src_list_functionality(self, df = None): |
| 697 | groups1 = (self.MGROUP1,) |
| 698 | groups2 = (self.MGROUP2,) |
| 699 | groups = groups1 + groups2 |
| 700 | self.send_igmp_leave(groups = groups2, src_list = [''], iface = self.V_INF1, delay = 2) |
| 701 | dst_mac = '01:00:5e:02:02:03' |
| 702 | src_ip = '5.5.5.5' |
| 703 | if df is None: |
| 704 | df = defer.Deferred() |
| 705 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 706 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 707 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 708 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 709 | mcastTraffic1.start() |
| 710 | join_state1 = IGMPTestState(groups = groups2) |
| 711 | target1 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
| 712 | log.info('Interface is receiving multicast groups %s' %groups2) |
| 713 | mcastTraffic1.stop() |
| 714 | self.onos_ctrl.deactivate() |
| 715 | |
| 716 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 717 | def ztest_igmp_exclude_empty_src_list_functionality(self): |
| 718 | '''This test is sending join with source list A,B,C and exclude D,F,G''' |
| 719 | '''Disabling this test case since scapy IGMP doesn't work with empty src list''' |
| 720 | df = defer.Deferred() |
| 721 | def igmp_exclude_empty_src_list_functionality(): |
| 722 | self.igmp_exclude_empty_src_list_functionality() |
| 723 | df.callback(0) |
| 724 | reactor.callLater(0, igmp_exclude_empty_src_list_functionality) |
| 725 | return df |
| 726 | |
| 727 | def igmp_join_sourceip_0_0_0_0_functionality(self, df = None): |
| 728 | groups1 = (self.MGROUP1,) |
| 729 | groups2 = (self.MGROUP2,) |
| 730 | groups = groups1 + groups2 |
| 731 | ip_src = '0.0.0.0' |
| 732 | self.igmp_send_joins_different_groups_srclist(groups, |
| 733 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['5.5.5.5']), |
| 734 | intf = self.V_INF1, delay = 2, ip_src = ip_src) |
| 735 | ip_src = self.IP_SRC |
| 736 | dst_mac = '01:00:5e:02:02:03' |
| 737 | src_ip = '5.5.5.5' |
| 738 | if df is None: |
| 739 | df = defer.Deferred() |
| 740 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 741 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 742 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 743 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 744 | mcastTraffic1.start() |
| 745 | join_state1 = IGMPTestState(groups = groups2) |
| 746 | target1 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
| 747 | log.info('Interface is receiving from multicast groups %s when we sent join with source IP is 0.0.0.0' %groups2) |
| 748 | mcastTraffic1.stop() |
| 749 | self.onos_ctrl.deactivate() |
| 750 | |
| 751 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 752 | def test_igmp_join_sourceip_0_0_0_0_functionality(self): |
| 753 | '''This test is sending join with source list A,B,C and exclude D,F,G with source IP as 0.0.0.0''' |
| 754 | df = defer.Deferred() |
| 755 | def igmp_join_sourceip_0_0_0_0_functionality(): |
| 756 | self.igmp_join_sourceip_0_0_0_0_functionality(df = df) |
| 757 | df.callback(0) |
| 758 | reactor.callLater(0, igmp_join_sourceip_0_0_0_0_functionality) |
| 759 | return df |
| 760 | |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame^] | 761 | def igmp_invalid_join_packet_functionality(self, df = None): |
| 762 | groups1 = (self.MGROUP1,) |
| 763 | groups2 = (self.MINVALIDGROUP1,) |
| 764 | groups = groups1 + groups2 |
| 765 | ip_src = '1.1.1.1' |
| 766 | self.igmp_send_joins_different_groups_srclist(groups, |
| 767 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['5.5.5.5']), |
| 768 | intf = self.V_INF1, delay = 2, ip_src = ip_src) |
| 769 | ip_src = self.IP_SRC |
| 770 | dst_mac = '01:00:5e:02:02:03' |
| 771 | src_ip = '5.5.5.5' |
| 772 | if df is None: |
| 773 | df = defer.Deferred() |
| 774 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 775 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 776 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 777 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 778 | mcastTraffic1.start() |
| 779 | join_state1 = IGMPTestState(groups = groups2) |
| 780 | target1 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 781 | assert target1==1, 'EXPECTED FAILURE' |
| 782 | log.info('Interface is not receiving from multicast groups %s when we sent invalid join packet ' %groups2) |
| 783 | mcastTraffic1.stop() |
| 784 | self.onos_ctrl.deactivate() |
| 785 | |
| 786 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 787 | def test_igmp_invalid_join_packet_functionality(self): |
| 788 | '''This test is sending invalid join with source list A,B,C and exclude D,F,G with multicast group as 255.255.255.255''' |
| 789 | df = defer.Deferred() |
| 790 | def igmp_invalid_join_packet_functionality(): |
| 791 | self.igmp_invalid_join_packet_functionality(df = df) |
| 792 | df.callback(0) |
| 793 | reactor.callLater(0, igmp_invalid_join_packet_functionality) |
| 794 | return df |
| 795 | |
| 796 | def igmp_join_data_receiving_during_subscriber_link_down_up_functionality(self, df = None): |
| 797 | groups1 = (self.MGROUP1,) |
| 798 | groups2 = (self.MGROUP2,) |
| 799 | groups = groups1 + groups2 |
| 800 | ip_src = '1.1.1.1' |
| 801 | self.igmp_send_joins_different_groups_srclist(groups, |
| 802 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['5.5.5.5']), |
| 803 | intf = self.V_INF1, delay = 2, ip_src = ip_src) |
| 804 | ip_src = self.IP_SRC |
| 805 | dst_mac = '01:00:5e:02:02:03' |
| 806 | src_ip = '5.5.5.5' |
| 807 | if df is None: |
| 808 | df = defer.Deferred() |
| 809 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 810 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 811 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 812 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 813 | mcastTraffic1.start() |
| 814 | join_state1 = IGMPTestState(groups = groups2) |
| 815 | target1 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
| 816 | log.info('Interface is receiving data from multicast groups, before bringing it down self.V_INF1=%s ' %self.V_INF1) |
| 817 | os.system('ifconfig '+self.V_INF1+' down') |
| 818 | log.info(' the self.V_INF1 %s is down now ' %self.V_INF1) |
| 819 | os.system('ifconfig '+self.V_INF1) |
| 820 | time.sleep(10) |
| 821 | #target1 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 822 | #assert target1==1, 'EXPECTED FAILURE' |
| 823 | #log.info('Interface is not receiving from multicast groups %s when we shutdown the subscriber interface ' %groups2) |
| 824 | os.system('ifconfig '+self.V_INF1+' up') |
| 825 | os.system('ifconfig '+self.V_INF1) |
| 826 | log.info(' the self.V_INF1 %s is up now ' %self.V_INF1) |
| 827 | #target1 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 828 | #assert target1==0, 'EXPECTED FAILURE' |
| 829 | #log.info('Interface is not receiving from multicast groups %s when we shutdown the subscriber interface ' %groups2) |
| 830 | target1 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
| 831 | log.info('Interface is receiving data from multicast groups %s when we bring up interface ' %groups2) |
| 832 | mcastTraffic1.stop() |
| 833 | self.onos_ctrl.deactivate() |
| 834 | |
| 835 | |
| 836 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 837 | def test_igmp_join_data_receiving_during_subscriber_link_down_up_functionality(self): |
| 838 | '''This test is sending join with source list A,B,C and exclude D,F,G with valid multicast group during receiving data shutdown the data receiving port ''' |
| 839 | df = defer.Deferred() |
| 840 | def igmp_join_data_receiving_during_subscriber_link_down_up_functionality(): |
| 841 | self.igmp_join_data_receiving_during_subscriber_link_down_up_functionality(df = df) |
| 842 | df.callback(0) |
| 843 | reactor.callLater(0, igmp_join_data_receiving_during_subscriber_link_down_up_functionality) |
| 844 | return df |
| 845 | |
| 846 | |
| 847 | def igmp_invalidClassDIP_join_packet_functionality(self, df = None): |
| 848 | groups1 = (self.MGROUP1,) |
| 849 | groups2 = (self.MINVALIDGROUP2,) |
| 850 | groups = groups1 + groups2 |
| 851 | ip_src = '1.1.1.1' |
| 852 | self.igmp_send_joins_different_groups_srclist(groups, |
| 853 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['5.5.5.5']), |
| 854 | intf = self.V_INF1, delay = 2, ip_src = ip_src) |
| 855 | ip_src = self.IP_SRC |
| 856 | dst_mac = '01:00:5e:02:02:03' |
| 857 | src_ip = '5.5.5.5' |
| 858 | if df is None: |
| 859 | df = defer.Deferred() |
| 860 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 861 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 862 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 863 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 864 | mcastTraffic1.start() |
| 865 | join_state1 = IGMPTestState(groups = groups2) |
| 866 | target1 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 867 | assert target1==1, 'EXPECTED FAILURE' |
| 868 | log.info('Interface is not receiving from multicast groups %s when we sent invalid join packet ' %groups2) |
| 869 | mcastTraffic1.stop() |
| 870 | self.onos_ctrl.deactivate() |
| 871 | |
| 872 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 873 | def test_igmp_invalidClassDIP_join_packet_functionality(self): |
| 874 | '''This test is sending invalid join with source list A,B,C and exclude D,F,G with multicast group as 239.255.255.255''' |
| 875 | df = defer.Deferred() |
| 876 | def igmp_invalidClassDIP_join_packet_functionality(): |
| 877 | self.igmp_invalidClassDIP_join_packet_functionality(df = df) |
| 878 | df.callback(0) |
| 879 | reactor.callLater(0, igmp_invalidClassDIP_join_packet_functionality) |
| 880 | return df |
| 881 | |
| 882 | def igmp_invalidClassDIP_as_srclistIP_join_packet_functionality(self, df = None): |
| 883 | groups1 = (self.MGROUP1,) |
| 884 | groups2 = (self.MGROUP2,) |
| 885 | groups = groups1 + groups2 |
| 886 | ip_src = '1.1.1.1' |
| 887 | self.igmp_send_joins_different_groups_srclist(groups, |
| 888 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['239.5.5.5']), |
| 889 | intf = self.V_INF1, delay = 2, ip_src = ip_src) |
| 890 | ip_src = self.IP_SRC |
| 891 | dst_mac = '01:00:5e:02:02:03' |
| 892 | src_ip = '5.5.5.5' |
| 893 | if df is None: |
| 894 | df = defer.Deferred() |
| 895 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 896 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 897 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 898 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 899 | mcastTraffic1.start() |
| 900 | join_state1 = IGMPTestState(groups = groups2) |
| 901 | target1 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 902 | assert target1==1, 'EXPECTED FAILURE' |
| 903 | log.info('Interface is not receiving from multicast groups %s when we sent invalid join packet ' %groups2) |
| 904 | mcastTraffic1.stop() |
| 905 | self.onos_ctrl.deactivate() |
| 906 | |
| 907 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 908 | def test_igmp_invalidClassDIP_as_srclistIP_join_packet_functionality(self): |
| 909 | '''This test is sending invalid join with source list A,B,C and exclude D,F,G with source list as 239.5.5.5''' |
| 910 | df = defer.Deferred() |
| 911 | def igmp_invalidClassDIP_as_srclistIP_join_packet_functionality(): |
| 912 | self.igmp_invalidClassDIP_as_srclistIP_join_packet_functionality(df = df) |
| 913 | df.callback(0) |
| 914 | reactor.callLater(0, igmp_invalidClassDIP_as_srclistIP_join_packet_functionality) |
| 915 | return df |