def _get_entries_with_native_port(dut, output, **kwargs): cli_type = st.get_ui_type(dut, **kwargs) ifname_type = kwargs.get("ifname_type", "") verify_ifname_type(dut, mode='standard') st.log("OUTPUT:{}".format(output)) for entry in output: if (cli_type == 'klish' and ifname_type == "alias"): st.log("Interface : {}".format(st.get_other_names(dut, [entry['interface']])[0])) else: st.log("Else Interface : {}".format(entry.get('interface'))) entry.update(interface=st.get_other_names(dut, [entry['interface']])[0] if (cli_type == 'klish' and ifname_type == "alias") else entry.get('interface')) st.log("OUTPUT1:{}".format(output)) return output
def get_params(): pddf_data.base_mac_address = baapi.get_ifconfig_ether(vars.D1, "eth0") pddf_data.platform_name_summary = baapi.get_platform_summary(vars.D1) pddf_data.platform_hwsku = pddf_data.platform_name_summary["hwsku"].lower() platform_check() pddf_data.platform_name = pddf_data.platform_name_summary["platform"] pddf_data.serial_number = baapi.show_version(vars.D1)['serial_number'] pddf_data.platform_constants = st.get_datastore(vars.D1, "constants", pddf_data.platform_hwsku) pddf_data.fan_list = pddf_data.platform_constants.get( "PDDF_FANS_LIST", None) pddf_data.psu_list = pddf_data.platform_constants.get( "PDDF_PSU_LIST", None) pddf_data.thermal_list = pddf_data.platform_constants.get( "PDDF_THERMAL_LIST", None) pddf_data.manufacturer = pddf_data.platform_constants.get( "Manufacturer", None) if not all([ pddf_data.fan_list, pddf_data.psu_list, pddf_data.thermal_list, pddf_data.manufacturer ]): st.report_env_fail("pddf_get_constanc_fail", pddf_data.feature, pddf_data.platform_hwsku) pddf_data.up_port_list = intapi.get_up_interfaces(vars.D1) if not pddf_data.up_port_list: st.report_env_fail("up_interface_not_found", pddf_data.feature) pddf_data.up_port = get_sfpytils_supported_up_interface() if any("/" in interface for interface in make_list(pddf_data.up_port_list)): pddf_data.up_port_list = st.get_other_names( vars.D1, make_list(pddf_data.up_port_list)) pddf_data.alias_up_port = st.get_other_names( vars.D1, make_list(pddf_data.up_port))[0] else: pddf_data.alias_up_port = pddf_data.up_port #Removed Warm reboot as it's not supported in Buzznik+ pddf_data.reboot_cause_dict = { 'warm': 'warm-reboot', 'fast': 'fast-reboot', 'normal': "issued 'reboot'" } pddf_data.reboot_type = random.sample(pddf_data.reboot_cause_dict.keys(), k=1)[0] if pddf_data.platform_hwsku not in pddf_data.hw_constants[ 'WARM_REBOOT_SUPPORTED_PLATFORMS']: pddf_data.reboot_cause_dict.pop('warm') pddf_data.reboot_type = random.sample( pddf_data.reboot_cause_dict.keys(), k=1)[0]
def dhcp_client_start(dut, interface, family="ipv4", run_bckgrnd=False): """ API to start DHCLIENT in foreground for v4 and background for v6 Author Chaitanya Vella ([email protected]) :param dut: :type dut: :param portlist: :type portlist: """ if interface != None: if '/' in interface: interface = st.get_other_names(dut,[interface])[0] v6_opt = "" if family == "ipv4" else "-6" run_bckgrnd = True if (family == "ipv6" or run_bckgrnd) else False bckgrd = "&" if run_bckgrnd else "" command = "dhclient {} {} {}".format(v6_opt, interface, bckgrd) output = st.config(dut, command, skip_error_check=True) if bckgrd: output = remove_last_line_from_string(output) if output: return output.split(" ")[1] else: return None else: return True
def udld_block(dut, **kwargs): """ Author: [email protected] udld_blockf(dut=data.dut1,intf ='Ethernet10') Block the UDLD packtets at interface level :param dut: :param intf: :return: """ if 'config' in kwargs: config = kwargs['config'] else: config = 'yes' if config.lower() == 'yes': config_cmd = 'enable' else: config_cmd = 'disable' if 'intf' in kwargs: if type(kwargs['intf']) is list: kwargs['intf'] = list(kwargs['intf']) else: kwargs['intf'] = [kwargs['intf']] my_cmd = '' for intf in kwargs['intf']: if '/' in intf: intf = st.get_other_names(dut, [intf])[0] my_cmd += 'udldctl rx_drop {} {}\n'.format(config_cmd, intf) else: st.error("Mandatory argument interface name Not Found") return False st.config(dut, my_cmd, type="click")
def get_intf_pmap(dut, interface_name=None): """ Author: Chaitanya Vella ([email protected]) This API is used to get the interface pmap details :param dut: dut :param interface_name: List of interface names :return: """ import apis.system.interface as interface_obj ##Passing the cli_type as click in the API call "interface_status_show" because the lanes information is available only in click CLI. ##Please refer the JIRA: SONIC-22102 for more information. interfaces = cutils.make_list(interface_name) if interface_name else '' if interfaces: if any("/" in interface for interface in interfaces): interfaces = st.get_other_names(dut, interfaces) key = 'alias' else: key = 'interface' st.debug("The interfaces list is: {}".format(interfaces)) interface_list = interface_obj.interface_status_show( dut, interfaces=interfaces, cli_type='click') else: key = 'alias' if interface_obj.show_ifname_type( dut, cli_type='klish') else 'interface' interface_list = interface_obj.interface_status_show(dut, cli_type='click') interface_pmap = dict() pmap_list = get_pmap(dut) for detail in cutils.iterable(interface_list): lane = detail["lanes"].split( ",")[0] if "," in detail["lanes"] else detail["lanes"] for pmap in pmap_list: if pmap["physical"] == lane: interface_pmap[detail[key]] = pmap["interface"] return interface_pmap
def check_ports_from_rest_output(resp, threshold_type, buffer_type, dut_ports): if any("/" in interface for interface in make_list(dut_ports)): dut_ports = st.get_other_names(vars.D1, make_list(dut_ports)) result = True if threshold_type == 'priority-group' and buffer_type in [ 'shared', 'headroom' ]: rest_ports = [each['port'] for each in resp['report'][0]['data']] elif threshold_type == 'queue' and buffer_type in ['unicast', 'multicast']: rest_ports = list(set([each[1] for each in resp['report'][0]['data']])) else: st.error('No Match for threshold_type and buffer_type found') return None for each in dut_ports: if each not in rest_ports: st.error( ">>> Port '{}' information is *not* available in REST data of {} {}" .format(each, threshold_type, buffer_type)) result = False else: st.debug( "Port '{}' information is available in REST data".format(each)) return result
def get_interface_breakout_mode(dut, interface, *fields): """ Author: Naveen Nag email : [email protected] :param dut: :param interface: :param fields: :return: port,interface,supported_modes,default mode Usage: port.get_interface_breakout_mode(dut1, 'Ethernet4', 'port','supported_modes') :return - [{'supported_modes': '1x100G[40G], 4x25G[10G]', 'port': '1/2'}] """ if '/' not in interface: temp_vars = st.get_testbed_vars() if temp_vars.config.ifname_type == 'alias': interface = st.get_other_names(dut,[interface])[0] if '/' in interface: interface = '/'.join([interface.split('/')[0], interface.split('/')[1]]) output = st.show(dut, "show interface breakout modes | grep \"{} \"".format(interface), type='klish') entries = filter_and_select(output, fields, {'iface': interface}) if entries: return entries else: st.error("{} is not part of the output".format(interface)) return False
def get_threshold_from_rest_output(resp, threshold_type, buffer_type, port_alias, index): if any("/" in interface for interface in make_list(port_alias)): port_alias = st.get_other_names(vars.D1, make_list(port_alias))[0] st.log(resp) if threshold_type == 'priority-group' and buffer_type == 'shared': for each in resp['report'][0]['data']: if port_alias in each['port']: return each['data'][index][1] elif threshold_type == 'priority-group' and buffer_type == 'headroom': for each in resp['report'][0]['data']: if port_alias in each['port']: return each['data'][index][2] elif threshold_type == 'queue' and buffer_type == 'multicast' and port_alias == 'CPU': for each in resp['report'][0]['data']: if each[0] == index: return each[1] elif threshold_type == 'queue' and buffer_type in ['unicast', 'multicast']: for each in resp['report'][0]['data']: if each[1] == port_alias and each[2] == index: return each[3] else: st.error('No Match for threshold_type and buffer_type found') st.error("No Value found for Port:{} Index:{} in the rest data".format( port_alias, index)) return None
def set_speed(dut, data, cli_type=""): cli_type = st.get_ui_type(dut, cli_type=cli_type) cli_type = 'klish' if cli_type in ['rest-patch', 'rest-put'] else cli_type platform = basic.get_hwsku(dut) ports_per_pg = 12 if platform in ["Accton-AS7326-56X"] else 4 non_portgroup_platforms = [ "Accton-AS7712-32X", "Quanta-IX8A-BWDE-56X", "AS5835-54X" ] if not st.is_feature_supported("port-group", dut): non_portgroup_platforms.append(platform) ports_dict = dict() port_name_dict = dict() for index in range(0, len(data), 2): port = st.get_other_names( dut, [data[index]])[0] if "/" in data[index] else data[index] port_name_dict[port] = data[index + 1] id = re.search(r"\d+", port).group(0) id = (int(int(id) / ports_per_pg)) + 1 ports_dict[str(id)] = data[index + 1] st.debug("port-group speed data: {}".format(ports_dict)) commands = list() if cli_type == 'click': if platform not in non_portgroup_platforms: commands = [ "config portgroup speed {} {}".format(index, speed) for index, speed in ports_dict.items() ] else: commands = [ "portconfig -p {} -s {}".format(port, speed) for port, speed in port_name_dict.items() ] elif cli_type == 'klish': if platform not in non_portgroup_platforms: commands = [ "port-group {} speed {}".format(index, speed) for index, speed in ports_dict.items() ] else: for port, speed in port_name_dict.items(): intf_details = get_interface_number_from_name(port) if not intf_details: st.error("Interface data not found for {} ".format(port)) continue commands.append("interface {} {}".format( intf_details["type"], intf_details["number"])) commands.append("speed {}".format(speed)) commands.append("exit") else: st.error("Unsupported CLI_TYPE: {}".format(cli_type)) if commands: st.config(dut, commands, type=cli_type) return True
def get_sfpytils_supported_up_interface(): """ This function return the First UP interface which supports SFP utils. :return: """ out = bsapi.show_sfputil(vars.D1, 'lpmode') for port in pddf_data.up_port_list: if "/" in port: port = st.get_other_names(vars.D1, make_list(port))[0] if filter_and_select(out, None, {'port': port}): return port
def fill_dev_ids(): dids, palias = {}, {} for dut in st.get_dut_names(): dids[dut] = st.get_device_alias(dut, True, True) palias[dut] = {} links = st.get_dut_links_local(dut) onames = st.get_other_names(dut, links) for index, local in enumerate(links): palias[dut][local] = onames[index] for tg in st.get_tg_names(): dids[tg] = st.get_device_alias(tg, True, True) return dids, palias
def initialize_variables(): global data data = SpyTestDict() data.session_name = "Mirror_Ses" data.gre_type = "0x88ee" data.dscp = "50" data.ttl = "100" data.queue = "0" data.type = 'monitoring' data.source_ip = '11.1.1.2' data.destination_ip = '15.1.1.2' data.source_mac = "00:00:02:00:00:01" data.destination_mac = "00:00:01:00:00:01" data.mode_high = 'high' data.mode_low = 'low' data.polling_interval = '1' data.threshold_percentage_type = 'percentage' data.threshold_used_type = 'used' data.threshold_free_type = 'free' data.ipv4_route_family = "ipv4_route" data.ipv6_route_family = "ipv6_route" data.fdb_family = "fdb" data.ipv4_neighbor_family = "ipv4_neighbor" data.ipv6_neighbor_family = "ipv6_neighbor" data.acl_group_entry_family = 'acl_group_entry' data.acl_group_counter_family = 'acl_group_counter' data.ipv6_nexthop_family = 'ipv6_nexthop' data.ipv4_nexthop_family = 'ipv4_nexthop' data.acl_table_family = "acl_table" data.mode_high_percentage = 50 data.mode_low_percentage = 20 data.mode_high_used = 1000 data.mode_low_used = 10 data.mode_high_free = 1000 data.mode_low_free = 10 data.mtu = "9216" data.eth = data.eth_name = st.get_free_ports(vars.D1)[0] if any("/" in interface for interface in make_list(data.eth_name)): data.eth_name = st.get_other_names(vars.D1, make_list(data.eth))[0] data.property = "mtu" data.mtu_default = "9100" data.portchannel_name = "PortChannel7" data.members_dut1 = [vars.D1D2P1, vars.D1D2P2] data.members_dut2 = [vars.D2D1P1, vars.D2D1P2] data.session_name_port = "Mirror1" data.mirror_type = "span" data.mirror_interface = vars.D1T1P2 data.source_interface = vars.D1T1P1 data.direction_list = "rx"
def verify_error_db_redis(dut, table, **kwargs): """ Verify error db using redis cli Author : Prudvi Mangadu ([email protected]) :param :dut: :param :table: :param :route: :param :mask: :param :ifname: :param :nhp: :param :operation: :param :rc: :param :result: (Default True) :param :iteration: default(30) :return: """ port = kwargs.pop("ifname") port = st.get_other_names(dut, [port])[0] if "/" in port else port exp_result = kwargs.get("result", True) iteration = kwargs.get("iteration", 30) command = '' if table == "ERROR_ROUTE_TABLE": command = redis.build( dut, redis.ERROR_DB, "hgetall {}:{}/{}".format(table, kwargs.pop("route"), kwargs.pop("mask"))) elif table == "ERROR_NEIGH_TABLE": command = redis.build( dut, redis.ERROR_DB, "hgetall {}:{}:{}".format(table, port, kwargs.pop("nhp"))) else: st.error("Invalid table name - {}".format(table)) i = 1 while True: output = st.show(dut, command) st.debug(output) result = True for each in kwargs.keys(): if not filter_and_select(output, None, {each: kwargs[each]}): st.error("No match for {} = {} in redis cli".format( each, kwargs[each])) result = False if result == exp_result: return True if i >= iteration: return False i += 1 st.wait(1)
def verify_show_error_db_multi(dut, table, *argv, **kwargs): """ Verify multiple Error Database entries. Author : Prudvi Mangadu ([email protected]) :param : dut: :param : table: :param : result: Expected result(Default True) :param : iteration: default(30) :param : argv: list of dict arguments to verify :return: """ exp_result = kwargs.get("result", True) iteration = kwargs.get("iteration", 30) cli_type = st.get_ui_type(dut, **kwargs) if kwargs.get("interface"): intf_entry_val = kwargs.get("interface") if cli_type == "klish": if vars.config.ifname_type == "alias": intf_entry_val = st.get_other_names( vars.D1, [kwargs.get("interface")])[0] kwargs.update({"interface": intf_entry_val}) command = "show error_database" if table: command = "show error_database {}".format(table) i = 1 while True: output = st.show(dut, command) output = _get_entries_with_native_port(dut, output, **kwargs) st.debug(output) result = True for each_row in argv: row_match = filter_and_select(output, None, each_row) if not row_match: st.log("Entry not found - {}".format(', '.join( ["{}='{}'".format(k, each_row[k]) for k in each_row]))) result = False else: st.log("Entry found - {}".format(', '.join( ["{}='{}'".format(k, each_row[k]) for k in each_row]))) if result == exp_result: return True if i >= iteration: return False i += 1 st.wait(1)
def get_sbin_intf_mac(dut, interface=None): """ This proc is to return the mac address of the interface from the ifconfig o/p. :param dut: DUT Number :param interface: Interface number :return: """ if st.get_args("filemode"): return "00:00:ba:db:ad:ba" interface = interface or st.get_mgmt_ifname(dut) if '/' in interface: interface = st.get_other_names(dut, [interface])[0] my_cmd = "/sbin/ifconfig {}".format(interface) output = st.show(dut, my_cmd) output = dict(output[0]) mac = output['mac'] return mac
def dhcp_client_stop(dut, interface, pid=None, family="ipv4", skip_error_check=False, show_interface=False): """ API to stop DHCP client either by using process id or dhclient Author Chaitanya Vella ([email protected]) :param dut: :type dut: :param portlist: :type portlist: """ if interface != None: if '/' in interface: interface = st.get_other_names(dut,[interface])[0] v6_opt = "" if family == "ipv4" else "-6" command = "kill -9 {}".format(pid) if pid else "dhclient {} -r {}".format(v6_opt, interface) st.config(dut, command, skip_error_check=skip_error_check) if show_interface: get_interface_ip_address(dut, interface_name=interface, family=family) return True
def udld_clear_stats_intf(dut, **kwargs): """ Author: [email protected] udld_clear_stats_intf(dut=data.dut1,intf ='Ethernet10') Reset the UDLD stats at interface level :param dut: :param intf: :return: """ if 'intf' in kwargs: if type(kwargs['intf']) is list: kwargs['intf'] = list(kwargs['intf']) else: kwargs['intf'] = [kwargs['intf']] my_cmd = '' for intf in kwargs['intf']: if '/' in intf: intf = st.get_other_names(dut, [intf])[0] my_cmd += 'clear udld statistics {}\n'.format(intf) st.config(dut, my_cmd, type="click")
def show(dut, *argv, **kwargs): """ show commands summary Author: prudviraj k ([email protected]) :param dut: :param argv: :param interval: :param clear_interval: :param persistent_head: :param persistent_shared: :param threshold_head: :param threshold__shared: :param watermark_head: :param watermark_shared: :param port_alias: :param column_name: :param queue_value: :return: """ cli_type = st.get_ui_type(dut, **kwargs) if cli_type in ["rest-patch", "rest-put"] and 'column_name' in kwargs: cli_type = 'klish' if cli_type in ["rest-patch", "rest-put"]: for queue_type in argv: if queue_type in [ "buffer_pool_watermark", "buffer_pool_persistent-watermark", "buffer_pool_counters_DB" ]: cli_type = 'klish' persistent = "show priority-group persistent-watermark" user_watermark = "show priority-group watermark" queue_user_watermark = "show queue watermark" queue_persistent_watermark = "show queue persistent-watermark" if cli_type == 'click' or cli_type == 'klish': if "snapshot_interval" in argv: command = "show watermark interval" elif 'telemetry_interval' in argv: command = "show watermark telemetry interval" elif 'persistent_PG_headroom' in argv: command = persistent + " " + "{}".format("headroom") elif 'persistent_PG_shared' in argv: command = persistent + " " + "{}".format("shared") elif 'user_watermark_PG_headroom' in argv: command = user_watermark + " " + "{}".format("headroom") elif 'user_watermark_PG_shared' in argv: command = user_watermark + " " + "{}".format("shared") elif 'queue_user_watermark_unicast' in argv: command = queue_user_watermark + " " + "{}".format("unicast") elif 'queue_user_watermark_multicast' in argv: command = queue_user_watermark + " " + "{}".format("multicast") elif 'queue_user_watermark_cpu' in argv: command = queue_user_watermark + " " + "{}".format("CPU") elif 'queue_persistent_watermark_unicast' in argv: command = queue_persistent_watermark + " " + "{}".format("unicast") elif 'queue_persistent_watermark_multicast' in argv: command = queue_persistent_watermark + " " + "{}".format( "multicast") elif 'buffer_pool_watermark' in argv or 'percent' in kwargs: if cli_type == 'klish' and 'percent' in kwargs: perc = 'percentage' else: perc = kwargs.get('percent', '') command = "show buffer_pool watermark {}".format(perc) elif 'buffer_pool_persistent-watermark' in argv or 'percent' in kwargs: if cli_type == 'klish' and 'percent' in kwargs: perc = 'percentage' else: perc = kwargs.get('percent', '') command = "show buffer_pool persistent-watermark {}".format(perc) elif 'column_name' and 'queue_value' in kwargs: intf_name = st.get_other_names( dut, [kwargs['interface_name']])[0] if '/' in kwargs[ 'interface_name'] else kwargs['interface_name'] command = redis.build( dut, redis.COUNTERS_DB, "hget {} {}:{}".format(kwargs['column_name'], intf_name, kwargs['queue_value'])) output = st.show(dut, command) oid = output[0]['oid'].strip('"') command = redis.build( dut, redis.COUNTERS_DB, "hgetall {}:{}".format(kwargs['table_name'], oid)) output = st.show(dut, command) output = output[:-1] dut_output = get_dict_from_redis_cli(output) st.log(dut_output) return [dut_output] elif 'buffer_pool_counters_DB' in argv: command = redis.build(dut, redis.COUNTERS_DB, "Hgetall COUNTERS_BUFFER_POOL_NAME_MAP") output = st.show(dut, command) output = output[:-1] dut_output = get_dict_from_redis_cli(output) st.log(dut_output) command = redis.build( dut, redis.COUNTERS_DB, "hgetall COUNTERS:{}".format( dut_output[kwargs['oid_type']].strip('"'))) output = st.show(dut, command) output = output[:-1] dut_output = get_dict_from_redis_cli(output) st.log(dut_output) return [dut_output] if 'port_alias' in kwargs or 'percentage' in kwargs: if cli_type == 'click': command += " {} | grep -w {}".format( kwargs.get('percentage', ''), kwargs['port_alias']) return st.show(dut, command, type=cli_type) elif cli_type == 'klish': if kwargs['port_alias'] == 'CPU': command += " | grep {}".format(kwargs['port_alias']) else: interface_details = get_interface_number_from_name( kwargs['port_alias']) if 'percentage' in kwargs: using_perc = command.split(" ") using_perc.insert(-1, "percentage") command = " ".join(using_perc) command += " interface {} {}".format( interface_details.get("type"), interface_details.get("number")) else: command += " interface {} {}".format( interface_details.get("type"), interface_details.get("number")) return st.show(dut, command, type=cli_type) elif cli_type in ["rest-patch", "rest-put"]: ret_val = list() rest_urls = st.get_datastore(dut, "rest_urls") if "snapshot_interval" in argv: url = rest_urls['get_watermark_interval'] get_info = get_rest(dut, rest_url=url, timeout=60) temp = dict() temp['snapshotinterval'] = get_info['output'][ 'openconfig-qos-ext:watermark']['state']['refresh-interval'] ret_val.append(temp) st.debug(ret_val) return ret_val elif 'telemetry_interval' in argv: url = rest_urls['get_telemetry_interval'] get_info = get_rest(dut, rest_url=url, timeout=60) temp = dict() temp['telemetryinterval'] = get_info['output'][ 'openconfig-qos-ext:telemetry-watermark']['state'][ 'refresh-interval'] ret_val.append(temp) st.debug(ret_val) return ret_val for queue_type in argv: if 'port_alias' in kwargs or 'percentage' in kwargs: ret_val = list() rest_urls = st.get_datastore(dut, "rest_urls") if queue_type in [ 'queue_user_watermark_unicast', 'queue_user_watermark_multicast', 'queue_persistent_watermark_unicast', 'queue_persistent_watermark_multicast', 'queue_user_watermark_cpu' ]: url = rest_urls['get_queue_counter_values'].format( kwargs['port_alias']) get_info = get_rest(dut, rest_url=url, timeout=60) for entry in get_info['output']['openconfig-qos:queues'][ 'queue']: temp = dict() counters_info = entry['state'] port, queue = counters_info['name'].split(':') type = counters_info["openconfig-qos-ext:traffic-type"] counter = type.lower() + queue if kwargs['port_alias'] == 'CPU': cpu_counter = port + queue temp['queue'] = cpu_counter temp['bytes'] = counters_info[ "openconfig-qos-ext:watermark"] if 'percentage' in kwargs: if queue_type in [ 'queue_user_watermark_unicast', 'queue_user_watermark_multicast' ]: temp[counter] = counters_info[ "openconfig-qos-ext:watermark-percent"] elif queue_type in [ 'queue_persistent_watermark_unicast', 'queue_persistent_watermark_multicast' ]: temp[counter] = counters_info[ "openconfig-qos-ext:persistent-watermark-percent"] else: if queue_type in [ 'queue_user_watermark_unicast', 'queue_user_watermark_multicast' ]: temp[counter] = counters_info[ "openconfig-qos-ext:watermark"] elif queue_type in [ 'queue_persistent_watermark_unicast', 'queue_persistent_watermark_multicast' ]: temp[counter] = counters_info[ "openconfig-qos-ext:persistent-watermark"] ret_val.append(temp) st.debug(ret_val) return ret_val if queue_type in [ 'persistent_PG_shared', 'user_watermark_PG_shared', 'persistent_PG_headroom', 'user_watermark_PG_headroom' ]: url = rest_urls['get_pg_counter_values'].format( kwargs['port_alias']) get_info = get_rest(dut, rest_url=url, timeout=60) for entry in get_info['output'][ 'openconfig-qos-ext:priority-groups'][ 'priority-group']: temp = dict() counters_info = entry['state'] port, queue = counters_info['name'].split(':') for i in range(0, 8): if queue == str(i): counter = 'pg' + str(i) if 'percentage' in kwargs: if queue_type == 'user_watermark_PG_shared': temp[counter] = counters_info[ 'shared-watermark-percent'] elif queue_type == 'user_watermark_PG_headroom': temp[counter] = counters_info[ 'headroom-watermark-percent'] elif queue_type == 'persistent_PG_shared': temp[counter] = counters_info[ 'shared-persistent-watermark-percent'] elif queue_type == 'persistent_PG_headroom': temp[counter] = counters_info[ 'headroom-persistent-watermark-percent'] else: if queue_type == 'user_watermark_PG_shared': temp[counter] = counters_info[ 'shared-watermark'] elif queue_type == 'user_watermark_PG_headroom': temp[counter] = counters_info[ 'headroom-watermark'] elif queue_type == 'persistent_PG_shared': temp[counter] = counters_info[ 'shared-persistent-watermark'] elif queue_type == 'persistent_PG_headroom': temp[counter] = counters_info[ 'headroom-persistent-watermark'] ret_val.append(temp) st.debug(ret_val) return ret_val else: st.error("Unsupported UI Type: {} provided".format(cli_type)) return False
def config_static_ndp(dut, ip6_address, mac_address, interface, operation="add", **kwargs): """ Config static ndp Author: Chaitanya Vella ([email protected]) :param dut: :param ip6_address: :param mac_address: :param interface: :param operation: :return: """ cli_type = st.get_ui_type(dut, **kwargs) command = '' if cli_type == 'click': interface = st.get_other_names( dut, [interface])[0] if '/' in interface else interface oper = "replace" if operation == "add" else "del" command = "ip -6 neighbor {} {} lladdr {} dev {}".format( oper, ip6_address, mac_address, interface) elif cli_type == 'klish': command = list() intf = get_interface_number_from_name(interface) command.append('interface {} {}'.format(intf["type"], intf["number"])) cmd = 'ipv6 neighbor {} {}'.format( ip6_address, mac_address ) if operation == 'add' else 'no ipv6 neighbor {} {}'.format( ip6_address, mac_address) command.extend([cmd, 'exit']) elif cli_type in ['rest-patch', 'rest-put']: rest_urls = st.get_datastore(dut, 'rest_urls') port_index = get_subinterface_index(dut, interface) if operation == 'add': url = rest_urls['config_static_ndp'].format(name=interface, index=port_index) config_data = { "openconfig-if-ip:neighbor": [{ "ip": ip6_address, "config": { "ip": ip6_address, "link-layer-address": mac_address } }] } if not config_rest( dut, rest_url=url, http_method=cli_type, json_data=config_data): st.error( "Failed to configure static neighbor with IP: {} MAC: {} on INTF: {}" .format(ip6_address, mac_address, interface)) return False else: url = rest_urls['delete_static_ndp'].format(name=interface, index=port_index, ip=ip6_address) if not delete_rest(dut, rest_url=url): st.error( "Failed to delete static neighbor with IP: {} MAC: {} on INTF: {}" .format(ip6_address, mac_address, interface)) return False else: st.error("Unsupported CLI Type: {}".format(cli_type)) return False if command: st.config(dut, command, type=cli_type) return True
def gnmi_call(dut, **kwargs): """ Call to test gnmi session using diff users w.r.t RBAC. Author : Prudvi Mangadu ([email protected]) :param dut: :param kwargs: :return: """ st.log('Performing gnmi operations using - {}'.format(kwargs)) for each in ['login_type', 'username', 'password', 'mode']: if not kwargs.get(each): st.error("Mandatory argument is not found - {}".format(each)) return False dut_ip = "127.0.0.1" result = {'gnmi_get_out': True, 'gnmi_set_out': True} result2 = True username = kwargs.get('username') password = kwargs.get('password') cert = kwargs.get('cert') login_type = kwargs.get('login_type') mode = kwargs.get('mode') port = st.get_free_ports(dut)[0] if "/" in port: port = st.get_other_names(dut, [port])[0] xpath = '/openconfig-interfaces:interfaces/interface[name={}]/config/description'.format(port) json_content = {"openconfig-interfaces:description": "Eth"} if login_type == 'cred': gnmi_set_out = gnmi_set(dut, xpath, json_content=json_content, ip_address=dut_ip, username=username, password=password) st.log(gnmi_set_out) gnmi_get_out = gnmi_get(dut, xpath, ip_address=dut_ip, username=username, password=password) st.log(gnmi_get_out) elif login_type == 'cert': gnmi_set_out = gnmi_set(dut, xpath, json_content=json_content, ip_address=dut_ip, cert=cert, username=None, password=None, insecure='none', target_name='admin') st.log(gnmi_set_out) gnmi_get_out = gnmi_get(dut, xpath, ip_address=dut_ip, cert=cert, username=None, password=None, insecure='none', target_name='admin') st.log(gnmi_get_out) else: st.error("Invalid 'login_type' used = {}".format(login_type)) return False if mode == 'rw': if not (gnmi_set_out and gnmi_get_out): st.report_fail('rbac_call_fail', "gNMI", mode, login_type) else: if not (not gnmi_set_out and gnmi_get_out): st.report_fail('rbac_call_fail', "gNMI", mode, login_type) msg = 'Failed to execute set command using gNMI session with mode- {mode}, type- {login_type}' if mode == 'rw' and "op: UPDATE" not in gnmi_set_out and "description" not in str(gnmi_get_out): st.error(msg.format(**kwargs)) result2 = False if mode == 'ro' and not gnmi_set_out and "description" not in str(gnmi_get_out): st.error(msg.format(**kwargs)) result2 = False if not result2: st.report_fail('rbac_test_status', 'Fail', mode, 'gNMI', login_type, result) st.report_pass('rbac_test_status', 'Pass', mode, 'gNMI', login_type, result)
def tf_config_common_call(call_type, th_value, **kwargs): """ Common function to make both CLI and REST threshold feature calls """ result2 = 1 dut = kwargs['dut'] if call_type != "REST_CLEAR": threshold_type = kwargs['threshold_type'] buffer_type = kwargs['buffer_type'] index_name = kwargs['index_name'] port_alias = kwargs['port_alias'] index = int(re.findall(r"\d+", kwargs['index_name'])[0]) if call_type == "REST_GET" or call_type == 'REST_GET_PORTS_CHECK': st.banner("Verifying Threshold {} {} config via REST".format( threshold_type, buffer_type)) if any("/" in interface for interface in make_list(port_alias)): port_alias = st.get_other_names(vars.D1, make_list(port_alias))[0] get_rest_data = tfapi.get_threshold_rest_data( threshold_type=threshold_type, buffer_type=buffer_type, port=port_alias) rv_data = rtapi.send_rest_request(dut, tf_rest_data.feature, tf_rest_data.get_bst_thresholds, get_rest_data) if not rv_data: st.error("Failed to GET Threshold {} {} via REST".format( threshold_type, buffer_type)) return 0 if rv_data: resp = json.loads(rv_data.text) if call_type == 'REST_GET_PORTS_CHECK': st.banner("Validating interfaces in {} {} REST Data ".format( threshold_type, buffer_type)) if not check_ports_from_rest_output(resp, threshold_type, buffer_type, tf_rest_data.all_ports): result2 = 0 if result2: st.log( "--> Success: Interface Validation of {} {} REST DATA" .format(threshold_type, buffer_type)) get_value = get_threshold_from_rest_output(resp, threshold_type, buffer_type, port_alias, index) if get_value is None: return 0 st.log( "REST GET Threshold Value {} {} on Port:{}, Index:{}".format( get_value, type(get_value), port_alias, index)) st.log("Configured Threshold Value {} {}".format( th_value, type(th_value))) if not get_value == int(th_value): st.error("Failed to Verify Threshold {} {} via REST".format( threshold_type, buffer_type)) return 0 st.log("--> Success: Verifying Threshold {} {} config via REST".format( threshold_type, buffer_type)) return 1 and result2 elif call_type == "REST_SET": st.banner("Configuring Threshold {} {} via REST".format( threshold_type, buffer_type)) if any("/" in interface for interface in make_list(port_alias)): port_alias = st.get_other_names(vars.D1, make_list(port_alias))[0] set_rest_data = tfapi.set_threshold_rest_data( threshold_type=threshold_type, port_alias=port_alias, index=index, buffer_type=buffer_type, value=th_value) if not rtapi.send_rest_request(dut, tf_rest_data.feature, tf_rest_data.configure_bst_thresholds, set_rest_data): st.error("Failed to SET Threshold {} {} via REST".format( threshold_type, buffer_type)) return 0 st.log("--> Success: Configuring Threshold {} {} via REST".format( threshold_type, buffer_type)) return 1 elif call_type == 'CLI_GET': st.banner("Verifying Threshold {} {} config via CLI".format( threshold_type, buffer_type)) api_data = { 'threshold_type': threshold_type, 'buffer_type': buffer_type, 'port_alias': port_alias, index_name: th_value } if not tfapi.verify_threshold(dut, **api_data): st.error("Failed to Verify Threshold {} {} via CLI".format( threshold_type, buffer_type)) return 0 st.log("--> Success: Verifying Threshold {} {} config via CLI".format( threshold_type, buffer_type)) return 1 elif call_type == 'REST_CLEAR': st.banner("Performing Clear BST thresholds via REST") if not rtapi.send_rest_request(dut, tf_rest_data.feature, tf_rest_data.clear_bst_thresholds, {}): st.error('REST: Clear BST thresholds call failed') return 0 st.log("--> Success: Performing Clear thresholds via REST") return 1 else: st.error("Unknown tf call_type : {}".format(call_type)) return 0