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