@param context - sender context, to match reply w/ request
@param sw_if_index - interface to use as filter (~0 == "all")
*/
-autoendian define lcp_itf_pair_get
+define lcp_itf_pair_get
{
u32 client_index;
u32 context;
u32 cursor;
};
-autoendian define lcp_itf_pair_get_reply
+define lcp_itf_pair_get_reply
{
u32 context;
i32 retval;
def test_api_map_domains_get(self):
# Create a bunch of domains
- domains = self.create_domains('130.67.0.0/24', '2001::/32',
+ no_domains = 4096 # This must be large enough to ensure VPP suspends
+ domains = self.create_domains('130.67.0.0/20', '2001::/32',
'2001::1/128')
- self.assertEqual(len(domains), 256)
+ self.assertEqual(len(domains), no_domains)
d = []
cursor = 0
# Invalid cursor
- rv, details = self.vapi.map_domains_get(cursor=1234)
+ rv, details = self.vapi.map_domains_get(cursor=no_domains+10)
self.assertEqual(rv.retval, -7)
# Delete a domain in the middle of walk
self.assertEqual(rv.retval, -165)
d = list(self.vapi.vpp.details_iter(self.vapi.map_domains_get))
- self.assertEqual(len(d), 255)
+ self.assertEqual(len(d), no_domains - 1)
# Clean up
for i in domains:
import time
import unittest
-from vpp_papi import vpp_transport_shmem
+from vpp_papi import VPPIOError
from framework import VppTestCase, VppTestRunner
self.assertEqual(rv.retval, 0)
def test_long_cli_delay(self):
- """ Test that VppApiClient raises VppTransportShmemIOError if timeout.""" # noqa
- with self.assertRaises(
- vpp_transport_shmem.VppTransportShmemIOError) as ctx:
+ """ Test that VppApiClient raises VppIOError if timeout.""" # noqa
+ with self.assertRaises(VPPIOError) as ctx:
rv = self.vapi.papi.cli_inband(cmd='wait 10')
def test_long_cli_delay_override(self):
vl_api_if_status_flags_t flags;
};
+service {
+ rpc want_bfd_events returns want_bfd_events_reply
+ events bfd_udp_session_event;
+};
+
/** \brief Register for BFD events
@param client_index - opaque cookie to identify the sender
@param context - sender context, to match reply w/ request
u32 pid;
};
+define bfd_udp_session_event
+{
+ u32 client_index;
+ u32 pid;
+ vl_api_interface_index_t sw_if_index;
+ vl_api_address_t local_addr;
+ vl_api_address_t peer_addr;
+ vl_api_bfd_state_t state;
+ bool is_authenticated;
+ u8 bfd_key_id;
+ u32 conf_key_id;
+ u32 required_min_rx;
+ u32 desired_min_tx;
+ u8 detect_mult;
+};
+
/** \brief BFD UDP - add/replace key to configuration
@param client_index - opaque cookie to identify the sender
@param context - sender context, to match reply w/ request
vl_api_send_msg (reg, (u8 *) mp);
}
+void
+send_bfd_udp_session_event (vl_api_registration_t *reg, u32 pid,
+ bfd_session_t *bs)
+{
+ if (bs->transport != BFD_TRANSPORT_UDP4 &&
+ bs->transport != BFD_TRANSPORT_UDP6)
+ {
+ return;
+ }
+
+ vl_api_bfd_udp_session_event_t *mp = vl_msg_api_alloc (sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
+ mp->_vl_msg_id = ntohs (VL_API_BFD_UDP_SESSION_EVENT);
+ mp->pid = pid;
+ mp->state = clib_host_to_net_u32 (bs->local_state);
+ bfd_udp_session_t *bus = &bs->udp;
+ bfd_udp_key_t *key = &bus->key;
+ mp->sw_if_index = clib_host_to_net_u32 (key->sw_if_index);
+ if ((!bs->auth.is_delayed && bs->auth.curr_key) ||
+ (bs->auth.is_delayed && bs->auth.next_key))
+ {
+ mp->is_authenticated = true;
+ }
+ if (bs->auth.is_delayed && bs->auth.next_key)
+ {
+ mp->bfd_key_id = bs->auth.next_bfd_key_id;
+ mp->conf_key_id = clib_host_to_net_u32 (bs->auth.next_key->conf_key_id);
+ }
+ else if (!bs->auth.is_delayed && bs->auth.curr_key)
+ {
+ mp->bfd_key_id = bs->auth.curr_bfd_key_id;
+ mp->conf_key_id = clib_host_to_net_u32 (bs->auth.curr_key->conf_key_id);
+ }
+ ip_address_encode (&key->local_addr, IP46_TYPE_ANY, &mp->local_addr);
+ ip_address_encode (&key->peer_addr, IP46_TYPE_ANY, &mp->peer_addr);
+
+ mp->required_min_rx = clib_host_to_net_u32 (bs->config_required_min_rx_usec);
+ mp->desired_min_tx = clib_host_to_net_u32 (bs->config_desired_min_tx_usec);
+ mp->detect_mult = bs->local_detect_mult;
+ vl_api_send_msg (reg, (u8 *) mp);
+}
+
void
bfd_event (bfd_main_t * bm, bfd_session_t * bs)
{
case BFD_TRANSPORT_UDP4:
/* fallthrough */
case BFD_TRANSPORT_UDP6:
- send_bfd_udp_session_details (vl_reg, 0, bs);
+ send_bfd_udp_session_event (vl_reg, 0, bs);
}
}
}
test.test_session.inc_seq_num()
test.test_session.send_packet()
test.logger.info("BFD: Waiting for event")
- e = test.vapi.wait_for_event(1, "bfd_udp_session_details")
+ e = test.vapi.wait_for_event(1, "bfd_udp_session_event")
verify_event(test, e, expected_state=BFDState.up)
test.logger.info("BFD: Session is Up")
test.test_session.update(state=BFDState.up)
test.test_session.inc_seq_num()
test.test_session.send_packet()
test.logger.info("BFD: Waiting for event")
- e = test.vapi.wait_for_event(1, "bfd_udp_session_details")
+ e = test.vapi.wait_for_event(1, "bfd_udp_session_event")
verify_event(test, e, expected_state=BFDState.down)
test.logger.info("BFD: Session is Down")
test.assert_equal(test.vpp_session.state, BFDState.down, BFDState)
self.test_session.update(your_discriminator=p[BFD].my_discriminator,
state=BFDState.up)
self.logger.info("BFD: Waiting for event")
- e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
verify_event(self, e, expected_state=BFDState.init)
self.logger.info("BFD: Sending Up")
self.test_session.send_packet()
self.logger.info("BFD: Waiting for event")
- e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
verify_event(self, e, expected_state=BFDState.up)
self.logger.info("BFD: Session is Up")
self.test_session.update(state=BFDState.up)
detection_time = self.test_session.detect_mult *\
self.vpp_session.required_min_rx / USEC_IN_SEC
self.sleep(detection_time, "waiting for BFD session time-out")
- e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
verify_event(self, e, expected_state=BFDState.down)
def test_peer_discr_reset_sess_down(self):
self.vpp_session.required_min_rx) / USEC_IN_SEC
self.test_session.send_packet(final)
time_mark = time.time()
- e = self.vapi.wait_for_event(2 * timeout, "bfd_udp_session_details")
+ e = self.vapi.wait_for_event(2 * timeout, "bfd_udp_session_event")
verify_event(self, e, expected_state=BFDState.down)
time_to_event = time.time() - time_mark
self.assert_in_range(time_to_event, .9 * timeout,
self.vpp_session.required_min_rx / USEC_IN_SEC
before = time.time()
e = self.vapi.wait_for_event(
- 2 * detection_time, "bfd_udp_session_details")
+ 2 * detection_time, "bfd_udp_session_event")
after = time.time()
self.assert_in_range(after - before,
0.9 * detection_time,
bfd_session_up(self)
self.vpp_session.admin_down()
self.pg0.enable_capture()
- e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
verify_event(self, e, expected_state=BFDState.admin_down)
for dummy in range(2):
p = wait_for_bfd_packet(self)
self.assert_equal(p[BFD].state, BFDState.admin_down, BFDState)
self.vpp_session.admin_up()
self.test_session.update(state=BFDState.down)
- e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
verify_event(self, e, expected_state=BFDState.down)
p = wait_for_bfd_packet(
self, pcap_time_min=time.time() - self.vpp_clock_offset)
p = wait_for_bfd_packet(
self, pcap_time_min=time.time() - self.vpp_clock_offset)
self.assert_equal(p[BFD].state, BFDState.init, BFDState)
- e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
verify_event(self, e, expected_state=BFDState.init)
self.test_session.update(state=BFDState.up)
self.test_session.send_packet()
p = wait_for_bfd_packet(
self, pcap_time_min=time.time() - self.vpp_clock_offset)
self.assert_equal(p[BFD].state, BFDState.up, BFDState)
- e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
verify_event(self, e, expected_state=BFDState.up)
def test_config_change_remote_demand(self):
vpp_session.add_vpp_config()
vpp_session.admin_up()
intf.remove_vpp_config()
- e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
self.assert_equal(e.sw_if_index, sw_if_index, "sw_if_index")
self.assertFalse(vpp_session.query_vpp_config())
self.test_session.update(your_discriminator=p[BFD].my_discriminator,
state=BFDState.up)
self.logger.info("BFD: Waiting for event")
- e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
verify_event(self, e, expected_state=BFDState.init)
self.logger.info("BFD: Sending Up")
self.test_session.send_packet()
self.logger.info("BFD: Waiting for event")
- e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
verify_event(self, e, expected_state=BFDState.up)
self.logger.info("BFD: Session is Up")
self.test_session.update(state=BFDState.up)
vpp_session.add_vpp_config()
vpp_session.admin_up()
intf.remove_vpp_config()
- e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
self.assert_equal(e.sw_if_index, sw_if_index, "sw_if_index")
self.assertFalse(vpp_session.query_vpp_config())
while True:
kwargs['cursor'] = cursor
rv, details = f(**kwargs)
- #
- # Convert to yield from details when we only support python 3
- #
for d in details:
yield d
if rv.retval == 0 or rv.retval != -165:
break
cursor = rv.cursor
-
-# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
try:
self.socket.connect(self.server_address)
except socket.error as msg:
- logging.error("{} on socket {}".format(msg, self.server_address))
- raise
+ # logging.error("{} on socket {}".format(msg, self.server_address))
+ raise msg
self.connected = True
@echo ""
@echo " SKIP_AARCH64=1 - skip tests that are failing on the ARM platorm in FD.io CI"
@echo ""
- @echo " SOCKET=1 - Communicate with VPP over Unix domain socket instead of SHM"
- @echo ""
@echo " RND_SEED=seed - Seed RND with given seed"
@echo ""
@echo "Creating test documentation"
from vpp_papi_provider import VppPapiProvider
import vpp_papi
from vpp_papi.vpp_stats import VPPStats
-from vpp_papi.vpp_transport_shmem import VppTransportShmemIOError
+from vpp_papi.vpp_transport_socket import VppTransportSocketIOError
from log import RED, GREEN, YELLOW, double_line_delim, single_line_delim, \
get_logger, colorize
from vpp_object import VppObjectRegistry
cls.logger.addHandler(cls.file_handler)
cls.logger.debug("--- setUpClass() for %s called ---" %
cls.__name__)
- cls.shm_prefix = os.path.basename(cls.tempdir)
+ cls.shm_prefix = os.path.basename(cls.tempdir) # Only used for VAPI
os.chdir(cls.tempdir)
- cls.logger.info("Temporary dir is %s, shm prefix is %s",
- cls.tempdir, cls.shm_prefix)
+ cls.logger.info("Temporary dir is %s, api socket is %s",
+ cls.tempdir, cls.api_sock)
cls.logger.debug("Random seed is %s" % seed)
cls.setUpConstants()
cls.reset_packet_infos()
cls.pump_thread.start()
if cls.debug_gdb or cls.debug_gdbserver:
cls.vapi_response_timeout = 0
- cls.vapi = VppPapiProvider(cls.shm_prefix, cls.shm_prefix, cls,
+ cls.vapi = VppPapiProvider(cls.__name__, cls,
cls.vapi_response_timeout)
if cls.step:
hook = hookmodule.StepHook(cls)
raise
try:
cls.vapi.connect()
- except vpp_papi.VPPIOError as e:
+ except (vpp_papi.VPPIOError, Exception) as e:
cls.logger.debug("Exception connecting to vapi: %s" % e)
cls.vapi.disconnect()
print(colorize("You're running VPP inside gdbserver but "
"VPP-API connection failed, did you forget "
"to 'continue' VPP from within gdb?", RED))
- raise
+ raise e
except vpp_papi.VPPRuntimeError as e:
cls.logger.debug("%s" % e)
cls.quit()
- raise
+ raise e
except Exception as e:
cls.logger.debug("Exception connecting to VPP: %s" % e)
cls.quit()
- raise
+ raise e
@classmethod
def _debug_quit(cls):
cls.logger.debug("Sending TERM to vpp")
cls.vpp.terminate()
cls.logger.debug("Waiting for vpp to die")
- cls.vpp.communicate()
+ try:
+ outs, errs = cls.vpp.communicate(timeout=5)
+ except subprocess.TimeoutExpired:
+ cls.vpp.kill()
+ outs, errs = cls.vpp.communicate()
cls.logger.debug("Deleting class vpp attribute on %s",
cls.__name__)
cls.vpp.stdout.close()
os.rename(tmp_api_trace, vpp_api_trace_log)
self.logger.info(self.vapi.ppcli("api trace custom-dump %s" %
vpp_api_trace_log))
- except VppTransportShmemIOError:
- self.logger.debug("VppTransportShmemIOError: Vpp dead. "
+ except VppTransportSocketIOError:
+ self.logger.debug("VppTransportSocketIOError: Vpp dead. "
"Cannot log show commands.")
self.vpp_dead = True
else:
stats0 = policer.get_stats(worker=0)
stats1 = policer.get_stats(worker=1)
- if pol_bind is 1:
+ if pol_bind == 1:
# First pass: Worker 1, should have done all the policing
self.assertEqual(stats, stats1)
stats0 = policer.get_stats(worker=0)
stats1 = policer.get_stats(worker=1)
- if pol_bind is 1:
+ if pol_bind == 1:
# First pass: Worker 1, should have done all the policing
self.assertEqual(stats, stats1)
import os
import time
from collections import deque
-
+import queue
from six import moves, iteritems
from vpp_papi import VPPApiClient, mac_pton
from hook import Hook
from vpp_ip_route import MPLS_IETF_MAX_LABEL, MPLS_LABEL_INVALID
-
#
# Dictionary keyed on message name to override default values for
# named parameters
_zero, _negative = range(2)
- def __init__(self, name, shm_prefix, test_class, read_timeout):
+ def __init__(self, name, test_class, read_timeout):
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 = []
# calling the constructor.
VPPApiClient.apidir = os.getenv('VPP_INSTALL_PATH')
- use_socket = False
- try:
- if os.environ['SOCKET'] == '1':
- use_socket = True
- except KeyError:
- pass
-
self.vpp = VPPApiClient(logger=test_class.logger,
read_timeout=read_timeout,
- use_socket=use_socket,
+ use_socket=True,
server_address=test_class.api_sock)
- self._events = deque()
+ self._events = queue.Queue()
def __enter__(self):
return self
def collect_events(self):
""" Collect all events from the internal queue and clear the queue. """
- e = self._events
- self._events = deque()
- return e
+ result = []
+ while True:
+ try:
+ e = self._events.get(block=False)
+ result.append(e)
+ except queue.Empty:
+ return result
+ return result
def wait_for_event(self, timeout, name=None):
""" Wait for and return next event. """
else:
self.test_class.logger.debug("Expecting event within %ss",
timeout)
- if self._events:
- self.test_class.logger.debug("Not waiting, event already queued")
- limit = time.time() + timeout
- while time.time() < limit:
- if self._events:
- e = self._events.popleft()
- if name and type(e).__name__ != name:
- raise Exception(
- "Unexpected event received: %s, expected: %s" %
- (type(e).__name__, name))
- self.test_class.logger.debug("Returning event %s:%s" %
- (name, e))
- return e
- self.test_class.sleep(0) # yield
- raise Exception("Event did not occur within timeout")
+ try:
+ e = self._events.get(timeout=timeout)
+ except queue.Empty:
+ raise Exception("Event did not occur within timeout")
+ msgname = type(e).__name__
+ if name and msgname != name:
+ raise Exception("Unexpected event received: %s, expected: %s"
+ % msgname)
+ self.test_class.logger.debug("Returning event %s:%s" % (name, e))
+ return e
def __call__(self, name, event):
""" Enqueue event in the internal event queue. """
- # FIXME use the name instead of relying on type(e).__name__ ?
- # FIXME #2 if this throws, it is eaten silently, Ole?
self.test_class.logger.debug("New event: %s: %s" % (name, event))
- self._events.append(event)
+ self._events.put(event)
def factory(self, name, apifn):
def f(*a, **ka):
def connect(self):
"""Connect the API to VPP"""
- self.vpp.connect(self.name, self.shm_prefix)
+ # This might be called before VPP is prepared to listen to the socket
+ retries = 0
+ while not os.path.exists(self.test_class.api_sock):
+ time.sleep(0.5)
+ retries += 1
+ if retries > 120:
+ break
+ self.vpp.connect(self.name[:63])
self.papi = self.vpp.api
self.vpp.register_event_callback(self)
Code Review / vpp.git / commitdiff