def verify_warm_restart(dut, **kwargs): """ To verify warm restart state and config Author : Prudvi Mangadu ([email protected]) :param dut: :param mode: config | state :param name: :param restore_count: :param state: :param enable: :param timer_name: :param timer_duration: :return: """ if 'mode' not in kwargs: st.error("mode is not passed as argument to API.") return False if kwargs['mode'] in ['config', 'state']: command = "show warm_restart {}".format(kwargs['mode']) else: st.error("Invalid mode provided, supported - mode or config") return False del kwargs['mode'] output = st.show(dut, command, type="click") st.debug(output) entries = utils.filter_and_select(output, None, kwargs) if not entries: return False return True
def config_save(dut, shell='sonic', skip_error_check=True): """ To perform config save. Author : Prudvi Mangadu ([email protected]) :param dut: single or list of duts :return: """ dut_li = list(dut) if isinstance(dut, list) else [dut] st.log("Performing config save") if shell == 'sonic': command = 'config save -y' [retvals, exceps] = utils.exec_foreach(True, dut_li, st.config, command) elif shell == "vtysh": command = 'do copy running-config startup-config' [retvals, exceps] = utils.exec_foreach(True, dut_li, st.config, command, type=shell, skip_error_check=skip_error_check) else: command = "do write memory" [retvals, exceps] = utils.exec_foreach(True, dut_li, st.config, command, type=shell, skip_error_check=skip_error_check) st.debug([retvals, exceps]) return True
def _get_rest_brief_dhcp_relay_data(dut, family='ipv4'): """ To get the dhcp-relay brief data Author Jagadish Chatrasi ([email protected]) :param dut: :param family: :return: """ retval = list() rest_urls = st.get_datastore(dut, 'rest_urls') ip_string = '' if family == 'ipv4' else 'v6' output = get_interface_ip_address(dut, family=family) interfaces = {entry['interface'] for entry in output} interfaces.discard('eth0') for intf in interfaces: url = rest_urls['get_dhcp{}_relay_helper_address'.format(ip_string)].format(id=intf) out = get_rest(dut, rest_url=url) if isinstance(out, dict) and out.get('output') and out['output'].get('openconfig-relay-agent:helper-address') and isinstance(out['output']['openconfig-relay-agent:helper-address'], list): addresses = out['output']['openconfig-relay-agent:helper-address'] for address in addresses: temp = dict() temp['intf'] = intf temp['dhcprelay_addr'] = address retval.append(temp) st.debug(retval) return retval
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 show_nat_config(dut, mode, **kwargs): """ Verify NAT Config :param dut: :param mode: :param kwargs: :return: """ cli_type = st.get_ui_type(dut, **kwargs) cli_type = "klish" if cli_type in ["rest-patch", "rest-put"] else cli_type nat_config_modes = ['globalvalues', 'static', 'pool', 'bindings'] if mode not in nat_config_modes: st.error("Invalid mode {}".format(mode)) return False command = "show nat config {}".format(mode) output = st.show(dut, command, type=cli_type) response = list() match = dict() for each in kwargs.keys(): match.update({each: kwargs[each]}) if match: entries = filter_and_select(output, None, match) if not entries: for each in kwargs.keys(): st.log("{} and {} is not match ".format(each, kwargs[each])) return [] st.debug(entries) if isinstance(entries, dict): response.append(entries) return response else: return entries return output
def get_nat_translations(dut, **kwargs): """ Get NAT Translations Author : Prudvi Mangadu ([email protected]) :param dut: :return: """ get_list = ["trn_src_ip", "trn_src_ip_port", "trn_dst_ip", "trn_dst_ip_port"] cli_type = st.get_ui_type(dut, **kwargs) output = show_nat_translations(dut, cli_type=cli_type) st.log(output) match = {} if 'protocol' in kwargs: match['protocol'] = kwargs['protocol'] if 'src_ip' in kwargs: match['src_ip'] = kwargs['src_ip'] if 'src_ip_port' in kwargs: match['src_ip_port'] = kwargs['src_ip_port'] if 'dst_ip' in kwargs: match['dst_ip'] = kwargs['dst_ip'] if 'dst_ip_port' in kwargs: match['dst_ip_port'] = kwargs['dst_ip_port'] st.debug(match) entries = filter_and_select(output, get_list, match) return entries
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 copp_module_hooks(request): global vars, tg, tg_ph_1, d1_p1, hw_constants, deviation_percentage, d1_p1_mac, copp_data, vlan_igmp, copp_data_pir vars = st.ensure_min_topology("D1T1:1") hw_constants = st.get_datastore(vars.D1, "constants", "default") st.debug("hw_constants: {}".format(hw_constants)) tg, tg_ph_1 = tgapi.get_handle_byname("T1D1P1") d1_p1 = vars.D1T1P1 vlan_igmp = 3188 vlan_obj.create_vlan(vars.D1, vlan_igmp) deviation_percentage = 0.05 ret_val = copp_obj.get_copp_config(dut=vars.D1, table_name='all') if ret_val: copp_data = ret_val else: st.report_fail('module_config_failed', 'show copp config command failed') copp_data_pir = copp_obj.set_copp_pir_config(vars.D1, config='get') # Get the DUT mac address d1_p1_mac = basic_obj.get_ifconfig(vars.D1, d1_p1)[0]['mac'] # Config the routing interface ip_obj.config_ip_addr_interface(dut=vars.D1, interface_name=d1_p1, ip_address='1.1.1.2', subnet='24') yield # Un-configure the routing interface ip_obj.delete_ip_interface(dut=vars.D1, interface_name=d1_p1, ip_address='1.1.1.2', subnet='24') vlan_obj.delete_vlan(vars.D1, vlan_igmp)
def rest_get_fallback_status(dut, portchannel): """ Author: Jagadish Chatrasi ([email protected]) :param dut: :type dut: :param portchannel: :type str: :return: :rtype: """ rest_urls = st.get_datastore(dut, 'rest_urls') ret_val = [] try: fallback_info = dict() url = rest_urls['fallback_oper_status_get'].format(portchannel) oper_info = get_rest(dut, rest_url=url) url = rest_urls['fallback_enable_config'].format(portchannel) enable_info = get_rest(dut, rest_url=url) fallback_info['port_channel_name'] = portchannel fallback_info['fallback_config'] = 'Enabled' if enable_info['output'][ 'openconfig-interfaces-ext:fallback'] else 'Disabled' fallback_info['fallback_oper_status'] = 'Enabled' if oper_info[ 'output']['openconfig-interfaces-ext:fallback'] else 'Disabled' ret_val.append(fallback_info) st.debug(ret_val) return ret_val except Exception as e: st.error("{} exception occurred".format(e)) st.debug(ret_val) return ret_val
def check_unwanted_logs_in_logging(dut, user_filter=None): """ Check unwanted log based on uers filter list Author: Prudvi Mangadu ([email protected]) :param dut: :param user_filter: :return: """ result = True static_filter = ['i2c', 'fan', 'power'] over_all_filter = static_filter + make_list( user_filter) if user_filter else static_filter for filter in over_all_filter: temp_count = get_logging_count(dut, filter_list=filter) st.debug("{} - logs found on the error string '{}'".format( temp_count, filter)) if temp_count: if filter == 'fan': filters = ["INFO system#monitor: MEM :: Name:fand"] logs = show_logging(dut, filter_list=filter) for log in logs: if not any(fil.lower() in log.lower() for fil in filters): result = False else: result = False return result
def get_rest_server_info(server_output): ret_val = [] try: servers = server_output["openconfig-system:server"] for server in servers: temp = dict() server_details = server['state'] req_params = ['address', 'openconfig-system-ext:reach', 'openconfig-system-ext:now', 'stratum', 'openconfig-system-ext:peerdelay', 'openconfig-system-ext:peertype', 'openconfig-system-ext:peeroffset', 'openconfig-system-ext:peerjitter', 'poll-interval', 'openconfig-system-ext:refid', 'openconfig-system-ext:selmode'] if all(param in server_details for param in req_params): temp['remote'] = str(server_details['openconfig-system-ext:selmode']+server_details['address']) temp['reach'] = str(server_details['openconfig-system-ext:reach']) temp['when'] = str(server_details['openconfig-system-ext:now']) temp['st'] = str(server_details['stratum']) temp['delay'] = str(server_details['openconfig-system-ext:peerdelay']) temp['t'] = str(server_details['openconfig-system-ext:peertype']) temp['offset'] = str(server_details['openconfig-system-ext:peeroffset']) temp['jitter'] = str(server_details['openconfig-system-ext:peerjitter']) temp['poll'] = str(server_details['poll-interval']) temp['refid'] = str(server_details['openconfig-system-ext:refid']) ret_val.append(temp) st.debug(ret_val) return ret_val except Exception as e: st.error("{} exception occurred".format(e)) st.debug("Given data is: {}".format(server_output)) return ret_val
def verify_ntp_synch(dut, server): entries = show_ntp_server(dut) if filter_and_select(entries, None, {'remote': "*{}".format(server)}): st.debug("NTP synchronized with server: {}".format(server)) return True st.error("NTP not synchronized with server: {}".format(server)) return False
def get_intf_pmap(dut, interface_name=None): """ Author: Chaitanya Vella ([email protected]) This API is used to get the interface pmap details :param dut: dut :param interface_name: List of interface names :return: """ import apis.system.interface as interface_obj ##Passing the cli_type as click in the API call "interface_status_show" because the lanes information is available only in click CLI. ##Please refer the JIRA: SONIC-22102 for more information. interfaces = cutils.make_list(interface_name) if interface_name else '' if interfaces: if any("/" in interface for interface in interfaces): interfaces = st.get_other_names(dut, interfaces) key = 'alias' else: key = 'interface' st.debug("The interfaces list is: {}".format(interfaces)) interface_list = interface_obj.interface_status_show( dut, interfaces=interfaces, cli_type='click') else: key = 'alias' if interface_obj.show_ifname_type( dut, cli_type='klish') else 'interface' interface_list = interface_obj.interface_status_show(dut, cli_type='click') interface_pmap = dict() pmap_list = get_pmap(dut) for detail in cutils.iterable(interface_list): lane = detail["lanes"].split( ",")[0] if "," in detail["lanes"] else detail["lanes"] for pmap in pmap_list: if pmap["physical"] == lane: interface_pmap[detail[key]] = pmap["interface"] return interface_pmap
def verify_show_nat_config_static(dut, mode=None, **kwargs): """ Author : Priyanka :param :dut: :param :mode: :param :local_ip: :param :global_ip: :param :nat_type: :param :twice_nat_id: :param :prot: :param :local_port: :param :global_port: """ nat_config_modes = ['globalvalues', 'static', 'pool', 'bindings'] if mode not in nat_config_modes: st.error("Invalid mode {}, should be in {}".format(mode, ','.join(nat_config_modes))) return False command = "show nat config {}".format(mode) 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 rest_get_queue_counters(dut, port): """ Author: Jagadish Chatrasi ([email protected]) :param dut: :type dut: :param port: :type port: :return: :rtype: """ ret_val = list() rest_urls = st.get_datastore(dut, 'rest_urls') url = rest_urls['queue_counters_get'].format(port) try: 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(':') temp['port'] = port temp['txq'] = "{}{}".format( counters_info["openconfig-qos-ext:traffic-type"], queue) temp['pkts_drop'] = counters_info['dropped-pkts'] temp['byte_drop'] = counters_info[ 'openconfig-qos-ext:dropped-octets'] temp['pkts_count'] = counters_info['transmit-pkts'] temp['byte_count'] = counters_info['transmit-octets'] ret_val.append(temp) st.debug(ret_val) return ret_val except Exception as e: st.error("{} exception occurred".format(e)) st.log("The output is:{}".format(get_info)) st.debug(ret_val) return ret_val
def apis_common_init(scope, ref=None): """ :param scope: :type scope: :param ref: :type ref: :return: :rtype: """ from spytest import st, utils if scope == "session": return _api_common_session_begin() if scope == "module": st.debug("---- common module {} begin ----".format(ref)) elif scope == "function": st.debug("---- common test {} begin ----".format(ref)) if not os.getenv("SPYTEST_SKIP_INIT_COMMANDS"): def f(dut): if st.get_device_type(dut) in ["sonic", "vsonic"]: if not st.is_community_build(): st.show(dut, "show system status", skip_error_check=True, skip_tmpl=True) utils.exec_foreach(True, st.get_dut_names(), f)
def get_mac_entries_by_mac_address(dut, mac_address, **kwargs): ''' Display MAC entries with a MAC search pattern and return the output. :param mac_address: :param cli_type: :return: ''' cli_type = st.get_ui_type(dut, **kwargs) if cli_type == 'click': command = "show mac | grep {}".format(mac_address) mac_entries = st.show(dut, command) elif cli_type == 'klish': command = "show mac address-table | grep {}".format(mac_address) mac_entries = st.show(dut, command, type=cli_type) elif cli_type in ["rest-patch", "rest-put"]: entries = get_mac(dut, cli_type=cli_type) st.debug(entries) mac_entries = [] for entry in entries: exp = "^{}".format(mac_address.strip()) if re.search(exp, entry['macaddress'], re.IGNORECASE): mac_entries.append(entry) st.debug(mac_entries) else: st.log("Unsupported cli") return False return mac_entries
def verify_nat_translations(dut, **kwargs): """ Verify NAT Translations Author : Prudvi Mangadu ([email protected]) :param :dut: :param :protocol :param :src_ip :param :src_ip_port :param :dst_ip :param :dst_ip_port :param :trn_src_ip :param :trn_src_ip_port :param :trn_dst_ip :param :trn_dst_ip_port :return: """ entries = None cli_type = st.get_ui_type(dut, **kwargs) output = show_nat_translations(dut, cli_type=cli_type) st.debug(output) for each in kwargs.keys(): match = {each: kwargs[each]} get_list = ["trn_src_ip", "trn_src_ip_port", "trn_dst_ip", "trn_dst_ip_port"] entries = filter_and_select(output, get_list, match) if not entries: st.log("{} and {} is not match ".format(each, kwargs[each])) return False return entries
def show_threshold_breaches(dut, cli_type=""): """ Show Threshold Breaches Author: Prudvi Mangadu ([email protected]) :param dut: :cli_type :return: """ cli_type = st.get_ui_type(dut, cli_type=cli_type) if cli_type in ["click", "klish"]: command = "show threshold breaches" output = st.show(dut, command, type=cli_type) elif cli_type in ["rest-patch", "rest-put"]: output = list() url = st.get_datastore(dut, "rest_urls")["threshold_breaches"] try: get_resp = get_rest(dut, rest_url=url)["output"]["openconfig-qos-ext:threshold-breaches"]["breach"] for each in get_resp: breach = dict() if "state" in each: breach["eventid"] = str(each["id"]) breach["index"] = str(each["state"]["index"]) breach["buffer"] = each["state"]["buffer"] breach["threshold_type"] = each["state"]["type"] breach["counter"] = each["state"]["counter"] breach["value"] = str(each["state"]["breach-value"]) breach["port"] = each["state"]["port"] output.append(breach) except Exception as e: st.debug("Error in getting threshold breaches") st.debug(e) return [] return output
def check_ports_from_rest_output(resp, threshold_type, buffer_type, dut_ports): if any("/" in interface for interface in make_list(dut_ports)): dut_ports = st.get_other_names(vars.D1, make_list(dut_ports)) result = True if threshold_type == 'priority-group' and buffer_type in [ 'shared', 'headroom' ]: rest_ports = [each['port'] for each in resp['report'][0]['data']] elif threshold_type == 'queue' and buffer_type in ['unicast', 'multicast']: rest_ports = list(set([each[1] for each in resp['report'][0]['data']])) else: st.error('No Match for threshold_type and buffer_type found') return None for each in dut_ports: if each not in rest_ports: st.error( ">>> Port '{}' information is *not* available in REST data of {} {}" .format(each, threshold_type, buffer_type)) result = False else: st.debug( "Port '{}' information is available in REST data".format(each)) return result
def rbac_module_epilog(): sshapi.ssh_keygen(vars.D2, mode='destroy', path=rbac.client_keygen_path) rbac_config_user(1) rest_client_auth(vars.D1, auth_type='') gnmi_client_auth(vars.D1, auth_type='') password = st.get_credentials(vars.D1)[3] st.debug("The password for user: {} is: {}".format( rbac.default_user['username'], password))
def verify_ip_in_network(ip_address, prefix): st.debug("IP ADDRESS : {}".format(ip_address)) st.debug("NETWORK : {}".format(prefix)) [prefix_address, net_size] = prefix.split("/") net_size = int(net_size) prefix_network = get_network_from_address(prefix_address, net_size) ip_network = get_network_from_address(ip_address, net_size) return ip_network == prefix_network
def show_ndp(dut, inet6_address=None, **kwargs): """ to get ndp table info Author: Chaitanya Vella ([email protected]) :param dut: :param inet6_address: :return: """ cli_type = st.get_ui_type(dut, **kwargs) if cli_type == "click": if 'vrf' not in kwargs: command = "show ndp" if inet6_address: command += " {}".format(inet6_address) elif "interface" in kwargs and kwargs["interface"]: command += " -if {}".format(kwargs["interface"]) elif 'vrf' in kwargs: vrf = kwargs['vrf'] command = "show ndp -vrf {}".format(vrf) if inet6_address: command += " {}".format(inet6_address) elif "interface" in kwargs and kwargs["interface"]: command += " -if {}".format(kwargs["interface"]) elif cli_type == "klish": if 'vrf' not in kwargs: command = "show ipv6 neighbors" if inet6_address: command += " {}".format(inet6_address) elif kwargs.get("interface"): intf = get_interface_number_from_name(kwargs.get("interface")) command += " interface {} {}".format(intf["type"], intf["number"]) elif 'vrf' in kwargs: vrf = kwargs['vrf'] command = "show ipv6 neighbors vrf {}".format(vrf) if inet6_address: command += " {}".format(inet6_address) elif cli_type in ["rest-patch", "rest-put"]: output = list() if kwargs.get('vrf'): interfaces = _get_rest_l3_interfaces(dut, vrf=kwargs['vrf']) else: interfaces = _get_rest_l3_interfaces(dut) for interface in interfaces: output.extend( _get_rest_neighbor_entries(dut, interface, is_arp=False)) st.debug(output) if inet6_address: return filter_and_select(output, None, {'address': inet6_address}) elif kwargs.get('interface'): return filter_and_select(output, None, {'interface': kwargs['interface']}) else: return output else: st.error("Unsupported CLI Type: {}".format(cli_type)) return False return st.show(dut, command, type=cli_type)
def show_ztp_status(dut, expect_reboot=False, cli_type=""): """ Author: Chaitanya Vella ([email protected]) API to show ztp status :param dut: :return: """ cli_type = st.get_ui_type(dut, cli_type=cli_type) result = dict() cli_type = "klish" if cli_type in ["rest-put", "rest-patch"] else cli_type if cli_type not in ["click", "klish"]: st.error("UNSUPPORTED CLI TYPE") return result command = "sudo ztp status" if cli_type == "click" else "show ztp-status" output = st.show(dut, command, expect_reboot=False, type=cli_type) file_name = dict() timestamps = dict() #excluded_file_name = ["--sonic-mgmt--#"] if output: for row in output: result["filenames"] = list() result["timestamps"] = list() if result.get("service"): pass else: result["service"] = row.get("service", "") # if not result["source"]: if result.get("source"): pass else: result["source"] = row.get("source", "") # if not result["status"]: if result.get("status"): pass else: result["status"] = row.get("status", "") # if not result["adminmode"]: if result.get("adminmode"): pass else: result["adminmode"] = row.get("adminmode", "") # if not result["timestamp"]: result["timestamp"] = row.get("timestamp", "") if row.get("filename"): if cli_type == "click": values = row["filename"].split(":") file_name[values[0].strip()] = values[1].strip() result["filenames"].append(file_name) elif cli_type == "klish": file_name[row.get("filename")] = row.get("filestatus") result["filenames"].append(file_name) if row.get("filetimestamp"): timestamps.update({row.get("filename"):row.get("filetimestamp")}) result["timestamps"].append(timestamps) # if not result["processingtext"]: # result["processingtext"] = row["processingtext"] if "processingtext" in row and row["processingtext"] else "" st.debug(result) return result
def _get_rest_dhcp_relay_statistics(dut, interface="", family='ipv4'): """ To get the dhcp-relay statistics data Author Jagadish Chatrasi ([email protected]) :param dut: :param interface: :param family: :return: """ retval = list() rest_urls = st.get_datastore(dut, 'rest_urls') ip_string = '' if family == 'ipv4' else 'v6' if not interface: output = get_interface_ip_address(dut, family=family) interfaces = {entry['interface'] for entry in output} interfaces.discard('eth0') else: interfaces = make_list(interface) for intf in interfaces: url = rest_urls['get_dhcp{}_relay_counters'.format(ip_string)].format(id=intf) out = get_rest(dut, rest_url=url) if isinstance(out, dict) and out.get('output') and out['output'].get('openconfig-relay-agent:counters') and isinstance(out['output']['openconfig-relay-agent:counters'], dict): data = out['output']['openconfig-relay-agent:counters'] temp = dict() if family == 'ipv4': temp['bootrequest_msgs_received_by_the_relay_agent'] = str(data['bootrequest-received']) if data.get('bootrequest-received') else '0' temp['bootrequest_msgs_forwarded_by_the_relay_agent'] = str(data['bootrequest-sent']) if data.get('bootrequest-sent') else '0' temp['bootreply_msgs_forwarded_by_the_relay_agent'] = str(data['bootreply-sent']) if data.get('bootreply-sent') else '0' temp['dhcp_ack_msgs_sent_by_the_relay_agent'] = str(data['dhcp-ack-sent']) if data.get('dhcp-ack-sent') else '0' temp['dhcp_decline_msgs_received_by_the_relay_agent'] = str(data['dhcp-decline-received']) if data.get('dhcp-decline-received') else '0' temp['dhcp_discover_msgs_received_by_the_relay_agent'] = str(data['dhcp-discover-received']) if data.get('dhcp-discover-received') else '0' temp['dhcp_inform_msgs_received_by_the_relay_agent'] = str(data['dhcp-inform-received']) if data.get('dhcp-inform-received') else '0' temp['dhcp_nack_msgs_sent_by_the_relay_agent'] = str(data['dhcp-nack-sent']) if data.get('dhcp-nack-sent') else '0' temp['dhcp_offer_msgs_sent_by_the_relay_agent'] = str(data['dhcp-offer-sent']) if data.get('dhcp-offer-sent') else '0' temp['dhcp_release_msgs_received_by_the_relay_agent'] = str(data['dhcp-release-received']) if data.get('dhcp-release-received') else '0' temp['dhcp_request_msgs_received_by_the_relay_agent'] = str(data['dhcp-request-received']) if data.get('dhcp-request-received') else '0' temp['number_of_dhcp_pkts_drpd_due_to_an_invd_opcode'] = str(data['invalid-opcode']) if data.get('invalid-opcode') else '0' temp['number_of_dhcp_pkts_drpd_due_to_an_invd_option'] = str(data['invalid-options']) if data.get('invalid-options') else '0' temp['total_nbr_of_dhcp_pkts_drpd_by_the_relay_agent'] = str(data['total-dropped']) if data.get('total-dropped') else '0' else: temp['dhcpv6_advt_msgs_sent_by_the_relay_agent'] = str(data['dhcpv6-adverstise-sent']) if data.get('dhcpv6-adverstise-sent') else '0' temp['dhcpv6_confirm_msgs_rcvd_by_the_relay_agent'] = str(data['dhcpv6-confirm-received']) if data.get('dhcpv6-confirm-received') else '0' temp['dhcpv6_decline_msgs_rcvd_by_the_relay_agent'] = str(data['dhcpv6-decline-received']) if data.get('dhcpv6-decline-received') else '0' temp['dhcpv6_info_rqst_msgs_rcvd_by_the_relay_agent'] = str(data['dhcpv6-info-request-received']) if data.get('dhcpv6-info-request-received') else '0' temp['dhcpv6_rebind_msgs_rcvd_by_the_relay_agent'] = str(data['dhcpv6-rebind-received']) if data.get('dhcpv6-rebind-received') else '0' temp['dhcpv6_reconfig_msgs_sent_by_the_relay_agent'] = str(data['dhcpv6-reconfigure-sent']) if data.get('dhcpv6-reconfigure-sent') else '0' temp['dhcpv6_relay_fwd_msgs_sent_by_the_relay_agent'] = str(data['dhcpv6-relay-forw-sent']) if data.get('dhcpv6-relay-forw-sent') else '0' temp['dhcpv6_relay_reply_msgs_rcvd_by_the_relay_agent'] = str(data['dhcpv6-relay-reply-received']) if data.get('dhcpv6-relay-reply-received') else '0' temp['dhcpv6_release_msgs_rcvd_by_the_relay_agent'] = str(data['dhcpv6-release-received']) if data.get('dhcpv6-release-received') else '0' temp['dhcpv6_reply_msgs_sent_by_the_relay_agent'] = str(data['dhcpv6-reply-sent']) if data.get('dhcpv6-reply-sent') else '0' temp['dhcpv6_rqst_msgs_rcvd_by_the_relay_agent'] = str(data['dhcpv6-request-received']) if data.get('dhcpv6-request-received') else '0' temp['dhcpv6_solic_msgs_rcvd_by_the_relay_agent'] = str(data['dhcpv6-solicit-received']) if data.get('dhcpv6-solicit-received') else '0' temp['number_of_dhcpv6_pkts_drpd_due_to_an_inv_opcode'] = str(data['invalid-opcode']) if data.get('invalid-opcode') else '0' temp['number_of_dhcpv6_pkts_drpd_due_to_an_inv_option'] = str(data['invalid-options']) if data.get('invalid-options') else '0' temp['total_nbr_of_dhcpv6_pkts_drpd_by_the_relay_agent'] = str(data['total-dropped']) if data.get('total-dropped') else '0' retval.append(temp) st.debug(retval) return retval
def poll_verify_interface_ip_address(dut, interface_name, ip_address, loopCnt): iter = 1 while True: out = ip_obj.get_interface_ip_address(dut, interface_name=interface_name, family="ipv6") st.debug("The ipv6 interface output is: {}".format(out)) if out and out[0]['ipaddr'] in ip_address: return True if iter > loopCnt: return False iter = iter + 1
def bcm_cmd_l3_intf_show(dut, **kwargs): command = "bcmcmd 'l3 intf show'" output = st.show(dut, command) st.debug(output) for each in kwargs.keys(): if utils.filter_and_select(output, None, {each: kwargs[each]}): st.error("No match for {} = {} in table".format( each, kwargs[each])) return False return True
def show_arp(dut, ipaddress=None, interface=None, vrf="", cli_type=""): """ To get arp table info Author: Prudvi Mangadu ([email protected]) :param dut: :param ipaddress: :param interface: :return: """ cli_type = st.get_ui_type(dut, cli_type=cli_type) if cli_type == "click": if vrf == "": command = "show arp" if ipaddress: command += " {}".format(ipaddress) elif interface: command += " -if {}".format(interface) elif vrf != "": command = "show arp -vrf {}".format(vrf) if ipaddress: command = "show arp {}".format(ipaddress) elif interface: command = "show arp -if {}".format(interface) elif cli_type == "klish": if vrf == "": command = "show ip arp" if ipaddress: command += " {}".format(ipaddress) elif interface: intf = get_interface_number_from_name(interface) command += " interface {} {}".format(intf["type"], intf["number"]) elif vrf != "": command = "show ip arp vrf {}".format(vrf) if ipaddress: command += " {}".format(ipaddress) elif cli_type in ['rest-patch', 'rest-put']: output = list() if vrf: interfaces = _get_rest_l3_interfaces(dut, vrf=vrf) else: interfaces = _get_rest_l3_interfaces(dut) for intf in interfaces: output.extend(_get_rest_neighbor_entries(dut, intf)) st.debug(output) if ipaddress: return filter_and_select(output, None, {'address': ipaddress}) elif interface: return filter_and_select(output, None, {'iface': interface}) else: return output else: st.error("Unsupported CLI_TYPE: {}".format(cli_type)) return False return st.show(dut, command, type=cli_type)
def set_speed(dut, data, cli_type=""): cli_type = st.get_ui_type(dut, cli_type=cli_type) cli_type = 'klish' if cli_type in ['rest-patch', 'rest-put'] else cli_type platform = basic.get_hwsku(dut) ports_per_pg = 12 if platform in ["Accton-AS7326-56X"] else 4 non_portgroup_platforms = [ "Accton-AS7712-32X", "Quanta-IX8A-BWDE-56X", "AS5835-54X" ] if not st.is_feature_supported("port-group", dut): non_portgroup_platforms.append(platform) ports_dict = dict() port_name_dict = dict() for index in range(0, len(data), 2): port = st.get_other_names( dut, [data[index]])[0] if "/" in data[index] else data[index] port_name_dict[port] = data[index + 1] id = re.search(r"\d+", port).group(0) id = (int(int(id) / ports_per_pg)) + 1 ports_dict[str(id)] = data[index + 1] st.debug("port-group speed data: {}".format(ports_dict)) commands = list() if cli_type == 'click': if platform not in non_portgroup_platforms: commands = [ "config portgroup speed {} {}".format(index, speed) for index, speed in ports_dict.items() ] else: commands = [ "portconfig -p {} -s {}".format(port, speed) for port, speed in port_name_dict.items() ] elif cli_type == 'klish': if platform not in non_portgroup_platforms: commands = [ "port-group {} speed {}".format(index, speed) for index, speed in ports_dict.items() ] else: for port, speed in port_name_dict.items(): intf_details = get_interface_number_from_name(port) if not intf_details: st.error("Interface data not found for {} ".format(port)) continue commands.append("interface {} {}".format( intf_details["type"], intf_details["number"])) commands.append("speed {}".format(speed)) commands.append("exit") else: st.error("Unsupported CLI_TYPE: {}".format(cli_type)) if commands: st.config(dut, commands, type=cli_type) return True
def 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)