def bind_class_action_copp_policy(dut, **kwargs): """ Author: Gangadhara Sahu ([email protected]) To configure classifier of type CoPP :param dut: :param classifier: :param action_group: :param config: :return bool: Example : bind_class_action_copp_policy(dut1,classifier="copp-system-arp",action_group="copp-system-arp",config="no") bind_class_action_copp_policy(dut1,classifier="copp-system-arp",action_group="copp-system-nd") """ config_cmd = 'no' if kwargs.get('config','yes').lower() == 'no' else 'yes' command = [] if config_cmd == 'no': command.append("policy-map copp-system-policy type copp") command.append("no class {}".format(kwargs['classifier'])) command.append("exit") else: command.append("policy-map copp-system-policy type copp") command.append("class {}".format(kwargs['classifier'])) command.append("set copp-action {}".format(kwargs['action_group'])) command.append("exit") command.append("exit") st.config(dut, command,type="klish") return True
def _cleanup_mclag_config_helper(dut_list, cli_type=''): """ Helper routine to cleanup MCLAG config from devices. """ dut_li = list(dut_list) if isinstance(dut_list, list) else [dut_list] cli_type = st.get_ui_type(dut_li[0], cli_type=cli_type) for dut in dut_li: st.log( "############## {} : MCLAG config cleanup ################".format( dut)) if cli_type == 'click': output = st.show(dut, "mclagdctl dump state") elif cli_type == 'klish': output = st.show(dut, "show mclag brief", type=cli_type) st.log("##### MCLAG : {}".format(output)) if len(output) == 0: continue for entry in output: if not entry['domain_id']: continue domain_id = entry['domain_id'] if cli_type == 'click': st.config(dut, "sudo config mclag del {}".format(domain_id)) elif cli_type == 'klish': cmd = "no mclag domain {}".format(domain_id) st.config(dut, cmd, type="klish", conf=True) return True
def default_interface(dut,**kwargs): """ TO configure default interface Author: Naveen ([email protected]) :param dut: :param interface_name: :param range: 'True', if Range is True, please provide interfaces range with "-" for eg Ethernet 0-10 :return: Eg : port.default_interface(dut1, interface = 'Ethernet 4-7',range='yes/True') port.default_interface(dut1, interface = 'Ethernet 4') """ cli_type = st.get_ui_type(dut, **kwargs) if 'interface' not in kwargs: st.error("Mandatory arg interface is not present") return False else: interface = kwargs['interface'] skip_error = kwargs.pop('skip_error', False) command = '' if cli_type == 'klish': if 'range' in kwargs: command = command + "\n" + "default interface range {}".format(interface) else: command = command + "\n" + "default interface {}".format(interface) else: st.error("Invalid cli_type for this API - {}.".format(cli_type)) return False st.config(dut, command, type='klish',skip_error_check=skip_error) 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 config_mclag_router_mac(dut, **kwargs): ''' Configures <gw_mac for mclag :param dut: :param kwargs: op_type/gw_mac> :return: Usage: config_mclag_router_mac(dut1, op_type='add', gw_mac='00:11:22:33:44:55') config_mclag_router_mac(dut1, op_type='del', gw_mac='00:11:22:33:44:55') ''' ### Optional parameters processing type_val = kwargs.get('op_type', None) gw_mac_val = kwargs.get('gw_mac', None) ##TODO enable below after adding Klish support as of now overriding with click #cli_type = kwargs.pop('cli_type', st.get_ui_type(dut,**kwargs)) cli_type = 'click' if cli_type == 'click': cmd = "" if 'op_type' in kwargs and 'gw_mac' in kwargs: cmd += "config mclag gw-mac {} {}\n".format(type_val, gw_mac_val) else: st.error("Mandatory argument gw_mac Not Found") return False st.config(dut, cmd) return True
def config_stp_vlan_parameters(dut, vlan, **kwargs): """ :param dut: :param vlan: :param kwargs: :return: """ cli_type = kwargs.setdefault('cli_type', 'click') no_form = 'no' if kwargs.setdefault('no_form', False) else '' del kwargs['cli_type'] del kwargs['no_form'] click_2_klish = { 'forward_delay': 'forward-time', 'hello': 'hello-time', 'max_age': 'max-age' } for each_key, value in kwargs.items(): if cli_type == 'click': command = "config spanning_tree vlan {} {} {}".format( each_key, vlan, value) elif cli_type == 'klish': each_key1 = click_2_klish.get(each_key, each_key) command = "{} spanning-tree vlan {} {} {}".format( no_form, vlan, each_key1, value) else: st.error("Invalid CLI type - {}".format(cli_type)) return st.config(dut, command, type=cli_type)
def config_nat_global(dut, **kwargs): """ Author : Priyanka :param :dut: :param :prot: :param :time: :return: """ cli_type = st.get_ui_type(dut, **kwargs) skip_error_check = kwargs.get("skip_error_check", True) if cli_type not in ["click", "klish"]: st.log("UNSUPPORTED CLI TYPE") return False if kwargs["admin_mode"]: if cli_type == "click": command = "config nat feature {}".format(kwargs["admin_mode"]) else: command = list() command.append("nat") admin_mode = "enable" if kwargs["admin_mode"] == "enable" else "no enable" command.append("{}".format(admin_mode)) command.append("exit") elif kwargs["prot"]: command = "config nat {}-timeout {}".format(kwargs["prot"], kwargs["time"]) else: command = "config nat timeout {}".format(kwargs["time"]) st.config(dut, command, type=cli_type, skip_error_check=skip_error_check) return True
def clear_watermark_counters(dut, **kwargs): """ Clear priority-group or queue watermark counters. Author: Shiva Kumar Boddula ([email protected]) :param :dut: :param :threshold_type: priority-group|queue :param :buffer_type: if threshold_type:priority-group {shared|headroom} | else threshold_type:queue {unicast|multicast} :return: """ if 'threshold_type' not in kwargs and 'buffer_type' not in kwargs and 'cli_type' not in kwargs: st.error( "Mandatory parameter threshold_type/buffer_type/cli_type not found" ) return False cli_type = st.get_ui_type(dut, **kwargs) if "priority-group" in kwargs['threshold_type'] or "queue" in kwargs[ 'threshold_type']: if cli_type == "click": command = "sonic-clear {} watermark {}".format( kwargs['threshold_type'], kwargs['buffer_type']) elif cli_type == "klish": command = "clear {} watermark {}".format(kwargs['threshold_type'], kwargs['buffer_type']) else: st.error("Invalid threshold_type provided '{}'".format( kwargs['threshold_type'])) return False st.config(dut, command, type=cli_type) return True
def disable_sshv6(dut): st.log(" # Disable SSH on a device to listen on IPv6") command = "sed -i 's/ListenAddress ::/#ListenAddress ::/g' /etc/ssh/sshd_config" st.config(dut, command) command = "/etc/init.d/ssh restart" st.config(dut, command) return True
def config_mac_agetime(dut, agetime, cli_type="", config= "add", **kwargs): """ This proc is to config mac aging and setting it back to default. :param dut: DUT Number :param agetime: fdb age time in seconds :return: """ cli_type = st.get_ui_type(dut, cli_type=cli_type) skip_error_check = kwargs.get('skip_error', False) command = '' if cli_type == 'click': command = "config mac aging_time {}".format(int(agetime)) if not st.is_feature_supported("config-mac-aging_time-command", dut): st.community_unsupported(command, dut) skip_error_check=True elif cli_type == 'klish': if config == 'add': command = "mac address-table aging-time {}".format(int(agetime)) else: command = "no mac address-table aging-time" elif cli_type in ['rest-patch', 'rest-put']: rest_urls = st.get_datastore(dut, 'rest_urls') url = rest_urls['mac_aging'].format(name='default') config_data = {"openconfig-network-instance:mac-aging-time": int(agetime)} if not config_rest(dut, rest_url=url, http_method=cli_type, json_data=config_data): st.error("Failed to configure aging as {}".format(agetime)) return False if command: st.config(dut, command, skip_error_check=skip_error_check, type=cli_type) return True
def bcmcmd_l3_entry_only_config(dut, **kwargs): if "action" not in kwargs: st.error("Mandatory params num, action are not provided") return False valid = 1 if kwargs["action"] == "delete": valid = 0 output = bcmcmd_get_l3_entry(dut) name_list = utils.dicts_list_values(output, "names") if "L3_ENTRY_ONLY" in name_list: num = int( utils.filter_and_select( output, [], {"names": "L3_ENTRY_ONLY"})[0]['entries']) - 1 command = "bcmcmd 'mod L3_ENTRY_ONLY 1 {} VALID={}'".format(num, valid) elif "L3_ENTRY_ONLY_SINGLE" in name_list: num = int( utils.filter_and_select( output, [], {"names": "L3_ENTRY_ONLY_SINGLE"})[0]['entries']) - 1 command = "bcmcmd 'mod L3_ENTRY_ONLY_SINGLE 1 {} BASE_VALID={}'".format( num, valid) elif "L3_ENTRY_SINGLE" in name_list: num = int( utils.filter_and_select( output, [], {"names": "L3_ENTRY_SINGLE"})[0]['entries']) - 1 command = "bcmcmd 'mod L3_ENTRY_SINGLE 1 {} BASE_VALID={}'".format( num, valid) else: st.error( "L3_ENTRY_ONLY | L3_ENTRY_ONLY_SINGLE | L3_ENTRY_SINGLE not found in - listmem l3_entry" ) return False st.config(dut, command) return True
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 test_wrong_vtysh_cmd_2(): vars = st.get_testbed_vars() st.config(vars.D1, "router bgp\nexit\nexit", type="vtysh", skip_error_check=True) st.show(vars.D1, "testetst\nexit", skip_error_check=True, skip_tmpl=True) st.report_pass("operation_successful")
def config_vrfs(dut, vrf_data_list={}, config='yes', cli_type=''): if config == 'yes' or config == 'add': config = 'add' elif config == 'no' or config == 'del': config = 'del' else: st.error("Invalid config type {}".format(config)) return False cli_type = st.get_ui_type(dut, cli_type=cli_type) command = [] for _, vrf_data in vrf_data_list.items(): vrf = vrf_data['name'] if cli_type == 'click': cmd_str = "sudo config vrf {} {} ".format(config, vrf) command.append(cmd_str) elif cli_type == "klish": cmd_str = "no " if config == 'del' else '' cmd_str += "ip vrf {}".format(vrf) command.append(cmd_str) elif cli_type in ['rest-patch', 'rest-put']: st.error("Spytest API not yet supported for REST type") return False if cli_type in ['click', 'klish']: try: st.config(dut, command, type=cli_type) except Exception as e: st.log(e) return False 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_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 config_spanning_tree(dut, feature="pvst", mode="enable", vlan=None, cli_type='click'): """ :param dut: :param feature: :param mode: :param vlan: :param cli_type: :return: """ command = '' no_form = 'no' if mode == 'enable': no_form = '' st.log("{} spanning_tree {}".format(mode, feature)) if cli_type == 'click': if vlan: command = "config spanning_tree vlan {} {}".format(mode, vlan) else: command = "config spanning_tree {} {}".format(mode, feature) elif cli_type == 'klish': if mode == 'disable': feature = '' if vlan: command = "{} spanning-tree vlan {}".format(no_form, vlan) else: command = "{} spanning-tree mode {}".format(no_form, feature) st.config(dut, command, type=cli_type)
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 config_nat_feature(dut, oper='enable', cli_type="", skip_error_check=True): """ Config NAT Feature Author:[email protected] :param dut: :param oper: enable/disable :param cli_type: :param skip_error_check: :return: """ instance = 0 cli_type = st.get_ui_type(dut, cli_type=cli_type) if cli_type == "click": command = "config nat feature {}".format(oper) elif cli_type == "klish": command = list() operation = "enable" if oper == "enable" else "no enable" command.append("nat") command.append("{}".format(operation)) command.append("exit") elif cli_type in ["rest-patch", "rest-put"]: operation = True if oper == "enable" else False url = st.get_datastore(dut, "rest_urls")['config_nat_feature'].format(instance) data = {"openconfig-nat:config": {"enable": operation}} config_rest(dut, http_method=cli_type, rest_url=url, json_data=data) return True else: st.log("UNSUPPORTED CLI TYPE") return False st.config(dut, command, type=cli_type, skip_error_check=skip_error_check) 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 delete_acl_table(dut, acl_table_name=None, cli_type="click"): """ API to delete the ACL table from DUT Author: Chaitanya Vella ([email protected]) :param dut: :param acl_table_name: table name can be a string or list :return: """ st.log("Deleting ACL table ...") if cli_type == "click": command = "config acl table delete" if st.is_community_build(): command = "config acl remove table" if acl_table_name: table_name = list([str(e) for e in acl_table_name]) if isinstance(acl_table_name, list) \ else [acl_table_name] for acl_table in table_name: command = "{} {}".format(command, acl_table) st.config(dut, command) else: st.config(dut, command) else: if not acl_table_name: st.report_fail("acl_table_name_missing") command = "no ip access-list {}".format(acl_table_name) output = st.config(dut, command, type=cli_type, skip_error_check=True) if "Entry not found" in output: st.log("acl_table_not_found")
def delete_vlan(dut, vlan_list, cli_type=""): """ To delete list of VLANs. Author : Prudvi Mangadu ([email protected]) :param dut: :param vlan_list: :param cli_type: :return: """ if not cli_type: cli_type = st.get_ui_type(dut) st.log("Delete vlan") vlan_li = map(str, vlan_list) if isinstance(vlan_list, list) else [vlan_list] commands = list() try: for each_vlan in vlan_li: if cli_type == "click": commands.append("config vlan del {}".format(each_vlan)) else: commands.append("no interface Vlan {}".format(each_vlan)) st.config(dut, commands, skip_error_check=True, type=cli_type) if cli_type == "click": vlan_list = get_vlan_list(dut, cli_type="click") 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 sonic_installer_install2(dut, url, max_time=1800, skip_error_check=False, migartion=False): cli_type = st.get_ui_type(dut) if cli_type == 'click': if migartion: cmd = "sudo sonic_installer install {} -y".format(url) else: cmd = "sudo sonic_installer install --skip_migration {} -y".format( url) st.log("installing {}".format(cmd)) output = st.config(dut, cmd, skip_error_check=skip_error_check, max_time=max_time) if re.search("Installed SONiC base image SONiC-OS successfully", output): return "success" if re.search("Not installing SONiC version", output) and \ re.search("as current running SONiC has the same version", output): return "skipped" return "error" elif cli_type == 'klish': cmd = "image install {}".format(url) st.log("installing {}".format(cmd)) st.config(dut, cmd, skip_error_check=skip_error_check, max_time=max_time, type=cli_type) return "success"
def create_vlan(dut, vlan_list, cli_type=""): """ To create list of VLANs. Author : Prudvi Mangadu ([email protected]) :param dut: :param vlan_list: :param cli_type: :return: """ if not cli_type: cli_type = st.get_ui_type(dut) st.log("Creating vlan") vlan_li = map(str, vlan_list) if isinstance(vlan_list, list) else [vlan_list] commands = list() for each_vlan in vlan_li: if cli_type == "click": commands.append("config vlan add {}".format(each_vlan)) else: commands.append("interface Vlan {}".format(each_vlan)) commands.append('exit') st.config(dut, commands, type=cli_type) return True
def config_gw_mac(dut, skip_error=False, **kwargs): ''' Configures< gw mac add | del> for Mclag Author: [email protected] :param dut: :param kwargs: optional parameters can be <config|mac|cli_type> :return: Usage: config_gw_mac(dut1, config='add', mac='xx:xx:xx:xx:xx:xx') config_gw_mac(dut1, config='del', mac='xx:xx:xx:xx:xx:xx') ''' config = kwargs.get('config', 'add') if 'mac' not in kwargs: st.error("Mandatory parameter mac address not found") return False mac_val = kwargs.get('mac') cli_type = kwargs.get('cli_type', st.get_ui_type(dut, **kwargs)) if cli_type == 'click': cmd = "config mclag gw-mac {} {}\n".format(config, mac_val) st.config(dut, cmd) elif cli_type == 'klish': config = 'no ' if config == 'del' else '' cmd = "{}mclag gateway-mac {}".format(config, mac_val) 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_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 udld_block(dut, **kwargs): """ Author: [email protected] udld_blockf(dut=data.dut1,intf ='Ethernet10') Block the UDLD packtets at interface level :param dut: :param intf: :return: """ if 'config' in kwargs: config = kwargs['config'] else: config = 'yes' if config.lower() == 'yes': config_cmd = 'enable' else: config_cmd = 'disable' if 'intf' in kwargs: if type(kwargs['intf']) is list: kwargs['intf'] = list(kwargs['intf']) else: kwargs['intf'] = [kwargs['intf']] my_cmd = '' for intf in kwargs['intf']: if '/' in intf: intf = st.get_other_names(dut, [intf])[0] my_cmd += 'udldctl rx_drop {} {}\n'.format(config_cmd, intf) else: st.error("Mandatory argument interface name Not Found") return False st.config(dut, my_cmd, type="click")
def rbac_config_user(no_form=0): result = True st.banner( "{}Configuring User(s) to the DUT.".format("Un-" if no_form else '')) for each in rbac.cred_list: each.update({'no_form': no_form}) st.banner("Configuring - {}".format(each), delimiter='*') config(vars.D1, **each) if each['cli_type'] == 'klish': st.config(vars.D1, 'usermod -s /bin/bash {}'.format(each['username'])) if not no_form: sshapi.ssh_copyid(vars.D2, st.get_mgmt_ip(vars.D1), **each) if not no_form: if not verify(vars.D1, 'user_list', verify_list=rbac.user_list): st.error("Failed to config User in DUT") result = False if not verify(vars.D1, 'group_list', verify_list=rbac.group_list): st.error("Failed to config Groups in DUT") result = False for username, role in rbac.user_group.items(): if not verify( vars.D1, user_group=username, verify_list=[{ 'group': role }]): st.error('Failed to config User with group in DUT') result = False if not result: st.report_fail('rbac_user_config')
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 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