test/test_vcl.py

   1 #!/usr/bin/env python
   2 """ Vpp VCL tests """
   3
   4 import unittest
   5 import os
   6 import subprocess
   7 import signal
   8 from framework import VppTestCase, VppTestRunner, running_extended_tests, \
   9     Worker
  10 from vpp_ip_route import VppIpTable, VppIpRoute, VppRoutePath, FibPathProto
  11
  12 iperf3 = '/usr/bin/iperf3'
  13
  14
  15 def have_app(app):
  16     try:
  17         subprocess.check_output([app, '-v'])
  18     except (subprocess.CalledProcessError, OSError):
  19         return False
  20     return True
  21
  22
  23 _have_iperf3 = have_app(iperf3)
  24 _have_permissions = os.geteuid() == 0
  25
  26
  27 class VCLAppWorker(Worker):
  28     """ VCL Test Application Worker """
  29
  30     def __init__(self, build_dir, appname, args, logger, env={}):
  31         vcl_lib_dir = "%s/vpp/lib" % build_dir
  32         if "iperf" in appname:
  33             app = appname
  34             env.update({'LD_PRELOAD':
  35                         "%s/libvcl_ldpreload.so" % vcl_lib_dir})
  36         elif "sock" in appname:
  37             app = "%s/vpp/bin/%s" % (build_dir, appname)
  38             env.update({'LD_PRELOAD':
  39                         "%s/libvcl_ldpreload.so" % vcl_lib_dir})
  40         else:
  41             app = "%s/vpp/bin/%s" % (build_dir, appname)
  42         self.args = [app] + args
  43         super(VCLAppWorker, self).__init__(self.args, logger, env)
  44
  45
  46 class VCLTestCase(VppTestCase):
  47     """ VCL Test Class """
  48
  49     @classmethod
  50     def setUpClass(cls):
  51         super(VCLTestCase, cls).setUpClass()
  52
  53     @classmethod
  54     def tearDownClass(cls):
  55         super(VCLTestCase, cls).tearDownClass()
  56
  57     def setUp(self):
  58         var = "VPP_BUILD_DIR"
  59         self.build_dir = os.getenv(var, None)
  60         if self.build_dir is None:
  61             raise EnvironmentError("Environment variable `%s' not set" % var)
  62         self.vppDebug = 'vpp_debug' in self.build_dir
  63         self.server_addr = "127.0.0.1"
  64         self.server_port = "22000"
  65         self.server_args = [self.server_port]
  66         self.server_ipv6_addr = "::1"
  67         self.server_ipv6_args = ["-6", self.server_port]
  68         self.timeout = 20
  69         self.echo_phrase = "Hello, world! Jenny is a friend of mine."
  70         self.pre_test_sleep = 0.3
  71         self.post_test_sleep = 0.2
  72
  73         if os.path.isfile("/tmp/ldp_server_af_unix_socket"):
  74             os.remove("/tmp/ldp_server_af_unix_socket")
  75
  76         super(VCLTestCase, self).setUp()
  77
  78     def cut_thru_setup(self):
  79         self.vapi.session_enable_disable(is_enabled=1)
  80
  81     def cut_thru_tear_down(self):
  82         self.vapi.session_enable_disable(is_enabled=0)
  83
  84     def cut_thru_test(self, server_app, server_args, client_app, client_args):
  85         self.env = {'VCL_API_PREFIX': self.shm_prefix,
  86                     'VCL_APP_SCOPE_LOCAL': "true"}
  87         worker_server = VCLAppWorker(self.build_dir, server_app, server_args,
  88                                      self.logger, self.env)
  89         worker_server.start()
  90         self.sleep(self.pre_test_sleep)
  91         worker_client = VCLAppWorker(self.build_dir, client_app, client_args,
  92                                      self.logger, self.env)
  93         worker_client.start()
  94         worker_client.join(self.timeout)
  95         try:
  96             self.validateResults(worker_client, worker_server, self.timeout)
  97         except Exception as error:
  98             self.fail("Failed with %s" % error)
  99         self.sleep(self.post_test_sleep)
 100
 101     def thru_host_stack_setup(self):
 102         self.vapi.session_enable_disable(is_enabled=1)
 103         self.create_loopback_interfaces(2)
 104
 105         table_id = 1
 106
 107         for i in self.lo_interfaces:
 108             i.admin_up()
 109
 110             if table_id != 0:
 111                 tbl = VppIpTable(self, table_id)
 112                 tbl.add_vpp_config()
 113
 114             i.set_table_ip4(table_id)
 115             i.config_ip4()
 116             table_id += 1
 117
 118         # Configure namespaces
 119         self.vapi.app_namespace_add_del(namespace_id=b"1", secret=1234,
 120                                         sw_if_index=self.loop0.sw_if_index)
 121         self.vapi.app_namespace_add_del(namespace_id=b"2", secret=5678,
 122                                         sw_if_index=self.loop1.sw_if_index)
 123
 124         # Add inter-table routes
 125         ip_t01 = VppIpRoute(self, self.loop1.local_ip4, 32,
 126                             [VppRoutePath("0.0.0.0",
 127                                           0xffffffff,
 128                                           nh_table_id=2)], table_id=1)
 129         ip_t10 = VppIpRoute(self, self.loop0.local_ip4, 32,
 130                             [VppRoutePath("0.0.0.0",
 131                                           0xffffffff,
 132                                           nh_table_id=1)], table_id=2)
 133         ip_t01.add_vpp_config()
 134         ip_t10.add_vpp_config()
 135         self.logger.debug(self.vapi.cli("show ip fib"))
 136
 137     def thru_host_stack_tear_down(self):
 138         for i in self.lo_interfaces:
 139             i.unconfig_ip4()
 140             i.set_table_ip4(0)
 141             i.admin_down()
 142
 143     def thru_host_stack_ipv6_setup(self):
 144         self.vapi.session_enable_disable(is_enabled=1)
 145         self.create_loopback_interfaces(2)
 146
 147         table_id = 1
 148
 149         for i in self.lo_interfaces:
 150             i.admin_up()
 151
 152             tbl = VppIpTable(self, table_id, is_ip6=1)
 153             tbl.add_vpp_config()
 154
 155             i.set_table_ip6(table_id)
 156             i.config_ip6()
 157             table_id += 1
 158
 159         # Configure namespaces
 160         self.vapi.app_namespace_add_del(namespace_id=b"1", secret=1234,
 161                                         sw_if_index=self.loop0.sw_if_index)
 162         self.vapi.app_namespace_add_del(namespace_id=b"2", secret=5678,
 163                                         sw_if_index=self.loop1.sw_if_index)
 164
 165         # Add inter-table routes
 166         ip_t01 = VppIpRoute(self, self.loop1.local_ip6, 128,
 167                             [VppRoutePath("::0", 0xffffffff,
 168                                           nh_table_id=2)],
 169                             table_id=1)
 170         ip_t10 = VppIpRoute(self, self.loop0.local_ip6, 128,
 171                             [VppRoutePath("::0", 0xffffffff,
 172                                           nh_table_id=1)],
 173                             table_id=2)
 174         ip_t01.add_vpp_config()
 175         ip_t10.add_vpp_config()
 176         self.logger.debug(self.vapi.cli("show interface addr"))
 177         self.logger.debug(self.vapi.cli("show ip6 fib"))
 178
 179     def thru_host_stack_ipv6_tear_down(self):
 180         for i in self.lo_interfaces:
 181             i.unconfig_ip6()
 182             i.set_table_ip6(0)
 183             i.admin_down()
 184
 185         self.vapi.session_enable_disable(is_enabled=0)
 186
 187     @unittest.skipUnless(_have_iperf3, "'%s' not found, Skipping.")
 188     @unittest.skipUnless(_have_permissions, 'Need to run as root. Skipping.')
 189     def thru_host_stack_test(self, server_app, server_args,
 190                              client_app, client_args):
 191         self.env = {'VCL_API_PREFIX': self.shm_prefix,
 192                     'VCL_APP_SCOPE_GLOBAL': "true",
 193                     'VCL_APP_NAMESPACE_ID': "1",
 194                     'VCL_APP_NAMESPACE_SECRET': "1234"}
 195
 196         worker_server = VCLAppWorker(self.build_dir, server_app, server_args,
 197                                      self.logger, self.env)
 198         worker_server.start()
 199         self.sleep(self.pre_test_sleep)
 200
 201         self.env.update({'VCL_APP_NAMESPACE_ID': "2",
 202                          'VCL_APP_NAMESPACE_SECRET': "5678"})
 203         worker_client = VCLAppWorker(self.build_dir, client_app, client_args,
 204                                      self.logger, self.env)
 205         worker_client.start()
 206         worker_client.join(self.timeout)
 207
 208         try:
 209             self.validateResults(worker_client, worker_server, self.timeout)
 210         except Exception as error:
 211             self.fail("Failed with %s" % error)
 212         self.sleep(self.post_test_sleep)
 213
 214     def validateResults(self, worker_client, worker_server, timeout):
 215         if worker_server.process is None:
 216             raise RuntimeError('worker_server is not running.')
 217         if os.path.isdir('/proc/{}'.format(worker_server.process.pid)):
 218             self.logger.info("Killing server worker process (pid %d)" %
 219                              worker_server.process.pid)
 220             os.killpg(os.getpgid(worker_server.process.pid), signal.SIGTERM)
 221             worker_server.join()
 222         self.logger.info("Client worker result is `%s'" % worker_client.result)
 223         error = False
 224         if worker_client.result is None:
 225             try:
 226                 error = True
 227                 self.logger.error(
 228                     "Timeout: %ss! Killing client worker process (pid %d)" %
 229                     (timeout, worker_client.process.pid))
 230                 os.killpg(os.getpgid(worker_client.process.pid),
 231                           signal.SIGKILL)
 232                 worker_client.join()
 233             except OSError:
 234                 self.logger.debug(
 235                     "Couldn't kill client worker process")
 236                 raise
 237         if error:
 238             raise RuntimeError(
 239                 "Timeout! Client worker did not finish in %ss" % timeout)
 240         self.assert_equal(worker_client.result, 0, "Binary test return code")
 241
 242
 243 class LDPCutThruTestCase(VCLTestCase):
 244     """ LDP Cut Thru Tests """
 245
 246     @classmethod
 247     def setUpClass(cls):
 248         super(LDPCutThruTestCase, cls).setUpClass()
 249
 250     @classmethod
 251     def tearDownClass(cls):
 252         super(LDPCutThruTestCase, cls).tearDownClass()
 253
 254     def setUp(self):
 255         super(LDPCutThruTestCase, self).setUp()
 256
 257         self.cut_thru_setup()
 258         self.client_echo_test_args = ["-E", self.echo_phrase, "-X",
 259                                       self.server_addr, self.server_port]
 260         self.client_iperf3_timeout = 20
 261         self.client_iperf3_args = ["-V4d", "-t 2", "-c", self.server_addr]
 262         self.server_iperf3_args = ["-V4d", "-s"]
 263         self.client_uni_dir_nsock_timeout = 20
 264         self.client_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 265                                                "-I", "2",
 266                                                self.server_addr,
 267                                                self.server_port]
 268         self.client_bi_dir_nsock_timeout = 20
 269         self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 270                                               "-I", "2",
 271                                               self.server_addr,
 272                                               self.server_port]
 273
 274     def tearDown(self):
 275         super(LDPCutThruTestCase, self).tearDown()
 276         self.cut_thru_tear_down()
 277
 278     def show_commands_at_teardown(self):
 279         self.logger.debug(self.vapi.cli("show session verbose 2"))
 280
 281     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 282     def test_ldp_cut_thru_echo(self):
 283         """ run LDP cut thru echo test """
 284
 285         self.cut_thru_test("sock_test_server", self.server_args,
 286                            "sock_test_client", self.client_echo_test_args)
 287
 288     @unittest.skipUnless(_have_iperf3, "'%s' not found, Skipping.")
 289     @unittest.skipUnless(_have_permissions, 'Need to run as root. Skipping.')
 290     def test_ldp_cut_thru_iperf3(self):
 291         """ run LDP cut thru iperf3 test """
 292
 293         self.timeout = self.client_iperf3_timeout
 294         self.cut_thru_test(iperf3, self.server_iperf3_args,
 295                            iperf3, self.client_iperf3_args)
 296
 297     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 298     def test_ldp_cut_thru_uni_dir_nsock(self):
 299         """ run LDP cut thru uni-directional (multiple sockets) test """
 300
 301         self.timeout = self.client_uni_dir_nsock_timeout
 302         self.cut_thru_test("sock_test_server", self.server_args,
 303                            "sock_test_client",
 304                            self.client_uni_dir_nsock_test_args)
 305
 306     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 307     def test_ldp_cut_thru_bi_dir_nsock(self):
 308         """ run LDP cut thru bi-directional (multiple sockets) test """
 309
 310         self.timeout = self.client_bi_dir_nsock_timeout
 311         self.cut_thru_test("sock_test_server", self.server_args,
 312                            "sock_test_client",
 313                            self.client_bi_dir_nsock_test_args)
 314
 315
 316 class VCLCutThruTestCase(VCLTestCase):
 317     """ VCL Cut Thru Tests """
 318
 319     @classmethod
 320     def setUpClass(cls):
 321         super(VCLCutThruTestCase, cls).setUpClass()
 322
 323     @classmethod
 324     def tearDownClass(cls):
 325         super(VCLCutThruTestCase, cls).tearDownClass()
 326
 327     def setUp(self):
 328         super(VCLCutThruTestCase, self).setUp()
 329
 330         self.cut_thru_setup()
 331         self.client_echo_test_args = ["-E", self.echo_phrase, "-X",
 332                                       self.server_addr, self.server_port]
 333
 334         self.client_uni_dir_nsock_timeout = 20
 335         self.client_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 336                                                "-I", "2",
 337                                                self.server_addr,
 338                                                self.server_port]
 339         self.client_bi_dir_nsock_timeout = 20
 340         self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 341                                               "-I", "2",
 342                                               self.server_addr,
 343                                               self.server_port]
 344
 345     def tearDown(self):
 346         super(VCLCutThruTestCase, self).tearDown()
 347
 348     def show_commands_at_teardown(self):
 349         self.logger.debug(self.vapi.cli("show session verbose 2"))
 350
 351     def test_vcl_cut_thru_echo(self):
 352         """ run VCL cut thru echo test """
 353
 354         self.cut_thru_test("vcl_test_server", self.server_args,
 355                            "vcl_test_client", self.client_echo_test_args)
 356
 357     def test_vcl_cut_thru_uni_dir_nsock(self):
 358         """ run VCL cut thru uni-directional (multiple sockets) test """
 359
 360         self.timeout = self.client_uni_dir_nsock_timeout
 361         self.cut_thru_test("vcl_test_server", self.server_args,
 362                            "vcl_test_client",
 363                            self.client_uni_dir_nsock_test_args)
 364
 365     def test_vcl_cut_thru_bi_dir_nsock(self):
 366         """ run VCL cut thru bi-directional (multiple sockets) test """
 367
 368         self.timeout = self.client_bi_dir_nsock_timeout
 369         self.cut_thru_test("vcl_test_server", self.server_args,
 370                            "vcl_test_client",
 371                            self.client_bi_dir_nsock_test_args)
 372
 373
 374 class VCLThruHostStackEcho(VCLTestCase):
 375     """ VCL Thru Host Stack Echo """
 376
 377     @classmethod
 378     def setUpClass(cls):
 379         super(VCLThruHostStackEcho, cls).setUpClass()
 380
 381     @classmethod
 382     def tearDownClass(cls):
 383         super(VCLThruHostStackEcho, cls).tearDownClass()
 384
 385     def setUp(self):
 386         super(VCLThruHostStackEcho, self).setUp()
 387
 388         self.thru_host_stack_setup()
 389         self.client_bi_dir_nsock_timeout = 20
 390         self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 391                                               "-I", "2",
 392                                               self.loop0.local_ip4,
 393                                               self.server_port]
 394         self.client_echo_test_args = ["-E", self.echo_phrase, "-X",
 395                                       self.loop0.local_ip4,
 396                                       self.server_port]
 397
 398     def tearDown(self):
 399         self.thru_host_stack_tear_down()
 400         super(VCLThruHostStackEcho, self).tearDown()
 401
 402     def show_commands_at_teardown(self):
 403         self.logger.debug(self.vapi.cli("show app server"))
 404         self.logger.debug(self.vapi.cli("show session verbose"))
 405
 406
 407 class VCLThruHostStackTLS(VCLTestCase):
 408     """ VCL Thru Host Stack TLS """
 409
 410     @classmethod
 411     def setUpClass(cls):
 412         super(VCLThruHostStackTLS, cls).setUpClass()
 413
 414     @classmethod
 415     def tearDownClass(cls):
 416         super(VCLThruHostStackTLS, cls).tearDownClass()
 417
 418     def setUp(self):
 419         super(VCLThruHostStackTLS, self).setUp()
 420
 421         self.thru_host_stack_setup()
 422         self.client_uni_dir_tls_timeout = 20
 423         self.server_tls_args = ["-L", self.server_port]
 424         self.client_uni_dir_tls_test_args = ["-N", "1000", "-U", "-X", "-L",
 425                                              self.loop0.local_ip4,
 426                                              self.server_port]
 427
 428     def test_vcl_thru_host_stack_tls_uni_dir(self):
 429         """ run VCL thru host stack uni-directional TLS test """
 430
 431         self.timeout = self.client_uni_dir_tls_timeout
 432         self.thru_host_stack_test("vcl_test_server", self.server_tls_args,
 433                                   "vcl_test_client",
 434                                   self.client_uni_dir_tls_test_args)
 435
 436     def tearDown(self):
 437         self.thru_host_stack_tear_down()
 438         super(VCLThruHostStackTLS, self).tearDown()
 439
 440     def show_commands_at_teardown(self):
 441         self.logger.debug(self.vapi.cli("show app server"))
 442         self.logger.debug(self.vapi.cli("show session verbose 2"))
 443
 444
 445 class VCLThruHostStackBidirNsock(VCLTestCase):
 446     """ VCL Thru Host Stack Bidir Nsock """
 447
 448     @classmethod
 449     def setUpClass(cls):
 450         super(VCLThruHostStackBidirNsock, cls).setUpClass()
 451
 452     @classmethod
 453     def tearDownClass(cls):
 454         super(VCLThruHostStackBidirNsock, cls).tearDownClass()
 455
 456     def setUp(self):
 457         super(VCLThruHostStackBidirNsock, self).setUp()
 458
 459         self.thru_host_stack_setup()
 460         self.client_bi_dir_nsock_timeout = 20
 461         self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 462                                               "-I", "2",
 463                                               self.loop0.local_ip4,
 464                                               self.server_port]
 465         self.client_echo_test_args = ["-E", self.echo_phrase, "-X",
 466                                       self.loop0.local_ip4,
 467                                       self.server_port]
 468
 469     def tearDown(self):
 470         self.thru_host_stack_tear_down()
 471         super(VCLThruHostStackBidirNsock, self).tearDown()
 472
 473     def show_commands_at_teardown(self):
 474         self.logger.debug(self.vapi.cli("show session verbose 2"))
 475
 476     def test_vcl_thru_host_stack_bi_dir_nsock(self):
 477         """ run VCL thru host stack bi-directional (multiple sockets) test """
 478
 479         self.timeout = self.client_bi_dir_nsock_timeout
 480         self.thru_host_stack_test("vcl_test_server", self.server_args,
 481                                   "vcl_test_client",
 482                                   self.client_bi_dir_nsock_test_args)
 483
 484
 485 class LDPThruHostStackBidirNsock(VCLTestCase):
 486     """ LDP Thru Host Stack Bidir Nsock """
 487
 488     @classmethod
 489     def setUpClass(cls):
 490         super(LDPThruHostStackBidirNsock, cls).setUpClass()
 491
 492     @classmethod
 493     def tearDownClass(cls):
 494         super(LDPThruHostStackBidirNsock, cls).tearDownClass()
 495
 496     def setUp(self):
 497         super(LDPThruHostStackBidirNsock, self).setUp()
 498
 499         self.thru_host_stack_setup()
 500         if self.vppDebug:
 501             self.client_bi_dir_nsock_timeout = 20
 502             self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 503                                                   # OUCH! Host Stack Bug?
 504                                                   # "-I", "2",
 505                                                   self.loop0.local_ip4,
 506                                                   self.server_port]
 507         else:
 508             self.client_bi_dir_nsock_timeout = 20
 509             self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 510                                                   # OUCH! Host Stack Bug?
 511                                                   # "-I", "2",
 512                                                   self.loop0.local_ip4,
 513                                                   self.server_port]
 514
 515     def tearDown(self):
 516         self.thru_host_stack_tear_down()
 517         super(LDPThruHostStackBidirNsock, self).tearDown()
 518
 519     def show_commands_at_teardown(self):
 520         self.logger.debug(self.vapi.cli("show session verbose 2"))
 521
 522     def test_ldp_thru_host_stack_bi_dir_nsock(self):
 523         """ run LDP thru host stack bi-directional (multiple sockets) test """
 524
 525         self.timeout = self.client_bi_dir_nsock_timeout
 526         self.thru_host_stack_test("sock_test_server", self.server_args,
 527                                   "sock_test_client",
 528                                   self.client_bi_dir_nsock_test_args)
 529
 530
 531 class LDPThruHostStackNsock(VCLTestCase):
 532     """ LDP Thru Host Stack Nsock """
 533
 534     @classmethod
 535     def setUpClass(cls):
 536         super(LDPThruHostStackNsock, cls).setUpClass()
 537
 538     @classmethod
 539     def tearDownClass(cls):
 540         super(LDPThruHostStackNsock, cls).tearDownClass()
 541
 542     def setUp(self):
 543         super(LDPThruHostStackNsock, self).setUp()
 544
 545         self.thru_host_stack_setup()
 546         if self.vppDebug:
 547             self.client_uni_dir_nsock_timeout = 20
 548             self.numSockets = "2"
 549         else:
 550             self.client_uni_dir_nsock_timeout = 20
 551             self.numSockets = "5"
 552
 553         self.client_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 554                                                "-I", self.numSockets,
 555                                                self.loop0.local_ip4,
 556                                                self.server_port]
 557
 558     def tearDown(self):
 559         self.thru_host_stack_tear_down()
 560         super(LDPThruHostStackNsock, self).tearDown()
 561
 562     def test_ldp_thru_host_stack_uni_dir_nsock(self):
 563         """ run LDP thru host stack uni-directional (multiple sockets) test """
 564
 565         self.timeout = self.client_uni_dir_nsock_timeout
 566         self.thru_host_stack_test("sock_test_server", self.server_args,
 567                                   "sock_test_client",
 568                                   self.client_uni_dir_nsock_test_args)
 569
 570
 571 class VCLThruHostStackNsock(VCLTestCase):
 572     """ VCL Thru Host Stack Nsock """
 573
 574     @classmethod
 575     def setUpClass(cls):
 576         super(VCLThruHostStackNsock, cls).setUpClass()
 577
 578     @classmethod
 579     def tearDownClass(cls):
 580         super(VCLThruHostStackNsock, cls).tearDownClass()
 581
 582     def setUp(self):
 583         super(VCLThruHostStackNsock, self).setUp()
 584
 585         self.thru_host_stack_setup()
 586         if self.vppDebug:
 587             self.client_uni_dir_nsock_timeout = 20
 588             self.numSockets = "2"
 589         else:
 590             self.client_uni_dir_nsock_timeout = 20
 591             self.numSockets = "5"
 592
 593         self.client_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 594                                                "-I", self.numSockets,
 595                                                self.loop0.local_ip4,
 596                                                self.server_port]
 597
 598     def tearDown(self):
 599         self.thru_host_stack_tear_down()
 600         super(VCLThruHostStackNsock, self).tearDown()
 601
 602     def test_vcl_thru_host_stack_uni_dir_nsock(self):
 603         """ run VCL thru host stack uni-directional (multiple sockets) test """
 604
 605         self.timeout = self.client_uni_dir_nsock_timeout
 606         self.thru_host_stack_test("vcl_test_server", self.server_args,
 607                                   "vcl_test_client",
 608                                   self.client_uni_dir_nsock_test_args)
 609
 610
 611 class LDPThruHostStackIperf(VCLTestCase):
 612     """ LDP Thru Host Stack Iperf  """
 613
 614     @classmethod
 615     def setUpClass(cls):
 616         super(LDPThruHostStackIperf, cls).setUpClass()
 617
 618     @classmethod
 619     def tearDownClass(cls):
 620         super(LDPThruHostStackIperf, cls).tearDownClass()
 621
 622     def setUp(self):
 623         super(LDPThruHostStackIperf, self).setUp()
 624
 625         self.thru_host_stack_setup()
 626         self.client_iperf3_timeout = 20
 627         self.client_iperf3_args = ["-V4d", "-t 2", "-c", self.loop0.local_ip4]
 628         self.server_iperf3_args = ["-V4d", "-s"]
 629
 630     def tearDown(self):
 631         self.thru_host_stack_tear_down()
 632         super(LDPThruHostStackIperf, self).tearDown()
 633
 634     def show_commands_at_teardown(self):
 635         self.logger.debug(self.vapi.cli("show session verbose 2"))
 636
 637     @unittest.skipUnless(_have_iperf3, "'%s' not found, Skipping.")
 638     @unittest.skipUnless(_have_permissions, 'Need to run as root. Skipping.')
 639     def test_ldp_thru_host_stack_iperf3(self):
 640         """ run LDP thru host stack iperf3 test """
 641
 642         self.timeout = self.client_iperf3_timeout
 643         self.thru_host_stack_test(iperf3, self.server_iperf3_args,
 644                                   iperf3, self.client_iperf3_args)
 645
 646
 647 class LDPIpv6CutThruTestCase(VCLTestCase):
 648     """ LDP IPv6 Cut Thru Tests """
 649
 650     @classmethod
 651     def setUpClass(cls):
 652         super(LDPIpv6CutThruTestCase, cls).setUpClass()
 653
 654     @classmethod
 655     def tearDownClass(cls):
 656         super(LDPIpv6CutThruTestCase, cls).tearDownClass()
 657
 658     def setUp(self):
 659         super(LDPIpv6CutThruTestCase, self).setUp()
 660
 661         self.cut_thru_setup()
 662         self.client_iperf3_timeout = 20
 663         self.client_uni_dir_nsock_timeout = 20
 664         self.client_bi_dir_nsock_timeout = 20
 665         self.client_ipv6_echo_test_args = ["-6", "-E", self.echo_phrase, "-X",
 666                                            self.server_ipv6_addr,
 667                                            self.server_port]
 668         self.client_ipv6_iperf3_args = ["-V6d", "-t 2", "-c",
 669                                         self.server_ipv6_addr]
 670         self.server_ipv6_iperf3_args = ["-V6d", "-s"]
 671         self.client_ipv6_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 672                                                     "-6",
 673                                                     "-I", "2",
 674                                                     self.server_ipv6_addr,
 675                                                     self.server_port]
 676         self.client_ipv6_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 677                                                    "-6",
 678                                                    "-I", "2",
 679                                                    self.server_ipv6_addr,
 680                                                    self.server_port]
 681
 682     def tearDown(self):
 683         super(LDPIpv6CutThruTestCase, self).tearDown()
 684         self.cut_thru_tear_down()
 685
 686     def test_ldp_ipv6_cut_thru_echo(self):
 687         """ run LDP IPv6 cut thru echo test """
 688
 689         self.cut_thru_test("sock_test_server",
 690                            self.server_ipv6_args,
 691                            "sock_test_client",
 692                            self.client_ipv6_echo_test_args)
 693
 694     @unittest.skipUnless(_have_iperf3, "'%s' not found, Skipping.")
 695     @unittest.skipUnless(_have_permissions, 'Need to run as root. Skipping.')
 696     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 697     def test_ldp_ipv6_cut_thru_iperf3(self):
 698         """ run LDP IPv6 cut thru iperf3 test """
 699
 700         self.timeout = self.client_iperf3_timeout
 701         self.cut_thru_test(iperf3, self.server_ipv6_iperf3_args,
 702                            iperf3, self.client_ipv6_iperf3_args)
 703
 704     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 705     def test_ldp_ipv6_cut_thru_uni_dir_nsock(self):
 706         """ run LDP IPv6 cut thru uni-directional (multiple sockets) test """
 707
 708         self.timeout = self.client_uni_dir_nsock_timeout
 709         self.cut_thru_test("sock_test_server", self.server_ipv6_args,
 710                            "sock_test_client",
 711                            self.client_ipv6_uni_dir_nsock_test_args)
 712
 713     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 714     def test_ldp_ipv6_cut_thru_bi_dir_nsock(self):
 715         """ run LDP IPv6 cut thru bi-directional (multiple sockets) test """
 716
 717         self.timeout = self.client_bi_dir_nsock_timeout
 718         self.cut_thru_test("sock_test_server", self.server_ipv6_args,
 719                            "sock_test_client",
 720                            self.client_ipv6_bi_dir_nsock_test_args)
 721
 722
 723 class VCLIpv6CutThruTestCase(VCLTestCase):
 724     """ VCL IPv6 Cut Thru Tests """
 725
 726     @classmethod
 727     def setUpClass(cls):
 728         super(VCLIpv6CutThruTestCase, cls).setUpClass()
 729
 730     @classmethod
 731     def tearDownClass(cls):
 732         super(VCLIpv6CutThruTestCase, cls).tearDownClass()
 733
 734     def setUp(self):
 735         super(VCLIpv6CutThruTestCase, self).setUp()
 736
 737         self.cut_thru_setup()
 738         self.client_uni_dir_nsock_timeout = 20
 739         self.client_bi_dir_nsock_timeout = 20
 740         self.client_ipv6_echo_test_args = ["-6", "-E", self.echo_phrase, "-X",
 741                                            self.server_ipv6_addr,
 742                                            self.server_port]
 743         self.client_ipv6_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 744                                                     "-6",
 745                                                     "-I", "2",
 746                                                     self.server_ipv6_addr,
 747                                                     self.server_port]
 748         self.client_ipv6_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 749                                                    "-6",
 750                                                    "-I", "2",
 751                                                    self.server_ipv6_addr,
 752                                                    self.server_port]
 753
 754     def tearDown(self):
 755         super(VCLIpv6CutThruTestCase, self).tearDown()
 756         self.cut_thru_tear_down()
 757
 758     def test_vcl_ipv6_cut_thru_echo(self):
 759         """ run VCL IPv6 cut thru echo test """
 760
 761         self.cut_thru_test("vcl_test_server",
 762                            self.server_ipv6_args,
 763                            "vcl_test_client",
 764                            self.client_ipv6_echo_test_args)
 765
 766     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 767     def test_vcl_ipv6_cut_thru_uni_dir_nsock(self):
 768         """ run VCL IPv6 cut thru uni-directional (multiple sockets) test """
 769
 770         self.timeout = self.client_uni_dir_nsock_timeout
 771         self.cut_thru_test("vcl_test_server", self.server_ipv6_args,
 772                            "vcl_test_client",
 773                            self.client_ipv6_uni_dir_nsock_test_args)
 774
 775     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 776     def test_vcl_ipv6_cut_thru_bi_dir_nsock(self):
 777         """ run VCL IPv6 cut thru bi-directional (multiple sockets) test """
 778
 779         self.timeout = self.client_bi_dir_nsock_timeout
 780         self.cut_thru_test("vcl_test_server", self.server_ipv6_args,
 781                            "vcl_test_client",
 782                            self.client_ipv6_bi_dir_nsock_test_args)
 783
 784
 785 class VCLIpv6ThruHostStackEcho(VCLTestCase):
 786     """ VCL IPv6 Thru Host Stack Echo """
 787
 788     @classmethod
 789     def setUpClass(cls):
 790         super(VCLIpv6ThruHostStackEcho, cls).setUpClass()
 791
 792     @classmethod
 793     def tearDownClass(cls):
 794         super(VCLIpv6ThruHostStackEcho, cls).tearDownClass()
 795
 796     def setUp(self):
 797         super(VCLIpv6ThruHostStackEcho, self).setUp()
 798
 799         self.thru_host_stack_ipv6_setup()
 800         self.client_ipv6_echo_test_args = ["-6", "-E", self.echo_phrase, "-X",
 801                                            self.loop0.local_ip6,
 802                                            self.server_port]
 803
 804     def tearDown(self):
 805         self.thru_host_stack_ipv6_tear_down()
 806         super(VCLIpv6ThruHostStackEcho, self).tearDown()
 807
 808     def test_vcl_ipv6_thru_host_stack_echo(self):
 809         """ run VCL IPv6 thru host stack echo test """
 810
 811         self.thru_host_stack_test("vcl_test_server",
 812                                   self.server_ipv6_args,
 813                                   "vcl_test_client",
 814                                   self.client_ipv6_echo_test_args)
 815
 816
 817 if __name__ == '__main__':
 818     unittest.main(testRunner=VppTestRunner)