X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Fvpp_papi_provider.py;h=c21d8c2a8b00ba9b0e50b7165123dccfb4c6a43b;hb=32f6d8e0c;hp=4812cb6ef70fed50644b531361143c74bb16b7b1;hpb=413f4a5b2123c1625d615315db293a080078482b;p=vpp.git diff --git a/test/vpp_papi_provider.py b/test/vpp_papi_provider.py index 4812cb6ef70..c21d8c2a8b0 100644 --- a/test/vpp_papi_provider.py +++ b/test/vpp_papi_provider.py @@ -1,25 +1,12 @@ -import fnmatch import os import time from collections import deque -from six import moves -from vpp_mac import mactobinary +from six import moves, iteritems +from vpp_papi import VPP, mac_pton from hook import Hook from vpp_l2 import L2_PORT_TYPE -# 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. - -try: - from vpp_papi import VPP -except ImportError: - if not os.getenv("NO_VPP_PAPI") == 1: - raise - pass - # from vnet/vnet/mpls/mpls_types.h MPLS_IETF_MAX_LABEL = 0xfffff MPLS_LABEL_INVALID = MPLS_IETF_MAX_LABEL + 1 @@ -54,6 +41,14 @@ class SYSLOG_SEVERITY: INFO = 6 DBG = 7 +# +# Dictionary keyed on message name to override default values for +# named parameters +# +defaultmapping = {'map_add_domain': {'mtu': 1280}, + 'syslog_set_sender': {'collector_port': 514, + 'max_msg_size': 480}} + class UnexpectedApiReturnValueError(Exception): """ exception raised when the API return value is unexpected """ @@ -69,20 +64,20 @@ class VppPapiProvider(object): _zero, _negative = range(2) def __init__(self, name, shm_prefix, test_class, read_timeout): - self.hook = Hook("vpp-papi-provider") + self.hook = Hook(test_class) self.name = name self.shm_prefix = shm_prefix self.test_class = test_class self._expect_api_retval = self._zero self._expect_stack = [] - jsonfiles = [] 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, + # 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(logger=test_class.logger, read_timeout=read_timeout) self._events = deque() @@ -158,6 +153,33 @@ class VppPapiProvider(object): self.test_class.logger.debug("New event: %s: %s" % (name, event)) self._events.append(event) + def factory(self, name, apifn): + def f(*a, **ka): + fields = apifn._func.msg.fields + + # add positional and kw arguments + d = ka + for i, o in enumerate(fields[3:]): + try: + d[o] = a[i] + except: + break + + # Default override + if name in defaultmapping: + for k, v in iteritems(defaultmapping[name]): + if k in d: + continue + d[k] = v + return self.api(apifn, d) + return f + + def __getattr__(self, name): + try: + return getattr(self, name) + except: + return self.factory(name, getattr(self.papi, name)) + def connect(self): """Connect the API to VPP""" self.vpp.connect(self.name, self.shm_prefix) @@ -223,9 +245,6 @@ class VppPapiProvider(object): """ return cli + "\n" + str(self.cli(cli)) - def _convert_mac(self, mac): - return mactobinary(mac) - def show_version(self): """ """ return self.api(self.papi.show_version, {}) @@ -317,8 +336,8 @@ class VppPapiProvider(object): return self.api(self.papi.ip_unnumbered_dump, {'sw_if_index': sw_if_index}) - def sw_interface_enable_disable_mpls(self, sw_if_index, - is_enable=1): + def sw_interface_set_mpls_enable(self, sw_if_index, + is_enable=1): """ Enable/Disable MPLS on the interface :param sw_if_index: @@ -329,11 +348,6 @@ class VppPapiProvider(object): {'sw_if_index': sw_if_index, 'enable': is_enable}) - def sw_interface_ra_suppress(self, sw_if_index, suppress=1): - return self.api(self.papi.sw_interface_ip6nd_ra_config, - {'sw_if_index': sw_if_index, - 'suppress': suppress}) - def set_ip_flow_hash(self, table_id, src=1, @@ -353,38 +367,30 @@ class VppPapiProvider(object): 'reverse': reverse, 'is_ipv6': is_ip6}) - def ip6_nd_proxy(self, address, sw_if_index, is_del=0): + def ip6nd_proxy_add_del(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}) - def ip6_sw_interface_ra_config(self, sw_if_index, - no, - suppress, - send_unicast): - return self.api(self.papi.sw_interface_ip6nd_ra_config, - {'sw_if_index': sw_if_index, - 'is_no': no, - 'suppress': suppress, - 'send_unicast': send_unicast}) - - def ip6_sw_interface_ra_prefix(self, - sw_if_index, - address, - address_length, - use_default=0, - no_advertise=0, - off_link=0, - no_autoconfig=0, - no_onlink=0, - is_no=0, - val_lifetime=0xffffffff, - pref_lifetime=0xffffffff): + def sw_interface_ip6nd_ra_prefix(self, + sw_if_index, + address, + address_length, + use_default=0, + no_advertise=0, + off_link=0, + no_autoconfig=0, + no_onlink=0, + is_no=0, + val_lifetime=0xffffffff, + 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, @@ -394,7 +400,7 @@ class VppPapiProvider(object): 'val_lifetime': val_lifetime, 'pref_lifetime': pref_lifetime}) - def ip6_sw_interface_enable_disable(self, sw_if_index, enable): + def sw_interface_ip6_enable_disable(self, sw_if_index, enable): """ Enable/Disable An interface for IPv6 """ @@ -506,16 +512,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): @@ -544,8 +550,8 @@ class VppPapiProvider(object): {'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): + def want_l2_macs_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, {'enable_disable': enable_disable, 'scan_delay': scan_delay, @@ -643,7 +649,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, @@ -740,7 +746,7 @@ class VppPapiProvider(object): 'tx_sw_if_index': tx_sw_if_index, 'enable': enable}) - def sw_interface_set_l2_tag_rewrite( + def l2_interface_vlan_tag_rewrite( self, sw_if_index, vtr_oper, @@ -764,7 +770,7 @@ class VppPapiProvider(object): 'tag1': tag1, 'tag2': tag2}) - def sw_interface_set_l2_emulation( + def l2_emulation( self, sw_if_index, enable=1): @@ -809,16 +815,6 @@ class VppPapiProvider(object): {'sw_if_index': sw_if_index, 'mtu': mtu}) - def sw_interface_set_promiscuous(self, sw_if_index, enable): - """ - :param sw_if_index: - :param enable: - - """ - return self.api(self.papi.sw_interface_set_promiscuous, - {'sw_if_index': sw_if_index, - 'enable': enable}) - def sw_interface_set_mac_address(self, sw_if_index, mac): return self.api(self.papi.sw_interface_set_mac_address, {'sw_if_index': sw_if_index, @@ -859,7 +855,7 @@ class VppPapiProvider(object): 'outer_vlan_id': outer_vlan, 'inner_vlan_id': inner_vlan}) - def create_p2pethernet_subif(self, sw_if_index, remote_mac, subif_id): + def p2p_ethernet_add(self, sw_if_index, remote_mac, subif_id): """Create p2p ethernet subinterface :param sw_if_index: main (parent) interface @@ -880,7 +876,7 @@ class VppPapiProvider(object): return self.api(self.papi.delete_subif, {'sw_if_index': sw_if_index}) - def delete_p2pethernet_subif(self, sw_if_index, remote_mac): + def p2p_ethernet_del(self, sw_if_index, remote_mac): """Delete p2p ethernet subinterface :param sw_if_index: main (parent) interface @@ -1021,32 +1017,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, @@ -1066,9 +1058,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. @@ -1081,9 +1073,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}) @@ -1103,23 +1095,6 @@ class VppPapiProvider(object): } ) - def reset_vrf(self, - vrf_id, - is_ipv6=0, - ): - """ Reset VRF (remove all routes etc.) request. - - :param int vrf_id: ID of the FIB table / VRF to reset. - :param int is_ipv6: 1 for IPv6 neighbor, 0 for IPv4. (Default = 0) - """ - - return self.api( - self.papi.reset_vrf, - {'vrf_id': vrf_id, - 'is_ipv6': is_ipv6, - } - ) - def reset_fib(self, vrf_id, is_ipv6=0, @@ -1167,7 +1142,7 @@ class VppPapiProvider(object): 'is_l2': is_l2, }) - def gre_tunnel_add_del(self, + def gre_add_del_tunnel(self, src_address, dst_address, outer_fib_id=0, @@ -1232,11 +1207,6 @@ class VppPapiProvider(object): def udp_encap_dump(self): return self.api(self.papi.udp_encap_dump, {}) - def want_udp_encap_stats(self, enable=1): - return self.api(self.papi.want_udp_encap_stats, - {'enable': enable, - 'pid': os.getpid()}) - def mpls_fib_dump(self): return self.api(self.papi.mpls_fib_dump, {}) @@ -1574,7 +1544,7 @@ class VppPapiProvider(object): """ return self.api(self.papi.nat_show_config, {}) - def nat44_add_interface_addr( + def nat44_add_del_interface_addr( self, sw_if_index, twice_nat=0, @@ -1597,7 +1567,7 @@ class VppPapiProvider(object): """ return self.api(self.papi.nat44_interface_addr_dump, {}) - def nat_ipfix( + def nat_ipfix_enable_disable( self, domain_id=1, src_port=4739, @@ -1671,6 +1641,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 @@ -2032,31 +2035,6 @@ class VppPapiProvider(object): """ return self.api(self.papi.nat64_bib_dump, {'proto': protocol}) - def nat64_set_timeouts(self, udp=300, icmp=60, tcp_trans=240, tcp_est=7440, - tcp_incoming_syn=6): - """Set values of timeouts for NAT64 (in seconds) - - :param udpi: UDP timeout (Default value = 300) - :param icmp: ICMP timeout (Default value = 60) - :param tcp_trans: TCP transitory timeout (Default value = 240) - :param tcp_est: TCP established timeout (Default value = 7440) - :param tcp_incoming_syn: TCP incoming SYN timeout (Default value = 6) - """ - return self.api( - self.papi.nat64_set_timeouts, - {'udp': udp, - 'icmp': icmp, - 'tcp_trans': tcp_trans, - 'tcp_est': tcp_est, - 'tcp_incoming_syn': tcp_incoming_syn}) - - def nat64_get_timeouts(self): - """Get values of timeouts for NAT64 - - :return: Timeouts for NAT64 (in seconds) - """ - return self.api(self.papi.nat64_get_timeouts, {}) - def nat64_st_dump(self, protocol=255): """Dump NAT64 session table @@ -2087,7 +2065,7 @@ class VppPapiProvider(object): """ return self.api(self.papi.nat64_prefix_dump, {}) - def nat64_add_interface_addr( + def nat64_add_del_interface_addr( self, sw_if_index, is_add=1): @@ -2186,6 +2164,50 @@ class VppPapiProvider(object): """ return self.api(self.papi.nat66_static_mapping_dump, {}) + def nat_ha_set_listener(self, addr, port, path_mtu=512): + """Set HA listener (local settings) + + :param addr: local IP4 address + :param port: local UDP port number + :param path_mtu: path MTU (Default value = 512) + """ + return self.api(self.papi.nat_ha_set_listener, + {'ip_address': addr, + 'port': port, + 'path_mtu': path_mtu}) + + def nat_ha_get_listener(self): + """Get HA listener/local configuration""" + return self.api(self.papi.nat_ha_get_listener, {}) + + def nat_ha_set_failover(self, addr, port, refresh=10): + """Set HA failover (remote settings) + + :param addr: failover IP4 address + :param port: failvoer UDP port number + :param refresh: number of seconds after which to send session refresh + """ + return self.api(self.papi.nat_ha_set_failover, + {'ip_address': addr, + 'port': port, + 'session_refresh_interval': refresh}) + + def nat_ha_get_failover(self): + """Get HA failover/remote settings reply""" + return self.api(self.papi.nat_ha_get_failover, {}) + + def nat_ha_flush(self): + """Flush the current HA data""" + return self.api(self.papi.nat_ha_flush, {}) + + def nat_ha_resync(self, want_resync_event=1): + """Resync HA (resend existing sessions to new failover) + :param want_resync_event: if non-zero resync completed event sent + """ + return self.api(self.papi.nat_ha_resync, + {'want_resync_event': want_resync_event, + 'pid': os.getpid()}) + def control_ping(self): self.api(self.papi.control_ping) @@ -2497,13 +2519,13 @@ class VppPapiProvider(object): def dhcp_client_dump(self): return self.api(self.papi.dhcp_client_dump, {}) - def dhcp_client(self, - sw_if_index, - hostname, - client_id='', - is_add=1, - set_broadcast_flag=1, - want_dhcp_events=0): + def dhcp_client_config(self, + sw_if_index, + hostname, + client_id='', + is_add=1, + set_broadcast_flag=1, + want_dhcp_events=0): return self.api( self.papi.dhcp_client_config, { @@ -2568,9 +2590,9 @@ class VppPapiProvider(object): 'is_en': is_enabled, }) - def lisp_locator_set(self, - ls_name, - is_add=1): + def lisp_add_del_locator_set(self, + ls_name, + is_add=1): return self.api( self.papi.lisp_add_del_locator_set, { @@ -2581,12 +2603,12 @@ class VppPapiProvider(object): def lisp_locator_set_dump(self): return self.api(self.papi.lisp_locator_set_dump, {}) - def lisp_locator(self, - ls_name, - sw_if_index, - priority=1, - weight=1, - is_add=1): + def lisp_add_del_locator(self, + ls_name, + sw_if_index, + priority=1, + weight=1, + is_add=1): return self.api( self.papi.lisp_add_del_locator, { @@ -2606,15 +2628,15 @@ class VppPapiProvider(object): 'ls_index': ls_index, }) - def lisp_local_mapping(self, - ls_name, - eid_type, - eid, - prefix_len, - vni=0, - key_id=0, - key="", - is_add=1): + def lisp_add_del_local_eid(self, + ls_name, + eid_type, + eid, + prefix_len, + vni=0, + key_id=0, + key="", + is_add=1): return self.api( self.papi.lisp_add_del_local_eid, { @@ -2646,15 +2668,15 @@ class VppPapiProvider(object): 'filter': filter_opt, }) - def lisp_remote_mapping(self, - eid_type, - eid, - eid_prefix_len=0, - vni=0, - rlocs=[], - rlocs_num=0, - is_src_dst=0, - is_add=1): + def lisp_add_del_remote_mapping(self, + eid_type, + eid, + eid_prefix_len=0, + vni=0, + rlocs=[], + rlocs_num=0, + is_src_dst=0, + is_add=1): return self.api( self.papi.lisp_add_del_remote_mapping, { @@ -2668,14 +2690,14 @@ class VppPapiProvider(object): 'is_src_dst': is_src_dst, }) - def lisp_adjacency(self, - leid, - reid, - leid_len, - reid_len, - eid_type, - is_add=1, - vni=0): + def lisp_add_del_adjacency(self, + leid, + reid, + leid_len, + reid_len, + eid_type, + is_add=1, + vni=0): return self.api( self.papi.lisp_add_del_adjacency, { @@ -2695,30 +2717,6 @@ class VppPapiProvider(object): 'vni': vni }) - def map_add_domain(self, - ip6_prefix, - ip6_src, - ip4_prefix, - 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, - 'ip4_prefix': ip4_prefix, - 'ip6_src': ip6_src, - '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 gtpu_add_del_tunnel( self, src_addr, @@ -3316,6 +3314,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 @@ -3332,7 +3333,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, @@ -3342,12 +3348,8 @@ class VppPapiProvider(object): protocol, tunnel_src_address='', tunnel_dst_address='', - is_tunnel=1, - is_tunnel_ipv6=0, - is_add=1, - udp_encap=0, - use_anti_replay=0, - use_extended_sequence_number=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 @@ -3364,27 +3366,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, - 'use_extended_sequence_number': use_extended_sequence_number, - 'use_anti_replay': use_anti_replay}) + 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_spd_add_del_entry(self, + 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_entry_add_del(self, spd_id, sa_id, local_address_start, @@ -3423,24 +3433,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, @@ -3471,12 +3490,12 @@ class VppPapiProvider(object): def ipsec_backend_dump(self): return self.api(self.papi.ipsec_backend_dump, {}) - def app_namespace_add(self, - namespace_id, - ip4_fib_id=0, - ip6_fib_id=0, - sw_if_index=0xFFFFFFFF, - secret=0): + def app_namespace_add_del(self, + namespace_id, + ip4_fib_id=0, + ip6_fib_id=0, + sw_if_index=0xFFFFFFFF, + secret=0): return self.api( self.papi.app_namespace_add_del, {'secret': secret, @@ -3536,7 +3555,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, @@ -3557,8 +3575,9 @@ class VppPapiProvider(object): return self.api(self.papi.gbp_endpoint_dump, {'_no_type_conversion': True}) - def gbp_endpoint_group_add(self, epg, bd, - rd, uplink_sw_if_index): + def gbp_endpoint_group_add(self, epg, sclass, bd, + rd, uplink_sw_if_index, + retention): """ GBP endpoint group Add """ return self.api(self.papi.gbp_endpoint_group_add, {'epg': @@ -3566,7 +3585,9 @@ 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, + 'retention': retention }}) def gbp_endpoint_group_del(self, epg): @@ -3580,7 +3601,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': @@ -3588,6 +3610,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 }}) @@ -3670,7 +3693,8 @@ class VppPapiProvider(object): 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, rules): + 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, @@ -3679,17 +3703,14 @@ class VppPapiProvider(object): 'src_epg': src_epg, 'dst_epg': dst_epg, 'n_rules': len(rules), - 'rules': rules}}) + 'rules': rules, + 'n_ether_types': len(allowed_ethertypes), + 'allowed_ethertypes': allowed_ethertypes}}) 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, @@ -3839,19 +3860,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( @@ -4062,40 +4086,3 @@ 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, {})