Chetan Gaonker | cb122cc | 2016-05-10 10:58:34 -0700 | [diff] [blame] | 1 | #!/usr/bin/env python |
Chetan Gaonker | cfcce78 | 2016-05-10 10:10:42 -0700 | [diff] [blame] | 2 | # |
| 3 | # Copyright 2016-present Ciena Corporation |
| 4 | # |
| 5 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | # you may not use this file except in compliance with the License. |
| 7 | # You may obtain a copy of the License at |
| 8 | # |
| 9 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | # |
| 11 | # Unless required by applicable law or agreed to in writing, software |
| 12 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | # See the License for the specific language governing permissions and |
| 15 | # limitations under the License. |
| 16 | # |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 17 | import unittest |
| 18 | from nose.tools import * |
| 19 | from nose.twistedtools import reactor, deferred |
| 20 | from twisted.internet import defer |
| 21 | from scapy.all import * |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 22 | import time, monotonic |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 23 | import os, sys |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 24 | import tempfile |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 25 | import random |
| 26 | import threading |
Chetan Gaonker | e88c95c | 2016-03-02 05:21:47 -0800 | [diff] [blame] | 27 | from IGMP import * |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 28 | from McastTraffic import * |
| 29 | from Stats import Stats |
Chetan Gaonker | 4a25e2b | 2016-03-04 14:45:15 -0800 | [diff] [blame] | 30 | from OnosCtrl import OnosCtrl |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 31 | from OltConfig import OltConfig |
Chetan Gaonker | 4eb1207 | 2016-03-28 15:04:15 -0700 | [diff] [blame] | 32 | from Channels import IgmpChannel |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 33 | log.setLevel('INFO') |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 34 | |
| 35 | class IGMPTestState: |
| 36 | |
| 37 | def __init__(self, groups = [], df = None, state = 0): |
| 38 | self.df = df |
| 39 | self.state = state |
| 40 | self.counter = 0 |
| 41 | self.groups = groups |
| 42 | self.group_map = {} ##create a send/recv count map |
| 43 | for g in groups: |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 44 | self.group_map[g] = (Stats(), Stats()) |
| 45 | |
| 46 | def update(self, group, tx = 0, rx = 0, t = 0): |
| 47 | self.counter += 1 |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 48 | index = 0 if rx == 0 else 1 |
| 49 | v = tx if rx == 0 else rx |
| 50 | if self.group_map.has_key(group): |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 51 | self.group_map[group][index].update(packets = v, t = t) |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 52 | |
| 53 | def update_state(self): |
| 54 | self.state = self.state ^ 1 |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 55 | |
| 56 | class igmp_exchange(unittest.TestCase): |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 57 | |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 58 | V_INF1 = 'veth0' |
| 59 | V_INF2 = 'veth1' |
| 60 | MGROUP1 = '239.1.2.3' |
| 61 | MGROUP2 = '239.2.2.3' |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 62 | MINVALIDGROUP1 = '255.255.255.255' |
| 63 | MINVALIDGROUP2 = '239.255.255.255' |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 64 | MMACGROUP1 = "01:00:5e:01:02:03" |
| 65 | MMACGROUP2 = "01:00:5e:02:02:03" |
| 66 | IGMP_DST_MAC = "01:00:5e:00:01:01" |
| 67 | IGMP_SRC_MAC = "5a:e1:ac:ec:4d:a1" |
| 68 | IP_SRC = '1.2.3.4' |
| 69 | IP_DST = '224.0.1.1' |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 70 | NEGATIVE_TRAFFIC_STATUS = 1 |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 71 | igmp_eth = Ether(dst = IGMP_DST_MAC, src = IGMP_SRC_MAC, type = ETH_P_IP) |
| 72 | igmp_ip = IP(dst = IP_DST, src = IP_SRC) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 73 | IGMP_TEST_TIMEOUT = 5 |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 74 | IGMP_QUERY_TIMEOUT = 60 |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 75 | MCAST_TRAFFIC_TIMEOUT = 10 |
Chetan Gaonker | 4eb1207 | 2016-03-28 15:04:15 -0700 | [diff] [blame] | 76 | PORT_TX_DEFAULT = 2 |
| 77 | PORT_RX_DEFAULT = 1 |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 78 | max_packets = 100 |
Chetan Gaonker | 4a25e2b | 2016-03-04 14:45:15 -0800 | [diff] [blame] | 79 | app = 'org.onosproject.igmp' |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 80 | olt_conf_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), '../setup/olt_config.json') |
Chetan Gaonker | 4a25e2b | 2016-03-04 14:45:15 -0800 | [diff] [blame] | 81 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 82 | @classmethod |
| 83 | def setUpClass(cls): |
| 84 | cls.olt = OltConfig(olt_conf_file = cls.olt_conf_file) |
| 85 | OnosCtrl.cord_olt_config(cls.olt.olt_device_data()) |
| 86 | |
| 87 | @classmethod |
| 88 | def tearDownClass(cls): pass |
| 89 | |
Chetan Gaonker | 4a25e2b | 2016-03-04 14:45:15 -0800 | [diff] [blame] | 90 | def setUp(self): |
| 91 | ''' Activate the dhcp app''' |
| 92 | self.onos_ctrl = OnosCtrl(self.app) |
| 93 | status, _ = self.onos_ctrl.activate() |
| 94 | assert_equal(status, True) |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 95 | time.sleep(2) |
Chetan Gaonker | 4eb1207 | 2016-03-28 15:04:15 -0700 | [diff] [blame] | 96 | self.igmp_channel = IgmpChannel() |
Chetan Gaonker | 4a25e2b | 2016-03-04 14:45:15 -0800 | [diff] [blame] | 97 | |
| 98 | def teardown(self): |
| 99 | '''Deactivate the dhcp app''' |
| 100 | self.onos_ctrl.deactivate() |
| 101 | |
| 102 | def onos_load_config(self, config): |
Chetan Gaonker | a2b87df | 2016-03-31 15:41:31 -0700 | [diff] [blame] | 103 | status, code = OnosCtrl.config(config) |
Chetan Gaonker | 4a25e2b | 2016-03-04 14:45:15 -0800 | [diff] [blame] | 104 | if status is False: |
| 105 | log.info('JSON request returned status %d' %code) |
| 106 | assert_equal(status, True) |
| 107 | time.sleep(2) |
| 108 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 109 | def onos_ssm_table_load(self, groups, src_list): |
| 110 | ssm_dict = {'apps' : { 'org.onosproject.igmp' : { 'ssmTranslate' : [] } } } |
| 111 | ssm_xlate_list = ssm_dict['apps']['org.onosproject.igmp']['ssmTranslate'] |
| 112 | for g in groups: |
| 113 | for s in src_list: |
| 114 | d = {} |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 115 | d['source'] = s or '0.0.0.0' |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 116 | d['group'] = g |
| 117 | ssm_xlate_list.append(d) |
Chetan Gaonker | 4a25e2b | 2016-03-04 14:45:15 -0800 | [diff] [blame] | 118 | self.onos_load_config(ssm_dict) |
Chetan Gaonker | 4eb1207 | 2016-03-28 15:04:15 -0700 | [diff] [blame] | 119 | cord_port_map = {} |
| 120 | for g in groups: |
| 121 | cord_port_map[g] = (self.PORT_TX_DEFAULT, self.PORT_RX_DEFAULT) |
| 122 | self.igmp_channel.cord_port_table_load(cord_port_map) |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 123 | time.sleep(2) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 124 | |
| 125 | def igmp_verify_join(self, igmpStateList): |
| 126 | sendState, recvState = igmpStateList |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 127 | ## check if the send is received for the groups |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 128 | for g in sendState.groups: |
| 129 | tx_stats = sendState.group_map[g][0] |
| 130 | tx = tx_stats.count |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 131 | assert_greater(tx, 0) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 132 | rx_stats = recvState.group_map[g][1] |
| 133 | rx = rx_stats.count |
| 134 | assert_greater(rx, 0) |
| 135 | log.info('Receive stats %s for group %s' %(rx_stats, g)) |
| 136 | |
| 137 | log.info('IGMP test verification success') |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 138 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 139 | def igmp_verify_leave(self, igmpStateList, leave_groups): |
| 140 | sendState, recvState = igmpStateList[0], igmpStateList[1] |
| 141 | ## check if the send is received for the groups |
| 142 | for g in sendState.groups: |
| 143 | tx_stats = sendState.group_map[g][0] |
| 144 | rx_stats = recvState.group_map[g][1] |
| 145 | tx = tx_stats.count |
| 146 | rx = rx_stats.count |
| 147 | assert_greater(tx, 0) |
| 148 | if g not in leave_groups: |
| 149 | log.info('Received %d packets for group %s' %(rx, g)) |
| 150 | for g in leave_groups: |
| 151 | rx = recvState.group_map[g][1].count |
| 152 | assert_equal(rx, 0) |
| 153 | |
| 154 | log.info('IGMP test verification success') |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 155 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 156 | def mcast_traffic_timer(self): |
| 157 | self.mcastTraffic.stopReceives() |
| 158 | |
| 159 | def send_mcast_cb(self, send_state): |
| 160 | for g in send_state.groups: |
| 161 | send_state.update(g, tx = 1) |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 162 | return 0 |
| 163 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 164 | ##Runs in the context of twisted reactor thread |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 165 | def igmp_recv(self, igmpState, iface = 'veth0'): |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 166 | p = self.recv_socket.recv() |
Chetan Gaonker | f1b9e32 | 2016-05-09 15:49:15 -0700 | [diff] [blame] | 167 | try: |
| 168 | send_time = float(p.payload.load) |
| 169 | recv_time = monotonic.monotonic() |
| 170 | except: |
| 171 | log.info('Unexpected Payload received: %s' %p.payload.load) |
| 172 | return 0 |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 173 | #log.info( 'Recv in %.6f secs' %(recv_time - send_time)) |
| 174 | igmpState.update(p.dst, rx = 1, t = recv_time - send_time) |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 175 | return 0 |
| 176 | |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 177 | 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] | 178 | self.onos_ssm_table_load(groups, src_list) |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 179 | igmp = IGMPv3(type = IGMP_TYPE_V3_MEMBERSHIP_REPORT, max_resp_code=30, |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 180 | gaddr=self.IP_DST) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 181 | for g in groups: |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 182 | gr = IGMPv3gr(rtype=IGMP_V3_GR_TYPE_EXCLUDE, mcaddr=g) |
| 183 | gr.sources = src_list |
| 184 | igmp.grps.append(gr) |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 185 | if ip_pkt is None: |
| 186 | ip_pkt = self.igmp_eth/self.igmp_ip |
| 187 | pkt = ip_pkt/igmp |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 188 | IGMPv3.fixup(pkt) |
| 189 | sendp(pkt, iface=iface) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 190 | if delay != 0: |
| 191 | time.sleep(delay) |
| 192 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 193 | def send_igmp_join_recvQuery(self, groups, rec_queryCount = None, src_list = ['1.2.3.4'], ip_pkt = None, iface = 'veth0', delay = 2): |
| 194 | self.onos_ssm_table_load(groups, src_list) |
| 195 | igmp = IGMPv3(type = IGMP_TYPE_V3_MEMBERSHIP_REPORT, max_resp_code=30, |
| 196 | gaddr=self.IP_DST) |
| 197 | for g in groups: |
| 198 | gr = IGMPv3gr(rtype=IGMP_V3_GR_TYPE_EXCLUDE, mcaddr=g) |
| 199 | gr.sources = src_list |
| 200 | gr.sources = src_list |
| 201 | igmp.grps.append(gr) |
| 202 | if ip_pkt is None: |
| 203 | ip_pkt = self.igmp_eth/self.igmp_ip |
| 204 | pkt = ip_pkt/igmp |
| 205 | IGMPv3.fixup(pkt) |
| 206 | if rec_queryCount == None: |
| 207 | log.info('Sending IGMP join for group %s and waiting for one query packet and printing the packet' %groups) |
| 208 | resp = srp1(pkt, iface=iface) |
| 209 | else: |
| 210 | log.info('Sending IGMP join for group %s and waiting for periodic query packets and printing one packet' %groups) |
| 211 | resp = srp3(pkt, iface=iface) |
| 212 | # resp = srp1(pkt, iface=iface) if rec_queryCount else srp3(pkt, iface=iface) |
| 213 | resp[0].summary() |
| 214 | log.info('Sent IGMP join for group %s and received a query packet and printing packet' %groups) |
| 215 | if delay != 0: |
| 216 | time.sleep(delay) |
| 217 | |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 218 | 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] | 219 | igmp = IGMPv3(type = IGMP_TYPE_V3_MEMBERSHIP_REPORT, max_resp_code=30, |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 220 | gaddr=self.IP_DST) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 221 | for g in groups: |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 222 | gr = IGMPv3gr(rtype=IGMP_V3_GR_TYPE_INCLUDE, mcaddr=g) |
| 223 | gr.sources = src_list |
| 224 | igmp.grps.append(gr) |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 225 | if ip_pkt is None: |
| 226 | ip_pkt = self.igmp_eth/self.igmp_ip |
| 227 | pkt = ip_pkt/igmp |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 228 | IGMPv3.fixup(pkt) |
| 229 | sendp(pkt, iface = iface) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 230 | if delay != 0: |
| 231 | time.sleep(delay) |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 232 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 233 | def send_igmp_leave_listening_group_specific_query(self, groups, src_list = ['1.2.3.4'], ip_pkt = None, iface = 'veth0', delay = 2): |
| 234 | igmp = IGMPv3(type = IGMP_TYPE_V3_MEMBERSHIP_REPORT, max_resp_code=30, |
| 235 | gaddr=self.IP_DST) |
| 236 | for g in groups: |
| 237 | gr = IGMPv3gr(rtype=IGMP_V3_GR_TYPE_INCLUDE, mcaddr=g) |
| 238 | gr.sources = src_list |
| 239 | igmp.grps.append(gr) |
| 240 | if ip_pkt is None: |
| 241 | ip_pkt = self.igmp_eth/self.igmp_ip |
| 242 | pkt = ip_pkt/igmp |
| 243 | IGMPv3.fixup(pkt) |
| 244 | log.info('Sending IGMP leave for group %s and waiting for one group specific query packet and printing the packet' %groups) |
| 245 | resp = srp1(pkt, iface=iface) |
| 246 | resp[0].summary() |
| 247 | log.info('Sent IGMP leave for group %s and received a group specific query packet and printing packet' %groups) |
| 248 | if delay != 0: |
| 249 | time.sleep(delay) |
| 250 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 251 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+10) |
| 252 | def test_igmp_join_verify_traffic(self): |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 253 | groups = ['224.0.1.1', '225.0.0.1'] |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 254 | df = defer.Deferred() |
| 255 | igmpState = IGMPTestState(groups = groups, df = df) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 256 | igmpStateRecv = IGMPTestState(groups = groups, df = df) |
| 257 | igmpStateList = (igmpState, igmpStateRecv) |
| 258 | mcastTraffic = McastTraffic(groups, iface= 'veth2', cb = self.send_mcast_cb, arg = igmpState) |
| 259 | self.df = df |
| 260 | self.mcastTraffic = mcastTraffic |
| 261 | self.recv_socket = L3PacketSocket(iface = 'veth0', type = ETH_P_IP) |
| 262 | |
| 263 | def igmp_srp_task(stateList): |
| 264 | igmpSendState, igmpRecvState = stateList |
| 265 | if not mcastTraffic.isRecvStopped(): |
| 266 | result = self.igmp_recv(igmpRecvState) |
| 267 | reactor.callLater(0, igmp_srp_task, stateList) |
| 268 | else: |
| 269 | self.mcastTraffic.stop() |
| 270 | self.recv_socket.close() |
| 271 | self.igmp_verify_join(stateList) |
| 272 | self.df.callback(0) |
| 273 | |
| 274 | self.send_igmp_join(groups) |
| 275 | mcastTraffic.start() |
| 276 | self.test_timer = reactor.callLater(self.MCAST_TRAFFIC_TIMEOUT, self.mcast_traffic_timer) |
| 277 | reactor.callLater(0, igmp_srp_task, igmpStateList) |
Chetan Gaonker | 2547097 | 2016-02-26 08:52:15 -0800 | [diff] [blame] | 278 | return df |
| 279 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 280 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+10) |
| 281 | def test_igmp_leave_verify_traffic(self): |
| 282 | groups = ['224.0.1.10', '225.0.0.10'] |
| 283 | leave_groups = ['224.0.1.10'] |
| 284 | df = defer.Deferred() |
| 285 | igmpState = IGMPTestState(groups = groups, df = df) |
| 286 | igmpStateRecv = IGMPTestState(groups = groups, df = df) |
| 287 | igmpStateList = (igmpState, igmpStateRecv) |
| 288 | mcastTraffic = McastTraffic(groups, iface= 'veth2', cb = self.send_mcast_cb, |
| 289 | arg = igmpState) |
| 290 | self.df = df |
| 291 | self.mcastTraffic = mcastTraffic |
| 292 | self.recv_socket = L3PacketSocket(iface = 'veth0', type = ETH_P_IP) |
| 293 | |
| 294 | def igmp_srp_task(stateList): |
| 295 | igmpSendState, igmpRecvState = stateList |
| 296 | if not mcastTraffic.isRecvStopped(): |
| 297 | result = self.igmp_recv(igmpRecvState) |
| 298 | reactor.callLater(0, igmp_srp_task, stateList) |
| 299 | else: |
| 300 | self.mcastTraffic.stop() |
| 301 | self.recv_socket.close() |
| 302 | self.igmp_verify_leave(stateList, leave_groups) |
| 303 | self.df.callback(0) |
| 304 | |
| 305 | self.send_igmp_join(groups) |
| 306 | self.send_igmp_leave(leave_groups, delay = 3) |
| 307 | mcastTraffic.start() |
| 308 | self.test_timer = reactor.callLater(self.MCAST_TRAFFIC_TIMEOUT, self.mcast_traffic_timer) |
| 309 | reactor.callLater(0, igmp_srp_task, igmpStateList) |
| 310 | return df |
| 311 | |
| 312 | @deferred(timeout=100) |
| 313 | def test_igmp_leave_join_loop(self): |
| 314 | self.groups = ['226.0.1.1', '227.0.0.1', '228.0.0.1', '229.0.0.1', '230.0.0.1' ] |
| 315 | self.src_list = ['3.4.5.6', '7.8.9.10'] |
| 316 | df = defer.Deferred() |
| 317 | self.df = df |
| 318 | self.iterations = 0 |
| 319 | self.num_groups = len(self.groups) |
| 320 | self.MAX_TEST_ITERATIONS = 10 |
| 321 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 322 | def igmp_srp_task(v): |
| 323 | if self.iterations < self.MAX_TEST_ITERATIONS: |
| 324 | if v == 1: |
| 325 | ##join test |
| 326 | self.num_groups = random.randint(0, len(self.groups)) |
| 327 | self.send_igmp_join(self.groups[:self.num_groups], |
| 328 | src_list = self.src_list, |
| 329 | iface = 'veth0', delay = 0) |
| 330 | else: |
| 331 | self.send_igmp_leave(self.groups[:self.num_groups], |
| 332 | src_list = self.src_list, |
| 333 | iface = 'veth0', delay = 0) |
| 334 | self.iterations += 1 |
| 335 | v ^= 1 |
| 336 | reactor.callLater(1.0 + 0.5*self.num_groups, |
| 337 | igmp_srp_task, v) |
| 338 | else: |
| 339 | self.df.callback(0) |
| 340 | |
| 341 | reactor.callLater(0, igmp_srp_task, 1) |
| 342 | return df |
| 343 | |
| 344 | def igmp_join_task(self, intf, groups, state, src_list = ['1.2.3.4']): |
| 345 | self.onos_ssm_table_load(groups, src_list) |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 346 | igmp = IGMPv3(type = IGMP_TYPE_V3_MEMBERSHIP_REPORT, max_resp_code=30, |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 347 | gaddr=self.IP_DST) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 348 | for g in groups: |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 349 | gr = IGMPv3gr(rtype = IGMP_V3_GR_TYPE_EXCLUDE, mcaddr = g) |
| 350 | gr.sources = src_list |
| 351 | igmp.grps.append(gr) |
| 352 | |
| 353 | for g in groups: |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 354 | state.group_map[g][0].update(1, t = monotonic.monotonic()) |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 355 | |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 356 | pkt = self.igmp_eth/self.igmp_ip/igmp |
Chetan Gaonker | 5a5204e | 2016-03-02 01:35:13 -0800 | [diff] [blame] | 357 | IGMPv3.fixup(pkt) |
| 358 | sendp(pkt, iface=intf) |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 359 | log.debug('Returning from join task') |
| 360 | |
| 361 | def igmp_recv_task(self, intf, groups, join_state): |
| 362 | recv_socket = L3PacketSocket(iface = intf, type = ETH_P_IP) |
| 363 | group_map = {} |
| 364 | for g in groups: |
| 365 | group_map[g] = [0,0] |
| 366 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 367 | log.info('Verifying join interface should receive multicast data') |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 368 | while True: |
| 369 | p = recv_socket.recv() |
| 370 | if p.dst in groups and group_map[p.dst][0] == 0: |
| 371 | group_map[p.dst][0] += 1 |
| 372 | group_map[p.dst][1] = monotonic.monotonic() |
| 373 | c = 0 |
| 374 | for g in groups: |
| 375 | c += group_map[g][0] |
| 376 | if c == len(groups): |
| 377 | break |
| 378 | for g in groups: |
| 379 | join_start = join_state.group_map[g][0].start |
| 380 | recv_time = group_map[g][1] * 1000000 |
| 381 | delta = (recv_time - join_start) |
| 382 | log.info('Join for group %s received in %.3f usecs' % |
| 383 | (g, delta)) |
| 384 | |
| 385 | recv_socket.close() |
| 386 | log.debug('Returning from recv task') |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 387 | |
| 388 | def igmp_not_recv_task(self, intf, groups, join_state): |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 389 | global NEGATIVE_TRAFFIC_STATUS |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 390 | recv_socket = L2Socket(iface = intf, type = ETH_P_IP) |
| 391 | group_map = {} |
| 392 | for g in groups: |
| 393 | group_map[g] = [0,0] |
| 394 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 395 | log.info('Verifying join interface should not receive any multicast data') |
| 396 | NEGATIVE_TRAFFIC_STATUS = 1 |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 397 | def igmp_recv_cb(pkt): |
| 398 | log.info('Multicast packet %s received for left groups %s' %(pkt[IP].dst, groups)) |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 399 | global NEGATIVE_TRAFFIC_STATUS |
| 400 | NEGATIVE_TRAFFIC_STATUS = 2 |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 401 | sniff(prn = igmp_recv_cb, count = 1, lfilter = lambda p: p[IP].dst in groups, |
| 402 | timeout = 3, opened_socket = recv_socket) |
| 403 | recv_socket.close() |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 404 | return NEGATIVE_TRAFFIC_STATUS |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 405 | |
Chetan Gaonker | eb2b24b | 2016-03-01 14:04:45 -0800 | [diff] [blame] | 406 | def group_latency_check(self, groups): |
| 407 | tasks = [] |
| 408 | self.send_igmp_leave(groups = groups) |
| 409 | join_state = IGMPTestState(groups = groups) |
| 410 | tasks.append(threading.Thread(target=self.igmp_join_task, args = ('veth0', groups, join_state,))) |
| 411 | traffic_state = IGMPTestState(groups = groups) |
| 412 | mcast_traffic = McastTraffic(groups, iface= 'veth2', cb = self.send_mcast_cb, |
| 413 | arg = traffic_state) |
| 414 | mcast_traffic.start() |
| 415 | tasks.append(threading.Thread(target=self.igmp_recv_task, args = ('veth0', groups, join_state))) |
| 416 | for t in tasks: |
| 417 | t.start() |
| 418 | for t in tasks: |
| 419 | t.join() |
| 420 | |
| 421 | mcast_traffic.stop() |
| 422 | self.send_igmp_leave(groups = groups) |
| 423 | return |
| 424 | |
| 425 | def test_igmp_1group_join_latency(self): |
| 426 | groups = ['239.0.1.1'] |
| 427 | self.group_latency_check(groups) |
| 428 | |
| 429 | def test_igmp_2group_join_latency(self): |
| 430 | groups = ['239.0.1.1', '240.0.1.1'] |
| 431 | self.group_latency_check(groups) |
| 432 | |
| 433 | def test_igmp_Ngroup_join_latency(self): |
| 434 | groups = ['239.0.1.1', '240.0.1.1', '241.0.1.1', '242.0.1.1'] |
| 435 | self.group_latency_check(groups) |
| 436 | |
| 437 | |
Chetan Gaonker | 1f7c3f8 | 2016-03-08 12:17:37 -0800 | [diff] [blame] | 438 | def test_igmp_join_rover(self): |
| 439 | '''Keep sending joins across multicast range of addresses''' |
| 440 | '''For now, restricting it to 50/100''' |
| 441 | s = (224 << 24) | 1 |
| 442 | #e = (225 << 24) | (255 << 16) | (255 << 16) | 255 |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 443 | e = (224 << 24) | 10 |
Chetan Gaonker | 1f7c3f8 | 2016-03-08 12:17:37 -0800 | [diff] [blame] | 444 | for i in xrange(s, e+1): |
| 445 | if i&0xff: |
| 446 | ip = '%d.%d.%d.%d'%((i>>24)&0xff, (i>>16)&0xff, (i>>8)&0xff, i&0xff) |
| 447 | self.send_igmp_join([ip], delay = 0) |
| 448 | |
| 449 | @deferred(timeout=IGMP_QUERY_TIMEOUT + 10) |
| 450 | def test_igmp_query(self): |
| 451 | groups = ['224.0.0.1'] ##igmp query group |
| 452 | df = defer.Deferred() |
| 453 | self.df = df |
| 454 | self.recv_socket = L2Socket(iface = 'veth0', type = ETH_P_IP) |
| 455 | |
| 456 | def igmp_query_timeout(): |
Chetan Gaonker | 1f7c3f8 | 2016-03-08 12:17:37 -0800 | [diff] [blame] | 457 | def igmp_query_cb(pkt): |
Chetan Gaonker | bd4390f | 2016-03-09 18:56:52 -0800 | [diff] [blame] | 458 | log.info('Got IGMP query packet from %s for %s' %(pkt[IP].src, pkt[IP].dst)) |
| 459 | assert_equal(pkt[IP].dst, '224.0.0.1') |
| 460 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 461 | sniff(prn = igmp_query_cb, count=1, lfilter = lambda p: IP in p and p[IP].dst in groups, |
Chetan Gaonker | bd4390f | 2016-03-09 18:56:52 -0800 | [diff] [blame] | 462 | opened_socket = self.recv_socket) |
Chetan Gaonker | 1f7c3f8 | 2016-03-08 12:17:37 -0800 | [diff] [blame] | 463 | self.recv_socket.close() |
| 464 | self.df.callback(0) |
| 465 | |
| 466 | self.send_igmp_join(groups) |
| 467 | self.test_timer = reactor.callLater(self.IGMP_QUERY_TIMEOUT, igmp_query_timeout) |
| 468 | return df |
| 469 | |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 470 | def igmp_send_joins_different_groups_srclist(self, groups, sources, intf = V_INF1, delay = 2, ip_src = None): |
| 471 | g1 = groups[0] |
| 472 | g2 = groups[1] |
| 473 | sourcelist1 = sources[0] |
| 474 | sourcelist2 = sources[1] |
| 475 | eth = Ether(dst = self.MMACGROUP1, src = self.IGMP_SRC_MAC, type = ETH_P_IP) |
| 476 | src_ip = ip_src or self.IP_SRC |
| 477 | ip = IP(dst = g1, src = src_ip) |
| 478 | log.info('Sending join message for the group %s' %g1) |
| 479 | self.send_igmp_join((g1,), src_list = sourcelist1, ip_pkt = eth/ip, iface = intf, delay = 2) |
| 480 | eth = Ether(dst = self.MMACGROUP2, src = self.IGMP_SRC_MAC, type = ETH_P_IP) |
| 481 | ip = IP(dst = g2, src = src_ip) |
| 482 | log.info('Sending join message for group %s' %g2) |
| 483 | self.send_igmp_join((g2,), src_list = sourcelist2, ip_pkt = eth/ip, iface = intf, delay = 2) |
| 484 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 485 | def igmp_send_joins_different_groups_srclist_wait_query_packets(self, groups, sources, intf = V_INF1, delay = 2, ip_src = None, query_group1 = None, query_group2 = None): |
| 486 | g1 = groups[0] |
| 487 | g2 = groups[1] |
| 488 | sourcelist1 = sources[0] |
| 489 | sourcelist2 = sources[1] |
| 490 | eth = Ether(dst = self.MMACGROUP1, src = self.IGMP_SRC_MAC, type = ETH_P_IP) |
| 491 | src_ip = ip_src or self.IP_SRC |
| 492 | ip = IP(dst = g1, src = src_ip) |
| 493 | if query_group1 is 'group1': |
| 494 | log.info('Sending join message for the group %s and waiting for a query packet on join interface' %g1) |
| 495 | self.send_igmp_join_recvQuery((g1,), None, src_list = sourcelist1, ip_pkt = eth/ip, iface = intf, delay = 2) |
| 496 | else: |
| 497 | log.info('Sending join message for the group %s' %g1) |
| 498 | self.send_igmp_join((g1,), src_list = sourcelist1, ip_pkt = eth/ip, iface = intf, delay = 2) |
| 499 | eth = Ether(dst = self.MMACGROUP2, src = self.IGMP_SRC_MAC, type = ETH_P_IP) |
| 500 | ip = IP(dst = g2, src = src_ip) |
| 501 | if query_group2 is 'group2': |
| 502 | log.info('Sending join message for the group %s and waiting for a query packet on join interface' %g2) |
| 503 | self.send_igmp_join_recvQuery((g2,), None, src_list = sourcelist2, ip_pkt = eth/ip, iface = intf, delay = 2) |
| 504 | else: |
| 505 | log.info('Sending join message for group %s' %g2) |
| 506 | self.send_igmp_join((g2,), src_list = sourcelist2, ip_pkt = eth/ip, iface = intf, delay = 2) |
| 507 | |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 508 | def igmp_joins_leave_functionality(self, again_join = False, df = None): |
| 509 | groups1 = (self.MGROUP1,) |
| 510 | groups2 = (self.MGROUP2,) |
| 511 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 512 | (['2.2.2.2'], ['2.2.2.2']), intf = self.V_INF1, delay = 2) |
| 513 | dst_mac = '01:00:5e:01:02:03' |
| 514 | src_ip = '2.2.2.2' |
| 515 | if df is None: |
| 516 | df = defer.Deferred() |
| 517 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 518 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 519 | igmpStateList1 = (igmpState1, igmpStateRecv1) |
| 520 | |
| 521 | igmpState2 = IGMPTestState(groups = groups2, df = df) |
| 522 | igmpStateRecv2 = IGMPTestState(groups = groups2, df = df) |
| 523 | igmpStateList2 = (igmpState2, igmpStateRecv2) |
| 524 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 525 | src_ip = src_ip, cb = self.send_mcast_cb, |
| 526 | arg = igmpState1) |
| 527 | dst_mac = '01:00:5e:02:02:03' |
| 528 | src_ip = '2.2.2.2' |
| 529 | mcastTraffic2 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 530 | src_ip = src_ip, cb = self.send_mcast_cb, |
| 531 | arg = igmpState2) |
| 532 | mcastTraffic1.start() |
| 533 | mcastTraffic2.start() |
| 534 | join_state1 = IGMPTestState(groups = groups1) |
| 535 | join_state2 = IGMPTestState(groups = groups2) |
| 536 | target1 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 537 | log.info('Interface is receiving multicast groups %s' %groups1) |
| 538 | target2 = self.igmp_recv_task(self.V_INF1, groups2, join_state2) |
| 539 | log.info('Interface is receiving multicast groups %s' %groups2) |
| 540 | log.info('Interface is sending leave message for groups %s now' %groups2) |
| 541 | self.send_igmp_leave(groups = groups2, src_list = ['2.2.2.2'], iface = self.V_INF1, delay = 2) |
| 542 | target3 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 543 | target4 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state2) |
| 544 | assert target4 == 1, 'EXPECTED FAILURE' |
| 545 | if again_join: |
| 546 | dst_mac = '01:00:5e:02:02:03' |
| 547 | ip_dst = '239.2.2.3' |
| 548 | eth = Ether(dst = dst_mac, src = self.IGMP_SRC_MAC, type = ETH_P_IP) |
| 549 | ip = IP(dst = ip_dst, src = self.IP_SRC) |
| 550 | log.info('Interface sending join message again for the groups %s' %groups2) |
| 551 | self.send_igmp_join(groups2, src_list = [src_ip], ip_pkt = eth/ip, iface = self.V_INF1, delay = 2) |
| 552 | target5 = self.igmp_recv_task(self.V_INF1, groups2, join_state2) |
| 553 | log.info('Interface is receiving multicast groups %s again' %groups2) |
| 554 | target6 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 555 | log.info('Interface is still receiving from multicast groups %s' %groups1) |
| 556 | else: |
| 557 | log.info('Ended test case') |
| 558 | mcastTraffic1.stop() |
| 559 | mcastTraffic2.stop() |
| 560 | self.onos_ctrl.deactivate() |
| 561 | |
| 562 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 563 | def test_igmp_2joins_1leave_functionality(self): |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 564 | ## '''This test is subscribing to two channels and sending leave for one channel''' |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 565 | df = defer.Deferred() |
| 566 | def test_igmp_2joins_1leave(): |
| 567 | self.igmp_joins_leave_functionality(again_join = False, df = df) |
| 568 | df.callback(0) |
| 569 | reactor.callLater(0, test_igmp_2joins_1leave) |
| 570 | return df |
| 571 | |
| 572 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+25) |
| 573 | def test_igmp_2joins_1leave_again_joins_functionality(self): |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 574 | ## '''This test is subscribing to two channels and sending leave for one channel,again join to the same group''' |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 575 | df = defer.Deferred() |
| 576 | def test_igmp_2joins_1leave_join_again(): |
| 577 | self.igmp_joins_leave_functionality(again_join = True, df = df) |
| 578 | df.callback(0) |
| 579 | reactor.callLater(0, test_igmp_2joins_1leave_join_again) |
| 580 | return df |
| 581 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 582 | def igmp_not_in_src_list_functionality(self, df = None): |
| 583 | ## '''This test is sending multicast data from source 6.6.6.6 which is not in joins report ''' |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 584 | groups1 = (self.MGROUP1,) |
| 585 | groups2 = (self.MGROUP2,) |
| 586 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 587 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 588 | intf = self.V_INF1, delay = 2) |
| 589 | dst_mac = '01:00:5e:01:02:03' |
| 590 | src_ip = '6.6.6.6' |
| 591 | if df is None: |
| 592 | df = defer.Deferred() |
| 593 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 594 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 595 | mcastTraffic1 = McastTraffic(groups1, iface = 'veth2', dst_mac = dst_mac, |
| 596 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 597 | mcastTraffic1.start() |
| 598 | join_state1 = IGMPTestState(groups = groups1) |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 599 | log.info('Interface should not receive from multicast groups %s from an interface, which is expected' %groups1) |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 600 | target1 = self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 601 | assert target1 == 1, 'EXPECTED FAILURE' |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 602 | log.info('Interface is not receiving from multicast groups %s, working as expected' %groups1) |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 603 | mcastTraffic1.stop() |
| 604 | self.onos_ctrl.deactivate() |
| 605 | |
| 606 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 607 | def test_igmp_not_in_src_list_functionality(self): |
| 608 | ## '''This test is sending multicast data from source 6.6.6.6 which is not in joins report ''' |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 609 | df = defer.Deferred() |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 610 | def igmp_not_in_src_list_functionality(): |
| 611 | self.igmp_not_in_src_list_functionality(df = df) |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 612 | df.callback(0) |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 613 | reactor.callLater(0, igmp_not_in_src_list_functionality) |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 614 | return df |
| 615 | |
| 616 | def igmp_change_to_exclude_src_list_functionality(self, df = None): |
| 617 | groups1 = (self.MGROUP1,) |
| 618 | groups2 = (self.MGROUP2,) |
| 619 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 620 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 621 | intf = self.V_INF1, delay = 2) |
| 622 | dst_mac = '01:00:5e:01:02:03' |
| 623 | src_ip = '2.2.2.2' |
| 624 | if df is None: |
| 625 | df = defer.Deferred() |
| 626 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 627 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 628 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 629 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 630 | mcastTraffic1.start() |
| 631 | join_state1 = IGMPTestState(groups = groups1) |
| 632 | target1 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 633 | self.send_igmp_leave(groups = groups1, src_list = ['2.2.2.2'], iface = self.V_INF1, delay =2) |
| 634 | target2 = self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 635 | assert target2 == 1, 'EXPECTED FAILURE' |
| 636 | log.info('Interface is not receiving from multicast groups %s after sending CHANGE_TO_EXCLUDE' %groups1) |
| 637 | mcastTraffic1.stop() |
| 638 | self.onos_ctrl.deactivate() |
| 639 | |
| 640 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+10) |
| 641 | def test_igmp_change_to_exclude_src_list_functionality(self): |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 642 | ## '''This test is checking that change to exclude source list functionality ''' |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 643 | df = defer.Deferred() |
| 644 | def igmp_change_to_exclude_src_list_functionality(): |
| 645 | self.igmp_change_to_exclude_src_list_functionality(df = df) |
| 646 | df.callback(0) |
| 647 | reactor.callLater(0, igmp_change_to_exclude_src_list_functionality) |
| 648 | return df |
| 649 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 650 | def igmp_include_to_allow_src_list_functionality(self, df = None): |
| 651 | groups1 = (self.MGROUP1,) |
| 652 | groups2 = (self.MGROUP2,) |
| 653 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 654 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 655 | intf = self.V_INF1, delay = 2) |
| 656 | dst_mac = '01:00:5e:01:02:03' |
| 657 | src_ip = '2.2.2.2' |
| 658 | if df is None: |
| 659 | df = defer.Deferred() |
| 660 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 661 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 662 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 663 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 664 | mcastTraffic1.start() |
| 665 | join_state1 = IGMPTestState(groups = groups1) |
| 666 | target1 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 667 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 668 | (['2.2.2.2', '3.3.3.3', '4.4.4.4', '6.6.6.6'], ['2.2.2.2', '5.5.5.5']), |
| 669 | intf = self.V_INF1, delay = 2) |
| 670 | target1 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 671 | mcastTraffic1.stop() |
| 672 | self.onos_ctrl.deactivate() |
| 673 | |
| 674 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+30) |
| 675 | def test_igmp_include_to_allow_src_list_functionality(self): |
| 676 | '''Verify join INCLUDE (A) and Allow(B) from both A and B source list should receive multicast traffic. ''' |
| 677 | df = defer.Deferred() |
| 678 | def igmp_include_to_allow_src_list_functionality(): |
| 679 | self.igmp_include_to_allow_src_list_functionality(df = df) |
| 680 | df.callback(0) |
| 681 | reactor.callLater(0, igmp_include_to_allow_src_list_functionality) |
| 682 | return df |
| 683 | |
| 684 | def igmp_include_to_block_src_list_functionality(self, df = None): |
| 685 | groups1 = (self.MGROUP1,) |
| 686 | groups2 = (self.MGROUP2,) |
| 687 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 688 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 689 | intf = self.V_INF1, delay = 2) |
| 690 | dst_mac = '01:00:5e:01:02:03' |
| 691 | src_ip = '2.2.2.2' |
| 692 | if df is None: |
| 693 | df = defer.Deferred() |
| 694 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 695 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 696 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 697 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 698 | mcastTraffic1.start() |
| 699 | join_state1 = IGMPTestState(groups = groups1) |
| 700 | target1 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 701 | self.send_igmp_leave(groups = groups1, src_list = ['6.6.6.6','7.7.7.7'], |
| 702 | iface = self.V_INF1, delay = 2) |
| 703 | target1 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 704 | log.info('Interface is still receiving from old multicast group data %s even after we send bolck list' %groups1) |
| 705 | mcastTraffic1.stop() |
| 706 | self.onos_ctrl.deactivate() |
| 707 | |
| 708 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+30) |
| 709 | def test_igmp_include_to_block_src_list_functionality(self): |
| 710 | '''Verify join INCLUDE (A) and Block(B) from A source list, should receive multicast traffic.''' |
| 711 | df = defer.Deferred() |
| 712 | def igmp_include_to_block_src_list_functionality(): |
| 713 | self.igmp_include_to_block_src_list_functionality(df = df) |
| 714 | df.callback(0) |
| 715 | reactor.callLater(0, igmp_include_to_block_src_list_functionality) |
| 716 | return df |
| 717 | |
| 718 | |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 719 | def igmp_change_to_include_src_list_functionality(self, df = None): |
| 720 | groups1 = (self.MGROUP1,) |
| 721 | groups2 = (self.MGROUP2,) |
| 722 | self.send_igmp_leave(groups = groups1, src_list = ['2.2.2.2', '3.3.3.3', '4.4.4.4'], |
| 723 | iface = self.V_INF1, delay = 2) |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 724 | |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 725 | dst_mac = '01:00:5e:01:02:03' |
| 726 | src_ip = '2.2.2.2' |
| 727 | if df is None: |
| 728 | df = defer.Deferred() |
| 729 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 730 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 731 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 732 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 733 | mcastTraffic1.start() |
| 734 | join_state1 = IGMPTestState(groups = groups1) |
| 735 | target1= self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 736 | assert target1 == 1, 'EXPECTED FAILURE' |
| 737 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 738 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 739 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['6.6.6.6', '5.5.5.5']), |
| 740 | intf = self.V_INF1, delay = 2) |
| 741 | target2 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 742 | log.info('Interface is receiving from multicast groups %s after send Change to include message' %groups1) |
| 743 | mcastTraffic1.stop() |
| 744 | self.onos_ctrl.deactivate() |
| 745 | |
| 746 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+10) |
| 747 | def test_igmp_change_to_include_src_list_functionality(self): |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 748 | ## '''This test is checking that change to include source list functionality ''' |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 749 | df = defer.Deferred() |
| 750 | def igmp_change_to_include_src_list_functionality(): |
| 751 | self.igmp_change_to_include_src_list_functionality(df = df) |
| 752 | df.callback(0) |
| 753 | reactor.callLater(0, igmp_change_to_include_src_list_functionality) |
| 754 | return df |
| 755 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 756 | def igmp_exclude_to_allow_src_list_functionality(self, df = None): |
| 757 | groups1 = (self.MGROUP1,) |
| 758 | groups2 = (self.MGROUP2,) |
| 759 | self.send_igmp_leave(groups = groups1, src_list = ['2.2.2.2', '3.3.3.3', '4.4.4.4'], |
| 760 | iface = self.V_INF1, delay = 2) |
| 761 | |
| 762 | dst_mac = '01:00:5e:01:02:03' |
| 763 | src_ip = '2.2.2.2' |
| 764 | if df is None: |
| 765 | df = defer.Deferred() |
| 766 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 767 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 768 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 769 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 770 | mcastTraffic1.start() |
| 771 | join_state1 = IGMPTestState(groups = groups1) |
| 772 | target1= self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 773 | assert target1 == 1, 'EXPECTED FAILURE' |
| 774 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 775 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 776 | (['6.6.6.6', '7.7.7.7', '8.8.8.8'], ['6.6.6.6', '5.5.5.5']), |
| 777 | intf = self.V_INF1, delay = 2) |
| 778 | target1= self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 779 | assert target1 == 1, 'EXPECTED FAILURE' |
| 780 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 781 | mcastTraffic1.stop() |
| 782 | self.onos_ctrl.deactivate() |
| 783 | |
| 784 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+10) |
| 785 | def test_igmp_exclude_to_allow_src_list_functionality(self): |
| 786 | '''Verify join EXCLUDE(A) and Allow(B) from both A and B source list, should receive multicast traffic. ''' |
| 787 | df = defer.Deferred() |
| 788 | def igmp_exclude_to_allow_src_list_functionality(): |
| 789 | self.igmp_exclude_to_allow_src_list_functionality(df = df) |
| 790 | df.callback(0) |
| 791 | reactor.callLater(0, igmp_exclude_to_allow_src_list_functionality) |
| 792 | return df |
| 793 | |
| 794 | def igmp_exclude_to_block_src_list_functionality(self, df = None): |
| 795 | groups1 = (self.MGROUP1,) |
| 796 | groups2 = (self.MGROUP2,) |
| 797 | self.send_igmp_leave(groups = groups1, src_list = ['2.2.2.2', '3.3.3.3', '4.4.4.4'], |
| 798 | iface = self.V_INF1, delay = 2) |
| 799 | |
| 800 | dst_mac = '01:00:5e:01:02:03' |
| 801 | src_ip = '2.2.2.2' |
| 802 | if df is None: |
| 803 | df = defer.Deferred() |
| 804 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 805 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 806 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 807 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 808 | mcastTraffic1.start() |
| 809 | join_state1 = IGMPTestState(groups = groups1) |
| 810 | target1= self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 811 | assert target1 == 1, 'EXPECTED FAILURE' |
| 812 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 813 | self.send_igmp_leave(groups = groups1, src_list = ['2.2.2.2', '3.3.3.3', '4.4.4.4', '5.5.5.5', '7.7.7.7'], |
| 814 | iface = self.V_INF1, delay = 2) |
| 815 | target1= self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 816 | assert target1 == 1, 'EXPECTED FAILURE' |
| 817 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 818 | mcastTraffic1.stop() |
| 819 | self.onos_ctrl.deactivate() |
| 820 | |
| 821 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+10) |
| 822 | def test_igmp_exclude_to_block_src_list_functionality(self): |
| 823 | ''' Verify join EXCLUDE (A) and Block(B) from A source list, should receive multicast traffic. ''' |
| 824 | df = defer.Deferred() |
| 825 | def igmp_exclude_to_block_src_list_functionality(): |
| 826 | self.igmp_exclude_to_block_src_list_functionality(df = df) |
| 827 | df.callback(0) |
| 828 | reactor.callLater(0, igmp_exclude_to_block_src_list_functionality) |
| 829 | return df |
| 830 | |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 831 | def igmp_new_src_list_functionality(self, df = None): |
| 832 | groups1 = (self.MGROUP1,) |
| 833 | groups2 = (self.MGROUP2,) |
| 834 | self.igmp_send_joins_different_groups_srclist(groups1+groups2, |
| 835 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 836 | intf = self.V_INF1, delay = 2) |
| 837 | dst_mac = '01:00:5e:01:02:03' |
| 838 | src_ip = '6.6.6.6' |
| 839 | if df is None: |
| 840 | df = defer.Deferred() |
| 841 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 842 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 843 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 844 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 845 | mcastTraffic1.start() |
| 846 | join_state1 = IGMPTestState(groups = groups1) |
| 847 | target1 = self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 848 | assert target1 == 1, 'EXPECTED FAILURE' |
| 849 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 850 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 851 | (['2.2.2.2', '6.6.6.6', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 852 | intf = self.V_INF1, delay = 2) |
| 853 | target2 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 854 | log.info('Interface is receiving from multicast groups %s after sending join with new source list' %groups1) |
| 855 | mcastTraffic1.stop() |
| 856 | self.onos_ctrl.deactivate() |
| 857 | |
| 858 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+10) |
| 859 | def test_igmp_new_src_list_functionality(self): |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 860 | ## '''This test is checking that adding new source list to existing source list functionality ''' |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 861 | df = defer.Deferred() |
| 862 | def igmp_new_src_list_functionality(): |
| 863 | self.igmp_new_src_list_functionality(df = df) |
| 864 | df.callback(0) |
| 865 | reactor.callLater(0, igmp_new_src_list_functionality) |
| 866 | return df |
| 867 | |
| 868 | def igmp_block_old_src_list_functionality(self, df = None): |
| 869 | groups1 = (self.MGROUP1,) |
| 870 | groups2 = (self.MGROUP2,) |
| 871 | groups = groups1 + groups2 |
| 872 | self.igmp_send_joins_different_groups_srclist(groups, |
| 873 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 874 | intf = self.V_INF1, delay = 2) |
| 875 | dst_mac = '01:00:5e:02:02:03' |
| 876 | src_ip = '5.5.5.5' |
| 877 | if df is None: |
| 878 | df = defer.Deferred() |
| 879 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 880 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 881 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 882 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 883 | mcastTraffic1.start() |
| 884 | join_state1 = IGMPTestState(groups = groups2) |
| 885 | target1 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
| 886 | log.info('Interface is receiving from multicast groups %s' %groups2) |
| 887 | self.igmp_send_joins_different_groups_srclist(groups, |
| 888 | (['6.6.6.6', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '7.7.7.7']), |
| 889 | intf = self.V_INF1, delay = 2) |
| 890 | target2 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 891 | assert target2 == 1, 'EXPECTED FAILURE' |
| 892 | log.info('Interface is not receiving from multicast groups %s after sending join with block old source list' %groups2) |
| 893 | mcastTraffic1.stop() |
| 894 | self.onos_ctrl.deactivate() |
| 895 | |
| 896 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 897 | def test_igmp_block_old_src_list_functionality(self): |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 898 | ## '''This test is checking that block old source list from existing source list functionality ''' |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 899 | df = defer.Deferred() |
| 900 | def igmp_block_old_src_list_functionality(): |
| 901 | self.igmp_block_old_src_list_functionality(df = df) |
| 902 | df.callback(0) |
| 903 | reactor.callLater(0, igmp_block_old_src_list_functionality) |
| 904 | return df |
| 905 | |
| 906 | def igmp_include_empty_src_list_functionality(self, df = None): |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 907 | groups1 = (self.MGROUP1,) |
| 908 | groups2 = (self.MGROUP2,) |
| 909 | groups = groups1 + groups2 |
| 910 | self.igmp_send_joins_different_groups_srclist(groups, |
| 911 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['']), |
| 912 | intf = self.V_INF1, delay = 2) |
| 913 | dst_mac = '01:00:5e:02:02:03' |
| 914 | src_ip = '5.5.5.5' |
| 915 | if df is None: |
| 916 | df = defer.Deferred() |
| 917 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 918 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 919 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 920 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 921 | mcastTraffic1.start() |
| 922 | join_state1 = IGMPTestState(groups = groups2) |
| 923 | target1 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 924 | assert target1==1, 'EXPECTED FAILURE' |
| 925 | log.info('Interface is not receiving from multicast groups %s when we sent join with source list is empty' %groups2) |
| 926 | mcastTraffic1.stop() |
| 927 | self.onos_ctrl.deactivate() |
| 928 | |
| 929 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 930 | def ztest_igmp_include_empty_src_list_functionality(self): |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 931 | ## '''This test is checking that multicast functionality by sending empty source list to include ''' |
| 932 | ## '''Disabling this test as scapy IGMP doesn't work with empty source lists''' |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 933 | df = defer.Deferred() |
| 934 | def igmp_include_empty_src_list_functionality(): |
| 935 | self.igmp_include_empty_src_list_functionality(df = df) |
| 936 | df.callback(0) |
| 937 | reactor.callLater(0, igmp_include_empty_src_list_functionality) |
| 938 | return df |
| 939 | |
| 940 | def igmp_exclude_empty_src_list_functionality(self, df = None): |
| 941 | groups1 = (self.MGROUP1,) |
| 942 | groups2 = (self.MGROUP2,) |
| 943 | groups = groups1 + groups2 |
| 944 | self.send_igmp_leave(groups = groups2, src_list = [''], iface = self.V_INF1, delay = 2) |
| 945 | dst_mac = '01:00:5e:02:02:03' |
| 946 | src_ip = '5.5.5.5' |
| 947 | if df is None: |
| 948 | df = defer.Deferred() |
| 949 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 950 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 951 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 952 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 953 | mcastTraffic1.start() |
| 954 | join_state1 = IGMPTestState(groups = groups2) |
| 955 | target1 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
| 956 | log.info('Interface is receiving multicast groups %s' %groups2) |
| 957 | mcastTraffic1.stop() |
| 958 | self.onos_ctrl.deactivate() |
| 959 | |
| 960 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 961 | def ztest_igmp_exclude_empty_src_list_functionality(self): |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 962 | ## '''This test is checking that multicast functionality by sending empty source list to exclude ''' |
| 963 | ## '''Disabling this test case since scapy IGMP doesn't work with empty src list''' |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 964 | df = defer.Deferred() |
| 965 | def igmp_exclude_empty_src_list_functionality(): |
| 966 | self.igmp_exclude_empty_src_list_functionality() |
| 967 | df.callback(0) |
| 968 | reactor.callLater(0, igmp_exclude_empty_src_list_functionality) |
| 969 | return df |
| 970 | |
| 971 | def igmp_join_sourceip_0_0_0_0_functionality(self, df = None): |
| 972 | groups1 = (self.MGROUP1,) |
| 973 | groups2 = (self.MGROUP2,) |
| 974 | groups = groups1 + groups2 |
| 975 | ip_src = '0.0.0.0' |
| 976 | self.igmp_send_joins_different_groups_srclist(groups, |
| 977 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['5.5.5.5']), |
| 978 | intf = self.V_INF1, delay = 2, ip_src = ip_src) |
| 979 | ip_src = self.IP_SRC |
| 980 | dst_mac = '01:00:5e:02:02:03' |
| 981 | src_ip = '5.5.5.5' |
| 982 | if df is None: |
| 983 | df = defer.Deferred() |
| 984 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 985 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 986 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 987 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 988 | mcastTraffic1.start() |
| 989 | join_state1 = IGMPTestState(groups = groups2) |
| 990 | target1 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
| 991 | log.info('Interface is receiving from multicast groups %s when we sent join with source IP is 0.0.0.0' %groups2) |
| 992 | mcastTraffic1.stop() |
| 993 | self.onos_ctrl.deactivate() |
| 994 | |
| 995 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 996 | def test_igmp_join_sourceip_0_0_0_0_functionality(self): |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 997 | ## '''This test is sending join with source list A,B,C and exclude D,F,G with source IP as 0.0.0.0''' |
Chetan Gaonker | 8bbc4d5 | 2016-03-29 16:59:45 -0700 | [diff] [blame] | 998 | df = defer.Deferred() |
| 999 | def igmp_join_sourceip_0_0_0_0_functionality(): |
| 1000 | self.igmp_join_sourceip_0_0_0_0_functionality(df = df) |
| 1001 | df.callback(0) |
| 1002 | reactor.callLater(0, igmp_join_sourceip_0_0_0_0_functionality) |
| 1003 | return df |
| 1004 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1005 | |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1006 | def igmp_invalid_join_packet_functionality(self, df = None): |
| 1007 | groups1 = (self.MGROUP1,) |
| 1008 | groups2 = (self.MINVALIDGROUP1,) |
| 1009 | groups = groups1 + groups2 |
| 1010 | ip_src = '1.1.1.1' |
| 1011 | self.igmp_send_joins_different_groups_srclist(groups, |
| 1012 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['5.5.5.5']), |
| 1013 | intf = self.V_INF1, delay = 2, ip_src = ip_src) |
| 1014 | ip_src = self.IP_SRC |
| 1015 | dst_mac = '01:00:5e:02:02:03' |
| 1016 | src_ip = '5.5.5.5' |
| 1017 | if df is None: |
| 1018 | df = defer.Deferred() |
| 1019 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 1020 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 1021 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 1022 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 1023 | mcastTraffic1.start() |
| 1024 | join_state1 = IGMPTestState(groups = groups2) |
| 1025 | target1 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 1026 | assert target1==1, 'EXPECTED FAILURE' |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1027 | log.info('Interface is not receiving from multicast groups %s when we sent invalid join packet ' %groups2) |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1028 | mcastTraffic1.stop() |
| 1029 | self.onos_ctrl.deactivate() |
| 1030 | |
| 1031 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
| 1032 | def test_igmp_invalid_join_packet_functionality(self): |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1033 | ## '''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''' |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1034 | df = defer.Deferred() |
| 1035 | def igmp_invalid_join_packet_functionality(): |
| 1036 | self.igmp_invalid_join_packet_functionality(df = df) |
| 1037 | df.callback(0) |
| 1038 | reactor.callLater(0, igmp_invalid_join_packet_functionality) |
| 1039 | return df |
| 1040 | |
| 1041 | def igmp_join_data_receiving_during_subscriber_link_down_up_functionality(self, df = None): |
| 1042 | groups1 = (self.MGROUP1,) |
| 1043 | groups2 = (self.MGROUP2,) |
| 1044 | groups = groups1 + groups2 |
| 1045 | ip_src = '1.1.1.1' |
| 1046 | self.igmp_send_joins_different_groups_srclist(groups, |
| 1047 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['5.5.5.5']), |
| 1048 | intf = self.V_INF1, delay = 2, ip_src = ip_src) |
| 1049 | ip_src = self.IP_SRC |
| 1050 | dst_mac = '01:00:5e:02:02:03' |
| 1051 | src_ip = '5.5.5.5' |
| 1052 | if df is None: |
| 1053 | df = defer.Deferred() |
| 1054 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 1055 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 1056 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 1057 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 1058 | mcastTraffic1.start() |
| 1059 | join_state1 = IGMPTestState(groups = groups2) |
| 1060 | target1 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1061 | log.info('Interface is receiving from multicast groups, before bring down the self.V_INF1=%s ' %self.V_INF1) |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1062 | os.system('ifconfig '+self.V_INF1+' down') |
| 1063 | log.info(' the self.V_INF1 %s is down now ' %self.V_INF1) |
| 1064 | os.system('ifconfig '+self.V_INF1) |
| 1065 | time.sleep(10) |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1066 | os.system('ifconfig '+self.V_INF1+' up') |
| 1067 | os.system('ifconfig '+self.V_INF1) |
| 1068 | log.info(' the self.V_INF1 %s is up now ' %self.V_INF1) |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1069 | target1 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1070 | log.info('Interface is receiving from multicast groups %s when we bringup interface up after down ' %groups2) |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1071 | mcastTraffic1.stop() |
| 1072 | self.onos_ctrl.deactivate() |
| 1073 | |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1074 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1075 | def test_igmp_join_data_receiving_during_subscriber_link_up_down_functionality(self): |
| 1076 | ## '''This test is sending join with source list A,B,C and exclude D,F,G with valid multicast group during receiving data, shutdown on data receiving port''' |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1077 | df = defer.Deferred() |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1078 | def igmp_join_data_receiving_during_subscriber_link_up_down_functionality(): |
| 1079 | self.igmp_join_data_receiving_during_subscriber_link_down_up_functionality(df = df) |
| 1080 | df.callback(0) |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1081 | reactor.callLater(0, igmp_join_data_receiving_during_subscriber_link_down_up_functionality) |
| 1082 | return df |
| 1083 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1084 | def igmp_join_data_receiving_during_channel_distributor_link_up_down_functionality(self, df = None): |
| 1085 | groups1 = (self.MGROUP1,) |
| 1086 | groups2 = (self.MGROUP2,) |
| 1087 | groups = groups1 + groups2 |
| 1088 | ip_src = '1.1.1.1' |
| 1089 | self.igmp_send_joins_different_groups_srclist(groups, |
| 1090 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['5.5.5.5', '6.6.6.6']), |
| 1091 | intf = self.V_INF1, delay = 2, ip_src = ip_src) |
| 1092 | ip_src = self.IP_SRC |
| 1093 | dst_mac1 = '01:00:5e:01:02:03' |
| 1094 | dst_mac2 = '01:00:5e:02:02:03' |
| 1095 | src_ip2 = '5.5.5.5' |
| 1096 | src_ip1 = '2.2.2.2' |
| 1097 | if df is None: |
| 1098 | df = defer.Deferred() |
| 1099 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 1100 | igmpState2 = IGMPTestState(groups = groups2, df = df) |
| 1101 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 1102 | igmpStateRecv2 = IGMPTestState(groups = groups2, df = df) |
| 1103 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac1, |
| 1104 | src_ip = src_ip1, cb = self.send_mcast_cb, arg = igmpState1) |
| 1105 | mcastTraffic2 = McastTraffic(groups2, iface= 'veth3', dst_mac = dst_mac2, |
| 1106 | src_ip = src_ip2, cb = self.send_mcast_cb, arg = igmpState2) |
| 1107 | mcastTraffic1.start() |
| 1108 | mcastTraffic2.start() |
| 1109 | join_state1 = IGMPTestState(groups = groups1) |
| 1110 | join_state2 = IGMPTestState(groups = groups2) |
| 1111 | target1 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 1112 | target2 = self.igmp_recv_task(self.V_INF1, groups2, join_state2) |
| 1113 | log.info('Interface is receiving from multicast groups, before bring down the veth2 and subscriber link is self.V_INF1=%s up ' %self.V_INF1) |
| 1114 | mcastTraffic1.stop() |
| 1115 | os.system('ifconfig '+'veth2'+' down') |
| 1116 | log.info(' the channel distributor interface veth2 is down now ' ) |
| 1117 | os.system('ifconfig '+'veth2') |
| 1118 | time.sleep(10) |
| 1119 | log.info('Verifying interface is still receiving a multicast groups2 %s traffic even though other group traffic sending interface goes down' %groups2) |
| 1120 | target2 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 1121 | log.info('Verified that interface is still receiving a multicast groups2 %s traffic even though other group traffic sending interface goes down' %groups2) |
| 1122 | target1 = self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 1123 | assert target1==1, 'EXPECTED FAILURE' |
| 1124 | log.info('Interface is not receiving from multicast groups1 %s when we shutdown the subscriber interface ' %groups1) |
| 1125 | os.system('ifconfig '+'veth2'+' up') |
| 1126 | os.system('ifconfig '+'veth2') |
| 1127 | log.info(' the channel distributor interface veth2 is up now ') |
| 1128 | time.sleep(10) |
| 1129 | mcastTraffic1.start() |
| 1130 | log.info('Verifying interface is receiving from both multicast groups data %s when we bringup interface up after down ' %groups2) |
| 1131 | target1 = self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 1132 | target2 = self.igmp_recv_task(self.V_INF1, groups2, join_state2) |
| 1133 | target2 = self.igmp_recv_task(self.V_INF1, groups2, join_state2) |
| 1134 | log.info('Interface is receiving from multicast groups %s when we bringup interface up after down ' %groups2) |
| 1135 | mcastTraffic2.stop() |
| 1136 | self.onos_ctrl.deactivate() |
| 1137 | ## This test case is failing to receive traffic from multicast data from defferent channel interfaces TO-DO |
| 1138 | ###### TO DO scenario ####### |
| 1139 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+60) |
| 1140 | def ztest_igmp_join_data_receiving_during_channel_distributor_link_down_up_functionality(self): |
| 1141 | ## '''This test is sending join with source list A,B,C with valid multicast group during receiving data, shutdown the data sending port''' |
| 1142 | df = defer.Deferred() |
| 1143 | def igmp_join_data_receiving_during_channel_distributor_link_down_up_functionality(): |
| 1144 | self.igmp_join_data_receiving_during_channel_distributor_link_down_up_functionality(df = df) |
| 1145 | df.callback(0) |
| 1146 | reactor.callLater(0, igmp_join_data_receiving_during_channel_distributor_link_down_up_functionality) |
| 1147 | return df |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1148 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1149 | def igmp_invalidClassD_IP_join_packet_functionality(self, df = None): |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1150 | groups1 = (self.MGROUP1,) |
| 1151 | groups2 = (self.MINVALIDGROUP2,) |
| 1152 | groups = groups1 + groups2 |
| 1153 | ip_src = '1.1.1.1' |
| 1154 | self.igmp_send_joins_different_groups_srclist(groups, |
| 1155 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['5.5.5.5']), |
| 1156 | intf = self.V_INF1, delay = 2, ip_src = ip_src) |
| 1157 | ip_src = self.IP_SRC |
| 1158 | dst_mac = '01:00:5e:02:02:03' |
| 1159 | src_ip = '5.5.5.5' |
| 1160 | if df is None: |
| 1161 | df = defer.Deferred() |
| 1162 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 1163 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 1164 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 1165 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 1166 | mcastTraffic1.start() |
| 1167 | join_state1 = IGMPTestState(groups = groups2) |
| 1168 | target1 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 1169 | assert target1==1, 'EXPECTED FAILURE' |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1170 | log.info('Interface is not receiving from multicast groups %s when we sent invalid join packet ' %groups2) |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1171 | mcastTraffic1.stop() |
| 1172 | self.onos_ctrl.deactivate() |
| 1173 | |
| 1174 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1175 | def test_igmp_invalidClassD_IP_join_packet_functionality(self): |
| 1176 | ## '''This test is sending invalid join with source list A,B,C with multicast group as 239.255.255.255''' |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1177 | df = defer.Deferred() |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1178 | def igmp_invalidClass_D_IP_join_packet_functionality(): |
| 1179 | self.igmp_invalidClass_D_IP_join_packet_functionality(df = df) |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1180 | df.callback(0) |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1181 | reactor.callLater(0, igmp_invalidClassD_IP_join_packet_functionality) |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1182 | return df |
| 1183 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1184 | def igmp_invalidClassD_IP_as_srclistIP_join_packet_functionality(self, df = None): |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1185 | groups1 = (self.MGROUP1,) |
| 1186 | groups2 = (self.MGROUP2,) |
| 1187 | groups = groups1 + groups2 |
| 1188 | ip_src = '1.1.1.1' |
| 1189 | self.igmp_send_joins_different_groups_srclist(groups, |
| 1190 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['239.5.5.5']), |
| 1191 | intf = self.V_INF1, delay = 2, ip_src = ip_src) |
| 1192 | ip_src = self.IP_SRC |
| 1193 | dst_mac = '01:00:5e:02:02:03' |
| 1194 | src_ip = '5.5.5.5' |
| 1195 | if df is None: |
| 1196 | df = defer.Deferred() |
| 1197 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 1198 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 1199 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 1200 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 1201 | mcastTraffic1.start() |
| 1202 | join_state1 = IGMPTestState(groups = groups2) |
| 1203 | target1 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 1204 | assert target1==1, 'EXPECTED FAILURE' |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1205 | log.info('Interface is not receiving from multicast groups %s when we sent invalid join packet ' %groups2) |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1206 | mcastTraffic1.stop() |
| 1207 | self.onos_ctrl.deactivate() |
| 1208 | |
| 1209 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+20) |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1210 | def test_igmp_invalidClassD_IP_as_srclistIP_join_packet_functionality(self): |
| 1211 | ## '''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''' |
Chetan Gaonker | 586fec3 | 2016-04-29 17:33:54 -0700 | [diff] [blame] | 1212 | df = defer.Deferred() |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1213 | def igmp_invalidClassD_IP_as_srclistIP_join_packet_functionality(): |
| 1214 | self.igmp_invalidClassD_IP_as_srclistIP_join_packet_functionality(df = df) |
| 1215 | df.callback(0) |
| 1216 | reactor.callLater(0, igmp_invalidClassD_IP_as_srclistIP_join_packet_functionality) |
| 1217 | return df |
Chetan Gaonker | f72ca40 | 2016-05-02 16:29:32 -0700 | [diff] [blame] | 1218 | |
Chetan Gaonker | 441c9ac | 2016-05-06 10:30:13 -0700 | [diff] [blame] | 1219 | |
| 1220 | def igmp_general_query_recv_packet_functionality(self, df = None): |
| 1221 | groups1 = (self.MGROUP1,) |
| 1222 | groups2 = (self.MGROUP2,) |
| 1223 | groups = groups1 + groups2 |
| 1224 | ip_src = '1.1.1.1' |
| 1225 | self.igmp_send_joins_different_groups_srclist(groups, |
| 1226 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['5.5.5.5']), |
| 1227 | intf = self.V_INF1, delay = 2, ip_src = ip_src) |
| 1228 | ip_src = self.IP_SRC |
| 1229 | dst_mac = '01:00:5e:02:02:03' |
| 1230 | src_ip = '5.5.5.5' |
| 1231 | if df is None: |
| 1232 | df = defer.Deferred() |
| 1233 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 1234 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 1235 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 1236 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 1237 | mcastTraffic1.start() |
| 1238 | join_state1 = IGMPTestState(groups = groups2) |
| 1239 | log.info('Started delay to verify multicast data taraffic for group %s is received or not for 180 sec ' %groups2) |
| 1240 | time.sleep(100) |
| 1241 | target2 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
| 1242 | log.info('Verified that multicast data for group %s is received after 100 sec ' %groups2) |
| 1243 | time.sleep(50) |
| 1244 | target2 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
| 1245 | log.info('Verified that multicast data for group %s is received after 150 sec ' %groups2) |
| 1246 | time.sleep(30) |
| 1247 | target2 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
| 1248 | log.info('Verified that multicast data for group %s is received after 180 sec ' %groups2) |
| 1249 | time.sleep(10) |
| 1250 | target2 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
| 1251 | log.info('Verified that multicast data for group %s is received after 190 sec ' %groups2) |
| 1252 | target3 = mcastTraffic1.isRecvStopped() |
| 1253 | assert target3==False, 'EXPECTED FAILURE' |
| 1254 | log.info('Verified that multicast data for a group %s is still transmitting from a data interface' %groups2) |
| 1255 | log.info('Now checking joining interface is receiving a multicast data for group %s after 190 sec' %groups2) |
| 1256 | target1 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 1257 | assert target1==1, 'EXPECTED FAILURE' |
| 1258 | log.info('Interface is not receiving multicast data for group %s' %groups2) |
| 1259 | mcastTraffic1.stop() |
| 1260 | self.onos_ctrl.deactivate() |
| 1261 | |
| 1262 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+250) |
| 1263 | def test_igmp_general_query_recv_packet_traffic_functionality(self): |
| 1264 | ## '''This test is verifying whether multicast data is stopped after 180 sec time if we dont respond to query packet which will generated by a querier router''' |
| 1265 | df = defer.Deferred() |
| 1266 | def igmp_general_query_recv_packet_functionality(): |
| 1267 | self.igmp_general_query_recv_packet_functionality(df = df) |
| 1268 | df.callback(0) |
| 1269 | reactor.callLater(0, igmp_general_query_recv_packet_functionality) |
| 1270 | return df |
| 1271 | |
| 1272 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+80) |
| 1273 | def test_igmp_query_packet_received_on_joining_interface(self): |
| 1274 | ## '''This test is verifying whether joining interface is receiving general membership query packet from querier router ''' |
| 1275 | groups = ['224.0.1.10', '225.0.0.10'] |
| 1276 | leave_groups = ['224.0.1.10'] |
| 1277 | df = defer.Deferred() |
| 1278 | igmpState = IGMPTestState(groups = groups, df = df) |
| 1279 | igmpStateRecv = IGMPTestState(groups = groups, df = df) |
| 1280 | igmpStateList = (igmpState, igmpStateRecv) |
| 1281 | mcastTraffic = McastTraffic(groups, iface= 'veth2', cb = self.send_mcast_cb, |
| 1282 | arg = igmpState) |
| 1283 | self.df = df |
| 1284 | self.mcastTraffic = mcastTraffic |
| 1285 | self.recv_socket = L3PacketSocket(iface = 'veth0', type = ETH_P_IP) |
| 1286 | |
| 1287 | def igmp_srp_task(stateList): |
| 1288 | igmpSendState, igmpRecvState = stateList |
| 1289 | if not mcastTraffic.isRecvStopped(): |
| 1290 | result = self.igmp_recv(igmpRecvState) |
| 1291 | reactor.callLater(0, igmp_srp_task, stateList) |
| 1292 | else: |
| 1293 | self.mcastTraffic.stop() |
| 1294 | self.recv_socket.close() |
| 1295 | self.igmp_verify_leave(stateList, leave_groups) |
| 1296 | self.df.callback(0) |
| 1297 | |
| 1298 | log.info('Sending join packet and expected to receive on egeneral query packet after 60 sec for multicast %s ' %groups) |
| 1299 | self.send_igmp_join_recvQuery(groups) |
| 1300 | log.info('Received a egeneral query packet for multicast %s group on joing interface and sending traffic' %groups) |
| 1301 | mcastTraffic.start() |
| 1302 | self.test_timer = reactor.callLater(self.MCAST_TRAFFIC_TIMEOUT, self.mcast_traffic_timer) |
| 1303 | reactor.callLater(0, igmp_srp_task, igmpStateList) |
| 1304 | return df |
| 1305 | |
| 1306 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+190) |
| 1307 | def test_igmp_periodic_query_packet_received_on_joining_interface(self): |
| 1308 | ## '''This test is verifying whether joining interface is receiving periodic general membership query packets from querier router ''' |
| 1309 | groups = ['224.0.1.10', '225.0.0.10'] |
| 1310 | leave_groups = ['224.0.1.10'] |
| 1311 | df = defer.Deferred() |
| 1312 | igmpState = IGMPTestState(groups = groups, df = df) |
| 1313 | igmpStateRecv = IGMPTestState(groups = groups, df = df) |
| 1314 | igmpStateList = (igmpState, igmpStateRecv) |
| 1315 | mcastTraffic = McastTraffic(groups, iface= 'veth2', cb = self.send_mcast_cb, |
| 1316 | arg = igmpState) |
| 1317 | self.df = df |
| 1318 | self.mcastTraffic = mcastTraffic |
| 1319 | self.recv_socket = L3PacketSocket(iface = 'veth0', type = ETH_P_IP) |
| 1320 | |
| 1321 | def igmp_srp_task(stateList): |
| 1322 | igmpSendState, igmpRecvState = stateList |
| 1323 | if not mcastTraffic.isRecvStopped(): |
| 1324 | result = self.igmp_recv(igmpRecvState) |
| 1325 | reactor.callLater(0, igmp_srp_task, stateList) |
| 1326 | else: |
| 1327 | self.mcastTraffic.stop() |
| 1328 | self.recv_socket.close() |
| 1329 | self.igmp_verify_leave(stateList, leave_groups) |
| 1330 | self.df.callback(0) |
| 1331 | |
| 1332 | self.send_igmp_join_recvQuery(groups,3) |
| 1333 | return df |
| 1334 | |
| 1335 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+190) |
| 1336 | def test_igmp_periodic_query_packet_received_and_checking_entry_deleted(self): |
| 1337 | ## '''This test is verifying whether joining interface is receiving periodic general membership query packets from querier router, checking expire membership interval and traffic should not receive''' |
| 1338 | groups = ['224.0.1.10', '225.0.0.10'] |
| 1339 | leave_groups = ['224.0.1.10'] |
| 1340 | df = defer.Deferred() |
| 1341 | igmpState = IGMPTestState(groups = groups, df = df) |
| 1342 | igmpStateRecv = IGMPTestState(groups = groups, df = df) |
| 1343 | igmpStateList = (igmpState, igmpStateRecv) |
| 1344 | mcastTraffic = McastTraffic(groups, iface= 'veth2', cb = self.send_mcast_cb, |
| 1345 | arg = igmpState) |
| 1346 | self.df = df |
| 1347 | self.mcastTraffic = mcastTraffic |
| 1348 | self.recv_socket = L3PacketSocket(iface = 'veth0', type = ETH_P_IP) |
| 1349 | |
| 1350 | def igmp_srp_task(stateList): |
| 1351 | igmpSendState, igmpRecvState = stateList |
| 1352 | if not mcastTraffic.isRecvStopped(): |
| 1353 | result = self.igmp_recv(igmpRecvState) |
| 1354 | reactor.callLater(0, igmp_srp_task, stateList) |
| 1355 | else: |
| 1356 | self.mcastTraffic.stop() |
| 1357 | self.recv_socket.close() |
| 1358 | self.igmp_verify_leave(stateList, leave_groups) |
| 1359 | self.df.callback(0) |
| 1360 | |
| 1361 | self.send_igmp_join_recvQuery(groups,3) |
| 1362 | log.info('Received periodic egeneral query packets for multicast %s, now checking entry is deleted from tabel by sending traffic for that group' %groups) |
| 1363 | mcastTraffic.start() |
| 1364 | self.test_timer = reactor.callLater(self.MCAST_TRAFFIC_TIMEOUT, self.mcast_traffic_timer) |
| 1365 | reactor.callLater(0, igmp_srp_task, igmpStateList) |
| 1366 | return df |
| 1367 | |
| 1368 | |
| 1369 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+190) |
| 1370 | def test_igmp_member_query_interval_expire_re_joining_interface(self): |
| 1371 | ## '''This test is verifying whether joining interface is receiving multicast data even after group menership interval expire by sending again joining to that multicast data group''' |
| 1372 | groups = ['224.0.1.10', '225.0.0.10'] |
| 1373 | leave_groups = ['224.0.1.10'] |
| 1374 | df = defer.Deferred() |
| 1375 | igmpState = IGMPTestState(groups = groups, df = df) |
| 1376 | igmpStateRecv = IGMPTestState(groups = groups, df = df) |
| 1377 | igmpStateList = (igmpState, igmpStateRecv) |
| 1378 | mcastTraffic = McastTraffic(groups, iface= 'veth2', cb = self.send_mcast_cb, |
| 1379 | arg = igmpState) |
| 1380 | self.df = df |
| 1381 | self.mcastTraffic = mcastTraffic |
| 1382 | self.recv_socket = L3PacketSocket(iface = 'veth0', type = ETH_P_IP) |
| 1383 | |
| 1384 | def igmp_srp_task(stateList): |
| 1385 | igmpSendState, igmpRecvState = stateList |
| 1386 | if not mcastTraffic.isRecvStopped(): |
| 1387 | result = self.igmp_recv(igmpRecvState) |
| 1388 | reactor.callLater(0, igmp_srp_task, stateList) |
| 1389 | else: |
| 1390 | self.mcastTraffic.stop() |
| 1391 | self.recv_socket.close() |
| 1392 | self.igmp_verify_leave(stateList, leave_groups) |
| 1393 | self.df.callback(0) |
| 1394 | |
| 1395 | self.send_igmp_join_recvQuery(groups,3) |
| 1396 | log.info('Received periodic egeneral query packets for multicast %s, now sending join packet again and verifying traffic for that group is received or not on joining interface' %groups) |
| 1397 | self.send_igmp_join(groups) |
| 1398 | mcastTraffic.start() |
| 1399 | self.test_timer = reactor.callLater(self.MCAST_TRAFFIC_TIMEOUT, self.mcast_traffic_timer) |
| 1400 | reactor.callLater(0, igmp_srp_task, igmpStateList) |
| 1401 | return df |
| 1402 | |
| 1403 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+50) |
| 1404 | def test_igmp_leave_verify_received_group_source_specific_query(self): |
| 1405 | ## '''This test is verfying when we send leave message we should get group-source specific query ''' |
| 1406 | groups = ['224.0.1.10', '225.0.0.10'] |
| 1407 | leave_groups = ['224.0.1.10'] |
| 1408 | df = defer.Deferred() |
| 1409 | igmpState = IGMPTestState(groups = groups, df = df) |
| 1410 | igmpStateRecv = IGMPTestState(groups = groups, df = df) |
| 1411 | igmpStateList = (igmpState, igmpStateRecv) |
| 1412 | mcastTraffic = McastTraffic(groups, iface= 'veth2', cb = self.send_mcast_cb, |
| 1413 | arg = igmpState) |
| 1414 | self.df = df |
| 1415 | self.mcastTraffic = mcastTraffic |
| 1416 | self.recv_socket = L3PacketSocket(iface = 'veth0', type = ETH_P_IP) |
| 1417 | |
| 1418 | def igmp_srp_task(stateList): |
| 1419 | igmpSendState, igmpRecvState = stateList |
| 1420 | if not mcastTraffic.isRecvStopped(): |
| 1421 | result = self.igmp_recv(igmpRecvState) |
| 1422 | reactor.callLater(0, igmp_srp_task, stateList) |
| 1423 | else: |
| 1424 | self.mcastTraffic.stop() |
| 1425 | self.recv_socket.close() |
| 1426 | self.igmp_verify_leave(stateList, leave_groups) |
| 1427 | self.df.callback(0) |
| 1428 | |
| 1429 | self.send_igmp_join(groups) |
| 1430 | self.send_igmp_leave_listening_group_specific_query(leave_groups, delay = 3) |
| 1431 | return df |
| 1432 | |
| 1433 | def igmp_change_to_exclude_src_list_check_for_group_source_specific_query(self, df = None): |
| 1434 | groups1 = (self.MGROUP1,) |
| 1435 | groups2 = (self.MGROUP2,) |
| 1436 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 1437 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 1438 | intf = self.V_INF1, delay = 2) |
| 1439 | dst_mac = '01:00:5e:01:02:03' |
| 1440 | src_ip = '2.2.2.2' |
| 1441 | if df is None: |
| 1442 | df = defer.Deferred() |
| 1443 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 1444 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 1445 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 1446 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 1447 | mcastTraffic1.start() |
| 1448 | join_state1 = IGMPTestState(groups = groups1) |
| 1449 | target1 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 1450 | self.send_igmp_leave_listening_group_specific_query(groups = groups1, src_list = ['2.2.2.2'], iface = self.V_INF1, delay =2) |
| 1451 | time.sleep(10) |
| 1452 | target2 = self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 1453 | assert target2 == 1, 'EXPECTED FAILURE' |
| 1454 | log.info('Interface is not receiving from multicast groups %s after sending CHANGE_TO_EXCLUDE' %groups2) |
| 1455 | mcastTraffic1.stop() |
| 1456 | self.onos_ctrl.deactivate() |
| 1457 | |
| 1458 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+60) |
| 1459 | def test_igmp_change_to_exclude_src_list_check_for_group_source_specific_query(self): |
| 1460 | '''Verify join INCLUDE (A) and TO_EX(B) for a multicast group, |
| 1461 | we should receive group source specific membership query packet to A*B source list interface''' |
| 1462 | df = defer.Deferred() |
| 1463 | def igmp_change_to_exclude_src_list_check_for_group_source_specific_query(): |
| 1464 | self.igmp_change_to_exclude_src_list_check_for_group_source_specific_query(df = df) |
| 1465 | df.callback(0) |
| 1466 | reactor.callLater(0, igmp_change_to_exclude_src_list_check_for_group_source_specific_query) |
| 1467 | return df |
| 1468 | |
| 1469 | def igmp_change_to_include_src_list_check_for_general_query(self, df = None): |
| 1470 | groups1 = (self.MGROUP1,) |
| 1471 | groups2 = (self.MGROUP2,) |
| 1472 | self.send_igmp_leave(groups = groups1, src_list = ['2.2.2.2', '3.3.3.3', '4.4.4.4'], |
| 1473 | iface = self.V_INF1, delay = 2) |
| 1474 | dst_mac = '01:00:5e:01:02:03' |
| 1475 | src_ip = '2.2.2.2' |
| 1476 | if df is None: |
| 1477 | df = defer.Deferred() |
| 1478 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 1479 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 1480 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 1481 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 1482 | mcastTraffic1.start() |
| 1483 | join_state1 = IGMPTestState(groups = groups1) |
| 1484 | target1= self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 1485 | assert target1 == 1, 'EXPECTED FAILURE' |
| 1486 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 1487 | self.igmp_send_joins_different_groups_srclist_wait_query_packets(groups1 + groups2, |
| 1488 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['6.6.6.6', '5.5.5.5']), |
| 1489 | intf = self.V_INF1, delay = 2,query_group1 = 'group1', query_group2 = None) |
| 1490 | time.sleep(10) |
| 1491 | target2 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 1492 | log.info('Interface is receiving from multicast groups %s after send Change to include message' %groups1) |
| 1493 | mcastTraffic1.stop() |
| 1494 | self.onos_ctrl.deactivate() |
| 1495 | |
| 1496 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+80) |
| 1497 | def test_igmp_change_to_include_src_list_check_for_general_query(self): |
| 1498 | '''Verify join EXCLUDE (A) and TO_IN(B) for a multicast group, |
| 1499 | we should receive general membership query packet. ''' |
| 1500 | df = defer.Deferred() |
| 1501 | def igmp_change_to_include_src_list_check_for_general_query(): |
| 1502 | self.igmp_change_to_include_src_list_check_for_general_query(df = df) |
| 1503 | df.callback(0) |
| 1504 | reactor.callLater(0, igmp_change_to_include_src_list_check_for_general_query) |
| 1505 | return df |
| 1506 | |
| 1507 | def igmp_allow_new_src_list_check_for_general_query(self, df = None): |
| 1508 | groups1 = (self.MGROUP1,) |
| 1509 | groups2 = (self.MGROUP2,) |
| 1510 | self.igmp_send_joins_different_groups_srclist(groups1+groups2, |
| 1511 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 1512 | intf = self.V_INF1, delay = 2) |
| 1513 | dst_mac = '01:00:5e:01:02:03' |
| 1514 | src_ip = '6.6.6.6' |
| 1515 | if df is None: |
| 1516 | df = defer.Deferred() |
| 1517 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 1518 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 1519 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 1520 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 1521 | mcastTraffic1.start() |
| 1522 | join_state1 = IGMPTestState(groups = groups1) |
| 1523 | target1 = self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 1524 | #assert target1 == 1, 'EXPECTED FAILURE' |
| 1525 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 1526 | self.igmp_send_joins_different_groups_srclist_wait_query_packets(groups1 + groups2, (['2.2.2.2', '6.6.6.6', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 1527 | intf = self.V_INF1, delay = 2, query_group1 = 'group1', query_group2 = None) |
| 1528 | target2 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 1529 | log.info('Interface is receiving from multicast groups %s after sending join with new source list' %groups1) |
| 1530 | mcastTraffic1.stop() |
| 1531 | self.onos_ctrl.deactivate() |
| 1532 | |
| 1533 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+80) |
| 1534 | def test_igmp_allow_new_src_list_check_for_general_query(self): |
| 1535 | '''Verify join INCLUDE (A) and ALLOW(B) for a multicast group, we |
| 1536 | should receive general membership query packet. ''' |
| 1537 | df = defer.Deferred() |
| 1538 | def igmp_allow_new_src_list_check_for_general_query(): |
| 1539 | self.igmp_allow_new_src_list_check_for_general_query(df = df) |
| 1540 | df.callback(0) |
| 1541 | reactor.callLater(0, igmp_allow_new_src_list_check_for_general_query) |
| 1542 | return df |
| 1543 | |
| 1544 | def igmp_block_old_src_list_check_for_group_source_specific_query(self, df = None): |
| 1545 | groups1 = (self.MGROUP1,) |
| 1546 | groups2 = (self.MGROUP2,) |
| 1547 | groups = groups1 + groups2 |
| 1548 | self.igmp_send_joins_different_groups_srclist(groups, |
| 1549 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 1550 | intf = self.V_INF1, delay = 2) |
| 1551 | dst_mac = '01:00:5e:02:02:03' |
| 1552 | src_ip = '5.5.5.5' |
| 1553 | if df is None: |
| 1554 | df = defer.Deferred() |
| 1555 | igmpState1 = IGMPTestState(groups = groups2, df = df) |
| 1556 | igmpStateRecv1 = IGMPTestState(groups = groups2, df = df) |
| 1557 | mcastTraffic1 = McastTraffic(groups2, iface= 'veth2', dst_mac = dst_mac, |
| 1558 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 1559 | mcastTraffic1.start() |
| 1560 | join_state1 = IGMPTestState(groups = groups2) |
| 1561 | target1 = self.igmp_recv_task(self.V_INF1, groups2, join_state1) |
| 1562 | log.info('Interface is receiving from multicast groups %s' %groups2) |
| 1563 | self.igmp_send_joins_different_groups_srclist_wait_query_packets(groups, |
| 1564 | (['6.6.6.6', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '7.7.7.7']), |
| 1565 | intf = self.V_INF1, delay = 2, query_group1 = 'group1', query_group2 = None) |
| 1566 | target2 = self.igmp_not_recv_task(self.V_INF1, groups2, join_state1) |
| 1567 | assert target2 == 1, 'EXPECTED FAILURE' |
| 1568 | log.info('Interface is not receiving from multicast groups %s after sending join with block old source list' %groups2) |
| 1569 | mcastTraffic1.stop() |
| 1570 | self.onos_ctrl.deactivate() |
| 1571 | |
| 1572 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+90) |
| 1573 | def test_igmp_block_old_src_list_check_for_group_source_specific_query(self): |
| 1574 | """ Verify when we send join INCLUDE (A) and BLOCK(B) for a multicast group, we should receive |
| 1575 | group source specific membership query packet to A*B source list interface""" |
| 1576 | df = defer.Deferred() |
| 1577 | def igmp_block_old_src_list_check_for_group_source_specific_query(): |
| 1578 | self.igmp_block_old_src_list_check_for_group_source_specific_query(df = df) |
| 1579 | df.callback(0) |
| 1580 | reactor.callLater(0, igmp_block_old_src_list_check_for_group_source_specific_query) |
| 1581 | return df |
| 1582 | |
| 1583 | def igmp_include_to_allow_src_list_check_for_general_query(self, df = None): |
| 1584 | groups1 = (self.MGROUP1,) |
| 1585 | groups2 = (self.MGROUP2,) |
| 1586 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 1587 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 1588 | intf = self.V_INF1, delay = 2) |
| 1589 | dst_mac = '01:00:5e:01:02:03' |
| 1590 | src_ip = '2.2.2.2' |
| 1591 | if df is None: |
| 1592 | df = defer.Deferred() |
| 1593 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 1594 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 1595 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 1596 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 1597 | mcastTraffic1.start() |
| 1598 | join_state1 = IGMPTestState(groups = groups1) |
| 1599 | target1 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 1600 | self.igmp_send_joins_different_groups_srclist_wait_query_packets(groups1 + groups2,(['2.2.2.2', '3.3.3.3', '4.4.4.4', '6.6.6.6'], ['2.2.2.2', '5.5.5.5']), intf = self.V_INF1, delay = 2, query_group1 = 'group1', query_group2 = None) |
| 1601 | target1 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 1602 | mcastTraffic1.stop() |
| 1603 | self.onos_ctrl.deactivate() |
| 1604 | |
| 1605 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+40) |
| 1606 | def test_igmp_include_to_allow_src_list_check_for_general_query(self): |
| 1607 | '''Verify join INCLUDE (A) and Allow(B) ,should receive general membership query packet ''' |
| 1608 | df = defer.Deferred() |
| 1609 | def igmp_include_to_allow_src_list_check_for_general_query(): |
| 1610 | self.igmp_include_to_allow_src_list_check_for_general_query(df = df) |
| 1611 | df.callback(0) |
| 1612 | reactor.callLater(0, igmp_include_to_allow_src_list_check_for_general_query) |
| 1613 | return df |
| 1614 | |
| 1615 | def igmp_include_to_block_src_list_check_for_group_source_specific_query(self, df = None): |
| 1616 | groups1 = (self.MGROUP1,) |
| 1617 | groups2 = (self.MGROUP2,) |
| 1618 | self.igmp_send_joins_different_groups_srclist(groups1 + groups2, |
| 1619 | (['2.2.2.2', '3.3.3.3', '4.4.4.4'], ['2.2.2.2', '5.5.5.5']), |
| 1620 | intf = self.V_INF1, delay = 2) |
| 1621 | dst_mac = '01:00:5e:01:02:03' |
| 1622 | src_ip = '2.2.2.2' |
| 1623 | if df is None: |
| 1624 | df = defer.Deferred() |
| 1625 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 1626 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 1627 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 1628 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 1629 | mcastTraffic1.start() |
| 1630 | join_state1 = IGMPTestState(groups = groups1) |
| 1631 | target1 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 1632 | self.send_igmp_leave_listening_group_specific_query(groups = groups1, src_list = ['6.6.6.6','7.7.7.7'], |
| 1633 | iface = self.V_INF1, delay = 2) |
| 1634 | target1 = self.igmp_recv_task(self.V_INF1, groups1, join_state1) |
| 1635 | mcastTraffic1.stop() |
| 1636 | self.onos_ctrl.deactivate() |
| 1637 | |
| 1638 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+40) |
| 1639 | def test_igmp_include_to_block_src_list_check_for_group_source_specific_query(self): |
| 1640 | '''Verify join INCLUDE (A) and Block(B) ,should receive group source specific membership query packet. ''' |
| 1641 | df = defer.Deferred() |
| 1642 | def igmp_include_to_block_src_list_check_for_group_source_specific_query(): |
| 1643 | self.igmp_include_to_block_src_list_check_for_group_source_specific_query(df = df) |
| 1644 | df.callback(0) |
| 1645 | reactor.callLater(0, igmp_include_to_block_src_list_check_for_group_source_specific_query) |
| 1646 | return df |
| 1647 | |
| 1648 | def igmp_exclude_to_allow_src_list_check_for_general_query(self, df = None): |
| 1649 | groups1 = (self.MGROUP1,) |
| 1650 | groups2 = (self.MGROUP2,) |
| 1651 | self.send_igmp_leave(groups = groups1, src_list = ['2.2.2.2', '3.3.3.3', '4.4.4.4'], |
| 1652 | iface = self.V_INF1, delay = 2) |
| 1653 | |
| 1654 | dst_mac = '01:00:5e:01:02:03' |
| 1655 | src_ip = '2.2.2.2' |
| 1656 | if df is None: |
| 1657 | df = defer.Deferred() |
| 1658 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 1659 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 1660 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 1661 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 1662 | mcastTraffic1.start() |
| 1663 | join_state1 = IGMPTestState(groups = groups1) |
| 1664 | target1= self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 1665 | assert target1 == 1, 'EXPECTED FAILURE' |
| 1666 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 1667 | self.igmp_send_joins_different_groups_srclist_wait_query_packets(groups1 + groups2, |
| 1668 | (['6.6.6.6', '7.7.7.7', '8.8.8.8'], ['6.6.6.6', '5.5.5.5']), intf = self.V_INF1, delay = 2, query_group1 = 'group1', query_group2 = None) |
| 1669 | target1= self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 1670 | assert target1 == 1, 'EXPECTED FAILURE' |
| 1671 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 1672 | mcastTraffic1.stop() |
| 1673 | self.onos_ctrl.deactivate() |
| 1674 | |
| 1675 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+90) |
| 1676 | def test_igmp_exclude_to_allow_src_list_check_for_general_query(self): |
| 1677 | '''Verify join EXCLUDE(A) and Allow(B) ,should receive general membership query packet. ''' |
| 1678 | df = defer.Deferred() |
| 1679 | def igmp_exclude_to_allow_src_list_check_for_general_query(): |
| 1680 | self.igmp_exclude_to_allow_src_list_check_for_general_query(df = df) |
| 1681 | df.callback(0) |
| 1682 | reactor.callLater(0, igmp_exclude_to_allow_src_list_check_for_general_query) |
| 1683 | return df |
| 1684 | |
| 1685 | def igmp_exclude_to_block_src_list_check_for_group_source_specific_query(self, df = None): |
| 1686 | groups1 = (self.MGROUP1,) |
| 1687 | groups2 = (self.MGROUP2,) |
| 1688 | self.send_igmp_leave(groups = groups1, src_list = ['2.2.2.2', '3.3.3.3', '4.4.4.4'], |
| 1689 | iface = self.V_INF1, delay = 2) |
| 1690 | |
| 1691 | dst_mac = '01:00:5e:01:02:03' |
| 1692 | src_ip = '2.2.2.2' |
| 1693 | if df is None: |
| 1694 | df = defer.Deferred() |
| 1695 | igmpState1 = IGMPTestState(groups = groups1, df = df) |
| 1696 | igmpStateRecv1 = IGMPTestState(groups = groups1, df = df) |
| 1697 | mcastTraffic1 = McastTraffic(groups1, iface= 'veth2', dst_mac = dst_mac, |
| 1698 | src_ip = src_ip, cb = self.send_mcast_cb, arg = igmpState1) |
| 1699 | mcastTraffic1.start() |
| 1700 | join_state1 = IGMPTestState(groups = groups1) |
| 1701 | target1= self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 1702 | assert target1 == 1, 'EXPECTED FAILURE' |
| 1703 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 1704 | self.send_igmp_leave_listening_group_specific_query(groups = groups1, |
| 1705 | src_list = ['2.2.2.2', '3.3.3.3', '4.4.4.4', '5.5.5.5', '7.7.7.7'], |
| 1706 | iface = self.V_INF1, delay = 2) |
| 1707 | target1= self.igmp_not_recv_task(self.V_INF1, groups1, join_state1) |
| 1708 | assert target1 == 1, 'EXPECTED FAILURE' |
| 1709 | log.info('Interface is not receiving from multicast groups %s' %groups1) |
| 1710 | mcastTraffic1.stop() |
| 1711 | self.onos_ctrl.deactivate() |
| 1712 | |
| 1713 | @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+40) |
| 1714 | def test_igmp_exclude_to_block_src_list_check_for_group_source_specific_query(self): |
| 1715 | '''Verify join EXCLUDE (A) and Block(B) ,should receive group source specific membership query packet.''' |
| 1716 | df = defer.Deferred() |
| 1717 | def igmp_exclude_to_block_src_list_check_for_group_source_specific_query(): |
| 1718 | self.igmp_exclude_to_block_src_list_check_for_group_source_specific_query(df = df) |
| 1719 | df.callback(0) |
| 1720 | reactor.callLater(0, igmp_exclude_to_block_src_list_check_for_group_source_specific_query) |
| 1721 | return df |
| 1722 | |
| 1723 | |