def client_auth(dut, **kwargs): """ To enable disable REST client auth. Author: Prudvi Mangadu ([email protected]) :param dut: :param kwargs: :return: """ st.log("Configuring REST authentication.") docer_name = "mgmt-framework" show_command = [] if 'auth_type' in kwargs: show_command.append('sonic-cfggen -d -v "REST_SERVER"') if kwargs.get('auth_type'): command = redis.build(dut, redis.CONFIG_DB, 'hmset "REST_SERVER|default" client_auth "{}"'.format(kwargs.get('auth_type'))) else: command = redis.build(dut, redis.CONFIG_DB, 'hdel "REST_SERVER|default" client_auth') st.config(dut, command) if 'ca_crt' in kwargs: show_command.append(redis.build(dut, redis.CONFIG_DB, 'hgetall "DEVICE_METADATA|x509"')) if kwargs.get('ca_crt'): command = redis.build(dut, redis.CONFIG_DB, 'hmset "DEVICE_METADATA|x509" ca_crt {}'.format(kwargs.get('ca_crt'))) else: command = redis.build(dut, redis.CONFIG_DB, 'hdel "DEVICE_METADATA|x509" ca_crt') st.config(dut, command) from apis.system.basic import service_operations_by_systemctl service_operations_by_systemctl(dut, docer_name, 'stop') service_operations_by_systemctl(dut, docer_name, 'start') st.config(dut, show_command) return True
def verify_error_db(dut, table, **kwargs): """ Verify error db using redis cli :param dut: :param table: :param kwargs: :return: """ match = "" if table == "ERROR_ROUTE_TABLE": vrfKey = "" if 'vrf' in kwargs: vrfKey = kwargs["vrf"] + ":" command = redis.build( dut, redis.ERROR_DB, "hgetall {}:{}{}/{}".format(table, vrfKey, kwargs["route"], kwargs["mask"])) if kwargs["opcode"] == "create": match = { "nhp": kwargs["nhp"], "rc": kwargs["rc"], "ifname": kwargs["port"], "opcode": kwargs["opcode"] } elif kwargs["opcode"] == "remove": match = {"rc": kwargs["rc"], "opcode": kwargs["opcode"]} elif "rc" not in kwargs and "opcode" not in kwargs: match = {"nhp": kwargs["nhp"], "ifname": kwargs["port"]} elif table == "ERROR_NEIGH_TABLE": st.log("table") command = redis.build( dut, redis.ERROR_DB, "hgetall {}:{}:{}".format(table, kwargs["port"], kwargs["nhp"])) if kwargs["opcode"] == "create": match = { "mac": kwargs["mac"], "rc": kwargs["rc"], "ifname": kwargs["port"], "opcode": kwargs["opcode"] } elif kwargs["opcode"] == "remove": match = {"rc": kwargs["rc"], "opcode": kwargs["opcode"]} elif "rc" not in kwargs and "opcode" not in kwargs: match = {"ifname": kwargs["port"], "mac": kwargs["mac"]} output = st.show(dut, command) output = _get_entries_with_native_port(dut, output, **kwargs) st.debug(output) if not filter_and_select(output, None, match): st.error("No match found") return False return True
def verify_error_db_redis(dut, table, **kwargs): """ Verify error db using redis cli Author : Prudvi Mangadu ([email protected]) :param :dut: :param :table: :param :route: :param :mask: :param :ifname: :param :nhp: :param :operation: :param :rc: :param :result: (Default True) :param :iteration: default(30) :return: """ port = kwargs.pop("ifname") port = st.get_other_names(dut, [port])[0] if "/" in port else port exp_result = kwargs.get("result", True) iteration = kwargs.get("iteration", 30) command = '' if table == "ERROR_ROUTE_TABLE": command = redis.build( dut, redis.ERROR_DB, "hgetall {}:{}/{}".format(table, kwargs.pop("route"), kwargs.pop("mask"))) elif table == "ERROR_NEIGH_TABLE": command = redis.build( dut, redis.ERROR_DB, "hgetall {}:{}:{}".format(table, port, kwargs.pop("nhp"))) else: st.error("Invalid table name - {}".format(table)) i = 1 while True: output = st.show(dut, command) st.debug(output) result = True for each in kwargs.keys(): if not filter_and_select(output, None, {each: kwargs[each]}): st.error("No match for {} = {} in redis cli".format( each, kwargs[each])) result = False if result == exp_result: return True if i >= iteration: return False i += 1 st.wait(1)
def verify_hardware_map_status(dut, queues, itter_count=30, delay=1): """ To verify the Queue init in hardware :param dut: :param queues: :param itter_count: :param delay: :return: """ command = redis.build(dut, redis.COUNTERS_DB, "keys *MAP*") queues_li = utils.make_list(queues) i = 1 while True: output = st.show(dut, command) output_list = utils.filter_and_select(output, ["name"], None) output_list = utils.dicts_list_values(output_list, "name") result = True for each_q in queues_li: if each_q not in output_list: st.log("{} not yet init.".format(each_q)) result = False if result: return True if i > itter_count: st.log("Max {} tries Exceeded.Exiting..".format(i)) return False i += 1 st.wait(delay)
def verify_nat_entry_db(dut, table, prot, ip, port, **kwargs): """ Author : Priyanka :param dut: :param table: :param prot: :param ip: :param port: :param kwargs: :return: """ string = '' if table == "NAT_TABLE": string = "NAT_TABLE:{}".format(ip) elif table == "NAPT_TABLE": string = "NAPT_TABLE:{}:{}:{}".format(prot, ip, port) command = redis.build(dut, redis.APPL_DB, "hgetall {}".format(string)) output = st.show(dut, command) st.debug(output) for each in kwargs.keys(): match = {each: kwargs[each]} entries = filter_and_select(output, None, match) if not entries: st.log("{} and {} is not match ".format(each, kwargs[each])) return False return True
def verify_stp_entry_db(dut, table, vlan = None, ifname = None, **kwargs): """ """ if table == "_STP_VLAN_INTF_TABLE": cmd = "Vlan"+str(vlan) string = "{}:{}:{}".format(table, cmd, ifname) elif table == "_STP_PORT_TABLE": string = "{}:{}".format(table, ifname) else: print("invalid table") return False print("string is-") print(string) command = redis.build(dut, redis.APPL_DB, "hgetall {}".format(string)) print("command is -", command) output = st.show(dut, command) print("output is -") print(output) st.debug(output) print("kwargs: ", kwargs) for each in kwargs.keys(): match = {each: kwargs[each]} entries = filter_and_select(output, None, match) print("match :", match) print("entries:", entries) if not entries: st.log("{} and {} do not match ".format(each, kwargs[each])) return False return True
def get_num_entries_error_db(dut, ifname_type=None): """ To Get total entries in Error Database using redis cli :param dut: :return: """ command = redis.build(dut, redis.ERROR_DB, "keys ERROR.*") output = st.show(dut, command) output = _get_entries_with_native_port(dut, output, ifname_type=ifname_type) st.debug(output) return len(output)
def show_asicDB_macs(dut): ''' Klish support not needed Author: [email protected] Display MACs in asicDB :param dut: :param kwargs: :return: ''' ### Collect asicDB st.log("AsicDB MAC Entries:") st.show(dut, redis.build(dut, redis.ASIC_DB, 'keys *FDB*'), skip_tmpl=True)
def set_nat_timeout_db(dut, prot, seconds): """ Author : Akhilesh :param dut: :param prot: :param seconds: :return: """ if prot == "tcp": timeout = "nat_tcp_timeout" elif prot == "udp": timeout = "nat_udp_timeout" elif prot == "all": timeout = "nat_timeout" string = "\"NAT_GLOBAL|Values\" \"{}\" {}".format(timeout, seconds) command = redis.build(dut, redis.CONFIG_DB, "hset {}".format(string)) st.config(dut, command) return True
def verify_ip_mroute_appdb(dut, source, group, **kwargs): """ Author : Kiran Kumar K :param : source: :type : address :param : group: :type : address :type : interface name :return: :type: bool """ if 'vrf' in kwargs: vrf_name = kwargs['vrf'] del kwargs['vrf'] else: vrf_name = 'default' if vrf_name != 'default': key = "IPMC_ROUTE_TABLE:{}|{}|{}".format(vrf_name, source, group) else: key = "IPMC_ROUTE_TABLE:{}|{}".format(source, group) print(key) command = redis.build(dut, redis.APPL_DB, "hgetall \"{}\"".format(key)) print(command) output = st.show(dut, command) print(output) st.debug(output) if len(output) == 0: return False for each in kwargs.keys(): print(each) match = {each: kwargs[each]} entries = filter_and_select(output, None, match) if not entries: st.log("{} and {} is not match ".format(each, kwargs[each])) return False return True
def verify_port_table_port_config(dut, itter_count=30, delay=1): """ To verify the Port Table Port config status Author: Prudvi Mangadu ([email protected]) :param dut: :param itter_count: :param delay: :return: """ command = redis.build(dut, redis.APPL_DB, "HGETALL PORT_TABLE:PortConfigDone") i = 1 while True: output = st.show(dut, command) output_list = utils.filter_and_select(output, ["name"], None) output_list = utils.dicts_list_values(output_list, "name") if 'count' in output_list: st.log("{}".format(output)) return True if i > itter_count: st.log("Max {} tries Exceeded.Exiting..".format(i)) return False i += 1 st.wait(delay)
def verify_intf_mcast_mode_in_appdb(dut, in_intf, **kwargs): """ Author : Kiran Kumar K :param : in_intf: :type : interface name :return: :type: bool """ key = "INTF_TABLE:{}".format(in_intf) print(key) command = redis.build(dut, redis.APPL_DB, "hgetall {}".format(key)) print(command) output = st.show(dut, command) print(output) st.debug(output) for each in kwargs.keys(): match = {each: kwargs[each]} entries = filter_and_select(output, None, match) if not entries: st.log("{} and {} is not match ".format(each, kwargs[each])) return False return True
def client_auth(dut, **kwargs): """ To enable disable gNMI client auth. Author: Prudvi Mangadu ([email protected]) :param dut: :param auth_type: :return: """ st.log("Configuring gNMI authentication.") docker_name= "telemetry" command = redis.build(dut, redis.CONFIG_DB, 'hmset "TELEMETRY|gnmi" client_auth') if 'auth_type' in kwargs: if kwargs.get('auth_type'): command = redis.build(dut, redis.CONFIG_DB, 'hmset "TELEMETRY|gnmi" client_auth "{}"'.format(kwargs.get('auth_type'))) else: command = redis.build(dut, redis.CONFIG_DB, 'hdel "TELEMETRY|gnmi" client_auth') st.config(dut, command) if 'server_key' in kwargs: if kwargs.get('server_key'): command = redis.build(dut, redis.CONFIG_DB, 'hmset "DEVICE_METADATA|x509" server_key "{}"'.format(kwargs.get('server_key'))) st.config(dut, command) if 'server_crt' in kwargs: if kwargs.get('server_crt'): command = redis.build(dut, redis.CONFIG_DB, 'hmset "DEVICE_METADATA|x509" server_crt "{}"'.format(kwargs.get('server_crt'))) st.config(dut, command) if 'ca_crt' in kwargs: if kwargs.get('ca_crt'): command = redis.build(dut, redis.CONFIG_DB, 'hmset "DEVICE_METADATA|x509" ca_crt "{}"'.format(kwargs.get('ca_crt'))) else: command = redis.build(dut, redis.CONFIG_DB, 'hdel "DEVICE_METADATA|x509" ca_crt') st.config(dut, command) service_operations_by_systemctl(dut, docker_name, 'stop') service_operations_by_systemctl(dut, docker_name, 'start') command = 'sonic-cfggen -d -v "TELEMETRY"' st.config(dut, command) return True
def show(dut, *argv, **kwargs): """ show commands summary Author: prudviraj k ([email protected]) :param dut: :param argv: :param interval: :param clear_interval: :param persistent_head: :param persistent_shared: :param threshold_head: :param threshold__shared: :param watermark_head: :param watermark_shared: :param port_alias: :param column_name: :param queue_value: :return: """ cli_type = st.get_ui_type(dut, **kwargs) if cli_type in ["rest-patch", "rest-put"] and 'column_name' in kwargs: cli_type = 'klish' if cli_type in ["rest-patch", "rest-put"]: for queue_type in argv: if queue_type in [ "buffer_pool_watermark", "buffer_pool_persistent-watermark", "buffer_pool_counters_DB" ]: cli_type = 'klish' persistent = "show priority-group persistent-watermark" user_watermark = "show priority-group watermark" queue_user_watermark = "show queue watermark" queue_persistent_watermark = "show queue persistent-watermark" if cli_type == 'click' or cli_type == 'klish': if "snapshot_interval" in argv: command = "show watermark interval" elif 'telemetry_interval' in argv: command = "show watermark telemetry interval" elif 'persistent_PG_headroom' in argv: command = persistent + " " + "{}".format("headroom") elif 'persistent_PG_shared' in argv: command = persistent + " " + "{}".format("shared") elif 'user_watermark_PG_headroom' in argv: command = user_watermark + " " + "{}".format("headroom") elif 'user_watermark_PG_shared' in argv: command = user_watermark + " " + "{}".format("shared") elif 'queue_user_watermark_unicast' in argv: command = queue_user_watermark + " " + "{}".format("unicast") elif 'queue_user_watermark_multicast' in argv: command = queue_user_watermark + " " + "{}".format("multicast") elif 'queue_user_watermark_cpu' in argv: command = queue_user_watermark + " " + "{}".format("CPU") elif 'queue_persistent_watermark_unicast' in argv: command = queue_persistent_watermark + " " + "{}".format("unicast") elif 'queue_persistent_watermark_multicast' in argv: command = queue_persistent_watermark + " " + "{}".format( "multicast") elif 'buffer_pool_watermark' in argv or 'percent' in kwargs: if cli_type == 'klish' and 'percent' in kwargs: perc = 'percentage' else: perc = kwargs.get('percent', '') command = "show buffer_pool watermark {}".format(perc) elif 'buffer_pool_persistent-watermark' in argv or 'percent' in kwargs: if cli_type == 'klish' and 'percent' in kwargs: perc = 'percentage' else: perc = kwargs.get('percent', '') command = "show buffer_pool persistent-watermark {}".format(perc) elif 'column_name' and 'queue_value' in kwargs: intf_name = st.get_other_names( dut, [kwargs['interface_name']])[0] if '/' in kwargs[ 'interface_name'] else kwargs['interface_name'] command = redis.build( dut, redis.COUNTERS_DB, "hget {} {}:{}".format(kwargs['column_name'], intf_name, kwargs['queue_value'])) output = st.show(dut, command) oid = output[0]['oid'].strip('"') command = redis.build( dut, redis.COUNTERS_DB, "hgetall {}:{}".format(kwargs['table_name'], oid)) output = st.show(dut, command) output = output[:-1] dut_output = get_dict_from_redis_cli(output) st.log(dut_output) return [dut_output] elif 'buffer_pool_counters_DB' in argv: command = redis.build(dut, redis.COUNTERS_DB, "Hgetall COUNTERS_BUFFER_POOL_NAME_MAP") output = st.show(dut, command) output = output[:-1] dut_output = get_dict_from_redis_cli(output) st.log(dut_output) command = redis.build( dut, redis.COUNTERS_DB, "hgetall COUNTERS:{}".format( dut_output[kwargs['oid_type']].strip('"'))) output = st.show(dut, command) output = output[:-1] dut_output = get_dict_from_redis_cli(output) st.log(dut_output) return [dut_output] if 'port_alias' in kwargs or 'percentage' in kwargs: if cli_type == 'click': command += " {} | grep -w {}".format( kwargs.get('percentage', ''), kwargs['port_alias']) return st.show(dut, command, type=cli_type) elif cli_type == 'klish': if kwargs['port_alias'] == 'CPU': command += " | grep {}".format(kwargs['port_alias']) else: interface_details = get_interface_number_from_name( kwargs['port_alias']) if 'percentage' in kwargs: using_perc = command.split(" ") using_perc.insert(-1, "percentage") command = " ".join(using_perc) command += " interface {} {}".format( interface_details.get("type"), interface_details.get("number")) else: command += " interface {} {}".format( interface_details.get("type"), interface_details.get("number")) return st.show(dut, command, type=cli_type) elif cli_type in ["rest-patch", "rest-put"]: ret_val = list() rest_urls = st.get_datastore(dut, "rest_urls") if "snapshot_interval" in argv: url = rest_urls['get_watermark_interval'] get_info = get_rest(dut, rest_url=url, timeout=60) temp = dict() temp['snapshotinterval'] = get_info['output'][ 'openconfig-qos-ext:watermark']['state']['refresh-interval'] ret_val.append(temp) st.debug(ret_val) return ret_val elif 'telemetry_interval' in argv: url = rest_urls['get_telemetry_interval'] get_info = get_rest(dut, rest_url=url, timeout=60) temp = dict() temp['telemetryinterval'] = get_info['output'][ 'openconfig-qos-ext:telemetry-watermark']['state'][ 'refresh-interval'] ret_val.append(temp) st.debug(ret_val) return ret_val for queue_type in argv: if 'port_alias' in kwargs or 'percentage' in kwargs: ret_val = list() rest_urls = st.get_datastore(dut, "rest_urls") if queue_type in [ 'queue_user_watermark_unicast', 'queue_user_watermark_multicast', 'queue_persistent_watermark_unicast', 'queue_persistent_watermark_multicast', 'queue_user_watermark_cpu' ]: url = rest_urls['get_queue_counter_values'].format( kwargs['port_alias']) get_info = get_rest(dut, rest_url=url, timeout=60) for entry in get_info['output']['openconfig-qos:queues'][ 'queue']: temp = dict() counters_info = entry['state'] port, queue = counters_info['name'].split(':') type = counters_info["openconfig-qos-ext:traffic-type"] counter = type.lower() + queue if kwargs['port_alias'] == 'CPU': cpu_counter = port + queue temp['queue'] = cpu_counter temp['bytes'] = counters_info[ "openconfig-qos-ext:watermark"] if 'percentage' in kwargs: if queue_type in [ 'queue_user_watermark_unicast', 'queue_user_watermark_multicast' ]: temp[counter] = counters_info[ "openconfig-qos-ext:watermark-percent"] elif queue_type in [ 'queue_persistent_watermark_unicast', 'queue_persistent_watermark_multicast' ]: temp[counter] = counters_info[ "openconfig-qos-ext:persistent-watermark-percent"] else: if queue_type in [ 'queue_user_watermark_unicast', 'queue_user_watermark_multicast' ]: temp[counter] = counters_info[ "openconfig-qos-ext:watermark"] elif queue_type in [ 'queue_persistent_watermark_unicast', 'queue_persistent_watermark_multicast' ]: temp[counter] = counters_info[ "openconfig-qos-ext:persistent-watermark"] ret_val.append(temp) st.debug(ret_val) return ret_val if queue_type in [ 'persistent_PG_shared', 'user_watermark_PG_shared', 'persistent_PG_headroom', 'user_watermark_PG_headroom' ]: url = rest_urls['get_pg_counter_values'].format( kwargs['port_alias']) get_info = get_rest(dut, rest_url=url, timeout=60) for entry in get_info['output'][ 'openconfig-qos-ext:priority-groups'][ 'priority-group']: temp = dict() counters_info = entry['state'] port, queue = counters_info['name'].split(':') for i in range(0, 8): if queue == str(i): counter = 'pg' + str(i) if 'percentage' in kwargs: if queue_type == 'user_watermark_PG_shared': temp[counter] = counters_info[ 'shared-watermark-percent'] elif queue_type == 'user_watermark_PG_headroom': temp[counter] = counters_info[ 'headroom-watermark-percent'] elif queue_type == 'persistent_PG_shared': temp[counter] = counters_info[ 'shared-persistent-watermark-percent'] elif queue_type == 'persistent_PG_headroom': temp[counter] = counters_info[ 'headroom-persistent-watermark-percent'] else: if queue_type == 'user_watermark_PG_shared': temp[counter] = counters_info[ 'shared-watermark'] elif queue_type == 'user_watermark_PG_headroom': temp[counter] = counters_info[ 'headroom-watermark'] elif queue_type == 'persistent_PG_shared': temp[counter] = counters_info[ 'shared-persistent-watermark'] elif queue_type == 'persistent_PG_headroom': temp[counter] = counters_info[ 'headroom-persistent-watermark'] ret_val.append(temp) st.debug(ret_val) return ret_val else: st.error("Unsupported UI Type: {} provided".format(cli_type)) return False