SKIP = 3
TEST_RUN = 4
-debug_framework = False
-if os.getenv('TEST_DEBUG', "0") == "1":
- debug_framework = True
+
+class BoolEnvironmentVariable(object):
+
+ def __init__(self, env_var_name, default='n', true_values=None):
+ self.name = env_var_name
+ self.default = default
+ self.true_values = true_values if true_values is not None else \
+ ("y", "yes", "1")
+
+ def __bool__(self):
+ return os.getenv(self.name, self.default).lower() in self.true_values
+
+ if sys.version_info[0] == 2:
+ __nonzero__ = __bool__
+
+ def __repr__(self):
+ return 'BoolEnvironmentVariable(%r, default=%r, true_values=%r)' % \
+ (self.name, self.default, self.true_values)
+
+
+debug_framework = BoolEnvironmentVariable('TEST_DEBUG')
+if debug_framework:
import debug_internal
"""
try:
self.signal_name = VppDiedError.signals_by_value[-rv]
- except KeyError:
+ except (KeyError, TypeError):
pass
if testcase is None and method_name is None:
msg = "VPP subprocess died %sunexpectedly with return code: %d%s." % (
in_msg,
self.rv,
- ' [%s]' % self.signal_name if
- self.signal_name is not None else '')
+ ' [%s]' % (self.signal_name if
+ self.signal_name is not None else ''))
super(VppDiedError, self).__init__(msg)
if testclass.vpp.stderr.fileno() in readable:
read = os.read(testclass.vpp.stderr.fileno(), 102400)
if len(read) > 0:
- split = read.splitlines(True)
+ split = read.decode('ascii',
+ errors='backslashreplace').splitlines(True)
if len(stderr_fragment) > 0:
split[0] = "%s%s" % (stderr_fragment, split[0])
- if len(split) > 0 and split[-1].endswith(b"\n"):
+ if len(split) > 0 and split[-1].endswith("\n"):
limit = None
else:
limit = -1
stderr_fragment = split[-1]
+
testclass.vpp_stderr_deque.extend(split[:limit])
if not testclass.cache_vpp_output:
for line in split[:limit]:
def _is_skip_aarch64_set():
- return os.getenv('SKIP_AARCH64', 'n').lower() in ('yes', 'y', '1')
+ return BoolEnvironmentVariable('SKIP_AARCH64')
is_skip_aarch64_set = _is_skip_aarch64_set()
def _running_extended_tests():
- s = os.getenv("EXTENDED_TESTS", "n")
- return True if s.lower() in ("y", "yes", "1") else False
+ return BoolEnvironmentVariable("EXTENDED_TESTS")
running_extended_tests = _running_extended_tests()
return True if "centos" in os_id.lower() else False
-running_on_centos = _running_on_centos
+running_on_centos = _running_on_centos()
class KeepAliveReporter(object):
@classmethod
def setUpConstants(cls):
""" Set-up the test case class based on environment variables """
- s = os.getenv("STEP", "n")
- cls.step = True if s.lower() in ("y", "yes", "1") else False
+ cls.step = BoolEnvironmentVariable('STEP')
d = os.getenv("DEBUG", None)
+ # inverted case to handle '' == True
c = os.getenv("CACHE_OUTPUT", "1")
cls.cache_vpp_output = False if c.lower() in ("n", "no", "0") else True
cls.set_debug_flags(d)
coredump_size = "coredump-size unlimited"
cpu_core_number = cls.get_least_used_cpu()
+ if not hasattr(cls, "worker_config"):
+ cls.worker_config = ""
cls.vpp_cmdline = [cls.vpp_bin, "unix",
"{", "nodaemon", debug_cli, "full-coredump",
coredump_size, "runtime-dir", cls.tempdir, "}",
"api-trace", "{", "on", "}", "api-segment", "{",
"prefix", cls.shm_prefix, "}", "cpu", "{",
- "main-core", str(cpu_core_number), "}",
+ "main-core", str(cpu_core_number),
+ cls.worker_config, "}",
"statseg", "{", "socket-name", cls.stats_sock, "}",
"socksvr", "{", "socket-name", cls.api_sock, "}",
"plugins",
@classmethod
def wait_for_stats_socket(cls):
- deadline = time.time() + 3
+ deadline = time.time() + 300
ok = False
while time.time() < deadline or \
cls.debug_gdb or cls.debug_gdbserver:
cls.setUpConstants()
cls.reset_packet_infos()
cls._captures = []
- cls._zombie_captures = []
cls.verbose = 0
cls.vpp_dead = False
cls.registry = VppObjectRegistry()
"VPP-API connection failed, did you forget "
"to 'continue' VPP from within gdb?", RED))
raise
- except Exception:
+ except Exception as e:
+ cls.logger.debug("Exception connecting to VPP: %s" % e)
cls.quit()
raise
self.logger.info(self.statistics.set_errors_str())
self.logger.info(self.vapi.ppcli("show run"))
self.logger.info(self.vapi.ppcli("show log"))
+ self.logger.info(self.vapi.ppcli("show bihash"))
self.logger.info("Logging testcase specific show commands.")
self.show_commands_at_teardown()
self.registry.remove_vpp_config(self.logger)
super(VppTestCase, self).setUp()
self.reporter.send_keep_alive(self)
if self.vpp_dead:
- raise VppDiedError(self.__class__.__name__, self._testMethodName,
- "VPP is dead when setting up the test "
- "(%s.%s)." % (self.__class__.__name__,
- self._testMethodName))
+
+ raise VppDiedError(rv=None, testcase=self.__class__.__name__,
+ method_name=self._testMethodName)
self.sleep(.1, "during setUp")
self.vpp_stdout_deque.append(
"--- test setUp() for %s.%s(%s) starts here ---\n" %
""" Register a capture in the testclass """
# add to the list of captures with current timestamp
cls._captures.append((time.time(), cap_name))
- # filter out from zombies
- cls._zombie_captures = [(stamp, name)
- for (stamp, name) in cls._zombie_captures
- if name != cap_name]
@classmethod
def pg_start(cls):
- """ Remove any zombie captures and enable the packet generator """
- # how long before capture is allowed to be deleted - otherwise vpp
- # crashes - 100ms seems enough (this shouldn't be needed at all)
- capture_ttl = 0.1
- now = time.time()
- for stamp, cap_name in cls._zombie_captures:
- wait = stamp + capture_ttl - now
- if wait > 0:
- cls.sleep(wait, "before deleting capture %s" % cap_name)
- now = time.time()
- cls.logger.debug("Removing zombie capture %s" % cap_name)
- cls.vapi.cli('packet-generator delete %s' % cap_name)
-
+ """ Enable the PG, wait till it is done, then clean up """
cls.vapi.cli("trace add pg-input 1000")
cls.vapi.cli('packet-generator enable')
- cls._zombie_captures = cls._captures
+ # PG, when starts, runs to completion -
+ # so let's avoid a race condition,
+ # and wait a little till it's done.
+ # Then clean it up - and then be gone.
+ deadline = time.time() + 300
+ while cls.vapi.cli('show packet-generator').find("Yes") != -1:
+ cls.sleep(0.01) # yield
+ if time.time() > deadline:
+ cls.logger.error("Timeout waiting for pg to stop")
+ break
+ for stamp, cap_name in cls._captures:
+ cls.vapi.cli('packet-generator delete %s' % cap_name)
cls._captures = []
@classmethod
- def create_pg_interfaces(cls, interfaces):
+ def create_pg_interfaces(cls, interfaces, gso=0, gso_size=0):
"""
Create packet-generator interfaces.
"""
result = []
for i in interfaces:
- intf = VppPGInterface(cls, i)
+ intf = VppPGInterface(cls, i, gso, gso_size)
setattr(cls, intf.name, intf)
result.append(intf)
cls.pg_interfaces = result
def assert_packet_checksums_valid(self, packet,
ignore_zero_udp_checksums=True):
received = packet.__class__(scapy.compat.raw(packet))
- self.logger.debug(
- ppp("Verifying packet checksums for packet:", received))
udp_layers = ['UDP', 'UDPerror']
checksum_fields = ['cksum', 'chksum']
checksums = []
class Worker(Thread):
- def __init__(self, args, logger, env={}):
+ def __init__(self, args, logger, env=None):
self.logger = logger
self.args = args
+ self.process = None
self.result = None
+ env = {} if env is None else env
self.env = copy.deepcopy(env)
super(Worker, self).__init__()
def run(self):
executable = self.args[0]
+ if not os.path.exists(executable) or not os.access(
+ executable, os.F_OK | os.X_OK):
+ # Exit code that means some system file did not exist,
+ # could not be opened, or had some other kind of error.
+ self.result = os.EX_OSFILE
+ raise EnvironmentError(
+ "executable '%s' is not found or executable." % executable)
self.logger.debug("Running executable w/args `%s'" % self.args)
env = os.environ.copy()
env.update(self.env)