Test-IgmpProxy:
Adding multiple test scenarios validating functionality
of app.
Change-Id: I98221b1135f7753d14d2944fd8925999f4a4e78f
diff --git a/src/test/igmpproxy/igmpproxyTest.py b/src/test/igmpproxy/igmpproxyTest.py
index db7765e..b65987b 100644
--- a/src/test/igmpproxy/igmpproxyTest.py
+++ b/src/test/igmpproxy/igmpproxyTest.py
@@ -97,7 +97,8 @@
PORT_RX_DEFAULT = 1
max_packets = 100
MAX_PORTS = 100
- app = 'org.opencord.igmpproxy'
+ proxy_app = 'org.opencord.igmpproxy'
+ mcast_app = 'org.opencord.mcast'
cord_config_app = 'org.opencord.config'
test_path = os.path.dirname(os.path.realpath(__file__))
proxy_device_id = OnosCtrl.get_device_id()
@@ -124,6 +125,7 @@
OnosCtrl.cord_olt_config(cls.olt)
time.sleep(2)
cls.uninstall_cord_config_app()
+ time.sleep(2)
cls.install_igmpproxy()
cls.igmp_proxy_setup()
@@ -159,7 +161,7 @@
cls.proxy_device_id = did
cls.olt = OltConfig(olt_conf_file = cls.olt_conf_file)
cls.port_map, _ = cls.olt.olt_port_map()
- log_test.info('port map is %s'%cls.port_map)
+ #log_test.info('port map is %s'%cls.port_map)
if cls.port_map:
##Per subscriber, we use 1 relay port
try:
@@ -191,7 +193,7 @@
@classmethod
def igmp_proxy_cleanup(cls):
- #reset the ONOS port configuration back to default
+ ##reset the ONOS port configuration back to default
for config in cls.configs.items():
OnosCtrl.delete(config)
# if cls.onos_restartable is True:
@@ -199,9 +201,9 @@
# return cord_test_onos_restart(config = {})
@classmethod
- def onos_load_config(cls, config,json_file=False):
- log_test.info('onos load config is %s'%config)
- status, code = OnosCtrl.config(config,json_file=json_file)
+ def onos_load_config(cls, config):
+ #log_test.info('onos load config is %s'%config)
+ status, code = OnosCtrl.config(config)
if status is False:
log_test.info('JSON request returned status %d' %code)
assert_equal(status, True)
@@ -225,13 +227,47 @@
cls.configs['interface_config'] = interface_dict
@classmethod
- def onos_igmp_proxy_config_load(cls):
+ def onos_igmp_proxy_config_load(cls, FastLeave = "false"):
+ #cls.proxy_interface_port = 12
proxy_connect_point = '{}/{}'.format(cls.proxy_device_id, cls.proxy_interface_port)
- #log_test.info('\nrelay interface port is %s'%cls.proxy_interface_port)
- #log_test.info('\nrelay interface is %s'%cls.port_map[cls.proxy_interface_port])
- #log_test.info('\nconnect point is %s'%proxy_connect_point)
- #cls.onos_load_config(cls.proxy_config_file,json_file=True)
- igmpproxy_dict = {'apps':{
+ log_test.info('\nRelay interface port is %s'%cls.proxy_interface_port)
+ log_test.info('\nRelay interface is %s'%cls.port_map[cls.proxy_interface_port])
+ log_test.info('\nConnect point is %s'%proxy_connect_point)
+ cls.onos_load_config(cls.proxy_config_file,json_file=True)
+ igmpproxy_dict = { "apps": {
+ "org.onosproject.provider.lldp": {
+ "suppression": {
+ "deviceTypes": ["ROADM"],
+ "annotation": "{\"no-lldp\":null}"
+ }
+ },
+ "org.opencord.igmpproxy": {
+ "igmpproxy": {
+ "globalConnectPointMode": "true",
+ "globalConnectPoint": proxy_connect_point,
+ "UnsolicitedTimeOut": "2",
+ "MaxResp": "10",
+ "KeepAliveInterval": "120",
+ "KeepAliveCount": "3",
+ "LastQueryInterval": "2",
+ "LastQueryCount": "2",
+ "FastLeave": FastLeave,
+ "PeriodicQuery": "true",
+ "IgmpCos": "7",
+ "withRAUpLink": "true",
+ "withRADownLink": "true"
+ }
+ },
+ "org.opencord.mcast": {
+ "multicast": {
+ "ingressVlan": "222",
+ "egressVlan": "17"
+ }
+ }
+ }
+ }
+
+ """igmpproxy_dict = {'apps':{
'org.opencord.igmpproxy':{
'igmpproxy':
{'globalConnectPointMode': 'true',
@@ -252,9 +288,9 @@
'org.opencord.mcast':{
'ingressVlan': '222',
'egressVlan': '17'
- }
+ },
}
- }
+ }"""
device_dict = {'devices':{
cls.proxy_device_id: {
'basic': {
@@ -268,7 +304,7 @@
}
}
}
- log_test.info('igmp proxy dict is %s'%igmpproxy_dict)
+ log_test.info('Igmp proxy dict is %s'%igmpproxy_dict)
cls.onos_load_config(igmpproxy_dict)
cls.onos_load_config(device_dict)
cls.configs['relay_config'] = igmpproxy_dict
@@ -291,7 +327,7 @@
'arping -I {0} {1} -c 2'.format(iface, host),)
#'ifconfig {} 0'.format(iface), )
for c in cmds:
- log_test.info('host load config command %s'%c)
+ log_test.info('Host load config command %s'%c)
os.system(c)
@classmethod
@@ -338,7 +374,7 @@
d['source'] = s or '0.0.0.0'
d['group'] = g
ssm_xlate_list.append(d)
- log_test.info('onos ssm table config dictionary is %s'%ssm_dict)
+ log_test.info('ONOS ssm table config dictionary is %s'%ssm_dict)
self.onos_load_config(ssm_dict)
cord_port_map = {}
for g in groups:
@@ -346,6 +382,37 @@
self.igmp_channel.cord_port_table_load(cord_port_map)
time.sleep(2)
+ def random_mcast_ip(self,start_ip = '224.1.1.1', end_ip = '224.1.254.254'):
+ start = list(map(int, start_ip.split(".")))
+ end = list(map(int, end_ip.split(".")))
+ temp = start
+ ip_range = []
+ ip_range.append(start_ip)
+ while temp != end:
+ start[3] += 1
+ for i in (3, 2, 1):
+ if temp[i] == 255:
+ temp[i] = 0
+ temp[i-1] += 1
+ ip_range.append(".".join(map(str, temp)))
+ return random.choice(ip_range)
+
+ def randomsourceip(self,start_ip = '10.10.0.1', end_ip = '10.10.0.100'):
+ start = list(map(int, start_ip.split(".")))
+ end = list(map(int, end_ip.split(".")))
+ temp = start
+ ip_range = []
+ ip_range.append(start_ip)
+ while temp != end:
+ start[3] += 1
+ for i in (3, 2, 1):
+ if temp[i] == 255:
+ temp[i] = 0
+ temp[i-1] += 1
+ ip_range.append(".".join(map(str, temp)))
+ return random.choice(ip_range)
+
+
def get_igmp_intf(self):
inst = os.getenv('TEST_INSTANCE', None)
if not inst:
@@ -426,7 +493,7 @@
ip_pkt = self.igmp_eth/self.igmp_ip
pkt = ip_pkt/igmp
IGMPv3.fixup(pkt)
- log_test.info('sending igmp join packet %s'%pkt.show())
+ #log_test.info('sending igmp join packet %s'%pkt.show())
sendp(pkt, iface=iface)
if delay != 0:
time.sleep(delay)
@@ -456,123 +523,401 @@
if delay != 0:
time.sleep(delay)
- def send_igmp_leave(self, groups, src_list = ['1.2.3.4'], ip_pkt = None, iface = 'veth0', delay = 2):
+ def send_igmp_leave(self, groups, src_list = [], ip_pkt = None, iface = 'veth0', delay = 2):
log_test.info('entering into igmp leave function')
igmp = IGMPv3(type = IGMP_TYPE_V3_MEMBERSHIP_REPORT, max_resp_code=30,
gaddr=self.IP_DST)
for g in groups:
- gr = IGMPv3gr(rtype=IGMP_V3_GR_TYPE_EXCLUDE, mcaddr=g)
+ #gr = IGMPv3gr(rtype=IGMP_V3_GR_TYPE_EXCLUDE, mcaddr=g)
+ gr = IGMPv3gr(rtype=IGMP_V3_GR_TYPE_CHANGE_TO_INCLUDE, mcaddr=g)
gr.sources = src_list
igmp.grps.append(gr)
if ip_pkt is None:
ip_pkt = self.igmp_eth/self.igmp_ip
pkt = ip_pkt/igmp
+ log_test.info('igmp leave packet is %s'%pkt.show())
IGMPv3.fixup(pkt)
sendp(pkt, iface = iface)
if delay != 0:
time.sleep(delay)
+ def verify_igmp_packets_on_proxy_interface(self,ip_dst=None,iface=None,count=1,positive_test = True):
+ log_test.info('positive test variable inside verify_igmp_packets_on_proxy_interface function is %s'%positive_test)
+ if not iface:
+ iface = self.proxy_interfaces[0]
+ if not ip_dst:
+ ip_dst = self.IP_DST
+ self.status = False if positive_test is True else True
+ #log_test.info('self.status is %s'%self.status)
+ try:
+ def igmp_recv_cb(pkt):
+ log_test.info('igmp packet received on proxy interface %s'%pkt.show())
+ #log_test.info('igmp packet received on proxy interface %s'%pkt[Raw].show())
+ self.status = True if positive_test is True else False
+ sniff(prn = igmp_recv_cb,lfilter = lambda p: IP in p and p[IP].proto == 2 and p[IP].dst==ip_dst, count=count, timeout = 5, iface=iface)
+ log_test.info('self.status is %s'%self.status)
+ #assert_equal(self.status, True)
+ except Exception as error:
+ log_test.info('Got Unexpected error %s'%error)
+ raise
+ #assert_equal(self.status, True)
+
+ @deferred(30)
def test_igmpproxy_app_installation(self):
- #self.uninstall_cord_config_app()
- #self.install_igmpproxy()
- auth = ('karaf','karaf')
- url = 'http://{}:8181/onos/v1/applications'.format(self.controller)
- for file in self.app_files:
- with open(file, 'rb') as payload:
- res = requests.post(url,auth=auth,data=payload)
- assert_equal(res.ok, True)
-
- def test_igmpproxy_app_netcfg(self):
- auth = ('karaf','karaf')
- net_cfg_url = 'http://{}:8181/onos/v1/network/configuration/'.format(self.controller)
- with open(self.proxy_config_file, 'rb') as payload:
- res = requests.post(net_cfg_url,auth=auth,data=payload)
- assert_equal(res.ok, True)
-
- def test_igmpproxy_for_first_join(self,iface='veth0'):
- group = ['224.9.8.7']
- src = ['10.9.8.7']
- self.onos_igmp_proxy_config_load()
- self.onos_ssm_table_load(group,src_list=src)
- self.success = False
- def recv_task():
- def igmp_recv_cb(pkt):
- log_test.info('igmp packet received on proxy interface')
- self.success = True
- sniff(prn = igmp_recv_cb,lfilter = lambda p: IP in p and p[IP].proto == 2 and p[IP].dst==self.IP_DST, count=1,timeout = 5, iface=self.proxy_interfaces[0])
- t = threading.Thread(target = recv_task)
- t.start()
- self.send_igmp_join(groups = group, src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
- iface = iface)
- t.join()
- assert_equal(self.success,True)
- """
- ############# Traffic Test
- def recv_task():
- def igmp_recv_cb(pkt):
- log_test.info('igmp data traffic received on proxy interface')
- self.success = False
- sniff(prn = igmp_recv_cb,count=1,timeout = 5, iface=self.proxy_interfaces[0])
- t = threading.Thread(target = recv_task)
- t.start()
- data = repr(monotonic.monotonic())
- pkt2 = Ether(dst='01:00:5e:09:08:07')/IP(src='10.9.8.7',dst='224.9.8.7')/data
- log_test.info('igmp data traffic packet is %s'%pkt2.show())
- sendp(pkt2,iface='veth2',count=10)
- t.join()
- assert_equal(self.success,False)
- """
-
- def test_igmpproxy_for_two_joins(self,iface='veth0'):
- groups = ['224.9.8.7','224.9.8.8']
- src = ['10.9.8.7']
- self.onos_igmp_proxy_config_load()
- self.onos_ssm_table_load(groups,src_list=src)
- def recv_task():
- def igmp_recv_cb(pkt):
- log_test.info('igmp packet received on proxy interface')
- self.success = True
- sniff(prn = igmp_recv_cb,lfilter = lambda p: IP in p and p[IP].proto == 2 and p[IP].dst==self.IP_DST, count=1,timeout = 5, iface=self.proxy_interfaces[0])
- for group in groups:
- self.success = False
- t = threading.Thread(target = recv_task)
- t.start()
- self.send_igmp_join(groups = [group], src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
- iface = iface)
- t.join()
- assert_equal(self.success,True)
-
- def test_igmpproxy_for_igmp_joins_on_non_proxy_interface(self,iface='veth0',non_proxy_iface='veth2'):
- group = ['224.9.8.7']
- src = ['10.9.8.7']
- self.onos_igmp_proxy_config_load()
- self.onos_ssm_table_load(group,src_list=src)
- def recv_task():
- def igmp_recv_cb(pkt):
- log_test.info('igmp packet received on non-proxy interface')
- self.success = True
- sniff(prn = igmp_recv_cb,lfilter = lambda p: IP in p and p[IP].proto == 2 and p[IP].dst==self.IP_DST, count=1,timeout = 5, iface=non_proxy_iface)
- self.success = False
- t = threading.Thread(target = recv_task)
- t.start()
- self.send_igmp_join(groups = [group], src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
- iface = iface)
- t.join()
- assert_equal(self.success,False)
-
- @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+10)
- def test_igmpproxy_with_join_and_verify_traffic(self):
- #groups = [self.MGROUP1, self.MGROUP1]
- groups = ["238.2.3.4"]
- self.onos_igmp_proxy_config_load()
- #self.onos_ssm_table_load(groups)
df = defer.Deferred()
- igmpState = IGMPProxyTestState(groups = groups, df = df)
- igmpStateRecv = IGMPProxyTestState(groups = groups, df = df)
+ def proxy_app_install(df):
+ self.uninstall_cord_config_app()
+ auth = ('karaf','karaf')
+ url = 'http://%s:8181/onos/v1/applications'.format(self.controller)
+ for file in self.app_files:
+ with open(file, 'rb') as payload:
+ res = requests.post(url,auth=auth,data=payload)
+ assert_equal(res.ok, True)
+ df.callback(0)
+ reactor.callLater(0, proxy_app_install, df)
+ return df
+
+ @deferred(30)
+ def test_igmpproxy_app_netcfg(self):
+ df = defer.Deferred()
+ def proxy_net_config(df):
+ auth = ('karaf','karaf')
+ net_cfg_url = 'http://172.17.0.2:8181/onos/v1/network/configuration/'.format(self.controller)
+ with open(self.proxy_config_file, 'rb') as payload:
+ res = requests.post(net_cfg_url,auth=auth,data=payload)
+ ssert_equal(res.ok, True)
+ df.callback(0)
+ reactor.callLater(0, proxy_net_config, df)
+ return df
+
+ @deferred(15)
+ def test_igmpproxy_for_first_join(self,iface='veth0'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ group = [self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(group,src_list=src)
+ try:
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_join(groups = group, src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ except Exception as error:
+ log_test.info('Igmp packet sent from subscriber interface, not received on proxy interface %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(20)
+ def test_igmpproxy_for_two_joins_with_different_igmp_groups(self,iface='veth0'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ groups = [self.random_mcast_ip(),self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(groups,src_list=src)
+ for group in groups:
+ try:
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_join(groups = [group], src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ except Exception as error:
+ log_test.info('Igmp packet sent from subscriber interface, not received on proxy interface %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(30)
+ def test_igmpproxy_for_igmp_join_with_proxy_app_deactivation(self, iface='veth0'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ groups = [self.random_mcast_ip(),self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(groups,src_list=src)
+ try:
+ for group in groups:
+ positive_test = True if group is groups[0] else False
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface,kwargs = {'positive_test':positive_test})
+ t.start()
+ self.send_igmp_join(groups = [groups[0]], src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ OnosCtrl(self.proxy_app).deactivate()
+ time.sleep(1)
+ except Exception as error:
+ log_test.info('Igmp packet sent from subscriber interface, not received on proxy interface %s'%error)
+ raise
+ OnosCtrl(self.proxy_app).activate()
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(30)
+ def test_igmpproxy_for_igmp_join_with_mcast_app_deactivation(self, iface='veth0'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ groups = [self.random_mcast_ip(),self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(groups,src_list=src)
+ try:
+ for group in groups:
+ positive_test = True if group is groups[0] else False
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface,kwargs = {'positive_test':positive_test})
+ t.start()
+ self.send_igmp_join(groups = [group], src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ OnosCtrl(self.mcast_app).deactivate()
+ time.sleep(1)
+ except Exception as error:
+ log_test.info('Igmp packet sent from subscriber interface, not received on proxy interface %s'%error)
+ raise
+ OnosCtrl(self.mcast_app).activate()
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(20)
+ def test_igmpproxy_for_igmp_joins_on_non_proxy_interface(self, iface='veth0', non_proxy_iface='veth4'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ group = [self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(group,src_list=src)
+ try:
+ t1 = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t2 = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface,kwargs = {'iface':non_proxy_iface,'positive_test':False})
+ t1.start()
+ t2.start()
+ self.send_igmp_join(groups = [group], src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ iface = iface)
+ t1.join()
+ assert_equal(self.status, True)
+ t2.join()
+ assert_equal(self.status, True)
+ except Exception as error:
+ log_test.info('Igmp packet sent from subscriber interface, not received on proxy interface %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(25)
+ def test_igmpproxy_sending_group_specific_query_receiving_igmp_leave(self, iface='veth0'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ group = [self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(group,src_list=src)
+ try:
+ self.send_igmp_join(groups = group, src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ iface = iface)
+ time.sleep(1)
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface, kwargs = {'ip_dst':group[0], 'iface':iface})
+ t.start()
+ self.send_igmp_leave(group, src_list= [], delay=10, iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ except Exception as error:
+ log_test.info('Igmp query not received on subscriber interface in response to leave sent %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(40)
+ def test_igmpproxy_verifying_group_specific_query_when_two_subscribers_leave_same_multicast_group_one_after_other(self,iface1='veth0',iface2='veth4'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ group = [self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(group,src_list=src)
+ try:
+ self.send_igmp_join(groups = group, src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ delay=1,iface = iface1)
+ self.send_igmp_join(groups = group, src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ delay=1,iface = iface2)
+ for iface in [iface1, iface2]:
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface, kwargs = {'ip_dst':group[0], 'iface':iface})
+ t.start()
+ time.sleep(1)
+ self.send_igmp_leave(group, src_list= [], delay=10, iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ except Exception as error:
+ log_test.info('Igmp query not received on subscriber interface in response to leave sent %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(60)
+ def test_igmpproxy_verifying_group_specific_query_sent_for_all_the_groups_after_subscriber_leaves(self, iface='veth0'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ groups = [self.random_mcast_ip(),self.random_mcast_ip(), self.random_mcast_ip(), self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(groups,src_list=src)
+ try:
+ self.send_igmp_join(groups = groups, src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ delay=1,iface = iface)
+ threads = []
+ for group in groups:
+ threads.append(threading.Thread(target = self.verify_igmp_packets_on_proxy_interface, kwargs = {'ip_dst':group, 'iface':iface, 'count':len(groups)}))
+ for thread in threads:
+ thread.start()
+ time.sleep(1)
+ self.send_igmp_leave(groups, src_list= [], delay=11, iface = iface)
+ for thread in threads:
+ thread.join()
+ assert_equal(self.status, True)
+ except Exception as error:
+ log_test.info('Igmp query not received on subscriber interface in response to leave sent %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(25)
+ def test_igmpproxy_fast_leave(self, iface='veth0'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ group = [self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load(FastLeave='true')
+ self.onos_ssm_table_load(group,src_list=src)
+ try:
+ self.send_igmp_join(groups = group, src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ iface = iface)
+ time.sleep(1)
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface, kwargs = {'positive_test':False, 'ip_dst':group[0], 'iface':iface})
+ t.start()
+ self.send_igmp_leave(group, src_list= [], delay=10, iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ except Exception as error:
+ log_test.info('Igmp query not received on subscriber interface in response to leave sent %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(30)
+ def test_igmpproxy_for_igmp_join_for_same_group_with_different_source(self, iface='veth0'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ group = [self.random_mcast_ip()]
+ sources = [self.randomsourceip(),self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(group,src_list=sources)
+ try:
+ for source in sources:
+ positive_test = True if source is sources[0] else False
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface,kwargs = {'positive_test':positive_test})
+ t.start()
+ self.send_igmp_join(groups = group, src_list = source, record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ time.sleep(1)
+ except:
+ log_test.info('Igmp query not received on subscriber interface in response to leave sent %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(20)
+ def test_igmpproxy_after_proxy_interface_toggles(self, iface='veth0'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ group = self.random_mcast_ip()
+ group2 = self.random_mcast_ip()
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load([group,group2],src_list=src)
+ for toggle in ['Up','Down']:
+ if toggle == 'Down':
+ log_test.info('Toggling proxy interface ')
+ os.system('ifconfig {} down'.format(self.proxy_interfaces[0]))
+ time.sleep(1)
+ os.system('ifconfig {} up'.format(self.proxy_interfaces[0]))
+ time.sleep(1)
+ group = group2
+ try:
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_join(groups = [group], src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ except:
+ log_test.info('Igmp query not received on subscriber interface in response to leave sent %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(20)
+ def test_igmpproxy_after_subscriber_interface_toggles(self,iface='veth0'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ group = self.random_mcast_ip()
+ group2 = self.random_mcast_ip()
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load([group,group2],src_list=src)
+ for toggle in ['Up','Down']:
+ if toggle == 'Down':
+ log_test.info('Toggling subscriber interface ')
+ os.system('ifconfig {} down'.format(iface))
+ time.sleep(1)
+ os.system('ifconfig {} up'.format(iface))
+ time.sleep(1)
+ group = group2
+ try:
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_join(groups = [group], src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ except:
+ log_test.info('Igmp query not received on subscriber interface in response to leave sent %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(20)
+ def test_igmpproxy_with_join_and_verify_traffic(self):
+ group = [self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(group,src_list=src)
+ df = defer.Deferred()
+ igmpState = IGMPProxyTestState(groups = group, df = df)
+ igmpStateRecv = IGMPProxyTestState(groups = group, df = df)
igmpStateList = (igmpState, igmpStateRecv)
tx_intf = self.port_map[self.PORT_TX_DEFAULT]
rx_intf = self.port_map[self.PORT_RX_DEFAULT]
- mcastTraffic = McastTraffic(groups, iface= tx_intf, cb = self.send_mcast_cb, arg = igmpState)
+ mcastTraffic = McastTraffic(group, iface= tx_intf, cb = self.send_mcast_cb, arg = igmpState)
self.df = df
self.mcastTraffic = mcastTraffic
self.recv_socket = L3PacketSocket(iface = rx_intf, type = ETH_P_IP)
@@ -585,22 +930,122 @@
else:
self.mcastTraffic.stop()
#log_test.info('Sending IGMP leave for groups: %s' %groups)
- self.send_igmp_leave(groups, iface = rx_intf, delay = 2)
+ self.send_igmp_leave(group , iface = rx_intf, delay = 2)
self.recv_socket.close()
self.igmp_verify_join(stateList)
self.df.callback(0)
-
- self.send_igmp_join(groups, iface = rx_intf)
+ self.send_igmp_join(group, iface = rx_intf)
mcastTraffic.start()
self.test_timer = reactor.callLater(self.MCAST_TRAFFIC_TIMEOUT, self.mcast_traffic_timer)
reactor.callLater(0, igmp_srp_task, igmpStateList)
return df
- @deferred(timeout=MCAST_TRAFFIC_TIMEOUT+40)
+ @deferred(50)
+ def test_igmpproxy_with_two_subscribers_joining_same_igmp_group_verifying_traffic(self, iface1='veth0', iface2='veth4'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ group = [self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(group,src_list=src)
+ igmpState = IGMPProxyTestState(groups = group, df = df)
+ IGMPProxyTestState(groups = group, df = df)
+ tx_intf = self.port_map[self.PORT_TX_DEFAULT]
+ rx_intf = self.port_map[self.PORT_RX_DEFAULT]
+ mcastTraffic = McastTraffic(group, iface= tx_intf, cb = self.send_mcast_cb,
+ arg = igmpState)
+ mcastTraffic.start()
+ time.sleep(1)
+ join_state = IGMPProxyTestState(groups = group)
+ try:
+ for iface in [iface1, iface2]:
+ positive_test = True if iface is iface1 else False
+ log_test.info('iface is %s'%iface)
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface, kwargs = {'positive_test':positive_test})
+ t.start()
+ self.send_igmp_join(groups = group, src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ status = self.igmp_recv_task(iface, group, join_state)
+ except Exception as error:
+ log_test.info('Got some unexpected error %s'%error)
+ raise
+ mcastTraffic.stop()
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(30)
+ def test_igmpproxy_with_two_subscribers_joining_different_igmp_group_verifying_traffic(self, iface1='veth0', iface2='veth4'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ groups = [self.random_mcast_ip(),self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(groups,src_list=src)
+ tx_intf = self.port_map[self.PORT_TX_DEFAULT]
+ rx_intf = self.port_map[self.PORT_RX_DEFAULT]
+ try:
+ for group in groups:
+ igmpState = IGMPProxyTestState(groups = [group], df = df)
+ IGMPProxyTestState(groups = [group], df = df)
+ mcastTraffic = McastTraffic([group], iface= tx_intf, cb = self.send_mcast_cb,
+ arg = igmpState)
+ mcastTraffic.start()
+ time.sleep(1)
+ join_state = IGMPProxyTestState(groups = [group])
+ iface = iface1 if group is groups[0] else iface2
+ log_test.info('iface is %s and group is %s'%(iface,group))
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_join(groups = [group], src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ status = self.igmp_recv_task(iface, [group], join_state)
+ mcastTraffic.stop()
+ except:
+ log_test.info('Got some unexpected error %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(30)
def test_igmpproxy_with_leave_and_verify_traffic(self):
- groups = [self.MGROUP1]
- leave_groups = [self.MGROUP1]
- self.onos_ssm_table_load(groups)
+ group = [self.random_mcast_ip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(group)
+ df = defer.Deferred()
+ igmpState = IGMPProxyTestState(groups = group, df = df)
+ IGMPProxyTestState(groups = group, df = df)
+ tx_intf = self.port_map[self.PORT_TX_DEFAULT]
+ rx_intf = self.port_map[self.PORT_RX_DEFAULT]
+ mcastTraffic = McastTraffic(group, iface= tx_intf, cb = self.send_mcast_cb,
+ arg = igmpState)
+ mcastTraffic.start()
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_join(group, iface = rx_intf,delay=1)
+ t.join()
+ assert_equal(self.status, True)
+ join_state = IGMPProxyTestState(groups = group)
+ status = self.igmp_recv_task(rx_intf, group, join_state)
+ self.send_igmp_leave(group, delay = 10, iface = rx_intf)
+ join_state = IGMPProxyTestState(groups = group)
+ status = self.igmp_not_recv_task(rx_intf, group, join_state)
+ log_test.info('verified status for igmp recv task %s'%status)
+ assert status == 1 , 'EXPECTED RESULT'
+ df.callback(0)
+ return df
+
+ @deferred(30)
+ def test_igmpproxy_data_traffic_for_non_joined_group(self):
+ groups = [self.random_mcast_ip(),self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(groups,src_list=src)
df = defer.Deferred()
igmpState = IGMPProxyTestState(groups = groups, df = df)
IGMPProxyTestState(groups = groups, df = df)
@@ -608,58 +1053,69 @@
rx_intf = self.port_map[self.PORT_RX_DEFAULT]
mcastTraffic = McastTraffic(groups, iface= tx_intf, cb = self.send_mcast_cb,
arg = igmpState)
- self.df = df
- self.mcastTraffic = mcastTraffic
- self.recv_socket = L3PacketSocket(iface = rx_intf, type = ETH_P_IP)
-
- mcastTraffic.start()
- self.send_igmp_join(groups, iface = rx_intf)
- time.sleep(5)
- self.send_igmp_leave(leave_groups, delay = 3, iface = rx_intf)
- time.sleep(10)
- join_state = IGMPProxyTestState(groups = leave_groups)
- status = self.igmp_not_recv_task(rx_intf, leave_groups, join_state)
- log_test.info('verified status for igmp recv task %s'%status)
- assert status == 1 , 'EXPECTED RESULT'
- self.df.callback(0)
+ mcastTraffic.start()
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_join([groups[0]],src_list= src, iface = rx_intf,delay=1)
+ t.join()
+ assert_equal(self.status, True)
+ join_state = IGMPProxyTestState(groups = [groups[0]])
+ status = self.igmp_recv_task(rx_intf, [groups[0]], join_state)
+ join_state = IGMPProxyTestState(groups = [groups[1]])
+ status = self.igmp_not_recv_task(rx_intf, [groups[1]], join_state)
+ log_test.info('verified status for igmp recv task %s'%status)
+ mcastTraffic.stop()
+ assert status == 1 , 'EXPECTED RESULT'
+ df.callback(0)
return df
- @deferred(timeout=100)
+ #fail
+ @deferred(timeout=60)
def test_igmpproxy_with_leave_and_join_loop(self):
self.groups = ['226.0.1.1', '227.0.0.1', '228.0.0.1', '229.0.0.1', '230.0.0.1' ]
self.src_list = ['3.4.5.6', '7.8.9.10']
+ self.onos_igmp_proxy_config_load()
self.onos_ssm_table_load(self.groups,src_list=self.src_list)
df = defer.Deferred()
- self.df = df
+ #self.df = df
self.iterations = 0
self.num_groups = len(self.groups)
- self.MAX_TEST_ITERATIONS = 10
+ self.MAX_TEST_ITERATIONS = 3
rx_intf = self.port_map[self.PORT_RX_DEFAULT]
+ self.send_igmp_leave(self.groups,src_list = [], iface=rx_intf,delay=5)
def igmp_srp_task(v):
if self.iterations < self.MAX_TEST_ITERATIONS:
if v == 1:
##join test
self.num_groups = random.randint(0, len(self.groups))
- self.send_igmp_join(self.groups[:self.num_groups],
- src_list = self.src_list,
- iface = rx_intf, delay = 0)
+ log_test.info('self.num_groups var is %s'%self.num_groups)
+ try:
+ for group in self.groups[:self.num_groups]:
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_join(group,src_list = self.src_list,
+ iface = rx_intf, delay = 1)
+ t.join()
+ assert_equal(self.status, True)
+ except:
+ log_test.info('Got some unexpected error %s'%error)
+ raise
else:
self.send_igmp_leave(self.groups[:self.num_groups],
- src_list = self.src_list,
- iface = rx_intf, delay = 0)
+ src_list = [],
+ iface = rx_intf, delay = 10)
self.iterations += 1
v ^= 1
reactor.callLater(1.0 + 0.5*self.num_groups,
igmp_srp_task, v)
else:
- self.df.callback(0)
-
+ df.callback(0)
reactor.callLater(0, igmp_srp_task, 1)
return df
def igmp_join_task(self, intf, groups, state, src_list = ['1.2.3.4']):
- #self.onos_ssm_table_load(groups, src_list)
+ self.onos_ssm_table_load(groups, src_list)
igmp = IGMPv3(type = IGMP_TYPE_V3_MEMBERSHIP_REPORT, max_resp_code=30,
gaddr=self.IP_DST)
for g in groups:
@@ -681,7 +1137,7 @@
for g in groups:
group_map[g] = [0,0]
- log_test.info('Verifying join interface should receive multicast data')
+ log_test.info('Verifying join interface %s should receive multicast data'%intf)
while True:
p = recv_socket.recv()
if p.dst in groups and group_map[p.dst][0] == 0:
@@ -721,7 +1177,7 @@
def group_latency_check(self, groups):
tasks = []
- self.send_igmp_leave(groups = groups)
+ self.send_igmp_leave(groups = groups,delay=10)
join_state = IGMPProxyTestState(groups = groups)
tasks.append(threading.Thread(target=self.igmp_join_task, args = ('veth0', groups, join_state,)))
traffic_state = IGMPProxyTestState(groups = groups)
@@ -740,7 +1196,7 @@
@deferred(timeout=IGMP_QUERY_TIMEOUT + 10)
def test_igmpproxy_with_1group_join_latency(self):
- groups = ['239.0.1.1']
+ groups = [self.random_mcast_ip()]
df = defer.Deferred()
def igmp_1group_join_latency():
self.group_latency_check(groups)
@@ -758,7 +1214,7 @@
reactor.callLater(0, igmp_2group_join_latency)
return df
- @deferred(timeout=IGMP_QUERY_TIMEOUT + 10)
+ @deferred(timeout=IGMP_QUERY_TIMEOUT + 100)
def test_igmpproxy_with_Ngroup_join_latency(self):
groups = ['239.0.1.1', '240.0.1.1', '241.0.1.1', '242.0.1.1']
df = defer.Deferred()
@@ -768,14 +1224,27 @@
reactor.callLater(0, igmp_Ngroup_join_latency)
return df
- def test_igmpproxy_with_join_rover_all(self):
- s = (224 << 24) | 1
- #e = (225 << 24) | (255 << 16) | (255 << 16) | 255
- e = (224 << 24) | 10
- for i in xrange(s, e+1):
- if i&0xff:
- ip = '%d.%d.%d.%d'%((i>>24)&0xff, (i>>16)&0xff, (i>>8)&0xff, i&0xff)
- self.send_igmp_join([ip], delay = 0)
+ @deferred(70)
+ def test_igmpproxy_with_join_rover_all(self,iface='veth0'):
+ self.onos_igmp_proxy_config_load()
+ df = defer.Deferred()
+ def igmp_proxy_join_rover():
+ s = (224 << 16) | 1
+ #e = (225 << 24) | (255 << 16) | (255 << 16) | 255
+ e = (224 << 16) | 10
+ for i in xrange(s, e+1):
+ if i&0xff:
+ ip = '%d.%d.%d.%d'%((i>>16)&0xff, (i>>16)&0xff, (i>>8)&0xff, i&0xff)
+ try:
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_join(groups = [ip], ssm_load=True, iface = iface, delay=1)
+ t.join()
+ except:
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_join_rover)
+ return df
@deferred(timeout=ROVER_TEST_TIMEOUT)
def test_igmpproxy_with_join_rover(self):
@@ -814,24 +1283,343 @@
reactor.callLater(0, igmp_join_rover, self)
return df
- @deferred(timeout=IGMP_QUERY_TIMEOUT + 10)
- def test_igmpproxy_with_query(self):
- groups = ['224.0.0.1'] ##igmp query group
+ #fail
+ @deferred(timeout=IGMP_QUERY_TIMEOUT + 30)
+ def test_igmpproxy_sends_periodic_general_query_on_subscriber_connected_segment(self,iface='veth0'):
+ groups = [self.random_mcast_ip()]
+ self.onos_igmp_proxy_config_load()
self.onos_ssm_table_load(groups)
+ self.send_igmp_join(groups)
+ self.success = False
df = defer.Deferred()
- self.df = df
- self.recv_socket = L2Socket(iface = 'veth0', type = ETH_P_IP)
-
def igmp_query_timeout():
def igmp_query_cb(pkt):
log_test.info('received igmp query packet is %s'%pkt.show())
- log_test.info('Got IGMP query packet from %s for %s' %(pkt[IP].src, pkt[IP].dst))
- assert_equal(pkt[IP].dst, '224.0.0.1')
- sniff(prn = igmp_query_cb, count=1, lfilter = lambda p: IP in p and p[IP].dst in groups,
- opened_socket = self.recv_socket)
- self.recv_socket.close()
- self.df.callback(0)
+ self.success = True
+ sniff(prn = igmp_query_cb, count=1, lfilter = lambda p: IP in p and p[IP].proto == 2 and p[IP].dst == '224.0.0.1',
+ timeout = self.IGMP_QUERY_TIMEOUT+2, iface = iface)
+ df.callback(0)
+ self.send_igmp_join(groups)
+ self.test_timer = reactor.callLater(0,igmp_query_timeout)
+ assert_equal(self.success, True)
+ return df
- #self.send_igmp_join(groups)
- self.test_timer = reactor.callLater(self.IGMP_QUERY_TIMEOUT, igmp_query_timeout)
+
+ @deferred(timeout=IGMP_QUERY_TIMEOUT + 30)
+ def test_igmpproxy_with_not_sending_periodic_general_query_on_proxy_connected_interface(self):
+ groups = [self.random_mcast_ip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(groups)
+ self.send_igmp_join(groups)
+ self.success = False
+ df = defer.Deferred()
+ def igmp_query_timeout():
+ def igmp_query_cb(pkt):
+ log_test.info('received igmp query packet on proxy connected interface %s'%pkt.show())
+ self.success = True
+ sniff(prn = igmp_query_cb, count=1, lfilter = lambda p: IP in p and p[IP].proto == 2 and p[IP].dst == '224.0.0.1',
+ timeout = self.IGMP_QUERY_TIMEOUT+2, iface = self.proxy_interfaces[0])
+ df.callback(0)
+ self.send_igmp_join(groups)
+ self.test_timer = reactor.callLater(0,igmp_query_timeout)
+ assert_equal(self.success, False)
+ return df
+
+ @deferred(50)
+ def test_igmpproxy_two_joins_one_leave_from_same_subscriber_and_verify_traffic(self,iface='veth0'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ groups = [self.random_mcast_ip(),self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(groups,src_list=src)
+ tx_intf = self.port_map[self.PORT_TX_DEFAULT]
+ rx_intf = self.port_map[self.PORT_RX_DEFAULT]
+ try:
+ for group in groups:
+ igmpState = IGMPProxyTestState(groups = [group], df = df)
+ IGMPProxyTestState(groups = [group], df = df)
+ mcastTraffic = McastTraffic([group], iface= tx_intf, cb = self.send_mcast_cb,
+ arg = igmpState)
+ mcastTraffic.start()
+ time.sleep(1)
+ join_state = IGMPProxyTestState(groups = [group])
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_join(groups = [group], src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ status = self.igmp_recv_task(iface, [group], join_state)
+ if group is groups[1]:
+ log_test.info('sending leave for group %s'%group)
+ self.send_igmp_leave([group], delay = 11, iface = iface)
+ join_state = IGMPProxyTestState(groups = [group])
+ status = self.igmp_not_recv_task(rx_intf, [group], join_state)
+ log_test.info('verified status for igmp recv task %s'%status)
+ assert status == 1 , 'EXPECTED RESULT'
+ log_test.info('verifying subscriber receives igmp traffic for group %s'%groups[0])
+ join_state = IGMPProxyTestState(groups = [groups[0]])
+ status = self.igmp_recv_task(iface, [groups[0]], join_state)
+ mcastTraffic.stop()
+ except:
+ log_test.info('Got some unexpected error %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ #fail
+ @deferred(50)
+ def test_igmpproxy_two_subscribers_joins_igmp_group_one_subscriber_goes_down_and_verify_traffic(self,iface1='veth0',iface2='veth4'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ group = [self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(group,src_list=src)
+ tx_intf = self.port_map[self.PORT_TX_DEFAULT]
+ rx_intf = self.port_map[self.PORT_RX_DEFAULT]
+ try:
+ igmpState = IGMPProxyTestState(groups = group, df = df)
+ IGMPProxyTestState(groups = group, df = df)
+ mcastTraffic = McastTraffic(group, iface= tx_intf, cb = self.send_mcast_cb,
+ arg = igmpState)
+ mcastTraffic.start()
+ time.sleep(1)
+ join_state = IGMPProxyTestState(groups = group)
+ for iface in [iface1, iface2]:
+ positive_test = True if iface is iface1 else False
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface, kwargs = {'positive_test':positive_test})
+ t.start()
+ self.send_igmp_join(groups = group, src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ status = self.igmp_recv_task(iface, group, join_state)
+ if iface is iface2:
+ log_test.info('bringning donw iface %s'%iface)
+ os.system('ifconfig {} down'.format(iface))
+ time.sleep(1)
+ os.system('ifconfig {} up'.format(iface))
+ time.sleep(1)
+ status = self.igmp_not_recv_task(iface, group, join_state)
+ log_test.info('verified status for igmp recv task %s'%status)
+ assert status == 1 , 'EXPECTED RESULT'
+ log_test.info('verifying subscriber %s receives igmp traffic'%iface1)
+ status = self.igmp_recv_task(iface1, group, join_state)
+ mcastTraffic.stop()
+ except:
+ log_test.info('Got some unexpected error %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(50)
+ def test_igmpproxy_two_subscribers_join_different_igmp_groups_one_subscriber_leaves_and_verifying_traffic(self, iface1='veth0', iface2='veth4'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ groups = [self.random_mcast_ip(),self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(groups,src_list=src)
+ tx_intf = self.port_map[self.PORT_TX_DEFAULT]
+ rx_intf = self.port_map[self.PORT_RX_DEFAULT]
+ try:
+ for group in groups:
+ igmpState = IGMPProxyTestState(groups = [group], df = df)
+ IGMPProxyTestState(groups = [group], df = df)
+ mcastTraffic = McastTraffic([group], iface= tx_intf, cb = self.send_mcast_cb,
+ arg = igmpState)
+ mcastTraffic.start()
+ time.sleep(1)
+ join_state = IGMPProxyTestState(groups = [group])
+ iface = iface1 if group is groups[0] else iface2
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_join(groups = [group], src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ delay=1,iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ status = self.igmp_recv_task(iface, [group], join_state)
+ if group is groups[1]:
+ log_test.info('sending leave for group %s'%group)
+ time.sleep(3)
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_leave([group], delay = 15, iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ join_state = IGMPProxyTestState(groups = [group])
+ status = self.igmp_not_recv_task(iface, [group], join_state)
+ log_test.info('verified status for igmp recv task %s'%status)
+ assert status == 1 , 'EXPECTED RESULT'
+ log_test.info('verifying subscriber receives igmp traffic for group %s'%groups[0])
+ join_state = IGMPProxyTestState(groups = [groups[0]])
+ status = self.igmp_recv_task(iface1, [groups[0]], join_state)
+ mcastTraffic.stop()
+ except:
+ log_test.info('Got some unexpected error %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ @deferred(50)
+ def test_igmpproxy_with_two_subscriber_joining_same_igmp_group_one_subscriber_doing_fast_leave_verifying_traffic(self, iface1='veth0', iface2='veth4'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ group = [self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load(FastLeave='true')
+ self.onos_ssm_table_load(group,src_list=src)
+ tx_intf = self.port_map[self.PORT_TX_DEFAULT]
+ rx_intf = self.port_map[self.PORT_RX_DEFAULT]
+ try:
+ for iface in [iface1, iface2]:
+ igmpState = IGMPProxyTestState(groups = group, df = df)
+ IGMPProxyTestState(groups = group, df = df)
+ mcastTraffic = McastTraffic(group, iface= tx_intf, cb = self.send_mcast_cb,
+ arg = igmpState)
+ mcastTraffic.start()
+ time.sleep(1)
+ join_state = IGMPProxyTestState(groups = group)
+ positive_test = True if iface is iface1 else False
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface, kwargs = {'positive_test':positive_test})
+ t.start()
+ self.send_igmp_join(groups = group, src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ delay=1,iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ status = self.igmp_recv_task(iface, group, join_state)
+ if iface is iface2:
+ log_test.info('sending leave for group %s'%group)
+ time.sleep(10)
+ self.send_igmp_leave(group, delay = 1, iface = iface)
+ join_state = IGMPProxyTestState(groups = group)
+ status = self.igmp_not_recv_task(iface, group, join_state)
+ log_test.info('verified status for igmp recv task %s'%status)
+ assert status == 1 , 'EXPECTED RESULT'
+ log_test.info('verifying subscriber receives igmp traffic for group %s'%group)
+ join_state = IGMPProxyTestState(groups = group)
+ status = self.igmp_recv_task(iface1, group, join_state)
+ mcastTraffic.stop()
+ except:
+ log_test.info('Got some unexpected error %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ #fail
+ @deferred(20)
+ def test_igmpproxy_with_multicast_source_connected_on_proxy_interface(self, iface='veth0'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ group = [self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(group,src_list=src)
+ tx_intf = self.port_map[self.PORT_TX_DEFAULT]
+ rx_intf = self.port_map[self.PORT_RX_DEFAULT]
+ igmpState = IGMPProxyTestState(groups = group, df = df)
+ IGMPProxyTestState(groups = group, df = df)
+ mcastTraffic = McastTraffic(group, iface= tx_intf, cb = self.send_mcast_cb,
+ arg = igmpState)
+ mcastTraffic.start()
+ time.sleep(1)
+ join_state = IGMPProxyTestState(groups = group)
+ try:
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_join(groups = group, src_list = src,record_type = IGMP_V3_GR_TYPE_INCLUDE,
+ delay=1,iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ status = self.igmp_recv_task(iface, group, join_state)
+ mcastTraffic.stop()
+ except:
+ log_test.info('Got some unexpected error %s'%error)
+ raise
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ #fail
+ @deferred(20)
+ def test_igmpproxy_which_drops_multicast_traffic_for_exclude_record_type_group(self, iface='veth0'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ group = [self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(group,src_list=src)
+ tx_intf = self.port_map[self.PORT_TX_DEFAULT]
+ rx_intf = self.port_map[self.PORT_RX_DEFAULT]
+ try:
+ igmpState = IGMPProxyTestState(groups = group, df = df)
+ IGMPProxyTestState(groups = group, df = df)
+ mcastTraffic = McastTraffic(group, iface= tx_intf, cb = self.send_mcast_cb,
+ arg = igmpState)
+ mcastTraffic.start()
+ time.sleep(1)
+ join_state = IGMPProxyTestState(groups = group)
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_join(groups = group, src_list = src,record_type = IGMP_V3_GR_TYPE_EXCLUDE,
+ iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ status = self.igmp_not_recv_task(iface, group, join_state)
+ log_test.info('verified status for igmp recv task %s'%status)
+ assert status == 1 , 'EXPECTED RESULT'
+ except:
+ log_test.info('Got some unexpected error %s'%error)
+ raise
+ mcastTraffic.stop()
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
+ return df
+
+ #fail : exclude record type igmp join not forwarded to proxy interface
+ @deferred(40)
+ def test_igmpproxy_with_two_subscriber_joins_set_with_include_and_exclude_mode_record_types_verifying_traffic(self, iface1='veth0', iface2='veth4'):
+ df = defer.Deferred()
+ def igmp_proxy_test(df):
+ groups = [self.random_mcast_ip(), self.random_mcast_ip()]
+ src = [self.randomsourceip()]
+ self.onos_igmp_proxy_config_load()
+ self.onos_ssm_table_load(groups,src_list=src)
+ tx_intf = self.port_map[self.PORT_TX_DEFAULT]
+ rx_intf = self.port_map[self.PORT_RX_DEFAULT]
+ try:
+ for group in groups:
+ iface = iface1 if group is groups[0] else iface2
+ r_type = IGMP_V3_GR_TYPE_INCLUDE if group is groups[0] else IGMP_V3_GR_TYPE_EXCLUDE
+ igmpState = IGMPProxyTestState(groups = [group], df = df)
+ IGMPProxyTestState(groups = [group], df = df)
+ mcastTraffic = McastTraffic([group], iface= tx_intf, cb = self.send_mcast_cb,
+ arg = igmpState)
+ mcastTraffic.start()
+ time.sleep(1)
+ join_state = IGMPProxyTestState(groups = [group])
+ t = threading.Thread(target = self.verify_igmp_packets_on_proxy_interface)
+ t.start()
+ self.send_igmp_join(groups = [group], src_list = src,record_type = r_type,
+ delay=1,iface = iface)
+ t.join()
+ assert_equal(self.status, True)
+ if group is groups[0]:
+ status = self.igmp_recv_task(iface, [group], join_state)
+ else:
+ status = self.igmp_not_recv_task(iface, [group], join_state)
+ log_test.info('verified status for igmp recv task %s'%status)
+ assert status == 1 , 'EXPECTED RESULT'
+ except:
+ log_test.info('Got some unexpected error %s'%error)
+ raise
+ mcastTraffic.stop()
+ df.callback(0)
+ reactor.callLater(0, igmp_proxy_test, df)
return df