def config_nat_interface(dut, **kwargs): """ Config NAT interface Author:[email protected] :param :dut: :param :config: add-del: :param :interface_name: :param :zone_value: usage: config_nat_interface(dut1, interface_name, zone_value, config="add") config_nat_interface(dut1, interface_name, config="del") """ result = False command = '' cli_type = st.get_ui_type(dut, **kwargs) skip_error_check = kwargs.get("skip_error_check", True) if cli_type not in ["klish", "click", "rest-patch", "rest-put"]: st.log("UNSUPPORTE CLI TYPE") return False if "interface_name" not in kwargs and "config" not in kwargs: st.error("Mandatory params interface_name or config not provided") return result if kwargs["config"] == "add": if "zone_value" not in kwargs: st.error("Mandatory params zone_vlaue not provided") return result if cli_type == "click": command = "config nat add interface {} -nat_zone {}".format(kwargs["interface_name"], kwargs["zone_value"]) elif cli_type == "klish": command = list() intf_data = get_interface_number_from_name(kwargs["interface_name"]) command.append("interface {} {}".format(intf_data["type"], intf_data["number"])) command.append("nat-zone {}".format(kwargs["zone_value"])) command.append("exit") elif cli_type in ["rest-patch", "rest-put"]: url = st.get_datastore(dut, "rest_urls")['config_nat_interface'].format(kwargs["interface_name"]) data = {"openconfig-interfaces-ext:nat-zone": int(kwargs["zone_value"])} config_rest(dut, http_method=cli_type, rest_url=url, json_data=data) return True if kwargs["config"] == "del": if cli_type == "click": command = "config nat remove interface {}".format(kwargs["interface_name"]) elif cli_type == "klish": command = list() intf_data = get_interface_number_from_name(kwargs["interface_name"]) command.append("interface {} {}".format(intf_data["type"], intf_data["number"])) command.append("no nat-zone") command.append("exit") elif cli_type in ["rest-patch", "rest-put"]: url = st.get_datastore(dut, "rest_urls")['del_nat_interface'].format(kwargs["interface_name"]) delete_rest(dut, rest_url=url) return True st.config(dut, command, type=cli_type, skip_error_check=skip_error_check) return True
def config_stp_vlan_interface(dut, vlan, iface, value, mode='cost', **kwargs): """ :param dut: :param vlan: :param iface: :param value: :param mode: :return: """ cli_type = kwargs.get('cli_type', 'click') no_form = 'no' if kwargs.get('no_form') else '' if mode in ['cost', 'priority']: if cli_type == 'click': command = "config spanning_tree vlan interface {} {} {} {} ".format( mode, vlan, iface, value) elif cli_type == 'klish': if mode == 'priority': mode = 'port-priority' interface_data = utils.get_interface_number_from_name(iface) command = [ 'interface {} {}'.format(interface_data["type"], interface_data["number"]), '{} spanning-tree vlan {} {} {}'.format( no_form, vlan, mode, value), "exit" ] else: st.error("Invalid CLI type - {}".format(cli_type)) return else: st.log("Invalid mode = {}".format(mode)) return st.config(dut, command, type=cli_type)
def config_port_type(dut, interface, stp_type="rpvst", port_type="edge", no_form=False, cli_type="klish"): """ API to config/unconfig the port type in RPVST :param dut: :param port_type: :param no_form: :return: """ commands = list() command = "spanning-tree port type {}".format( port_type) if not no_form else "no spanning-tree port type" interface_details = utils.get_interface_number_from_name(interface) if not interface_details: st.log("Interface details not found {}".format(interface_details)) return False commands.append("interface {} {}".format(interface_details.get("type"), interface_details.get("number"))) commands.append(command) commands.append('exit') st.config(dut, commands, type=cli_type) return True
def clear_mac_dampening(dut, **kwargs): """ Author : :param dut: :param interface: :return: usage clear_mac_dampening(dut1,interface="Ethernet0") clear_mac_dampening(dut1) """ cli_type = kwargs.get("cli_type", st.get_ui_type(dut)) if cli_type in ["click", "rest-put", "rest-patch"]: cli_type = 'klish' if cli_type == "klish": if 'interface' in kwargs: intf_data = get_interface_number_from_name(kwargs['interface']) command = "clear mac dampening-disabled-ports {} {}\n".format( intf_data["type"], intf_data["number"]) else: command = "clear mac dampening-disabled-ports all\n" elif cli_type in ["rest-put", "rest-patch"]: st.log('Needs to add rest url support') #url = st.get_datastore(dut, "rest_urls")["config_interface"] #if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=): #return False else: st.log("Unsupported CLI TYPE {}".format(cli_type)) return False if command: st.config(dut, command, type=cli_type) return True
def verify_intf_diag_loopback_cap(dut, intf, **kwargs): ''' :param ms_hs_loopback: :param pl_ms_loopback: :param pl_hs_loopback: :param hs_ip_loopback: :param hs_op_loopback: :param ms_ip_loopback: :param ms_op_loopback: ''' st.log('API: verify_intf_diag_reporting - DUT: {}, intf: {}, kwargs: {}'. format(dut, intf, kwargs)) #cli_type = kwargs.pop('cli_type', st.get_ui_type(dut,**kwargs)) kwargs.pop('cli_type', None) num_args = len(kwargs) intf_info = get_interface_number_from_name(intf) cmd = 'show interface transceiver diagnostics loopback capability {} {}'.format( intf_info['type'], intf_info['number']) cmd_output = st.show(dut, cmd, type='klish') for kv in kwargs.items(): if not filter_and_select(cmd_output, None, {kv[0]: kv[1]}): st.error('{} is not matching on {}'.format(kv[0], dut)) else: num_args -= 1 return True if num_args == 0 else False
def clear_mac(dut,port=None,vlan=None,**kwargs): """ This proc is to clear mac address/fdb entries of the dut. :param dut: DUT Number :return: """ cli_type = st.get_ui_type(dut, **kwargs) cli_type = 'klish' if cli_type in ['rest-patch', 'rest-put'] else cli_type if cli_type == "click": if not st.is_feature_supported("sonic-clear-fdb-type-command", dut): command = "sonic-clear fdb all" elif port: command = "sonic-clear fdb port {}".format(port) elif vlan: command = "sonic-clear fdb vlan Vlan{}".format(vlan) else: command = "sonic-clear fdb all" st.config(dut, command, type=cli_type) elif cli_type == "klish": if 'address' in kwargs: command = "clear mac address-table dynamic address {}".format(kwargs['address']) elif vlan: command = "clear mac address-table dynamic Vlan {}".format(vlan) elif port: intf_data = get_interface_number_from_name(port) command = "clear mac address-table dynamic interface {} {}".format(intf_data["type"],intf_data["number"]) else: command = "clear mac address-table dynamic all" st.config(dut, command,type=cli_type) else: st.error("Unsupported CLI: {}".format(cli_type)) return False return True
def config_mac(dut, mac, vlan, intf, cli_type=""): """ :param dut: :type dut: :return: :rtype: """ #st.log("config mac add <mac> <vlan> <intf>") cli_type = st.get_ui_type(dut, cli_type=cli_type) if cli_type == 'click': command = "config mac add {} {} {}".format(mac, vlan, intf) if not st.is_feature_supported("config-mac-add-command", dut): st.community_unsupported(command, dut) _json_mac_add(dut, mac, vlan, intf) else: st.config(dut, command, type='click') elif cli_type == 'klish': interface = get_interface_number_from_name(intf) command = "mac address-table {} vlan {} {} {}".format( mac, vlan, interface["type"], interface["number"]) st.config(dut, command, type=cli_type) elif cli_type in ["rest-patch", "rest-put"]: rest_urls = st.get_datastore(dut, "rest_urls") url = rest_urls['static_mac_config'] json = { "openconfig-network-instance:network-instances": { "network-instance": [{ "name": "default", "fdb": { "mac-table": { "entries": { "entry": [{ "mac-address": mac, "vlan": int(vlan), "config": { "mac-address": mac, "vlan": int(vlan) }, "interface": { "interface-ref": { "config": { "interface": intf, "subinterface": 0 } } } }] } } } }] } } if not config_rest( dut, http_method=cli_type, rest_url=url, json_data=json): return False else: st.log("Unsupported cli") return False return True
def clear_port_shaper(dut, port='', shaper_data='', **kwargs): """ API to clear shaper and detach shaper from port :param dut: :type dut: :param port: :type port: :param shaper_data: :type shaper_data: :param cli_type: :type cli_type: :return: :rtype: """ cli_type = st.get_ui_type(dut, **kwargs) skip_error = kwargs.get('skip_error', False) cli_type = 'klish' if skip_error and cli_type == 'click' else cli_type qos_clear = kwargs.get('qos_clear', False) remove_shaper = kwargs.get('remove_shaper', True) if (not qos_clear) and cli_type == 'click': cli_type = 'klish' if cli_type == 'click': clear_qos_config(dut) elif cli_type == 'klish': commands = list() if port: intf_data = get_interface_number_from_name(port) commands.append("interface {} {}".format(intf_data['type'], intf_data['number'])) commands.append("no scheduler-policy") commands.append("exit") if shaper_data and remove_shaper: commands.append("no qos scheduler-policy {}".format(shaper_data)) response = st.config(dut, commands, type=cli_type, skip_error_check=skip_error) if any(error in response.lower() for error in errors_list): st.error("The response is: {}".format(response)) return False elif cli_type in ['rest-patch', 'rest-put']: rest_urls = st.get_datastore(dut, "rest_urls") if port: url = rest_urls['policy_apply_config'].format(port) if not delete_rest(dut, rest_url=url): st.error( "Failed to remove scheduler-policy on port: {}".format( port)) return False if shaper_data and remove_shaper: url = rest_urls['scheduler_policy_config'].format(shaper_data) if not delete_rest(dut, rest_url=url): st.error("Failed to remove QOS scheduler-policy: {}".format( shaper_data)) return False else: st.error("Unsupported CLI Type: {}".format(cli_type)) return False return True
def add_static_arp(dut, ipaddress, macaddress, interface="", cli_type=""): """ To add static arp Author: Prudvi Mangadu ([email protected]) :param dut: :param ipaddress: :param macaddress: :param interface: :return: """ cli_type = st.get_ui_type(dut, cli_type=cli_type) command = '' if cli_type == "click": command = "arp -s {} {}".format(ipaddress, macaddress) if interface: command += " -i {}".format(interface) elif cli_type == "klish": if interface: intf = get_interface_number_from_name(interface) command = "interface {} {}".format(intf['type'], intf['number']) command = command + "\n" + "ip arp {} {}".format( ipaddress, macaddress) + "\n" + "exit" else: st.error( "'interface' option is mandatory for adding static arp entry in KLISH" ) return False elif cli_type in ['rest-patch', 'rest-put']: if not interface: st.error( "'interface' option is mandatory for adding static arp entry in REST" ) return False port_index = get_subinterface_index(dut, interface) rest_urls = st.get_datastore(dut, 'rest_urls') url = rest_urls['config_static_arp'].format(name=interface, index=port_index) config_data = { "openconfig-if-ip:neighbor": [{ "ip": ipaddress, "config": { "ip": ipaddress, "link-layer-address": macaddress } }] } if not config_rest( dut, rest_url=url, http_method=cli_type, json_data=config_data): st.error( "Failed to configure static ARP with IP: {}, MAC: {}, INTF: {}" .format(ipaddress, macaddress, 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 config_intf_udld_mode(dut, **kwargs): """ config_intf_udld_mode(dut=data.dut1,intf ='Ethernet10',udld_mode='yes',config='yes') config_intf_udld_mode(dut=data.dut1,intf ='Ethernet10',udld_mode='yes') config_intf_udld_mode(dut=data.dut1,intf ='Ethernet10',udld_mode='',config='no') udld.config_intf_udld_mode(dut=dut2,intf ='Ethernet37',udld_mode='yes',config='yes',cli_type='rest-put') Author: [email protected] Enable UDLD mode Aggressive at interface level :param dut: :param intf: :param udld_mode: :return: """ cli_type = kwargs.pop('cli_type', st.get_ui_type(dut)) if 'config' in kwargs: config = kwargs['config'] else: config = 'yes' if config.lower() == 'yes': config_cmd = '' else: config_cmd = 'no' if 'intf' in kwargs: if type(kwargs['intf']) is list: kwargs['intf'] = list(kwargs['intf']) else: kwargs['intf'] = [kwargs['intf']] my_cmd = '' if cli_type == 'klish' or cli_type == 'click': for intf in kwargs['intf']: intf_details = get_interface_number_from_name(intf) my_cmd += 'interface {} {}\n'.format(intf_details['type'], intf_details['number']) if 'udld_mode' in kwargs: my_cmd += '{} udld aggressive\n'.format(config_cmd) my_cmd += 'exit\n' st.config(dut, my_cmd, type='klish') elif cli_type in ['rest-patch', 'rest-put']: http_method = kwargs.pop('http_method', cli_type) rest_urls = st.get_datastore(dut, 'rest_urls') for intf in kwargs['intf']: rest_url = rest_urls['udld_interface_aggressive_config'].format( intf) if config_cmd == '': ocdata = {"openconfig-udld-ext:aggressive": bool(1)} else: ocdata = {"openconfig-udld-ext:aggressive": bool(0)} response = config_rest(dut, http_method=http_method, rest_url=rest_url, json_data=ocdata) if not response: st.log('UDLD mode for interface config/unconfig failed') st.log(response) return False return True else: st.log("Unsupported CLI TYPE - {}".format(cli_type)) return False
def show_ndp(dut, inet6_address=None, **kwargs): """ to get ndp table info Author: Chaitanya Vella ([email protected]) :param dut: :param inet6_address: :return: """ cli_type = st.get_ui_type(dut, **kwargs) if cli_type == "click": if 'vrf' not in kwargs: command = "show ndp" if inet6_address: command += " {}".format(inet6_address) elif "interface" in kwargs and kwargs["interface"]: command += " -if {}".format(kwargs["interface"]) elif 'vrf' in kwargs: vrf = kwargs['vrf'] command = "show ndp -vrf {}".format(vrf) if inet6_address: command += " {}".format(inet6_address) elif "interface" in kwargs and kwargs["interface"]: command += " -if {}".format(kwargs["interface"]) elif cli_type == "klish": if 'vrf' not in kwargs: command = "show ipv6 neighbors" if inet6_address: command += " {}".format(inet6_address) elif kwargs.get("interface"): intf = get_interface_number_from_name(kwargs.get("interface")) command += " interface {} {}".format(intf["type"], intf["number"]) elif 'vrf' in kwargs: vrf = kwargs['vrf'] command = "show ipv6 neighbors vrf {}".format(vrf) if inet6_address: command += " {}".format(inet6_address) elif cli_type in ["rest-patch", "rest-put"]: output = list() if kwargs.get('vrf'): interfaces = _get_rest_l3_interfaces(dut, vrf=kwargs['vrf']) else: interfaces = _get_rest_l3_interfaces(dut) for interface in interfaces: output.extend( _get_rest_neighbor_entries(dut, interface, is_arp=False)) st.debug(output) if inet6_address: return filter_and_select(output, None, {'address': inet6_address}) elif kwargs.get('interface'): return filter_and_select(output, None, {'interface': kwargs['interface']}) else: return output else: st.error("Unsupported CLI Type: {}".format(cli_type)) return False return st.show(dut, command, type=cli_type)
def test_ft_snmp_dot1d_base_port(): """ Author : Prasad Darnasi<*****@*****.**> Verify that the dot1dBasePort Object functions properly. Reference Test Bed : D1 --- Mgmt Network """ get_snmp_output = snmp_obj.walk_snmp_operation( ipaddress=ipaddress, oid=data.oid_dot1d_Base_Port, community_name=data.ro_community, filter=data.filter) intf_name1 = util_obj.get_interface_number_from_name(vars.D1T1P1) intf_name2 = util_obj.get_interface_number_from_name(vars.D1T1P2) if (intf_name1.get('number') not in str(get_snmp_output)) and (intf_name2.get('number') not in str(get_snmp_output)): st.report_fail("snmp_output_failed", "dot1dBasePort") st.report_pass("test_case_passed")
def delete_vlan_member(dut, vlan, port_list, participation_mode="trunk", cli_type="", skip_error_check=False): """ Delete Members in VLAN Author : Prudvi Mangadu ([email protected]) :param dut: :param vlan: :param port_list: :param participation_mode: :param cli_type: :return: """ if not cli_type: cli_type = st.get_ui_type(dut) st.log("Delete member from the VLAN") port_li = list(port_list) if isinstance(port_list, list) else [port_list] commands = list() for each_port in port_li: if cli_type == "click": command = "config vlan member del {} {}".format(vlan, each_port) out = st.config(dut, command, skip_error_check=skip_error_check) if "is not a member of Vlan{}".format(vlan) in out: st.error("{} is not a member of Vlan{}".format( each_port, vlan)) return False if "Vlan{} doesn't exist".format(vlan) in out: st.error("Vlan{} doesn't exist".format(vlan)) return False else: interface_details = get_interface_number_from_name(each_port) if not interface_details: st.log( "Interface details not found {}".format(interface_details)) return False commands.append("interface {} {}".format( interface_details.get("type"), interface_details.get("number"))) if participation_mode == "trunk": command = "switchport trunk allowed Vlan {}".format(vlan) commands.append("no {}".format(command)) elif participation_mode == "access": command = "switchport access Vlan".format(vlan) commands.append("no {}".format(command)) commands.append("exit") if commands: st.config(dut, commands, type=cli_type, skip_error_check=skip_error_check) return True
def show_arp(dut, ipaddress=None, interface=None, vrf="", cli_type=""): """ To get arp table info Author: Prudvi Mangadu ([email protected]) :param dut: :param ipaddress: :param interface: :return: """ cli_type = st.get_ui_type(dut, cli_type=cli_type) if cli_type == "click": if vrf == "": command = "show arp" if ipaddress: command += " {}".format(ipaddress) elif interface: command += " -if {}".format(interface) elif vrf != "": command = "show arp -vrf {}".format(vrf) if ipaddress: command = "show arp {}".format(ipaddress) elif interface: command = "show arp -if {}".format(interface) elif cli_type == "klish": if vrf == "": command = "show ip arp" if ipaddress: command += " {}".format(ipaddress) elif interface: intf = get_interface_number_from_name(interface) command += " interface {} {}".format(intf["type"], intf["number"]) elif vrf != "": command = "show ip arp vrf {}".format(vrf) if ipaddress: command += " {}".format(ipaddress) elif cli_type in ['rest-patch', 'rest-put']: output = list() if vrf: interfaces = _get_rest_l3_interfaces(dut, vrf=vrf) else: interfaces = _get_rest_l3_interfaces(dut) for intf in interfaces: output.extend(_get_rest_neighbor_entries(dut, intf)) st.debug(output) if ipaddress: return filter_and_select(output, None, {'address': ipaddress}) elif interface: return filter_and_select(output, None, {'iface': interface}) else: return output else: st.error("Unsupported CLI_TYPE: {}".format(cli_type)) return False return st.show(dut, command, type=cli_type)
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 config_sag_ip(dut, **kwargs): ''' Author: [email protected] :param dut: :param interface: Interface name on which SAG Gateway has to be configured. :param gateway: Gateway IP. :param mask: Mask. Default=24. :param config: Value can be <add|remove>. :param kwargs: parameters can be <interface|gateway|config|cli_type> :return: usage: config_sag_ip(dut1,interface='Vlan20', gateway="20.20.20.2", mask="24", config="add") config_sag_ip(dut1,interface='Vlan20', gateway="2002::2", mask="24", config="remove") ''' ### Parameters processing intf = kwargs.get('interface', None) gateway = kwargs.get('gateway', None) mask = kwargs.get('mask', '24') config = kwargs.get('config', 'add') cli_type = kwargs.get('cli_type', st.get_ui_type(dut)) cli_type = "klish" if cli_type in ["rest-put", "rest-patch"] else cli_type if 'interface' not in kwargs or 'gateway' not in kwargs: st.error("Mandatory parameters interface and gateway not found.") return False if cli_type == 'click': cmd = "config interface ip anycast-address {} {} {}/{}".format( config, intf, gateway, mask) output = st.config(dut, cmd) if "Missing argument" in output: st.error("Argument Missing") return False if "interface name is invalid" in output: st.error("Invalid peer interface") return False if "is not configured on interface" in output: st.error("IP is not configured") return False elif cli_type == 'klish': config = 'no ' if config == 'remove' else '' vval = get_interface_number_from_name(intf) cmd = "interface {} {}".format(vval['type'], vval['number']) type_val = 'ipv6' if ':' in gateway else 'ip' cmd = cmd + "\n" + "{}{} anycast-address {}/{}".format( config, type_val, gateway, mask) cmd = cmd + "\n" + "exit" output = st.config(dut, cmd, type="klish", conf=True) if "Could not connect to Management REST Server" in output: st.error("klish mode not working.") return False return True
def config_port_qos_map(dut, obj_name, interface, **kwargs): cli_type = st.get_ui_type(dut, **kwargs) if cli_type == 'click': final_data = dict() temp_data = dict() if not obj_name or not interface: st.log( "Please provide obj_name like 'AZURE' and interface like 'Ethernet0,Ethernet1'" ) return False else: cos_specific_dict = { "tc_to_queue_map": "[TC_TO_QUEUE_MAP|" + obj_name + "]", "dscp_to_tc_map": "[DSCP_TO_TC_MAP|" + obj_name + "]" } temp_data[interface] = cos_specific_dict final_data['PORT_QOS_MAP'] = temp_data final_data = json.dumps(final_data) st.apply_json(dut, final_data) elif cli_type == 'klish': commands = list() intf_data = get_interface_number_from_name(interface) commands.append('interface {} {}'.format(intf_data['type'], intf_data['number'])) commands.append('qos-map tc-queue {}'.format(obj_name)) commands.append('qos-map dscp-tc {}'.format(obj_name)) commands.append('exit') response = st.config(dut, commands, type=cli_type) if any(error in response.lower() for error in errors_list): st.error("The response is: {}".format(response)) return False elif cli_type in ['rest-patch', 'rest-put']: rest_urls = st.get_datastore(dut, 'rest_urls') url = rest_urls['port_qos_map_config'].format(interface) port_qos_map_data = { "openconfig-qos-maps-ext:interface-maps": { "config": { "dscp-to-forwarding-group": obj_name, "forwarding-group-to-queue": obj_name } } } if not config_rest(dut, rest_url=url, http_method=cli_type, json_data=port_qos_map_data): st.error("Failed configure PORT_QOS_MAP") return False else: st.error("Unsupported CLI Type: {}".format(cli_type)) return False return True
def config_stp_interface_params(dut, iface, **kwargs): """ :param dut: :param iface: :param cli_type: :param kwargs: :return: """ cli_type = kwargs.setdefault('cli_type', 'click') del kwargs['cli_type'] click_2_klish = { "root_guard": " guard root", "bpdu_guard": "bpduguard ", "portfast": "portfast", "uplink_fast": "uplinkfast" } if cli_type == 'click': for each_key in kwargs.keys(): if each_key == "priority" or each_key == "cost": command = "config spanning_tree interface {} {} {}".format( each_key, iface, kwargs[each_key]) elif each_key == "bpdu_guard_action": command = "config spanning_tree interface bpdu_guard enable {} {}".format( iface, kwargs[each_key]) else: command = "config spanning_tree interface {} {} {}".format( each_key, kwargs[each_key], iface) st.config(dut, command) elif cli_type == 'klish': interface_data = utils.get_interface_number_from_name(iface) command = [ 'interface {} {}'.format(interface_data["type"], interface_data["number"]) ] for each_key in kwargs.keys(): no_form = 'no' if kwargs[each_key] == 'disable' else '' if each_key == "priority" or each_key == "cost": command.append('spanning-tree {} {}'.format( each_key, kwargs[each_key])) elif each_key == "bpdu_guard_action": command.append( '{} spanning-tree bpduguard port-shutdown'.format(no_form)) else: command.append("{} spanning-tree {}".format( no_form, click_2_klish[each_key])) command.append('exit') st.config(dut, command, type=cli_type)
def clear_interface_counters(dut, **kwargs): cli_type = st.get_ui_type(dut, **kwargs) interface_name = kwargs.get("interface_name", "") interface_type = kwargs.get("interface_type", "all") if cli_type == "klish": confirm = kwargs.get("confirm") if kwargs.get("confirm") else "y" if interface_type != "all": interface_type = get_interface_number_from_name( str(interface_name)) if interface_type["type"] and interface_type["number"]: interface_val = "{} {}".format(interface_type.get("type"), interface_type.get("number")) else: interface_val = "" else: interface_val = "all" if not interface_val: st.log("Invalid interface type") return False command = "clear counters interface {}".format(interface_val) st.config(dut, command, type=cli_type, confirm=confirm, conf=False, skip_error_check=True) elif cli_type == "click": command = "show interfaces counters -c" if not st.is_feature_supported( "show-interfaces-counters-clear-command", dut): st.community_unsupported(command, dut) return st.config(dut, "sonic-clear counters") return st.show(dut, command) elif cli_type in ["rest-patch", "rest-put"]: rest_urls = st.get_datastore(dut, "rest_urls") url = rest_urls['clear_interface_counters'] clear_type = 'all' if interface_type == 'all' else interface_name clear_counters = { "sonic-interface:input": { "interface-param": clear_type } } if not config_rest( dut, http_method='post', rest_url=url, json_data=clear_counters): st.error("Failed to clear interface counters") return False else: st.log("Unsupported CLI TYPE {}".format(cli_type)) return False return True
def show(dut, interface_name=None, stc_type=None, **kwargs): """ API to show storm control configuration Author : Chaitanya Vella ([email protected]) :param dut: :param interface_name: :param stc_type: :param bits_per_sec: :return: """ cli_type = st.get_ui_type(dut, **kwargs) interface_data = utils.get_interface_number_from_name(interface_name) if cli_type == 'click': if not interface_name: command = "show storm-control all" else: command = "show storm-control interface {}".format(interface_name) return st.show(dut, command, type=cli_type) elif cli_type == 'klish': if not interface_name: command = "show storm-control" else: command = "show storm-control interface {} {}".format( interface_data["type"], interface_data["number"]) return st.show(dut, command, type=cli_type) elif cli_type in ['rest-put', 'rest-patch']: rest_urls = st.get_datastore(dut, "rest_urls") if stc_type == "unknown-multicast": stc_type = "unknown_multicast" if stc_type == "unknown-unicast": stc_type = "unknown_unicast" url = rest_urls['config_stormcontrol'].format(interface_name, stc_type.upper()) rest_get_output = get_rest(dut, rest_url=url) actual_data = rest_get_output['output'][ 'openconfig-if-ethernet-ext:config'] temp = {} output = [] temp['interface'] = actual_data['ifname'] temp['rate'] = actual_data['kbps'] stc_type = (actual_data['storm-type'].lower()) if stc_type == "unknown_multicast": stc_type = "unknown-multicast" if stc_type == "unknown_unicast": stc_type = "unknown-unicast" temp['type'] = str(stc_type) output.append(temp) return output else: st.log("invalid cli type") return False
def config_interfaces(dut, domain_id, interface_list, **kwargs): ''' Author: [email protected] :param dut: :param domain_id: Mclag domain_id :param interface_list: list of mclag interfaces (portchannels) in the dut for the given domain :param kwargs: optional parameters can be <config|cli_type> :return: usage: config_mclag_interface(dut1,10,['PortChannel001','PortChannel002']) config_mclag_interface(dut1,10,['PortChannel001','PortChannel002'],config='del') ''' ### Optional parameters processing config = kwargs.get('config', 'add') cli_type = kwargs.get('cli_type', st.get_ui_type(dut, **kwargs)) cli_type = "klish" if cli_type in ["rest-put", "rest-patch"] else cli_type if not interface_list: st.error("interfaces not found for Mclag interface configuration") return False interface_list = interface_list if isinstance(interface_list, list) else [interface_list] if cli_type == 'click': cmd = "config mclag member {} {} ".format(config, domain_id) for intf in interface_list: cmd += '{},'.format(intf) cmd = cmd.strip(',') output = st.config(dut, cmd) if "Domain doesn't exist" in output: st.error(" Mclag domain:{} doesn't exist".format(domain_id)) return False if "name should have prefix 'PortChannel' " in output: st.error(" Mclag interface has to be PortChannel") return False elif cli_type == 'klish': cmd = '' config = 'no ' if config == 'del' else '' for intf in interface_list: pintf = get_interface_number_from_name(intf) cmd = cmd + "\n" + "interface {} {}".format( pintf['type'], pintf['number']) cmd = cmd + "\n" + "{}mclag {}".format(config, domain_id) cmd = cmd + "\n" + "exit" output = st.config(dut, cmd, type="klish", conf=True) if "Could not connect to Management REST Server" in output: st.error("klish mode not working.") return False return True
def test_ft_snmp_dot1q_tp_fdb_port(): """ Author : Prasad Darnasi<*****@*****.**> Verify that the dot1qTpFdbPort Object functions properly. Reference Test Bed : D1 --- Mgmt Network """ get_snmp_output = snmp_obj.walk_snmp_operation( ipaddress=ipaddress, oid=data.oid_dot1q_Tp_Fdb_Port, community_name=data.ro_community) intf_name = util_obj.get_interface_number_from_name(vars.D1T1P2) if intf_name.get('number') not in get_snmp_output[0]: st.report_fail("snmp_output_failed", "dot1qTpFdbPort") st.report_pass("test_case_passed")
def get_mac(dut, **kwargs): """ :param dut: :type dut: :return: :rtype: """ cli_type = st.get_ui_type(dut, **kwargs) if cli_type == "click": return st.show(dut, "show mac") elif cli_type == "klish": response = dict() attrs = ["address", "interface", "type", "vlan", "count"] command = "show mac address-table" if kwargs.get("count"): command += " count" output = st.show(dut, command, type=cli_type) if output: for data in output: for key, value in data.items(): if value: response[key] = value return response else: for attr in attrs: if kwargs.get(attr): if attr not in ["type", "count"]: if attr == "interface": interface_number = get_interface_number_from_name( kwargs.get(attr)) if interface_number: command += " {} {} {}".format( attr, interface_number["type"], interface_number["number"]) else: command += " {} {}".format(attr, kwargs.get(attr)) else: command += " {}".format(kwargs.get(attr)) return st.show(dut, command, type=cli_type) elif cli_type in ["rest-patch", "rest-put"]: network_instance_name = 'default' rest_urls = st.get_datastore(dut, "rest_urls") url = rest_urls['all_mac_entries'].format(network_instance_name) output = get_rest(dut, rest_url=url) rest_get_output = processed_output_based_macentries(output) return rest_get_output else: st.log("Invalid cli type") return False
def config_bpdu_filter(dut, **kwargs): """ API to config BPDU filter for global and interface level Usage: ====== Interface level config: ========================= config_bpdu_filter(dut, interface="Ethernet8", action="enable", cli_type="klish") config_bpdu_filter(dut, interface="Ethernet8", no_form=True, cli_type="klish") Global level config: ==================== config_bpdu_filter(dut, cli_type="klish") config_bpdu_filter(dut, ,no_form=True, cli_type="klish") :param dut: :param kwargs: :return: """ cli_type = kwargs.get("cli_type", "klish") interface = kwargs.get("interface", None) no_form = kwargs.get("no_form", None) action = kwargs.get("action", "enable") commands = list() if not interface: command = "spanning-tree edge-port bpdufilter default" if no_form: command = "no {}".format(command) commands.append(command) else: interface_details = utils.get_interface_number_from_name(interface) if not interface_details: st.log("Interface details not found {}".format(interface_details)) return False commands.append("interface {} {}".format( interface_details.get("type"), interface_details.get("number"))) command = "spanning-tree bpdufilter" if no_form: command = "no {}".format(command) elif action: command = "{} {}".format(command, action) else: command = "" if command: commands.append(command) if commands: st.config(dut, commands, type=cli_type) return True return False
def get_arp_count(dut, ipaddress=None, interface=None, cli_type="", **kwargs): """ To get arp count Author: Prudvi Mangadu ([email protected]) :param dut: :param ipaddress: :param interface: :return: """ cli_type = st.get_ui_type(dut, cli_type=cli_type) if cli_type == "click": command = "show arp" if ipaddress: command += " {}".format(ipaddress) if interface: command += " -if {}".format(interface) command += " | grep 'Total number of entries'" elif cli_type == "klish": command = "show ip arp" if interface: intf = get_interface_number_from_name(interface) command += " interface {} {}".format(intf["type"], intf["number"]) if 'vrf' in kwargs: command += " vrf {}".format(kwargs["vrf"]) if ipaddress: st.log("Unsupported attribute ipaddress") return 0 command += " summary" elif cli_type in ["rest-patch", "rest-put"]: show_arp(dut, ipaddress=None, interface=None, vrf="", cli_type="") if interface: out = show_arp(dut, interface=interface, cli_type=cli_type) if 'vrf' in kwargs: out = show_arp(dut, vrf=kwargs['vrf'], cli_type=cli_type) if ipaddress: out = show_arp(dut, ipaddress=ipaddress, cli_type=cli_type) if not (interface and kwargs.get('vrf') and ipaddress): out = show_arp(dut, cli_type=cli_type) return len(out) else: st.error("Unsupported CLI_TYPE: {}".format(cli_type)) return False output = st.show(dut, command, type=cli_type) out = dicts_list_values(output, 'count') return int(out[0]) if out else 0
def config_access_group(dut, **kwargs): """ API to map interface to Access-list Author : Pradeep Bathula ([email protected]) :param dut: :type dut: :param cli_type: :type cli_type:klish :param table_name: :type table_name: :param port: :type interface: :param access_group_action: :type access_group_action:in|out :return: """ cli_type = kwargs.get("cli_type", "klish") table_name = kwargs.get("table_name", None) port = kwargs.get("port", None) access_group_action = kwargs.get("access_group_action", None) skip_error_check = kwargs.get("skip_error_check", True) config = kwargs.get("config", "yes") mode = "" if config == "yes" else "no " st.log("Assigning Access-group action on interface") if not cli_type == "klish": st.log("Unsupported CLI type {} provided, required klish".format( cli_type)) return False if not (table_name and port and access_group_action and config): st.log( "Mandatory parameters like table_name and/or port and/or access_group_action and/or config not passed" ) return False interface_details = util_obj.get_interface_number_from_name(port) commands = list() commands.append("interface {} {}".format(interface_details.get("type"), interface_details.get("number"))) commands.append("{}ip access-group {} {}".format(mode, table_name, access_group_action)) commands.append("exit") st.config(dut, commands, type=cli_type, skip_error_check=skip_error_check) return True
def show_interface_transceiver(dut, mode, interface=None, cli_type=""): """ API to get the interface transceiver eeprom details Author: Chaitanya Vella ([email protected]) :param dut: :param mode: eeprom , presence :param interface: :return: """ cli_type = st.get_ui_type(dut, cli_type=cli_type) if mode not in ["eeprom", "presence"]: st.log("Unsupported modes provided ...") return False if cli_type == "click": command = "show interface transceiver {}".format(mode) if interface: command = "show interface transceiver {} | grep -w {}".format(mode, interface) return st.show(dut, command) elif cli_type == "klish": if interface: intf_data = utils.get_interface_number_from_name(interface) command = "show interface transceiver {} {}".format(intf_data['type'], intf_data['number']) else: command = "show interface transceiver" output = st.show(dut, command, type=cli_type) for i in range(len(output)): if output[i]['presence'] == "PRESENT": output[i]['presence'] = "Present" output[i]['eeprom_status'] = "SFP EEPROM detected" else: output[i]['presence'] = "Not present" output[i]['eeprom_status'] = "SFP EEPROM Not detected" elif cli_type in ["rest-patch", "rest-put"]: rest_urls = st.get_datastore(dut, "rest_urls") url1 = rest_urls['get_fan_psu'] data = get_rest(dut, rest_url=url1)["output"] output = _get_transceiver_data(data) if interface: output = filter_and_select(output, match={"port": interface}) else: st.error("Unsupported CLI Type provided: {}".format(cli_type)) return [] return output
def config_intf_diagnostics(dut, intf, mode, **kwargs): ''' :param dut: :param intf: :param feature: value: loopback (default) :param mode: value: <media-side-output|media-side-input|host-side-output|host-side-input> :param action: value: <enable|disable>, default is enable :param skip_error: :return: :mode : import apis.system.cmis as cmis_api cmis_api.config_intf_diagnostics(dut=data.dut1, intf='Ethernet17', mode='media-side-input') cmis_api.config_intf_diagnostics(dut=data.dut1, intf='Ethernet17', mode='media-side-input',action='disable') ''' st.log( 'API: config_intf_diagnostics - DUT: {}, intf: {}, mode: {}, kwargs: {}' .format(dut, intf, mode, kwargs)) feature = kwargs.get('feature', 'loopback') action = kwargs.get('action', 'enable') skip_error = kwargs.get('skip_error', False) #cli_type = kwargs.pop('cli_type', st.get_ui_type(dut,**kwargs)) intf_info = get_interface_number_from_name(intf) cmd = 'interface diagnostics {} {} {} {} {}'.format( feature, intf_info['type'], intf_info['number'], mode, action) try: st.config(dut, cmd, skip_error_check=skip_error, type="klish", conf=True) except Exception as e: st.log(e) return False return True
def config_uniqueip(dut, skip_error=False, **kwargs): ''' Configures< unique-ip add | del> vlan for Mclag Author: [email protected] :param dut: :param kwargs: optional parameters can be <op_type|vlan|cli_type> :return: Usage: config_uniqueip(dut1, op_type='add', vlan='Vlan10') config_uniqueip(dut1, op_type='del', vlan='Vlan10') ''' ### Optional parameters processing type_val = kwargs.get('op_type', None) vlan_val = kwargs.get('vlan', None) cli_type = kwargs.get('cli_type', st.get_ui_type(dut, **kwargs)) if cli_type == 'click': cmd = "" if 'op_type' in kwargs and 'vlan' in kwargs: cmd += "config mclag unique-ip {} {}\n".format(type_val, vlan_val) output = st.config(dut, cmd) if "configure mclag domain first" in output: st.error("Domain_id doesn't exist") return False elif cli_type == 'klish': if 'op_type' in kwargs and 'vlan' in kwargs: vval = get_interface_number_from_name(vlan_val) cmd = "interface {} {}".format(vval['type'], vval['number']) type_val = 'no ' if type_val == 'del' else '' cmd = cmd + "\n" + "{}mclag-separate-ip".format(type_val) cmd = cmd + "\n" + "exit" output = st.config(dut, cmd, type="klish", conf=True, skip_error_check=skip_error) if "Could not connect to Management REST Server" in output: st.error("klish mode not working.") return False return True
def bind_qos_map(dut, intf_name,config="yes",**kwargs): """ purpose: This definition is used to bind QOS map to an interface Arguments: :param dut: device to be configured :type dut: string :param intf_name: interface name to be binded with qos map :type intf_name: string :param config: whether to configure or delete :type config: string :param map_type: qos map type like dscp-tc, dot1p-tc etc :type map_type: string :param map_name: qos map name :type map_name: string :return: None/False; False for unsupported UI type usage: bind_qos_map(dut1,"Ethernet15",map_type="dscp-tc",map_name="dscpToTc") bind_qos_map(dut1,"PortChannel12",map_type="dscp-tc",map_name="dscpToTc") bind_qos_map(dut1,"PortChannel12",config="no",map_type="dscp-tc") Created by: Julius <[email protected] """ cli_type = st.get_ui_type(dut, **kwargs) cli_type = "klish" if cli_type in ["rest-put", "rest-patch"] else cli_type if cli_type == "klish": intf_details = get_interface_number_from_name(intf_name) cmd = "interface {} {} \n".format(intf_details["type"],intf_details["number"]) if config.lower() == "yes": if "map_type" in kwargs and "map_name" in kwargs: cmd += "qos-map {} {} \n".format(kwargs["map_type"],kwargs["map_name"]) else: if "map_type" in kwargs: cmd += "no qos-map {} \n".format(kwargs["map_type"]) cmd += "exit" else: st.log("support for UI type {} yet to be added".format(cli_type)) return False return st.config(dut, cmd, type=cli_type)