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 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): tc.cmd_cookies = [] tc.interval = 0.1 tc.resp = None tc.skip = False tc.uplink_fail_stage = False tc.nodes = api.GetNaplesHostnames() tc.is_bm_type = False for node in tc.nodes: if api.IsBareMetalWorkloadType(node): # for baremetal topology, untag WL is configured on the uplink itself. # shutting down uplink on both nodes will bring down the WL. # so bring down uplink only on one naples tc.nodes = [node] tc.is_bm_type = True break tc.port_down_time = getattr(tc.args, "port_shut_time", 60) tc.failover_delay = getattr(tc.args, "failover_delay", 0) result = bond_utils.DetectUpLinkState(tc.nodes, bond_utils.PORT_OPER_STATUS_UP, all) if result != api.types.status.SUCCESS: api.Logger.error("All uplink on %s are not in UP state." % tc.nodes) tc.skip = True return api.types.status.SUCCESS api.Logger.info("All uplink on %s are UP!" % tc.nodes) # Bring up inband and reset the active link on bond. result = bond_utils.SetupInbandInterface() if result != api.types.status.SUCCESS: return result trigger_ping_to_bond(tc) result = verify_ping_to_bond_result(tc) if result != api.types.status.SUCCESS: api.Logger.error("Ping failed during setup stage") return result
def Setup(tc): global is_wl_type_bm global wl_sec_ip_info tc.workload_pairs = api.GetRemoteWorkloadPairs() tc.workloads = api.GetWorkloads() for wl in tc.workloads: wl_sec_ip_info[wl.workload_name] = [] # for BM type set untag collector if api.IsBareMetalWorkloadType(wl.node_name): is_wl_type_bm = True sec_ip_list = sec_ip_api.ConfigWorkloadSecondaryIp(wl, True, 2) wl_sec_ip_info[wl.workload_name] = sec_ip_list #for wl in tc.workloads: # for sec_ip in wl_sec_ip_info[wl.workload_name]: # api.Logger.info("Node: {} WL: {} Sec IP: {}".format(wl.node_name, wl.workload_name, sec_ip)) #tc.skip = True return api.types.status.SUCCESS
def Setup(tc): # # Set up global variables # tc.feature = 'lif-flow-erspan-flowmon' tc.udp_count = NUMBER_OF_UDP_ERSPAN_PACKETS_PER_SESSION >> 1 tc.icmp_count = NUMBER_OF_ICMP_ERSPAN_PACKETS_PER_SESSION >> 1 tc.tcp_close_val = None tc.classic_mode = False tc.ignore = False tc.error = False # # Establish Workloads # result = eutils.establishWorkloads(tc) if result != api.types.status.SUCCESS: tc.error = True return result # # Check to see if Naples-hosted node is present # result = eutils.establishNaplesWorkload(tc) if result != api.types.status.SUCCESS: tc.error = True return result # # Ignore non-applicable test-options in Sanity mode # - [peer = local] is not supported until ps_2263 is fixed # - [collector = local] is not supported until ps_2790 is fixed # - Multi-collector testing is not enabled in freebsd # environment until tcpdump capture on secondary-IP is resolved # if (tc.args.ps_2263 != 'fixed' and tc.iterators.peer == 'local') or\ (tc.args.ps_2790 != 'fixed' and tc.iterators.collector == 'local') or\ (api.GetNodeOs(tc.naples.node_name) == 'freebsd' and\ tc.iterators.ccount > 1): tc.ignore = True return api.types.status.SUCCESS if api.IsBareMetalWorkloadType(tc.naples.node_name): tc.classic_mode = True tc.udp_count = 1 tc.icmp_count = 1 # # Figure out (Collector) Workloads that are remote to Naples node and # identify remote Naples-peer, if applicable # result = eutils.establishRemoteWorkloads(tc) if result != api.types.status.SUCCESS: tc.error = True return result # # Figure out Workloads that are local to Naples node and identify # local Naples-peer, if applicable # result = eutils.establishLocalWorkloads(tc) if result != api.types.status.SUCCESS: tc.error = True return result if tc.classic_mode == True: result = eutils.establishCollectorWorkloadInClassicMode( tc, '10.255.0.2') if result != api.types.status.SUCCESS: tc.error = True return result # # Allocate Secondary-IPs for collectors as needed in order to test up to # Eight collectors # result = eutils.establishCollectorSecondaryIPs(tc) if result != api.types.status.SUCCESS: tc.error = True return result # # Generate feature specific Collector list # eutils.generateFeatureCollectorList(tc) eutils.debugWorkLoadTraces(tc) # # Retrieve relevant Table-Id's # eutils.retrieveTableIds(tc) # # Set up runtime validation knobs # - dupcheck: To circumvent duplicate-pkts checks in case of LIF-ERSPAN # where multiple workloads map to the same LIF # tc.dupcheck = 'enable' if tc.iterators.peer == 'local' or tc.iterators.iftype != 'uplink': tc.dupcheck = 'disable' # # Preserve current TCP-Close configs and shrink it to 1-second # if tc.classic_mode == False: tc.tcp_close_val = get_timeout_val('tcp-close') update_timeout('tcp-close', "1s") return api.types.status.SUCCESS
def Setup(tc): # # Set up global variables # tc.feature = 'endpoint-span' tc.protocol = 'all' tc.udp_count = 1 tc.icmp_count = 1 tc.tcp_close_val = None tc.classic_mode = False tc.ignore = False tc.error = False # # Establish Workloads # result = eutils.establishWorkloads(tc) if result != api.types.status.SUCCESS: tc.error = True return result # # Check to see if Naples-hosted node is present # result = eutils.establishNaplesWorkload(tc) if result != api.types.status.SUCCESS: tc.error = True return result # # Ignore non-applicable test-options in Sanity mode # - Multi-collector testing is not enabled in freebsd # environment until tcpdump capture on secondary-IP is resolved # - Multi-collector testing is limited to 2 in esx # environment until secondary-IP works in esx mode # if (api.GetNodeOs(tc.naples.node_name) == 'freebsd' and\ tc.iterators.ccount > 1) or\ (api.GetNodeOs(tc.naples.node_name) == 'esx' and\ tc.iterators.ccount > 2): tc.ignore = True return api.types.status.SUCCESS if api.IsBareMetalWorkloadType(tc.naples.node_name): tc.classic_mode = True # # Figure out (Collector) Workloads that are remote to Naples node and # identify remote Naples-peer, if applicable # result = eutils.establishRemoteWorkloads(tc) if result != api.types.status.SUCCESS: tc.error = True return result # # Figure out Workloads that are local to Naples node and identify # local Naples-peer, if applicable # result = eutils.establishLocalWorkloads(tc) if result != api.types.status.SUCCESS: tc.error = True return result ''' # endpoint span is not supported in classic mode if tc.classic_mode == True: result = eutils.establishCollectorWorkloadInClassicMode(tc, '10.255.0.2') if result != api.types.status.SUCCESS: tc.error = True return result ''' # # Allocate Secondary-IPs for collectors as needed in order to test up to # Eight collectors # result = eutils.establishCollectorSecondaryIPs(tc) if result != api.types.status.SUCCESS: tc.error = True return result # # Generate feature specific Collector list # eutils.generateFeatureCollectorList(tc) eutils.debugWorkLoadTraces(tc) # # Retrieve relevant Table-Id's # eutils.retrieveTableIds(tc) # # Set up runtime validation knobs # - dupcheck: To circumvent duplicate-pkts checks in case of LIF-ERSPAN # where multiple workloads map to the same LIF # tc.dupcheck = 'enable' if tc.iterators.peer == 'local': tc.dupcheck = 'disable' # # Preserve current TCP-Close configs and shrink it to 1-second # if tc.classic_mode == False: tc.tcp_close_val = get_timeout_val('tcp-close') update_timeout('tcp-close', "1s") #Query will get the reference of objects on store nw_filter = "meta.name=" + tc.naples.workload_name + ";" tc.store_endpoint_objects = netagent_cfg_api.QueryConfigs(kind='Endpoint', filter=nw_filter) if len(tc.store_endpoint_objects) == 0: api.Logger.error("No Endpoint objects in store") tc.ignore = True return api.types.status.FAILURE #api.Logger.info("Len of endpoint_objects {}".format(len(tc.store_endpoint_objects))) #cfg_api.PrintConfigsObjects(tc.store_endpoint_objects) #api.Logger.info("Naples selected for test node: {} WL: {}".format(tc.naples.node_name, tc.naples.workload_name)) 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 ConfigWorkloadSecondaryIp(workload, is_add, sec_ip_count_per_intf=1): res = api.types.status.SUCCESS wl_sec_ip_list = [] if (workload.uplink_vlan != 0): return wl_sec_ip_list nodes = api.GetWorkloadNodeHostnames() max_untag_wl = 0 max_tag_wl = 0 if is_add == True: op = "add" else: op = "del" is_wl_bm_type = False for node in nodes: if api.IsBareMetalWorkloadType(node): is_wl_bm_type = True workloads = api.GetWorkloads(node) num_untag_wl_in_node = 0 num_tag_wl_in_node = 0 for wl in workloads: if (wl.uplink_vlan == 0): num_untag_wl_in_node += 1 else: num_tag_wl_in_node += 1 if num_untag_wl_in_node > max_untag_wl: max_untag_wl = num_untag_wl_in_node if num_tag_wl_in_node > max_tag_wl: max_tag_wl = num_tag_wl_in_node #api.Logger.info("Node {} WL #untag {} #tag {} ".format(node, num_untag_wl_in_node, num_tag_wl_in_node)) #api.Logger.info("Topo Max untag WL {} Max tag WL {} ".format(max_untag_wl, max_tag_wl)) sec_ip_incr_step = max_untag_wl if is_wl_bm_type == False: sec_ip_incr_step += max_tag_wl req = api.Trigger_CreateExecuteCommandsRequest(serial=True) wl = workload sec_ipv4_allocator = resmgr.IpAddressStep( wl.ip_prefix.split('/')[0], str(ipaddress.IPv4Address(sec_ip_incr_step)), sec_ip_count_per_intf) sec_ip4_addr_str = str(sec_ipv4_allocator.Alloc()) for i in range(sec_ip_count_per_intf): sec_ip4_addr_str = str(sec_ipv4_allocator.Alloc()) sec_ip_prefix = sec_ip4_addr_str + "/" + str( wl.ip_prefix.split('/')[1]) wl_sec_ip_list.append(sec_ip4_addr_str) #api.Logger.info("Node {} WL {} Intf {} Secondary IP {} Op {}".format( # wl.node_name, wl.workload_name, wl.interface, sec_ip_prefix, op)) api.Trigger_AddCommand( req, wl.node_name, wl.workload_name, "ip address %s %s dev %s " % (op, sec_ip_prefix, wl.interface)) trig_resp = api.Trigger(req) #api.Logger.info("Response ") #for cmd in trig_resp.commands: # api.PrintCommandResults(cmd) return wl_sec_ip_list
def IsBareMetal(): for node_name in api.GetNaplesHostnames(): if api.IsBareMetalWorkloadType(node_name): return True return False