Ejemplo n.º 1
0
 def setUpClass(cls):
     """
     Perform class setup before running the testcase
     Remove shared memory files, start vpp and connect the vpp-api
     """
     cls.logger = getLogger(cls.__name__)
     cls.tempdir = tempfile.mkdtemp(
         prefix='vpp-unittest-' + cls.__name__ + '-')
     file_handler = FileHandler("%s/log.txt" % cls.tempdir)
     file_handler.setLevel(DEBUG)
     cls.logger.addHandler(file_handler)
     cls.shm_prefix = cls.tempdir.split("/")[-1]
     os.chdir(cls.tempdir)
     cls.logger.info("Temporary dir is %s, shm prefix is %s",
                     cls.tempdir, cls.shm_prefix)
     cls.setUpConstants()
     cls.reset_packet_infos()
     cls._captures = []
     cls._zombie_captures = []
     cls.verbose = 0
     cls.vpp_dead = False
     print(double_line_delim)
     print(colorize(getdoc(cls).splitlines()[0], YELLOW))
     print(double_line_delim)
     # need to catch exceptions here because if we raise, then the cleanup
     # doesn't get called and we might end with a zombie vpp
     try:
         cls.run_vpp()
         cls.vpp_stdout_deque = deque()
         cls.vpp_stdout_reader_thread = Thread(target=pump_output, args=(
             cls.vpp.stdout, cls.vpp_stdout_deque))
         cls.vpp_stdout_reader_thread.start()
         cls.vpp_stderr_deque = deque()
         cls.vpp_stderr_reader_thread = Thread(target=pump_output, args=(
             cls.vpp.stderr, cls.vpp_stderr_deque))
         cls.vpp_stderr_reader_thread.start()
         cls.vapi = VppPapiProvider(cls.shm_prefix, cls.shm_prefix, cls)
         if cls.step:
             hook = StepHook(cls)
         else:
             hook = PollHook(cls)
         cls.vapi.register_hook(hook)
         time.sleep(0.1)
         hook.poll_vpp()
         try:
             cls.vapi.connect()
         except:
             if cls.debug_gdbserver:
                 print(colorize("You're running VPP inside gdbserver but "
                                "VPP-API connection failed, did you forget "
                                "to 'continue' VPP from within gdb?", RED))
             raise
     except:
         t, v, tb = sys.exc_info()
         try:
             cls.quit()
         except:
             pass
         raise t, v, tb
Ejemplo n.º 2
0
 def setUpClass(cls):
     """
     Perform class setup before running the testcase
     Remove shared memory files, start vpp and connect the vpp-api
     """
     cls.logger = getLogger(cls.__name__)
     cls.tempdir = tempfile.mkdtemp(prefix='vpp-unittest-' + cls.__name__ +
                                    '-')
     cls.shm_prefix = cls.tempdir.split("/")[-1]
     os.chdir(cls.tempdir)
     cls.logger.info("Temporary dir is %s, shm prefix is %s", cls.tempdir,
                     cls.shm_prefix)
     cls.setUpConstants()
     cls.pg_streams = []
     cls.packet_infos = {}
     cls.verbose = 0
     print(double_line_delim)
     print(colorize(getdoc(cls).splitlines()[0], YELLOW))
     print(double_line_delim)
     # need to catch exceptions here because if we raise, then the cleanup
     # doesn't get called and we might end with a zombie vpp
     try:
         cls.run_vpp()
         cls.vpp_dead = False
         cls.vapi = VppPapiProvider(cls.shm_prefix, cls.shm_prefix)
         if cls.step:
             cls.vapi.register_hook(StepHook(cls))
         else:
             cls.vapi.register_hook(PollHook(cls))
         time.sleep(0.1)
         try:
             cls.vapi.connect()
         except:
             if cls.debug_gdbserver:
                 print(
                     colorize(
                         "You're running VPP inside gdbserver but "
                         "VPP-API connection failed, did you forget "
                         "to 'continue' VPP from within gdb?", RED))
             raise
         cls.vpp_stdout_queue = Queue()
         cls.vpp_stdout_reader_thread = Thread(target=pump_output,
                                               args=(cls.vpp.stdout,
                                                     cls.vpp_stdout_queue))
         cls.vpp_stdout_reader_thread.start()
         cls.vpp_stderr_queue = Queue()
         cls.vpp_stderr_reader_thread = Thread(target=pump_output,
                                               args=(cls.vpp.stderr,
                                                     cls.vpp_stderr_queue))
         cls.vpp_stderr_reader_thread.start()
     except:
         if hasattr(cls, 'vpp'):
             cls.vpp.terminate()
             del cls.vpp
         raise
