def delete_mac(dut, mac, vlan, cli_type=""): """ :param dut: :type dut: :return: :rtype: """ #st.log("config mac del <mac> <vlan>") cli_type = st.get_ui_type(dut, cli_type=cli_type) if cli_type == 'click': command = "config mac del {} {}".format(mac, vlan) if not st.is_feature_supported("config-mac-add-command", dut): st.community_unsupported(command, dut) _json_mac_del(dut, mac, vlan) else: st.config(dut, command, type=cli_type) elif cli_type == 'klish': command = "no mac address-table {} vlan {}".format(mac, vlan) st.config(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['mac_entry_based_vlan_interface'].format( network_instance_name, mac, vlan) delete_rest(dut, rest_url=url) 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 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 clear_radius_statistics(dut, skip_error_check=False, cli_type=""): cli_type = st.get_ui_type(dut, cli_type=cli_type) if cli_type in ['click', 'klish']: command = "sonic-clear radius" st.config(dut, command, skip_error_check=skip_error_check) elif cli_type in ["rest-patch", "rest-put"]: rest_urls = st.get_datastore(dut, "rest_urls") url = rest_urls['radius_statistics'].format("RADIUS") delete_rest(dut, rest_url=url, get_response=True) else: st.log("UNSUPPORTED CLI TYPE") return False return True
def reset_port_shaper_params(dut, policy_name, params_list, **kwargs): """ API to reset Port-Level shaper parameters :param dut: :type dut: :param policy_name: :type policy_name: :param params_list: :type params_list: :return: :rtype: """ cli_type = st.get_ui_type(dut, **kwargs) cli_type = 'klish' if cli_type == 'click' else cli_type skip_error = kwargs.get('skip_error', False) params_list = [param.lower() for param in make_list(params_list)] if cli_type == 'klish': commands = list() commands.append("qos scheduler-policy {}".format(policy_name)) commands.append("port") commands.extend(["no {}".format(param) for param in params_list]) commands.extend(["exit", "exit"]) 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') for param in params_list: if param.lower() not in ['pir', 'pbs']: st.error('Invalid port shaper parameter: {}'.format(param)) return False if param == 'pir': url = rest_urls['shaper_pir_config'].format(policy_name, 255) if not delete_rest(dut, rest_url=url): st.error("Failed to reset {} for port shaper profile: {}". format(param, policy_name)) return False if param == 'pbs': url = rest_urls['shaper_pbs_config'].format(policy_name, 255) if not delete_rest(dut, rest_url=url): st.error("Failed to reset {} for port shaper profile: {}". format(param, policy_name)) return False else: st.error("Unsupported CLI Type: {}".format(cli_type)) return False return True
def delete_ntp_servers(dut, cli_type=''): """ :param dut: :param iplist: :return: """ cli_type = st.get_ui_type(dut, cli_type=cli_type) output = show_ntp_server(dut) commands = [] if output is None: st.log("No servers to delete") return True else: for ent in iterable(output): server_ip = ent["remote"].strip("+*#o-x").strip() if cli_type == "click": commands.append("config ntp del {}".format(server_ip)) elif cli_type == "klish": commands.append("no ntp server {}".format(server_ip)) elif cli_type in ['rest-patch', 'rest-put']: rest_urls = st.get_datastore(dut, "rest_urls") url1 = rest_urls['config_ntp_server'].format(server_ip) if not delete_rest(dut, rest_url=url1): st.error("Failed to delete ntp {} server".format(server_ip)) else: st.log("UNSUPPORTED CLI TYPE -- {}".format(cli_type)) return False st.config(dut, commands, type=cli_type) return True
def set_crm_clear_config(dut, cli_type=""): """ API to clear CRM configuration. Author : Prudvi Mangadu ([email protected]) :param dut: :param cli_type: click or klish designation: :return: Command output """ cli_type = st.get_ui_type(dut, cli_type=cli_type) if cli_type == "click": command = "crm config clear" if not st.is_feature_supported("crm-config-clear-command", dut): st.community_unsupported(command, dut) command = "crm config polling interval 9999999" elif cli_type == "klish": command = "no crm all" elif cli_type in ["rest-patch", "rest-put"]: rest_urls = st.get_datastore(dut, "rest_urls") url = rest_urls['crm_all'] if not delete_rest(dut, rest_url=url): return False return True else: st.error("Unsupported cli type: {}".format(cli_type)) return False return st.config(dut, command, type=cli_type)
def set_crm_nothresholds(dut, cli_type=""): """ Set no thresholds (default). :param dut: :param cli_type: click or klish designation: :return: """ cli_type = st.get_ui_type(dut, cli_type=cli_type) command = "" if cli_type == "click": command = "crm config clear" elif cli_type == "klish": command = "no crm thresholds all" elif cli_type in ["rest-patch", "rest-put"]: rest_urls = st.get_datastore(dut, "rest_urls") url = rest_urls['crm_thresholds'] if not delete_rest(dut, rest_url=url): return False else: st.error("Unsupported cli type: {}".format(cli_type)) return False if command: rv = st.config(dut, command, type=cli_type) if 'Error' in rv: st.error("{}".format(rv)) return False return True
def delete_vlan(dut, vlan_list, cli_type=''): cli_type = st.get_ui_type(dut, cli_type=cli_type) """ To delete list of VLANs. Author : Prudvi Mangadu ([email protected]) :param dut: :param vlan_list: :param cli_type: :return: """ st.log("Delete vlan") vlan_li = map(str, vlan_list) if isinstance(vlan_list, list) else [vlan_list] commands = list() rest_fail_status = False try: for each_vlan in vlan_li: if cli_type == "click": commands.append("config vlan del {}".format(each_vlan)) elif cli_type == "klish": commands.append("no interface Vlan {}".format(each_vlan)) elif cli_type in ["rest-put", "rest-patch"]: rest_url = st.get_datastore( dut, "rest_urls")["per_interface_details"].format( "Vlan{}".format(each_vlan)) output = delete_rest(dut, rest_url=rest_url, get_response=True) if not output: st.error("OUTPUT IS EMPTY FROM DELETE VLAN REST CALL") return False st.log("STATUS: {}".format(output["status"])) if not rest_status(output["status"]): rest_fail_status = True else: st.log("Unsupported CLI type") return False if rest_fail_status: st.log("One of VLAN DELETE REST call failed") return False if commands: response = st.config(dut, commands, skip_error_check=True, type=cli_type) if "Error" in response: st.log(response) return False else: vlan_list = get_vlan_list(dut, cli_type=cli_type) for each_vlan in vlan_li: if each_vlan in vlan_list: st.error(" Vlan{} is not deleted".format(each_vlan)) return False return True except Exception as e1: st.log(e1) st.error(" Vlan is not deleted due to other reasons") return False
def config_mclag_system_mac(dut, skip_error=False, **kwargs): ''' Configures< mclag system-mac <add|del> <domain-id> mac > for Mclag Author: [email protected] :param dut: :param kwargs: optional parameters can be <config|domain_id|mac|cli_type> :return: Usage: config_mclag_system_mac(dut1, domain_id= 1, config='add', mac='xx:xx:xx:xx:xx:xx') config_mclag_system_mac(dut1, domain_id= 1, config='del') ''' ### Optional parameters processing config = kwargs.get('config', 'add') if config == 'add' and 'mac' not in kwargs: st.error("Mandatory parameter mac address not found for config = add") return False if 'domain_id' not in kwargs: st.error("Mandatory parameter domain_id not found") return False mac_val = kwargs.get('mac') domain_id = kwargs.get('domain_id') cli_type = kwargs.get('cli_type', st.get_ui_type(dut, **kwargs)) mac_val = '' if config == 'del' else mac_val if cli_type == 'click': cmd = "config mclag system-mac {} {} {}\n".format( config, domain_id, mac_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': config = 'no' if config == 'del' else '' cmd = "mclag domain {} \n{} mclag-system-mac {}".format( domain_id, config, mac_val) 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 elif cli_type in ["rest-patch", "rest-put"]: rest_urls = st.get_datastore(dut, 'rest_urls') url = rest_urls['mclag_config_mclag_system_mac'].format(int(domain_id)) if config == "add": payload = {"openconfig-mclag:mclag-system-mac": mac_val} if not config_rest( dut, http_method=cli_type, rest_url=url, json_data=payload): return False else: if not delete_rest(dut, rest_url=url): return False else: st.log("Invalid cli_type provided: {}".format(cli_type)) return False return True
def config(dut, **kwargs): cli_type = st.get_ui_type(dut, **kwargs) """ API to create Mgmt VRF. Author : Kiran Vedula ([email protected]) :param :dut: :param :mgmtvrf: :param :cli_type: default - klish :param :no_form: default - False :return: Usage: config(vars.D1, cli_type='klish') config(vars.D1, no_form=True,cli_type='klish') """ no_form = "no" if kwargs.get("no_form") else "" command_list = [] if cli_type == 'klish': if not no_form: command_list.append("ip vrf mgmt") st.config(dut, command_list, type=cli_type, expect_ipchange=True) else: command_list.append("no ip vrf mgmt") st.config(dut, command_list, type=cli_type, expect_ipchange=True) elif cli_type == "click": st.log('Config Mgmt VRF API') if no_form != 'no': my_cmd = 'sudo config vrf add mgmt' else: my_cmd = 'sudo config vrf del mgmt' st.config(dut, my_cmd, type=cli_type) elif cli_type in ["rest-patch", "rest-put"]: rest_urls = st.get_datastore(dut, "rest_urls") if no_form != 'no': url = rest_urls['config_mgmt_vrf'].format("mgmt") config_data = { "openconfig-network-instance:config": { "enabled": True, "name": "mgmt" } } if not config_rest( dut, http_method=cli_type, rest_url=url, json_data=config_data): return False else: url = rest_urls['unconfig_mgmt_vrf'].format("mgmt") if not delete_rest(dut, rest_url=url): return False else: st.error("Unsupported cli_type: {}".format(cli_type)) return False return True
def set_tacacs_properties(dut, property, value, cli_type="", **kwargs): ''' Configuring tacacs properties. ''' cli_type = st.get_ui_type(dut, cli_type=cli_type) property_mapping = { "authtype": "auth-type", "passkey": "key", "timeout": "timeout", "sourceip": "host", "source-interface": "source-interface" } if cli_type == "click": command = "config tacacs {} {}".format(property, value) st.config(dut, command, type=cli_type) elif cli_type == "klish": if property != "default": property = property_mapping[property] command = "tacacs-server {} {}".format(property, value) else: property = property_mapping[value] command = "no tacacs-server {}".format(property) st.config(dut, command, type=cli_type) elif cli_type in ['rest-put', 'rest-patch']: rest_urls = st.get_datastore(dut, "rest_urls") property_mapping = { "authtype": "openconfig-system-ext:auth-type", "passkey": "openconfig-system-ext:secret-key", "timeout": "openconfig-system-ext:timeout" } url_mapping = { "authtype": "tacacs_global_authtype_config", "passkey": "tacacs_global_passkey_config", "timeout": "tacacs_global_timeout_config" } if property != 'default': url = rest_urls[url_mapping[property]].format("TACACS") data = {property_mapping[property]: value} if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=data, timeout=time_out, **kwargs): st.error("Failed to configure tacacs global params") return False else: url = rest_urls[url_mapping[value]].format("TACACS") if not delete_rest(dut, rest_url=url, timeout=time_out, **kwargs): st.error("Failed to delete tacacs global params") return False else: st.log("UNSUPPORTED CLI TYPE -- {}".format(cli_type)) return False return True
def config_udld_multiplier(dut, **kwargs): """ Author: [email protected] config_udld_multiplier(dut=data.dut1,udld_multiplier='4',config='yes') config_udld_multipier(dut=data.dut1,udld_multiplier='4') config_udld_multipier(dut=data.dut1,udld_multiplier='4',config='no') udld.config_udld_multiplier(dut=dut1,udld_multiplier='3',config='yes',cli_type='rest-put') Configure udld multipllier globally :param dut: :param udld_multipier: :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' udld_multiplier = kwargs.get('udld_multiplier', None) if cli_type == 'klish' or cli_type == 'click': if 'udld_multiplier' in kwargs: my_cmd = '{} udld multiplier {} \n'.format( config_cmd, kwargs['udld_multiplier']) 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') rest_url = rest_urls['udld_multiplier_config'] ocdata = { "openconfig-udld-ext:multiplier": int(kwargs['udld_multiplier']) } if config_cmd == '' and udld_multiplier != None: response = config_rest(dut, http_method=http_method, rest_url=rest_url, json_data=ocdata) else: response = delete_rest(dut, http_method='delete', rest_url=rest_url, json_data=ocdata) if not response: st.log('UDLD global message time config/unconfig failed') st.log(response) return False return True else: st.log("Unsupported CLI TYPE - {}".format(cli_type)) return False
def enable_ssh_in_user_vrf(dut, **kwargs): """ To enable SSH-in over user defined VRF :param dut: :param kwargs: :return: Usage:enable_ssh_in_user_vrf(vars.D1, config='add',vrf_name='mgmt') """ cli_type = st.get_ui_type(dut, **kwargs) st.log(" Configure SSH-in for user VRF") if not kwargs.get('vrf_name'): st.error("Mandatory arguments are missing.") return False if kwargs.get('config') not in ['add', 'del']: st.error("Incorrect config type") return False if cli_type == "click": command = "config ssh-server vrf {} {}".format(kwargs.get('config'), kwargs.get('vrf_name')) st.config(dut, command, type=cli_type, skip_error_check=True) elif cli_type == "klish": config = "no " if kwargs.get('config') == "del" else "" command = "{}ssh-server vrf {}".format(config, kwargs.get('vrf_name')) st.config(dut, command, type=cli_type, skip_error_check=True) elif cli_type in ["rest-patch","rest-put"]: rest_urls = st.get_datastore(dut, "rest_urls") url = rest_urls['config_ssh_server'].format(kwargs.get('vrf_name')) ssh_config={"openconfig-system-ext:ssh-server-vrf":[{"vrf-name": kwargs.get('vrf_name'),"config":{ "vrf-name": kwargs.get('vrf_name'),"port": 22}}]} if kwargs.get('config') == 'add': if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=ssh_config): st.error("ssh server configuration failed") return False else: if not delete_rest(dut, rest_url=url): st.error("ssh server deletion failed") return False else: st.error("Unsupported cli_type: {}".format(cli_type)) return False return True
def delete_session(dut, mirror_session='', skip_err_check=False, cli_type=""): cli_type = st.get_ui_type(dut, cli_type=cli_type) ''' :param dut: :param mirror_session: :return: ''' if not mirror_session: st.error("Mirror session name not provided ...") return False if cli_type == "click": command = "config mirror_session remove {}".format(mirror_session) st.config(dut, command, skip_error_check=skip_err_check) return True if show_session(dut, mirror_session) else False elif cli_type == "klish": commands = list() command = "no mirror-session {}".format(mirror_session) commands.append(command) output = st.config(dut, commands, type=cli_type, skip_error_check=skip_err_check) st.config(dut, "exit", type=cli_type) output = remove_last_line_from_string(output) if output: if "Failed" not in output or "Error" not in output: return False return True elif cli_type in ['rest-put', "rest-patch"]: rest_urls = st.get_datastore(dut, "rest_urls") url = rest_urls['get_session_session_name'].format(mirror_session) if not delete_rest(dut, rest_url=url): return False return True else: st.log("Unsupported cli") return False
def set_tacacs_server(dut, mode, address, tcp_port=None, timeout=None, passkey=None, auth_type=None, priority=None, use_mgmt_vrf=False, cli_type="", **kwargs): ''' Configuring tacacs server properties. ''' cli_type = st.get_ui_type(dut, cli_type=cli_type) if cli_type == "click": sub_opts = [] if mode.lower() == 'add': command = "config tacacs {} {} ".format('add', address) if tcp_port: sub_opts.append('{} {}'.format('-o', tcp_port)) if timeout: sub_opts.append('{} {}'.format('-t', timeout)) if passkey: sub_opts.append('{} {}'.format('-k', passkey)) if auth_type: sub_opts.append('{} {}'.format('-a', auth_type)) if priority: sub_opts.append('{} {}'.format('-p', priority)) if use_mgmt_vrf: sub_opts.append('{}'.format('-m')) command = command + ' '.join(sub_opts) elif mode.lower() == 'delete': command = "config tacacs {} {} ".format('delete', address) st.config(dut, command, type=cli_type) elif cli_type == "klish": no_form = "no" if mode.lower() == "delete" else "" if not no_form: command = "tacacs-server host {}".format(address) if timeout: command += " timeout {}".format(timeout) if passkey: command += " key {}".format(passkey) if auth_type: command += " type {}".format(auth_type) if tcp_port: command += " port {}".format(tcp_port) if priority: command += " priority {}".format(priority) if use_mgmt_vrf: command += " vrf mgmt" else: command = "{} tacacs-server host {}".format(no_form, address) st.config(dut, command, type=cli_type) elif cli_type in ["rest-patch", "rest-put"]: rest_urls = st.get_datastore(dut, "rest_urls") if mode.lower() == 'add': url = rest_urls['tacacs_authtype_config'] data = { "openconfig-system:server-group": [{ "name": "TACACS", "config": { "name": "TACACS", "openconfig-system-ext:auth-type": str(auth_type), "openconfig-system-ext:secret-key": str(passkey), "openconfig-system-ext:timeout": int(timeout) }, "servers": { "server": [{ "address": str(address), "config": { "name": "TACACS", "address": str(address), "timeout": int(timeout), "openconfig-system-ext:auth-type": str(auth_type), "openconfig-system-ext:priority": int(priority) }, "tacacs": { "config": { "port": int(tcp_port), "secret-key": str(passkey) } } }] } }] } if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=data, timeout=time_out, **kwargs): st.error("Failed to configure auth_type for {} server".format( address)) return False if use_mgmt_vrf: url = rest_urls['tacacs_vrf_config'].format('TACACS', address) data = {"openconfig-system-ext:vrf": "mgmt"} if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=data, timeout=time_out, **kwargs): st.error("Failed to configure VRF for {} server".format( address)) return False if mode.lower() == 'delete': url = rest_urls['delete_tacacs_server'].format('TACACS', address) if not delete_rest(dut, rest_url=url, timeout=time_out, **kwargs): st.error('Failed to delete the server {}'.format(address)) return False else: st.log("UNSUPPORTED CLI TYPE -- {}".format(cli_type)) return False return True
def config_snapshot_interval(dut, **kwargs): """ configuring the water mark intervals Author: prudviraj k ([email protected]) :param dut: :param kwargs: Needed arguments to update the watermark configuration :return: """ snapshot_arg = kwargs cli_type = st.get_ui_type(dut, **kwargs) if cli_type in ["rest-patch", "rest-put"] and snapshot_arg['snap'] in [ "clear_buffer-pool watermark", "sonic-clear buffer-pool watermark" ]: cli_type = 'klish' if not snapshot_arg: st.error("Mandatory arguments are not given") if cli_type == "click": if snapshot_arg['snap'] == "interval": command = "config watermark interval {}".format( snapshot_arg['interval_val']) elif snapshot_arg['snap'] == "telemetry": command = "config watermark telemetry interval {}".format( snapshot_arg['interval_val']) elif snapshot_arg['snap'] == "clear_snaphot_interval": command = "sonic-clear watermark interval" elif snapshot_arg['snap'] == "clear_snapshot_counters": command = "sonic-clear {} {} {}".format( snapshot_arg['group'], snapshot_arg['table'], snapshot_arg['counter_type']) elif snapshot_arg['snap'] == "clear_buffer-pool watermark": command = "sonic-clear buffer-pool watermark" elif snapshot_arg['snap'] == "clear_buffer-pool persistent-watermark": command = "sonic-clear buffer-pool persistent-watermark" st.config(dut, command, type=cli_type) return True elif cli_type == "klish": if snapshot_arg['snap'] == "interval": command = "watermark interval {}".format( snapshot_arg['interval_val']) elif snapshot_arg['snap'] == "telemetry": command = "watermark telemetry interval {}".format( snapshot_arg['interval_val']) elif snapshot_arg['snap'] == "clear_snaphot_interval": command = "no watermark interval" elif snapshot_arg['snap'] == "clear_snapshot_counters": command = "clear {} {} {}".format(snapshot_arg['group'], snapshot_arg['table'], snapshot_arg['counter_type']) elif snapshot_arg['snap'] == "clear_buffer-pool watermark": command = "clear buffer_pool watermark" elif snapshot_arg['snap'] == "clear_buffer-pool persistent-watermark": command = "clear buffer_pool persistent-watermark" st.config(dut, command, type=cli_type) return True elif cli_type in ["rest-patch", "rest-put"]: rest_urls = st.get_datastore(dut, "rest_urls") if snapshot_arg['snap'] == "interval": url = rest_urls['config_watermark_interval'] data = { "openconfig-qos-ext:refresh-interval": snapshot_arg['interval_val'] } if not config_rest( dut, http_method=cli_type, rest_url=url, json_data=data): return False elif snapshot_arg['snap'] == "telemetry": url = rest_urls['config_telemetry_interval'] data = { "openconfig-qos-ext:refresh-interval": snapshot_arg['interval_val'] } if not config_rest( dut, http_method=cli_type, rest_url=url, json_data=data): return False elif snapshot_arg['snap'] == "clear_snaphot_interval": url = rest_urls['config_watermark_interval'] if not delete_rest(dut, http_method='delete', rest_url=url): return False elif snapshot_arg['snap'] == "clear_snapshot_counters": url = rest_urls['clear_watermark_counters'] data = { "openconfig-qos-ext:input": { "buffer": snapshot_arg['group'], "buffer-type": snapshot_arg['counter_type'], "watermark-type": snapshot_arg['table'] } } if not config_rest( dut, http_method='post', rest_url=url, json_data=data): return False return True 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 delete_static_arp(dut, ipaddress, interface="", mac="", cli_type="", vrf=""): """ To delete static arp Author: Prudvi Mangadu ([email protected]) :param dut: :param ipaddress: :param interface: :return: """ cli_type = st.get_ui_type(dut, cli_type=cli_type) command = '' if cli_type == "click": command = "arp -d {} ".format(ipaddress) if interface: command += " -i {}".format(interface) elif cli_type == "klish": if interface: if mac: macaddress = mac else: output = show_arp(dut, ipaddress=ipaddress, interface=interface, vrf=vrf) if len(output) == 0: st.error( "Did not find static arp entry with IP : {} and Interface : {}" .format(ipaddress, interface)) return False else: macaddress = output[0]["macaddress"] intf = get_interface_number_from_name(interface) command = "interface {} {}".format(intf['type'], intf['number']) command = command + "\n" + "no ip arp {} {}".format( ipaddress, macaddress) + "\n" + "exit" else: st.error( "'interface' option is mandatory for deleting 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 deleting 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['delete_static_arp'].format(name=interface, index=port_index, ip=ipaddress) if not delete_rest(dut, rest_url=url): st.error( "Failed to delete static ARP with INTF: {}, IP: {}".format( interface, ipaddress)) 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(dut, **kwargs): """ Add/Delete username with password and role to the device. Author : Prudvi Mangadu ([email protected]) :param :dut: :param :username: :param :password: :param :role: admin | operator :param :group: :param :cli_type: click | klish :param :no_form: 0[False] | 1[True] :Usage: config(vars.D1, username='******', password='******', role='operator', cli_type='kilsh') config(vars.D1, username='******', cli_type='kilsh', no_form=True) config(vars.D1, username='******', password='******', role='admin', cli_type='click', no_form=0) config(vars.D1, username='******', password_update='test1234', cli_type='click', no_form=0) config(vars.D1, group='admin_test', cli_type='click', no_form=0) config(vars.D1, group='admin_test', cli_type='click', no_form=1) config(vars.D1, username='******', password='******', role='admin', cli_type='click', no_form=1) """ cli_type = kwargs.get("cli_type", "") cli_type = st.get_ui_type(dut, cli_type=cli_type) no_form = kwargs.get("no_form", False) if cli_type == "click": if not no_form: if kwargs.get('group'): st.config(dut, "groupadd {}".format(kwargs['group'])) if kwargs.get('username'): command = "useradd {} -m".format(kwargs['username']) if kwargs.get('role'): command += " -g {}".format(kwargs['role']) st.config(dut, command) if kwargs.get('username') and kwargs.get('password'): st.change_passwd(dut, kwargs['username'], kwargs['password']) if kwargs.get('username') and kwargs.get('append_role'): st.config( dut, "usermod -aG {} {}".format(kwargs['append_role'], kwargs['username'])) else: if kwargs.get('username') and kwargs.get('role'): st.config( dut, "gpasswd -d {} {}".format(kwargs['username'], kwargs['role'])) if kwargs.get('group'): st.config(dut, "groupdel {}".format(kwargs['group'])) if kwargs.get('username'): st.config(dut, "userdel {} -r".format(kwargs['username'])) elif cli_type == "klish": if not kwargs.get('username'): st.error("Mandatory parameter 'username' is missing") return False if not no_form: if not kwargs.get("password") and not kwargs.get('role'): st.error( "Mandatory parameter 'password' and 'role' is missing") return False if kwargs['role'] == 'sudo': kwargs['role'] = 'operator' command = "username {} password {} role {}".format( kwargs['username'], kwargs['password'], kwargs['role']) if no_form: command = "no username {} ".format(kwargs['username']) st.config(dut, command, type=cli_type, skip_error_check=True) add_user(dut, kwargs['username']) elif cli_type in ['rest-patch', 'rest-put']: if not no_form: if kwargs['role'] == 'sudo': kwargs['role'] = 'operator' data = { "openconfig-system:user": [{ "username": str(kwargs['username']), "config": { "username": str(kwargs['username']), "password": "", "password-hashed": hashed_pwd(kwargs['password']), "ssh-key": "", "role": str(kwargs['role']) } }] } rest_urls = st.get_datastore(dut, "rest_urls") url1 = rest_urls['user_creation_del'].format(kwargs['username']) if not config_rest( dut, http_method=cli_type, rest_url=url1, json_data=data): st.error("Failed to configure user {} ".format( kwargs['username'])) return False if no_form: rest_urls = st.get_datastore(dut, "rest_urls") url1 = rest_urls['user_creation_del'].format(kwargs['username']) if not delete_rest(dut, http_method=cli_type, rest_url=url1): st.error("Failed to delete user {} ".format( kwargs['username'])) else: st.log("UNSUPPORTED CLI TYPE -- {}".format(cli_type)) return False return True
def delete_vlan_member(dut, vlan, port_list, tagging_mode=False, 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: """ cli_type = st.get_ui_type(dut, cli_type=cli_type) st.log("Delete member {} from the VLAN {}".format(port_list, vlan)) if tagging_mode: participation_mode = "trunk" else: participation_mode = "access" port_li = make_list(port_list) commands = list() rest_fail_status = False 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 elif cli_type == "klish": 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 remove {}".format( vlan) commands.append("{}".format(command)) elif participation_mode == "access": command = "switchport access Vlan" commands.append("no {}".format(command)) commands.append("exit") elif cli_type in ["rest-put", "rest-patch"]: if participation_mode == "access": if "Eth" in get_interface_number_from_name(each_port)["type"]: rest_url = st.get_datastore( dut, "rest_urls")["interface_access_member_config"].format( each_port) else: rest_url = st.get_datastore( dut, "rest_urls")["aggregate_access_member_config"].format( each_port) else: vlan_id = str(vlan).split('-') vlan = '{}..{}'.format( vlan_id[0], vlan_id[1]) if len(vlan_id) > 1 else vlan if "Eth" in get_interface_number_from_name(each_port)["type"]: rest_url = st.get_datastore( dut, "rest_urls")["interface_trunk_member_config"].format( each_port, vlan) else: rest_url = st.get_datastore( dut, "rest_urls")["aggregate_trunk_member_config"].format( each_port, vlan) output = delete_rest(dut, rest_url=rest_url, get_response=True) if not output: st.error("OUTPUT IS EMPTY FROM DELETE VLAN MEMBER REST CALL") return False st.log("STATUS: {}".format(output["status"])) if not rest_status(output["status"]): rest_fail_status = True else: st.error("UNSUPPORTED CLI TYPE -- {}".format(cli_type)) return False if rest_fail_status: st.log("One of VLAN member DELETE REST call failed") return False if commands: st.config(dut, commands, type=cli_type, skip_error_check=skip_error_check) return True
def lldp_config(dut, **kwargs): """ Set LLDP non default config parameters Author: Prasad Darnasi ([email protected]) :param dut: :param txinterval:LLDP update packet interval txinterval in klish is timer :param txhold:LLDP hold time txhold in klish is multiplier :param interface:remote interface :param status:LLDP rx|tx|rx-and-tx|disabled|enable :param hostname:remote system name hostname in klish is system-name :param description:remote system description :param capability:LLDP optional capabilities capability in klish is tlv-select :return: """ cli_type = st.get_ui_type(dut, **kwargs) config = kwargs.get('config', 'yes') no_form = '' if config == 'yes' else 'no' rest_urls = st.get_datastore(dut, "rest_urls") if cli_type == 'click': if 'txinterval' in kwargs: command = "configure lldp {} {}".format('tx-interval', kwargs['txinterval']) st.config(dut, command, type='lldp') if 'txhold' in kwargs: command = "configure lldp {} {}".format('tx-hold', kwargs['txhold']) st.config(dut, command, type='lldp') if 'status' in kwargs: if kwargs['status'] == "enable": kwargs['status'] = "rx-and-tx" if 'interface' in kwargs: command = "configure ports {} lldp status {}".format(kwargs['interface'], kwargs['status']) else: command = "configure lldp status {}".format(kwargs['status']) st.config(dut, command, type='lldp') if 'hostname' in kwargs: command = "configure system hostname {}".format(kwargs['hostname']) st.config(dut, command, type='lldp') if 'capability' in kwargs and 'config' in kwargs: cap = kwargs['capability'] cap_li = list(cap) if isinstance(cap, list) else [cap] for each_cap in cap_li: if kwargs['config'] == 'yes': command = "config lldp {}".format(each_cap) else: command = "unconfigure lldp {}".format(each_cap) st.config(dut, command, type='lldp') return True elif cli_type == 'klish': cmds = [] if 'txinterval' in kwargs: cmds.append("{} lldp timer {}".format(no_form, kwargs['txinterval'])) if 'txhold' in kwargs: cmds.append("{} lldp multiplier {}".format(no_form, kwargs['txhold'])) if 'hostname'in kwargs: cmds.append("{} lldp system-name {}".format(no_form, kwargs['hostname'])) if 'description'in kwargs: cmds.append("{} lldp system-description {}".format(no_form, kwargs['description'])) if 'capability' in kwargs: cap = kwargs['capability'] cap_li = list(cap) if isinstance(cap, list) else [cap] for e_cap in cap_li: if 'management-addresses-advertisements' in e_cap: cmds.append("{} lldp tlv-select management-address".format(no_form)) if 'capabilities-advertisements' in e_cap: cmds.append("{} lldp tlv-select system-capabilities".format(no_form)) if 'status' in kwargs: if 'interface' in kwargs: port = get_interface_number_from_name(kwargs['interface']) cmds.append('interface {} {}'.format(port['type'], port['number'])) intf_mode = {"rx": "receive", "tx": "transmit", "rx-and-tx": "enable", "disabled": "disable", "enable":"enable"} status = intf_mode[kwargs['status']] if status == 'disable': no_form = "no" status = "enable" cmds.append("{} lldp {}".format(no_form, status)) if 'interface' in kwargs: cmds.append('exit') output = st.config(dut, cmds, type=cli_type) if "Error:" in output: st.error("LLDP config failed") st.log(output) return False return True elif cli_type in ["rest-put", "rest-patch"]: if 'status' in kwargs and 'interface' not in kwargs: status = kwargs['status'] if status in ['enable','rx-and-tx']: url = rest_urls['config_lldp_enabled'] json_data = {"openconfig-lldp:enabled": True} if config == 'yes': config_rest(dut, http_method=cli_type, rest_url=url, json_data=json_data) else: delete_rest(dut, rest_url=url) elif status == 'disabled': url = rest_urls['tx_rx_lldp_enable'] delete_rest(dut,rest_url = url) elif status == 'tx': json_data = {"openconfig-lldp-ext:mode": "TRANSMIT"} url = rest_urls['tx_rx_lldp_enable'] if kwargs.get('config', 'yes') == 'yes': config_rest(dut, http_method=cli_type, url= url, json_data=json_data) else: delete_rest(dut, rest_url = url) elif status == 'rx': json_data = {"openconfig-lldp-ext:mode": "RECEIVE"} url = rest_urls['tx_rx_lldp_enable'] if kwargs.get('config', 'yes') == 'yes': config_rest(dut, http_method=cli_type, url= url, json_data=json_data) else: delete_rest(dut, rest_url = url) if 'txinterval' in kwargs: url = rest_urls['txinterval_config'] json_data = { "openconfig-lldp:hello-timer": str(kwargs['txinterval']) } if kwargs.get('config', 'yes') == 'yes': config_rest(dut, http_method=cli_type, rest_url = url, json_data=json_data) else: delete_rest(dut, rest_url = url) if 'txhold' in kwargs: json_data = { "openconfig-lldp-ext:multiplier": kwargs['txhold'] } url = rest_urls['txhold_config'] if kwargs.get('config', 'yes') == 'yes': config_rest(dut, http_method=cli_type, rest_url = url, json_data=json_data) else: delete_rest(dut, rest_url = url) if 'hostname'in kwargs: json_data = { "openconfig-lldp:system-name": str(kwargs['hostname']) } url = rest_urls['system_name_config'] if kwargs.get('config', 'yes') == 'yes': config_rest(dut, http_method=cli_type, rest_url = url, json_data=json_data) else: delete_rest(dut, rest_url = url) if 'description'in kwargs: json_data= { "openconfig-lldp:system-description": kwargs['description'] } url = rest_urls['system_description_config'] if kwargs.get('config', 'yes') == 'yes': config_rest(dut, http_method=cli_type, rest_url = url, json_data=json_data) else: delete_rest(dut, rest_url = url) if 'capability' in kwargs: cap = kwargs['capability'] cap_li = list(cap) if isinstance(cap, list) else [cap] for e_cap in cap_li: if 'management-addresses-advertisements' in e_cap: if kwargs.get('config', 'yes') == 'yes': url = rest_urls['clear_tlv_advertise'].format("MANAGEMENT_ADDRESS") if not delete_rest(dut, rest_url = url): st.error("Failed to enable LLDP TLV: MANAGEMENT_ADDRESS") return False else: json_data = {"openconfig-lldp:suppress-tlv-advertisement": ["MANAGEMENT_ADDRESS"]} url = rest_urls['suppress_tlv_advertisement'] if not config_rest(dut, http_method=cli_type, rest_url = url, json_data=json_data): st.error("Failed to disable LLDP TLV: MANAGEMENT_ADDRESS") return False if 'capabilities-advertisements' in e_cap: if kwargs.get('config', 'yes') == 'yes': url = rest_urls['clear_tlv_advertise'].format("SYSTEM_CAPABILITIES") if not delete_rest(dut, rest_url = url): st.error("Failed to enable LLDP TLV: SYSTEM_CAPABILITIES") return False else: json_data = {"openconfig-lldp:suppress-tlv-advertisement": ["SYSTEM_CAPABILITIES"]} url = rest_urls['suppress_tlv_advertisement'] if not config_rest(dut, http_method=cli_type, rest_url = url, json_data=json_data): st.error("Failed to disable LLDP TLV: SYSTEM_CAPABILITIES") return False if 'interface' in kwargs and 'status' in kwargs: status = kwargs['status'] url = rest_urls['config_lldp'] params_data = {"name": kwargs['interface']} if status == 'disabled': params_data.update(enabled=False) if status == 'enable' or status == "rx-and-tx": params_data.update(enabled=True) if status == 'tx': if config == 'yes': params_data.update({"openconfig-lldp-ext:mode": "TRANSMIT"}) else: del_url = rest_urls['tx_rx_lldp_enable_intf'].format(kwargs['interface']) if not delete_rest(dut, rest_url = del_url): return False if status == 'rx': if config == 'yes': params_data.update({"openconfig-lldp-ext:mode": "RECEIVE"}) else: del_url = rest_urls['tx_rx_lldp_enable_intf'].format(kwargs['interface']) if not delete_rest(dut, rest_url = del_url): return False if len(params_data) > 1: json_data = {"openconfig-lldp:interfaces": {"interface": [{"name": kwargs['interface'], "config": params_data}]}} if not config_rest(dut, http_method=cli_type, rest_url = url, json_data=json_data): return False return True else: st.error('Unsupported UI TYPE - {}'.format(cli_type)) return False
def config_nat_pool_binding(dut, **kwargs): """ Config NAT pool bindings Author:[email protected] :param :dut: :param :config: add/del: :param :binding_name: :param :pool_name: :param :nat_type: :param :twice_nat_id: :param :acl_name: usage: config_nat_pool_binding(dut1, binding_name="name", pool_name="pool1", acl_name="acl1", nat_type="dnat", config="add") """ # config nat add binding bind1 test1 acl1 instance = 0 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 ["click", "klish", "rest-patch", "rest-put"]: st.log("UNSUPPORTE CLI TYPE") return False if "binding_name" not in kwargs and "config" not in kwargs: st.error("Mandatory params binding_name, config not provided ") return result if kwargs["config"] == "add": if "pool_name" not in kwargs: st.error("Mandatory params pool_name is not provided ") return result if cli_type == "click": command = "config nat add binding {} {}".format(kwargs["binding_name"], kwargs["pool_name"]) if "acl_name" in kwargs: command += " {}".format(kwargs["acl_name"]) if "nat_type" in kwargs: command += " -nat_type {}".format(kwargs["nat_type"]) if "twice_nat_id" in kwargs: command += ' -twice_nat_id {}'.format(kwargs["twice_nat_id"]) elif cli_type == "klish": command = list() command.append("nat") cmd = "binding {} {}".format(kwargs["binding_name"], kwargs["pool_name"]) if "acl_name" in kwargs: cmd += " {}".format(kwargs["acl_name"]) if "nat_type" in kwargs: cmd += " {}".format(kwargs["nat_type"]) if "twice_nat_id" in kwargs: cmd += " twice-nat-id {}".format(kwargs["twice_nat_id"]) command.append(cmd) command.append("exit") elif cli_type in ["rest-patch", "rest-put"]: url = st.get_datastore(dut, "rest_urls")['config_nat_pool_binding'].format(instance, kwargs["binding_name"]) data = {"openconfig-nat:config": {"nat-pool": kwargs["pool_name"]}} if "acl_name" in kwargs: data['openconfig-nat:config']['access-list'] = kwargs["acl_name"] if "nat_type" in kwargs: data['openconfig-nat:config']['type'] = kwargs["nat_type"].upper() if "twice_nat_id" in kwargs: data['openconfig-nat:config']['twice-nat-id'] = int(kwargs["twice_nat_id"]) 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 binding {} ".format(kwargs['binding_name']) elif cli_type == "klish": command = list() command.append("nat") command.append("no binding {}".format(kwargs["binding_name"])) command.append("exit") elif cli_type in ["rest-patch", "rest-put"]: url = st.get_datastore(dut, "rest_urls")['del_nat_pool_binding'].format(instance, kwargs["binding_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_remote_syslog_server(dut, **kwargs): """ Configuring syslog server :param dut: :param host: :param source_intf: :param remote_port: :param vrf: :param skip_error: :param config: :return: log_obj.config_remote_syslog_server(dut = dut1, host = '10.59.130.43', config = 'yes') log_obj.config_remote_syslog_server(dut = data.dut1_client, host = dut1_dut2_ip[0], config = 'yes',source_intf = 'Ethernet48') log_obj.config_remote_syslog_server(dut = data.dut1_client, host = dut1_dut2_ip[0], config = 'yes',source_intf = 'Ethernet48', remote_port = 514) log_obj.config_remote_syslog_server(dut = data.dut1_client, host = dut2_dut1_ip[0], source_intf = 'Ethernet48',config = 'yes',cli_type='rest-put') log_obj.config_remote_syslog_server(dut = data.dut1_client, host = dut2_dut1_ip[0], source_intf = 'Ethernet48',config = 'yes',vrf = 'mgmt',cli_type='rest-put') """ st.log('Config Syslog server') config = kwargs.get('config','') host = kwargs.get('host',None) source_intf = kwargs.get('source_intf',None) remote_port = kwargs.get('remote_port',None) vrf = kwargs.get('vrf',None) skip_error = kwargs.get('skip_error',False) cli_type = kwargs.pop('cli_type', st.get_ui_type(dut,**kwargs)) if config.lower() == 'yes': config = '' if host is None: st.error("Mandatory parameter hostname/IP address not found") return False if cli_type == 'klish': command = "{} logging server {}".format(config, host) if source_intf != None and config == '': command = command + " source-interface {}".format(source_intf) if remote_port != None and config == '': command = command + " remote-port {}".format(remote_port) if vrf != None and config == '': command = command + " vrf {}".format(vrf) output = st.config(dut, command, skip_error_check=skip_error, type="klish", conf=True) if "Could not connect to Management REST Server" in output: st.error("klish mode not working.") return False if "Error" in output: st.error("Error during configuration") return False return True elif cli_type in ['rest-patch','rest-put']: http_method = kwargs.pop('http_method',cli_type) rest_urls = st.get_datastore(dut,'rest_urls') if config == '': rest_url = rest_urls['config_remote_server'].format(str(host)) ocdata = {"openconfig-system:config":{"host":str(host)}} if source_intf != None: ocdata["openconfig-system:config"]["openconfig-system-ext:source-interface"] = str(source_intf) if remote_port != None: ocdata["openconfig-system:config"]["remote-port"] = int(remote_port) if vrf != None: ocdata["openconfig-system:config"]["openconfig-system-ext:vrf-name"] = str(vrf) response = config_rest(dut, http_method=http_method, rest_url=rest_url, json_data=ocdata) if not response: st.log(response) return False return True else: rest_url = rest_urls['delete_remote_server'].format(str(host)) response = delete_rest(dut, http_method='delete', rest_url=rest_url) if not response: st.log(response) return False return True else: st.log("Unsupported cli")
def config_ntp_parameters(dut, **kwargs): """ To Configure NTP paramters Author: Jagadish Chatrasi ([email protected]) """ cli_type = st.get_ui_type(dut, **kwargs) config = kwargs.get('config', True) skip_error = kwargs.get('skip_error', False) commands = list() if cli_type == "klish": if 'source_intf' in kwargs: config_string = '' if config else 'no ' for src_intf in make_list(kwargs['source_intf']): intf_data = get_interface_number_from_name(src_intf) commands.append('{}ntp source-interface {} {}'.format(config_string, intf_data['type'], intf_data['number'])) if 'vrf' in kwargs: if not config: commands.append('no ntp vrf') else: commands.append('ntp vrf {}'.format(kwargs['vrf'])) if 'authenticate' in kwargs: config_string = '' if config else 'no ' commands.append('{}ntp authenticate'.format(config_string)) if kwargs.get('auth_key_id'): if not config: commands.append('no ntp authentication-key {}'.format(kwargs['auth_key_id'])) else: if kwargs.get('auth_type') and kwargs.get('auth_string'): commands.append('ntp authentication-key {} {} "{}"'.format(kwargs['auth_key_id'], kwargs['auth_type'], kwargs['auth_string'])) if kwargs.get('trusted_key'): config_string = '' if config else 'no ' commands.append('{}ntp trusted-key {}'.format(config_string, kwargs['trusted_key'])) if kwargs.get('servers'): servers = make_list(kwargs.get('servers')) for server in servers: if not config: commands.append('no ntp server {}'.format(server)) else: commands.append('ntp server {} key {}'.format(server, kwargs['server_key']) if kwargs.get('server_key') else 'ntp server {}'.format(server)) elif cli_type in ["rest-patch", "rest-put"]: rest_urls = st.get_datastore(dut, "rest_urls") if 'source_intf' in kwargs: for src_intf in make_list(kwargs['source_intf']): src_intf = 'eth0' if src_intf == "Management0" else src_intf if config: url = rest_urls['ntp_config_source_interface'] payload = json.loads("""{"openconfig-system-ext:ntp-source-interface": ["string"]}""") payload["openconfig-system-ext:ntp-source-interface"] = [src_intf] if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=payload): return False else: url = rest_urls['ntp_delete_source_interface'].format(src_intf) if not delete_rest(dut, rest_url=url): return False if 'vrf' in kwargs: if config: url = rest_urls['ntp_config_vrf_delete'] payload = json.loads("""{"openconfig-system-ext:vrf": "string"}""") payload["openconfig-system-ext:vrf"] = kwargs['vrf'] if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=payload): return False else: url = rest_urls['ntp_config_vrf_delete'] if not delete_rest(dut, rest_url=url): return False if 'authenticate' in kwargs: url = rest_urls['ntp_config'] if config: payload = json.loads("""{"openconfig-system:config": {"enable-ntp-auth": true}}""") if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=payload): return False else: payload = json.loads("""{"openconfig-system:config": {"enable-ntp-auth": false}}""") if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=payload): return False if kwargs.get('auth_key_id'): keymap = {"md5" : "NTP_AUTH_MD5", 'sha1' : 'NTP_AUTH_SHA1', 'sha2-256' : 'NTP_AUTH_SHA2_256'} if not config: url = rest_urls['ntp_key_delete'].format(kwargs['auth_key_id']) if not delete_rest(dut, rest_url=url): return False else: if kwargs.get('auth_type') and kwargs.get('auth_string'): url = rest_urls['ntp_key_config'] payload = json.loads("""{"openconfig-system:ntp-keys": { "ntp-key": [ { "key-id": 0, "config": { "key-id": 0, "key-type": "string", "openconfig-system-ext:encrypted": false, "key-value": "string" } } ] } }""") payload["openconfig-system:ntp-keys"]["ntp-key"][0]["key-id"] = int(kwargs['auth_key_id']) payload["openconfig-system:ntp-keys"]["ntp-key"][0]["config"]["key-id"] = int(kwargs['auth_key_id']) payload["openconfig-system:ntp-keys"]["ntp-key"][0]["config"]["key-type"] = keymap[kwargs['auth_type']] payload["openconfig-system:ntp-keys"]["ntp-key"][0]["config"]["key-value"] = kwargs['auth_string'] if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=payload): return False if kwargs.get('trusted_key'): if config: url = rest_urls['ntp_config'] payload = json.loads("""{"openconfig-system:config": {"openconfig-system-ext:trusted-key": [0]}}""") payload["openconfig-system:config"]["openconfig-system-ext:trusted-key"] = [int(kwargs['trusted_key'])] if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=payload): return False else: url = rest_urls["ntp_trusted_key_delete"].format(kwargs['trusted_key']) if not delete_rest(dut, rest_url=url): return False if kwargs.get('servers'): servers = make_list(kwargs.get('servers')) for server in servers: if not config: url = rest_urls['delete_ntp_server'].format(server) if not delete_rest(dut, rest_url=url): return False else: url = rest_urls['config_ntp_server'] if kwargs.get('server_key'): payload = json.loads("""{"openconfig-system:servers": { "server": [ { "address": "string", "config": { "address": "string", "openconfig-system-ext:key-id": 0 } } ] } }""") payload["openconfig-system:servers"]["server"][0]["address"] = server payload["openconfig-system:servers"]["server"][0]["config"]["address"] = server payload["openconfig-system:servers"]["server"][0]["config"]["openconfig-system-ext:key-id"] = int(kwargs.get('server_key')) else: payload = json.loads("""{"openconfig-system:servers": { "server": [ { "address": "string", "config": { "address": "string" } } ] } }""") payload["openconfig-system:servers"]["server"][0]["address"] = server payload["openconfig-system:servers"]["server"][0]["config"]["address"] = server if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=payload): return False else: st.error("Unsupported CLI_TYPE: {}".format(cli_type)) return False if commands: 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 return True
def config_nat_static(dut, **kwargs): """ Config NAT Static Author:[email protected] :param :dut: :param :config: add/del :param :local_ip: local ipv4 address :param :global_ip: global ipv4 address :param :nat_type: snat/dnat :param :twice_nat_id: twice_nat_id for group :param :protocol: basic/tcp/udp :param :local_port_id: L4 port number: :param :global_port_id: L4 port number usage: config_nat_static(dut1, protocol="basic, global_ip="65,89.12.11", local_ip="10.0.0.1", nat_type="dnat", config="add") config_nat_static(dut1, protocol="basic, global_ip="65,89.12.11", local_ip="10.0.0.1", nat_type="snat", config="add") config_nat_static(dut1, protocol="basic, global_ip="65,89.12.11",local_ip="10.0.0.1", nat_type="dnat", twice_nat_id ="100", config="yes") config_nat_static(dut1, protocol="basic, global_ip="65,89.12.11",local_ip="10.0.0.1", nat_type="snat", twice_nat_id ="100", config="yes") config_nat_static(dut1, protocol="basic, global_ip="65,89.12.11", local_ip="10.0.0.1", config="del") """ instance = 0 result = False command = "" if "local_ip" not in kwargs and "global_ip" not in kwargs and "config" not in kwargs and "protocol" not in kwargs: st.error("Mandatory params local_ip,global_ip,config,protocol not provided ") return result cli_type = st.get_ui_type(dut, **kwargs) skip_error_check = kwargs.get("skip_error_check", True) if cli_type == "click": if kwargs["config"] == "add": if kwargs['protocol'] == 'all': command = "config nat add static basic {} {} ".format(kwargs["global_ip"], kwargs["local_ip"]) if kwargs['protocol'] in ['tcp', 'udp']: command = "config nat add static {} {} {} {} {}".format(kwargs['protocol'], kwargs["global_ip"], kwargs["global_port_id"], kwargs["local_ip"], kwargs["local_port_id"]) if "nat_type" in kwargs: command += ' -nat_type {}'.format(kwargs["nat_type"]) if "twice_nat_id" in kwargs: command += ' -twice_nat_id {}'.format(kwargs["twice_nat_id"]) if kwargs["config"] == "del": if kwargs['protocol'] == 'all': command = "config nat remove static basic {} {} ".format(kwargs["global_ip"], kwargs["local_ip"]) if kwargs['protocol'] in ['tcp', 'udp']: command = "config nat remove static {} {} {} {} {} ".format(kwargs['protocol'], kwargs["global_ip"], kwargs["global_port_id"], kwargs["local_ip"], kwargs["local_port_id"]) st.config(dut, command, type=cli_type, skip_error_check=skip_error_check) elif cli_type == "klish": commands = list() cmd = '' commands.append("nat") if kwargs.get("config") == "add": if kwargs['protocol'] == 'all': cmd = "static basic {} {}".format(kwargs["global_ip"], kwargs["local_ip"]) elif kwargs['protocol'] in ['tcp', 'udp']: cmd = "static {} {} {} {} {}".format(kwargs['protocol'], kwargs["global_ip"], kwargs["global_port_id"], kwargs["local_ip"], kwargs["local_port_id"]) if "nat_type" in kwargs: cmd += " {}".format(kwargs["nat_type"]) if "twice_nat_id" in kwargs: cmd += " twice-nat-id {}".format(kwargs["twice_nat_id"]) commands.append(cmd) else: if kwargs['protocol'] == 'all': commands.append("no static basic {}".format(kwargs["global_ip"])) elif kwargs['protocol'] in ['tcp', 'udp']: commands.append( "no static {} {} {}".format(kwargs['protocol'], kwargs["global_ip"], kwargs["global_port_id"])) commands.append("exit") st.config(dut, commands, type=cli_type, skip_error_check=skip_error_check) elif cli_type in ["rest-patch", "rest-put"]: data = {} rest_urls = st.get_datastore(dut, "rest_urls") url = '' if kwargs.get("config") == "add": if kwargs['protocol'] == 'all': url = rest_urls['config_nat_static'].format(instance, kwargs["global_ip"]) data = {"openconfig-nat:config": {"internal-address": kwargs["local_ip"]}} elif kwargs['protocol'] in ['tcp', 'udp']: protocol_no = 6 if kwargs['protocol'] == 'tcp' else 17 url = rest_urls['config_napt_static'].format(instance, kwargs["global_ip"], protocol_no, kwargs["global_port_id"]) data = {"openconfig-nat:config": {"internal-address": kwargs["local_ip"], "internal-port": int(kwargs["local_port_id"])}} if "nat_type" in kwargs: data['openconfig-nat:config']['type'] = kwargs["nat_type"].upper() if "twice_nat_id" in kwargs: data['openconfig-nat:config']['twice-nat-id'] = int(kwargs["twice_nat_id"]) config_rest(dut, http_method=cli_type, rest_url=url, json_data=data) return True else: if kwargs['protocol'] == 'all': url = rest_urls['del_nat_static'].format(instance, kwargs["global_ip"]) elif kwargs['protocol'] in ['tcp', 'udp']: protocol_no = 6 if kwargs['protocol'] == 'tcp' else 17 url = rest_urls['del_napt_static'].format(instance, kwargs["global_ip"], protocol_no, kwargs["global_port_id"]) delete_rest(dut, rest_url=url) return True else: st.log("UNSUPPORTED CLI TYPE") return False return True
def set_aaa_authentication_properties(dut, property, value, cli_type="", **kwargs): ''' Configuring aaa authentication properties. ''' cli_type = st.get_ui_type(dut, cli_type=cli_type) if cli_type == "click": command = "config aaa authentication {} {}".format(property, value) st.config(dut, command, type=cli_type) elif cli_type == "klish": if property == "login": value = "local" if value == "default" else value if value == "local": command = "aaa authentication {} default {}".format( property, value) else: values = re.split(" +", value) if len(values) == 2 and values[0] == "local": command = "aaa authentication {} default {} group {}".format( property, values[0], values[1]) else: command = "aaa authentication {} default group {}".format( property, value) elif property == "failthrough": value = "disable" if value == "default" else value command = "aaa authentication failthrough {}".format(value) else: st.log( "UNSUPPORTED AUTHENTICATION PROPERTY -- {}".format(property)) return False 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['aaa_autentication_method'] url1 = rest_urls['aaa_autentication_failthrough'] if property == "login" and value == "radius local": data = json.loads(""" { "openconfig-system:authentication-method": [ "radius", "local" ] } """) if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=data, timeout=time_out): return False elif property == "login" and value == "local radius": data = json.loads(""" { "openconfig-system:authentication-method": [ "local", "radius" ] } """) if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=data, timeout=time_out): return False elif property == "login" and value == "default": data = json.loads(""" { "openconfig-system:authentication-method": [ "local" ] } """) if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=data, timeout=time_out): return False elif property == "login" and value == "radius": data = json.loads(""" { "openconfig-system:authentication-method": [ "radius" ] } """) if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=data, timeout=time_out): return False elif property == "failthrough" and value == "enable": data = json.loads(""" { "openconfig-system-ext:failthrough": "True" } """) if not config_rest(dut, http_method=cli_type, rest_url=url1, json_data=data, timeout=time_out, **kwargs): return False elif property == "failthrough" and value == "default": if not delete_rest(dut, rest_url=url1, timeout=time_out): return False elif property == "login" and value == "tacacs+ local": data = json.loads(""" { "openconfig-system:authentication-method": [ "tacacs+", "local" ] } """) if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=data, **kwargs): return False elif property == "login" and value == "local tacacs+": data = json.loads(""" { "openconfig-system:authentication-method": [ "local", "tacacs+" ] } """) if not config_rest(dut, http_method=cli_type, rest_url=url, json_data=data, **kwargs): return False elif property == "login" and value == "tacacs+": data = json.loads(""" { "openconfig-system:authentication-method":[ "tacacs+" ] } """) if not config_rest( dut, http_method=cli_type, rest_url=url, json_data=data): return False elif property == "login" and value == "ldap": data = json.loads(""" { "openconfig-system:authentication-method":[ "ldap" ] } """) if not config_rest( dut, http_method=cli_type, rest_url=url, json_data=data): return False elif property == "login" and value == "ldap local": data = json.loads(""" { "openconfig-system:authentication-method":[ "ldap", "local" ] } """) if not config_rest( dut, http_method=cli_type, rest_url=url, json_data=data): return False elif property == "login" and value == "local ldap": data = json.loads(""" { "openconfig-system:authentication-method":[ "local", "ldap" ] } """) if not config_rest( dut, http_method=cli_type, rest_url=url, json_data=data): return False else: st.log("UNSUPPORTED CLI TYPE -- {}".format(cli_type)) return False return True
def config_udld_recover(dut, **kwargs): """ Author: [email protected] config_udld_recover(dut=data.dut1,udld_recover='enable',module="udld") config_udld_recover(dut=data.dut1,udld_recover='disable',module="udld") udld.config_udld_recover(dut=dut1,udld_recover='enable',module="udld",cli_type = 'klish') udld.config_udld_recover(dut=dut1,udld_recover='enable',module="udld",cli_type = 'rest-put') Configure udld recover global :param dut: :param udld_recover: :module: :return: """ cli_type = kwargs.pop('cli_type', st.get_ui_type(dut)) module = kwargs.get('module', None) udld_recover = kwargs.get('udld_recover', None) st.log("Starting UDLD recover Configurations1...") my_cmd = '' if cli_type == 'click': if 'udld_recover' in kwargs and 'module' in kwargs: my_cmd = 'config errdisable recovery cause {} {}'.format( kwargs['udld_recover'], kwargs['module']) else: st.error( "Mandatory arguments udld enable or disable and module name should be given" ) return False st.config(dut, my_cmd, type=cli_type) elif cli_type == 'klish': if udld_recover != None and module != None: if udld_recover == 'enable': my_cmd = 'errdisable recovery cause {}'.format( kwargs['module']) elif udld_recover == 'disable': my_cmd = 'no errdisable recovery cause {}'.format( kwargs['module']) else: st.error( "Mandatory arguments udld recover and module name should be given" ) return False st.config(dut, my_cmd, type=cli_type) elif cli_type in ['rest-patch', 'rest-put']: http_method = kwargs.pop('http_method', cli_type) rest_urls = st.get_datastore(dut, 'rest_urls') rest_url = rest_urls['errdisable_recover_cause_config'] if module != None and udld_recover != None: ocdata = {"openconfig-errdisable-ext:cause": [module.upper()]} if udld_recover.lower() == 'enable': response = config_rest(dut, http_method=http_method, rest_url=rest_url, json_data=ocdata) elif udld_recover.lower() == 'disable': response = delete_rest(dut, http_method='delete', rest_url=rest_url, json_data=ocdata) else: st.error( "Mandatory arguments udld recover and module name should be given" ) return False if not response: st.log('Errdisable recovery cause config/unconfig failed') st.log(response) return False return True else: st.log("Unsupported CLI TYPE - {}".format(cli_type)) return False
def config_udld_recover_timer(dut, **kwargs): """ Author: [email protected] config_udld_recover_timer(dut=data.dut1,udld_recover_timer='30') config_udld_recover_timer(dut=data.dut1,udld_recover_timer='300') udld.config_udld_recover_timer(dut=dut1,udld_recover_timer='30',cli_type = 'klish') Configure udld recover timer :param dut: :param udld_recover_timer: 300 default in sec :return: """ cli_type = kwargs.pop('cli_type', st.get_ui_type(dut)) udld_recover_timer = kwargs.get('udld_recover_timer', None) config = kwargs.get('config', '') st.log("Starting UDLD recover timer Configurations1...") my_cmd = '' if cli_type == 'click': if 'udld_recover_timer' in kwargs: my_cmd = 'config errdisable recovery interval {}'.format( kwargs['udld_recover_timer']) else: st.error("Mandatory argument udld recover timer should be given") return False st.config(dut, my_cmd, type=cli_type) elif cli_type == 'klish': if udld_recover_timer != None: if config == '': my_cmd = 'errdisable recovery interval {}'.format( kwargs['udld_recover_timer']) else: my_cmd = 'no errdisable recovery interval' else: st.error("Mandatory argument udld recover timer should be given") return False st.config(dut, my_cmd, type=cli_type) elif cli_type in ['rest-patch', 'rest-put']: http_method = kwargs.pop('http_method', cli_type) rest_urls = st.get_datastore(dut, 'rest_urls') rest_url = rest_urls['errdisable_recover_interval_config'] if udld_recover_timer != None: ocdata = { "openconfig-errdisable-ext:interval": int(udld_recover_timer) } if config == '': response = config_rest(dut, http_method=http_method, rest_url=rest_url, json_data=ocdata) else: response = delete_rest(dut, http_method='delete', rest_url=rest_url, json_data=ocdata) else: st.error( "Mandatory arguments udld recover interval should be given") return False if not response: st.log('Errdisable recovery interval config/unconfig failed') st.log(response) return False return True else: st.log("Unsupported CLI TYPE - {}".format(cli_type)) return False
def clear_threshold(dut, **kwargs): """ Clear threshold configuration. Author: Prudvi Mangadu ([email protected]) :param :dut: :param :threshold_type: priority-group|queue :param :port_alias: :param :buffer_type: if threshold_type:priority-group {shared|headroom} | else threshold_type:queue {unicast|multicast} | all :param :index: if threshold_type:priority-group - PGindex value | else threshold_type:queue - queueindex value :param :breach: all | event-id :param :cli_type: click|klish :return: """ cli_type = st.get_ui_type(dut, **kwargs) if cli_type == "click": if kwargs.get('port_alias') == 'CPU': kwargs['buffer_type'] = 'all' if kwargs.get("breach"): if kwargs.get('breach') == "all": commands = "sonic-clear threshold breach" else: commands = "sonic-clear threshold breach {}".format(kwargs.get("breach")) elif kwargs.get("threshold_type") and kwargs.get('buffer_type') == "all": commands = "sonic-clear {} threshold".format(kwargs['threshold_type']) else: if 'threshold_type' not in kwargs and 'port_alias' not in kwargs and 'buffer_type' not in kwargs and \ 'index' not in kwargs: st.error("Mandatory parameter threshold_type/port_alias/index/type not found") return False if kwargs['threshold_type'] in ["priority-group", "queue"]: commands = "sonic-clear {} threshold {} {} {}".format(kwargs['threshold_type'], kwargs['port_alias'], kwargs['index'], kwargs['buffer_type']) else: st.error("Invalid threshold_type provided '{}'".format(kwargs['threshold_type'])) return False elif cli_type == "klish": if kwargs.get("breach"): if kwargs.get('breach') == "all": commands = "clear threshold breach all" else: commands = "clear threshold breach {}".format(kwargs['breach']) else: if 'threshold_type' not in kwargs or 'port_alias' not in kwargs or 'buffer_type' not in kwargs: st.error("Mandatory parameter threshold_type/port_alias not found") return False ports_list = utils.make_list(kwargs['port_alias']) if kwargs['threshold_type'] in ["priority-group", "queue"]: commands = list() buffers = ['unicast', 'multicast'] if kwargs['threshold_type'] == 'queue' else ['shared', 'headroom'] for port in ports_list: if port.upper() == 'CPU': commands.append("interface {}".format(port.upper())) else: interface_details = get_interface_number_from_name(port) commands.append("interface {} {}".format(interface_details['type'], interface_details['number'])) if kwargs['buffer_type'] == 'all': for buffer in buffers: commands.extend(["no threshold {} {} {}".format(kwargs['threshold_type'], i, buffer) for i in range(8)]) else: commands.append("no threshold {} {} {}".format(kwargs['threshold_type'], kwargs['index'], kwargs['buffer_type'])) commands.append("exit") else: st.error("Invalid threshold_type provided '{}'".format(kwargs['threshold_type'])) return False elif cli_type in ["rest-patch","rest-put"]: if kwargs.get("breach"): if kwargs.get('breach') == "all": data = {"openconfig-qos-ext:input": {"breach-event-id": "ALL"}} else: data = {"openconfig-qos-ext:input": {"breach-event-id": str(kwargs.get('breach'))}} url = st.get_datastore(dut, "rest_urls")["clear_threshold_breaches"] if not config_rest(dut, http_method="post", rest_url= url, json_data=data): st.debug("Failed to clear threshold breaches") return False else: if 'threshold_type' not in kwargs or 'port_alias' not in kwargs or 'buffer_type' not in kwargs: st.error("Mandatory parameter threshold_type/port_alias not found") return False ports_list = utils.make_list(kwargs['port_alias']) if kwargs['threshold_type'] in ["priority-group", "queue"]: buffers = ['unicast', 'multicast'] if kwargs['threshold_type'] == 'queue' else ['shared', 'headroom'] for port in ports_list: if kwargs['buffer_type'] == 'all': for buffer in buffers: for i in range(8): url = st.get_datastore(dut,"rest_urls")["delete_int_threshold"].\ format(kwargs['threshold_type'], buffer,port, i) if not delete_rest(dut, rest_url=url): st.debug("Failed to clear threshold buffers") return False else: url = st.get_datastore(dut,"rest_urls")["delete_int_threshold"].format(kwargs['threshold_type'], kwargs['buffer_type'], port, kwargs['index']) if not delete_rest(dut, rest_url=url): st.debug("Failed to clear threshold buffers") return False else: st.error("Invalid threshold_type provided '{}'".format(kwargs['threshold_type'])) return False return True else: st.error("UNSUPPORTED CLI TYPE -- {}".format(cli_type)) return False st.config(dut, commands, type=cli_type) return True