X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Fvpp_papi_provider.py;h=d22cc7c4b491a539526ee4fefe8ed6d443af4165;hb=17dcec0b9;hp=9f7968bbbb791a800258b067b64ee15bb71a7f50;hpb=c29c0af40eda76e382a63269bca9ff57c6ecf5d5;p=vpp.git diff --git a/test/vpp_papi_provider.py b/test/vpp_papi_provider.py index 9f7968bbbb7..d22cc7c4b49 100644 --- a/test/vpp_papi_provider.py +++ b/test/vpp_papi_provider.py @@ -1,24 +1,12 @@ -import os import fnmatch +import os import time -from hook import Hook from collections import deque -# Sphinx creates auto-generated documentation by importing the python source -# files and collecting the docstrings from them. The NO_VPP_PAPI flag allows -# the vpp_papi_provider.py file to be importable without having to build -# the whole vpp api if the user only wishes to generate the test documentation. -do_import = True -try: - no_vpp_papi = os.getenv("NO_VPP_PAPI") - if no_vpp_papi == "1": - do_import = False -except: - pass - -if do_import: - from vpp_papi import VPP - from vpp_l2 import L2_PORT_TYPE +from six import moves +from vpp_papi import VPP, mac_pton +from hook import Hook +from vpp_l2 import L2_PORT_TYPE # from vnet/vnet/mpls/mpls_types.h MPLS_IETF_MAX_LABEL = 0xfffff @@ -44,6 +32,17 @@ class QOS_SOURCE: IP = 3 +class SYSLOG_SEVERITY: + EMERG = 0 + ALERT = 1 + CRIT = 2 + ERR = 3 + WARN = 4 + NOTICE = 5 + INFO = 6 + DBG = 7 + + class UnexpectedApiReturnValueError(Exception): """ exception raised when the API return value is unexpected """ pass @@ -64,28 +63,37 @@ class VppPapiProvider(object): self.test_class = test_class self._expect_api_retval = self._zero self._expect_stack = [] - jsonfiles = [] - install_dir = os.getenv('VPP_TEST_INSTALL_PATH') - for root, dirnames, filenames in os.walk(install_dir): - for filename in fnmatch.filter(filenames, '*.api.json'): - jsonfiles.append(os.path.join(root, filename)) + install_dir = os.getenv('VPP_INSTALL_PATH') + + # Vapi requires 'VPP_API_DIR', not set when run from Makefile. + if 'VPP_API_DIR' not in os.environ: + os.environ['VPP_API_DIR'] = os.getenv('VPP_INSTALL_PATH') - self.vpp = VPP(jsonfiles, logger=test_class.logger, + self.vpp = VPP(logger=test_class.logger, read_timeout=read_timeout) self._events = deque() def __enter__(self): return self - def expect_negative_api_retval(self): - """ Expect API failure """ + def assert_negative_api_retval(self): + """ Expect API failure - used with with, e.g.: + with self.vapi.assert_negative_api_retval(): + self.vapi. + """ self._expect_stack.append(self._expect_api_retval) self._expect_api_retval = self._negative return self - def expect_zero_api_retval(self): - """ Expect API success """ + def assert_zero_api_retval(self): + """ Expect API success - used with with, e.g.: + with self.vapi.assert_negative_api_retval(): + self.vapi. + + note: this is useful only inside another with block + as success is the default expected value + """ self._expect_stack.append(self._expect_api_retval) self._expect_api_retval = self._zero return self @@ -164,14 +172,14 @@ class VppPapiProvider(object): if hasattr(reply, 'retval') and reply.retval >= 0: msg = "API call passed unexpectedly: expected negative "\ "return value instead of %d in %s" % \ - (reply.retval, repr(reply)) + (reply.retval, moves.reprlib.repr(reply)) self.test_class.logger.info(msg) raise UnexpectedApiReturnValueError(msg) elif self._expect_api_retval == self._zero: if hasattr(reply, 'retval') and reply.retval != expected_retval: msg = "API call failed, expected %d return value instead "\ "of %d in %s" % (expected_retval, reply.retval, - repr(reply)) + moves.reprlib.repr(reply)) self.test_class.logger.info(msg) raise UnexpectedApiReturnValueError(msg) else: @@ -190,10 +198,10 @@ class VppPapiProvider(object): """ self.hook.before_cli(cli) cli += '\n' - r = self.papi.cli_inband(length=len(cli), cmd=cli) + r = self.papi.cli_inband(cmd=cli) self.hook.after_cli(cli) if hasattr(r, 'reply'): - return r.reply.decode().rstrip('\x00') + return r.reply def ppcli(self, cli): """ Helper method to print CLI command in case of info logging level. @@ -203,9 +211,6 @@ class VppPapiProvider(object): """ return cli + "\n" + str(self.cli(cli)) - def _convert_mac(self, mac): - return mac.replace(':', '').decode('hex') - def show_version(self): """ """ return self.api(self.papi.show_version, {}) @@ -333,9 +338,9 @@ class VppPapiProvider(object): 'reverse': reverse, 'is_ipv6': is_ip6}) - def ip6_nd_proxy(self, address, sw_if_index, is_del=0): + def ip6_nd_proxy(self, ip, sw_if_index, is_del=0): return self.api(self.papi.ip6nd_proxy_add_del, - {'address': address, + {'ip': ip, 'sw_if_index': sw_if_index, 'is_del': is_del}) @@ -363,8 +368,10 @@ class VppPapiProvider(object): pref_lifetime=0xffffffff): return self.api(self.papi.sw_interface_ip6nd_ra_prefix, {'sw_if_index': sw_if_index, - 'address': address, - 'address_length': address_length, + 'prefix': { + 'address': address, + 'address_length': address_length, + }, 'use_default': use_default, 'no_advertise': no_advertise, 'off_link': off_link, @@ -486,16 +493,16 @@ class VppPapiProvider(object): return self.api(self.papi.bd_ip_mac_dump, {'bd_id': bd_id}) - def want_ip4_arp_events(self, enable_disable=1, address=0): + def want_ip4_arp_events(self, enable_disable=1, ip="0.0.0.0"): return self.api(self.papi.want_ip4_arp_events, {'enable_disable': enable_disable, - 'address': address, + 'ip': ip, 'pid': os.getpid(), }) - def want_ip6_nd_events(self, enable_disable=1, address=0): + def want_ip6_nd_events(self, enable_disable=1, ip="::"): return self.api(self.papi.want_ip6_nd_events, {'enable_disable': enable_disable, - 'address': address, + 'ip': ip, 'pid': os.getpid(), }) def want_ip6_ra_events(self, enable_disable=1): @@ -623,7 +630,7 @@ class VppPapiProvider(object): interface. (Default value = 0) """ return self.api(self.papi.l2fib_add_del, - {'mac': self._convert_mac(mac), + {'mac': mac, 'bd_id': bd_id, 'sw_if_index': sw_if_index, 'is_add': is_add, @@ -1001,33 +1008,28 @@ class VppPapiProvider(object): def ip_neighbor_add_del(self, sw_if_index, mac_address, - dst_address, + ip_address, is_add=1, - is_ipv6=0, - is_static=0, - is_no_adj_fib=0, - ): + flags=0): """ Add neighbor MAC to IPv4 or IPv6 address. :param sw_if_index: :param mac_address: :param dst_address: :param is_add: (Default value = 1) - :param is_ipv6: (Default value = 0) - :param is_static: (Default value = 0) - :param is_no_adj_fib: (Default value = 0) + :param flags: (Default value = 0/NONE) """ - return self.api( self.papi.ip_neighbor_add_del, - {'sw_if_index': sw_if_index, - 'is_add': is_add, - 'is_ipv6': is_ipv6, - 'is_static': is_static, - 'is_no_adj_fib': is_no_adj_fib, - 'mac_address': mac_address, - 'dst_address': dst_address - } + { + 'is_add': is_add, + 'neighbor': { + 'sw_if_index': sw_if_index, + 'flags': flags, + 'mac_address': mac_address, + 'ip_address': ip_address + } + } ) def ip_neighbor_dump(self, @@ -1047,9 +1049,9 @@ class VppPapiProvider(object): ) def proxy_arp_add_del(self, - low_address, - hi_address, - vrf_id=0, + low, + hi, + table_id=0, is_add=1): """ Config Proxy Arp Range. @@ -1062,9 +1064,9 @@ class VppPapiProvider(object): self.papi.proxy_arp_add_del, {'proxy': { - 'vrf_id': vrf_id, - 'low_address': low_address, - 'hi_address': hi_address, + 'table_id': table_id, + 'low': low, + 'hi': hi, }, 'is_add': is_add}) @@ -1652,6 +1654,39 @@ class VppPapiProvider(object): 'local_num': local_num, 'locals': locals}) + def nat44_lb_static_mapping_add_del_local( + self, + external_addr, + external_port, + local_addr, + local_port, + protocol, + probability, + vrf_id=0, + is_add=1): + """Add/delete NAT44 load-balancing static mapping rule backend + + :param external_addr: external IPv4 address of the servic + :param external_port: external L4 port number of the service + :param local_addr: IPv4 address of the internal node + :param local_port: L4 port number of the internal node + :param protocol: IP protocol number + :param probability: probability of the internal node + :param vrf_id: VRF id of the internal node + :param is_add: 1 if add, 0 if delete + """ + return self.api( + self.papi.nat44_lb_static_mapping_add_del_local, + {'is_add': is_add, + 'external_addr': external_addr, + 'external_port': external_port, + 'local': { + 'addr': local_addr, + 'port': local_port, + 'probability': probability, + 'vrf_id': vrf_id}, + 'protocol': protocol}) + def nat44_lb_static_mapping_dump(self): """Dump NAT44 load balancing static mappings @@ -2678,34 +2713,41 @@ class VppPapiProvider(object): def map_add_domain(self, ip6_prefix, - ip6_prefix_len, ip6_src, - ip6_src_prefix_len, ip4_prefix, - ip4_prefix_len, ea_bits_len=0, psid_offset=0, psid_length=0, - is_translation=0, - is_rfc6052=0, mtu=1280): + return self.api( self.papi.map_add_domain, { 'ip6_prefix': ip6_prefix, - 'ip6_prefix_len': ip6_prefix_len, 'ip4_prefix': ip4_prefix, - 'ip4_prefix_len': ip4_prefix_len, 'ip6_src': ip6_src, - 'ip6_src_prefix_len': ip6_src_prefix_len, 'ea_bits_len': ea_bits_len, 'psid_offset': psid_offset, 'psid_length': psid_length, - 'is_translation': is_translation, - 'is_rfc6052': is_rfc6052, 'mtu': mtu }) + def map_if_enable_disable(self, is_enable, sw_if_index, is_translation): + return self.api( + self.papi.map_if_enable_disable, + { + 'is_enable': is_enable, + 'sw_if_index': sw_if_index, + 'is_translation': is_translation, + }) + + def map_param_set_tcp(self, tcp_mss): + return self.api( + self.papi.map_param_set_tcp, + { + 'tcp_mss': tcp_mss, + }) + def gtpu_add_del_tunnel( self, src_addr, @@ -2808,7 +2850,8 @@ class VppPapiProvider(object): def vxlan_gbp_tunnel_dump(self, sw_if_index=0xffffffff): return self.api(self.papi.vxlan_gbp_tunnel_dump, - {'sw_if_index': sw_if_index}) + {'sw_if_index': sw_if_index, + '_no_type_conversion': True}) def pppoe_add_del_session( self, @@ -3151,15 +3194,18 @@ class VppPapiProvider(object): def ip_punt_redirect(self, rx_sw_if_index, tx_sw_if_index, - nh, - is_ip6=0, + address, is_add=1): return self.api(self.papi.ip_punt_redirect, - {'rx_sw_if_index': rx_sw_if_index, - 'tx_sw_if_index': tx_sw_if_index, - 'nh': nh, - 'is_add': is_add, - 'is_ip6': is_ip6}) + {'punt': {'rx_sw_if_index': rx_sw_if_index, + 'tx_sw_if_index': tx_sw_if_index, + 'nh': address}, + 'is_add': is_add}) + + def ip_punt_redirect_dump(self, sw_if_index, is_ipv6=0): + return self.api(self.papi.ip_punt_redirect_dump, + {'sw_if_index': sw_if_index, + 'is_ipv6': is_ipv6}) def bier_table_add_del(self, bti, @@ -3299,6 +3345,9 @@ class VppPapiProvider(object): self.papi.ipsec_spd_add_del, { 'spd_id': spd_id, 'is_add': is_add}) + def ipsec_spds_dump(self): + return self.api(self.papi.ipsec_spds_dump, {}) + def ipsec_interface_add_del_spd(self, spd_id, sw_if_index, is_add=1): """ IPSEC interface SPD add/del - \ Wrapper to associate/disassociate SPD to interface in VPP @@ -3315,7 +3364,12 @@ class VppPapiProvider(object): self.papi.ipsec_interface_add_del_spd, {'spd_id': spd_id, 'sw_if_index': sw_if_index, 'is_add': is_add}) - def ipsec_sad_add_del_entry(self, + def ipsec_spd_interface_dump(self, spd_index=None): + return self.api(self.papi.ipsec_spd_interface_dump, + {'spd_index': spd_index if spd_index else 0, + 'spd_index_valid': 1 if spd_index else 0}) + + def ipsec_sad_entry_add_del(self, sad_id, spi, integrity_algorithm, @@ -3325,10 +3379,8 @@ class VppPapiProvider(object): protocol, tunnel_src_address='', tunnel_dst_address='', - is_tunnel=1, - is_tunnel_ipv6=0, - is_add=1, - udp_encap=0): + flags=0, + is_add=1): """ IPSEC SA add/del :param sad_id: security association ID :param spi: security param index of the SA in decimal @@ -3345,25 +3397,35 @@ class VppPapiProvider(object): crypto and ipsec algorithms """ return self.api( - self.papi.ipsec_sad_add_del_entry, - {'sad_id': sad_id, - 'spi': spi, - 'tunnel_src_address': tunnel_src_address, - 'tunnel_dst_address': tunnel_dst_address, - 'protocol': protocol, - 'integrity_algorithm': integrity_algorithm, - 'integrity_key_length': len(integrity_key), - 'integrity_key': integrity_key, - 'crypto_algorithm': crypto_algorithm, - 'crypto_key_length': len(crypto_key) if crypto_key is not None - else 0, - 'crypto_key': crypto_key, - 'is_add': is_add, - 'is_tunnel': is_tunnel, - 'is_tunnel_ipv6': is_tunnel_ipv6, - 'udp_encap': udp_encap}) + self.papi.ipsec_sad_entry_add_del, + { + 'is_add': is_add, + 'entry': + { + 'sad_id': sad_id, + 'spi': spi, + 'tunnel_src': tunnel_src_address, + 'tunnel_dst': tunnel_dst_address, + 'protocol': protocol, + 'integrity_algorithm': integrity_algorithm, + 'integrity_key': { + 'length': len(integrity_key), + 'data': integrity_key, + }, + 'crypto_algorithm': crypto_algorithm, + 'crypto_key': { + 'length': len(crypto_key), + 'data': crypto_key, + }, + 'flags': flags, + } + }) + + def ipsec_sa_dump(self, sa_id=None): + return self.api(self.papi.ipsec_sa_dump, + {'sa_id': sa_id if sa_id else 0xffffffff}) - def ipsec_spd_add_del_entry(self, + def ipsec_spd_entry_add_del(self, spd_id, sa_id, local_address_start, @@ -3402,24 +3464,33 @@ class VppPapiProvider(object): :param is_add: (Default value = 1) """ return self.api( - self.papi.ipsec_spd_add_del_entry, - {'spd_id': spd_id, - 'sa_id': sa_id, - 'local_address_start': local_address_start, - 'local_address_stop': local_address_stop, - 'remote_address_start': remote_address_start, - 'remote_address_stop': remote_address_stop, - 'local_port_start': local_port_start, - 'local_port_stop': local_port_stop, - 'remote_port_start': remote_port_start, - 'remote_port_stop': remote_port_stop, - 'is_add': is_add, - 'protocol': protocol, - 'policy': policy, - 'priority': priority, - 'is_outbound': is_outbound, - 'is_ipv6': is_ipv6, - 'is_ip_any': is_ip_any}) + self.papi.ipsec_spd_entry_add_del, + { + 'is_add': is_add, + 'entry': + { + 'spd_id': spd_id, + 'sa_id': sa_id, + 'local_address_start': local_address_start, + 'local_address_stop': local_address_stop, + 'remote_address_start': remote_address_start, + 'remote_address_stop': remote_address_stop, + 'local_port_start': local_port_start, + 'local_port_stop': local_port_stop, + 'remote_port_start': remote_port_start, + 'remote_port_stop': remote_port_stop, + 'protocol': protocol, + 'policy': policy, + 'priority': priority, + 'is_outbound': is_outbound, + 'is_ip_any': is_ip_any + } + }) + + def ipsec_spd_dump(self, spd_id, sa_id=0xffffffff): + return self.api(self.papi.ipsec_spd_dump, + {'spd_id': spd_id, + 'sa_id': sa_id}) def ipsec_tunnel_if_add_del(self, local_ip, remote_ip, local_spi, remote_spi, crypto_alg, local_crypto_key, @@ -3443,6 +3514,13 @@ class VppPapiProvider(object): 'show_instance': show_instance }) + def ipsec_select_backend(self, protocol, index): + return self.api(self.papi.ipsec_select_backend, + {'protocol': protocol, 'index': index}) + + def ipsec_backend_dump(self): + return self.api(self.papi.ipsec_backend_dump, {}) + def app_namespace_add(self, namespace_id, ip4_fib_id=0, @@ -3458,15 +3536,27 @@ class VppPapiProvider(object): 'namespace_id': namespace_id, 'namespace_id_len': len(namespace_id)}) - def punt_socket_register(self, l4_port, pathname, header_version=1, - is_ip4=1, l4_protocol=0x11): - """ Punt to socket """ + def punt_socket_register(self, port, pathname, protocol=0x11, + header_version=1, is_ip4=1): + """ Register punt socket """ return self.api(self.papi.punt_socket_register, - {'is_ip4': is_ip4, - 'l4_protocol': l4_protocol, - 'l4_port': l4_port, - 'pathname': pathname, - 'header_version': header_version}) + {'header_version': header_version, + 'punt': {'ipv': is_ip4, + 'l4_protocol': protocol, + 'l4_port': port}, + 'pathname': pathname}) + + def punt_socket_deregister(self, port, protocol=0x11, is_ip4=1): + """ Unregister punt socket """ + return self.api(self.papi.punt_socket_deregister, + {'punt': {'ipv': is_ip4, + 'l4_protocol': protocol, + 'l4_port': port}}) + + def punt_socket_dump(self, is_ip6=1): + """ Dump punt socket""" + return self.api(self.papi.punt_socket_dump, + {'is_ipv6': is_ip6}) def ip_reassembly_set(self, timeout_ms, max_reassemblies, expire_walk_interval_ms, is_ip6=0): @@ -3496,7 +3586,6 @@ class VppPapiProvider(object): return self.api(self.papi.gbp_endpoint_add, {'endpoint': { 'sw_if_index': sw_if_index, - 'flags': 0, 'ips': ips, 'n_ips': len(ips), 'mac': mac, @@ -3514,9 +3603,10 @@ class VppPapiProvider(object): def gbp_endpoint_dump(self): """ GBP endpoint Dump """ - return self.api(self.papi.gbp_endpoint_dump, {}) + return self.api(self.papi.gbp_endpoint_dump, + {'_no_type_conversion': True}) - def gbp_endpoint_group_add(self, epg, bd, + def gbp_endpoint_group_add(self, epg, sclass, bd, rd, uplink_sw_if_index): """ GBP endpoint group Add """ return self.api(self.papi.gbp_endpoint_group_add, @@ -3525,7 +3615,8 @@ class VppPapiProvider(object): 'uplink_sw_if_index': uplink_sw_if_index, 'bd_id': bd, 'rd_id': rd, - 'epg_id': epg + 'epg_id': epg, + 'sclass': sclass }}) def gbp_endpoint_group_del(self, epg): @@ -3539,7 +3630,8 @@ class VppPapiProvider(object): def gbp_bridge_domain_add(self, bd_id, flags, bvi_sw_if_index, - uu_fwd_sw_if_index): + uu_fwd_sw_if_index, + bm_flood_sw_if_index): """ GBP bridge-domain Add """ return self.api(self.papi.gbp_bridge_domain_add, {'bd': @@ -3547,6 +3639,7 @@ class VppPapiProvider(object): 'flags': flags, 'bvi_sw_if_index': bvi_sw_if_index, 'uu_fwd_sw_if_index': uu_fwd_sw_if_index, + 'bm_flood_sw_if_index': bm_flood_sw_if_index, 'bd_id': bd_id }}) @@ -3597,6 +3690,19 @@ class VppPapiProvider(object): """ GBP recirc Dump """ return self.api(self.papi.gbp_recirc_dump, {}) + def gbp_ext_itf_add_del(self, is_add, sw_if_index, bd_id, rd_id): + """ GBP recirc Add/Del """ + return self.api(self.papi.gbp_ext_itf_add_del, + {'is_add': is_add, + 'ext_itf': { + 'sw_if_index': sw_if_index, + 'bd_id': bd_id, + 'rd_id': rd_id}}) + + def gbp_ext_itf_dump(self): + """ GBP recirc Dump """ + return self.api(self.papi.gbp_ext_itf_dump, {}) + def gbp_subnet_add_del(self, is_add, rd_id, prefix, type, sw_if_index=0xffffffff, @@ -3613,16 +3719,22 @@ class VppPapiProvider(object): def gbp_subnet_dump(self): """ GBP Subnet Dump """ - return self.api(self.papi.gbp_subnet_dump, {}) + return self.api(self.papi.gbp_subnet_dump, + {'_no_type_conversion': True}) - def gbp_contract_add_del(self, is_add, src_epg, dst_epg, acl_index): + def gbp_contract_add_del(self, is_add, src_epg, dst_epg, acl_index, + rules, allowed_ethertypes): """ GBP contract Add/Del """ return self.api(self.papi.gbp_contract_add_del, {'is_add': is_add, 'contract': { 'acl_index': acl_index, 'src_epg': src_epg, - 'dst_epg': dst_epg}}) + 'dst_epg': dst_epg, + 'n_rules': len(rules), + 'rules': rules, + 'n_ether_types': len(allowed_ethertypes), + 'allowed_ethertypes': allowed_ethertypes}}) def gbp_contract_dump(self): """ GBP contract Dump """ @@ -3754,10 +3866,7 @@ class VppPapiProvider(object): 'sw_if_index': sw_if_index, 'n_srcs': len(saddrs), 'saddrs': saddrs, - 'gaddr': - { - 'address': gaddr - } + 'gaddr': gaddr } }) @@ -3785,19 +3894,22 @@ class VppPapiProvider(object): mode, lb, use_custom_mac, - mac_address=''): + mac_address='', + interface_id=0xFFFFFFFF): """ :param mode: mode :param lb: load balance :param use_custom_mac: use custom mac :param mac_address: mac address + :param interface_id: custom interface ID """ return self.api( self.papi.bond_create, {'mode': mode, 'lb': lb, 'use_custom_mac': use_custom_mac, - 'mac_address': mac_address + 'mac_address': mac_address, + 'id': interface_id }) def bond_delete( @@ -4008,3 +4120,40 @@ class VppPapiProvider(object): def svs_dump(self): return self.api(self.papi.svs_dump, {}) + + def syslog_set_sender( + self, + collector, + src, + collector_port=514, + vrf_id=0, + max_msg_size=480): + """Set syslog sender configuration + + :param collector: colector IP address + :param src: source IP address + :param collector_port: collector UDP port (Default value = 514) + :param vrf_id: VRF id (Default value = 0) + :param max_msg_size: maximum message length (Default value = 480) + """ + return self.api(self.papi.syslog_set_sender, + {'collector_address': collector, + 'src_address': src, + 'collector_port': collector_port, + 'vrf_id': vrf_id, + 'max_msg_size': max_msg_size}) + + def syslog_get_sender(self): + """Return syslog sender configuration""" + return self.api(self.papi.syslog_get_sender, {}) + + def syslog_set_filter(self, severity): + """Set syslog filter parameters + + :param severity: severity filter (specified severity and greater match) + """ + return self.api(self.papi.syslog_set_filter, {'severity': severity}) + + def syslog_get_filter(self): + """Return syslog filter parameters""" + return self.api(self.papi.syslog_get_filter, {})