def start_tcpdump(self, session, tap_intf, vlan=None, vm_fixtures=[], pcap_on_vm=False, no_header = False):
filt_str = ''
if not no_header:
filt_str = 'udp port 8099'
if not pcap_on_vm:
pcap = '/tmp/mirror-%s_%s.pcap' % (tap_intf, get_random_name())
cmd = 'rm -f %s' % pcap
execute_cmd(session, cmd, self.logger)
assert check_pcap_file_exists(session, pcap, expect=False),'pcap file still exists'
if vlan:
filt_str = 'greater 1200'
cmd = "sudo tcpdump -ni %s -U %s -w %s" % (tap_intf, filt_str, pcap)
self.logger.info("Starting tcpdump to capture the mirrored packets.")
execute_cmd(session, cmd, self.logger)
assert check_pcap_file_exists(session, pcap),'pcap file does not exist'
return pcap
else:
pcap = '/tmp/%s.pcap' % (get_random_name())
cmd_to_tcpdump = [ 'tcpdump -ni %s %s -w %s 1>/dev/null 2>/dev/null' % (tap_intf, filt_str, pcap) ]
pidfile = pcap + '.pid'
vm_fix_pcap_pid_files =[]
for vm_fixture in vm_fixtures:
vm_fixture.run_cmd_on_vm(cmds=cmd_to_tcpdump, as_daemon=True, pidfile=pidfile, as_sudo=True)
vm_fix_pcap_pid_files.append((vm_fixture, pcap, pidfile))
return vm_fix_pcap_pid_files
def stop_tcpdump(self, session):
self.logger.info("Stopping any tcpdump process running")
cmd = 'kill $(pidof tcpdump)'
execute_cmd(session, cmd, self.logger)
self.logger.info("Removing any encap-pcap files in /tmp")
cmd = 'rm -f /tmp/encap*pcap'
execute_cmd(session, cmd, self.logger)
def stop_tcpdump_for_intf(session, pcap, logger=None):
if not logger:
logger = contrail_logging.getLogger(__name__)
cmd = 'sudo kill $(ps -ef|grep tcpdump | grep pcap| awk \'{print $2}\')'
execute_cmd(session, cmd, logger)
sleep(2)
return True
def set_cpu_performance(self, hosts):
sessions = {}
cmd = 'for f in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor ; do echo performance > $f; cat $f; done'
for i in range(0, 2):
session = ssh(hosts[i]['host_ip'], hosts[i]['username'], hosts[i]['password'])
execute_cmd(session, cmd, self.logger)
return
def stop_tcpdump_for_intf(session, pcap, logger=None):
if not logger:
logger = contrail_logging.getLogger(__name__)
cmd = 'sudo kill $(ps -ef|grep tcpdump | grep pcap| awk \'{print $2}\')'
execute_cmd(session, cmd, logger)
sleep(2)
return True
def stop_tcpdump(self, session):
self.logger.info("Stopping any tcpdump process running")
cmd = 'kill $(pidof tcpdump)'
execute_cmd(session, cmd, self.logger)
self.logger.info("Removing any encap-pcap files in /tmp")
cmd = 'rm -f /tmp/encap*pcap'
execute_cmd(session, cmd, self.logger)
def verify_mirroring(self, si_fix, src_vm, dst_vm, mirr_vm=None):
result = True
if mirr_vm:
svm = mirr_vm.vm_obj
else:
svms = self.get_svms_in_si(si_fix)
svm = svms[0]
if svm.status == 'ACTIVE':
svm_name = svm.name
host = self.get_svm_compute(svm_name)
if mirr_vm:
tapintf = self.get_svm_tapintf(svm_name)
else:
tapintf = self.get_bridge_svm_tapintf(svm_name, 'left')
session = ssh(host['host_ip'], host['username'], host['password'])
cmd = 'sudo tcpdump -nni %s -c 5 > /tmp/%s_out.log' % (tapintf, tapintf)
execute_cmd(session, cmd, self.logger)
assert src_vm.ping_with_certainty(dst_vm.vm_ip)
sleep(10)
output_cmd = 'sudo cat /tmp/%s_out.log' % tapintf
out, err = execute_cmd_out(session, output_cmd, self.logger)
print(out)
if '8099' in out:
self.logger.info('Mirroring action verified')
else:
result = False
self.logger.warning('No mirroring action seen')
return result
def verify_mirroring(self, si_fix, src_vm, dst_vm, mirr_vm=None):
result = True
if mirr_vm:
svm = mirr_vm.vm_obj
else:
svms = self.get_svms_in_si(si_fix)
svm = svms[0]
if svm.status == 'ACTIVE':
svm_name = svm.name
host = self.get_svm_compute(svm_name)
if mirr_vm:
tapintf = self.get_svm_tapintf(svm_name)
else:
tapintf = self.get_bridge_svm_tapintf(svm_name, 'left')
session = ssh(host['host_ip'], host['username'], host['password'])
cmd = 'sudo tcpdump -nni %s -c 5 > /tmp/%s_out.log' % (tapintf, tapintf)
execute_cmd(session, cmd, self.logger)
assert src_vm.ping_with_certainty(dst_vm.vm_ip)
sleep(10)
output_cmd = 'sudo cat /tmp/%s_out.log' % tapintf
out, err = execute_cmd_out(session, output_cmd, self.logger)
print out
if '8099' in out:
self.logger.info('Mirroring action verified')
else:
result = False
self.logger.warning('No mirroring action seen')
return result
def set_cpu_performance(self, hosts):
sessions = {}
cmd = 'for f in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor ; do echo performance > $f; cat $f; done'
for i in range(0, 2):
session = ssh(hosts[i]['host_ip'], hosts[i]['username'], hosts[i]['password'])
execute_cmd(session, cmd, self.logger)
return
def start_tcpdump(self, server_ip, tap_intf):
session = ssh(server_ip,self.inputs.host_data[server_ip]['username'],self.inputs.host_data[server_ip]['password'])
pcap = '/tmp/%s.pcap' % tap_intf
cmd = "tcpdump -nei %s tcp -w %s" % (tap_intf, pcap)
self.logger.info("Staring tcpdump to capture the packets on server %s" % (server_ip))
execute_cmd(session, cmd, self.logger)
return pcap, session
def verify_vrrp_action(self, src_vm, dst_vm, ip, vsrx=False):
result = False
self.logger.info('Will ping %s from %s and check if %s responds' % (
ip, src_vm.vm_name, dst_vm.vm_name))
compute_ip = dst_vm.vm_node_ip
compute_user = self.inputs.host_data[compute_ip]['username']
compute_password = self.inputs.host_data[compute_ip]['password']
session = ssh(compute_ip, compute_user, compute_password)
if vsrx:
vm_tapintf = dst_vm.tap_intf[dst_vm.vn_fq_names[1]]['name']
else:
vm_tapintf = dst_vm.tap_intf[dst_vm.vn_fq_name]['name']
cmd = 'sudo tcpdump -nni %s -c 2 icmp > /tmp/%s_out.log' % (
vm_tapintf, vm_tapintf)
execute_cmd(session, cmd, self.logger)
assert src_vm.ping_with_certainty(ip)
output_cmd = 'cat /tmp/%s_out.log' % vm_tapintf
output, err = execute_cmd_out(session, output_cmd, self.logger)
if src_vm.vm_ip in output:
result = True
self.logger.info(
'%s is seen responding to ICMP Requests' % dst_vm.vm_name)
else:
self.logger.error(
'ICMP Requests to %s not seen on the VRRP Master' % ip)
result = False
return result
def verify_vrrp_action(self, src_vm, dst_vm, ip, vsrx=False):
result = False
self.logger.info('Will ping %s from %s and check if %s responds' % (
ip, src_vm.vm_name, dst_vm.vm_name))
compute_ip = dst_vm.vm_node_ip
compute_user = self.inputs.host_data[compute_ip]['username']
compute_password = self.inputs.host_data[compute_ip]['password']
session = ssh(compute_ip, compute_user, compute_password)
if vsrx:
vm_tapintf = dst_vm.tap_intf[dst_vm.vn_fq_names[1]]['name']
else:
vm_tapintf = dst_vm.tap_intf[dst_vm.vn_fq_name]['name']
cmd = 'tcpdump -nni %s -c 10 > /tmp/%s_out.log' % (
vm_tapintf, vm_tapintf)
execute_cmd(session, cmd, self.logger)
assert src_vm.ping_with_certainty(ip), 'Ping to vIP failure'
output_cmd = 'cat /tmp/%s_out.log' % vm_tapintf
output, err = execute_cmd_out(session, output_cmd, self.logger)
if ip in output:
result = True
self.logger.info(
'%s is seen responding to ICMP Requests' % dst_vm.vm_name)
else:
self.logger.error('ICMP Requests not seen on the VRRP Master')
result = False
return result
def start_tcpdump(self, session, tap_intf, vlan=None, vm_fixtures=[], pcap_on_vm=False, no_header = False):
filt_str = ''
if not no_header:
filt_str = 'udp port 8099'
if not pcap_on_vm:
pcap = '/tmp/mirror-%s_%s.pcap' % (tap_intf, get_random_name())
cmd = 'rm -f %s' % pcap
execute_cmd(session, cmd, self.logger)
assert check_pcap_file_exists(session, pcap, expect=False),'pcap file still exists'
if vlan:
filt_str = 'greater 1200'
cmd = "sudo tcpdump -ni %s -U %s -w %s" % (tap_intf, filt_str, pcap)
self.logger.info("Starting tcpdump to capture the mirrored packets.")
execute_cmd(session, cmd, self.logger)
assert check_pcap_file_exists(session, pcap),'pcap file does not exist'
return pcap
else:
pcap = '/tmp/%s.pcap' % (get_random_name())
cmd_to_tcpdump = [ 'tcpdump -ni %s %s -w %s 1>/dev/null 2>/dev/null' % (tap_intf, filt_str, pcap) ]
pidfile = pcap + '.pid'
vm_fix_pcap_pid_files =[]
for vm_fixture in vm_fixtures:
vm_fixture.run_cmd_on_vm(cmds=cmd_to_tcpdump, as_daemon=True, pidfile=pidfile, as_sudo=True)
vm_fix_pcap_pid_files.append((vm_fixture, pcap, pidfile))
return vm_fix_pcap_pid_files
def start_tcpdump_for_intf(ip, username, password, interface, filters='-v', logger=None):
if not logger:
logger = logging.getLogger(__name__)
session = ssh(ip, username, password)
pcap = '/tmp/%s_%s.pcap' % (interface, get_random_name())
cmd = 'tcpdump -ni %s -U %s -w %s' % (interface, filters, pcap)
execute_cmd(session, cmd, logger)
return (session, pcap)
def start_tcpdump_for_intf(ip, username, password, interface, filters='-v', logger=None):
if not logger:
logger = contrail_logging.getLogger(__name__)
session = ssh(ip, username, password)
pcap = '/tmp/%s_%s.pcap' % (interface, get_random_name())
cmd = 'tcpdump -nni %s -U %s -w %s' % (interface, filters, pcap)
execute_cmd(session, cmd, logger)
return (session, pcap)
def start_tcpdump(self, session, tap_intf):
pcap = '/tmp/mirror-%s.pcap' % tap_intf
cmd = 'rm -f %s' % pcap
execute_cmd(session, cmd, self.logger)
cmd = "tcpdump -ni %s udp port 8099 -w %s" % (tap_intf, pcap)
self.logger.info("Staring tcpdump to capture the mirrored packets.")
execute_cmd(session, cmd, self.logger)
return pcap
def start_tcpdump(self, session, tap_intf):
pcap = "/tmp/mirror-%s.pcap" % tap_intf
cmd = "rm -f %s" % pcap
execute_cmd(session, cmd, self.logger)
sleep(5)
cmd = "tcpdump -ni %s udp port 8099 -w %s" % (tap_intf, pcap)
self.logger.info("Staring tcpdump to capture the mirrored packets.")
execute_cmd(session, cmd, self.logger)
return pcap
def start_tcpdump(self, server_ip, tap_intf):
session = ssh(server_ip, self.inputs.host_data[server_ip]['username'],
self.inputs.host_data[server_ip]['password'])
pcap = '/tmp/%s.pcap' % tap_intf
cmd = "tcpdump -nei %s tcp -w %s" % (tap_intf, pcap)
self.logger.info(
"Staring tcpdump to capture the packets on server %s" %
(server_ip))
execute_cmd(session, cmd, self.logger)
return pcap, session
def stop_tcpdump(self, session, pcap):
self.logger.info("Waiting for the tcpdump write to complete.")
sleep(30)
cmd = 'kill $(pidof tcpdump)'
execute_cmd(session, cmd, self.logger)
cmd = 'tcpdump -r %s | wc -l' % pcap
out, err = execute_cmd_out(session, cmd, self.logger)
count = int(out.strip('\n'))
cmd = 'rm -f %s' % pcap
execute_cmd(session, cmd, self.logger)
return count
def start_tcpdump(self, session, tap_intf, vlan=None):
pcap = '/tmp/mirror-%s.pcap' % tap_intf
cmd = 'rm -f %s' % pcap
execute_cmd(session, cmd, self.logger)
filt_str = ''
if not vlan:
filt_str = 'udp port 8099'
cmd = "sudo tcpdump -ni %s %s -w %s" % (tap_intf, filt_str, pcap)
self.logger.info("Starting tcpdump to capture the mirrored packets.")
execute_cmd(session, cmd, self.logger)
return pcap
def start_tcpdump_for_vm_intf(obj, vm_fix, vn_fq_name, filters='-v'):
compute_ip = vm_fix.vm_node_ip
compute_user = obj.inputs.host_data[compute_ip]['username']
compute_password = obj.inputs.host_data[compute_ip]['password']
session = ssh(compute_ip, compute_user, compute_password)
vm_tapintf = vm_fix.tap_intf[vn_fq_name]['name']
pcap = '/tmp/%s_%s.pcap' % (vm_tapintf, get_random_name())
cmd = 'tcpdump -ni %s -U %s -w %s' % (vm_tapintf, filters, pcap)
execute_cmd(session, cmd, obj.logger)
return (session, pcap)
def stop_tcpdump(self, session, pcap):
self.logger.info("Waiting for the tcpdump write to complete.")
sleep(30)
cmd = 'sudo kill $(pidof tcpdump)'
execute_cmd(session, cmd, self.logger)
cmd = 'sudo tcpdump -r %s | wc -l' % pcap
out, err = execute_cmd_out(session, cmd, self.logger)
count = int(out.strip('\n'))
cmd = 'sudo rm -f %s' % pcap
execute_cmd(session, cmd, self.logger)
return count
def stop_tcp_dump(self, sessions):
self.logger.info("Waiting for the tcpdump write to complete.")
sleep(30)
cmd = 'kill $(pidof tcpdump)'
execute_cmd(sessions[0], cmd, self.logger)
execute_cmd(sessions[0], 'sync', self.logger)
cmd = 'tcpdump -r %s | wc -l' % sessions[1]
out, err = execute_cmd_out(sessions[0], cmd, self.logger)
count = int(out.strip('\n'))
#cmd = 'rm -f %s' % sessions[1]
#execute_cmd(sessions[0], cmd, self.logger)
return count
def stop_tcp_dump(self, sessions):
self.logger.info("Waiting for the tcpdump write to complete.")
sleep(30)
cmd = 'kill $(pidof tcpdump)'
execute_cmd(sessions[0], cmd, self.logger)
execute_cmd(sessions[0], 'sync', self.logger)
cmd = 'tcpdump -r %s | wc -l' % sessions[1]
out, err = execute_cmd_out(sessions[0], cmd, self.logger)
count = int(out.strip('\n'))
#cmd = 'rm -f %s' % sessions[1]
#execute_cmd(sessions[0], cmd, self.logger)
return count
def start_tcp_dump(self, vm_fixture):
sessions =[]
vm_name = vm_fixture.vm_name
host = self.inputs.host_data[vm_fixture.vm_node_ip]
inspect_h = self.agent_inspect[vm_fixture.vm_node_ip]
tapintf = inspect_h.get_vna_tap_interface_by_ip(vm_fixture.vm_ip)[0]['name']
pcap = '/tmp/%s.pcap' % tapintf
cmd = "tcpdump -ni %s udp -w %s" % (tapintf, pcap)
session = ssh(host['host_ip'], host['username'], host['password'])
self.logger.info("Staring tcpdump to capture the packets.")
execute_cmd(session, cmd, self.logger)
sessions.extend((session, pcap))
return sessions
def start_tcp_dump(self, vm_fixture):
sessions =[]
vm_name = vm_fixture.vm_name
host = self.inputs.host_data[vm_fixture.vm_node_ip]
inspect_h = self.agent_inspect[vm_fixture.vm_node_ip]
tapintf = inspect_h.get_vna_tap_interface_by_ip(vm_fixture.vm_ip)[0]['name']
pcap = '/tmp/%s.pcap' % tapintf
cmd = "sudo tcpdump -ni %s udp -w %s" % (tapintf, pcap)
session = ssh(host['host_ip'], host['username'], host['password'])
self.logger.info("Staring tcpdump to capture the packets.")
execute_cmd(session, cmd, self.logger)
sessions.extend((session, pcap))
return sessions
def stop_tcpdump_on_vm_verify_cnt(obj, session, pcap, exp_count=None):
cmd = 'tcpdump -r %s | wc -l' % pcap
out, err = execute_cmd_out(session, cmd, obj.logger)
count = int(out.strip('\n'))
if exp_count and count != exp_count:
obj.logger.warn("%s packets are found in tcpdump output but expected %s" % (count, exp_count))
return False
elif count == 0:
obj.logger.warn("No packets are found in tcpdump output but expected something")
return False
obj.logger.info("%s packets are found in tcpdump output", count)
cmd = 'rm -f %s' % pcap
execute_cmd(session, cmd, obj.logger)
cmd = 'kill $(pidof tcpdump)'
execute_cmd(session, cmd, obj.logger)
return True
def stop_tcpdump(self, session, pcap, filt=''):
self.logger.debug("Waiting for the tcpdump write to complete.")
sleep(5)
cmd = 'kill $(pidof tcpdump)'
execute_cmd(session, cmd, self.logger)
execute_cmd(session, 'sync', self.logger)
cmd = 'tcpdump -n -r %s %s ' % (pcap, filt)
out, err = execute_cmd_out(session, cmd, self.logger)
self.logger.debug('Stopped tcpdump, out : %s, err : %s' % (out, err))
cmd = 'tcpdump -n -r %s %s | wc -l' % (pcap, filt)
out, err = execute_cmd_out(session, cmd, self.logger)
count = int(out.strip('\n'))
cmd = 'rm -f %s' % pcap
#TODO
# Temporary for debugging
# execute_cmd(session, cmd, self.logger)
return count
def verify_flow_thru_si(self, si_fix, src_vn):
self.logger.info('Will start a tcpdump on the left-interfaces of the Service Instances to find out which flow is entering which Service Instance')
flowcount= 0
result= True
si_count= si_fix.max_inst
for i in range(1, si_count+1):
svm_name = si_fix.si_name + '_%s'%i
host = self.get_svm_compute(svm_name)
tapintf = self.get_svm_tapintf_of_vn(svm_name, src_vn)
session = ssh(host['host_ip'], host['username'], host['password'])
cmd = 'tcpdump -ni %s proto 17 -vvv -c 5 > /tmp/%s_out.log' % (tapintf,tapintf)
execute_cmd(session, cmd, self.logger)
sleep(5)
self.logger.info('***** Will check the result of tcpdump *****')
for i in range(1, si_count+1):
svm_name = si_fix.si_name + '_%s'%i
host = self.get_svm_compute(svm_name)
tapintf = self.get_svm_tapintf_of_vn(svm_name, src_vn)
session = ssh(host['host_ip'], host['username'], host['password'])
output_cmd = 'cat /tmp/%s_out.log' % tapintf
out, err = execute_cmd_out(session, output_cmd, self.logger)
if '9000' in out:
flowcount= flowcount + 1
self.logger.info('Flow with dport 9000 seen flowing inside %s'%svm_name)
if '9001' in out:
flowcount= flowcount + 1
self.logger.info('Flow with dport 9001 seen flowing inside %s'%svm_name)
if '9002' in out:
flowcount= flowcount + 1
self.logger.info('Flow with dport 9002 seen flowing inside %s'%svm_name)
if flowcount > 1:
self.logger.info('Flows are distributed across the Service Instances')
else:
result= False
assert result, 'No Flow distribution seen'
def stop_tcpdump(self, session, pcap, filt=""):
self.logger.info("Waiting for the tcpdump write to complete.")
sleep(30)
cmd = "kill $(pidof tcpdump)"
execute_cmd(session, cmd, self.logger)
execute_cmd(session, "sync", self.logger)
cmd = "tcpdump -r %s %s | wc -l" % (pcap, filt)
out, err = execute_cmd_out(session, cmd, self.logger)
count = int(out.strip("\n"))
cmd = "rm -f %s" % pcap
execute_cmd(session, cmd, self.logger)
return count
def stop_tcpdump(self, session, pcap, filt=''):
self.logger.debug("Waiting for the tcpdump write to complete.")
sleep(2)
cmd = 'sudo kill $(ps -ef|grep tcpdump | grep %s| awk \'{print $2}\')' % pcap
execute_cmd(session, cmd, self.logger)
execute_cmd(session, 'sync', self.logger)
sleep(3)
cmd = 'sudo tcpdump -n -r %s %s | wc -l' % (pcap, filt)
out, err = execute_cmd_out(session, cmd, self.logger)
count = int(out.strip('\n'))
cmd = 'sudo tcpdump -n -r %s' % pcap
#TODO
# Temporary for debugging
execute_cmd(session, cmd, self.logger)
return count
def stop_tcpdump(self, session, pcap, filt='', vm_fix_pcap_pid_files=[], pcap_on_vm=False):
self.logger.debug("Waiting for the tcpdump write to complete.")
sleep(2)
if not pcap_on_vm:
cmd = 'sudo kill $(ps -ef|grep tcpdump | grep %s| awk \'{print $2}\')' %pcap
execute_cmd(session, cmd, self.logger)
execute_cmd(session, 'sync', self.logger)
sleep(3)
cmd = 'sudo tcpdump -n -r %s %s | wc -l' % (pcap, filt)
out, err = execute_cmd_out(session, cmd, self.logger)
count = int(out.strip('\n'))
cmd = 'sudo tcpdump -n -r %s' % pcap
#TODO
# Temporary for debugging
execute_cmd(session, cmd, self.logger)
return count
else:
output = []
pkt_count = []
for vm_fix, pcap, pidfile in vm_fix_pcap_pid_files:
cmd_to_output = 'tcpdump -nr %s %s' % (pcap, filt)
cmd_to_kill = 'cat %s | xargs kill ' % (pidfile)
count = cmd_to_output + '| wc -l'
vm_fix.run_cmd_on_vm(cmds=[cmd_to_kill], as_sudo=True)
sleep(2)
vm_fix.run_cmd_on_vm(cmds=[cmd_to_output], as_sudo=True)
output.append(vm_fix.return_output_cmd_dict[cmd_to_output])
vm_fix.run_cmd_on_vm(cmds=[count], as_sudo=True)
pkt_count_list = vm_fix.return_output_cmd_dict[count].split('\n')
try:
pkts = pkt_count_list[2]
except:
pkts = pkt_count_list[1]
pkts = int(pkts)
pkt_count.append(pkts)
total_pkts = sum(pkt_count)
return output, total_pkts
def stop_tcpdump(self, session, pcap, filt='', vm_fix_pcap_pid_files=[], pcap_on_vm=False):
self.logger.debug("Waiting for the tcpdump write to complete.")
sleep(2)
if not pcap_on_vm:
cmd = 'sudo kill $(ps -ef|grep tcpdump | grep %s| awk \'{print $2}\')' %pcap
execute_cmd(session, cmd, self.logger)
execute_cmd(session, 'sync', self.logger)
sleep(3)
cmd = 'sudo tcpdump -n -r %s %s | wc -l' % (pcap, filt)
out, err = execute_cmd_out(session, cmd, self.logger)
count = int(out.strip('\n'))
cmd = 'sudo tcpdump -n -r %s' % pcap
#TODO
# Temporary for debugging
execute_cmd(session, cmd, self.logger)
return count
else:
output = []
pkt_count = []
for vm_fix, pcap, pidfile in vm_fix_pcap_pid_files:
cmd_to_output = 'tcpdump -nr %s %s' % (pcap, filt)
cmd_to_kill = 'cat %s | xargs kill ' % (pidfile)
count = cmd_to_output + '| wc -l'
vm_fix.run_cmd_on_vm(cmds=[cmd_to_kill], as_sudo=True)
sleep(2)
vm_fix.run_cmd_on_vm(cmds=[cmd_to_output], as_sudo=True)
output.append(vm_fix.return_output_cmd_dict[cmd_to_output])
vm_fix.run_cmd_on_vm(cmds=[count], as_sudo=True)
pkt_count_list = vm_fix.return_output_cmd_dict[count].split('\n')
try:
pkts = pkt_count_list[2]
except:
pkts = pkt_count_list[1]
pkts = int(pkts)
pkt_count.append(pkts)
total_pkts = sum(pkt_count)
return output, total_pkts
def start_tcpdump_on_intf(self, host, tapintf):
session = ssh(host['host_ip'], host['username'], host['password'])
cmd = 'sudo tcpdump -nni %s -c 1 proto 1 > /tmp/%s_out.log 2>&1' % (
tapintf, tapintf)
execute_cmd(session, cmd, self.logger)
def start_tcpdump(self, session, cmd):
self.logger.info("Starting tcpdump to capture the packets.")
result = execute_cmd(session, cmd, self.logger)
def stop_tcpdump_for_vm_intf(obj, session, pcap):
cmd = 'rm -f %s' % pcap
execute_cmd(session, cmd, obj.logger)
cmd = 'kill $(ps -ef|grep tcpdump | grep pcap| awk \'{print $2}\')'
execute_cmd(session, cmd, obj.logger)
return True
def start_tcpdump_on_intf(self, host, tapintf):
session = ssh(host['host_ip'], host['username'], host['password'])
cmd = 'tcpdump -nni %s -c 10 > /tmp/%s_out.log' % (tapintf, tapintf)
execute_cmd(session, cmd, self.logger)
def verify_flow_thru_si(self, si_fix, src_vn=None, ecmp_hash=None, flow_count=3):
self.logger.info(
'Will start a tcpdump on the left-interfaces of the Service Instances to find out which flow is entering which Service Instance')
flowcount = 0
result = True
flow_pattern = {}
svms = self.get_svms_in_si(si_fix)
svms = sorted(set(svms))
svm_list = si_fix.svm_list
svm_index = 0
vm_fix_pcap_pid_files = []
# Capturing packets based upon source port
src_port = "8000"
filters = '\'(src port %s)\'' % (src_port)
if None in svms:
svms.remove(None)
for svm_fixture in svm_list:
svm = svm_fixture.vm_obj
self.logger.info('SVM %s is in %s state' % (svm.name, svm.status))
if svm.status == 'ACTIVE':
svm_name = svm.name
host_name = self.connections.orch.get_host_of_vm(svm)
host = self.inputs.host_data[host_name]
if src_vn is not None:
#tapintf = svm_fixture.tap_intf[src_vn.vn_fq_name]['name']
tapintf = self.connections.orch.get_vm_tap_interface(\
svm_fixture.tap_intf[src_vn.vn_fq_name])
else:
tapintf = self.connections.orch.get_vm_tap_interface(svm_fixture.tap_intf[si_fix.left_vn_fq_name])
filters = ''
if self.inputs.pcap_on_vm:
tcpdump_files = start_tcpdump_for_vm_intf(
None, [svm_list[svm_index]], None, filters=filters, pcap_on_vm=True, vm_intf='eth1', svm=True)
svm_index = svm_index + 1
vm_fix_pcap_pid_files.append(tcpdump_files)
else:
session = ssh(
host['host_ip'], host['username'], host['password'])
cmd = 'sudo tcpdump -nni %s %s -c 20 > /tmp/%s_out.log' % (
tapintf, filters, tapintf)
execute_cmd(session, cmd, self.logger)
else:
self.logger.info('%s is not in ACTIVE state' % svm.name)
sleep(15)
self.logger.info('%%%%% Will check the result of tcpdump %%%%%')
svms = self.get_svms_in_si(si_fix)
svms = sorted(set(svms))
if None in svms:
svms.remove(None)
svm_index = 0
for svm_fixture in svm_list:
svm = svm_fixture.vm_obj
self.logger.info('SVM %s is in %s state' % (svm.name, svm.status))
if svm.status == 'ACTIVE':
svm_name = svm.name
host_name = self.connections.orch.get_host_of_vm(svm)
host = self.inputs.host_data[host_name]
if src_vn is not None:
tapintf = self.connections.orch.get_vm_tap_interface(\
svm_fixture.tap_intf[src_vn.vn_fq_name])
#tapintf = svm_fixture.tap_intf[src_vn.vn_fq_name]['name']
else:
direction = 'left'
tapintf = self.connections.orch.get_vm_tap_interface(svm_fixture.tap_intf[si_fix.left_vn_fq_name])
if not self.inputs.pcap_on_vm:
session = ssh(
host['host_ip'], host['username'], host['password'])
output_cmd = 'cat /tmp/%s_out.log' % tapintf
out, err = execute_cmd_out(session, output_cmd, self.logger)
else:
out, pkt_count = stop_tcpdump_for_vm_intf(
None, None, None, vm_fix_pcap_pid_files=vm_fix_pcap_pid_files[svm_index], svm=True)
svm_index = svm_index + 1
out = out[0]
for i in range(0,flow_count):
dport = str(9000+i)
if dport in out:
flowcount = flowcount + 1
self.logger.info(
'Flow with dport %s seen flowing inside %s' % (dport,svm_name))
flow_pattern[dport] = svm_name
else:
self.logger.info('%s is not in ACTIVE state' % svm.name)
if flowcount > 0:
self.logger.info(
'Flows are distributed across the Service Instances as :')
self.logger.info('%s' % flow_pattern)
else:
result = False
if ecmp_hash and ecmp_hash != 'default':
# count the number of hash fields set
hash_var_count = sum(ecmp_hash.values())
# Incase, only one hash field is set, all flows should go through
# single service instance. One exception here is destination_port.
# Destination port varies for traffic streams.So, for destination
# port, traffic will get load balanced even if ecmp hash is
# configured "destination_port" alone.
if hash_var_count == 1 and (not 'destination_port' in ecmp_hash):
flow_pattern_ref = flow_pattern['9000']
if all(flow_pattern_ref == item for item in flow_pattern.values()):
self.logger.info(
'Flows are flowing through Single Service Instance: %s, as per config hash: %s' % (flow_pattern_ref, ecmp_hash))
self.logger.info('%s' % flow_pattern)
else:
result = False
self.logger.error(
'Flows are flowing through multiple Service Instances:%s, where as it should not as per config hash:%s' % (flow_pattern, ecmp_hash))
assert result, 'Config hash is not working for: %s' % ( ecmp_hash)
# Incase, multiple ecmp hash fields are configured or default ecmp
# hash is present or only 'destionation_port' is configured in
# ecmp_hash
else:
flow_pattern_ref = flow_pattern['9000']
if all(flow_pattern_ref == item for item in flow_pattern.values()):
result = False
self.logger.error(
'Flows are flowing through Single Service Instance:%s, where as it should not as per config hash:%s' % (flow_pattern_ref, ecmp_hash))
#assert result, 'Config hash is not working fine.'
else:
self.logger.info(
'Flows are flowing through multiple Service Instances:%s, as per config hash: %s' % (flow_pattern, ecmp_hash))
self.logger.info('%s' % flow_pattern)
else:
assert result, 'No Flow distribution seen'
def verify_flow_thru_si(self, si_fix, src_vn=None):
self.logger.info(
'Will start a tcpdump on the left-interfaces of the Service Instances to find out which flow is entering which Service Instance')
flowcount = 0
result = True
flow_pattern = {}
svms = self.get_svms_in_si(si_fix, self.inputs.project_name)
svms = sorted(set(svms))
if None in svms:
svms.remove(None)
for svm in svms:
self.logger.info('SVM %s is in %s state' % (svm.name, svm.status))
if svm.status == 'ACTIVE':
svm_name = svm.name
host = self.get_svm_compute(svm_name)
if src_vn is not None:
tapintf = self.get_svm_tapintf_of_vn(svm_name, src_vn)
else:
direction = 'left'
tapintf = self.get_bridge_svm_tapintf(svm_name, direction)
session = ssh(
host['host_ip'], host['username'], host['password'])
cmd = 'tcpdump -nni %s -c 10 > /tmp/%s_out.log' % (
tapintf, tapintf)
execute_cmd(session, cmd, self.logger)
else:
self.logger.info('%s is not in ACTIVE state' % svm.name)
sleep(15)
self.logger.info('%%%%% Will check the result of tcpdump %%%%%')
svms = self.get_svms_in_si(si_fix, self.inputs.project_name)
svms = sorted(set(svms))
if None in svms:
svms.remove(None)
for svm in svms:
self.logger.info('SVM %s is in %s state' % (svm.name, svm.status))
if svm.status == 'ACTIVE':
svm_name = svm.name
host = self.get_svm_compute(svm_name)
if src_vn is not None:
tapintf = self.get_svm_tapintf_of_vn(svm_name, src_vn)
else:
direction = 'left'
tapintf = self.get_bridge_svm_tapintf(svm_name, direction)
session = ssh(
host['host_ip'], host['username'], host['password'])
output_cmd = 'cat /tmp/%s_out.log' % tapintf
out, err = execute_cmd_out(session, output_cmd, self.logger)
if '9000' in out:
flowcount = flowcount + 1
self.logger.info(
'Flow with dport 9000 seen flowing inside %s' % svm_name)
flow_pattern['9000'] = svm_name
if '9001' in out:
flowcount = flowcount + 1
self.logger.info(
'Flow with dport 9001 seen flowing inside %s' % svm_name)
flow_pattern['9001'] = svm_name
if '9002' in out:
flowcount = flowcount + 1
self.logger.info(
'Flow with dport 9002 seen flowing inside %s' % svm_name)
flow_pattern['9002'] = svm_name
else:
self.logger.info('%s is not in ACTIVE state' % svm.name)
if flowcount > 0:
self.logger.info(
'Flows are distributed across the Service Instances as :')
self.logger.info('%s' % flow_pattern)
else:
result = False
assert result, 'No Flow distribution seen'
def start_tcpdump(self, session, cmd, pcap=None):
self.logger.info("Starting tcpdump to capture the packets.")
result = execute_cmd(session, cmd, self.logger)
if pcap:
assert check_pcap_file_exists(session, pcap),'pcap not got created'
def verify_flow_thru_si(self, si_fix, src_vn=None):
self.logger.info(
'Will start a tcpdump on the left-interfaces of the Service Instances to find out which flow is entering which Service Instance'
)
flowcount = 0
result = True
flow_pattern = {}
svms = self.get_svms_in_si(si_fix, self.inputs.project_name)
svms = sorted(set(svms))
if None in svms:
svms.remove(None)
for svm in svms:
self.logger.info('SVM %s is in %s state' % (svm.name, svm.status))
if svm.status == 'ACTIVE':
svm_name = svm.name
host = self.get_svm_compute(svm_name)
if src_vn is not None:
tapintf = self.get_svm_tapintf_of_vn(svm_name, src_vn)
else:
direction = 'left'
tapintf = self.get_bridge_svm_tapintf(svm_name, direction)
session = ssh(host['host_ip'], host['username'],
host['password'])
cmd = 'tcpdump -nni %s -c 10 > /tmp/%s_out.log' % (tapintf,
tapintf)
execute_cmd(session, cmd, self.logger)
else:
self.logger.info('%s is not in ACTIVE state' % svm.name)
sleep(15)
self.logger.info('%%%%% Will check the result of tcpdump %%%%%')
svms = self.get_svms_in_si(si_fix, self.inputs.project_name)
svms = sorted(set(svms))
if None in svms:
svms.remove(None)
for svm in svms:
self.logger.info('SVM %s is in %s state' % (svm.name, svm.status))
if svm.status == 'ACTIVE':
svm_name = svm.name
host = self.get_svm_compute(svm_name)
if src_vn is not None:
tapintf = self.get_svm_tapintf_of_vn(svm_name, src_vn)
else:
direction = 'left'
tapintf = self.get_bridge_svm_tapintf(svm_name, direction)
session = ssh(host['host_ip'], host['username'],
host['password'])
output_cmd = 'cat /tmp/%s_out.log' % tapintf
out, err = execute_cmd_out(session, output_cmd, self.logger)
if '9000' in out:
flowcount = flowcount + 1
self.logger.info(
'Flow with dport 9000 seen flowing inside %s' %
svm_name)
flow_pattern['9000'] = svm_name
if '9001' in out:
flowcount = flowcount + 1
self.logger.info(
'Flow with dport 9001 seen flowing inside %s' %
svm_name)
flow_pattern['9001'] = svm_name
if '9002' in out:
flowcount = flowcount + 1
self.logger.info(
'Flow with dport 9002 seen flowing inside %s' %
svm_name)
flow_pattern['9002'] = svm_name
else:
self.logger.info('%s is not in ACTIVE state' % svm.name)
if flowcount > 0:
self.logger.info(
'Flows are distributed across the Service Instances as :')
self.logger.info('%s' % flow_pattern)
else:
result = False
assert result, 'No Flow distribution seen'
def start_tcpdump_on_intf(self, host, tapintf):
session = ssh(host["host_ip"], host["username"], host["password"])
cmd = "tcpdump -nni %s -c 10 > /tmp/%s_out.log" % (tapintf, tapintf)
execute_cmd(session, cmd, self.logger)
def start_tcpdump(self, session, cmd, pcap=None):
self.logger.info("Starting tcpdump to capture the packets.")
result = execute_cmd(session, cmd, self.logger)
if pcap:
assert check_pcap_file_exists(session,
pcap), 'pcap not got created'
def verify_flow_thru_si(self,
si_fix,
src_vn=None,
ecmp_hash=None,
flow_count=3):
self.logger.info(
'Will start a tcpdump on the left-interfaces of the Service Instances to find out which flow is entering which Service Instance'
)
flowcount = 0
result = True
flow_pattern = {}
svms = self.get_svms_in_si(si_fix)
svms = sorted(set(svms))
if None in svms:
svms.remove(None)
for svm in svms:
self.logger.info('SVM %s is in %s state' % (svm.name, svm.status))
if svm.status == 'ACTIVE':
svm_name = svm.name
host = self.get_svm_compute(svm_name)
if src_vn is not None:
tapintf = self.get_svm_tapintf_of_vn(svm_name, src_vn)
else:
direction = 'left'
tapintf = self.get_bridge_svm_tapintf(svm_name, direction)
session = ssh(host['host_ip'], host['username'],
host['password'])
cmd = 'tcpdump -nni %s -c 10 > /tmp/%s_out.log' % (tapintf,
tapintf)
execute_cmd(session, cmd, self.logger)
else:
self.logger.info('%s is not in ACTIVE state' % svm.name)
sleep(15)
self.logger.info('%%%%% Will check the result of tcpdump %%%%%')
svms = self.get_svms_in_si(si_fix)
svms = sorted(set(svms))
if None in svms:
svms.remove(None)
for svm in svms:
self.logger.info('SVM %s is in %s state' % (svm.name, svm.status))
if svm.status == 'ACTIVE':
svm_name = svm.name
host = self.get_svm_compute(svm_name)
if src_vn is not None:
tapintf = self.get_svm_tapintf_of_vn(svm_name, src_vn)
else:
direction = 'left'
tapintf = self.get_bridge_svm_tapintf(svm_name, direction)
session = ssh(host['host_ip'], host['username'],
host['password'])
output_cmd = 'cat /tmp/%s_out.log' % tapintf
out, err = execute_cmd_out(session, output_cmd, self.logger)
for i in range(0, flow_count):
dport = str(9000 + i)
if dport in out:
flowcount = flowcount + 1
self.logger.info(
'Flow with dport %s seen flowing inside %s' %
(dport, svm_name))
flow_pattern[dport] = svm_name
else:
self.logger.info('%s is not in ACTIVE state' % svm.name)
if flowcount > 0:
self.logger.info(
'Flows are distributed across the Service Instances as :')
self.logger.info('%s' % flow_pattern)
else:
result = False
if ecmp_hash and ecmp_hash != 'default':
# count the number of hash fields set
hash_var_count = sum(ecmp_hash.values())
# Incase, only one hash field is set, all flows should go through
# single service instance. One exception here is destination_port.
# Destination port varies for traffic streams.So, for destination
# port, traffic will get load balanced even if ecmp hash is
# configured "destination_port" alone.
if hash_var_count == 1 and (not 'destination_port' in ecmp_hash):
flow_pattern_ref = flow_pattern['9000']
if all(flow_pattern_ref == item
for item in flow_pattern.values()):
self.logger.info(
'Flows are flowing through Single Service Instance: %s, as per config hash: %s'
% (flow_pattern_ref, ecmp_hash))
self.logger.info('%s' % flow_pattern)
else:
result = False
self.logger.error(
'Flows are flowing through multiple Service Instances:%s, where as it should not as per config hash:%s'
% (flow_pattern, ecmp_hash))
assert result, 'Config hash is not working for: %s' % (
ecmp_hash)
# Incase, multiple ecmp hash fields are configured or default ecmp
# hash is present or only 'destionation_port' is configured in
# ecmp_hash
else:
flow_pattern_ref = flow_pattern['9000']
if all(flow_pattern_ref == item
for item in flow_pattern.values()):
result = False
self.logger.error(
'Flows are flowing through Single Service Instance:%s, where as it should not as per config hash:%s'
% (flow_pattern_ref, ecmp_hash))
#assert result, 'Config hash is not working fine.'
else:
self.logger.info(
'Flows are flowing through multiple Service Instances:%s, as per config hash: %s'
% (flow_pattern, ecmp_hash))
self.logger.info('%s' % flow_pattern)
else:
assert result, 'No Flow distribution seen'
def verify_flow_thru_si(self, si_fix, src_vn=None, ecmp_hash=None, flow_count=3):
self.logger.info(
'Will start a tcpdump on the left-interfaces of the Service Instances to find out which flow is entering which Service Instance')
flowcount = 0
result = True
flow_pattern = {}
svms = self.get_svms_in_si(si_fix)
svms = sorted(set(svms))
svm_list = si_fix.svm_list
svm_index = 0
vm_fix_pcap_pid_files = []
# Capturing packets based upon source port
src_port = "8000"
filters = '\'(src port %s)\'' % (src_port)
if None in svms:
svms.remove(None)
for svm_fixture in svm_list:
svm = svm_fixture.vm_obj
self.logger.info('SVM %s is in %s state' % (svm.name, svm.status))
if svm.status == 'ACTIVE':
svm_name = svm.name
host_name = self.connections.orch.get_host_of_vm(svm)
host = self.inputs.host_data[host_name]
if src_vn is not None:
#tapintf = svm_fixture.tap_intf[src_vn.vn_fq_name]['name']
tapintf = self.connections.orch.get_vm_tap_interface(\
svm_fixture.tap_intf[src_vn.vn_fq_name])
else:
direction = 'left'
tapintf = self.get_bridge_svm_tapintf(svm_name, direction)
if self.inputs.pcap_on_vm:
tcpdump_files = start_tcpdump_for_vm_intf(
None, [svm_list[svm_index]], None, filters=filters, pcap_on_vm=True, vm_intf='eth1', svm=True)
svm_index = svm_index + 1
vm_fix_pcap_pid_files.append(tcpdump_files)
else:
session = ssh(
host['host_ip'], host['username'], host['password'])
cmd = 'sudo tcpdump -nni %s %s -c 20 > /tmp/%s_out.log' % (
tapintf, filters, tapintf)
execute_cmd(session, cmd, self.logger)
else:
self.logger.info('%s is not in ACTIVE state' % svm.name)
sleep(15)
self.logger.info('%%%%% Will check the result of tcpdump %%%%%')
svms = self.get_svms_in_si(si_fix)
svms = sorted(set(svms))
if None in svms:
svms.remove(None)
svm_index = 0
for svm_fixture in svm_list:
svm = svm_fixture.vm_obj
self.logger.info('SVM %s is in %s state' % (svm.name, svm.status))
if svm.status == 'ACTIVE':
svm_name = svm.name
host_name = self.connections.orch.get_host_of_vm(svm)
host = self.inputs.host_data[host_name]
if src_vn is not None:
tapintf = self.connections.orch.get_vm_tap_interface(\
svm_fixture.tap_intf[src_vn.vn_fq_name])
#tapintf = svm_fixture.tap_intf[src_vn.vn_fq_name]['name']
else:
direction = 'left'
tapintf = self.get_bridge_svm_tapintf(svm_name, direction)
if not self.inputs.pcap_on_vm:
session = ssh(
host['host_ip'], host['username'], host['password'])
output_cmd = 'cat /tmp/%s_out.log' % tapintf
out, err = execute_cmd_out(session, output_cmd, self.logger)
else:
out, pkt_count = stop_tcpdump_for_vm_intf(
None, None, None, vm_fix_pcap_pid_files=vm_fix_pcap_pid_files[svm_index], svm=True)
svm_index = svm_index + 1
out = out[0]
for i in range(0,flow_count):
dport = str(9000+i)
if dport in out:
flowcount = flowcount + 1
self.logger.info(
'Flow with dport %s seen flowing inside %s' % (dport,svm_name))
flow_pattern[dport] = svm_name
else:
self.logger.info('%s is not in ACTIVE state' % svm.name)
if flowcount > 0:
self.logger.info(
'Flows are distributed across the Service Instances as :')
self.logger.info('%s' % flow_pattern)
else:
result = False
if ecmp_hash and ecmp_hash != 'default':
# count the number of hash fields set
hash_var_count = sum(ecmp_hash.values())
# Incase, only one hash field is set, all flows should go through
# single service instance. One exception here is destination_port.
# Destination port varies for traffic streams.So, for destination
# port, traffic will get load balanced even if ecmp hash is
# configured "destination_port" alone.
if hash_var_count == 1 and (not 'destination_port' in ecmp_hash):
flow_pattern_ref = flow_pattern['9000']
if all(flow_pattern_ref == item for item in flow_pattern.values()):
self.logger.info(
'Flows are flowing through Single Service Instance: %s, as per config hash: %s' % (flow_pattern_ref, ecmp_hash))
self.logger.info('%s' % flow_pattern)
else:
result = False
self.logger.error(
'Flows are flowing through multiple Service Instances:%s, where as it should not as per config hash:%s' % (flow_pattern, ecmp_hash))
assert result, 'Config hash is not working for: %s' % ( ecmp_hash)
# Incase, multiple ecmp hash fields are configured or default ecmp
# hash is present or only 'destionation_port' is configured in
# ecmp_hash
else:
flow_pattern_ref = flow_pattern['9000']
if all(flow_pattern_ref == item for item in flow_pattern.values()):
result = False
self.logger.error(
'Flows are flowing through Single Service Instance:%s, where as it should not as per config hash:%s' % (flow_pattern_ref, ecmp_hash))
#assert result, 'Config hash is not working fine.'
else:
self.logger.info(
'Flows are flowing through multiple Service Instances:%s, as per config hash: %s' % (flow_pattern, ecmp_hash))
self.logger.info('%s' % flow_pattern)
else:
assert result, 'No Flow distribution seen'
def start_tcpdump(self, session, cmd):
self.logger.info("Starting tcpdump to capture the packets.")
result = execute_cmd(session, cmd, self.logger)