X-Git-Url: https://gerrit.fd.io/r/gitweb?p=vpp.git;a=blobdiff_plain;f=test%2Fvpp_papi_provider.py;h=6cbde71633eae62360495e2815d7a848b8cea546;hp=e3d8459b0b10b6aab4cca952db89032667afb1a3;hb=8c8acc0;hpb=7c922dc404c2c0a2d67d53ca05db1c1ae1598f44 diff --git a/test/vpp_papi_provider.py b/test/vpp_papi_provider.py index e3d8459b0b1..6cbde71633e 100644 --- a/test/vpp_papi_provider.py +++ b/test/vpp_papi_provider.py @@ -1,9 +1,12 @@ -import os import fnmatch +import os import time -from hook import Hook from collections import deque +from six import moves + +from hook import Hook + # 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 @@ -18,6 +21,7 @@ except: if do_import: from vpp_papi import VPP + from vpp_l2 import L2_PORT_TYPE # from vnet/vnet/mpls/mpls_types.h MPLS_IETF_MAX_LABEL = 0xfffff @@ -43,6 +47,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 @@ -56,7 +71,7 @@ class VppPapiProvider(object): _zero, _negative = range(2) - def __init__(self, name, shm_prefix, test_class): + def __init__(self, name, shm_prefix, test_class, read_timeout): self.hook = Hook("vpp-papi-provider") self.name = name self.shm_prefix = shm_prefix @@ -65,25 +80,35 @@ class VppPapiProvider(object): self._expect_stack = [] jsonfiles = [] - install_dir = os.getenv('VPP_TEST_INSTALL_PATH') + install_dir = os.getenv('VPP_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)) - self.vpp = VPP(jsonfiles, logger=test_class.logger, read_timeout=5) + self.vpp = VPP(jsonfiles, 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 @@ -162,14 +187,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: @@ -241,6 +266,17 @@ class VppPapiProvider(object): {'sw_if_index': sw_if_index, 'is_ipv6': is_ipv6, 'vrf_id': table_id}) + def sw_interface_get_table(self, sw_if_index, is_ipv6): + """ Get the IPvX Table-id for the Interface + + :param sw_if_index: + :param is_ipv6: + :return table_id + + """ + return self.api(self.papi.sw_interface_get_table, + {'sw_if_index': sw_if_index, 'is_ipv6': is_ipv6}) + def sw_interface_add_del_address(self, sw_if_index, addr, addr_len, is_ipv6=0, is_add=1, del_all=0): """ @@ -261,6 +297,11 @@ class VppPapiProvider(object): 'address_length': addr_len, 'address': addr}) + def ip_address_dump(self, sw_if_index, is_ipv6=0): + return self.api(self.papi.ip_address_dump, + {'sw_if_index': sw_if_index, + 'is_ipv6': is_ipv6}) + def sw_interface_set_unnumbered(self, sw_if_index, ip_sw_if_index, is_add=1): """ Set the Interface to be unnumbered @@ -461,9 +502,12 @@ class VppPapiProvider(object): return self.api(self.papi.bd_ip_mac_add_del, {'bd_id': bd_id, 'is_add': is_add, - 'is_ipv6': is_ipv6, - 'ip_address': ip, - 'mac_address': mac}) + 'ip': ip, + 'mac': mac}) + + def bd_ip_mac_dump(self, bd_id): + return self.api(self.papi.bd_ip_mac_dump, + {'bd_id': bd_id}) def want_ip4_arp_events(self, enable_disable=1, address=0): return self.api(self.papi.want_ip4_arp_events, @@ -498,6 +542,11 @@ class VppPapiProvider(object): 'enable': enable, 'install_default_routes': install_default_routes}) + def want_interface_events(self, enable_disable=1): + return self.api(self.papi.want_interface_events, + {'enable_disable': enable_disable, + 'pid': os.getpid(), }) + def want_macs_learn_events(self, enable_disable=1, scan_delay=0, max_macs_in_event=0, learn_limit=0): return self.api(self.papi.want_l2_macs_events, @@ -626,8 +675,14 @@ class VppPapiProvider(object): """ return self.api(self.papi.l2fib_flush_all, {}) + def l2_fib_table_dump(self, bd_id): + """ Dump the L2 FIB """ + return self.api(self.papi.l2_fib_table_dump, + {'bd_id': bd_id}) + def sw_interface_set_l2_bridge(self, sw_if_index, bd_id, - shg=0, bvi=0, enable=1): + shg=0, port_type=L2_PORT_TYPE.NORMAL, + enable=1): """Add/remove interface to/from bridge domain. :param int sw_if_index: Software interface index of the interface. @@ -641,7 +696,7 @@ class VppPapiProvider(object): {'rx_sw_if_index': sw_if_index, 'bd_id': bd_id, 'shg': shg, - 'bvi': bvi, + 'port_type': port_type, 'enable': enable}) def bridge_flags(self, bd_id, is_set, feature_bitmap): @@ -650,7 +705,7 @@ class VppPapiProvider(object): :param int bd_id: Bridge domain ID. :param int is_set: Set to 1 to enable, set to 0 to disable the feature. - :param int feature_bitmap: Bitmap value of the feature to be set: + :param int flags: Bitmap value of the feature to be set: - learn (1 << 0), - forward (1 << 1), - flood (1 << 2), @@ -660,7 +715,7 @@ class VppPapiProvider(object): return self.api(self.papi.bridge_flags, {'bd_id': bd_id, 'is_set': is_set, - 'feature_bitmap': feature_bitmap}) + 'flags': feature_bitmap}) def bridge_domain_dump(self, bd_id=0): """ @@ -1150,14 +1205,12 @@ class VppPapiProvider(object): ) def udp_encap_add(self, - id, src_ip, dst_ip, src_port, dst_port, table_id=0): """ Add a GRE tunnel - :param id: user provided ID :param src_ip: :param dst_ip: :param src_port: @@ -1169,7 +1222,6 @@ class VppPapiProvider(object): self.papi.udp_encap_add, { 'udp_encap': { - 'id': id, 'src_ip': src_ip, 'dst_ip': dst_ip, 'src_port': src_port, @@ -1348,6 +1400,10 @@ class VppPapiProvider(object): 'mt_next_hop_via_label': next_hop_via_label, 'mt_next_hop_out_label_stack': next_hop_out_label_stack}) + def mpls_tunnel_dump(self, sw_if_index=0xffffffff): + return self.api(self.papi.mpls_tunnel_dump, + {'sw_if_index': sw_if_index}) + def nat44_interface_add_del_feature( self, sw_if_index, @@ -1594,6 +1650,7 @@ class VppPapiProvider(object): self_twice_nat=0, out2in_only=0, tag='', + affinity=0, local_num=0, locals=[], is_add=1): @@ -1601,6 +1658,7 @@ class VppPapiProvider(object): :param twice_nat: 1 if translate external host address and port :param tag: Opaque string tag + :param affinity: if 0 disabled, otherwise client IP affinity timeout :param is_add - 1 if add, 0 if delete """ return self.api( @@ -1613,6 +1671,7 @@ class VppPapiProvider(object): 'self_twice_nat': self_twice_nat, 'out2in_only': out2in_only, 'tag': tag, + 'affinity': affinity, 'local_num': local_num, 'locals': locals}) @@ -1794,6 +1853,50 @@ class VppPapiProvider(object): """ return self.api(self.papi.nat_get_timeouts, {}) + def nat_set_addr_and_port_alloc_alg( + self, + alg=0, + psid_offset=0, + psid_length=0, + psid=0, + start_port=0, + end_port=0): + """Set address and port assignment algorithm + + :param alg: algorithm: 0 - default, 1 - MAP-E, 2 - port range + :param psid_offset: number of offset bits (valid only for MAP-E alg) + :param psid_length: length of PSID (valid only for MAP-E alg) + :param psid: Port Set Identifier value (valid only for MAP-E alg) + :param start_port: beginning of the port range + :param end_port: end of the port range + """ + return self.api( + self.papi.nat_set_addr_and_port_alloc_alg, + {'alg': alg, + 'psid_offset': psid_offset, + 'psid_length': psid_length, + 'psid': psid, + 'start_port': start_port, + 'end_port': end_port}) + + def nat_get_addr_and_port_alloc_alg(self): + """Get address and port assignment algorithm""" + return self.api(self.papi.nat_get_addr_and_port_alloc_alg, {}) + + def nat_set_mss_clamping(self, enable=0, mss_value=1500): + """Set TCP MSS rewriting configuration + + :param enable: disable(0)/enable(1) MSS rewriting feature + :param mss_value: MSS value to be used for MSS rewriting + """ + return self.api( + self.papi.nat_set_mss_clamping, + {'enable': enable, 'mss_value': mss_value}) + + def nat_get_mss_clamping(self): + """Get TCP MSS rewriting configuration""" + return self.api(self.papi.nat_get_mss_clamping, {}) + def nat_det_close_session_out( self, out_addr, @@ -2208,6 +2311,9 @@ class VppPapiProvider(object): def bfd_udp_del_echo_source(self): return self.api(self.papi.bfd_udp_del_echo_source, {}) + def bfd_udp_get_echo_source(self): + return self.api(self.papi.bfd_udp_get_echo_source, {}) + def classify_add_del_table( self, is_add, @@ -2595,11 +2701,8 @@ 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, @@ -2610,11 +2713,8 @@ class VppPapiProvider(object): 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, @@ -2690,6 +2790,43 @@ class VppPapiProvider(object): 'protocol': protocol, 'vni': vni}) + def vxlan_gbp_tunnel_add_del( + self, + src, + dst, + mcast_sw_if_index=0xFFFFFFFF, + is_add=1, + is_ipv6=0, + encap_table_id=0, + vni=0, + instance=0xFFFFFFFF): + """ + + :param dst_addr: + :param src_addr: + :param is_add: (Default value = 1) + :param is_ipv6: (Default value = 0) + :param encap_table_id: (Default value = 0) + :param decap_next_index: (Default value = 0xFFFFFFFF) + :param mcast_sw_if_index: (Default value = 0xFFFFFFFF) + :param vni: (Default value = 0) + :param instance: (Default value = 0xFFFFFFFF) + + """ + return self.api(self.papi.vxlan_gbp_tunnel_add_del, + {'is_add': is_add, + 'tunnel': { + 'src': src, + 'dst': dst, + 'mcast_sw_if_index': mcast_sw_if_index, + 'encap_table_id': encap_table_id, + 'vni': vni, + 'instance': instance}}) + + 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}) + def pppoe_add_del_session( self, client_ip, @@ -3031,15 +3168,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, @@ -3061,7 +3201,8 @@ class VppPapiProvider(object): bti, bp, paths, - is_add=1): + is_add=1, + is_replace=0): """ BIER Route add/del """ return self.api( self.papi.bier_route_add_del, @@ -3071,7 +3212,8 @@ class VppPapiProvider(object): 'br_bp': bp, 'br_n_paths': len(paths), 'br_paths': paths, - 'br_is_add': is_add}) + 'br_is_add': is_add, + 'br_is_replace': is_replace}) def bier_route_dump(self, bti): return self.api( @@ -3204,8 +3346,11 @@ class VppPapiProvider(object): tunnel_src_address='', tunnel_dst_address='', is_tunnel=1, + is_tunnel_ipv6=0, is_add=1, - udp_encap=0): + udp_encap=0, + use_anti_replay=0, + use_extended_sequence_number=0): """ IPSEC SA add/del :param sad_id: security association ID :param spi: security param index of the SA in decimal @@ -3237,7 +3382,10 @@ class VppPapiProvider(object): 'crypto_key': crypto_key, 'is_add': is_add, 'is_tunnel': is_tunnel, - 'udp_encap': udp_encap}) + 'is_tunnel_ipv6': is_tunnel_ipv6, + 'udp_encap': udp_encap, + 'use_extended_sequence_number': use_extended_sequence_number, + 'use_anti_replay': use_anti_replay}) def ipsec_spd_add_del_entry(self, spd_id, @@ -3255,6 +3403,7 @@ class VppPapiProvider(object): priority=100, is_outbound=1, is_add=1, + is_ipv6=0, is_ip_any=0): """ IPSEC policy SPD add/del - Wrapper to configure ipsec SPD policy entries in VPP @@ -3293,6 +3442,7 @@ class VppPapiProvider(object): 'policy': policy, 'priority': priority, 'is_outbound': is_outbound, + 'is_ipv6': is_ipv6, 'is_ip_any': is_ip_any}) def ipsec_tunnel_if_add_del(self, local_ip, remote_ip, local_spi, @@ -3317,6 +3467,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, @@ -3364,38 +3521,100 @@ class VppPapiProvider(object): 'enable_ip6': 1 if enable_ip6 else 0, }) - def gbp_endpoint_add_del(self, is_add, sw_if_index, addr, is_ip6, epg): - """ GBP endpoint Add/Del """ - return self.api(self.papi.gbp_endpoint_add_del, - {'is_add': is_add, - 'endpoint': { - 'is_ip6': is_ip6, - 'sw_if_index': sw_if_index, - 'address': addr, - 'epg_id': epg}}) + def gbp_endpoint_add(self, sw_if_index, ips, mac, epg, flags, + tun_src, tun_dst): + """ GBP endpoint Add """ + 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, + 'epg_id': epg, + 'flags': flags, + 'tun': { + 'src': tun_src, + 'dst': tun_dst, + }}}) + + def gbp_endpoint_del(self, handle): + """ GBP endpoint Del """ + return self.api(self.papi.gbp_endpoint_del, + {'handle': handle}) def gbp_endpoint_dump(self): """ GBP endpoint Dump """ return self.api(self.papi.gbp_endpoint_dump, {}) - def gbp_endpoint_group_add_del(self, is_add, epg, bd, - ip4_rd, - ip6_rd, - uplink_sw_if_index): - """ GBP endpoint group Add/Del """ - return self.api(self.papi.gbp_endpoint_group_add_del, - {'is_add': is_add, - 'epg': { + def gbp_endpoint_group_add(self, epg, bd, + rd, uplink_sw_if_index): + """ GBP endpoint group Add """ + return self.api(self.papi.gbp_endpoint_group_add, + {'epg': + { 'uplink_sw_if_index': uplink_sw_if_index, 'bd_id': bd, - 'ip4_table_id': ip4_rd, - 'ip6_table_id': ip6_rd, - 'epg_id': epg}}) + 'rd_id': rd, + 'epg_id': epg + }}) + + def gbp_endpoint_group_del(self, epg): + """ GBP endpoint group Del """ + return self.api(self.papi.gbp_endpoint_group_del, + {'epg_id': epg}) def gbp_endpoint_group_dump(self): """ GBP endpoint group Dump """ return self.api(self.papi.gbp_endpoint_group_dump, {}) + def gbp_bridge_domain_add(self, bd_id, flags, + bvi_sw_if_index, + uu_fwd_sw_if_index): + """ GBP bridge-domain Add """ + return self.api(self.papi.gbp_bridge_domain_add, + {'bd': + { + 'flags': flags, + 'bvi_sw_if_index': bvi_sw_if_index, + 'uu_fwd_sw_if_index': uu_fwd_sw_if_index, + 'bd_id': bd_id + }}) + + def gbp_bridge_domain_del(self, bd_id): + """ GBP bridge-domain Del """ + return self.api(self.papi.gbp_bridge_domain_del, + {'bd_id': bd_id}) + + def gbp_bridge_domain_dump(self): + """ GBP Bridge Domain Dump """ + return self.api(self.papi.gbp_bridge_domain_dump, {}) + + def gbp_route_domain_add(self, rd_id, + ip4_table_id, + ip6_table_id, + ip4_uu_sw_if_index, + ip6_uu_sw_if_index): + """ GBP route-domain Add """ + return self.api(self.papi.gbp_route_domain_add, + {'rd': + { + 'ip4_table_id': ip4_table_id, + 'ip6_table_id': ip6_table_id, + 'ip4_uu_sw_if_index': ip4_uu_sw_if_index, + 'ip6_uu_sw_if_index': ip6_uu_sw_if_index, + 'rd_id': rd_id + }}) + + def gbp_route_domain_del(self, rd_id): + """ GBP route-domain Del """ + return self.api(self.papi.gbp_route_domain_del, + {'rd_id': rd_id}) + + def gbp_route_domain_dump(self): + """ GBP Route Domain Dump """ + return self.api(self.papi.gbp_route_domain_dump, {}) + def gbp_recirc_add_del(self, is_add, sw_if_index, epg, is_ext): """ GBP recirc Add/Del """ return self.api(self.papi.gbp_recirc_add_del, @@ -3409,41 +3628,79 @@ class VppPapiProvider(object): """ GBP recirc Dump """ return self.api(self.papi.gbp_recirc_dump, {}) - def gbp_subnet_add_del(self, is_add, table_id, - is_internal, - addr, addr_len, + 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, - epg_id=0xffffffff, - is_ip6=False): + epg_id=0xffff): """ GBP Subnet Add/Del """ return self.api(self.papi.gbp_subnet_add_del, {'is_add': is_add, 'subnet': { - 'is_internal': is_internal, - 'is_ip6': is_ip6, + 'type': type, 'sw_if_index': sw_if_index, 'epg_id': epg_id, - 'address': addr, - 'address_length': addr_len, - 'table_id': table_id}}) + 'prefix': prefix, + 'rd_id': rd_id}}) def gbp_subnet_dump(self): """ GBP Subnet Dump """ return self.api(self.papi.gbp_subnet_dump, {}) - 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): """ 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}}) def gbp_contract_dump(self): """ GBP contract Dump """ return self.api(self.papi.gbp_contract_dump, {}) + def gbp_endpoint_learn_set_inactive_threshold(self, threshold): + """ GBP set inactive threshold """ + return self.api(self.papi.gbp_endpoint_learn_set_inactive_threshold, + {'threshold': threshold}) + + def gbp_vxlan_tunnel_add(self, vni, bd_rd_id, mode): + """ GBP VXLAN tunnel add """ + return self.api(self.papi.gbp_vxlan_tunnel_add, + { + 'tunnel': { + 'vni': vni, + 'mode': mode, + 'bd_rd_id': bd_rd_id + } + }) + + def gbp_vxlan_tunnel_del(self, vni): + """ GBP VXLAN tunnel del """ + return self.api(self.papi.gbp_vxlan_tunnel_del, + { + 'vni': vni, + }) + + def gbp_vxlan_tunnel_dump(self): + """ GBP VXLAN tunnel add/del """ + return self.api(self.papi.gbp_vxlan_tunnel_dump, {}) + def ipip_6rd_add_tunnel(self, ip6_table_id, ip6_prefix, ip6_prefix_len, ip4_table_id, ip4_prefix, ip4_prefix_len, ip4_src, security_check): @@ -3515,6 +3772,18 @@ class VppPapiProvider(object): 'mode': host, 'sw_if_index': sw_if_index}) + def igmp_proxy_device_add_del(self, vrf_id, sw_if_index, add): + """ Add/del IGMP proxy device """ + return self.api(self.papi.igmp_proxy_device_add_del, + {'vrf_id': vrf_id, 'sw_if_index': sw_if_index, + 'add': add}) + + def igmp_proxy_device_add_del_interface(self, vrf_id, sw_if_index, add): + """ Add/del interface to/from IGMP proxy device """ + return self.api(self.papi.igmp_proxy_device_add_del_interface, + {'vrf_id': vrf_id, 'sw_if_index': sw_if_index, + 'add': add}) + def igmp_listen(self, filter, sw_if_index, saddrs, gaddr): """ Listen for new (S,G) on specified interface @@ -3531,10 +3800,7 @@ class VppPapiProvider(object): 'sw_if_index': sw_if_index, 'n_srcs': len(saddrs), 'saddrs': saddrs, - 'gaddr': - { - 'address': gaddr - } + 'gaddr': gaddr } }) @@ -3637,6 +3903,8 @@ class VppPapiProvider(object): is_server, sock_filename, renumber, + disable_mrg_rxbuf, + disable_indirect_desc, custom_dev_instance, use_custom_mac, mac_address, @@ -3645,16 +3913,20 @@ class VppPapiProvider(object): :param is_server: is server :param sock_filename: socket name :param renumber: renumber + :param disable_mrg_rxbuf: disable mergable rx buffers + :param disable_indirect_desc: disable indirect descriptors :param custom_dev_instance: custom dev instance :param use_custom_mac: use custom mac :param mac_address: mac address - :param tag: tag (default '' + :param tag: tag (default '') """ return self.api( self.papi.create_vhost_user_if, {'is_server': is_server, 'sock_filename': sock_filename, 'renumber': renumber, + 'disable_mrg_rxbuf': disable_mrg_rxbuf, + 'disable_indirect_desc': disable_indirect_desc, 'custom_dev_instance': custom_dev_instance, 'use_custom_mac': use_custom_mac, 'mac_address': mac_address, @@ -3709,3 +3981,110 @@ class VppPapiProvider(object): def pipe_dump(self): return self.api(self.papi.pipe_dump, {}) + + def memif_create( + self, + role, + mode, + rx_queues=None, + tx_queues=None, + _id=None, + socket_id=None, + secret=None, + ring_size=None, + buffer_size=None, + hw_addr=None): + return self.api(self.papi.memif_create, + {'role': role, + 'mode': mode, + 'rx_queues': rx_queues, + 'tx_queues': tx_queues, + 'id': _id, + 'socket_id': socket_id, + 'secret': secret, + 'ring_size': ring_size, + 'buffer_size': buffer_size, + 'hw_addr': hw_addr}) + + def memif_delete(self, sw_if_index): + return self.api(self.papi.memif_delete, {'sw_if_index': sw_if_index}) + + def memif_dump(self): + return self.api(self.papi.memif_dump, {}) + + def memif_socket_filename_add_del( + self, is_add, socket_id, socket_filename): + return self.api( + self.papi.memif_socket_filename_add_del, + {'is_add': is_add, + 'socket_id': socket_id, + 'socket_filename': socket_filename}) + + def memif_socket_filename_dump(self): + return self.api(self.papi.memif_socket_filename_dump, {}) + + def svs_table_add_del(self, af, table_id, is_add=1): + return self.api(self.papi.svs_table_add_del, + { + 'table_id': table_id, + 'is_add': is_add, + 'af': af, + }) + + def svs_route_add_del(self, table_id, prefix, src_table_id, is_add=1): + return self.api(self.papi.svs_route_add_del, + { + 'table_id': table_id, + 'source_table_id': src_table_id, + 'prefix': prefix, + 'is_add': is_add, + }) + + def svs_enable_disable(self, af, table_id, sw_if_index, is_enable=1): + return self.api(self.papi.svs_enable_disable, + { + 'af': af, + 'table_id': table_id, + 'sw_if_index': sw_if_index, + 'is_enable': is_enable, + }) + + 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, {})