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