test/test_quic.py

   1 #!/usr/bin/env python3
   2 """ Vpp QUIC tests """
   3
   4 import unittest
   5 import os
   6 import subprocess
   7 import signal
   8 from config import config
   9 from framework import tag_fixme_vpp_workers
  10 from framework import VppTestCase, VppTestRunner, Worker
  11 from vpp_ip_route import VppIpTable, VppIpRoute, VppRoutePath
  12
  13
  14 class QUICAppWorker(Worker):
  15     """QUIC Test Application Worker"""
  16
  17     process = None
  18
  19     def __init__(
  20         self,
  21         appname,
  22         executable_args,
  23         logger,
  24         role,
  25         testcase,
  26         env=None,
  27         *args,
  28         **kwargs,
  29     ):
  30         if env is None:
  31             env = {}
  32         app = f"{config.vpp_build_dir}/vpp/bin/{appname}"
  33         self.args = [app] + executable_args
  34         self.role = role
  35         self.wait_for_gdb = "wait-for-gdb"
  36         self.testcase = testcase
  37         super(QUICAppWorker, self).__init__(self.args, logger, env, *args, **kwargs)
  38
  39     def run(self):
  40         super(QUICAppWorker, self).run()
  41
  42     def teardown(self, logger, timeout):
  43         if self.process is None:
  44             return False
  45         try:
  46             logger.debug("Killing worker process (pid %d)" % self.process.pid)
  47             os.killpg(os.getpgid(self.process.pid), signal.SIGKILL)
  48             self.join(timeout)
  49         except OSError as e:
  50             logger.debug("Couldn't kill worker process")
  51             return True
  52         return False
  53
  54
  55 class QUICTestCase(VppTestCase):
  56     """QUIC Test Case"""
  57
  58     timeout = 20
  59     pre_test_sleep = 0.3
  60     post_test_sleep = 0.3
  61
  62     @classmethod
  63     def setUpClass(cls):
  64         cls.extra_vpp_plugin_config.append("plugin quic_plugin.so { enable }")
  65         super(QUICTestCase, cls).setUpClass()
  66
  67     def setUp(self):
  68         super(QUICTestCase, self).setUp()
  69         self.vppDebug = "vpp_debug" in config.vpp_build_dir
  70
  71         self.create_loopback_interfaces(2)
  72         self.uri = "quic://%s/1234" % self.loop0.local_ip4
  73         table_id = 1
  74         for i in self.lo_interfaces:
  75             i.admin_up()
  76
  77             if table_id != 0:
  78                 tbl = VppIpTable(self, table_id)
  79                 tbl.add_vpp_config()
  80
  81             i.set_table_ip4(table_id)
  82             i.config_ip4()
  83             table_id += 1
  84
  85         # Configure namespaces
  86         self.vapi.app_namespace_add_del(
  87             namespace_id="server", sw_if_index=self.loop0.sw_if_index
  88         )
  89         self.vapi.app_namespace_add_del(
  90             namespace_id="client", sw_if_index=self.loop1.sw_if_index
  91         )
  92
  93         # Add inter-table routes
  94         self.ip_t01 = VppIpRoute(
  95             self,
  96             self.loop1.local_ip4,
  97             32,
  98             [VppRoutePath("0.0.0.0", 0xFFFFFFFF, nh_table_id=2)],
  99             table_id=1,
 100         )
 101         self.ip_t10 = VppIpRoute(
 102             self,
 103             self.loop0.local_ip4,
 104             32,
 105             [VppRoutePath("0.0.0.0", 0xFFFFFFFF, nh_table_id=1)],
 106             table_id=2,
 107         )
 108         self.ip_t01.add_vpp_config()
 109         self.ip_t10.add_vpp_config()
 110         self.logger.debug(self.vapi.cli("show ip fib"))
 111
 112     def tearDown(self):
 113         # Delete inter-table routes
 114         self.ip_t01.remove_vpp_config()
 115         self.ip_t10.remove_vpp_config()
 116
 117         for i in self.lo_interfaces:
 118             i.unconfig_ip4()
 119             i.set_table_ip4(0)
 120             i.admin_down()
 121         super(QUICTestCase, self).tearDown()
 122
 123
 124 class QUICEchoIntTestCase(QUICTestCase):
 125     """QUIC Echo Internal Test Case"""
 126
 127     test_bytes = " test-bytes"
 128     extra_vpp_punt_config = ["session", "{", "enable", "poll-main", "}"]
 129
 130     def setUp(self):
 131         super(QUICEchoIntTestCase, self).setUp()
 132         self.client_args = "uri {uri} fifo-size 64{testbytes} appns client".format(
 133             uri=self.uri, testbytes=self.test_bytes
 134         )
 135         self.server_args = "uri %s fifo-size 64 appns server" % self.uri
 136
 137     def tearDown(self):
 138         super(QUICEchoIntTestCase, self).tearDown()
 139
 140     def server(self, *args):
 141         error = self.vapi.cli(
 142             "test echo server %s %s" % (self.server_args, " ".join(args))
 143         )
 144         if error:
 145             self.logger.critical(error)
 146             self.assertNotIn("failed", error)
 147
 148     def client(self, *args):
 149         error = self.vapi.cli(
 150             "test echo client %s %s" % (self.client_args, " ".join(args))
 151         )
 152         if error:
 153             self.logger.critical(error)
 154             self.assertNotIn("failed", error)
 155
 156
 157 @tag_fixme_vpp_workers
 158 class QUICEchoIntTransferTestCase(QUICEchoIntTestCase):
 159     """QUIC Echo Internal Transfer Test Case"""
 160
 161     def test_quic_int_transfer(self):
 162         """QUIC internal transfer"""
 163         self.server()
 164         self.client("no-output", "mbytes", "2")
 165
 166
 167 @tag_fixme_vpp_workers
 168 class QUICEchoIntSerialTestCase(QUICEchoIntTestCase):
 169     """QUIC Echo Internal Serial Transfer Test Case"""
 170
 171     def test_quic_serial_int_transfer(self):
 172         """QUIC serial internal transfer"""
 173         self.server()
 174         self.client("no-output", "mbytes", "2")
 175         self.client("no-output", "mbytes", "2")
 176         self.client("no-output", "mbytes", "2")
 177         self.client("no-output", "mbytes", "2")
 178         self.client("no-output", "mbytes", "2")
 179
 180
 181 @tag_fixme_vpp_workers
 182 class QUICEchoIntMStreamTestCase(QUICEchoIntTestCase):
 183     """QUIC Echo Internal MultiStream Test Case"""
 184
 185     def test_quic_int_multistream_transfer(self):
 186         """QUIC internal multi-stream transfer"""
 187         self.server()
 188         self.client("nclients", "10", "mbytes", "1", "no-output")
 189
 190
 191 class QUICEchoExtTestCase(QUICTestCase):
 192     quic_setup = "default"
 193     test_bytes = "test-bytes:assert"
 194     pre_test_sleep = 1
 195     post_test_sleep = 1
 196     app = "vpp_echo"
 197     evt_q_len = 16384
 198     vpp_worker_count = 1
 199     server_fifo_size = "1M"
 200     client_fifo_size = "4M"
 201     extra_vpp_punt_config = [
 202         "session",
 203         "{",
 204         "enable",
 205         "poll-main",
 206         "evt_qs_memfd_seg",
 207         "evt_qs_seg_size",
 208         "64M",
 209         "event-queue-length",
 210         f"{evt_q_len}",
 211         "preallocated-sessions",
 212         "1024",
 213         "v4-session-table-buckets",
 214         "20000",
 215         "v4-session-table-memory",
 216         "64M",
 217         "v4-halfopen-table-buckets",
 218         "20000",
 219         "v4-halfopen-table-memory",
 220         "64M",
 221         "local-endpoints-table-buckets",
 222         "250000",
 223         "local-endpoints-table-memory",
 224         "512M",
 225         "}",
 226     ]
 227
 228     def setUp(self):
 229         super(QUICEchoExtTestCase, self).setUp()
 230         common_args = [
 231             "uri",
 232             self.uri,
 233             "json",
 234             self.test_bytes,
 235             "socket-name",
 236             self.get_api_sock_path(),
 237             "quic-setup",
 238             self.quic_setup,
 239             "nthreads",
 240             "1",
 241             "mq-size",
 242             f"{self.evt_q_len}",
 243         ]
 244         self.server_echo_test_args = common_args + [
 245             "server",
 246             "appns",
 247             "server",
 248             "fifo-size",
 249             f"{self.server_fifo_size}",
 250         ]
 251         self.client_echo_test_args = common_args + [
 252             "client",
 253             "appns",
 254             "client",
 255             "fifo-size",
 256             f"{self.client_fifo_size}",
 257         ]
 258         error = self.vapi.cli("quic set fifo-size 2M")
 259         if error:
 260             self.logger.critical(error)
 261             self.assertNotIn("failed", error)
 262
 263     def server(self, *args):
 264         _args = self.server_echo_test_args + list(args)
 265         self.worker_server = QUICAppWorker(self.app, _args, self.logger, "server", self)
 266         self.worker_server.start()
 267         self.sleep(self.pre_test_sleep)
 268
 269     def client(self, *args):
 270         _args = self.client_echo_test_args + list(args)
 271         self.worker_client = QUICAppWorker(self.app, _args, self.logger, "client", self)
 272         self.worker_client.start()
 273         timeout = None if self.debug_all else self.timeout
 274         self.worker_client.join(timeout)
 275         if self.worker_client.is_alive():
 276             error = f"Client failed to complete in {timeout} seconds!"
 277             self.logger.critical(error)
 278             return
 279         self.worker_server.join(timeout)
 280         if self.worker_server.is_alive():
 281             error = f"Server failed to complete in {timeout} seconds!"
 282             self.logger.critical(error)
 283         self.sleep(self.post_test_sleep)
 284
 285     def validate_ext_test_results(self):
 286         server_result = self.worker_server.result
 287         client_result = self.worker_client.result
 288         self.logger.info("Server worker result is `%s'" % server_result)
 289         self.logger.info("Client worker result is `%s'" % client_result)
 290         server_kill_error = False
 291         if self.worker_server.result is None:
 292             server_kill_error = self.worker_server.teardown(self.logger, self.timeout)
 293         if self.worker_client.result is None:
 294             self.worker_client.teardown(self.logger, self.timeout)
 295         err_msg = "Wrong server worker return code (%s)" % server_result
 296         self.assertEqual(server_result, 0, err_msg)
 297         self.assertIsNotNone(
 298             client_result, "Timeout! Client worker did not finish in %ss" % self.timeout
 299         )
 300         err_msg = "Wrong client worker return code (%s)" % client_result
 301         self.assertEqual(client_result, 0, err_msg)
 302         self.assertFalse(server_kill_error, "Server kill errored")
 303
 304
 305 class QUICEchoExtTransferTestCase(QUICEchoExtTestCase):
 306     """QUIC Echo External Transfer Test Case"""
 307
 308     timeout = 60
 309
 310     def test_quic_ext_transfer(self):
 311         """QUIC external transfer"""
 312         self.server()
 313         self.client()
 314         self.validate_ext_test_results()
 315
 316
 317 class QUICEchoExtTransferBigTestCase(QUICEchoExtTestCase):
 318     """QUIC Echo External Transfer Big Test Case"""
 319
 320     server_fifo_size = "4M"
 321     client_fifo_size = "4M"
 322     test_bytes = ""
 323     timeout = 60
 324
 325     @unittest.skipUnless(config.extended, "part of extended tests")
 326     def test_quic_ext_transfer_big(self):
 327         """QUIC external transfer, big stream"""
 328         self.server("TX=0", "RX=2G")
 329         self.client("TX=2G", "RX=0")
 330         self.validate_ext_test_results()
 331
 332
 333 class QUICEchoExtQcloseRxTestCase(QUICEchoExtTestCase):
 334     """QUIC Echo External Transfer Qclose Rx Test Case"""
 335
 336     @unittest.skipUnless(config.extended, "part of extended tests")
 337     @unittest.skip("testcase under development")
 338     def test_quic_ext_qclose_rx(self):
 339         """QUIC external transfer, rx close"""
 340         self.server("TX=0", "RX=10M", "qclose=Y", "sclose=N")
 341         self.client("TX=10M", "RX=0", "qclose=W", "sclose=W")
 342         self.validate_ext_test_results()
 343
 344
 345 class QUICEchoExtQcloseTxTestCase(QUICEchoExtTestCase):
 346     """QUIC Echo External Transfer Qclose Tx Test Case"""
 347
 348     @unittest.skipUnless(config.extended, "part of extended tests")
 349     @unittest.skip("testcase under development")
 350     def test_quic_ext_qclose_tx(self):
 351         """QUIC external transfer, tx close"""
 352         self.server("TX=0", "RX=10M", "qclose=W", "sclose=W", "rx-results-diff")
 353         self.client("TX=10M", "RX=0", "qclose=Y", "sclose=N")
 354         self.validate_ext_test_results()
 355
 356
 357 class QUICEchoExtEarlyQcloseRxTestCase(QUICEchoExtTestCase):
 358     """QUIC Echo External Transfer Early Qclose Rx Test Case"""
 359
 360     @unittest.skipUnless(config.extended, "part of extended tests")
 361     @unittest.skip("testcase under development")
 362     def test_quic_ext_early_qclose_rx(self):
 363         """QUIC external transfer, early rx close"""
 364         self.server("TX=0", "RX=10M", "qclose=Y", "sclose=N")
 365         self.client("TX=20M", "RX=0", "qclose=W", "sclose=W", "tx-results-diff")
 366         self.validate_ext_test_results()
 367
 368
 369 class QUICEchoExtEarlyQcloseTxTestCase(QUICEchoExtTestCase):
 370     """QUIC Echo External Transfer Early Qclose Tx Test Case"""
 371
 372     @unittest.skipUnless(config.extended, "part of extended tests")
 373     @unittest.skip("testcase under development")
 374     def test_quic_ext_early_qclose_tx(self):
 375         """QUIC external transfer, early tx close"""
 376         self.server("TX=0", "RX=20M", "qclose=W", "sclose=W", "rx-results-diff")
 377         self.client("TX=10M", "RX=0", "qclose=Y", "sclose=N")
 378         self.validate_ext_test_results()
 379
 380
 381 class QUICEchoExtScloseRxTestCase(QUICEchoExtTestCase):
 382     """QUIC Echo External Transfer Sclose Rx Test Case"""
 383
 384     @unittest.skipUnless(config.extended, "part of extended tests")
 385     @unittest.skip("testcase under development")
 386     def test_quic_ext_sclose_rx(self):
 387         """QUIC external transfer, rx stream close"""
 388         self.server("TX=0", "RX=10M", "qclose=N", "sclose=Y")
 389         self.client("TX=10M", "RX=0", "qclose=W", "sclose=W")
 390         self.validate_ext_test_results()
 391
 392
 393 class QUICEchoExtScloseTxTestCase(QUICEchoExtTestCase):
 394     """QUIC Echo External Transfer Sclose Tx Test Case"""
 395
 396     @unittest.skipUnless(config.extended, "part of extended tests")
 397     @unittest.skip("testcase under development")
 398     def test_quic_ext_sclose_tx(self):
 399         """QUIC external transfer, tx stream close"""
 400         self.server("TX=0", "RX=10M", "qclose=W", "sclose=W")
 401         self.client("TX=10M", "RX=0", "qclose=Y", "sclose=Y")
 402         self.validate_ext_test_results()
 403
 404
 405 class QUICEchoExtEarlyScloseRxTestCase(QUICEchoExtTestCase):
 406     """QUIC Echo External Transfer Early Sclose Rx Test Case"""
 407
 408     @unittest.skipUnless(config.extended, "part of extended tests")
 409     @unittest.skip("testcase under development")
 410     def test_quic_ext_early_sclose_rx(self):
 411         """QUIC external transfer, early rx stream close"""
 412         self.server("TX=0", "RX=10M", "qclose=N", "sclose=Y")
 413         self.client("TX=20M", "RX=0", "qclose=W", "sclose=W", "tx-results-diff")
 414         self.validate_ext_test_results()
 415
 416
 417 class QUICEchoExtEarlyScloseTxTestCase(QUICEchoExtTestCase):
 418     """QUIC Echo External Transfer Early Sclose Tx Test Case"""
 419
 420     @unittest.skipUnless(config.extended, "part of extended tests")
 421     @unittest.skip("testcase under development")
 422     def test_quic_ext_early_sclose_tx(self):
 423         """QUIC external transfer, early tx stream close"""
 424         self.server("TX=0", "RX=20M", "qclose=W", "sclose=W", "rx-results-diff")
 425         self.client("TX=10M", "RX=0", "qclose=Y", "sclose=Y")
 426         self.validate_ext_test_results()
 427
 428
 429 class QUICEchoExtServerStreamTestCase(QUICEchoExtTestCase):
 430     """QUIC Echo External Transfer Server Stream Test Case"""
 431
 432     quic_setup = "serverstream"
 433     timeout = 60
 434
 435     def test_quic_ext_transfer_server_stream(self):
 436         """QUIC external server transfer"""
 437         self.server("TX=10M", "RX=0")
 438         self.client("TX=0", "RX=10M")
 439         self.validate_ext_test_results()
 440
 441
 442 class QUICEchoExtServerStreamBigTestCase(QUICEchoExtTestCase):
 443     """QUIC Echo External Transfer Server Stream Big Test Case"""
 444
 445     quic_setup = "serverstream"
 446     server_fifo_size = "4M"
 447     client_fifo_size = "4M"
 448     test_bytes = ""
 449     timeout = 60
 450
 451     @unittest.skipUnless(config.extended, "part of extended tests")
 452     def test_quic_ext_transfer_server_stream_big(self):
 453         """QUIC external server transfer, big stream"""
 454         self.server("TX=2G", "RX=0")
 455         self.client("TX=0", "RX=2G")
 456         self.validate_ext_test_results()
 457
 458
 459 class QUICEchoExtServerStreamQcloseRxTestCase(QUICEchoExtTestCase):
 460     """QUIC Echo External Transfer Server Stream Qclose Rx Test Case"""
 461
 462     quic_setup = "serverstream"
 463
 464     @unittest.skipUnless(config.extended, "part of extended tests")
 465     @unittest.skip("testcase under development")
 466     def test_quic_ext_server_stream_qclose_rx(self):
 467         """QUIC external server transfer, rx close"""
 468         self.server("TX=10M", "RX=0", "qclose=W", "sclose=W")
 469         self.client("TX=0", "RX=10M", "qclose=Y", "sclose=N")
 470         self.validate_ext_test_results()
 471
 472
 473 class QUICEchoExtServerStreamQcloseTxTestCase(QUICEchoExtTestCase):
 474     """QUIC Echo External Transfer Server Stream Qclose Tx Test Case"""
 475
 476     quic_setup = "serverstream"
 477
 478     @unittest.skipUnless(config.extended, "part of extended tests")
 479     @unittest.skip("testcase under development")
 480     def test_quic_ext_server_stream_qclose_tx(self):
 481         """QUIC external server transfer, tx close"""
 482         self.server("TX=10M", "RX=0", "qclose=Y", "sclose=N")
 483         self.client("TX=0", "RX=10M", "qclose=W", "sclose=W", "rx-results-diff")
 484         self.validate_ext_test_results()
 485
 486
 487 class QUICEchoExtServerStreamEarlyQcloseRxTestCase(QUICEchoExtTestCase):
 488     """QUIC Echo External Transfer Server Stream Early Qclose Rx Test Case"""
 489
 490     quic_setup = "serverstream"
 491
 492     @unittest.skipUnless(config.extended, "part of extended tests")
 493     @unittest.skip("testcase under development")
 494     def test_quic_ext_server_stream_early_qclose_rx(self):
 495         """QUIC external server transfer, early rx close"""
 496         self.server("TX=20M", "RX=0", "qclose=W", "sclose=W", "tx-results-diff")
 497         self.client("TX=0", "RX=10M", "qclose=Y", "sclose=N")
 498         self.validate_ext_test_results()
 499
 500
 501 class QUICEchoExtServerStreamEarlyQcloseTxTestCase(QUICEchoExtTestCase):
 502     """QUIC Echo External Transfer Server Stream Early Qclose Tx Test Case"""
 503
 504     quic_setup = "serverstream"
 505
 506     @unittest.skipUnless(config.extended, "part of extended tests")
 507     @unittest.skip("testcase under development")
 508     def test_quic_ext_server_stream_early_qclose_tx(self):
 509         """QUIC external server transfer, early tx close"""
 510         self.server("TX=10M", "RX=0", "qclose=Y", "sclose=N")
 511         self.client("TX=0", "RX=20M", "qclose=W", "sclose=W", "rx-results-diff")
 512         self.validate_ext_test_results()
 513
 514
 515 class QUICEchoExtServerStreamScloseRxTestCase(QUICEchoExtTestCase):
 516     """QUIC Echo External Transfer Server Stream Sclose Rx Test Case"""
 517
 518     quic_setup = "serverstream"
 519
 520     @unittest.skipUnless(config.extended, "part of extended tests")
 521     @unittest.skip("testcase under development")
 522     def test_quic_ext_server_stream_sclose_rx(self):
 523         """QUIC external server transfer, rx stream close"""
 524         self.server("TX=10M", "RX=0", "qclose=W", "sclose=W")
 525         self.client("TX=0", "RX=10M", "qclose=N", "sclose=Y")
 526         self.validate_ext_test_results()
 527
 528
 529 class QUICEchoExtServerStreamScloseTxTestCase(QUICEchoExtTestCase):
 530     """QUIC Echo External Transfer Server Stream Sclose Tx Test Case"""
 531
 532     quic_setup = "serverstream"
 533
 534     @unittest.skipUnless(config.extended, "part of extended tests")
 535     @unittest.skip("testcase under development")
 536     def test_quic_ext_server_stream_sclose_tx(self):
 537         """QUIC external server transfer, tx stream close"""
 538         self.server("TX=10M", "RX=0", "qclose=Y", "sclose=Y")
 539         self.client("TX=0", "RX=10M", "qclose=W", "sclose=W")
 540         self.validate_ext_test_results()
 541
 542
 543 class QUICEchoExtServerStreamEarlyScloseRxTestCase(QUICEchoExtTestCase):
 544     """QUIC Echo External Transfer Server Stream Early Sclose Rx Test Case"""
 545
 546     quic_setup = "serverstream"
 547
 548     @unittest.skipUnless(config.extended, "part of extended tests")
 549     @unittest.skip("testcase under development")
 550     def test_quic_ext_server_stream_early_sclose_rx(self):
 551         """QUIC external server transfer, early rx stream close"""
 552         self.server("TX=20M", "RX=0", "qclose=W", "sclose=W", "tx-results-diff")
 553         self.client("TX=0", "RX=10M", "qclose=N", "sclose=Y")
 554         self.validate_ext_test_results()
 555
 556
 557 class QUICEchoExtServerStreamEarlyScloseTxTestCase(QUICEchoExtTestCase):
 558     """QUIC Echo Ext Transfer Server Stream Early Sclose Tx Test Case"""
 559
 560     quic_setup = "serverstream"
 561
 562     @unittest.skipUnless(config.extended, "part of extended tests")
 563     @unittest.skip("testcase under development")
 564     def test_quic_ext_server_stream_early_sclose_tx(self):
 565         """QUIC external server transfer, early tx stream close"""
 566         self.server("TX=10M", "RX=0", "qclose=Y", "sclose=Y")
 567         self.client("TX=0", "RX=20M", "qclose=W", "sclose=W", "rx-results-diff")
 568         self.validate_ext_test_results()
 569
 570
 571 class QUICEchoExtServerStreamWorkersTestCase(QUICEchoExtTestCase):
 572     """QUIC Echo External Transfer Server Stream MultiWorker Test Case"""
 573
 574     quic_setup = "serverstream"
 575
 576     @unittest.skipUnless(config.extended, "part of extended tests")
 577     @unittest.skip("testcase under development")
 578     def test_quic_ext_transfer_server_stream_multi_workers(self):
 579         """QUIC external server transfer, multi-worker"""
 580         self.server("nclients", "4", "quic-streams", "4", "TX=10M", "RX=0")
 581         self.client("nclients", "4", "quic-streams", "4", "TX=0", "RX=10M")
 582         self.validate_ext_test_results()
 583
 584
 585 if __name__ == "__main__":
 586     unittest.main(testRunner=VppTestRunner)