def setupWorkloadDict(tc, kind=None): workload_pairs = [] if kind != None: if kind == 'remote': workload_pairs = api.GetRemoteWorkloadPairs() elif kind == 'local': workload_pairs.extend(api.GetLocalWorkloadPairs()) else: workload_pairs = api.GetRemoteWorkloadPairs() workload_pairs.extend(api.GetLocalWorkloadPairs()) naples_node_name_list = api.GetNaplesHostnames() w_list = [] for w1,w2 in workload_pairs: if w1.node_name in naples_node_name_list or \ w2.node_name in naples_node_name_list: w_list.append((w1,w2)) api.Logger.info("Adding Naples workload w1: %s and w2: %s to list"% (w1.workload_name, w2.workload_name)) else: api.Logger.debug("Skipping non Naples workload w1: %s and w2: %s"% (w1.workload_name, w2.workload_name)) tc.workload_dict = workload_dict = {} for w1,w2 in w_list: l = workload_dict.get(w1, []) l.append(w2) workload_dict[w1] = l for w1, dst_workload_list in tc.workload_dict.items(): l = [w2.workload_name for w2 in dst_workload_list] api.Logger.info("%s => %s"%(w1.workload_name, ",".join(l)))
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.os == naples_host.OS_TYPE_ESX: api.Logger.info("Not implemented for %s" % tc.os) return api.types.status.IGNORED fail = 0 pairs = api.GetLocalWorkloadPairs() hosts = pairs[0] for host in hosts: if not host.IsNaples(): continue api.Logger.info("Checking host %s" % host.node_name) lif_info = __getLifInfo(host.node_name) intfs = api.GetNaplesHostInterfaces(host.node_name) for intf in intfs: # Windows HAL interface name is translated two times. if tc.os == naples_host.OS_TYPE_WINDOWS: intf = ionic_utils.winHalIntfName(host.node_name, intf) # HAL yaml o/p is Pen..Adapter, halctl cli op/ is pen..adap. intf = intf.lower() if lif_info.find(intf) == -1: api.Logger.error("interface %s not found" % intf) fail += 1 if fail != 0: return api.types.status.FAILURE return api.types.status.SUCCESS
def Setup(tc): tc.loop_count = 0 tc.policy_db = {} api.Logger.info("Loop count set to ", tc.loop_count) tc.nodes = api.GetNaplesHostnames() #netagent_cfg_api.ReadJsons() tc.sgpolicy = sgpolicy_obj.gl_sg_json_template #get rules list - it is list of dictionary policy_rules = tc.sgpolicy['sgpolicies'][0]['spec']['policy-rules'] meta = tc.sgpolicy['sgpolicies'][0]['meta'] meta['name'] = 'default_policies' meta['namespace'] = 'default' meta['tenant'] = 'default' print('Initial policy rules {}'.format(policy_rules)) print(api.GetWorkloads()) tc.workload_pairs = api.GetLocalWorkloadPairs() print(tc.workload_pairs) for pair in tc.workload_pairs: w1 = pair[0] w2 = pair[1] rule = get_rule(w1.ip_address, w2.ip_address, "udp", "59379", "PERMIT") tc.policy_db[(w1, w2, "udp", "59379")] = "PERMIT" policy_rules.append(rule) return api.types.status.SUCCESS
def Trigger(tc): if tc.os != naples_host.OS_TYPE_BSD and tc.os != naples_host.OS_TYPE_LINUX: api.Logger.info("Not implemented for %s" % tc.os) return api.types.status.IGNORED fail = 0 pairs = api.GetLocalWorkloadPairs() hosts = pairs[0] for host in hosts: if not host.IsNaples(): continue api.Logger.info("Checking host %s" % host.node_name) lif_info = __getLifInfo(host.node_name) intfs = api.GetNaplesHostInterfaces(host.node_name) for intf in intfs: api.Logger.info("Checking interface %s" % intf) if lif_info.find(intf) == -1: api.Logger.info("interface %s not found" % intf) fail += 1 if fail != 0: return api.types.status.FAILURE return api.types.status.SUCCESS
def Setup(tc): tc.Nodes = api.GetNaplesHostnames() tc.uuidMap = api.GetNaplesNodeUuidMap() tc.old_node = None tc.new_node = None tc.skip_security_prof = getattr(tc.args, "skip_security_prof", False) tc.client, tc.server, tc.naples = None, None, None if tc.args.type == 'local_only': tc.workload_pairs = api.GetLocalWorkloadPairs(naples=True) else: tc.workload_pairs = api.GetRemoteWorkloadPairs() if len(tc.workload_pairs) == 0: api.Logger.error("Failed to get client server pair") return api.types.status.FAIL # pick a node to run traffic test ret = chooseNaples(tc, tc.workload_pairs[0]) if ret != api.types.status.SUCCESS: return ret # pick a new node to move one of the vms to ret = vm_utils.pick_new_node(tc) if ret != api.types.status.SUCCESS: return ret if not addPktFltrRuleOnEp(tc): api.Logger.error("Failed to add packet filter on EP") return api.types.status.FAIL return api.types.status.SUCCESS
def Setup(tc): tc.skip = False if tc.args.type == 'local_only': tc.workload_pairs = api.GetLocalWorkloadPairs() else: tc.workload_pairs = api.GetRemoteWorkloadPairs() if len(tc.workload_pairs) == 0: api.Logger.info("Skipping Testcase due to no workload pairs.") tc.skip = True if api.GetConfigNicMode() == 'hostpin' and tc.iterators.ipaf == 'ipv6': api.Logger.info("Skipping Testcase: IPv6 not supported in hostpin mode.") tc.skip = True if getattr(tc.args, 'vmotion_enable', False): wloads = [] for idx, pair in enumerate(tc.workload_pairs): if idx % 2: continue w2 = pair[1] wloads.append(w2) vmotion_utils.PrepareWorkloadVMotion(tc, wloads) return api.types.status.SUCCESS
def Setup(tc): if tc.iterators.eptype == 'local': tc.workload_pairs = api.GetLocalWorkloadPairs() else: tc.workload_pairs = api.GetRemoteWorkloadPairs() return api.types.status.SUCCESS
def Setup(tc): api.Logger.info ("Driver compat test") if api.IsDryrun(): return api.types.status.SUCCESS tc.nodes = api.GetNaplesHostnames() tc.os = api.GetNodeOs(tc.nodes[0]) tc.skip = False tc.driver_changed = False if tc.os == compat.OS_TYPE_BSD: # Not supportig BSD right now tc.skip = True return api.types.status.SUCCESS # Intention to test locally built FW with target-version driver tc.target_version = getattr(tc.iterators, 'release', 'latest') if compat.LoadDriver(tc.nodes, node_os, tc.target_version): tc.driver_changed = True if getattr(tc.args, 'type', 'local_only') == 'local_only': tc.workload_pairs = api.GetLocalWorkloadPairs() else: tc.workload_pairs = api.GetRemoteWorkloadPairs() if len(tc.workload_pairs) == 0: api.Logger.info("Skipping ping part of testcase due to no workload pairs.") tc.skip = True return api.types.status.SUCCESS
def Setup(tc): tc.skip = False if tc.selected: tc.workload_pairs = tc.selected else: if tc.args.type == 'local_only': tc.workload_pairs = api.GetLocalWorkloadPairs() else: tc.workload_pairs = api.GetRemoteWorkloadPairs() tc.workload_pairs = tc.workload_pairs[:1] if len(tc.workload_pairs) == 0: api.Logger.info("Skipping Testcase due to no workload pairs.") tc.skip = True if getattr(tc.args, 'vmotion_enable', False): wloads = [] # collecting all server for wl_pair in tc.workload_pairs: wloads.append(wl_pair[1]) vmotion_utils.PrepareWorkloadVMotion(tc, wloads) #Have to fix it later. 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 Setup(tc): tc.Nodes = api.GetNaplesHostnames() tc.uuidMap = api.GetNaplesNodeUuidMap() tc.old_node = None tc.new_node = None tc.skip_security_prof = getattr(tc.args, "skip_security_prof", False) if tc.args.type == 'local_only': tc.workload_pairs = api.GetLocalWorkloadPairs() else: tc.workload_pairs = api.GetRemoteWorkloadPairs() w1, w2 = tc.workload_pairs[0] tc.old_node = w1.node_name if w1.IsNaples() else w2.node_name tc.wl = w1 # remove the node being used to pick wl for traffic # pick the next node in the naples nodes naples_nodes = tc.Nodes[:] naples_nodes.remove(w1.node_name) assert (len(naples_nodes) >= 1) new_node = naples_nodes[0] tc.new_node = new_node move_info = vm_utils.MoveInfo() move_info.new_node = new_node move_info.wl = w1 move_info.old_node = w1.node_name tc.move_info.append(move_info) return api.types.status.SUCCESS
def Setup(tc): if tc.args.type == 'local_only': tc.workload_pairs = api.GetLocalWorkloadPairs() else: tc.workload_pairs = api.GetRemoteWorkloadPairs() w1, w2 = tc.workload_pairs[0] tc.naples = w1 if w1.IsNaples() else w2 return api.types.status.SUCCESS
def Setup(tc): tc.workload_pairs = api.GetLocalWorkloadPairs() if len(tc.workload_pairs) == 0: api.Logger.info("Skipping Testcase due to no workload pairs.") tc.skip = True return api.types.status.SUCCESS
def Setup(tc): api.Logger.info("Setup.") tc.pcap_file_name = None tc.dir_path = os.path.dirname(os.path.realpath(__file__)) tc.test_mss = 900 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) if pairs[0][0].IsNaples(): tc.client, tc.server = pairs[0] else: tc.server, tc.client = pairs[0] fullpath = tc.dir_path + '/' + "scapy_3way.py" resp = api.CopyToWorkload(tc.server.node_name, tc.server.workload_name, [fullpath]) resp = api.CopyToWorkload(tc.client.node_name, tc.client.workload_name, [fullpath]) cmd_cookie = start_nc_server(tc.server, "1237") add_command(req, tc, 'server', tc.server, cmd_cookie, True) ret = __add_remove_tcp_drop_rule(tc.client) if ret != api.types.status.SUCCESS: api.Logger.error( f"Failed to drop the drop rule on {tc.client.workload_name}") return ret #start session cmd_cookie = "sudo -E python3 ./scapy_3way.py {} {}".format( tc.client.ip_address, tc.server.ip_address) api.Trigger_AddCommand(req, tc.client.node_name, tc.client.workload_name, cmd_cookie, False) cmd_cookie = "/nic/bin/halctl show session --dstport 1237 --dstip {} --yaml".format( tc.server.ip_address) add_command(req, tc, 'show before', tc.client, cmd_cookie, naples=True) tc.first_resp = api.Trigger(req) cmd = tc.first_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 Setup(tc): tc.skip = False if tc.args.type == 'local_only': tc.workload_pairs = api.GetLocalWorkloadPairs() else: tc.workload_pairs = api.GetRemoteWorkloadPairs() if len(tc.workload_pairs) == 0: api.Logger.info("Skipping Testcase due to no workload pairs.") tc.skip = True return api.types.status.SUCCESS
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 RTSP test from %s" % (tc.cmd_descr)) dir_path = os.path.dirname(os.path.realpath(__file__)) fullpath = dir_path + '/' + "small.vob" api.Logger.info("fullpath %s" % (fullpath)) resp = api.CopyToWorkload(server.node_name, server.workload_name, [fullpath], 'rtspdir') if resp is None: return api.types.status.FAILURE api.Trigger_AddCommand(req, client.node_name, client.workload_name, "ls -al | grep video") tc.cmd_cookies.append("Before RTSP") server_cmd = "cd rtspdir && live555MediaServer" api.Trigger_AddCommand(req, server.node_name, server.workload_name, server_cmd, background = True) tc.cmd_cookies.append("Run RTSP server") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "openRTSP rtsp://%s/small.vob" % server.ip_address) tc.cmd_cookies.append("Run RTSP client") ## Add Naples command validation api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session --alg rtsp --yaml") tc.cmd_cookies.append("show session RTSP established") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show nwsec flow-gate | grep RTSP") tc.cmd_cookies.append("show flow-gate") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "ls -al | grep video") tc.cmd_cookies.append("After RTSP") 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 Main(step): res = api.types.status.SUCCESS workloads = api.GetLocalWorkloadPairs(True) naples_inband_ip = {} ip_offset = 100 new_controller_ip = None for wl in workloads: w1 = wl[0] w2 = wl[1] if (w1.uplink_vlan != 0): continue if naples_inband_ip.get(w1.node_name) != None: continue ip_mask = w1.ip_prefix.split('/')[1] ip_addr = ip.IPv4Interface(w1.ip_prefix) w1_ip_intf = ip.IPv4Interface(str(w1.ip_prefix)) #For inband collector config, agent always resolves thru first ip addr on the inband mgmt i/f. #so forcing to use 10.x.x.x network as inband mgmt ip for baremetal workloads if api.IsBareMetalWorkloadType(w1.node_name): if (str(w1_ip_intf.network).split('/')[0]) != "10.255.0.0": continue #chose ip_offset as the IP address for host in-band mgmt ip new_naples_inband_ip = ip.IPv4Interface(ip_addr.ip + ip_offset) ip_offset += 1 if new_controller_ip == None: new_controller_ip = ip.IPv4Interface(ip_addr.ip + ip_offset) ip_offset += 1 new_naples_inband_ip_str = str( new_naples_inband_ip.ip) + "/" + str(ip_mask) node = w1.node_name api.Logger.info( "Configuring Naples Inband IP {}".format(new_naples_inband_ip_str)) ret = common.SetNaplesModeInband_Static(node, str(new_controller_ip.ip), new_naples_inband_ip_str) if ret == None: api.Logger.info("Failed to set Naples Inband mode IP: {}".format( new_naples_inband_ip_str)) res = api.types.status.FAILURE #api.Logger.info("Naples {}".format(common.PenctlGetNaplesMgtmIp(node))) naples_inband_ip.update({w1.node_name: new_naples_inband_ip_str}) #break return res
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 SUNRPC test from %s" % (tc.cmd_descr)) api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl clear session") tc.cmd_cookies.append("clear session") api.Trigger_AddCommand(req, server.node_name, server.workload_name, "sudo service rpcbind start") tc.cmd_cookies.append("Start RPC") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "rpcinfo -T udp %s 100000 4"%(server.ip_address)) tc.cmd_cookies.append("RPC Getport") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session --alg sun_rpc") tc.cmd_cookies.append("show session") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show nwsec flow-gate") tc.cmd_cookies.append("show security flow-gate") # Add Naples command validation api.Trigger_AddNaplesCommand(req, naples.node_name, "sleep 100", timeout=120) tc.cmd_cookies.append("sleep") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session --alg sun_rpc") tc.cmd_cookies.append("After timeout session") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show nwsec flow-gate") tc.cmd_cookies.append("After timeout flow-gate") 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 GetServerClientSinglePair(kind, naples=True): if kind == 'remote': pairs = api.GetRemoteWorkloadPairs() else: pairs = api.GetLocalWorkloadPairs(naples=naples) if len(pairs) == 0: api.Logger.info("No workloads found") return (None, None) server, client = pairs[0] if not server.IsNaples(): if not client.IsNaples(): api.Logger.info("Naples workloads not found") return (None, None) return (server, client)
def Setup(tc): api.Logger.info("Interface Names") tc.nodes = api.GetNaplesHostnames() tc.os = api.GetNodeOs(tc.nodes[0]) if tc.os != naples_host.OS_TYPE_BSD and tc.os != naples_host.OS_TYPE_LINUX: api.Logger.info("Not implemented for %s" % tc.os) return api.types.status.IGNORED pairs = api.GetLocalWorkloadPairs() if not pairs: api.Logger.error("No workloads found") return api.types.status.FAILURE return api.types.status.SUCCESS
def chooseWorkload(tc): tc.skip = False if tc.selected: tc.workload_pairs = tc.selected else: if tc.args.type == 'local_only': tc.workload_pairs = api.GetLocalWorkloadPairs() else: tc.workload_pairs = api.GetRemoteWorkloadPairs() naples_node_name_list = api.GetNaplesHostnames() w1, w2 = tc.workload_pairs[0] tc.workload_pair = (w1, w2) return
def Setup(tc): if tc.args.type == 'local_only': tc.workload_pairs = api.GetLocalWorkloadPairs() else: tc.workload_pairs = api.GetRemoteWorkloadPairs() for pair in tc.workload_pairs: w1 = pair[0] w2 = pair[1] # check if BM type if api.IsBareMetalWorkloadType(w1.node_name): api.Logger.info("For BM type, this test is not supported yet") tc.skip = True break return api.types.status.SUCCESS
def Setup(tc): 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.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 = "nc -l 1234" api.Trigger_AddCommand(req, tc.server.node_name, tc.server.workload_name, cmd_cookie, background=True) tc.cmd_cookies['server'] = cmd_cookie cmd_cookie = "nc {} 1234 -p 52252".format(tc.server.ip_address) api.Trigger_AddCommand(req, tc.client.node_name, tc.client.workload_name, cmd_cookie, background=True) tc.cmd_cookies['client'] = cmd_cookie cmd_cookie = "/nic/bin/halctl show session --dstport 1234 --dstip {} --yaml".format( tc.server.ip_address) api.Trigger_AddNaplesCommand(req, tc.client.node_name, cmd_cookie) 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): pairs = api.GetLocalWorkloadPairs() w1 = pairs[0][0] client = pairs[0][1] tc.cmd_cookies = [] 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] 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 DNS test from %s" % (tc.cmd_descr)) SetupDNSServer(server) api.Trigger_AddCommand( req, client.node_name, client.workload_name, "echo \"nameserver %s\" | tee -a /etc/resolv.conf" % (server.ip_address)) tc.cmd_cookies.append("Setup resolv conf") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "nslookup test3.example.com") tc.cmd_cookies.append("Query DNS server") ## Add Naples command validation api.Trigger_AddNaplesCommand( req, naples.node_name, "/nic/bin/halctl show session --dstport 53 --dstip {}".format( server.ip_address)) tc.cmd_cookies.append("Find session") 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 Setup(tc): api.Logger.info("Fw compat test") if api.IsDryrun(): return api.types.status.SUCCESS tc.nodes = api.GetNaplesHostnames() tc.os = api.GetNodeOs(tc.nodes[0]) tc.skip = False if tc.os == compat.OS_TYPE_BSD: # Not supportig BSD & ESXi right now tc.skip = True return api.types.status.SUCCESS # Intention to test locally built FW with target-version driver tc.target_version = getattr(tc.iterators, 'release', 'latest') # this is required to bring the testbed into operation state # after driver unload interfaces need to be initialized tc.fw_changed = False if compat.LoadFirmware(tc.nodes, tc.os, tc.target_version) == api.types.status.SUCCESS: api.Logger.info("Loaded %s Fw on %s" % (tc.target_version, node)) else: return api.types.status.FAILURE tc.fw_changed = True if tc.os == compat.OS_TYPE_LINUX: for node in tc.nodes: # this is required to bring the testbed into operation state # after driver unload interfaces need to be initialized wl_api.ReAddWorkloads(node) if getattr(tc.args, 'type', 'local_only') == 'local_only': tc.workload_pairs = api.GetLocalWorkloadPairs() else: tc.workload_pairs = api.GetRemoteWorkloadPairs() if len(tc.workload_pairs) == 0: api.Logger.info( "Skipping ping part of testcase due to no workload pairs.") tc.skip = True 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 Setup(tc): tc.client, tc.server, tc.naples = None, None, None if tc.args.type == 'local_only': pairs = api.GetLocalWorkloadPairs(naples=True) else: pairs = api.GetRemoteWorkloadPairs() if len(pairs) == 0: api.Logger.error("Failed to get client server pair") return api.types.status.FAILURE ret = chooseNaples(tc, pairs[0]) if ret != api.types.status.SUCCESS: return ret if not addPktFltrRuleOnEp(tc): api.Logger.error("Failed to add packet filter on EP") return api.types.status.FAILURE return api.types.status.SUCCESS
def chooseWorkload(tc): tc.skip = False if tc.selected: tc.workload_pairs = tc.selected else: if tc.args.type == 'local_only': tc.workload_pairs = api.GetLocalWorkloadPairs() else: tc.workload_pairs = api.GetRemoteWorkloadPairs() naples_node_name_list = api.GetNaplesHostnames() random.seed(tc.seed) while 1: w1, w2 = random.choice(tc.workload_pairs) tc.workload_pair = [w1, w2] if w1.node_name in naples_node_name_list or \ w2.node_name in naples_node_name_list: tc.workload_pair = (w1, w2) return
def Setup(tc): tc.loop_count = 0 tc.policy_db = {} tc.nodes = api.GetNaplesHostnames() #netagent_cfg_api.ReadJsons() tc.sgpolicy = sgpolicy_obj.gl_sg_json_template #get rules list - it is list of dictionary policy_rules = tc.sgpolicy['sgpolicies'][0]['spec']['policy-rules'] meta = tc.sgpolicy['sgpolicies'][0]['meta'] meta['name'] = 'default_policies' meta['namespace'] = 'default' meta['tenant'] = 'default' print('Initial policy rules {}'.format(policy_rules)) print(api.GetWorkloads()) tc.workload_pairs = api.GetLocalWorkloadPairs() print(tc.workload_pairs) for pair in tc.workload_pairs: w1 = pair[0] w2 = pair[1] for proto in proto_list: if proto is not 'icmp': port = str(random.randint(1, 65535)) else: port = '1' action = random.choice(action_list) rule = Rule((w1, w2, proto, port), (action)) tc.policy_db[rule.key] = rule.action for match, action_tuple in tc.policy_db.items(): src, dst, proto, dst_port = match action = action_tuple policy_rules.append( get_rule(dst.ip_address, src.ip_address, proto, dst_port, action)) print(tc.sgpolicy) json_str = json.dumps(tc.sgpolicy) obj = api.parser.ParseJsonStream(json_str) agent_api.ConfigureSecurityGroupPolicies(obj.sgpolicies, oper=agent_api.CfgOper.UPDATE) return api.types.status.SUCCESS