test/asf/test_vcl.py

   1 #!/usr/bin/env python3
   2 """ Vpp VCL tests """
   3
   4 import unittest
   5 import os
   6 import subprocess
   7 import signal
   8 import glob
   9 from config import config
  10 from asfframework import VppAsfTestCase, VppTestRunner, Worker
  11 from vpp_ip_route import VppIpTable, VppIpRoute, VppRoutePath
  12
  13 iperf3 = "/usr/bin/iperf3"
  14
  15
  16 def have_app(app):
  17     try:
  18         subprocess.check_output([app, "-v"])
  19     except (subprocess.CalledProcessError, OSError):
  20         return False
  21     return True
  22
  23
  24 _have_iperf3 = have_app(iperf3)
  25
  26
  27 class VCLAppWorker(Worker):
  28     """VCL Test Application Worker"""
  29
  30     libname = "libvcl_ldpreload.so"
  31
  32     class LibraryNotFound(Exception):
  33         pass
  34
  35     def __init__(
  36         self, appname, executable_args, logger, env=None, role=None, *args, **kwargs
  37     ):
  38         self.role = role
  39         vcl_ldpreload_glob = f"{config.vpp_install_dir}/**/{self.libname}"
  40         vcl_ldpreload_so = glob.glob(vcl_ldpreload_glob, recursive=True)
  41
  42         if len(vcl_ldpreload_so) < 1:
  43             raise LibraryNotFound("cannot locate library: {}".format(self.libname))
  44
  45         vcl_ldpreload_so = vcl_ldpreload_so[0]
  46
  47         if env is None:
  48             env = {}
  49         if "iperf" in appname:
  50             app = appname
  51             env.update({"LD_PRELOAD": vcl_ldpreload_so})
  52         elif "sock" in appname:
  53             app = f"{config.vpp_build_dir}/vpp/bin/{appname}"
  54             env.update({"LD_PRELOAD": vcl_ldpreload_so})
  55         else:
  56             app = f"{config.vpp_build_dir}/vpp/bin/{appname}"
  57         self.args = [app] + executable_args
  58         super(VCLAppWorker, self).__init__(self.args, logger, env, *args, **kwargs)
  59
  60
  61 class VCLTestCase(VppAsfTestCase):
  62     """VCL Test Class"""
  63
  64     session_startup = ["poll-main"]
  65
  66     @classmethod
  67     def setUpClass(cls):
  68         if cls.session_startup:
  69             conf = "session {" + " ".join(cls.session_startup) + "}"
  70             cls.extra_vpp_config = [conf]
  71         super(VCLTestCase, cls).setUpClass()
  72
  73     @classmethod
  74     def tearDownClass(cls):
  75         super(VCLTestCase, cls).tearDownClass()
  76
  77     def setUp(self):
  78         self.vppDebug = "vpp_debug" in config.vpp_install_dir
  79         self.server_addr = "127.0.0.1"
  80         self.server_port = "22000"
  81         self.server_args = [self.server_port]
  82         self.server_ipv6_addr = "::1"
  83         self.server_ipv6_args = ["-6", self.server_port]
  84         self.timeout = 20
  85         self.echo_phrase = "Hello, world! Jenny is a friend of mine."
  86         self.pre_test_sleep = 0.3
  87         self.post_test_sleep = 1
  88         self.sapi_client_sock = ""
  89         self.sapi_server_sock = ""
  90
  91         if os.path.isfile("/tmp/ldp_server_af_unix_socket"):
  92             os.remove("/tmp/ldp_server_af_unix_socket")
  93
  94         super(VCLTestCase, self).setUp()
  95
  96     def update_vcl_app_env(self, ns_id, ns_secret, attach_sock):
  97         if not ns_id:
  98             if "VCL_APP_NAMESPACE_ID" in self.vcl_app_env:
  99                 del self.vcl_app_env["VCL_APP_NAMESPACE_ID"]
 100         else:
 101             self.vcl_app_env["VCL_APP_NAMESPACE_ID"] = ns_id
 102
 103         if not ns_secret:
 104             if "VCL_APP_NAMESPACE_SECRET" in self.vcl_app_env:
 105                 del self.vcl_app_env["VCL_APP_NAMESPACE_SECRET"]
 106         else:
 107             self.vcl_app_env["VCL_APP_NAMESPACE_SECRET"] = ns_secret
 108
 109         if not attach_sock:
 110             self.vcl_app_env["VCL_VPP_API_SOCKET"] = self.get_api_sock_path()
 111             if "VCL_VPP_SAPI_SOCKET" in self.vcl_app_env:
 112                 del self.vcl_app_env["VCL_VPP_SAPI_SOCKET"]
 113         else:
 114             sapi_sock = "%s/app_ns_sockets/%s" % (self.tempdir, attach_sock)
 115             self.vcl_app_env["VCL_VPP_SAPI_SOCKET"] = sapi_sock
 116             if "VCL_VPP_API_SOCKET" in self.vcl_app_env:
 117                 del self.vcl_app_env["VCL_VPP_API_SOCKET"]
 118
 119     def cut_thru_setup(self):
 120         self.vapi.session_enable_disable(is_enable=1)
 121
 122     def cut_thru_tear_down(self):
 123         self.vapi.session_enable_disable(is_enable=0)
 124
 125     def cut_thru_test(self, server_app, server_args, client_app, client_args):
 126         self.vcl_app_env = {"VCL_APP_SCOPE_LOCAL": "true"}
 127
 128         self.update_vcl_app_env("", "", self.sapi_server_sock)
 129         worker_server = VCLAppWorker(
 130             server_app, server_args, self.logger, self.vcl_app_env, "server"
 131         )
 132         worker_server.start()
 133         self.sleep(self.pre_test_sleep)
 134
 135         self.update_vcl_app_env("", "", self.sapi_client_sock)
 136         worker_client = VCLAppWorker(
 137             client_app, client_args, self.logger, self.vcl_app_env, "client"
 138         )
 139         worker_client.start()
 140         worker_client.join(self.timeout)
 141         try:
 142             self.validateResults(worker_client, worker_server, self.timeout)
 143         except Exception as error:
 144             self.fail("Failed with %s" % error)
 145         self.sleep(self.post_test_sleep)
 146
 147     def thru_host_stack_setup(self):
 148         self.vapi.session_enable_disable(is_enable=1)
 149         self.create_loopback_interfaces(2)
 150
 151         table_id = 1
 152
 153         for i in self.lo_interfaces:
 154             i.admin_up()
 155
 156             if table_id != 0:
 157                 tbl = VppIpTable(self, table_id)
 158                 tbl.add_vpp_config()
 159
 160             i.set_table_ip4(table_id)
 161             i.config_ip4()
 162             table_id += 1
 163
 164         # Configure namespaces
 165         self.vapi.app_namespace_add_del_v4(
 166             namespace_id="1", secret=1234, sw_if_index=self.loop0.sw_if_index
 167         )
 168         self.vapi.app_namespace_add_del_v4(
 169             namespace_id="2", secret=5678, sw_if_index=self.loop1.sw_if_index
 170         )
 171
 172         # Add inter-table routes
 173         ip_t01 = VppIpRoute(
 174             self,
 175             self.loop1.local_ip4,
 176             32,
 177             [VppRoutePath("0.0.0.0", 0xFFFFFFFF, nh_table_id=2)],
 178             table_id=1,
 179         )
 180         ip_t10 = VppIpRoute(
 181             self,
 182             self.loop0.local_ip4,
 183             32,
 184             [VppRoutePath("0.0.0.0", 0xFFFFFFFF, nh_table_id=1)],
 185             table_id=2,
 186         )
 187         ip_t01.add_vpp_config()
 188         ip_t10.add_vpp_config()
 189         self.logger.debug(self.vapi.cli("show ip fib"))
 190
 191     def thru_host_stack_tear_down(self):
 192         for i in self.lo_interfaces:
 193             i.unconfig_ip4()
 194             i.set_table_ip4(0)
 195             i.admin_down()
 196             i.remove_vpp_config()
 197
 198     def thru_host_stack_ipv6_setup(self):
 199         self.vapi.session_enable_disable(is_enable=1)
 200         self.create_loopback_interfaces(2)
 201
 202         table_id = 1
 203
 204         for i in self.lo_interfaces:
 205             i.admin_up()
 206
 207             tbl = VppIpTable(self, table_id, is_ip6=1)
 208             tbl.add_vpp_config()
 209
 210             i.set_table_ip6(table_id)
 211             i.config_ip6()
 212             table_id += 1
 213
 214         # Configure namespaces
 215         self.vapi.app_namespace_add_del_v4(
 216             namespace_id="1", secret=1234, sw_if_index=self.loop0.sw_if_index
 217         )
 218         self.vapi.app_namespace_add_del_v4(
 219             namespace_id="2", secret=5678, sw_if_index=self.loop1.sw_if_index
 220         )
 221
 222         # Add inter-table routes
 223         ip_t01 = VppIpRoute(
 224             self,
 225             self.loop1.local_ip6,
 226             128,
 227             [VppRoutePath("::0", 0xFFFFFFFF, nh_table_id=2)],
 228             table_id=1,
 229         )
 230         ip_t10 = VppIpRoute(
 231             self,
 232             self.loop0.local_ip6,
 233             128,
 234             [VppRoutePath("::0", 0xFFFFFFFF, nh_table_id=1)],
 235             table_id=2,
 236         )
 237         ip_t01.add_vpp_config()
 238         ip_t10.add_vpp_config()
 239         self.logger.debug(self.vapi.cli("show interface addr"))
 240         self.logger.debug(self.vapi.cli("show ip6 fib"))
 241
 242     def thru_host_stack_ipv6_tear_down(self):
 243         for i in self.lo_interfaces:
 244             i.unconfig_ip6()
 245             i.set_table_ip6(0)
 246             i.admin_down()
 247
 248         self.vapi.session_enable_disable(is_enable=0)
 249
 250     @unittest.skipUnless(_have_iperf3, "'%s' not found, Skipping.")
 251     def thru_host_stack_test(self, server_app, server_args, client_app, client_args):
 252         self.vcl_app_env = {"VCL_APP_SCOPE_GLOBAL": "true"}
 253
 254         self.update_vcl_app_env("1", "1234", self.sapi_server_sock)
 255         worker_server = VCLAppWorker(
 256             server_app, server_args, self.logger, self.vcl_app_env, "server"
 257         )
 258         worker_server.start()
 259         self.sleep(self.pre_test_sleep)
 260
 261         self.update_vcl_app_env("2", "5678", self.sapi_client_sock)
 262         worker_client = VCLAppWorker(
 263             client_app, client_args, self.logger, self.vcl_app_env, "client"
 264         )
 265         worker_client.start()
 266         worker_client.join(self.timeout)
 267
 268         try:
 269             self.validateResults(worker_client, worker_server, self.timeout)
 270         except Exception as error:
 271             self.fail("Failed with %s" % error)
 272         self.sleep(self.post_test_sleep)
 273
 274     def validateResults(self, worker_client, worker_server, timeout):
 275         if worker_server.process is None:
 276             raise RuntimeError("worker_server is not running.")
 277         if os.path.isdir("/proc/{}".format(worker_server.process.pid)):
 278             self.logger.info(
 279                 "Killing server worker process (pid %d)" % worker_server.process.pid
 280             )
 281             os.killpg(os.getpgid(worker_server.process.pid), signal.SIGTERM)
 282             worker_server.join()
 283         self.logger.info("Client worker result is `%s'" % worker_client.result)
 284         error = False
 285         if worker_client.result is None:
 286             try:
 287                 error = True
 288                 self.logger.error(
 289                     "Timeout: %ss! Killing client worker process (pid %d)"
 290                     % (timeout, worker_client.process.pid)
 291                 )
 292                 os.killpg(os.getpgid(worker_client.process.pid), signal.SIGKILL)
 293                 worker_client.join()
 294             except OSError:
 295                 self.logger.debug("Couldn't kill client worker process")
 296                 raise
 297         if error:
 298             raise RuntimeError("Timeout! Client worker did not finish in %ss" % timeout)
 299         self.assert_equal(worker_client.result, 0, "Binary test return code")
 300
 301
 302 class LDPCutThruTestCase(VCLTestCase):
 303     """LDP Cut Thru Tests"""
 304
 305     @classmethod
 306     def setUpClass(cls):
 307         cls.session_startup = ["poll-main", "use-app-socket-api"]
 308         super(LDPCutThruTestCase, cls).setUpClass()
 309
 310     @classmethod
 311     def tearDownClass(cls):
 312         super(LDPCutThruTestCase, cls).tearDownClass()
 313
 314     def setUp(self):
 315         super(LDPCutThruTestCase, self).setUp()
 316
 317         self.cut_thru_setup()
 318         self.client_echo_test_args = [
 319             "-E",
 320             self.echo_phrase,
 321             "-X",
 322             self.server_addr,
 323             self.server_port,
 324         ]
 325         self.client_iperf3_timeout = 20
 326         self.client_iperf3_args = ["-4", "-t 2", "-c", self.server_addr]
 327         self.server_iperf3_args = ["-4", "-s"]
 328         self.client_uni_dir_nsock_timeout = 20
 329         self.client_uni_dir_nsock_test_args = [
 330             "-N",
 331             "1000",
 332             "-U",
 333             "-X",
 334             "-I",
 335             "2",
 336             self.server_addr,
 337             self.server_port,
 338         ]
 339         self.client_bi_dir_nsock_timeout = 20
 340         self.client_bi_dir_nsock_test_args = [
 341             "-N",
 342             "1000",
 343             "-B",
 344             "-X",
 345             "-I",
 346             "2",
 347             self.server_addr,
 348             self.server_port,
 349         ]
 350         self.sapi_client_sock = "default"
 351         self.sapi_server_sock = "default"
 352
 353     def tearDown(self):
 354         super(LDPCutThruTestCase, self).tearDown()
 355         self.cut_thru_tear_down()
 356
 357     def show_commands_at_teardown(self):
 358         self.logger.debug(self.vapi.cli("show session verbose 2"))
 359         self.logger.debug(self.vapi.cli("show app mq"))
 360
 361     @unittest.skipUnless(config.extended, "part of extended tests")
 362     def test_ldp_cut_thru_echo(self):
 363         """run LDP cut thru echo test"""
 364
 365         self.cut_thru_test(
 366             "sock_test_server",
 367             self.server_args,
 368             "sock_test_client",
 369             self.client_echo_test_args,
 370         )
 371
 372     def test_ldp_cut_thru_iperf3(self):
 373         """run LDP cut thru iperf3 test"""
 374
 375         self.timeout = self.client_iperf3_timeout
 376         self.cut_thru_test(
 377             iperf3, self.server_iperf3_args, iperf3, self.client_iperf3_args
 378         )
 379
 380     @unittest.skipUnless(config.extended, "part of extended tests")
 381     def test_ldp_cut_thru_uni_dir_nsock(self):
 382         """run LDP cut thru uni-directional (multiple sockets) test"""
 383
 384         self.timeout = self.client_uni_dir_nsock_timeout
 385         self.cut_thru_test(
 386             "sock_test_server",
 387             self.server_args,
 388             "sock_test_client",
 389             self.client_uni_dir_nsock_test_args,
 390         )
 391
 392     @unittest.skipUnless(config.extended, "part of extended tests")
 393     @unittest.skip("sock test apps need to be improved")
 394     def test_ldp_cut_thru_bi_dir_nsock(self):
 395         """run LDP cut thru bi-directional (multiple sockets) test"""
 396
 397         self.timeout = self.client_bi_dir_nsock_timeout
 398         self.cut_thru_test(
 399             "sock_test_server",
 400             self.server_args,
 401             "sock_test_client",
 402             self.client_bi_dir_nsock_test_args,
 403         )
 404
 405
 406 class VCLCutThruTestCase(VCLTestCase):
 407     """VCL Cut Thru Tests"""
 408
 409     @classmethod
 410     def setUpClass(cls):
 411         super(VCLCutThruTestCase, cls).setUpClass()
 412
 413     @classmethod
 414     def tearDownClass(cls):
 415         super(VCLCutThruTestCase, cls).tearDownClass()
 416
 417     def setUp(self):
 418         super(VCLCutThruTestCase, self).setUp()
 419
 420         self.cut_thru_setup()
 421         self.client_echo_test_args = [
 422             "-E",
 423             self.echo_phrase,
 424             "-X",
 425             self.server_addr,
 426             self.server_port,
 427         ]
 428
 429         self.client_uni_dir_nsock_timeout = 20
 430         self.client_uni_dir_nsock_test_args = [
 431             "-N",
 432             "1000",
 433             "-U",
 434             "-X",
 435             "-I",
 436             "2",
 437             self.server_addr,
 438             self.server_port,
 439         ]
 440         self.client_bi_dir_nsock_timeout = 20
 441         self.client_bi_dir_nsock_test_args = [
 442             "-N",
 443             "1000",
 444             "-B",
 445             "-X",
 446             "-I",
 447             "2",
 448             self.server_addr,
 449             self.server_port,
 450         ]
 451
 452     def tearDown(self):
 453         super(VCLCutThruTestCase, self).tearDown()
 454
 455     def show_commands_at_teardown(self):
 456         self.logger.debug(self.vapi.cli("show session verbose 2"))
 457         self.logger.debug(self.vapi.cli("show app mq"))
 458
 459     def test_vcl_cut_thru_echo(self):
 460         """run VCL cut thru echo test"""
 461
 462         self.cut_thru_test(
 463             "vcl_test_server",
 464             self.server_args,
 465             "vcl_test_client",
 466             self.client_echo_test_args,
 467         )
 468
 469     def test_vcl_cut_thru_uni_dir_nsock(self):
 470         """run VCL cut thru uni-directional (multiple sockets) test"""
 471
 472         self.timeout = self.client_uni_dir_nsock_timeout
 473         self.cut_thru_test(
 474             "vcl_test_server",
 475             self.server_args,
 476             "vcl_test_client",
 477             self.client_uni_dir_nsock_test_args,
 478         )
 479
 480     def test_vcl_cut_thru_bi_dir_nsock(self):
 481         """run VCL cut thru bi-directional (multiple sockets) test"""
 482
 483         self.timeout = self.client_bi_dir_nsock_timeout
 484         self.cut_thru_test(
 485             "vcl_test_server",
 486             self.server_args,
 487             "vcl_test_client",
 488             self.client_bi_dir_nsock_test_args,
 489         )
 490
 491
 492 class VCLThruHostStackEcho(VCLTestCase):
 493     """VCL Thru Host Stack Echo"""
 494
 495     @classmethod
 496     def setUpClass(cls):
 497         super(VCLThruHostStackEcho, cls).setUpClass()
 498
 499     @classmethod
 500     def tearDownClass(cls):
 501         super(VCLThruHostStackEcho, cls).tearDownClass()
 502
 503     def setUp(self):
 504         super(VCLThruHostStackEcho, self).setUp()
 505
 506         self.thru_host_stack_setup()
 507         self.client_bi_dir_nsock_timeout = 20
 508         self.client_bi_dir_nsock_test_args = [
 509             "-N",
 510             "1000",
 511             "-B",
 512             "-X",
 513             "-I",
 514             "2",
 515             self.loop0.local_ip4,
 516             self.server_port,
 517         ]
 518         self.client_echo_test_args = [
 519             "-E",
 520             self.echo_phrase,
 521             "-X",
 522             self.loop0.local_ip4,
 523             self.server_port,
 524         ]
 525
 526     def tearDown(self):
 527         self.thru_host_stack_tear_down()
 528         super(VCLThruHostStackEcho, self).tearDown()
 529
 530     def test_vcl_thru_host_stack_echo(self):
 531         """run VCL IPv4 thru host stack echo test"""
 532
 533         self.thru_host_stack_test(
 534             "vcl_test_server",
 535             self.server_args,
 536             "vcl_test_client",
 537             self.client_echo_test_args,
 538         )
 539
 540     def show_commands_at_teardown(self):
 541         self.logger.debug(self.vapi.cli("show app server"))
 542         self.logger.debug(self.vapi.cli("show session verbose"))
 543         self.logger.debug(self.vapi.cli("show app mq"))
 544
 545
 546 class VCLThruHostStackTLS(VCLTestCase):
 547     """VCL Thru Host Stack TLS"""
 548
 549     @classmethod
 550     def setUpClass(cls):
 551         cls.session_startup = ["poll-main", "use-app-socket-api"]
 552         super(VCLThruHostStackTLS, cls).setUpClass()
 553
 554     @classmethod
 555     def tearDownClass(cls):
 556         super(VCLThruHostStackTLS, cls).tearDownClass()
 557
 558     def setUp(self):
 559         super(VCLThruHostStackTLS, self).setUp()
 560
 561         self.thru_host_stack_setup()
 562         self.client_uni_dir_tls_timeout = 20
 563         self.server_tls_args = ["-L", self.server_port]
 564         self.client_uni_dir_tls_test_args = [
 565             "-N",
 566             "1000",
 567             "-U",
 568             "-X",
 569             "-L",
 570             self.loop0.local_ip4,
 571             self.server_port,
 572         ]
 573         self.sapi_server_sock = "1"
 574         self.sapi_client_sock = "2"
 575
 576     def test_vcl_thru_host_stack_tls_uni_dir(self):
 577         """run VCL thru host stack uni-directional TLS test"""
 578
 579         self.timeout = self.client_uni_dir_tls_timeout
 580         self.thru_host_stack_test(
 581             "vcl_test_server",
 582             self.server_tls_args,
 583             "vcl_test_client",
 584             self.client_uni_dir_tls_test_args,
 585         )
 586
 587     def tearDown(self):
 588         self.thru_host_stack_tear_down()
 589         super(VCLThruHostStackTLS, self).tearDown()
 590
 591     def show_commands_at_teardown(self):
 592         self.logger.debug(self.vapi.cli("show app server"))
 593         self.logger.debug(self.vapi.cli("show session verbose 2"))
 594         self.logger.debug(self.vapi.cli("show app mq"))
 595
 596
 597 class VCLThruHostStackEchoInterruptMode(VCLThruHostStackEcho):
 598     """VCL Thru Host Stack Echo interrupt mode"""
 599
 600     @classmethod
 601     def setUpClass(cls):
 602         cls.session_startup = ["use-private-rx-mqs", "use-app-socket-api"]
 603         super(VCLThruHostStackEcho, cls).setUpClass()
 604
 605     def test_vcl_thru_host_stack_echo(self):
 606         """run VCL IPv4 thru host stack echo test interrupt mode"""
 607
 608         self.sapi_server_sock = "1"
 609         self.sapi_client_sock = "2"
 610
 611         self.thru_host_stack_test(
 612             "vcl_test_server",
 613             self.server_args,
 614             "vcl_test_client",
 615             self.client_echo_test_args,
 616         )
 617
 618
 619 class VCLThruHostStackTLSInterruptMode(VCLThruHostStackTLS):
 620     """VCL Thru Host Stack TLS interrupt mode"""
 621
 622     @classmethod
 623     def setUpClass(cls):
 624         cls.session_startup = ["poll-main", "use-app-socket-api", "use-private-rx-mqs"]
 625         super(VCLThruHostStackTLS, cls).setUpClass()
 626
 627
 628 class VCLThruHostStackDTLS(VCLTestCase):
 629     """VCL Thru Host Stack DTLS"""
 630
 631     @classmethod
 632     def setUpClass(cls):
 633         super(VCLThruHostStackDTLS, cls).setUpClass()
 634
 635     @classmethod
 636     def tearDownClass(cls):
 637         super(VCLThruHostStackDTLS, cls).tearDownClass()
 638
 639     def setUp(self):
 640         super(VCLThruHostStackDTLS, self).setUp()
 641
 642         self.thru_host_stack_setup()
 643         self.client_uni_dir_dtls_timeout = 20
 644         self.server_dtls_args = ["-p", "dtls", self.server_port]
 645         self.client_uni_dir_dtls_test_args = [
 646             "-N",
 647             "1000",
 648             "-U",
 649             "-X",
 650             "-p",
 651             "dtls",
 652             "-T 1400",
 653             self.loop0.local_ip4,
 654             self.server_port,
 655         ]
 656
 657     def test_vcl_thru_host_stack_dtls_uni_dir(self):
 658         """run VCL thru host stack uni-directional DTLS test"""
 659
 660         self.timeout = self.client_uni_dir_dtls_timeout
 661         self.thru_host_stack_test(
 662             "vcl_test_server",
 663             self.server_dtls_args,
 664             "vcl_test_client",
 665             self.client_uni_dir_dtls_test_args,
 666         )
 667
 668     def tearDown(self):
 669         self.thru_host_stack_tear_down()
 670         super(VCLThruHostStackDTLS, self).tearDown()
 671
 672     def show_commands_at_teardown(self):
 673         self.logger.debug(self.vapi.cli("show app server"))
 674         self.logger.debug(self.vapi.cli("show session verbose 2"))
 675         self.logger.debug(self.vapi.cli("show app mq"))
 676
 677
 678 class VCLThruHostStackQUIC(VCLTestCase):
 679     """VCL Thru Host Stack QUIC"""
 680
 681     @classmethod
 682     def setUpClass(cls):
 683         cls.extra_vpp_plugin_config.append("plugin quic_plugin.so { enable }")
 684         super(VCLThruHostStackQUIC, cls).setUpClass()
 685
 686     @classmethod
 687     def tearDownClass(cls):
 688         super(VCLThruHostStackQUIC, cls).tearDownClass()
 689
 690     def setUp(self):
 691         super(VCLThruHostStackQUIC, self).setUp()
 692
 693         self.thru_host_stack_setup()
 694         self.client_uni_dir_quic_timeout = 20
 695         self.server_quic_args = ["-p", "quic", self.server_port]
 696         self.client_uni_dir_quic_test_args = [
 697             "-N",
 698             "1000",
 699             "-U",
 700             "-X",
 701             "-p",
 702             "quic",
 703             self.loop0.local_ip4,
 704             self.server_port,
 705         ]
 706
 707     @unittest.skipUnless(config.extended, "part of extended tests")
 708     def test_vcl_thru_host_stack_quic_uni_dir(self):
 709         """run VCL thru host stack uni-directional QUIC test"""
 710
 711         self.timeout = self.client_uni_dir_quic_timeout
 712         self.thru_host_stack_test(
 713             "vcl_test_server",
 714             self.server_quic_args,
 715             "vcl_test_client",
 716             self.client_uni_dir_quic_test_args,
 717         )
 718
 719     def tearDown(self):
 720         self.thru_host_stack_tear_down()
 721         super(VCLThruHostStackQUIC, self).tearDown()
 722
 723     def show_commands_at_teardown(self):
 724         self.logger.debug(self.vapi.cli("show app server"))
 725         self.logger.debug(self.vapi.cli("show session verbose 2"))
 726         self.logger.debug(self.vapi.cli("show app mq"))
 727
 728
 729 class VCLThruHostStackBidirNsock(VCLTestCase):
 730     """VCL Thru Host Stack Bidir Nsock"""
 731
 732     @classmethod
 733     def setUpClass(cls):
 734         super(VCLThruHostStackBidirNsock, cls).setUpClass()
 735
 736     @classmethod
 737     def tearDownClass(cls):
 738         super(VCLThruHostStackBidirNsock, cls).tearDownClass()
 739
 740     def setUp(self):
 741         super(VCLThruHostStackBidirNsock, self).setUp()
 742
 743         self.thru_host_stack_setup()
 744         self.client_bi_dir_nsock_timeout = 20
 745         self.client_bi_dir_nsock_test_args = [
 746             "-N",
 747             "1000",
 748             "-B",
 749             "-X",
 750             "-I",
 751             "2",
 752             self.loop0.local_ip4,
 753             self.server_port,
 754         ]
 755         self.client_echo_test_args = [
 756             "-E",
 757             self.echo_phrase,
 758             "-X",
 759             self.loop0.local_ip4,
 760             self.server_port,
 761         ]
 762
 763     def tearDown(self):
 764         self.thru_host_stack_tear_down()
 765         super(VCLThruHostStackBidirNsock, self).tearDown()
 766
 767     def show_commands_at_teardown(self):
 768         self.logger.debug(self.vapi.cli("show session verbose 2"))
 769         self.logger.debug(self.vapi.cli("show app mq"))
 770
 771     def test_vcl_thru_host_stack_bi_dir_nsock(self):
 772         """run VCL thru host stack bi-directional (multiple sockets) test"""
 773
 774         self.timeout = self.client_bi_dir_nsock_timeout
 775         self.thru_host_stack_test(
 776             "vcl_test_server",
 777             self.server_args,
 778             "vcl_test_client",
 779             self.client_bi_dir_nsock_test_args,
 780         )
 781
 782
 783 class LDPThruHostStackBidirNsock(VCLTestCase):
 784     """LDP Thru Host Stack Bidir Nsock"""
 785
 786     @classmethod
 787     def setUpClass(cls):
 788         super(LDPThruHostStackBidirNsock, cls).setUpClass()
 789
 790     @classmethod
 791     def tearDownClass(cls):
 792         super(LDPThruHostStackBidirNsock, cls).tearDownClass()
 793
 794     def setUp(self):
 795         super(LDPThruHostStackBidirNsock, self).setUp()
 796
 797         self.thru_host_stack_setup()
 798         self.client_bi_dir_nsock_timeout = 20
 799         self.client_bi_dir_nsock_test_args = [
 800             "-N",
 801             "1000",
 802             "-B",
 803             "-X",
 804             # OUCH! Host Stack Bug?
 805             # Only fails when running
 806             # 'make test TEST_JOBS=auto'
 807             # or TEST_JOBS > 1
 808             # "-I", "2",
 809             self.loop0.local_ip4,
 810             self.server_port,
 811         ]
 812
 813     def tearDown(self):
 814         self.thru_host_stack_tear_down()
 815         super(LDPThruHostStackBidirNsock, self).tearDown()
 816
 817     def show_commands_at_teardown(self):
 818         self.logger.debug(self.vapi.cli("show session verbose 2"))
 819         self.logger.debug(self.vapi.cli("show app mq"))
 820
 821     def test_ldp_thru_host_stack_bi_dir_nsock(self):
 822         """run LDP thru host stack bi-directional (multiple sockets) test"""
 823
 824         self.timeout = self.client_bi_dir_nsock_timeout
 825         self.thru_host_stack_test(
 826             "sock_test_server",
 827             self.server_args,
 828             "sock_test_client",
 829             self.client_bi_dir_nsock_test_args,
 830         )
 831
 832
 833 class LDPThruHostStackNsock(VCLTestCase):
 834     """LDP Thru Host Stack Nsock"""
 835
 836     @classmethod
 837     def setUpClass(cls):
 838         super(LDPThruHostStackNsock, cls).setUpClass()
 839
 840     @classmethod
 841     def tearDownClass(cls):
 842         super(LDPThruHostStackNsock, cls).tearDownClass()
 843
 844     def setUp(self):
 845         super(LDPThruHostStackNsock, self).setUp()
 846
 847         self.thru_host_stack_setup()
 848         if self.vppDebug:
 849             self.client_uni_dir_nsock_timeout = 20
 850             self.numSockets = "2"
 851         else:
 852             self.client_uni_dir_nsock_timeout = 20
 853             self.numSockets = "5"
 854
 855         self.client_uni_dir_nsock_test_args = [
 856             "-N",
 857             "1000",
 858             "-U",
 859             "-X",
 860             "-I",
 861             self.numSockets,
 862             self.loop0.local_ip4,
 863             self.server_port,
 864         ]
 865
 866     def tearDown(self):
 867         self.thru_host_stack_tear_down()
 868         super(LDPThruHostStackNsock, self).tearDown()
 869
 870     def test_ldp_thru_host_stack_uni_dir_nsock(self):
 871         """run LDP thru host stack uni-directional (multiple sockets) test"""
 872
 873         self.timeout = self.client_uni_dir_nsock_timeout
 874         self.thru_host_stack_test(
 875             "sock_test_server",
 876             self.server_args,
 877             "sock_test_client",
 878             self.client_uni_dir_nsock_test_args,
 879         )
 880
 881
 882 class VCLThruHostStackNsock(VCLTestCase):
 883     """VCL Thru Host Stack Nsock"""
 884
 885     @classmethod
 886     def setUpClass(cls):
 887         super(VCLThruHostStackNsock, cls).setUpClass()
 888
 889     @classmethod
 890     def tearDownClass(cls):
 891         super(VCLThruHostStackNsock, cls).tearDownClass()
 892
 893     def setUp(self):
 894         super(VCLThruHostStackNsock, self).setUp()
 895
 896         self.thru_host_stack_setup()
 897         if self.vppDebug:
 898             self.client_uni_dir_nsock_timeout = 20
 899             self.numSockets = "2"
 900         else:
 901             self.client_uni_dir_nsock_timeout = 20
 902             self.numSockets = "5"
 903
 904         self.client_uni_dir_nsock_test_args = [
 905             "-N",
 906             "1000",
 907             "-U",
 908             "-X",
 909             "-I",
 910             self.numSockets,
 911             self.loop0.local_ip4,
 912             self.server_port,
 913         ]
 914
 915     def tearDown(self):
 916         self.thru_host_stack_tear_down()
 917         super(VCLThruHostStackNsock, self).tearDown()
 918
 919     def test_vcl_thru_host_stack_uni_dir_nsock(self):
 920         """run VCL thru host stack uni-directional (multiple sockets) test"""
 921
 922         self.timeout = self.client_uni_dir_nsock_timeout
 923         self.thru_host_stack_test(
 924             "vcl_test_server",
 925             self.server_args,
 926             "vcl_test_client",
 927             self.client_uni_dir_nsock_test_args,
 928         )
 929
 930
 931 class LDPThruHostStackIperf(VCLTestCase):
 932     """LDP Thru Host Stack Iperf"""
 933
 934     @classmethod
 935     def setUpClass(cls):
 936         super(LDPThruHostStackIperf, cls).setUpClass()
 937
 938     @classmethod
 939     def tearDownClass(cls):
 940         super(LDPThruHostStackIperf, cls).tearDownClass()
 941
 942     def setUp(self):
 943         super(LDPThruHostStackIperf, self).setUp()
 944
 945         self.thru_host_stack_setup()
 946         self.client_iperf3_timeout = 20
 947         self.client_iperf3_args = ["-4", "-t 2", "-c", self.loop0.local_ip4]
 948         self.server_iperf3_args = ["-4", "-s"]
 949
 950     def tearDown(self):
 951         self.thru_host_stack_tear_down()
 952         super(LDPThruHostStackIperf, self).tearDown()
 953
 954     def show_commands_at_teardown(self):
 955         self.logger.debug(self.vapi.cli("show session verbose 2"))
 956         self.logger.debug(self.vapi.cli("show app mq"))
 957
 958     @unittest.skipUnless(_have_iperf3, "'%s' not found, Skipping.")
 959     def test_ldp_thru_host_stack_iperf3(self):
 960         """run LDP thru host stack iperf3 test"""
 961
 962         self.timeout = self.client_iperf3_timeout
 963         self.thru_host_stack_test(
 964             iperf3, self.server_iperf3_args, iperf3, self.client_iperf3_args
 965         )
 966
 967     @unittest.skipUnless(_have_iperf3, "'%s' not found, Skipping.")
 968     def test_ldp_thru_host_stack_iperf3_mss(self):
 969         """run LDP thru host stack iperf3 test with mss option"""
 970
 971         self.timeout = self.client_iperf3_timeout
 972         self.client_iperf3_args.append("-M 1000")
 973         self.thru_host_stack_test(
 974             iperf3, self.server_iperf3_args, iperf3, self.client_iperf3_args
 975         )
 976
 977
 978 class LDPThruHostStackIperfUdp(VCLTestCase):
 979     """LDP Thru Host Stack Iperf UDP"""
 980
 981     @classmethod
 982     def setUpClass(cls):
 983         super(LDPThruHostStackIperfUdp, cls).setUpClass()
 984
 985     @classmethod
 986     def tearDownClass(cls):
 987         super(LDPThruHostStackIperfUdp, cls).tearDownClass()
 988
 989     def setUp(self):
 990         super(LDPThruHostStackIperfUdp, self).setUp()
 991
 992         self.thru_host_stack_setup()
 993         self.client_iperf3_timeout = 20
 994         self.client_iperf3_args = [
 995             "-4",
 996             "-t 2",
 997             "-u",
 998             "-l 1400",
 999             "-P 2",
1000             "-c",
1001             self.loop0.local_ip4,
1002         ]
1003         self.server_iperf3_args = ["-4", "-s"]
1004
1005     def tearDown(self):
1006         self.thru_host_stack_tear_down()
1007         super(LDPThruHostStackIperfUdp, self).tearDown()
1008
1009     def show_commands_at_teardown(self):
1010         self.logger.debug(self.vapi.cli("show session verbose 2"))
1011         self.logger.debug(self.vapi.cli("show app mq"))
1012
1013     @unittest.skipUnless(_have_iperf3, "'%s' not found, Skipping.")
1014     def test_ldp_thru_host_stack_iperf3_udp(self):
1015         """run LDP thru host stack iperf3 UDP test"""
1016
1017         self.timeout = self.client_iperf3_timeout
1018         self.thru_host_stack_test(
1019             iperf3, self.server_iperf3_args, iperf3, self.client_iperf3_args
1020         )
1021
1022
1023 class LDPIpv6CutThruTestCase(VCLTestCase):
1024     """LDP IPv6 Cut Thru Tests"""
1025
1026     @classmethod
1027     def setUpClass(cls):
1028         super(LDPIpv6CutThruTestCase, cls).setUpClass()
1029
1030     @classmethod
1031     def tearDownClass(cls):
1032         super(LDPIpv6CutThruTestCase, cls).tearDownClass()
1033
1034     def show_commands_at_teardown(self):
1035         self.logger.debug(self.vapi.cli("show session verbose 2"))
1036         self.logger.debug(self.vapi.cli("show app mq"))
1037
1038     def setUp(self):
1039         super(LDPIpv6CutThruTestCase, self).setUp()
1040
1041         self.cut_thru_setup()
1042         self.client_iperf3_timeout = 20
1043         self.client_uni_dir_nsock_timeout = 20
1044         self.client_bi_dir_nsock_timeout = 20
1045         self.client_ipv6_echo_test_args = [
1046             "-6",
1047             "-E",
1048             self.echo_phrase,
1049             "-X",
1050             self.server_ipv6_addr,
1051             self.server_port,
1052         ]
1053         self.client_ipv6_iperf3_args = ["-6", "-t 2", "-c", self.server_ipv6_addr]
1054         self.server_ipv6_iperf3_args = ["-6", "-s"]
1055         self.client_ipv6_uni_dir_nsock_test_args = [
1056             "-N",
1057             "1000",
1058             "-U",
1059             "-X",
1060             "-6",
1061             "-I",
1062             "2",
1063             self.server_ipv6_addr,
1064             self.server_port,
1065         ]
1066         self.client_ipv6_bi_dir_nsock_test_args = [
1067             "-N",
1068             "1000",
1069             "-B",
1070             "-X",
1071             "-6",
1072             "-I",
1073             "2",
1074             self.server_ipv6_addr,
1075             self.server_port,
1076         ]
1077
1078     def tearDown(self):
1079         super(LDPIpv6CutThruTestCase, self).tearDown()
1080         self.cut_thru_tear_down()
1081
1082     @unittest.skipUnless(config.extended, "part of extended tests")
1083     def test_ldp_ipv6_cut_thru_echo(self):
1084         """run LDP IPv6 cut thru echo test"""
1085
1086         self.cut_thru_test(
1087             "sock_test_server",
1088             self.server_ipv6_args,
1089             "sock_test_client",
1090             self.client_ipv6_echo_test_args,
1091         )
1092
1093     @unittest.skipUnless(_have_iperf3, "'%s' not found, Skipping.")
1094     def test_ldp_ipv6_cut_thru_iperf3(self):
1095         """run LDP IPv6 cut thru iperf3 test"""
1096
1097         self.timeout = self.client_iperf3_timeout
1098         self.cut_thru_test(
1099             iperf3, self.server_ipv6_iperf3_args, iperf3, self.client_ipv6_iperf3_args
1100         )
1101
1102     @unittest.skipUnless(config.extended, "part of extended tests")
1103     def test_ldp_ipv6_cut_thru_uni_dir_nsock(self):
1104         """run LDP IPv6 cut thru uni-directional (multiple sockets) test"""
1105
1106         self.timeout = self.client_uni_dir_nsock_timeout
1107         self.cut_thru_test(
1108             "sock_test_server",
1109             self.server_ipv6_args,
1110             "sock_test_client",
1111             self.client_ipv6_uni_dir_nsock_test_args,
1112         )
1113
1114     @unittest.skipUnless(config.extended, "part of extended tests")
1115     @unittest.skip("sock test apps need to be improved")
1116     def test_ldp_ipv6_cut_thru_bi_dir_nsock(self):
1117         """run LDP IPv6 cut thru bi-directional (multiple sockets) test"""
1118
1119         self.timeout = self.client_bi_dir_nsock_timeout
1120         self.cut_thru_test(
1121             "sock_test_server",
1122             self.server_ipv6_args,
1123             "sock_test_client",
1124             self.client_ipv6_bi_dir_nsock_test_args,
1125         )
1126
1127
1128 class VCLIpv6CutThruTestCase(VCLTestCase):
1129     """VCL IPv6 Cut Thru Tests"""
1130
1131     @classmethod
1132     def setUpClass(cls):
1133         super(VCLIpv6CutThruTestCase, cls).setUpClass()
1134
1135     @classmethod
1136     def tearDownClass(cls):
1137         super(VCLIpv6CutThruTestCase, cls).tearDownClass()
1138
1139     def show_commands_at_teardown(self):
1140         self.logger.debug(self.vapi.cli("show session verbose 2"))
1141         self.logger.debug(self.vapi.cli("show app mq"))
1142
1143     def setUp(self):
1144         super(VCLIpv6CutThruTestCase, self).setUp()
1145
1146         self.cut_thru_setup()
1147         self.client_uni_dir_nsock_timeout = 20
1148         self.client_bi_dir_nsock_timeout = 20
1149         self.client_ipv6_echo_test_args = [
1150             "-6",
1151             "-E",
1152             self.echo_phrase,
1153             "-X",
1154             self.server_ipv6_addr,
1155             self.server_port,
1156         ]
1157         self.client_ipv6_uni_dir_nsock_test_args = [
1158             "-N",
1159             "1000",
1160             "-U",
1161             "-X",
1162             "-6",
1163             "-I",
1164             "2",
1165             self.server_ipv6_addr,
1166             self.server_port,
1167         ]
1168         self.client_ipv6_bi_dir_nsock_test_args = [
1169             "-N",
1170             "1000",
1171             "-B",
1172             "-X",
1173             "-6",
1174             "-I",
1175             "2",
1176             self.server_ipv6_addr,
1177             self.server_port,
1178         ]
1179
1180     def tearDown(self):
1181         super(VCLIpv6CutThruTestCase, self).tearDown()
1182         self.cut_thru_tear_down()
1183
1184     def show_commands_at_teardown(self):
1185         self.logger.debug(self.vapi.cli("show session verbose 2"))
1186         self.logger.debug(self.vapi.cli("show app mq"))
1187
1188     def test_vcl_ipv6_cut_thru_echo(self):
1189         """run VCL IPv6 cut thru echo test"""
1190
1191         self.cut_thru_test(
1192             "vcl_test_server",
1193             self.server_ipv6_args,
1194             "vcl_test_client",
1195             self.client_ipv6_echo_test_args,
1196         )
1197
1198     @unittest.skipUnless(config.extended, "part of extended tests")
1199     def test_vcl_ipv6_cut_thru_uni_dir_nsock(self):
1200         """run VCL IPv6 cut thru uni-directional (multiple sockets) test"""
1201
1202         self.timeout = self.client_uni_dir_nsock_timeout
1203         self.cut_thru_test(
1204             "vcl_test_server",
1205             self.server_ipv6_args,
1206             "vcl_test_client",
1207             self.client_ipv6_uni_dir_nsock_test_args,
1208         )
1209
1210     @unittest.skipUnless(config.extended, "part of extended tests")
1211     def test_vcl_ipv6_cut_thru_bi_dir_nsock(self):
1212         """run VCL IPv6 cut thru bi-directional (multiple sockets) test"""
1213
1214         self.timeout = self.client_bi_dir_nsock_timeout
1215         self.cut_thru_test(
1216             "vcl_test_server",
1217             self.server_ipv6_args,
1218             "vcl_test_client",
1219             self.client_ipv6_bi_dir_nsock_test_args,
1220         )
1221
1222
1223 class VCLIpv6ThruHostStackEcho(VCLTestCase):
1224     """VCL IPv6 Thru Host Stack Echo"""
1225
1226     @classmethod
1227     def setUpClass(cls):
1228         super(VCLIpv6ThruHostStackEcho, cls).setUpClass()
1229
1230     @classmethod
1231     def tearDownClass(cls):
1232         super(VCLIpv6ThruHostStackEcho, cls).tearDownClass()
1233
1234     def setUp(self):
1235         super(VCLIpv6ThruHostStackEcho, self).setUp()
1236
1237         self.thru_host_stack_ipv6_setup()
1238         self.client_ipv6_echo_test_args = [
1239             "-6",
1240             "-E",
1241             self.echo_phrase,
1242             "-X",
1243             self.loop0.local_ip6,
1244             self.server_port,
1245         ]
1246
1247     def tearDown(self):
1248         self.thru_host_stack_ipv6_tear_down()
1249         super(VCLIpv6ThruHostStackEcho, self).tearDown()
1250
1251     def test_vcl_ipv6_thru_host_stack_echo(self):
1252         """run VCL IPv6 thru host stack echo test"""
1253
1254         self.thru_host_stack_test(
1255             "vcl_test_server",
1256             self.server_ipv6_args,
1257             "vcl_test_client",
1258             self.client_ipv6_echo_test_args,
1259         )
1260
1261
1262 if __name__ == "__main__":
1263     unittest.main(testRunner=VppTestRunner)