def test_traff_from_vm_to_allvms(self, vm_name, proto='all'):
"""
Test Full Mesh Traffic from bw VMs' FIPs
"""
dest_vm_fips = {}
dest_vms = self.vm_list
print 'VM List before Remove', self.vm_list
dest_vms.remove(vm_name)
print 'VM List After Remove', self.vm_list
for vm in dest_vms:
dest_vm_fips[vm] = self.vm_to_ip_ns[vm][0][1:3]
print dest_vm_fips
flattended_dest_vm_fips = [
fip for x in dest_vm_fips.values() for fip in x
]
print flattended_dest_vm_fips
dhcp_ns_vm = self.vm_to_ip_ns[vm_name][1]
vm_pvt_ip = self.vm_to_ip_ns[vm_name][0][0]
gbppexptraff = gbpExpTraff(self.ntk_node, dhcp_ns_vm, vm_pvt_ip,
flattended_dest_vm_fips)
# Run for all protocols irrespective of the contract type
results = gbppexptraff.test_run(protocols=['icmp', 'tcp'],
tcp_syn_only=1)
# Restore the self.vm_list by appending the vm_name which was removed
# earlier
self.vm_list.append(vm_name)
print 'VM List After Restoration', self.vm_list
if results == {}:
return 2
else:
return self.verify_traff(results, dest_vm_fips, proto)
def test_traff_anyvm_to_extgw(self, vm_name, extgw, proto='all', jumbo=0):
"""
Test Traffic from each VM to ExtGW
"""
for vm in self.vm_list:
#vm_to_ip_list = self.gbpnova.get_any_vm_property(vm)['networks'][0]
vm_to_ip_list = self.gbpnova.get_any_vm_property(vm)[0]
vm_to_ip_list = [ip.encode('ascii') for ip in vm_to_ip_list]
src_vm_pvt_ip_subnet = re.search(
'(\d+.\d+.\d+).\d+', vm_to_ip_list[0].encode('ascii'), re.I).group(1)
src_vm_dhcp_ns = self.gbpcfg.get_netns(vm)
#src_vm_dhcp_ns = self.gbpcfg.get_netns(
# self.ntk_node, src_vm_pvt_ip_subnet)
self.vm_to_ip_ns[vm] = [vm_to_ip_list, src_vm_dhcp_ns]
print 'VM-to-IP-NS == %s' % (self.vm_to_ip_ns)
dhcp_ns_vm = self.vm_to_ip_ns[vm_name][1]
vm_pvt_ip = self.vm_to_ip_ns[vm_name][0][0]
print 'EXTERNAL GW IPs from TESTUITE == ', extgw
gbppexptraff = gbpExpTraff(
self.ntk_node, dhcp_ns_vm, vm_pvt_ip, extgw)
# Run for all protocols irrespective of the contract type
results = gbppexptraff.test_run(
protocols=['icmp', 'tcp'], tcp_syn_only=1,jumbo=1)
if results == {}:
return 2
else:
return self.verify_traff(results, extgw, proto)
def test_traff_anyvm_to_extgw(self, vm_name, extgw, proto='all', jumbo=0):
"""
Test Traffic from each VM to ExtGW
"""
for vm in self.vm_list:
#vm_to_ip_list = self.gbpnova.get_any_vm_property(vm)['networks'][0]
vm_to_ip_list = self.gbpnova.get_any_vm_property(vm)[0]
vm_to_ip_list = [ip.encode('ascii') for ip in vm_to_ip_list]
src_vm_pvt_ip_subnet = re.search('(\d+.\d+.\d+).\d+',
vm_to_ip_list[0].encode('ascii'),
re.I).group(1)
src_vm_dhcp_ns = self.gbpcfg.get_netns(vm)
#src_vm_dhcp_ns = self.gbpcfg.get_netns(
# self.ntk_node, src_vm_pvt_ip_subnet)
self.vm_to_ip_ns[vm] = [vm_to_ip_list, src_vm_dhcp_ns]
print 'VM-to-IP-NS == %s' % (self.vm_to_ip_ns)
dhcp_ns_vm = self.vm_to_ip_ns[vm_name][1]
vm_pvt_ip = self.vm_to_ip_ns[vm_name][0][0]
print 'EXTERNAL GW IPs from TESTUITE == ', extgw
gbppexptraff = gbpExpTraff(self.ntk_node, dhcp_ns_vm, vm_pvt_ip, extgw)
# Run for all protocols irrespective of the contract type
results = gbppexptraff.test_run(protocols=['icmp', 'tcp'],
tcp_syn_only=1,
jumbo=1)
if results == {}:
return 2
else:
return self.verify_traff(results, extgw, proto)
def send_traff_for_aap(self): aap_tr = gbpExpTraff(COMPUTE1,self.dhcp_netns,\ self.vm_prop[self.vm1]['ip'], self.vm_prop[self.vm1]['ip'] ) if not aap_tr.aap_traff(self.vip): return 0 return 1
def send_traff_for_aap(self):
aap_tr = gbpExpTraff(COMPUTE1,self.dhcp_netns,\
self.vm_prop[self.vm1]['ip'],
self.vm_prop[self.vm1]['ip']
)
if not aap_tr.aap_traff(self.vip):
return 0
return 1
def verify_traff(self):
"""
Verifies the expected traffic result per testcase
"""
# Incase of Diff PTG Diff L2P and DIff L3P all traffic is disallowed irrespective what Policy-Ruleset is applied
# Hence verify_traff will check for all protocols including the
# implicit ones
if self.vm_loc == 'diff_host_same_leaf' or self.vm_loc == 'diff_host_diff_leaf':
dest_ip = self.gbpcfg.get_vm_subnet('VM12', ret='ip')
self._log.debug(
'VM10-IP: %s, VM10-subnet: %s, Dest-IP: %s, NetNS: %s' %
(self.vm10_ip, self.vm10_subn, dest_ip, self.dhcp_ns))
gbppexptraff = gbpExpTraff(self.ntk_node, self.dhcp_ns,
self.vm10_ip, dest_ip)
if self.vm_loc == 'same_host':
dest_ip = self.gbpcfg.get_vm_subnet('VM11', ret='ip')
self._log.debug(
'VM10-IP: %s, VM10-subnet: %s, Dest-IP: %s, NetNS: %s' %
(self.vm10_ip, self.vm10_subn, dest_ip, self.dhcp_ns))
gbppexptraff = gbpExpTraff(self.ntk_node, self.dhcp_ns,
self.vm10_ip, dest_ip)
results = gbppexptraff.test_run()
self._log.info("Results from the Testcase == %s" % (results))
if results == {} or results == 2:
return 0
failed = {}
if type(dest_ip) is list:
for ip in dest_ip:
ip_failed = {
key: val
for key, val in results[ip].iteritems() if val == 1
}
if ip_failed:
failed[ip] = ip_failed
else:
failed = {
key: val
for key, val in results[dest_ip].iteritems() if val == 1
}
if len(failed) > 0:
self._log.error('Following traffic_types %s = Failed' % (failed))
return 0
else:
return 1
def verify_traff(self):
"""
Verifies the expected traffic result per testcase
"""
# Incase of Same PTG all traffic is allowed irrespective what Policy-Ruleset is applied
# Hence verify_traff will check for all protocols including the
# implicit ones
if self.vm_loc == 'diff_host_same_leaf' or self.vm_loc == 'diff_host_diff_leaf':
dest_ip = self.gbpcfg.get_vm_subnet('VM3', ret='ip')
self._log.debug("VM1-IP: %s, VM1-subnet: %s, Dest-IP: %s, NetNS: %s" %(self.vm1_ip, self.vm1_subn, dest_ip, self.dhcp_ns))
gbppexptraff = gbpExpTraff(
self.ntk_node, self.dhcp_ns, self.vm1_ip, dest_ip)
if self.vm_loc == 'same_host':
dest_ip = self.gbpcfg.get_vm_subnet('VM2', ret='ip')
self._log.debug("VM1-IP: %s, VM1-subnet: %s, Dest-IP: %s, NetNS: %s" %(self.vm1_ip, self.vm1_subn, dest_ip, self.dhcp_ns))
gbppexptraff = gbpExpTraff(
self.ntk_node, self.dhcp_ns, self.vm1_ip, dest_ip)
results = gbppexptraff.test_run()
self._log.info('Results from the Testcase == %s' %(results))
if results == 2:
return 2
if type(dest_ip) is list:
failed = {}
for ip in dest_ip:
ip_failed = {key: val for key, val in results[
ip].iteritems() if val == 0}
if ip_failed:
failed[ip] = ip_failed
else:
failed = {key: val for key, val in results[
dest_ip].iteritems() if val == 0}
if len(failed) > 0:
self._log.error('Following traffic_types %s = Failed' % (failed))
return 0
else:
return 1
def test_traff_anyvm_to_extgw(self, vm_name, extgw, proto='all', jumbo=0):
"""
Test Traffic from each VM to ExtGW
"""
dhcp_ns_vm = self.vm_to_ip_ns[vm_name][1]
vm_pvt_ip = self.vm_to_ip_ns[vm_name][0][0]
print 'EXTERNAL GW IPs from TESTUITE == ', extgw
gbppexptraff = gbpExpTraff(self.ntk_node, dhcp_ns_vm, vm_pvt_ip, extgw)
# Run for all protocols irrespective of the contract type
results = gbppexptraff.test_run(protocols=['icmp', 'tcp'],
tcp_syn_only=1,
jumbo=1)
if results == {}:
return 2
else:
return self.verify_traff(results, extgw, proto)
def verify_traff(self, proto=['all']):
"""
Verifies the expected traffic result per testcase
"""
# Incase of Diff PTG Same L2 & L3P all traffic is dis-allowed by default unless Policy-Ruleset is applied
# Hence verify_traff will check for all protocols including the
# implicit ones
if self.vm_loc == 'diff_host_same_leaf' or self.vm_loc == 'diff_host_diff_leaf':
dest_ip = self.gbpcfg.get_vm_subnet('VM9', ret='ip')
self._log.debug('VM7-IP: %s, VM7-subnet: %s, Dest-IP: %s, NetNS: %s' %(self.vm7_ip, self.vm7_subn, dest_ip, self.dhcp_ns))
gbppexptraff = gbpExpTraff(
self.ntk_node, self.dhcp_ns, self.vm7_ip, dest_ip)
if self.vm_loc == 'same_host':
dest_ip = self.gbpcfg.get_vm_subnet('VM8', ret='ip')
self._log.debug('VM7-IP: %s, VM7-subnet: %s, Dest-IP: %s, NetNS: %s' %(self.vm7_ip, self.vm7_subn, dest_ip, self.dhcp_ns))
gbppexptraff = gbpExpTraff(
self.ntk_node, self.dhcp_ns, self.vm7_ip, dest_ip)
results = gbppexptraff.test_run()
self._log.info('Results from the Testcase == %s' %(results))
if results == 2:
return 2
failed = {}
# In 'all' proto is verified for PTGs with NO_PRS, PRS_NO_RULE,
# REM_PRS, hence below val ==1, then Fail, because pkts were
# expected to be dropped but they were NOT(hence the Test should
# be marked FAIL.
if proto[0] == 'all':
if type(dest_ip) is list:
failed = {}
for ip in dest_ip:
ip_failed = {key: val for key, val in results[
ip].iteritems() if val == 1}
if ip_failed:
failed[ip] = ip_failed
else:
failed = {key: val for key, val in results[
dest_ip].iteritems() if val == 1}
if len(failed) > 0:
self._log.error('For All Protcol Following traffic_types %s = Failed' %(failed))
return 0
else:
return 1
else:
implicit_allow = ['arp', 'dhcp', 'dns']
allow_list = implicit_allow + proto
if type(dest_ip) is list:
failed = {}
for ip in dest_ip:
ip_failed = {key: val for key, val in results[
ip].iteritems() if val == 0 and key in allow_list}
ip_failed.update({key: val for key, val in results[
ip].iteritems() if val == 1 and key not in allow_list})
if ip_failed:
failed[ip] = ip_failed
else:
failed = {key: val for key, val in results[
dest_ip].iteritems() if val == 0 and key in allow_list}
failed.update({key: val for key, val in results[
dest_ip].iteritems() if val == 1 and key not in allow_list})
if len(failed) > 0:
self._log.error('Following traffic_types %s = Failed' %(failed))
return 0
else:
return 1
def verify_traff(self, proto=['all']):
"""
Verifies the expected traffic result per testcase
"""
# Incase of Diff PTG Same L2 & L3P all traffic is dis-allowed by default unless Policy-Ruleset is applied
# Hence verify_traff will check for all protocols including the
# implicit ones
if self.vm_loc == 'diff_host_same_leaf' or self.vm_loc == 'diff_host_diff_leaf':
dest_ip = self.gbpcfg.get_vm_subnet('VM6', ret='ip')
self._log.debug(
'VM4-IP: %s, VM4-subnet: %s, Dest-IP: %s, NetNS: %s' %
(self.vm4_ip, self.vm4_subn, dest_ip, self.dhcp_ns))
gbppexptraff = gbpExpTraff(self.ntk_node, self.dhcp_ns,
self.vm4_ip, dest_ip)
if self.vm_loc == 'same_host':
dest_ip = self.gbpcfg.get_vm_subnet('VM5', ret='ip')
self._log.debug(
'VM4-IP: %s, VM4-subnet: %s, Dest-IP: %s, NetNS: %s' %
(self.vm4_ip, self.vm4_subn, dest_ip, self.dhcp_ns))
gbppexptraff = gbpExpTraff(self.ntk_node, self.dhcp_ns,
self.vm4_ip, dest_ip)
results = gbppexptraff.test_run()
self._log.info('Results from the Testcase == %s' % (results))
if results == 2:
return 2
failed = {}
# In 'all' proto is verified for PTGs with NO_PRS, PRS_NO_RULE,
# REM_PRS, hence below val ==1, then Fail, because pkts were
# expected to be dropped but they were NOT(hence the Test should
# be marked FAIL.
if proto[0] == 'all':
if type(dest_ip) is list:
failed = {}
for ip in dest_ip:
ip_failed = {
key: val
for key, val in results[ip].iteritems() if val == 1
}
if ip_failed:
failed[ip] = ip_failed
else:
failed = {
key: val
for key, val in results[dest_ip].iteritems() if val == 1
}
if len(failed) > 0:
self._log.error(
'For All Protcol Following traffic_types %s = Failed' %
(failed))
return 0
else:
return 1
else:
implicit_allow = ['arp', 'dhcp', 'dns']
allow_list = implicit_allow + proto
if type(dest_ip) is list:
failed = {}
for ip in dest_ip:
ip_failed = {
key: val
for key, val in results[ip].iteritems()
if val == 0 and key in allow_list
}
ip_failed.update({
key: val
for key, val in results[ip].iteritems()
if val == 1 and key not in allow_list
})
if ip_failed:
failed[ip] = ip_failed
else:
failed = {
key: val
for key, val in results[dest_ip].iteritems()
if val == 0 and key in allow_list
}
failed.update({
key: val
for key, val in results[dest_ip].iteritems()
if val == 1 and key not in allow_list
})
if len(failed) > 0:
self._log.error('Following traffic_types %s = Failed' %
(failed))
return 0
else:
return 1