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 __node_api_handler(self, url, json_data=None, oper=CfgOper.ADD): if oper == CfgOper.DELETE: oper = "DELETE" elif oper == CfgOper.ADD: oper = "POST" elif oper == CfgOper.UPDATE: oper = "PUT" elif oper == CfgOper.GET: oper = "GET" else: print(oper) assert (0) if GlobalOptions.debug: api.Logger.info("Url : %s" % url) cmd = None if json_data and len(json.dumps(json_data)) > 100000: filename = "/tmp/temp_config.json" with open(filename, 'w') as outfile: json.dump(json_data, outfile) req = api.Trigger_CreateAllParallelCommandsRequest() cmd = ["rm", "-rf", "temp_config.json"] cmd = " ".join(cmd) api.Trigger_AddHostCommand(req, self.host_name, cmd, timeout=3600) api.Trigger(req) resp = api.CopyToHost(self.host_name, [filename], "") if not api.IsApiResponseOk(resp): assert (0) cmd = [ "curl", "-X", oper, "-d", "@temp_config.json", "-k", "-H", "\"Content-Type:application/json\"", url ] else: cmd = [ "curl", "-X", oper, "-k", "-d", "\'" + json.dumps(json_data) + "\'" if json_data else " ", "-H", "\"Content-Type:application/json\"", url ] cmd = " ".join(cmd) req = api.Trigger_CreateAllParallelCommandsRequest() api.Trigger_AddHostCommand(req, self.host_name, cmd, timeout=3600) resp = api.Trigger(req) if GlobalOptions.debug: print(" ".join(cmd)) return resp.commands[0].stdout
def __add_iptables_to_workloads(workloads=[]): if not api.IsSimulation(): req = api.Trigger_CreateAllParallelCommandsRequest() else: req = api.Trigger_CreateExecuteCommandsRequest(serial = False) workloads = workloads if workloads else api.GetWorkloads() for wl in workloads: api.Trigger_AddCommand(req, wl.node_name, wl.workload_name, "iptables -A INPUT -p tcp -i %s --src %s -j DROP" % (wl.interface, wl.ip_prefix)) api.Logger.info(f"iptables -A INPUT -p tcp -i {wl.interface} --src {wl.ip_prefix} -j DROP") api.Trigger_AddCommand(req, wl.node_name, wl.workload_name, "iptables -A INPUT -p tcp -i %s --dst %s -j DROP" % (wl.interface, wl.ip_prefix)) api.Logger.info(f"iptables -A INPUT -p tcp -i {wl.interface} --dst {wl.ip_prefix} -j DROP") api.Trigger_AddCommand(req, wl.node_name, wl.workload_name, "iptables -A INPUT -p udp -i %s --src %s -j DROP" % (wl.interface, wl.ip_prefix)) api.Logger.info(f"iptables -A INPUT -p udp -i {wl.interface} --src {wl.ip_prefix} -j DROP") api.Trigger_AddCommand(req, wl.node_name, wl.workload_name, "iptables -A INPUT -p udp -i %s --dst %s -j DROP" % (wl.interface, wl.ip_prefix)) api.Logger.info(f"iptables -A INPUT -p udp -i {wl.interface} --dst {wl.ip_prefix} -j DROP") resp = api.Trigger(req) if resp is None: return api.types.status.FAILURE return api.types.status.SUCCESS
def Trigger(tc): tc.context = None ctxt = PingTestContext() ctxt.req = api.Trigger_CreateAllParallelCommandsRequest() ctxt.cmd_cookies = [] for tunnel in tc.tunnels: w1 = tunnel.ltep w2 = tunnel.rtep for sec_ipaddr in w1.sec_ip_addresses: if ipaddress.IPv4Address(sec_ipaddr).is_reserved: api.Logger.info("Workload1: ClassE IP = %s" % sec_ipaddr) for sec_ipaddr in w2.sec_ip_addresses: if ipaddress.IPv4Address(sec_ipaddr).is_reserved: api.Logger.info("Workload2: ClassE IP = %s" % sec_ipaddr) cmd_cookie = "%s(%s) --> %s(%s)" %\ (w1.workload_name, w1.ip_address, w2.workload_name, w2.ip_address) api.Trigger_AddCommand( ctxt.req, w1.node_name, w1.workload_name, "ping -i 0.2 -c 20 -s %d %s" % (64, w2.ip_address)) api.Logger.info("Ping test from %s" % (cmd_cookie)) ctxt.cmd_cookies.append(cmd_cookie) ctxt.resp = api.Trigger(ctxt.req) tc.context = ctxt return api.types.status.SUCCESS
def ARPingWorkloads(workload_pairs, update_neighbor=False, send_dad=False, count=3): cmd_cookies = [] if not api.IsSimulation(): req = api.Trigger_CreateAllParallelCommandsRequest() else: req = api.Trigger_CreateExecuteCommandsRequest(serial=False) for pair in workload_pairs: w1 = pair[0] w2 = pair[1] arp_base_cmd = __get_arp_base_cmd(w1, update_neighbor, send_dad, count) addr = __get_workload_address(w1, "ipv4") if update_neighbor is True: dest_addr = " %s" % (addr) else: addr = __get_workload_address(w2, "ipv4") dest_addr = " %s" % (addr) arp_cmd = arp_base_cmd + dest_addr api.Logger.verbose(" ARP cmd %s " % (arp_cmd)) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, arp_cmd) cmd_cookies.append(arp_cmd) resp = api.Trigger(req) return cmd_cookies, resp
def Trigger(tc): if tc.skip: return api.types.status.SUCCESS req = None if not api.IsSimulation(): req = api.Trigger_CreateAllParallelCommandsRequest() else: req = api.Trigger_CreateExecuteCommandsRequest(serial=False) tc.cmd_cookies = [] if tc.args.type == 'remote_only': tc.control_ep_pairs = config_api.GetControlEPPairs( pair_type=config_api.WORKLOAD_PAIR_TYPE_REMOTE_ONLY) if len(tc.control_ep_pairs) == 0: api.Logger.error("Skipping Testcase due to no VCN Endpoint pairs.") return api.types.status.FAILURE for pair in tc.control_ep_pairs: api.Logger.verbose("Ping between %s and %s" % (pair[0].ip_addresses[0], pair[1].ip_addresses[0])) if pair[0].node_name == tc.naples_node0: cmd_cookie = "ip netns exec %s ping %s -c 10 -s %d" % ( "vcn", pair[1].ip_addresses[0], tc.iterators.pktsize) else: cmd_cookie = "ip netns exec %s ping %s -c 10 -s %d" % ( "vcn", pair[0].ip_addresses[0], tc.iterators.pktsize) api.Trigger_AddNaplesCommand(req, tc.naples_node0, cmd_cookie) api.Logger.info("Ping test %s" % (cmd_cookie)) tc.cmd_cookies.append(cmd_cookie) tc.resp = api.Trigger(req) return api.types.status.SUCCESS
def Trigger(tc): if tc.skip: return api.types.status.SUCCESS req = None interval = "0.2" if not api.IsSimulation(): req = api.Trigger_CreateAllParallelCommandsRequest() else: req = api.Trigger_CreateExecuteCommandsRequest(serial = False) interval = "3" tc.cmd_cookies = [] for pair in tc.workload_pairs: w1 = pair[0] w2 = pair[1] if tc.iterators.ipaf == 'ipv6': cmd_cookie = "%s(%s) --> %s(%s)" %\ (w1.workload_name, w1.ipv6_address, w2.workload_name, w2.ipv6_address) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, "ping6 -i %s -c 20 -s %d %s" % (interval, tc.iterators.pktsize, w2.ipv6_address)) else: cmd_cookie = "%s(%s) --> %s(%s)" %\ (w1.workload_name, w1.ip_address, w2.workload_name, w2.ip_address) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, "ping -i %s -c 20 -s %d %s" % (interval, tc.iterators.pktsize, w2.ip_address)) api.Logger.info("Ping test from %s" % (cmd_cookie)) tc.cmd_cookies.append(cmd_cookie) tc.resp = api.Trigger(req) return api.types.status.SUCCESS
def trigger_ping_to_bond(tc): req = api.Trigger_CreateAllParallelCommandsRequest() for node, wl in utils.GetBondWorkloadPair(): node_name, bond_ip = node.Name(), node.GetBondIp() # for baremetal, don't ping to workloads in the nodes where the uplink is brought down. if tc.is_bm_type and tc.uplink_fail_stage: if wl.node_name in tc.nodes: #api.Logger.info("Skipping ping b/w %s <--> %s"%(bond_ip, wl.ip_address)) continue # Ping Bond ===> Workload cmd_cookie = "%s(%s) --> %s(%s)" % (node_name, bond_ip, wl.workload_name, wl.ip_address) tc.cmd_cookies.append(cmd_cookie) api.Logger.info("%s" % (cmd_cookie)) cmd = "ping -i %s -c 20 -s %d %s" % (tc.interval, tc.iterators.pktsize, wl.ip_address) api.Trigger_AddNaplesCommand(req, node_name, cmd) # Ping Workload ===> Bond cmd_cookie = "%s(%s) --> %s(%s)" % (wl.workload_name, wl.ip_address, node_name, bond_ip) tc.cmd_cookies.append(cmd_cookie) api.Logger.info("%s" % (cmd_cookie)) cmd = "ping -i %s -c 20 -s %d %s" % (tc.interval, tc.iterators.pktsize, bond_ip) api.Trigger_AddCommand(req, wl.node_name, wl.workload_name, cmd) tc.resp = api.Trigger(req) return api.types.status.SUCCESS
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 ChangeHostLifsAdminStatus(tc, shutdown=False): result = api.types.status.SUCCESS req = api.Trigger_CreateAllParallelCommandsRequest() tc.cmd_cookies = [] for node in tc.nodes: for intf_wl in tc.host_lifs[node]: intf, wl = next(iter(intf_wl.items())) # Change admin status cmd = "ifconfig %s %s" % (intf, ("down" if shutdown else "up")) if wl: cmd_cookie = "Node: %s, WL: %s, intf: %s, shutdown: %s" % ( node, wl, intf, shutdown) tc.cmd_cookies.append(cmd_cookie) #api.Logger.info("%s"%(cmd_cookie)) api.Trigger_AddCommand(req, node, wl, cmd) else: cmd_cookie = "Node: %s, intf: %s, shutdown: %s" % (node, intf, shutdown) tc.cmd_cookies.append(cmd_cookie) #api.Logger.info("%s"%(cmd_cookie)) api.Trigger_AddHostCommand(req, node, cmd) tc.resp = api.Trigger(req) cookie_idx = 0 for cmd in tc.resp.commands: if cmd.exit_code != 0: result = api.types.status.FAILURE api.Logger.info("Failed to change Admin for %s" % (tc.cmd_cookies[cookie_idx])) api.PrintCommandResults(cmd) cookie_idx += 1 return result
def TriggerUnderlayConnectivityTest(ping_count=20, connectivity = 'bgp_peer', interval = 0.01): req = None req = api.Trigger_CreateAllParallelCommandsRequest() cmd_cookies = [] naplesHosts = api.GetNaplesHostnames() if connectivity == 'bgp_peer': for node in naplesHosts: for bgppeer in bgp_peer.client.Objects(node): cmd_cookie = "%s --> %s" %\ (str(bgppeer.LocalAddr), str(bgppeer.PeerAddr)) api.Trigger_AddNaplesCommand(req, node, \ f"ping -i {interval} -c {ping_count} -s 64 {str(bgppeer.PeerAddr)}") api.Logger.verbose(f"Ping test from {cmd_cookie}") cmd_cookies.append(cmd_cookie) else: for node1 in naplesHosts: for node2 in naplesHosts: if node1 == node2: continue objs = device.client.Objects(node1) device1 = next(iter(objs)) objs = device.client.Objects(node2) device2 = next(iter(objs)) cmd_cookie = "%s --> %s" %\ (device1.IP, device2.IP) api.Trigger_AddNaplesCommand(req, node1, \ f"ping -i {interval} -c {ping_count} -s 64 {device2.IP}") api.Logger.verbose(f"Loopback ping test from {cmd_cookie}") cmd_cookies.append(cmd_cookie) resp = api.Trigger(req) return resp, cmd_cookies
def ConnectivityVRIPTest(proto='icmp', af='ipv4', pktsize=64, scope=config_api.WORKLOAD_PAIR_SCOPE_INTRA_SUBNET, args=None): cmd_cookies = [] cmd = None # default probe count is 3 probe_count = 3 sent_probes = dict() if not api.IsSimulation(): req = api.Trigger_CreateAllParallelCommandsRequest() else: req = api.Trigger_CreateExecuteCommandsRequest(serial = False) naplesHosts = api.GetNaplesHostnames() vnics = [] subnets = [] for node in naplesHosts: vnics.extend(vnic.client.Objects(node)) subnets.extend(subnet.client.Objects(node)) if scope == config_api.WORKLOAD_PAIR_SCOPE_INTRA_SUBNET: for vnic1 in vnics: if vnic1.SUBNET.VPC.Type == vpc_pb2.VPC_TYPE_CONTROL: continue wl = config_api.FindWorkloadByVnic(vnic1) assert(wl) dest_ip = vnic1.SUBNET.GetIPv4VRIP() cmd = traffic_utils.PingCmdBuilder(wl, dest_ip, proto, af, pktsize, args, probe_count) api.Logger.info(f" VR_IP on {wl.node_name}: {cmd}") api.Trigger_AddCommand(req, wl.node_name, wl.workload_name, cmd) cmd_cookies.append(cmd) cur_cnt = sent_probes.get(wl.node_name, 0) sent_probes.update({wl.node_name: cur_cnt + probe_count}) else: for vnic1 in vnics: if vnic1.SUBNET.VPC.Type == vpc_pb2.VPC_TYPE_CONTROL: continue wl = config_api.FindWorkloadByVnic(vnic1) assert(wl) for subnet1 in subnets: if subnet1.VPC.Type == vpc_pb2.VPC_TYPE_CONTROL: continue if subnet1.Node != vnic1.Node: continue if scope == config_api.WORKLOAD_PAIR_SCOPE_INTER_SUBNET and (vnic1.SUBNET.GID() == subnet1.GID()): continue dest_ip = subnet1.GetIPv4VRIP() cmd = traffic_utils.PingCmdBuilder(wl, dest_ip, proto, af, pktsize, args, probe_count) api.Logger.info(f" VRIP on {wl.node_name}: {cmd} ") api.Trigger_AddCommand(req, wl.node_name, wl.workload_name, cmd) cmd_cookies.append(cmd) cur_cnt = sent_probes.get(wl.node_name, 0) sent_probes.update({wl.node_name: cur_cnt + probe_count}) resp = api.Trigger(req) return cmd_cookies, resp, sent_probes
def ArPing(tc): 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() if len(tc.workload_pairs) == 0: api.Logger.info("Skipping Testcase due to no workload pairs.") tc.skip = True req = None interval = "0.2" if not api.IsSimulation(): req = api.Trigger_CreateAllParallelCommandsRequest() else: req = api.Trigger_CreateExecuteCommandsRequest(serial=False) interval = "3" tc.cmd_cookies = [] for pair in tc.workload_pairs: w1 = pair[0] w2 = pair[1] cmd_cookie = "%s %s %s %s" % (w1.node_name, w1.workload_name, w1.interface, w1.ip_address) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, "arping -c 5 -U %s -I eth1" % (w1.ip_address)) api.Logger.info("ArPing from %s" % (cmd_cookie)) tc.cmd_cookies.append(cmd_cookie) cmd_cookie = "%s %s %s %s" % (w2.node_name, w2.workload_name, w2.interface, w2.ip_address) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, "arping -c 5 -U %s -I eth1" % (w2.ip_address)) api.Logger.info("ArPing from %s" % (cmd_cookie)) tc.cmd_cookies.append(cmd_cookie) tc.resp = api.Trigger(req) if tc.resp is None: return api.types.status.FAILURE result = api.types.status.SUCCESS cookie_idx = 0 for cmd in tc.resp.commands: api.Logger.info("ArPing Results for %s" % (tc.cmd_cookies[cookie_idx])) api.PrintCommandResults(cmd) if cmd.exit_code != 0: result = api.types.status.FAILURE cookie_idx += 1 return result
def Trigger(tc): if tc.skip: return api.types.status.SUCCESS tc.serverCmds = [] tc.clientCmds = [] tc.cmd_descr = [] iperfClients = [] serverReq = api.Trigger_CreateAllParallelCommandsRequest() dip_port_cache = dict() def __dip_port_key(dip, port): return dip + ":" + str(port) for idx, pairs in enumerate(tc.workload_pairs): client = pairs[0] server = pairs[1] port = int(pairs[2]) server_key = __dip_port_key(server.ip_address, port) 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)) serverCmd = None #if tc.iterators.proto == 'udp': #port = api.AllocateTcpPort() if server_key not in dip_port_cache: dip_port_cache[server_key] = True serverCmd = iperf.ServerCmd(port) tc.serverCmds.append(serverCmd) api.Trigger_AddCommand(serverReq, server.node_name, server.workload_name, serverCmd, background=True, stdout_on_err=True, stderr_on_err=True) iperfClients.append( IperfClient(server.ip_address, port, client.node_name, client.workload_name)) store = tc.GetBundleStore() store["server_req"] = serverReq store["client_ctxts"] = iperfClients return api.types.status.SUCCESS
def delete_file(tc): result = True req = api.Trigger_CreateAllParallelCommandsRequest() for node in tc.nodes: api.Trigger_AddNaplesCommand(req, node, tc.delete_cmd) resp = api.Trigger(req) for cmd in resp.commands: if cmd.exit_code != 0: api.PrintCommandResults(cmd) result = False return result
def trigger_techsupport_requests(tc): result = ts_utils.DeleteTSDir(tc.nodes) if result != True: api.Logger.error("Failed to clean techsupport in naples before request") return result req = api.Trigger_CreateAllParallelCommandsRequest() for node in tc.nodes: api.Logger.info(f"Collecting techsupport from {node}") api.Trigger_AddNaplesCommand(req, node, TS_SCRIPT, timeout=300) tc.resp = api.Trigger(req) return True
def pingWorkloads(workload_pairs, af="ipv4", packet_size=64, count=3, interval=0.2, do_pmtu_disc=False, sec_ip_test_type='none'): cmd_cookies = [] if not api.IsSimulation(): req = api.Trigger_CreateAllParallelCommandsRequest() else: req = api.Trigger_CreateExecuteCommandsRequest(serial=False) for pair in workload_pairs: w1 = pair[0] w2 = pair[1] ping_base_cmd = __get_ping_base_cmd(w1, af, packet_size, count, interval, do_pmtu_disc) if sec_ip_test_type == 'all': src_list = [__get_workload_address(w1, af)] + w1.sec_ip_addresses dst_list = [__get_workload_address(w2, af)] + w2.sec_ip_addresses for src_ip in src_list: for dst_ip in dst_list: ping_cmd = __add_source_ip_to_ping_cmd( ping_base_cmd, src_ip) ping_cmd = __ping_addr_substitution(ping_cmd, dst_ip) api.Logger.verbose(" Ping cmd %s " % (ping_cmd)) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, ping_cmd) cmd_cookies.append(ping_cmd) else: addr = __get_workload_address(w2, af) ping_cmd = __ping_addr_substitution(ping_base_cmd, addr) api.Logger.verbose(" Ping cmd %s " % (ping_cmd)) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, ping_cmd) cmd_cookies.append(ping_cmd) if sec_ip_test_type == 'random' and w1.sec_ip_addresses and w2.sec_ip_addresses: ping_cmd = __add_source_ip_to_ping_cmd( ping_base_cmd, random.choice(w1.sec_ip_addresses)) ping_cmd = __ping_addr_substitution( ping_cmd, random.choice(w2.sec_ip_addresses)) api.Logger.verbose(" Ping cmd %s " % (ping_cmd)) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, ping_cmd) cmd_cookies.append(ping_cmd) resp = api.Trigger(req) return cmd_cookies, resp
def TriggerHping(workload_pairs, proto, af, pktsize, count=3, tcp_flags=None, rflow=False): resp = None cmd_cookies = [] options = '' req = api.Trigger_CreateAllParallelCommandsRequest() if proto in ['tcp', 'udp']: src_port = 1234 dest_port = 8000 if proto == 'tcp' and tcp_flags is not None: if "fin" in tcp_flags: options += ' -F' else: src_port = 0 dest_port = 0 for pair in workload_pairs: src_wl = pair[0] dst_wl = pair[1] dest_ip = dst_wl.ip_address cmd = GetHping3Cmd(proto, src_wl, dest_ip, dest_port, src_port, count, options) background = False if count > 100: background = True api.Trigger_AddCommand(req, src_wl.node_name, src_wl.workload_name, cmd, background=background) cmd_cookies.append(cmd) if rflow: # If rflow is True, then trigger hping in the reverse direction as well cmd = GetHping3Cmd(proto, dst_wl, src_wl.ip_address, src_port, dest_port, count, options) api.Trigger_AddCommand(req, dst_wl.node_name, dst_wl.workload_name, cmd) cmd_cookies.append(cmd) resp = api.Trigger(req) return cmd_cookies, resp
def Trigger(tc): if tc.skip: return api.types.status.SUCCESS store = tc.GetBundleStore() cps = int(getattr(tc.args, "cps", 500)) attempts = int(getattr(tc.args, "attempts", 3)) sessions = int(getattr(tc.args, "num_sessions", 1)) session_time = str(getattr(tc.args, "session_time", "10")) + "s" static_arp = int(getattr(tc.args, "static_arp", False)) if static_arp: #install arp entries before running arpReqs = store["arp_ctx"] api.Trigger(arpReqs) #Spread CPS evenly clientReq = api.Trigger_CreateAllParallelCommandsRequest() cps_per_node = int(cps / len(store["client_ctxts"])) for index, (_, client) in enumerate(store["client_ctxts"].items()): jsonInput = {"connections": []} for serverIPPort in client.GetServers(): jsonInput["connections"].append({ "ServerIPPort": serverIPPort, "proto": "tcp" }) outfile = api.GetTestDataDirectory( ) + "/" + client.workload_name + "_fuz.json" with open(outfile, 'w') as fp: json.dump(jsonInput, fp) api.CopyToWorkload(client.node_name, client.workload_name, [outfile], "") clientCmd = fuz_init.FUZ_EXEC[ client.workload_name] + " -attempts " + str( attempts) + " -duration " + session_time + " -conns " + str( sessions) + " -cps " + str( cps_per_node ) + " -talk --jsonOut --jsonInput " + os.path.basename( outfile) api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name, clientCmd, background=True) #Initiate connections store["client_req"] = api.Trigger(clientReq) return api.types.status.SUCCESS
def HitlessAddUpgTestAppToJson(node, naples_json_dir): file = 'upgrade_hitless.json' tmp_dir = f"/tmp/{node}/" # remove already existing one if there are any if os.path.exists(f"{tmp_dir}/{file}"): os.remove(f"{tmp_dir}/{file}") # copy hitless.json from naples api.CopyFromNaples(node, [f"{naples_json_dir}/{file}"], f"{tmp_dir}", via_oob=True) if api.GlobalOptions.dryrun: return api.types.status.SUCCESS if not os.path.exists(f"{tmp_dir}/{file}"): api.Logger.error(f"Upgrade json for {node} not found @ {file}") return api.types.status.FAILURE # delete from the host req = api.Trigger_CreateAllParallelCommandsRequest() api.Trigger_AddHostCommand(req, node, f"rm -f {file}") resp = api.Trigger(req) file = f"{tmp_dir}/{file}" cmd = "cp %s %s.org && " % (file, file) # add upgtestapp to the discovery and serial list cmd = cmd + '''awk ' BEGIN { found=0;line=0 } /"upg_svc"/ { found=1;line=0 } /.*/ { if (found == 1 && line == 1) print " \\\"upgtestapp\\\"," } /.*/ { print $0;line=line+1 } ' %s.org > %s && ''' % (file, file) cmd = cmd + '''sed -i 's/"svc_sequence" : "\([a-z:].*\)"/"svc_sequence" : "\\1:upgtestapp"/' "%s"''' % ( file) rv = subprocess.call(cmd, shell=True) if rv != 0: api.Logger.error(f"Upgrade hitless json modify {cmd} failed") return api.types.status.FAILURE # copy the modified json back resp = api.CopyToNaples(node, [file], "", naples_dir=f"{naples_json_dir}", via_oob=True) if resp.api_response.api_status != types_pb2.API_STATUS_OK: return api.types.status.FAILURE return api.types.status.SUCCESS
def addPktFilterRuleOnEp(wl_pairs, proto, enable=True): req = api.Trigger_CreateAllParallelCommandsRequest() for wl_pair in wl_pairs: wl = wl_pair[1] api.Trigger_AddCommand(req, wl.node_name, wl.workload_name, f"iptables -{'A' if enable else 'D'} INPUT -p {proto} -j DROP -w") resp = api.Trigger(req) result = 0 for cmd in resp.commands: if cmd.exit_code != 0: api.PrintCommandResults(cmd) result |= cmd.exit_code return False if result else True
def Trigger(tc): store = tc.GetBundleStore() clientReq = api.Trigger_CreateAllParallelCommandsRequest() num_sessions = int(getattr(tc.args, "num_sessions", 1)) for client in store["client_ctxts"]: clientCmd = iperf.ClientCmd(client.server_ip, client.server_port, proto=tc.iterators.proto, jsonOut=True, num_of_streams = num_sessions, connect_timeout = 15000) api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name, clientCmd, timeout = 0, stdout_on_err = True, stderr_on_err = True) tc.iperf_client_resp = api.Trigger(clientReq) return api.types.status.SUCCESS
def Trigger(tc): if tc.skip: return api.types.status.SUCCESS store = tc.GetBundleStore() serverReq = store["server_req"] if serverReq: store["server_resp"] = api.Trigger(serverReq) #If we want to start server combined server_pcap_info = [] if store.get("server_ctxts", None): serverReq = api.Trigger_CreateAllParallelCommandsRequest() for _, server in store["server_ctxts"].items(): jsonInput = {"connections": []} for serverIPPort in server.GetServers(): jsonInput["connections"].append({ "ServerIPPort": serverIPPort, "proto": "tcp" }) outfile = api.GetTestDataDirectory( ) + "/" + server.node_name + "_fuz.json" with open(outfile, 'w') as fp: json.dump(jsonInput, fp) api.CopyToHost(server.node_name, [outfile], "") serverCmd = fuz_init.FUZ_EXEC[ server.workload_name] + " --jsonInput " + os.path.basename( outfile) + " --jsonOut" api.Trigger_AddHostCommand(serverReq, server.node_name, serverCmd, background=True) for intf in server.interfaces: server_pcap_info.append( (server.node_name, intf, intf + ".pcap")) #Start server store["combined_server_resp"] = api.Trigger(serverReq) #Start Pcap just before starting client store["server_pcap_info"] = server_pcap_info #Sleep for some time as bg may not have been started. time.sleep(30) return api.types.status.SUCCESS
def verify_copy(tc): result = True req = api.Trigger_CreateAllParallelCommandsRequest() for node in tc.nodes: api.Trigger_AddNaplesCommand(req, node, tc.verify_cmd) resp = api.Trigger(req) for cmd in resp.commands: api.PrintCommandResults(cmd) if cmd.exit_code != 0: api.Logger.error("Failed to verify md5sum") result = False elif tc.src_file_md5sum != __parse_md5sum(cmd): if GlobalOptions.dryrun: continue api.Logger.error("md5sum mismatch") result = False return result
def __generate_ping_command_cookies(tc): req = None interval = "0.2" if not api.IsSimulation(): req = api.Trigger_CreateAllParallelCommandsRequest() else: req = api.Trigger_CreateExecuteCommandsRequest(serial = False) interval = "3" tc.cmd_cookies = [] for pair in tc.workload_pairs: w1 = pair[0] w2 = pair[1] cmd_cookie = "%s(%s) --> %s(%s)" % (w1.workload_name, w1.ip_address, w2.workload_name, w2.ip_address) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name,"ping -i %s -c 20 -s %d %s" % (interval, 128, w2.ip_address)) api.Logger.info("Ping test from %s" % (cmd_cookie)) tc.cmd_cookies.append(cmd_cookie) return api.Trigger(req)
def SetWorkloadIntfOperState(wl, state): if not api.IsSimulation(): req = api.Trigger_CreateAllParallelCommandsRequest() else: req = api.Trigger_CreateExecuteCommandsRequest(serial=False) api.Trigger_AddCommand(req, wl.node_name, wl.workload_name, "ifconfig %s %s" % (wl.interface, state)) api.Logger.debug("ifconfig %s %s from %s %s" % (wl.interface, state, wl.node_name, wl.workload_name)) resp = api.Trigger(req) if resp is None: return False if state is 'up': add_routes.AddRoutes(config_api.FindVnicObjectByWorkload(wl)) return resp.commands[0].exit_code == 0
def __mk_testcase_directory(self, newdir): Logger.debug("Creating Testcase directory: %s" % newdir) command = "mkdir -p %s && chmod 777 %s" % (newdir, newdir) req = api.Trigger_CreateAllParallelCommandsRequest() for nodename in api.GetWorkloadNodeHostnames(): api.Trigger_AddHostCommand(req, nodename, command) for wl in api.GetWorkloads(): if api.IsWorkloadRunning(wl.workload_name): api.Trigger_AddCommand(req, wl.node_name, wl.workload_name, command, timeout=60) resp = api.Trigger(req) if not api.Trigger_IsSuccess(resp): Logger.error("Failed to create destination directory %s" % newdir) return types.status.FAILURE return types.status.SUCCESS
def __add_secondary_ip_to_workloads(workloads=[]): if not api.IsSimulation(): req = api.Trigger_CreateAllParallelCommandsRequest() else: req = api.Trigger_CreateExecuteCommandsRequest(serial = False) workloads = workloads if workloads else api.GetWorkloads() for wl in workloads: for sec_ip_addr in wl.sec_ip_addresses: api.Trigger_AddCommand(req, wl.node_name, wl.workload_name, "ifconfig %s add %s" % (wl.interface, sec_ip_addr)) api.Logger.debug("ifconfig add from %s %s %s %s" % (wl.node_name, wl.workload_name, wl.interface, sec_ip_addr)) resp = api.Trigger(req) if resp is None: return api.types.status.FAILURE return api.types.status.SUCCESS
def Trigger(tc): if tc.skip: return api.types.status.SUCCESS req = None interval = "0.2" if not api.IsSimulation(): req = api.Trigger_CreateAllParallelCommandsRequest() else: req = api.Trigger_CreateExecuteCommandsRequest(serial=False) interval = "3" tc.cmd_cookies = [] if tc.os == compat.OS_TYPE_LINUX: for node in tc.nodes: cmd_cookie = "Driver-FW-Version" cmd = "/naples/nodeinit.sh --version" api.Trigger_AddHostCommand(req, node, cmd) tc.cmd_cookies.append(cmd_cookie) for pair in tc.workload_pairs: w1 = pair[0] w2 = pair[1] if tc.args.ipaf == 'ipv6': cmd_cookie = "%s(%s) --> %s(%s)" %\ (w1.workload_name, w1.ipv6_address, w2.workload_name, w2.ipv6_address) api.Trigger_AddCommand( req, w1.node_name, w1.workload_name, "ping6 -i %s -c 20 -s %d %s" % (interval, tc.args.pktsize, w2.ipv6_address)) else: cmd_cookie = "%s(%s) --> %s(%s)" %\ (w1.workload_name, w1.ip_address, w2.workload_name, w2.ip_address) api.Trigger_AddCommand( req, w1.node_name, w1.workload_name, "ping -i %s -c 20 -s %d %s" % (interval, tc.args.pktsize, w2.ip_address)) api.Logger.info("Ping test from %s" % (cmd_cookie)) tc.cmd_cookies.append(cmd_cookie) tc.resp = api.Trigger(req) return api.types.status.SUCCESS
def Trigger(tc): if tc.skip: return api.types.status.SUCCESS store = tc.GetBundleStore() serverResp = store["server_resp"] kill_cmd = "pkill -9 iperf3" server_nodes = set() for cmd in serverResp.commands: server_nodes.add(cmd.node_name) serverReq = api.Trigger_CreateAllParallelCommandsRequest() for server in server_nodes: api.Trigger_AddHostCommand(serverReq, server, kill_cmd) api.Trigger(serverReq) #Still call terminate on all api.Trigger_TerminateAllCommands(serverResp) return api.types.status.SUCCESS