Ejemplo n.º 3
0
 def setUpClass(cls):
     """
     Perform class setup before running the testcase
     Remove shared memory files, start vpp and connect the vpp-api
     """
     gc.collect()  # run garbage collection first
     random.seed()
     cls.logger = getLogger(cls.__name__)
     cls.tempdir = tempfile.mkdtemp(
         prefix='vpp-unittest-%s-' % cls.__name__)
     cls.file_handler = FileHandler("%s/log.txt" % cls.tempdir)
     cls.file_handler.setFormatter(
         Formatter(fmt='%(asctime)s,%(msecs)03d %(message)s',
                   datefmt="%H:%M:%S"))
     cls.file_handler.setLevel(DEBUG)
     cls.logger.addHandler(cls.file_handler)
     cls.shm_prefix = cls.tempdir.split("/")[-1]
     os.chdir(cls.tempdir)
     cls.logger.info("Temporary dir is %s, shm prefix is %s",
                     cls.tempdir, cls.shm_prefix)
     cls.setUpConstants()
     cls.reset_packet_infos()
     cls._captures = []
     cls._zombie_captures = []
     cls.verbose = 0
     cls.vpp_dead = False
     cls.registry = VppObjectRegistry()
     cls.vpp_startup_failed = False
     cls.reporter = KeepAliveReporter()
     # need to catch exceptions here because if we raise, then the cleanup
     # doesn't get called and we might end with a zombie vpp
     try:
         cls.run_vpp()
         cls.reporter.send_keep_alive(cls)
         cls.vpp_stdout_deque = deque()
         cls.vpp_stderr_deque = deque()
         cls.pump_thread_stop_flag = Event()
         cls.pump_thread_wakeup_pipe = os.pipe()
         cls.pump_thread = Thread(target=pump_output, args=(cls,))
         cls.pump_thread.daemon = True
         cls.pump_thread.start()
         cls.vapi = VppPapiProvider(cls.shm_prefix, cls.shm_prefix, cls)
         if cls.step:
             hook = StepHook(cls)
         else:
             hook = PollHook(cls)
         cls.vapi.register_hook(hook)
         cls.sleep(0.1, "after vpp startup, before initial poll")
         try:
             hook.poll_vpp()
         except:
             cls.vpp_startup_failed = True
             cls.logger.critical(
                 "VPP died shortly after startup, check the"
                 " output to standard error for possible cause")
             raise
         try:
             cls.vapi.connect()
         except:
             if cls.debug_gdbserver:
                 print(colorize("You're running VPP inside gdbserver but "
                                "VPP-API connection failed, did you forget "
                                "to 'continue' VPP from within gdb?", RED))
             raise
     except:
         t, v, tb = sys.exc_info()
         try:
             cls.quit()
         except:
             pass
         raise t, v, tb
Ejemplo n.º 4
0
 def setUpClass(cls):
     """
     Perform class setup before running the testcase
     Remove shared memory files, start vpp and connect the vpp-api
     """
     gc.collect()  # run garbage collection first
     random.seed()
     cls.logger = get_logger(cls.__name__)
     if hasattr(cls, 'parallel_handler'):
         cls.logger.addHandler(cls.parallel_handler)
         cls.logger.propagate = False
     cls.tempdir = tempfile.mkdtemp(
         prefix='vpp-unittest-%s-' % cls.__name__)
     cls.stats_sock = "%s/stats.sock" % cls.tempdir
     cls.file_handler = FileHandler("%s/log.txt" % cls.tempdir)
     cls.file_handler.setFormatter(
         Formatter(fmt='%(asctime)s,%(msecs)03d %(message)s',
                   datefmt="%H:%M:%S"))
     cls.file_handler.setLevel(DEBUG)
     cls.logger.addHandler(cls.file_handler)
     cls.shm_prefix = os.path.basename(cls.tempdir)
     os.chdir(cls.tempdir)
     cls.logger.info("Temporary dir is %s, shm prefix is %s",
                     cls.tempdir, cls.shm_prefix)
     cls.setUpConstants()
     cls.reset_packet_infos()
     cls._captures = []
     cls._zombie_captures = []
     cls.verbose = 0
     cls.vpp_dead = False
     cls.registry = VppObjectRegistry()
     cls.vpp_startup_failed = False
     cls.reporter = KeepAliveReporter()
     # need to catch exceptions here because if we raise, then the cleanup
     # doesn't get called and we might end with a zombie vpp
     try:
         cls.run_vpp()
         cls.reporter.send_keep_alive(cls, 'setUpClass')
         VppTestResult.current_test_case_info = TestCaseInfo(
             cls.logger, cls.tempdir, cls.vpp.pid, cls.vpp_bin)
         cls.vpp_stdout_deque = deque()
         cls.vpp_stderr_deque = deque()
         cls.pump_thread_stop_flag = Event()
         cls.pump_thread_wakeup_pipe = os.pipe()
         cls.pump_thread = Thread(target=pump_output, args=(cls,))
         cls.pump_thread.daemon = True
         cls.pump_thread.start()
         if cls.debug_gdb or cls.debug_gdbserver:
             read_timeout = 0
         else:
             read_timeout = 5
         cls.vapi = VppPapiProvider(cls.shm_prefix, cls.shm_prefix, cls,
                                    read_timeout)
         if cls.step:
             hook = StepHook(cls)
         else:
             hook = PollHook(cls)
         cls.vapi.register_hook(hook)
         cls.wait_for_stats_socket()
         cls.statistics = VPPStats(socketname=cls.stats_sock)
         try:
             hook.poll_vpp()
         except VppDiedError:
             cls.vpp_startup_failed = True
             cls.logger.critical(
                 "VPP died shortly after startup, check the"
                 " output to standard error for possible cause")
             raise
         try:
             cls.vapi.connect()
         except Exception:
             try:
                 cls.vapi.disconnect()
             except Exception:
                 pass
             if cls.debug_gdbserver:
                 print(colorize("You're running VPP inside gdbserver but "
                                "VPP-API connection failed, did you forget "
                                "to 'continue' VPP from within gdb?", RED))
             raise
     except Exception:
         try:
             cls.quit()
         except Exception:
             pass
         raise