def GetHping3Cmd(protocol, src_wl, destination_ip, destination_port, src_port=0, count=3, options=''): if protocol == 'tcp': if src_port == 0: src_port = api.AllocateTcpPort() if options == '': cmd = ( f"hping3 -S -s {int(src_port)} -k -p {int(destination_port)} -c {count} {destination_ip} -I {src_wl.interface}" ) else: cmd = ( f"hping3 -s {int(src_port)} -k -p {int(destination_port)} -c {count} {destination_ip} -I {src_wl.interface} {options}" ) elif protocol == 'udp': if src_port == 0: src_port = api.AllocateTcpPort() cmd = ( f"hping3 --{protocol.lower()} -s {int(src_port)} -k -p {int(destination_port)} -c {count} {destination_ip} -I {src_wl.interface}" ) else: cmd = ( f"hping3 --{protocol.lower()} -c {count} {destination_ip} -I {src_wl.interface}" ) return cmd
def Trigger(tc): tc.contexts = [] ctxt = IperfTestContext() ctxt.req = api.Trigger_CreateAllParallelCommandsRequest() ctxt.cmd_cookies = [] for tunnel in tc.tunnels: w1 = tunnel.ltep w2 = tunnel.rtep cmd_cookie = "Server: %s(%s) <--> Client: %s(%s)" %\ (w1.workload_name, w1.ip_address, w2.workload_name, w2.ip_address) api.Logger.info("Starting Iperf test from %s" % (cmd_cookie)) basecmd = 'iperf -p %d ' % api.AllocateTcpPort() if tc.iterators.proto == 'udp': basecmd = 'iperf -u -p %d ' % api.AllocateUdpPort() api.Trigger_AddCommand(ctxt.req, w1.node_name, w1.workload_name, "%s -s -t 300" % basecmd, background = True) api.Trigger_AddCommand(ctxt.req, w2.node_name, w2.workload_name, "%s -c %s" % (basecmd, w1.ip_address)) ctxt.cmd_cookies.append(cmd_cookie) ctxt.cmd_cookies.append(cmd_cookie) trig_resp = api.Trigger(ctxt.req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) ctxt.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) tc.context = ctxt return api.types.status.SUCCESS
def Trigger(tc): pairs = api.GetLocalWorkloadPairs() tc.cmd_cookies = [] server, client = pairs[0] naples = server if not server.IsNaples(): naples = client if not client.IsNaples(): return api.types.status.SUCCESS else: client, server = pairs[0] cmd_cookie = "%s(%s) --> %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) api.Logger.info("Starting clear & show stress test from %s" % (cmd_cookie)) basecmd = 'iperf -p %d ' % api.AllocateTcpPort() proto = 6 timeout = 250 #tc.secprof = sec_profile_obj.gl_securityprofile_json_template #timeout = int(tc.secprof['security-profiles'][0]['spec']['timeouts']['tcp']) + \ # int(tc.secprof['security-profiles'][0]['spec']['timeouts']['tcp-close']) if tc.iterators.proto == 'udp': basecmd = 'iperf -u -p %d ' % api.AllocateUdpPort() proto = 17 timeout = 150 #timeout = tc.security_profile['security-profiles'][0]['spec']['timeouts']['udp'] req = api.Trigger_CreateExecuteCommandsRequest(serial=True) for cnt in range(tc.args.count): cmd_cookie = "iperf -s" api.Trigger_AddCommand(req, server.node_name, server.workload_name, "%s-s -t 300" % basecmd, background=True) tc.cmd_cookies.append(cmd_cookie) cmd_cookie = "iperf -c " api.Trigger_AddCommand( req, client.node_name, client.workload_name, "%s -c %s -P 100" % (basecmd, server.ip_address)) tc.cmd_cookies.append(cmd_cookie) cmd_cookie = "Show session" api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session") tc.cmd_cookies.append(cmd_cookie) cmd_cookie = "Clear session" api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl clear session") tc.cmd_cookies.append(cmd_cookie) trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): if api.IsDryrun(): return api.types.status.SUCCESS srv = tc.workloads[0] cli = tc.workloads[1] # Determine where the commands will be run - host or Naples. test_type = getattr(tc.args, "test-type", INTF_TEST_TYPE_HOST) is_naples_cmd = True if test_type == INTF_TEST_TYPE_HOST: is_naples_cmd = False srv_req = api.Trigger_CreateExecuteCommandsRequest(serial = False) cli_req = api.Trigger_CreateExecuteCommandsRequest(serial = False) proto = getattr(tc.iterators, "proto", 'tcp') number_of_iperf_threads = getattr(tc.args, "iperfthreads", 1) pktsize = getattr(tc.iterators, "pktsize", None) ipproto = getattr(tc.iterators, "ipproto", 'v4') if ipproto == 'v4': server_ip = srv.ip_address client_ip = cli.ip_address else: server_ip = srv.ipv6_address client_ip = cli.ipv6_address tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (srv.interface, server_ip, cli.interface, client_ip) api.Logger.info("Starting Iperf(%s/%s) test from %s" % (proto, ipproto, tc.cmd_descr)) duration = 10 for i in range(number_of_iperf_threads): if proto == 'tcp': port = api.AllocateTcpPort() else: port = api.AllocateUdpPort() iperf_server_cmd = iperf.ServerCmd(port, naples = is_naples_cmd) api.Trigger_AddCommand(srv_req, srv.node_name, srv.workload_name, iperf_server_cmd, background = True) iperf_client_cmd = iperf.ClientCmd(server_ip, port, time=duration, proto=proto, jsonOut=True, ipproto=ipproto, pktsize=pktsize, client_ip=client_ip, naples = is_naples_cmd) api.Trigger_AddCommand(cli_req, cli.node_name, cli.workload_name, iperf_client_cmd, timeout = 60) srv_resp = api.Trigger(srv_req) # Wait for iperf server to start. time.sleep(10) tc.cli_resp = api.Trigger(cli_req) # Wait for iperf clients to finish. time.sleep(2*duration) srv_resp1 = api.Trigger_TerminateAllCommands(srv_resp) return api.types.status.SUCCESS
def Setup(tc): tc.server_port = api.AllocateTcpPort() tc.client_port = api.AllocateTcpPort() api.Logger.info("Setup.") if tc.iterators.kind == "remote": pairs = api.GetRemoteWorkloadPairs() if not pairs: api.Logger.info("no remtote eps") return api.types.status.SUCCESS else: pairs = api.GetLocalWorkloadPairs() tc.resp_flow = getattr(tc.args, "resp_flow", 0) tc.cmd_cookies = {} req = api.Trigger_CreateExecuteCommandsRequest(serial = True) #for w1,w2 in pairs: if pairs[0][0].IsNaples(): tc.client,tc.server = pairs[0] else: tc.server,tc.client = pairs[0] cmd_cookie = start_nc_server(tc.server, tc.server_port) add_command(req, tc, 'server', tc.server, cmd_cookie, True) cmd_cookie = start_nc_client(tc.server, tc.client_port, tc.server_port) add_command(req, tc, 'client', tc.client, cmd_cookie, True) cmd_cookie = "/nic/bin/halctl show session --dstport {} --dstip {} --yaml".format(tc.server_port, tc.server.ip_address) add_command(req, tc, 'show before', tc.client, cmd_cookie, naples=True) tc.setup_cmd_resp = api.Trigger(req) cmd = tc.setup_cmd_resp.commands[-1] api.PrintCommandResults(cmd) tc.pre_ctrckinf = get_conntrackinfo(cmd) if getattr(tc.args, 'vmotion_enable', False): vmotion_utils.PrepareWorkloadVMotion(tc, [tc.client]) return api.types.status.SUCCESS
def Trigger(tc): if tc.skip: return api.types.status.SUCCESS tc.serverCmds = [] tc.clientCmds = [] tc.cmd_descr = [] if not api.IsSimulation(): serverReq = api.Trigger_CreateAllParallelCommandsRequest() clientReq = api.Trigger_CreateAllParallelCommandsRequest() else: serverReq = api.Trigger_CreateExecuteCommandsRequest(serial = False) clientReq = api.Trigger_CreateExecuteCommandsRequest(serial = False) for idx, pairs in enumerate(tc.workload_pairs): client = pairs[0] server = pairs[1] cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) tc.cmd_descr.append(cmd_descr) num_sessions = int(getattr(tc.args, "num_sessions", 1)) api.Logger.info("Starting Iperf test from %s num-sessions %d" % (cmd_descr, num_sessions)) if tc.iterators.proto == 'udp': port = api.AllocateTcpPort() serverCmd = iperf.ServerCmd(port) clientCmd = iperf.ClientCmd(server.ip_address, port, proto='udp', jsonOut=True, num_of_streams = num_sessions) else: port = api.AllocateUdpPort() serverCmd = iperf.ServerCmd(port) clientCmd = iperf.ClientCmd(server.ip_address, port, jsonOut=True, num_of_streams = num_sessions) tc.serverCmds.append(serverCmd) tc.clientCmds.append(clientCmd) api.Trigger_AddCommand(serverReq, server.node_name, server.workload_name, serverCmd, background = True) api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name, clientCmd) server_resp = api.Trigger(serverReq) #Sleep for some time as bg may not have been started. time.sleep(30) tc.iperf_client_resp = api.Trigger(clientReq) #Its faster kill iperf servers #Still call terminate on all api.Trigger_TerminateAllCommands(server_resp) return api.types.status.SUCCESS
def Trigger(tc): #Run all commands in parallel. req = api.Trigger_CreateExecuteCommandsRequest(serial=False) #Start traffic commands in background wloads = [] for pair in tc.workload_pairs: w1 = pair[0] w2 = pair[1] tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (w1.workload_name, w1.ip_address, w2.workload_name, w2.ip_address) api.Logger.info("Starting Iperf test from %s" % (tc.cmd_descr)) basecmd = 'iperf -p %d ' % api.AllocateTcpPort() api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, "%s -s -t 300" % basecmd, background=True) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, "%s -c %s" % (basecmd, w1.ip_address), background=True) wloads.append(w1) wloads.append(w2) #now bring up workloads ret = api.BringUpWorkloads(wloads) if ret != api.types.status.SUCCESS: return api.types.status.FAILURE #Now Send all the commands trig_resp = api.Trigger(req) #Sleep for some time for traffic to stabalize time.sleep(10) #Teardown workloads ret = api.TeardownWorkloads(wloads) if ret != api.types.status.SUCCESS: api.Trigger_TerminateAllCommands(trig_resp) return api.types.status.FAILURE #this will fail as workload is already delete and all commands are stopped tc.resp = api.Trigger_TerminateAllCommands(trig_resp) #Bring up the same workoad loads ret = api.BringUpWorkloads(wloads) if ret != api.types.status.SUCCESS: return api.types.status.FAILURE return api.types.status.SUCCESS
def Trigger(tc): pairs = api.GetRemoteWorkloadPairs() w1 = pairs[0][1] w2 = pairs[0][0] group = "239.1.1.1" maddr = "01:00:5e:01:01:01" req = api.Trigger_CreateExecuteCommandsRequest(serial = True) tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" % \ (w1.workload_name, w1.ip_address, w2.workload_name, w2.ip_address) api.Logger.info("Starting Multicast outbound Iperf test from %s" % (tc.cmd_descr)) basecmd = "ip maddress add %s dev %s" % (maddr, w1.interface) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, basecmd, background = True) basecmd = "ip maddress add %s dev %s" % (maddr, w2.interface) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, basecmd, background = True) basecmd = "ip route add %s/32 dev %s" % (group, w1.interface) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, basecmd, background = True) basecmd = "ip route add %s/32 dev %s" % (group, w2.interface) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, basecmd, background = True) basecmd = 'iperf -p %d ' % api.AllocateTcpPort() if tc.iterators.proto == 'udp': basecmd = 'iperf -u -p %d ' % api.AllocateUdpPort() api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, "%s -s -t 300 -B %s -i 1" % (basecmd, group), background = True) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, "%s -c %s -T 32 -t 3 -i 1" % (basecmd, group)) basecmd = "ip maddress del %s dev %s" % (maddr, w1.interface) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, basecmd, background = True) basecmd = "ip maddress del %s dev %s" % (maddr, w2.interface) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, basecmd, background = True) basecmd = "ip route del %s/32 dev %s" % (group, w1.interface) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, basecmd, background = True) basecmd = "ip route del %s/32 dev %s" % (group, w2.interface) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, basecmd, background = True) trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): if api.IsDryrun(): return api.types.status.SUCCESS req1 = api.Trigger_CreateExecuteCommandsRequest(serial=True) req2 = api.Trigger_CreateExecuteCommandsRequest(serial=False) w1 = tc.workloads[0] w2 = tc.workloads[1] tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (w1.interface, w1.ip_address, w2.interface, w2.ip_address) api.Logger.info("Starting Iperf test from %s" % (tc.cmd_descr)) proto = getattr(tc.iterators, "proto", 'tcp') number_of_iperf_threads = getattr(tc.args, "iperfthreads", 1) pktsize = getattr(tc.iterators, "pktsize", 512) ipproto = getattr(tc.iterators, "ipproto", 'v4') for i in range(number_of_iperf_threads): if proto == 'tcp': port = api.AllocateTcpPort() else: port = api.AllocateUdpPort() iperf_server_cmd = cmd_builder.iperf_server_cmd(port=port) api.Trigger_AddCommand(req1, w1.node_name, w1.workload_name, iperf_server_cmd, background=True) iperf_client_cmd = cmd_builder.iperf_client_cmd( server_ip=w1.ip_address, port=port, proto=proto, pktsize=pktsize, ipproto=ipproto) api.Trigger_AddCommand(req2, w2.node_name, w2.workload_name, iperf_client_cmd) trig_resp1 = api.Trigger(req1) trig_resp2 = api.Trigger(req2) term_resp1 = api.Trigger_TerminateAllCommands(trig_resp1) response = api.Trigger_AggregateCommandsResponse(trig_resp1, term_resp1) tc.resp = api.Trigger_AggregateCommandsResponse(response, trig_resp2) return api.types.status.SUCCESS
def SendTraffic(tc): req = api.Trigger_CreateExecuteCommandsRequest(serial=True) tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" % ( tc.intf1.Name(), tc.intf1.GetIP(), tc.intf2.Name(), tc.intf2.GetIP()) api.Logger.info("Starting Iperf from %s" % (tc.cmd_descr)) port = api.AllocateTcpPort() iperf_server_cmd = iperf.ServerCmd(port=port) tc.intf1.AddCommand(req, iperf_server_cmd, background=True) iperf_client_cmd = iperf.ClientCmd(server_ip=tc.intf1.GetIP(), port=port, proto='tcp', pktsize=512, ipproto='v4') tc.intf2.AddCommand(req, iperf_client_cmd) trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def PingCmdBuilder(src_wl, dest_ip, proto='icmp', af='ipv4', pktsize=64, args=None, count=3): cmd = None dest_addr = " %s" % (dest_ip) if proto == 'arp': if not __is_ipv4(af): assert (0) if args == 'DAD': arp_base_cmd = __get_arp_base_cmd(src_wl, False, True, count) elif args == 'update': arp_base_cmd = __get_arp_base_cmd(src_wl, True, False, count) else: arp_base_cmd = __get_arp_base_cmd(src_wl, False, False, count) addr = __get_workload_address(src_wl, "ipv4") if args == 'update': dest_addr = " %s" % (addr) cmd = arp_base_cmd + dest_addr elif proto == 'icmp': ping_base_cmd = __get_ping_base_cmd(src_wl, af, pktsize, 3, 0.2, False) cmd = __ping_addr_substitution(ping_base_cmd, dest_addr) elif proto in ['tcp', 'udp']: if proto == 'udp': dest_port = api.AllocateUdpPort() # Skip over 'geneve' reserved port 6081 if dest_port == 6081: dest_port = api.AllocateUdpPort() else: dest_port = api.AllocateTcpPort() cmd = hping.GetHping3Cmd(proto, src_wl, dest_ip, dest_port) return cmd
def Trigger(tc): max_pings = int(getattr(tc.args, "max_pings", 60)) num_runs = int(getattr(tc.args, "num_runs", 1)) serverCmd = None clientCmd = None mode = tc.initial_mode IPERF_TIMEOUT = 86400 try: serverReq = api.Trigger_CreateExecuteCommandsRequest() clientReq = api.Trigger_CreateExecuteCommandsRequest() client = tc.wl_pair[0] server = tc.wl_pair[1] tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) num_streams = int(getattr(tc.args, "num_streams", 2)) api.Logger.info("Starting Iperf test from %s num-sessions %d" % (tc.cmd_descr, num_streams)) if tc.iterators.proto == 'tcp': port = api.AllocateTcpPort() serverCmd = iperf.ServerCmd(port, jsonOut=True, run_core=3) clientCmd = iperf.ClientCmd(server.ip_address, port, time=IPERF_TIMEOUT, jsonOut=True, num_of_streams=num_streams, run_core=3) else: port = api.AllocateUdpPort() serverCmd = iperf.ServerCmd(port, jsonOut=True, run_core=3) clientCmd = iperf.ClientCmd(server.ip_address, port, proto='udp', jsonOut=True, num_of_streams=num_streams, run_core=3) tc.serverCmd = serverCmd tc.clientCmd = clientCmd api.Trigger_AddCommand(serverReq, server.node_name, server.workload_name, serverCmd, background=True, timeout=IPERF_TIMEOUT) api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name, clientCmd, background=True, timeout=IPERF_TIMEOUT) tc.server_resp = api.Trigger(serverReq) time.sleep(5) tc.iperf_client_resp = api.Trigger(clientReq) for _i in range(num_runs): RF = get_redfish_obj(tc.cimc_info, mode=mode) obs_mode = get_nic_mode(RF) api.Logger.info("Iteration %d: curr_mode %s" % (_i, obs_mode)) if mode != obs_mode: raise RuntimeError("Expected NIC mode %s, observed %s" % (mode, obs_mode)) next_mode = "dedicated" if mode == "ncsi" else "ncsi" if next_mode == "ncsi": ret = set_ncsi_mode(RF, mode="dhcp") else: ret = set_dedicated_mode(RF, mode="dhcp") if ret != api.types.status.SUCCESS: api.Logger.error("Mode switch from %s -> %s failed" %(mode, next_mode)) return api.types.status.FAILURE api.Logger.info("Switched mode to %s" % (next_mode)) time.sleep(5) if ret == api.types.status.SUCCESS: curr_ilo_ip = tc.ilo_ip if next_mode == "dedicated" else tc.ilo_ncsi_ip ret = ping(curr_ilo_ip, max_pings) if ret != api.types.status.SUCCESS: RF.logout() raise RuntimeError('Unable to ping ILO, Port Switch fail from' ' %s -> %s' % (mode, next_mode)) api.Logger.info("Mode switch from %s -> %s successful" % (mode, next_mode)) else: raise RuntimeError('Mode switch config failed') mode = next_mode except: api.Logger.error(traceback.format_exc()) return api.types.status.FAILURE return api.types.status.SUCCESS
def start_fuz(tc): ret = copy_fuz(tc) if ret != api.types.status.SUCCESS: return api.types.status.FAILURE tc.serverCmds = [] tc.clientCmds = [] tc.cmd_descr = [] serverReq = None clientReq = None serverReq = api.Trigger_CreateExecuteCommandsRequest(serial=False) clientReq = api.Trigger_CreateExecuteCommandsRequest(serial=False) # ping test above sets the workload pairs to remote only # setting wl_pairs as per arg selected in testbundle if tc.args.type == 'local_only': api.Logger.info("local_only test") tc.workload_pairs = api.GetLocalWorkloadPairs() elif tc.args.type == 'both': api.Logger.info(" both local and remote test") tc.workload_pairs = api.GetLocalWorkloadPairs() tc.workload_pairs.extend(api.GetRemoteWorkloadPairs()) else: api.Logger.info("remote_only test") tc.workload_pairs = api.GetRemoteWorkloadPairs() for idx, pairs in enumerate(tc.workload_pairs): client = pairs[0] server = pairs[1] cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) tc.cmd_descr.append(cmd_descr) num_sessions = int(getattr(tc.args, "num_sessions", 1)) api.Logger.info("Starting Fuz test from %s num-sessions %d" % (cmd_descr, num_sessions)) serverCmd = None clientCmd = None port = api.AllocateTcpPort() serverCmd = tc.fuz_exec[server.workload_name] + " -port " + str(port) clientCmd = tc.fuz_exec[client.workload_name] + " -conns " + str( num_sessions ) + " -duration " + str( __fuz_run_time ) + " -attempts 1 -read-timeout 100 -talk " + server.ip_address + ":" + str( port) tc.serverCmds.append(serverCmd) tc.clientCmds.append(clientCmd) api.Trigger_AddCommand(serverReq, server.node_name, server.workload_name, serverCmd, background=True) api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name, clientCmd, background=True) tc.server_resp = api.Trigger(serverReq) #Sleep for some time as bg may not have been started. time.sleep(5) tc.fuz_client_resp = api.Trigger(clientReq) return api.types.status.SUCCESS
def iperfWorkloads(workload_pairs, af="ipv4", proto="tcp", packet_size=64, bandwidth="100G", time=1, num_of_streams=None, sleep_time=30, background=False): serverCmds = [] clientCmds = [] cmdDesc = [] ipproto = __get_ipproto(af) if not api.IsSimulation(): serverReq = api.Trigger_CreateAllParallelCommandsRequest() clientReq = api.Trigger_CreateAllParallelCommandsRequest() else: serverReq = api.Trigger_CreateExecuteCommandsRequest(serial=False) clientReq = api.Trigger_CreateExecuteCommandsRequest(serial=False) for idx, pairs in enumerate(workload_pairs): client = pairs[0] server = pairs[1] server_addr = __get_workload_address(server, af) client_addr = __get_workload_address(client, af) if proto == 'udp': port = api.AllocateUdpPort() if port == 6081: port = api.AllocateUdpPort() else: port = api.AllocateTcpPort() serverCmd = iperf.ServerCmd(port, jsonOut=True) clientCmd = iperf.ClientCmd(server_addr, port, time, packet_size, proto, None, ipproto, bandwidth, num_of_streams, jsonOut=True) cmd_cookie = "Server: %s(%s:%s:%d) <--> Client: %s(%s)" %\ (server.workload_name, server_addr, proto, port,\ client.workload_name, client_addr) api.Logger.info("Starting Iperf test %s" % cmd_cookie) serverCmds.append(serverCmd) clientCmds.append(clientCmd) cmdDesc.append(cmd_cookie) api.Trigger_AddCommand(serverReq, server.node_name, server.workload_name, serverCmd, background=True) api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name, clientCmd, background=background) server_resp = api.Trigger(serverReq) #Sleep for some time as bg may not have been started. api.Logger.info( f"Waiting {sleep_time} sec to start iperf server in background") __sleep(sleep_time) client_resp = api.Trigger(clientReq) __sleep(3) if background: return [cmdDesc, serverCmds, clientCmds], server_resp, client_resp else: api.Trigger_TerminateAllCommands(server_resp) return [cmdDesc, serverCmds, clientCmds], client_resp
def Trigger(tc): api.Logger.info("Trigger.") pairs = api.GetLocalWorkloadPairs(naples=True) tc.cmd_cookies1 = [] tc.cmd_cookies2 = [] req = api.Trigger_CreateExecuteCommandsRequest(serial = True) #for w1,w2 in pairs: server,client = pairs[0] naples = server if not server.IsNaples(): if not client.IsNaples(): naples = client return api.types.status.SUCCESS else: client, server = pairs[0] #TBD remove this once agent side profile update is implemented timeout = get_timeout("tcp-close") #Step 0: Update the timeout in the config object update_timeout("tcp-close", tc.iterators.timeout) #profilereq = api.Trigger_CreateExecuteCommandsRequest(serial = True) #api.Trigger_AddNaplesCommand(profilereq, naples.node_name, "/nic/bin/halctl show nwsec profile --id 11") #profcommandresp = api.Trigger(profilereq) #cmd = profcommandresp.commands[-1] #for command in profcommandresp.commands: # api.PrintCommandResults(command) #timeout = get_haltimeout("tcp-close", cmd) #tc.config_update_fail = 0 #if (timeout != timetoseconds(tc.iterators.timeout)): # tc.config_update_fail = 1 timeout = timetoseconds(tc.iterators.timeout) #Step 1: Start TCP Server server_port = api.AllocateTcpPort() api.Trigger_AddCommand(req, server.node_name, server.workload_name, "nc -l %s"%(server_port), background=True) tc.cmd_cookies1.append("start server") #Step 2: Start TCP Client client_port = api.AllocateTcpPort() api.Trigger_AddCommand(req, client.node_name, client.workload_name, "nc {} {} -p {}".format(server.ip_address, server_port, client_port), background=True) tc.cmd_cookies1.append("start client") #Step 3: Get the session out from naples api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session --dstport {} --dstip {} --yaml".format(server_port, server.ip_address)) trig_resp1 = api.Trigger(req) cmd = trig_resp1.commands[-1] for command in trig_resp1.commands: api.PrintCommandResults(command) tc.ctrckinf = get_conntrackinfo(cmd) tc.cmd_cookies1.append("show session detail") req = api.Trigger_CreateExecuteCommandsRequest(serial = True) #Step 4: Start TCPDUMP in background at the client api.Trigger_AddCommand(req, client.node_name, client.workload_name, "tcpdump -i {} > out.txt".format(client.interface), background=True) tc.cmd_cookies2.append("tcpdump client"); api.Trigger_AddCommand(req, server.node_name, server.workload_name, "tcpdump -i {} > out.txt".format(server.interface), background=True) tc.cmd_cookies2.append("tcpdump server"); #Step 5: Cook up a FIN and send api.Trigger_AddCommand(req, client.node_name, client.workload_name, "hping3 -c 1 -s {} -p {} -M {} -L {} --ack --tcp-timestamp {} -d 0 -F".format(client_port, server_port, tc.ctrckinf.i_tcpseqnum+1, tc.ctrckinf.i_tcpacknum, server.ip_address)) tc.cmd_cookies2.append("Send FIN") #Step 6: Send FIN ACK now from other side after timeout api.Trigger_AddCommand(req, server.node_name, server.workload_name, "hping3 -c 1 -s {} -p {} -M {} -L {} --ack --tcp-timestamp {} -d 0 -F".format(server_port, client_port, tc.ctrckinf.r_tcpseqnum+1, tc.ctrckinf.r_tcpacknum, client.ip_address)) tc.cmd_cookies2.append("Send FIN ACK") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "hping3 -c 1 -s {} -p {} -M {} -L {} --ack --tcp-timestamp {} -d 0".format(server_port, client_port, tc.ctrckinf.i_tcpseqnum, tc.ctrckinf.i_tcpacknum+1, server.ip_address)) tc.cmd_cookies2.append("Send ACK") #Step 6: Check if session is up in FIN_RCVD state api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session --dstport {} --dstip {} --srcip {} | grep BIDIR_FIN".format(server_port, server.ip_address, client.ip_address)) tc.cmd_cookies2.append("Before timeout"); #Sleep for connection setup timeout ######TBD -- uncomment this once agent update fix is in!!! #timeout = timetoseconds(tc.iterators.timeout) cmd_cookie = "sleep" api.Trigger_AddNaplesCommand(req, naples.node_name, "sleep %s" % timeout, timeout=300) tc.cmd_cookies2.append("sleep") #Step 7: Validate if session is gone. Note that we could have session in INIT state in this case as the server would retransmit. #Idea is to make sure we have removed the session that was in FIN_RCVD state api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session --dstport {} --dstip {} --srcip {} | grep BIDIR_FIN".format(server_port, server.ip_address, client.ip_address)) tc.cmd_cookies2.append("After timeout") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): if tc.skip == True: return api.types.status.FAILURE # # Set-up Test Environment # tc.cmd_cookies = [] tc.cookie_idx = 0 cmd_cookie = "%s(%s) --> %s(%s)" %\ (tc.server.workload_name, tc.server.ip_address, tc.client.workload_name, tc.client.ip_address) api.Logger.info("Starting Multiple-IPv4-TCP-Flow-Drops test from %s" %\ (cmd_cookie)) # # Start TCPDUMP in background on Server/Client # req = api.Trigger_CreateExecuteCommandsRequest(serial=True) #cmd_cookie = "start tcpdump on Server" #cmd = "sudo tcpdump -nnSXi {} > out.txt".format(tc.server.interface) #add_command(tc, req, cmd_cookie, cmd, tc.server, True) #cmd_cookie = "start tcpdump on Client" #cmd = "sudo tcpdump -nnSXi {} > out.txt".format(tc.client.interface) #add_command(tc, req, cmd_cookie, cmd, tc.client, True) # # Start with a clean slate by clearing all sessions/flows # cmd_cookie = "clear session" cmd = "/nic/bin/halctl clear session" add_naples_command(tc, req, cmd_cookie, cmd, tc.naples) # # Make sure that Client<=>Server Forwarding is set up # cmd_cookie = "trigger ping: Create case" cmd = "ping -c1 %s -I %s" %\ (tc.server.ip_address, tc.client.interface) add_command(tc, req, cmd_cookie, cmd, tc.client, False) tc.resp = api.Trigger(req) for command in tc.resp.commands: api.PrintCommandResults(command) # # Allocate TCP-portnum for Server/Client and start the service on the Server # tc.server_port = api.AllocateTcpPort() tc.client_port = api.AllocateTcpPort() req_nc1 = api.Trigger_CreateExecuteCommandsRequest(serial=True) iseq_num = 0 iack_num = 0 rseq_num = 0 rack_num = 0 idx = 0 while (idx < tc.iterators.sessions): # # Establish TCP-connection # cmd_cookie = "start server" cmd = "nc --listen {}".format(tc.server_port + idx) add_command(tc, req_nc1, cmd_cookie, cmd, tc.server, True) cmd_cookie = "start client" cmd = "nc {} {} --source-port {} "\ .format(tc.server.ip_address, tc.server_port+idx, tc.client_port) add_command(tc, req_nc1, cmd_cookie, cmd, tc.client, True) idx += 1 resp_nc1 = api.Trigger(req_nc1) for command in resp_nc1.commands: api.PrintCommandResults(command) idx = 0 while (idx < tc.iterators.sessions): # # Do applicable "show session" commands and # retrieve Seq-num and Ack-num associated with the session # # req1 = api.Trigger_CreateExecuteCommandsRequest(serial = True) # cmd_cookie = "show session" # cmd = "/nic/bin/halctl show session" # add_naples_command(tc, req1, cmd_cookie, cmd, tc.naples) # cmd_cookie = "show session detail" # cmd = "/nic/bin/halctl show session --dstport {} --dstip {} --yaml"\ # .format(tc.server_port+idx, tc.server.ip_address) # add_naples_command(tc, req1, cmd_cookie, cmd, tc.naples) # tc.resp1 = api.Trigger(req1) # cmd = tc.resp1.commands[-1] # for command in tc.resp1.commands: # api.PrintCommandResults(command) # iseq_num, iack_num, iwindosz, iwinscale, rseq_num, rack_num, rwindosz, rwinscale = get_conntrackinfo(cmd) # # Send Bad Data with TTL=0 from both Client and Server # req2 = api.Trigger_CreateExecuteCommandsRequest(serial=True) cmd_cookie = "send bad data from Client TTL=0: Create case" cmd = "hping3 --count 1 --baseport {} --destport {}\ --setseq {} --setack {} --ttl 0 --data 10 {}"\ .format(tc.client_port, tc.server_port+idx, rack_num, rseq_num, tc.server.ip_address) add_command(tc, req2, cmd_cookie, cmd, tc.client, False) cmd_cookie = "send bad data from Server TTL=0: Create case" cmd = "hping3 --count 1 --baseport {} --destport {}\ --setseq {} --setack {} --ttl 0 --data 10 {}"\ .format(tc.server_port+idx, tc.client_port, iack_num, iseq_num, tc.client.ip_address) add_command(tc, req2, cmd_cookie, cmd, tc.server, False) # # Send Bad Data with TCP-RSVD-FLAGS-BIT-0 set from Client and Server # cmd_cookie = "send bad data from Client TCP-RSVD-FLAGS-BIT-0: Create" cmd = "hping3 --count 1 --baseport {} --destport {}\ --setseq {} --setack {} --xmas --data 10 {}"\ .format(tc.client_port, tc.server_port+idx, rack_num+10, rseq_num, tc.server.ip_address) add_command(tc, req2, cmd_cookie, cmd, tc.client, False) cmd_cookie = "send bad data from Server TCP-RSVD-FLAGS-BIT-0: Create" cmd = "hping3 --count 1 --baseport {} --destport {}\ --setseq {} --setack {} --xmas --data 10 {}"\ .format(tc.server_port+idx, tc.client_port, iack_num+10, iseq_num, tc.client.ip_address) add_command(tc, req2, cmd_cookie, cmd, tc.server, False) # # Send Bad Data with TCP-RSVD-FLAGS-BIT-1 set from Client and Server # cmd_cookie = "send bad data from Client TCP-RSVD-FLAGS-BIT-1: Create" cmd = "hping3 --count 1 --baseport {} --destport {}\ --setseq {} --setack {} --ymas --data 10 {}"\ .format(tc.client_port, tc.server_port+idx, rack_num+20, rseq_num, tc.server.ip_address) add_command(tc, req2, cmd_cookie, cmd, tc.client, False) cmd_cookie = "send bad data from Server TCP-RSVD-FLAGS-BIT-1: Create" cmd = "hping3 --count 1 --baseport {} --destport {}\ --setseq {} --setack {} --ymas --data 10 {}"\ .format(tc.server_port+idx, tc.client_port, iack_num+20, iseq_num, tc.client.ip_address) add_command(tc, req2, cmd_cookie, cmd, tc.server, False) tc.resp2 = api.Trigger(req2) for command in tc.resp2.commands: api.PrintCommandResults(command) # api.Trigger_TerminateAllCommands(tc.resp1) api.Trigger_TerminateAllCommands(tc.resp2) idx += 1 # # Do "show session" command # req3 = api.Trigger_CreateExecuteCommandsRequest(serial=True) tc.cookie_idx_3 = tc.cookie_idx cmd_cookie = "show session" cmd = "/nic/bin/halctl show session" add_naples_command(tc, req3, cmd_cookie, cmd, tc.naples) # # Trigger "metrics get IPv4FlowDropMetrics" output # cmd_cookie = "show flow-drop: Create case" cmd = "PATH=$PATH:/platform/bin/;\ LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/platform/lib/:/nic/lib/;\ export PATH; export LD_LIBRARY_PATH;\ /nic/bin/delphictl metrics get IPv4FlowDropMetrics" add_naples_command(tc, req3, cmd_cookie, cmd, tc.naples) tc.resp3 = api.Trigger(req3) for command in tc.resp3.commands: api.PrintCommandResults(command) # # Re-establish TCP-connection # api.Trigger_TerminateAllCommands(resp_nc1) #time.sleep(5) # req_nc2 = api.Trigger_CreateExecuteCommandsRequest(serial = True) # # Make sure that Client<=>Server Forwarding is set up # # cmd_cookie = "trigger ping: Re-use case" # cmd = "ping -c1 %s -I %s" %\ # (tc.server.ip_address, tc.client.interface) # add_command(tc, req_nc2, cmd_cookie, cmd, tc.client, False) # idx = 0 # while (idx < tc.iterators.sessions): # cmd_cookie = "restart server" # cmd = "nc --listen {}".format(tc.server_port+idx) # add_command(tc, req_nc2, cmd_cookie, cmd, tc.server, True) # cmd_cookie = "restart client" # cmd = "nc {} {} --source-port {} "\ # .format(tc.server.ip_address, tc.server_port+idx, tc.client_port) # add_command(tc, req_nc2, cmd_cookie, cmd, tc.client, True) # idx += 1 # resp_nc2 = api.Trigger(req_nc2) # for command in resp_nc2.commands: # api.PrintCommandResults(command) # idx = 0 # while (idx < tc.iterators.sessions): # # # # Do applicable "show session" commands and # # retrieve Seq-num and Ack-num associated with the session # # # req4 = api.Trigger_CreateExecuteCommandsRequest(serial = True) # cmd_cookie = "show session" # cmd = "/nic/bin/halctl show session" # add_naples_command(tc, req4, cmd_cookie, cmd, tc.naples) # cmd_cookie = "show session detail" # cmd = "/nic/bin/halctl show session --dstport {} --dstip {} --yaml"\ # .format(tc.server_port+idx, tc.server.ip_address) # add_naples_command(tc, req4, cmd_cookie, cmd, tc.naples) # tc.resp4 = api.Trigger(req4) # cmd = tc.resp4.commands[-1] # for command in tc.resp4.commands: # api.PrintCommandResults(command) # iseq_num, iack_num, iwindosz, iwinscale, rseq_num, rack_num, rwindosz, rwinscale = get_conntrackinfo(cmd) # # # # Re-send Bad Data with TTL=0 from both Client and Server # # # req5 = api.Trigger_CreateExecuteCommandsRequest(serial = True) # cmd_cookie = "send bad data from Client TTL=0: Re-use case" # cmd = "hping3 --count 1 --baseport {} --destport {}\ # --setseq {} --setack {} --ttl 0 --data 10 {}"\ # .format(tc.client_port, tc.server_port+idx, rack_num, rseq_num, # tc.server.ip_address) # add_command(tc, req5, cmd_cookie, cmd, tc.client, False) # cmd_cookie = "send bad data from Server TTL=0: Re-use case" # cmd = "hping3 --count 1 --baseport {} --destport {}\ # --setseq {} --setack {} --ttl 0 --data 10 {}"\ # .format(tc.server_port+idx, tc.client_port, iack_num, iseq_num, # tc.client.ip_address) # add_command(tc, req5, cmd_cookie, cmd, tc.server, False) # # # # Re-send Bad Data with TCP-RSVD-FLAGS-BIT-0 set from Client and Server # # # cmd_cookie = "send bad data from Client TCP-RSVD-FLAGS-BIT-0: Re-use" # cmd = "hping3 --count 1 --baseport {} --destport {}\ # --setseq {} --setack {} --xmas --data 10 {}"\ # .format(tc.client_port, tc.server_port+idx, rack_num+10, rseq_num, # tc.server.ip_address) # add_command(tc, req5, cmd_cookie, cmd, tc.client, False) # cmd_cookie = "send bad data from Server TCP-RSVD-FLAGS-BIT-0: Re-use" # cmd = "hping3 --count 1 --baseport {} --destport {}\ # --setseq {} --setack {} --xmas --data 10 {}"\ # .format(tc.server_port+idx, tc.client_port, iack_num+10, iseq_num, # tc.client.ip_address) # add_command(tc, req5, cmd_cookie, cmd, tc.server, False) # # # # Re-send Bad Data with TCP-RSVD-FLAGS-BIT-1 set from Client and Server # # # cmd_cookie = "send bad data from Client TCP-RSVD-FLAGS-BIT-1: Re-use" # cmd = "hping3 --count 1 --baseport {} --destport {}\ # --setseq {} --setack {} --ymas --data 10 {}"\ # .format(tc.client_port, tc.server_port+idx, rack_num+20, rseq_num, # tc.server.ip_address) # add_command(tc, req5, cmd_cookie, cmd, tc.client, False) # cmd_cookie = "send bad data from Server TCP-RSVD-FLAGS-BIT-1: Re-use" # cmd = "hping3 --count 1 --baseport {} --destport {}\ # --setseq {} --setack {} --ymas --data 10 {}"\ # .format(tc.server_port+idx, tc.client_port, iack_num+20, iseq_num, # tc.client.ip_address) # add_command(tc, req5, cmd_cookie, cmd, tc.server, False) # tc.resp5 = api.Trigger(req5) # for command in tc.resp5.commands: # api.PrintCommandResults(command) # api.Trigger_TerminateAllCommands(tc.resp4) # api.Trigger_TerminateAllCommands(tc.resp5) # idx += 1 # # # # Do "show session" command # # # req6 = api.Trigger_CreateExecuteCommandsRequest(serial = True) # tc.cookie_idx_6 = tc.cookie_idx # cmd_cookie = "show session" # cmd = "/nic/bin/halctl show session" # add_naples_command(tc, req6, cmd_cookie, cmd, tc.naples) # # # # Trigger "metrics get IPv4FlowDropMetrics" output # # # cmd_cookie = "show flow-drop: Re-use case" # cmd = "PATH=$PATH:/platform/bin/;\ # LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/platform/lib/:/nic/lib/;\ # export PATH; export LD_LIBRARY_PATH;\ # /nic/bin/delphictl metrics get IPv4FlowDropMetrics" # add_naples_command(tc, req6, cmd_cookie, cmd, tc.naples) # tc.resp6 = api.Trigger(req6) # for command in tc.resp6.commands: # api.PrintCommandResults(command) # # Do "show session" command after doing Sleep for 45secs # # api.Trigger_TerminateAllCommands(resp_nc2) req7 = api.Trigger_CreateExecuteCommandsRequest(serial=True) tc.cookie_idx_7 = tc.cookie_idx cmd_cookie = "clear session" cmd = "/nic/bin/halctl clear session; sleep 45" add_naples_command(tc, req7, cmd_cookie, cmd, tc.naples) cmd_cookie = "show session" cmd = "/nic/bin/halctl show session" add_naples_command(tc, req7, cmd_cookie, cmd, tc.naples) # # Trigger "metrics get IPv4FlowDropMetrics" output # cmd_cookie = "show flow-drop: Delete case" cmd = "PATH=$PATH:/platform/bin/;\ LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/platform/lib/:/nic/lib/;\ export PATH; export LD_LIBRARY_PATH;\ /nic/bin/delphictl metrics get IPv4FlowDropMetrics" add_naples_command(tc, req7, cmd_cookie, cmd, tc.naples) tc.resp7 = api.Trigger(req7) for command in tc.resp7.commands: api.PrintCommandResults(command) return api.types.status.SUCCESS
def Trigger(tc): tc.cmd_cookies = [] client, server, naples = tc.client, tc.server, tc.naples req = api.Trigger_CreateExecuteCommandsRequest(serial=True) cmd_cookie = "%s(%s) --> %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) api.Logger.info("Starting TCP aging test from %s" % (cmd_cookie)) cmd_cookie = "halctl clear session" api.Trigger_AddNaplesCommand(req, server.node_name, "/nic/bin/halctl clear session") tc.cmd_cookies.append(cmd_cookie) #Step 0: Update the timeout in the config object if not tc.args.skip_security_prof: update_timeout('tcp-timeout', tc.iterators.timeout) timeout = timetoseconds(tc.iterators.timeout) else: timeout = DEFAULT_TCP_TIMEOUT #profilereq = api.Trigger_CreateExecuteCommandsRequest(serial = True) #api.Trigger_AddNaplesCommand(profilereq, naples.node_name, "/nic/bin/halctl show nwsec profile --id 11") #profcommandresp = api.Trigger(profilereq) #cmd = profcommandresp.commands[-1] #for command in profcommandresp.commands: # api.PrintCommandResults(command) #timeout = get_haltimeout('tcp-timeout', cmd) #tc.config_update_fail = 0 #if (timeout != timetoseconds(tc.iterators.timeout)): # tc.config_update_fail = 1 server_port = api.AllocateTcpPort() client_port = api.AllocateTcpPort() cmd_cookie = "Send SYN from client" api.Trigger_AddCommand( req, client.node_name, client.workload_name, "hping3 -c 1 -s %s -p %s -M 0 -L 0 -S %s" % (client_port, server_port, server.ip_address)) tc.cmd_cookies.append(cmd_cookie) cmd_cookie = "Send SYN, ACK and SEQ from server" api.Trigger_AddCommand( req, server.node_name, server.workload_name, "hping3 -c 1 -s %s -p %s -M 0 -A -L 1 -S %s" % (server_port, client_port, client.ip_address)) tc.cmd_cookies.append(cmd_cookie) #Get Seq + Ack api.Trigger_AddNaplesCommand( req, naples.node_name, "/nic/bin/halctl show session ".format(server_port, server.ip_address)) tc.cmd_cookies.append("show session") api.Trigger_AddNaplesCommand( req, naples.node_name, "/nic/bin/halctl show session --dstport {} --dstip {} --yaml".format( server_port, server.ip_address)) tc.cmd_cookies.append("show session detail") trig_resp1 = api.Trigger(req) cmd = trig_resp1.commands[-1] for command in trig_resp1.commands: api.PrintCommandResults(command) tc.ctrckinf = get_conntrackinfo(cmd) #Send ACK req2 = api.Trigger_CreateExecuteCommandsRequest(serial=True) api.Trigger_AddCommand( req2, client.node_name, client.workload_name, "hping3 -c 1 -s {} -p {} -M {} -L {} --ack {}".format( client_port, server_port, tc.ctrckinf.r_tcpacknum, tc.ctrckinf.r_tcpseqnum, server.ip_address)) tc.cmd_cookies.append("Send ACK") cmd_cookie = "Before aging show session" api.Trigger_AddNaplesCommand( req2, naples.node_name, "/nic/bin/halctl show session --dstport {} --dstip {} | grep ESTABLISHED" .format(server_port, server.ip_address)) tc.cmd_cookies.append(cmd_cookie) #Get it from the config if not tc.args.skip_security_prof: timeout += get_timeout('tcp-close') + (TCP_TICKLE_GAP * NUM_TICKLES) + GRACE_TIME else: timeout += GRACE_TIME api.Logger.info("Sleeping for %s sec... " % timeout) cmd_cookie = "sleep" api.Trigger_AddNaplesCommand(req2, naples.node_name, "sleep %s" % timeout, timeout=300) tc.cmd_cookies.append(cmd_cookie) cmd_cookie = "After aging show session" api.Trigger_AddNaplesCommand( req2, naples.node_name, "/nic/bin/halctl show session --dstport {} --dstip {} | grep ESTABLISHED" .format(server_port, server.ip_address)) tc.cmd_cookies.append(cmd_cookie) cmd_cookie = "show session yaml" api.Trigger_AddNaplesCommand( req2, naples.node_name, "/nic/bin/halctl show session --yaml --ipproto 6".format( server_port, server.ip_address)) tc.cmd_cookies.append(cmd_cookie) trig_resp2 = api.Trigger(req2) term_resp2 = api.Trigger_TerminateAllCommands(trig_resp2) tc.resp2 = api.Trigger_AggregateCommandsResponse(trig_resp2, term_resp2) term_resp1 = api.Trigger_TerminateAllCommands(trig_resp1) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp1, term_resp1) return api.types.status.SUCCESS
def start_fuz(tc, fuz_run_time=__fuz_run_time, read_timeout=__read_timeout, copyfuz=True): ''' if arping.ArPing(tc) != api.types.status.SUCCESS: api.Logger.info("arping failed on setup") tc1 = ping.TestPing(tc, 'local_only', 'ipv4', 64) tc2 = ping.TestPing(tc, 'remote_only', 'ipv4', 64) if tc1 != api.types.status.SUCCESS or tc2 != api.types.status.SUCCESS: api.Logger.info("ping test failed on setup") return api.types.status.FAILURE ''' if copyfuz: ret = copy_fuz(tc) if ret != api.types.status.SUCCESS: return api.types.status.FAILURE tc.serverCmds = [] tc.clientCmds = [] tc.cmd_descr = [] serverReq = None clientReq = None serverReq = api.Trigger_CreateExecuteCommandsRequest(serial=False) clientReq = api.Trigger_CreateExecuteCommandsRequest(serial=False) # ping test above sets the workload pairs to remote only # setting wl_pairs as per arg selected in testbundle workload_pairs = [] if tc.args.type == 'local_only': api.Logger.info("local_only test") workload_pairs = api.GetLocalWorkloadPairs() elif tc.args.type == 'both': api.Logger.info(" both local and remote test") workload_pairs = api.GetLocalWorkloadPairs() workload_pairs.extend(api.GetRemoteWorkloadPairs()) else: api.Logger.info("remote_only test") workload_pairs = api.GetRemoteWorkloadPairs() wl_under_move = [] for wl_info in tc.move_info: wl_under_move.append(wl_info.wl) tc.workload_pairs = [] for pairs in workload_pairs: if pairs[0] in wl_under_move or pairs[1] in wl_under_move: api.Logger.info("Adding %s and %s for fuz test" % (pairs[0].workload_name, pairs[1].workload_name)) tc.workload_pairs.append(pairs) for idx, pairs in enumerate(tc.workload_pairs): client = pairs[0] server = pairs[1] cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) tc.cmd_descr.append(cmd_descr) num_sessions = int(getattr(tc.args, "num_sessions", 1)) serverCmd = None clientCmd = None port = api.AllocateTcpPort() api.Logger.info("Starting Fuz test from %s num-sessions %d port %d" % (cmd_descr, num_sessions, port)) serverCmd = tc.fuz_exec[server.workload_name] + " -port " + str(port) clientCmd = tc.fuz_exec[client.workload_name] + " -conns " +\ str(num_sessions) + " -duration " + str(__fuz_run_time) +\ " -attempts 1 -read-timeout " + read_timeout +" -talk " +\ server.ip_address + ":" + str(port) api.Logger.info("Server command %s" % serverCmd) api.Logger.info("Client command %s" % clientCmd) tc.serverCmds.append(serverCmd) tc.clientCmds.append(clientCmd) api.Trigger_AddCommand(serverReq, server.node_name, server.workload_name, serverCmd, background=True) api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name, clientCmd, background=True) tc.server_resp = api.Trigger(serverReq) #Sleep for some time as bg may not have been started. time.sleep(5) tc.fuz_client_resp = api.Trigger(clientReq) return api.types.status.SUCCESS
def runIperfTest(tc, srv, cli): if api.IsDryrun(): return api.types.status.SUCCESS req1 = api.Trigger_CreateExecuteCommandsRequest(serial=True) req2 = api.Trigger_CreateExecuteCommandsRequest(serial=False) proto = getattr(tc.iterators, "proto", 'tcp') number_of_iperf_threads = getattr(tc.args, "iperfthreads", 1) pktsize = getattr(tc.iterators, "pktsize", 512) ipproto = getattr(tc.iterators, "ipproto", 'v4') if ipproto == 'v6': srv_ip_address = srv.ipv6_address tc.cmd_descr = " Server: %s(%s) <--> Client: %s(%s)" %\ (srv.interface, srv.ipv6_address, cli.interface, cli.ipv6_address) else: srv_ip_address = srv.ip_address tc.cmd_descr = " Server: %s(%s) <--> Client: %s(%s)" %\ (srv.interface, srv.ip_address, cli.interface, cli.ip_address) api.Logger.info("Starting TSO test %s" % (tc.cmd_descr)) tc.srv_bad_csum = ionic_stats.getNetstatBadCsum(srv, proto) tc.cli_bad_csum = ionic_stats.getNetstatBadCsum(cli, proto) for i in range(number_of_iperf_threads): if proto == 'tcp': port = api.AllocateTcpPort() else: port = api.AllocateUdpPort() file_name_suffix = "_instance" + \ str(i) + proto + "_" + ipproto + "_" + str(pktsize) file_name = '/tmp/' + 'srv_' + srv.interface + file_name_suffix iperf_server_cmd = cmd_builder.iperf_server_cmd(port=port) api.Trigger_AddCommand(req1, srv.node_name, srv.workload_name, iperf_server_cmd, background=True) file_name = '/tmp/' + 'cli_' + cli.interface + file_name_suffix iperf_file_name = file_name + ".log" iperf_client_cmd = cmd_builder.iperf_client_cmd( server_ip=srv_ip_address, port=port, proto=proto, pktsize=pktsize, ipproto=ipproto) # Once iperf JSON support is available, we don't need this hacks. api.Trigger_AddCommand( req2, cli.node_name, cli.workload_name, iperf_client_cmd + " -J | tee " + iperf_file_name) # Read the retransmission counter from the log api.Trigger_AddCommand( req2, cli.node_name, cli.workload_name, 'grep retrans ' + iperf_file_name + '| tail -1| cut -d ":" -f 2 | cut -d "," -f 1') # Read the bandwidth numbers. api.Trigger_AddCommand( req2, cli.node_name, cli.workload_name, 'cat ' + iperf_file_name + ' | grep bits_per_second | tail -1 | cut -d ":" -f 2 | cut -d "," -f 1' ) # Read the bytes transferred numbers. api.Trigger_AddCommand( req2, cli.node_name, cli.workload_name, 'cat ' + iperf_file_name + ' | grep bytes | tail -1 | cut -d ":" -f 2 | cut -d "," -f 1') trig_resp1 = api.Trigger(req1) if trig_resp1 is None: api.Logger.error("Failed to run iperf server") return api.types.status.FAILURE tc.resp = api.Trigger(req2) if tc.resp is None: api.Logger.error("Failed to run iperf client") return api.types.status.FAILURE for cmd in tc.resp.commands: if cmd.exit_code != 0: api.Logger.error("Failed to start client iperf\n") api.PrintCommandResults(cmd) return api.types.status.FAILURE status, retran, bw = verifySingle(tc) vlan = getattr(tc.iterators, 'vlantag', 'off') vxlan = getattr(tc.iterators, 'vxlan', 'off') tso = getattr(tc.iterators, 'tso_offload', 'off') api.Logger.info( "Result TSO: %s VLAN: %s VXLAN: %s Proto: %s/%s Pkt size: %d Threads: %d" " Bandwidth: %d Mbps" % (tso, vlan, vxlan, proto, ipproto, pktsize, number_of_iperf_threads, bw)) return status
def Trigger(tc): naples_list = [] tc.cmd_cookies = [] tc.fin_fail = 0 req = api.Trigger_CreateExecuteCommandsRequest(serial=True) idx = 0 for pairs in tc.workload_pairs: server = pairs[0] client = pairs[1] naples = server if not server.IsNaples(): naples = client if not client.IsNaples(): continue found = False for info in naples_list: if info[0] == naples.node_name: found = True if found == False: naples_list.append((naples.node_name, pairs)) tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) api.Logger.info("Starting Upgrade test from %s" % (tc.cmd_descr)) #Step 1: Start TCPDUMP api.Trigger_AddCommand(req, client.node_name, client.workload_name, "tcpdump -i {} > out.txt".format( client.interface), background=True) tc.cmd_cookies.append("tcpdump on client") api.Trigger_AddCommand(req, server.node_name, server.workload_name, "tcpdump -i {} > out.txt".format( server.interface), background=True) tc.cmd_cookies.append("tcpdump on server") #Step 1: Start TCP Server server_port = api.AllocateTcpPort() api.Trigger_AddCommand(req, server.node_name, server.workload_name, "nc -l %s" % (server_port), background=True) tc.cmd_cookies.append("start server") #Step 2: Start TCP Client client_port = api.AllocateTcpPort() api.Trigger_AddCommand(req, client.node_name, client.workload_name, "nc {} {} -p {}".format(server.ip_address, server_port, client_port), background=True) tc.cmd_cookies.append("start client") api.Trigger_AddCommand(req, server.node_name, server.workload_name, "ping {}".format(server.ip_address), background=True) tc.cmd_cookies.append("Start ping") idx = idx + 1 for node in naples_list: api.Trigger_AddNaplesCommand(req, node[0], "/nic/bin/halctl show session") tc.cmd_cookies.append("show session") api.Trigger_AddNaplesCommand(req, node[0], "/nic/bin/halctl debug test send-fin") tc.cmd_cookies.append("Send fin") api.Trigger_AddNaplesCommand(req, node[0], "/nic/bin/halctl show session --yaml") tc.cmd_cookies.append("show session after delete") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) for node in naples_list: found = False api.CopyFromWorkload(node[1][0].node_name, node[1][0].workload_name, ['out.txt'], dir_path) api.Logger.info("Copy from {} {}".format(node[0], node[1][0])) tcpout = dir_path + '/out.txt' for line in open(tcpout, 'r'): if re.search("\[F\.\]", line): found = True break if node[0] == node[1][0].node_name and found == False: tc.fin_fail = 1 os.remove(tcpout) found = False api.CopyFromWorkload(node[1][1].node_name, node[1][1].workload_name, ['out.txt'], dir_path) api.Logger.info("Copy from {} {}".format(node[0], node[1][0])) tcpout = dir_path + '/out.txt' for line in open(tcpout, 'r'): if re.search("\[F\.\]", line): found = True if node[0] == node[1][1].node_name and found == False: tc.fin_fail = 1 os.remove(tcpout) return api.types.status.SUCCESS
def iperf_test(tc): tc.flow_hit_cnt_before = {} tc.flow_hit_cnt_after = {} tc.flow_match_before = {} tc.flow_match_after = {} tc.conntrack_state = {} tc.is_ct_test = False if tc.duration is not None and tc.stateful: tc.is_ct_test = True api.Logger.info("Start Connection Tracking e2e iPerf Test") wl_nodes = [pair[0] for pair in tc.wl_node_nic_pairs] node1, node2 = wl_nodes[0], wl_nodes[1] node1_ath_nic = tc.athena_node_nic_pairs[0][1] node2_ath_nic = tc.athena_node_nic_pairs[1][1] tc.node_info = {'node1': node1, 'node2': node2, 'node1_ath_nic': node1_ath_nic, 'node2_ath_nic': node2_ath_nic} # cl_node => client node for cl_node in wl_nodes: tc.flow_hit_cnt_before[cl_node] = [] tc.flow_hit_cnt_after[cl_node] = [] tc.flow_match_before[cl_node] = [] tc.flow_match_after[cl_node] = [] tc.conntrack_state[cl_node] = [] sintf, dintf, smac, dmac, sip, dip = _get_client_server_info( cl_node, tc) if tc.proto == 'UDP': sport = api.AllocateUdpPort() dport = api.AllocateUdpPort() else: sport = api.AllocateTcpPort() dport = api.AllocateTcpPort() flow_n1, flow_n2 = _get_bitw_flows(cl_node, tc.proto, sip, dip, sport = sport, dport = dport) def _get_flow_match_info(flow_match_dict): for node, nic, vnic_id, flow in [ (node1, node1_ath_nic, tc.node1_vnic_id, flow_n1), (node2, node2_ath_nic, tc.node2_vnic_id, flow_n2)]: rc, num_match_ent = utils.match_dynamic_flows(node, vnic_id, flow, nic) if rc != api.types.status.SUCCESS: return rc flow_match_dict[cl_node].append((flow, num_match_ent)) return (api.types.status.SUCCESS) # check if flow installed on both athena nics before sending traffic rc = _get_flow_match_info(tc.flow_match_before) if rc != api.types.status.SUCCESS: return rc # Send iperf traffic if cl_node == 'node1': client_wl = tc.wl[0] server_wl = tc.wl[1] else: client_wl = tc.wl[1] server_wl = tc.wl[0] cmd_descr = "Client %s(%s) <--> Server %s(%s)" % (sip, sintf, dip, dintf) tc.cmd_descr.append(cmd_descr) api.Logger.info("Starting Iperf test: %s" % cmd_descr) serverCmd = iperf.ServerCmd(dport, server_ip = dip) if tc.proto == 'UDP': clientCmd = iperf.ClientCmd(dip, dport, proto = 'udp', jsonOut = True, client_ip = sip, client_port = sport, pktsize = tc.pyld_size, packet_count = tc.pkt_cnt) else: if tc.is_ct_test: clientCmd = iperf.ClientCmd(dip, dport, jsonOut = True, client_ip = sip, client_port = sport, pktsize = tc.pyld_size, time = tc.duration) else: clientCmd = iperf.ClientCmd(dip, dport, jsonOut = True, client_ip = sip, client_port = sport, pktsize = tc.pyld_size, packet_count = tc.pkt_cnt) tc.serverCmds.append(serverCmd) tc.clientCmds.append(clientCmd) serverReq = api.Trigger_CreateExecuteCommandsRequest() clientReq = api.Trigger_CreateExecuteCommandsRequest() api.Trigger_AddCommand(serverReq, server_wl.node_name, server_wl.workload_name, serverCmd, background = True) api.Trigger_AddCommand(clientReq, client_wl.node_name, client_wl.workload_name, clientCmd, background = True) server_resp = api.Trigger(serverReq) # sleep for bg iperf servers to be started time.sleep(3) tc.iperf_client_resp.append(api.Trigger(clientReq)) if tc.is_ct_test: iperf_ct_test(tc, cl_node, flow_n1, flow_n2) api.Trigger_TerminateAllCommands(server_resp) # check if flow installed on both athena nics after sending traffic rc = _get_flow_match_info(tc.flow_match_after) if rc != api.types.status.SUCCESS: return rc return (api.types.status.SUCCESS)
def Trigger(tc): if tc.skip == True: return api.types.status.FAILURE # # Set-up Test Environment # tc.cmd_cookies = [] tc.cookie_idx = 0 cmd_cookie = "%s(%s) --> %s(%s)" %\ (tc.server.workload_name, tc.server.ip_address, tc.client.workload_name, tc.client.ip_address) api.Logger.info("Starting Single-IPv4-TCP-Flow-Drops test from %s" %\ (cmd_cookie)) # # Start TCPDUMP in background on Server/Client # req = api.Trigger_CreateExecuteCommandsRequest(serial=True) #cmd_cookie = "start tcpdump on Server" #cmd = "sudo tcpdump -nnSXi {} > out.txt".format(tc.server.interface) #add_command(tc, req, cmd_cookie, cmd, tc.server, True) #cmd_cookie = "start tcpdump on Client" #cmd = "sudo tcpdump -nnSXi {} > out.txt".format(tc.client.interface) #add_command(tc, req, cmd_cookie, cmd, tc.client, True) # # Start with a clean slate by clearing all sessions/flows # 45 secs sleep is to ensure that residual FlowDrops induced by previous # non-flowstats testbundle (in this case Connectivity) is flushed out # cmd_cookie = "clear session" cmd = "/nic/bin/halctl clear session; sleep 45" add_naples_command(tc, req, cmd_cookie, cmd, tc.naples) # # Make sure that Client<=>Server Forwarding is set up # cmd_cookie = "trigger ping: Create case" cmd = "ping -c1 %s -I %s" %\ (tc.server.ip_address, tc.client.interface) add_command(tc, req, cmd_cookie, cmd, tc.client, False) tc.resp = api.Trigger(req) for command in tc.resp.commands: api.PrintCommandResults(command) # # Allocate TCP-portnum for Server and start the service on the Server # req_nc1 = api.Trigger_CreateExecuteCommandsRequest(serial=True) tc.server_port = api.AllocateTcpPort() cmd_cookie = "start server" cmd = "nc --listen %s" % (tc.server_port) add_command(tc, req_nc1, cmd_cookie, cmd, tc.server, True) # # Allocate TCP-portnum for Client and establish TCP-connection # tc.client_port = api.AllocateTcpPort() cmd_cookie = "start client" cmd = "nc {} {} --source-port {} "\ .format(tc.server.ip_address, tc.server_port, tc.client_port) add_command(tc, req_nc1, cmd_cookie, cmd, tc.client, True) resp_nc1 = api.Trigger(req_nc1) for command in resp_nc1.commands: api.PrintCommandResults(command) # # Do applicable "show session" commands and # retrieve Seq-num and Ack-num associated with the session # req1 = api.Trigger_CreateExecuteCommandsRequest(serial=True) cmd_cookie = "show session" cmd = "/nic/bin/halctl show session" add_naples_command(tc, req1, cmd_cookie, cmd, tc.naples) cmd_cookie = "show session detail" cmd = "/nic/bin/halctl show session --dstport {} --dstip {} --yaml"\ .format(tc.server_port, tc.server.ip_address) add_naples_command(tc, req1, cmd_cookie, cmd, tc.naples) tc.resp1 = api.Trigger(req1) cmd = tc.resp1.commands[-1] for command in tc.resp1.commands: api.PrintCommandResults(command) tc.pre_ctrckinf = get_conntrackinfo(cmd) # # Send Bad Data with TTL=0 from both Client and Server # req2 = api.Trigger_CreateExecuteCommandsRequest(serial=True) cmd_cookie = "send bad data from Client TTL=0: Create case" cmd = "hping3 --count 1 --baseport {} --destport {} --setseq {} --setack {}\ --ttl 0 --data 10 {}".format(tc.client_port, tc.server_port, tc.pre_ctrckinf.r_tcpacknum, tc.pre_ctrckinf.r_tcpseqnum, tc.server.ip_address) add_command(tc, req2, cmd_cookie, cmd, tc.client, False) cmd_cookie = "send bad data from Server TTL=0: Create case" cmd = "hping3 --count 1 --baseport {} --destport {} --setseq {} --setack {}\ --ttl 0 --data 10 {}".format(tc.server_port, tc.client_port, tc.pre_ctrckinf.i_tcpacknum, tc.pre_ctrckinf.i_tcpseqnum, tc.client.ip_address) add_command(tc, req2, cmd_cookie, cmd, tc.server, False) # # Send Bad Data with TCP-RSVD-FLAGS-BIT-0 set from both Client and Server # cmd_cookie = "send bad data from Client TCP-RSVD-FLAGS-BIT-0: Create case" cmd = "hping3 --count 1 --baseport {} --destport {} --setseq {} --setack {}\ --xmas --data 10 {}".format(tc.client_port, tc.server_port, tc.pre_ctrckinf.r_tcpacknum + 10, tc.pre_ctrckinf.r_tcpseqnum, tc.server.ip_address) add_command(tc, req2, cmd_cookie, cmd, tc.client, False) cmd_cookie = "send bad data from Server TCP-RSVD-FLAGS-BIT-0: Create case" cmd = "hping3 --count 1 --baseport {} --destport {} --setseq {} --setack {}\ --xmas --data 10 {}".format(tc.server_port, tc.client_port, tc.pre_ctrckinf.i_tcpacknum + 10, tc.pre_ctrckinf.i_tcpseqnum, tc.client.ip_address) add_command(tc, req2, cmd_cookie, cmd, tc.server, False) # # Send Bad Data with TCP-RSVD-FLAGS-BIT-1 set from both Client and Server # cmd_cookie = "send bad data from Client TCP-RSVD-FLAGS-BIT-1: Create case" cmd = "hping3 --count 1 --baseport {} --destport {} --setseq {} --setack {}\ --ymas --data 10 {}".format(tc.client_port, tc.server_port, tc.pre_ctrckinf.r_tcpacknum + 20, tc.pre_ctrckinf.r_tcpseqnum, tc.server.ip_address) add_command(tc, req2, cmd_cookie, cmd, tc.client, False) cmd_cookie = "send bad data from Server TCP-RSVD-FLAGS-BIT-1: Create case" cmd = "hping3 --count 1 --baseport {} --destport {} --setseq {} --setack {}\ --ymas --data 10 {}".format(tc.server_port, tc.client_port, tc.pre_ctrckinf.i_tcpacknum + 20, tc.pre_ctrckinf.i_tcpseqnum, tc.client.ip_address) add_command(tc, req2, cmd_cookie, cmd, tc.server, False) tc.resp2 = api.Trigger(req2) for command in tc.resp2.commands: api.PrintCommandResults(command) # # Do "show session" command # req3 = api.Trigger_CreateExecuteCommandsRequest(serial=True) tc.cookie_idx_3 = tc.cookie_idx cmd_cookie = "show session" cmd = "/nic/bin/halctl show session" add_naples_command(tc, req3, cmd_cookie, cmd, tc.naples) # # Trigger "metrics get IPv4FlowDropMetrics" output # cmd_cookie = "show flow-drop: Create case" cmd = "PATH=$PATH:/platform/bin/;\ LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/platform/lib/:/nic/lib/;\ export PATH; export LD_LIBRARY_PATH;\ /nic/bin/delphictl metrics get IPv4FlowDropMetrics" add_naples_command(tc, req3, cmd_cookie, cmd, tc.naples) tc.resp3 = api.Trigger(req3) for command in tc.resp3.commands: api.PrintCommandResults(command) # # Clear all sessions/flows # api.Trigger_TerminateAllCommands(resp_nc1) req_nc2 = api.Trigger_CreateExecuteCommandsRequest(serial=True) cmd_cookie = "clear session" cmd = "/nic/bin/halctl clear session" add_naples_command(tc, req_nc2, cmd_cookie, cmd, tc.naples) # # Make sure that Client<=>Server Forwarding is set up # cmd_cookie = "trigger ping: Re-use case" cmd = "ping -c1 %s -I %s" %\ (tc.server.ip_address, tc.client.interface) add_command(tc, req_nc2, cmd_cookie, cmd, tc.client, False) # # Re-establish TCP-connection # cmd_cookie = "show session" cmd = "/nic/bin/halctl show session" add_naples_command(tc, req_nc2, cmd_cookie, cmd, tc.naples) cmd_cookie = "restart server" cmd = "nc --listen %s" % (tc.server_port) add_command(tc, req_nc2, cmd_cookie, cmd, tc.server, True) cmd_cookie = "restart client" cmd = "nc {} {} --source-port {} "\ .format(tc.server.ip_address, tc.server_port, tc.client_port) add_command(tc, req_nc2, cmd_cookie, cmd, tc.client, True) resp_nc2 = api.Trigger(req_nc2) for command in resp_nc2.commands: api.PrintCommandResults(command) # # Do applicable "show session" commands and # retrieve Seq-num and Ack-num associated with the session # req4 = api.Trigger_CreateExecuteCommandsRequest(serial=True) cmd_cookie = "show session" cmd = "/nic/bin/halctl show session" add_naples_command(tc, req4, cmd_cookie, cmd, tc.naples) cmd_cookie = "show session detail" cmd = "/nic/bin/halctl show session --dstport {} --dstip {} --yaml"\ .format(tc.server_port, tc.server.ip_address) add_naples_command(tc, req4, cmd_cookie, cmd, tc.naples) tc.resp4 = api.Trigger(req4) cmd = tc.resp4.commands[-1] for command in tc.resp4.commands: api.PrintCommandResults(command) tc.post_ctrckinf = get_conntrackinfo(cmd) # # Re-send Bad Data with TTL=0 from both Client and Server # req5 = api.Trigger_CreateExecuteCommandsRequest(serial=True) cmd_cookie = "send bad data from Client TTL=0: Re-use case" cmd = "hping3 --count 1 --baseport {} --destport {} --setseq {} --setack {}\ --ttl 0 --data 10 {}".format(tc.client_port, tc.server_port, tc.post_ctrckinf.r_tcpacknum, tc.post_ctrckinf.r_tcpseqnum, tc.server.ip_address) add_command(tc, req5, cmd_cookie, cmd, tc.client, False) cmd_cookie = "send bad data from Server TTL=0: Re-use case" cmd = "hping3 --count 1 --baseport {} --destport {} --setseq {} --setack {}\ --ttl 0 --data 10 {}".format(tc.server_port, tc.client_port, tc.post_ctrckinf.i_tcpacknum, tc.post_ctrckinf.i_tcpseqnum, tc.client.ip_address) add_command(tc, req5, cmd_cookie, cmd, tc.server, False) # # Re-send Bad Data with TCP-RSVD-FLAGS-BIT-0 set from both Client and Server # cmd_cookie = "send bad data from Client TCP-RSVD-FLAGS-BIT-0: Re-use case" cmd = "hping3 --count 1 --baseport {} --destport {} --setseq {} --setack {}\ --xmas --data 10 {}".format(tc.client_port, tc.server_port, tc.post_ctrckinf.r_tcpacknum + 10, tc.post_ctrckinf.r_tcpseqnum, tc.server.ip_address) add_command(tc, req5, cmd_cookie, cmd, tc.client, False) cmd_cookie = "send bad data from Server TCP-RSVD-FLAGS-BIT-0: Re-use case" cmd = "hping3 --count 1 --baseport {} --destport {} --setseq {} --setack {}\ --xmas --data 10 {}".format(tc.server_port, tc.client_port, tc.post_ctrckinf.i_tcpacknum + 10, tc.post_ctrckinf.i_tcpseqnum, tc.client.ip_address) add_command(tc, req5, cmd_cookie, cmd, tc.server, False) # # Re-send Bad Data with TCP-RSVD-FLAGS-BIT-1 set from both Client and Server # cmd_cookie = "send bad data from Client TCP-RSVD-FLAGS-BIT-1: Re-use case" cmd = "hping3 --count 1 --baseport {} --destport {} --setseq {} --setack {}\ --ymas --data 10 {}".format(tc.client_port, tc.server_port, tc.post_ctrckinf.r_tcpacknum + 20, tc.post_ctrckinf.r_tcpseqnum, tc.server.ip_address) add_command(tc, req5, cmd_cookie, cmd, tc.client, False) cmd_cookie = "send bad data from Server TCP-RSVD-FLAGS-BIT-1: Re-use case" cmd = "hping3 --count 1 --baseport {} --destport {} --setseq {} --setack {}\ --ymas --data 10 {}".format(tc.server_port, tc.client_port, tc.post_ctrckinf.i_tcpacknum + 20, tc.post_ctrckinf.i_tcpseqnum, tc.client.ip_address) add_command(tc, req5, cmd_cookie, cmd, tc.server, False) tc.resp5 = api.Trigger(req5) for command in tc.resp5.commands: api.PrintCommandResults(command) # # Do "show session" command # req6 = api.Trigger_CreateExecuteCommandsRequest(serial=True) tc.cookie_idx_6 = tc.cookie_idx cmd_cookie = "show session" cmd = "/nic/bin/halctl show session" add_naples_command(tc, req6, cmd_cookie, cmd, tc.naples) # # Trigger "metrics get IPv4FlowDropMetrics" output # cmd_cookie = "show flow-drop: Re-use case" cmd = "PATH=$PATH:/platform/bin/;\ LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/platform/lib/:/nic/lib/;\ export PATH; export LD_LIBRARY_PATH;\ /nic/bin/delphictl metrics get IPv4FlowDropMetrics" add_naples_command(tc, req6, cmd_cookie, cmd, tc.naples) tc.resp6 = api.Trigger(req6) for command in tc.resp6.commands: api.PrintCommandResults(command) # # Do "show session" command after doing Sleep for 45secs # api.Trigger_TerminateAllCommands(resp_nc2) req7 = api.Trigger_CreateExecuteCommandsRequest(serial=True) tc.cookie_idx_7 = tc.cookie_idx cmd_cookie = "clear session" cmd = "/nic/bin/halctl clear session; sleep 45" add_naples_command(tc, req7, cmd_cookie, cmd, tc.naples) cmd_cookie = "show session" cmd = "/nic/bin/halctl show session" add_naples_command(tc, req7, cmd_cookie, cmd, tc.naples) # # Trigger "metrics get IPv4FlowDropMetrics" output # cmd_cookie = "show flow-drop: Delete case" cmd = "PATH=$PATH:/platform/bin/;\ LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/platform/lib/:/nic/lib/;\ export PATH; export LD_LIBRARY_PATH;\ /nic/bin/delphictl metrics get IPv4FlowDropMetrics" add_naples_command(tc, req7, cmd_cookie, cmd, tc.naples) tc.resp7 = api.Trigger(req7) for command in tc.resp7.commands: api.PrintCommandResults(command) return api.types.status.SUCCESS
def Trigger(tc): serverCmd = None clientCmd = None IPERF_TIMEOUT = 86400 try: serverReq = api.Trigger_CreateExecuteCommandsRequest() clientReq = api.Trigger_CreateExecuteCommandsRequest() client = tc.wl_pair[0] server = tc.wl_pair[1] tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) num_streams = int(getattr(tc.args, "num_streams", 2)) api.Logger.info("Starting Iperf test from %s num-sessions %d" % (tc.cmd_descr, num_streams)) if tc.iterators.proto == 'tcp': port = api.AllocateTcpPort() serverCmd = iperf.ServerCmd(port, jsonOut=True, run_core=3) clientCmd = iperf.ClientCmd(server.ip_address, port, time=IPERF_TIMEOUT, jsonOut=True, num_of_streams=num_streams, run_core=3) else: port = api.AllocateUdpPort() serverCmd = iperf.ServerCmd(port, jsonOut=True, run_core=3) clientCmd = iperf.ClientCmd(server.ip_address, port, proto='udp', jsonOut=True, num_of_streams=num_streams, run_core=3) tc.serverCmd = serverCmd tc.clientCmd = clientCmd api.Trigger_AddCommand(serverReq, server.node_name, server.workload_name, serverCmd, background=True, timeout=IPERF_TIMEOUT) api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name, clientCmd, background=True, timeout=IPERF_TIMEOUT) tc.server_resp = api.Trigger(serverReq) time.sleep(5) tc.iperf_client_resp = api.Trigger(clientReq) _run_vmedia_traffic(tc.node_name) except: api.Logger.error(traceback.format_exc()) return api.types.status.FAILURE return api.types.status.SUCCESS
def Trigger(tc): api.Logger.info("Trigger.") pairs = api.GetLocalWorkloadPairs(naples=True) tc.cmd_cookies1 = [] tc.cmd_cookies2 = [] req = api.Trigger_CreateExecuteCommandsRequest(serial=True) #for w1,w2 in pairs: server, client = pairs[0] naples = server if not server.IsNaples(): if not client.IsNaples(): naples = client return api.types.status.SUCCESS else: client, server = pairs[0] #Step 0: Update the timeout in the config object update_timeout("tcp-connection-setup", tc.iterators.timeout) #profilereq = api.Trigger_CreateExecuteCommandsRequest(serial = True) #api.Trigger_AddNaplesCommand(profilereq, naples.node_name, "/nic/bin/halctl show nwsec profile --id 11") #profcommandresp = api.Trigger(profilereq) #cmd = profcommandresp.commands[-1] #for command in profcommandresp.commands: # api.PrintCommandResults(command) #timeout = get_haltimeout("tcp-connection-setup", cmd) #tc.config_update_fail = 0 #if (timeout != timetoseconds(tc.iterators.timeout)): # tc.config_update_fail = 1 timeout = timetoseconds(tc.iterators.timeout) #Step 1: Start TCP Server server_port = api.AllocateTcpPort() api.Trigger_AddCommand(req, server.node_name, server.workload_name, "nc -l %s -i 600s" % (server_port), background=True) tc.cmd_cookies1.append("start server") #Step 2: Start TCPDUMP in background api.Trigger_AddCommand(req, server.node_name, server.workload_name, "tcpdump -i {} -nn > out.txt".format( server.interface), background=True) tc.cmd_cookies1.append("tcpdump") #Step 3: Start Hping with SYN set client_port = api.AllocateTcpPort() api.Trigger_AddCommand( req, client.node_name, client.workload_name, "hping3 -c 1 -s {} -p {} -S -M 1000 {}".format(client_port, server_port, server.ip_address)) tc.cmd_cookies1.append("Send SYN") #Step 4: Check if session is up in SYN_RCVD state api.Trigger_AddNaplesCommand( req, naples.node_name, "/nic/bin/halctl show session --dstport {} --dstip {} --srcip {} | grep SYN" .format(server_port, server.ip_address, client.ip_address)) tc.cmd_cookies1.append("Before timeout") #Sleep for connection setup timeout ######TBD -- uncomment this once agent update fix is in!!! #timeout = timetoseconds(tc.iterators.timeout) cmd_cookie = "sleep" api.Trigger_AddNaplesCommand(req, naples.node_name, "sleep %s" % timeout, timeout=300) tc.cmd_cookies1.append("sleep") #Step 5: Validate if session is gone. Note that we could have session in INIT state in this case as the server would retransmit. #Idea is to make sure we have removed the session that was in SYN state api.Trigger_AddNaplesCommand( req, naples.node_name, "/nic/bin/halctl show session --dstport {} --dstip {} --srcip {} | grep SYN" .format(server_port, server.ip_address, client.ip_address)) tc.cmd_cookies1.append("After timeout") #Step 6: Send an ACK now from the same port api.Trigger_AddCommand( req, client.node_name, client.workload_name, "hping3 -c 1 -s {} -p {} -A -M 1000 {}".format(client_port, server_port, server.ip_address)) tc.cmd_cookies1.append("Send ACK") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) req = api.Trigger_CreateExecuteCommandsRequest(serial=True) #Step 7: Check TCPDUMP on the other side to make sure we dropped the packet api.Trigger_AddCommand( req, server.node_name, server.workload_name, "grep \"{} >\" out.txt | grep \"\[\.\]\"".format( client_port, server_port, server.ip_address)) tc.cmd_cookies2.append("Check ACK Received") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.tcpdump_resp = api.Trigger_AggregateCommandsResponse( trig_resp, term_resp) return api.types.status.SUCCESS
def __runTraffic(intf): api.Logger.info("Run traffic: %s" % intf) client = None server = None clientCmd = None serverCmd = None clientReq = None serverReq = None for pairs in api.GetRemoteWorkloadPairs(): client = pairs[0] api.Logger.error("Comparing client interface %s with %s" % (client.interface, intf)) if client.interface == intf: server = pairs[1] break if server is None: api.Logger.error("No workload found for interface %s" % intf) return api.types.status.FAILURE cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address,\ client.workload_name, client.ip_address) api.Logger.info("Starting Iperf test from %s" % cmd_descr) port = api.AllocateTcpPort() serverCmd = iperf.ServerCmd(port) clientCmd = iperf.ClientCmd(server.ip_address, port) serverReq = api.Trigger_CreateExecuteCommandsRequest(serial=False) api.Trigger_AddCommand(serverReq, server.node_name, server.workload_name, serverCmd, background=True) clientReq = api.Trigger_CreateExecuteCommandsRequest(serial=False) api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name, clientCmd) # Server runs in the background server_resp = api.Trigger(serverReq) # Sleep for some time as bg may not have been started. time.sleep(5) client_resp = api.Trigger(clientReq) # Stop the backgrounded server term_resp = api.Trigger_TerminateAllCommands(server_resp) # We don't bother checking the iperf results, we just wanted traffic # so just check that the commands succeeded ret = api.types.status.SUCCESS for cmd in server_resp.commands: if cmd.exit_code != 0: ret = api.types.status.FAILURE for cmd in client_resp.commands: if cmd.exit_code != 0: ret = api.types.status.FAILURE for cmd in term_resp.commands: if cmd.exit_code != 0: ret = api.types.status.FAILURE return ret
def Trigger(tc): pairs = api.GetLocalWorkloadPairs() server = pairs[0][0] client = pairs[0][1] tc.cmd_cookies = [] naples = server if not server.IsNaples(): naples = client if not client.IsNaples(): return api.types.status.SUCCESS req = api.Trigger_CreateExecuteCommandsRequest(serial=True) tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) api.Logger.info("Starting MSRPC test from %s" % (tc.cmd_descr)) api.Trigger_AddCommand(req, server.node_name, server.workload_name, "tcpdump -nni %s > out.txt" % (server.interface), background=True) tc.cmd_cookies.append("tcpdump") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "tcpdump -nni %s > out.txt" % (client.interface), background=True) tc.cmd_cookies.append("tcpdump") api.Trigger_AddCommand(req, server.node_name, server.workload_name, "sudo nc -l %s" % (MSRPC_PORT), background=True) tc.cmd_cookies.append("netcat start-server") client_port = api.AllocateTcpPort() api.Trigger_AddCommand(req, client.node_name, client.workload_name, "sudo nc %s %s -p %s" % (server.ip_address, MSRPC_PORT, client_port), background=True) tc.cmd_cookies.append("netcat start-client") msrpcscript = dir_path + '/' + "msrpcscapy.py" resp = api.CopyToWorkload(server.node_name, server.workload_name, [msrpcscript], 'msrpcdir') if resp is None: return api.types.status.SUCCESS resp = api.CopyToWorkload(client.node_name, client.workload_name, [msrpcscript], 'msrpcdir') if resp is None: return api.types.status.SUCCESS api.Trigger_AddNaplesCommand( req, naples.node_name, "/nic/bin/halctl show session --dstport 135 --yaml") tc.cmd_cookies.append("show session yaml") sesssetup = api.Trigger(req) cmd = sesssetup.commands[-1] api.PrintCommandResults(cmd) tc.pre_ctrckinf = get_conntrackinfo(cmd) req = api.Trigger_CreateExecuteCommandsRequest(serial=True) msrpcpcap = dir_path + '/' + "msrpc_first_bind.pcap" pkts = rdpcap(msrpcpcap) clientidx = 0 serveridx = 0 client_ack = tc.pre_ctrckinf.i_tcpacknum server_ack = tc.pre_ctrckinf.r_tcpacknum filename = None for pkt in pkts: node = client.node_name workload = client.workload_name if pkt[IP].src == "172.31.9.1": filename = ("msrpcscapy" + "%s" + ".pcap") % (clientidx) msrpcscapy = dir_path + '/' + filename pkt[Ether].src = client.mac_address pkt[IP].src = client.ip_address pkt[Ether].dst = server.mac_address pkt[IP].dst = server.ip_address pkt[TCP].sport = client_port pkt[TCP].dport = 135 if clientidx == 0: client_start_seq = pkt[TCP].seq client_start_ack = pkt[TCP].ack pkt[TCP].seq = tc.pre_ctrckinf.i_tcpseqnum + (pkt[TCP].seq - client_start_seq) pkt[TCP].ack = client_ack server_ack = pkt[TCP].seq + len(pkt[TCP].payload) + 1 clientidx += 1 else: filename = ("msrpcscapy" + "%s" + ".pcap") % (serveridx) msrpcscapy = dir_path + '/' + filename pkt[Ether].src = server.mac_address pkt[IP].src = server.ip_address pkt[Ether].dst = client.mac_address pkt[IP].dst = client.ip_address node = server.node_name workload = server.workload_name pkt[TCP].dport = client_port pkt[TCP].sport = 135 if serveridx == 0: server_start_seq = pkt[TCP].seq server_start_ack = pkt[TCP].ack pkt[TCP].seq = tc.pre_ctrckinf.r_tcpseqnum + (pkt[TCP].seq - server_start_seq) pkt[TCP].ack = server_ack client_ack = pkt[TCP].seq + len(pkt[TCP].payload) + 1 serveridx += 1 del pkt[IP].chksum del pkt[TCP].chksum a = pkt.show(dump=True) print(a) wrpcap(msrpcscapy, pkt) resp = api.CopyToWorkload(node, workload, [msrpcscapy], 'msrpcdir') if resp is None: continue api.Trigger_AddCommand( req, node, workload, "sh -c 'cd msrpcdir && chmod +x msrpcscapy.py && ./msrpcscapy.py %s'" % (filename)) tc.cmd_cookies.append("running #%s on node %s workload %s" % (filename, node, workload)) os.remove(msrpcscapy) api.Trigger_AddNaplesCommand( req, naples.node_name, "/nic/bin/halctl show session --dstport 135 --yaml") tc.cmd_cookies.append("show session yaml") firstbind = api.Trigger(req) cmd = firstbind.commands[-1] api.PrintCommandResults(cmd) tc.post_ctrckinf = get_conntrackinfo(cmd) req = api.Trigger_CreateExecuteCommandsRequest(serial=True) msrpcpcap = dir_path + '/' + "msrpc_second_bind.pcap" pkts = rdpcap(msrpcpcap) client_ack = tc.post_ctrckinf.i_tcpacknum server_ack = tc.post_ctrckinf.r_tcpacknum clientidx = 0 serveridx = 0 filename = None for pkt in pkts: node = client.node_name workload = client.workload_name if pkt[IP].src == "172.31.9.1": filename = ("msrpcscapy" + "%s" + ".pcap") % (clientidx) msrpcscapy = dir_path + '/' + filename pkt[Ether].src = client.mac_address pkt[IP].src = client.ip_address pkt[Ether].dst = server.mac_address pkt[IP].dst = server.ip_address pkt[TCP].sport = client_port pkt[TCP].dport = 135 if clientidx == 0: client_start_seq = pkt[TCP].seq client_start_ack = pkt[TCP].ack pkt[TCP].seq = tc.post_ctrckinf.i_tcpseqnum + (pkt[TCP].seq - client_start_seq) pkt[TCP].ack = client_ack server_ack = pkt[TCP].seq + len(pkt[TCP].payload) + 1 clientidx += 1 else: filename = ("msrpcscapy" + "%s" + ".pcap") % (serveridx) msrpcscapy = dir_path + '/' + filename pkt[Ether].src = server.mac_address pkt[IP].src = server.ip_address pkt[Ether].dst = client.mac_address pkt[IP].dst = client.ip_address node = server.node_name workload = server.workload_name pkt[TCP].dport = client_port pkt[TCP].sport = 135 if serveridx == 0: server_start_seq = pkt[TCP].seq server_start_ack = pkt[TCP].ack pkt[TCP].seq = tc.post_ctrckinf.r_tcpseqnum + (pkt[TCP].seq - server_start_seq) pkt[TCP].ack = server_ack client_ack = pkt[TCP].seq + len(pkt[TCP].payload) + 1 serveridx += 1 del pkt[IP].chksum del pkt[TCP].chksum a = pkt.show(dump=True) print(a) wrpcap(msrpcscapy, pkt) resp = api.CopyToWorkload(node, workload, [msrpcscapy], 'msrpcdir') if resp is None: continue api.Trigger_AddCommand( req, node, workload, "sh -c 'cd msrpcdir && chmod +x msrpcscapy.py && ./msrpcscapy.py %s'" % (filename)) tc.cmd_cookies.append("running #%s on node %s workload %s" % (filename, node, workload)) os.remove(msrpcscapy) api.Trigger_AddCommand(req, server.node_name, server.workload_name, "sudo nc -l 49134", background=True) tc.cmd_cookies.append("msrpc start-server") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "sudo nc %s 49134 -p 59374" % (server.ip_address), background=True) tc.cmd_cookies.append("msrpc start-client") # Add Naples command validation #api.Trigger_AddNaplesCommand(req, naples.node_name, # "/nic/bin/halctl show security flow-gate | grep MSRPC") #tc.cmd_cookies.append("show security flow-gate") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session") tc.cmd_cookies.append("show session") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp2 = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) term_resp = api.Trigger_TerminateAllCommands(firstbind) tc.resp1 = api.Trigger_AggregateCommandsResponse(firstbind, term_resp) term_resp = api.Trigger_TerminateAllCommands(sesssetup) tc.resp = api.Trigger_AggregateCommandsResponse(sesssetup, term_resp) #GetTcpdumpData(client) #GetTcpdumpData(server) return api.types.status.SUCCESS
def Trigger(tc): if tc.skip: return api.types.status.SUCCESS tc.serverCmds = [] tc.clientCmds = [] tc.cmd_descr = [] fuzClients = {} fuzServers = {} clientReq = api.Trigger_CreateAllParallelCommandsRequest() serverReq = api.Trigger_CreateAllParallelCommandsRequest() clientArp = defaultdict(lambda: {}) sip_dip_cache = dict() server_key_cache = dict() def __sip_dip_key(sip, dip): return sip + ":" + dip def __server_key(server_ip, port): return server_ip + ":" + str(port) for idx, pairs in enumerate(tc.workload_pairs): client = pairs[0] server = pairs[1] port = None try: port = int(pairs[2]) except: port = api.AllocateTcpPort() server_key = __server_key(server.ip_address, port) sip_dip_key = __sip_dip_key(client.ip_address, server.ip_address) if sip_dip_key in sip_dip_cache: #Already added, ignore for this workload pair continue sip_dip_cache[sip_dip_key] = True cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) tc.cmd_descr.append(cmd_descr) num_sessions = int(getattr(tc.args, "num_sessions", 1)) api.Logger.info("Starting Fuz test from %s num-sessions %d" % (cmd_descr, num_sessions)) fuzClient = fuzClients.get(client.workload_name, None) if not fuzClient: fuzClient = FuzContext(client.workload_name, client.interface, client.node_name) fuzClients[client.workload_name] = fuzClient fuzClient.AddServer(server.ip_address, port) #Just start once instance of server for the combination if server_key not in server_key_cache: server_key_cache[server_key] = True #Combine baremetal workloads if api.IsBareMetalWorkloadType(server.node_name): fuzServer = fuzServers.get(server.node_name, None) if not fuzServer: fuzServer = FuzContext(server.workload_name, server.interface, server.node_name) fuzServers[server.node_name] = fuzServer else: fuzServer.AddInterface(server.interface) fuzServer.AddServer(server.ip_address, port) else: serverCmd = FUZ_EXEC[server.workload_name] + " -port " + str( port) api.Trigger_AddCommand(serverReq, server.node_name, server.workload_name, serverCmd, background=True, stdout_on_err=True, stderr_on_err=True) #For now add static arp if api.IsBareMetalWorkloadType(client.node_name): if not clientArp[client.node_name].get(server.ip_address, None): clientArp[client.node_name][ server.ip_address] = server.mac_address arp_cmd = "arp -s " + server.ip_address + " " + server.mac_address api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name, arp_cmd) else: if not clientArp[client.workload_name].get(server.ip_address, None): clientArp[client.workload_name][ server.ip_address] = server.mac_address arp_cmd = "arp -s " + server.ip_address + " " + server.mac_address api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name, arp_cmd) store = tc.GetBundleStore() store["server_req"] = serverReq store["client_ctxts"] = fuzClients store["server_ctxts"] = fuzServers store["arp_ctx"] = clientReq return api.types.status.SUCCESS
def Trigger(tc): tc.cmd_cookies = [] client, server, naples = tc.client, tc.server, tc.naples req = api.Trigger_CreateExecuteCommandsRequest(serial = True) cmd_cookie = "%s(%s) --> %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) api.Logger.info("Starting TCP aging test from %s" % (cmd_cookie)) cmd_cookie = "halctl clear session" api.Trigger_AddNaplesCommand(req, server.node_name, "/nic/bin/halctl clear session") tc.cmd_cookies.append(cmd_cookie) #Step 0: Update the timeout in the config object if not tc.skip_security_prof: update_timeout('tcp-timeout', tc.iterators.timeout) timeout = timetoseconds(tc.iterators.timeout) else: timeout = DEFAULT_TCP_TIMEOUT #profilereq = api.Trigger_CreateExecuteCommandsRequest(serial = True) #api.Trigger_AddNaplesCommand(profilereq, naples.node_name, "/nic/bin/halctl show nwsec profile --id 11") #profcommandresp = api.Trigger(profilereq) #cmd = profcommandresp.commands[-1] #for command in profcommandresp.commands: # api.PrintCommandResults(command) #timeout = get_haltimeout('tcp-timeout', cmd) #tc.config_update_fail = 0 #if (timeout != timetoseconds(tc.iterators.timeout)): # tc.config_update_fail = 1 server_port = api.AllocateTcpPort() client_port = api.AllocateTcpPort() cmd_cookie = "Send SYN from client" api.Trigger_AddCommand(req, client.node_name, client.workload_name, "hping3 -c 1 -s %s -p %s -M 0 -L 0 -S %s" % (client_port, server_port, server.ip_address)) tc.cmd_cookies.append(cmd_cookie) cmd_cookie = "Send SYN, ACK and SEQ from server" api.Trigger_AddCommand(req, server.node_name, server.workload_name, "hping3 -c 1 -s %s -p %s -M 0 -A -L 1 -S %s" % (server_port, client_port, client.ip_address)) tc.cmd_cookies.append(cmd_cookie) #Get Seq + Ack api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session ".format(server_port, server.ip_address)) tc.cmd_cookies.append("show session") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session --dstport {} --dstip {} --yaml".format(server_port, server.ip_address)) tc.cmd_cookies.append("show session detail") trig_resp1 = api.Trigger(req) cmd = trig_resp1.commands[-1] for command in trig_resp1.commands: api.PrintCommandResults(command) iseq_num, iack_num, iwindosz, iwinscale, rseq_num, rack_num, rwindo_sz, rwinscale = get_conntrackinfo(cmd) #Send ACK req2 = api.Trigger_CreateExecuteCommandsRequest(serial = True) api.Trigger_AddCommand(req2, client.node_name, client.workload_name, "hping3 -c 1 -s {} -p {} -M {} -L {} --ack {}".format(client_port, server_port, rack_num, rseq_num, server.ip_address)) tc.cmd_cookies.append("Send ACK") cmd_cookie = "Before moving show session" api.Trigger_AddNaplesCommand(req2, naples.node_name, "/nic/bin/halctl show session --dstport {} --dstip {} | grep ESTABLISHED".format(server_port, server.ip_address)) tc.cmd_cookies.append(cmd_cookie) # vm_utils.do_vmotion(tc, tc.wl, tc.new_node) vm_utils.do_vmotion(tc, True)
def Trigger(tc): if tc.args.type == 'local_only': pairs = api.GetLocalWorkloadPairs() else: pairs = api.GetRemoteWorkloadPairs() tc.cmd_cookies = [] server, client = pairs[0] naples = server if not server.IsNaples(): naples = client if not client.IsNaples(): return api.types.status.SUCCESS else: client, server = pairs[0] req = api.Trigger_CreateExecuteCommandsRequest(serial=True) cmd_cookie = "%s(%s) --> %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) api.Logger.info("Starting Iperf test from %s" % (cmd_cookie)) cmd_cookie = "halctl clear session" api.Trigger_AddNaplesCommand(req, server.node_name, "/nic/bin/halctl clear session") tc.cmd_cookies.append(cmd_cookie) server_port = api.AllocateTcpPort() basecmd = 'iperf -p %d ' % server_port proto = 6 timeout_str = 'tcp-drop' if tc.iterators.proto == 'udp': server_port = api.AllocateUdpPort() basecmd = 'iperf -u -p %d ' % server_port proto = 17 timeout_str = 'udp-drop' #Step 0: Update the timeout in the config object update_timeout(timeout_str, tc.iterators.timeout) update_sgpolicy(client.ip_address, server.ip_address, tc.iterators.proto, server_port) profilereq = api.Trigger_CreateExecuteCommandsRequest(serial=True) api.Trigger_AddNaplesCommand(profilereq, naples.node_name, "/nic/bin/halctl show nwsec profile --id 16") profcommandresp = api.Trigger(profilereq) cmd = profcommandresp.commands[-1] for command in profcommandresp.commands: api.PrintCommandResults(command) timeout = get_haltimeout(timeout_str, cmd) api.Logger.info("Hal timeout %s, tc timeout %s" % (timeout, timetoseconds(tc.iterators.timeout))) if (timeout != timetoseconds(tc.iterators.timeout)): api.Logger.errror("Found mismatch in HAL and testcase timeout") tc.config_update_fail = 1 return api.types.status.FAILURE timeout += GRACE_TIME cmd_cookie = "iperf -s" api.Trigger_AddCommand(req, server.node_name, server.workload_name, "%s -s -t 300 " % basecmd, background=True) tc.cmd_cookies.append(cmd_cookie) cmd_cookie = "iperf -c " api.Trigger_AddCommand(req, client.node_name, client.workload_name, "%s -c %s " % (basecmd, server.ip_address)) tc.cmd_cookies.append(cmd_cookie) cmd_cookie = "Before aging show session" api.Trigger_AddNaplesCommand( req, naples.node_name, "/nic/bin/halctl show session --ipproto %s | grep %s" % (proto, naples.ip_address)) tc.cmd_cookies.append(cmd_cookie) #Get it from the config cmd_cookie = "sleep" api.Trigger_AddNaplesCommand(req, naples.node_name, "sleep %s" % timeout, timeout=300) tc.cmd_cookies.append(cmd_cookie) cmd_cookie = "After aging show session" api.Trigger_AddNaplesCommand( req, naples.node_name, "/nic/bin/halctl show session --ipproto %s | grep %s" % (proto, naples.ip_address)) tc.cmd_cookies.append(cmd_cookie) trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS