Python commands.execute_cmd函数代码示例

 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 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 = '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 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, 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 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 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 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(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_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 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 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 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'