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