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(namespace_id="1", secret=1234,
 107                                     sw_if_index=self.loop0.sw_if_index)
 108         self.vapi.app_namespace_add(namespace_id="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         self.vapi.session_enable_disable(is_enabled=0)
 131
 132     def thru_host_stack_ipv6_setup(self):
 133         self.vapi.session_enable_disable(is_enabled=1)
 134         self.create_loopback_interfaces(2)
 135
 136         table_id = 1
 137
 138         for i in self.lo_interfaces:
 139             i.admin_up()
 140
 141             tbl = VppIpTable(self, table_id, is_ip6=1)
 142             tbl.add_vpp_config()
 143
 144             i.set_table_ip6(table_id)
 145             i.config_ip6()
 146             table_id += 1
 147
 148         # Configure namespaces
 149         self.vapi.app_namespace_add(namespace_id="1", secret=1234,
 150                                     sw_if_index=self.loop0.sw_if_index)
 151         self.vapi.app_namespace_add(namespace_id="2", secret=5678,
 152                                     sw_if_index=self.loop1.sw_if_index)
 153
 154         # Add inter-table routes
 155         ip_t01 = VppIpRoute(self, self.loop1.local_ip6, 128,
 156                             [VppRoutePath("::0", 0xffffffff,
 157                                           nh_table_id=2,
 158                                           proto=DpoProto.DPO_PROTO_IP6)],
 159                             table_id=1, is_ip6=1)
 160         ip_t10 = VppIpRoute(self, self.loop0.local_ip6, 128,
 161                             [VppRoutePath("::0", 0xffffffff,
 162                                           nh_table_id=1,
 163                                           proto=DpoProto.DPO_PROTO_IP6)],
 164                             table_id=2, is_ip6=1)
 165         ip_t01.add_vpp_config()
 166         ip_t10.add_vpp_config()
 167         self.logger.debug(self.vapi.cli("show interface addr"))
 168         self.logger.debug(self.vapi.cli("show ip6 fib"))
 169
 170     def thru_host_stack_ipv6_tear_down(self):
 171         for i in self.lo_interfaces:
 172             i.unconfig_ip6()
 173             i.set_table_ip6(0)
 174             i.admin_down()
 175
 176         self.vapi.session_enable_disable(is_enabled=0)
 177
 178     def thru_host_stack_test(self, server_app, server_args,
 179                              client_app, client_args):
 180         self.env = {'VCL_API_PREFIX': self.shm_prefix,
 181                     'VCL_APP_SCOPE_GLOBAL': "true",
 182                     'VCL_APP_NAMESPACE_ID': "1",
 183                     'VCL_APP_NAMESPACE_SECRET': "1234"}
 184
 185         worker_server = VCLAppWorker(self.build_dir, server_app, server_args,
 186                                      self.logger, self.env)
 187         worker_server.start()
 188         self.sleep(self.pre_test_sleep)
 189
 190         self.env.update({'VCL_APP_NAMESPACE_ID': "2",
 191                          'VCL_APP_NAMESPACE_SECRET': "5678"})
 192         worker_client = VCLAppWorker(self.build_dir, client_app, client_args,
 193                                      self.logger, self.env)
 194         worker_client.start()
 195         worker_client.join(self.timeout)
 196
 197         try:
 198             self.validateResults(worker_client, worker_server, self.timeout)
 199         except Exception as error:
 200             self.fail("Failed with %s" % error)
 201         self.sleep(self.post_test_sleep)
 202
 203     def validateResults(self, worker_client, worker_server, timeout):
 204         if os.path.isdir('/proc/{}'.format(worker_server.process.pid)):
 205             self.logger.info("Killing server worker process (pid %d)" %
 206                              worker_server.process.pid)
 207             os.killpg(os.getpgid(worker_server.process.pid), signal.SIGKILL)
 208             worker_server.join()
 209         self.logger.info("Client worker result is `%s'" % worker_client.result)
 210         error = False
 211         if worker_client.result is None:
 212             try:
 213                 error = True
 214                 self.logger.error(
 215                     "Timeout: %ss! Killing client worker process (pid %d)" %
 216                     (timeout, worker_client.process.pid))
 217                 os.killpg(os.getpgid(worker_client.process.pid),
 218                           signal.SIGKILL)
 219                 worker_client.join()
 220             except:
 221                 self.logger.debug(
 222                     "Couldn't kill client worker process")
 223                 raise
 224         if error:
 225             raise Exception(
 226                 "Timeout! Client worker did not finish in %ss" % timeout)
 227         self.assert_equal(worker_client.result, 0, "Binary test return code")
 228
 229
 230 class LDPCutThruTestCase(VCLTestCase):
 231     """ LDP Cut Thru Tests """
 232
 233     @classmethod
 234     def setUpClass(cls):
 235         super(LDPCutThruTestCase, cls).setUpClass()
 236
 237     @classmethod
 238     def tearDownClass(cls):
 239         super(LDPCutThruTestCase, cls).tearDownClass()
 240
 241     def setUp(self):
 242         super(LDPCutThruTestCase, self).setUp()
 243
 244         self.cut_thru_setup()
 245         self.client_echo_test_args = ["-E", self.echo_phrase, "-X",
 246                                       self.server_addr, self.server_port]
 247         self.client_iperf3_timeout = 20
 248         self.client_iperf3_args = ["-V4d", "-t 2", "-c", self.server_addr]
 249         self.server_iperf3_args = ["-V4d", "-s"]
 250         self.client_uni_dir_nsock_timeout = 20
 251         self.client_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 252                                                "-I", "2",
 253                                                self.server_addr,
 254                                                self.server_port]
 255         self.client_bi_dir_nsock_timeout = 20
 256         self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 257                                               "-I", "2",
 258                                               self.server_addr,
 259                                               self.server_port]
 260
 261     def tearDown(self):
 262         self.cut_thru_tear_down()
 263
 264         super(LDPCutThruTestCase, self).tearDown()
 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("WARNING: 'iperf3' is not installed,")
 280             self.logger.error("         'test_ldp_cut_thru_iperf3' not run!")
 281             return
 282
 283         self.timeout = self.client_iperf3_timeout
 284         self.cut_thru_test("iperf3", self.server_iperf3_args,
 285                            "iperf3", self.client_iperf3_args)
 286
 287     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 288     def test_ldp_cut_thru_uni_dir_nsock(self):
 289         """ run LDP cut thru uni-directional (multiple sockets) test """
 290
 291         self.timeout = self.client_uni_dir_nsock_timeout
 292         self.cut_thru_test("sock_test_server", self.server_args,
 293                            "sock_test_client",
 294                            self.client_uni_dir_nsock_test_args)
 295
 296     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 297     def test_ldp_cut_thru_bi_dir_nsock(self):
 298         """ run LDP cut thru bi-directional (multiple sockets) test """
 299
 300         self.timeout = self.client_bi_dir_nsock_timeout
 301         self.cut_thru_test("sock_test_server", self.server_args,
 302                            "sock_test_client",
 303                            self.client_bi_dir_nsock_test_args)
 304
 305
 306 class VCLCutThruTestCase(VCLTestCase):
 307     """ VCL Cut Thru Tests """
 308
 309     @classmethod
 310     def setUpClass(cls):
 311         super(VCLCutThruTestCase, cls).setUpClass()
 312
 313     @classmethod
 314     def tearDownClass(cls):
 315         super(VCLCutThruTestCase, cls).tearDownClass()
 316
 317     def setUp(self):
 318         super(VCLCutThruTestCase, self).setUp()
 319
 320         self.cut_thru_setup()
 321         self.client_echo_test_args = ["-E", self.echo_phrase, "-X",
 322                                       self.server_addr, self.server_port]
 323
 324         self.client_uni_dir_nsock_timeout = 20
 325         self.client_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 326                                                "-I", "2",
 327                                                self.server_addr,
 328                                                self.server_port]
 329         self.client_bi_dir_nsock_timeout = 20
 330         self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 331                                               "-I", "2",
 332                                               self.server_addr,
 333                                               self.server_port]
 334
 335     def tearDown(self):
 336         self.cut_thru_tear_down()
 337
 338         super(VCLCutThruTestCase, self).tearDown()
 339
 340     def test_vcl_cut_thru_echo(self):
 341         """ run VCL cut thru echo test """
 342
 343         self.cut_thru_test("vcl_test_server", self.server_args,
 344                            "vcl_test_client", self.client_echo_test_args)
 345
 346     def test_vcl_cut_thru_uni_dir_nsock(self):
 347         """ run VCL cut thru uni-directional (multiple sockets) test """
 348
 349         self.timeout = self.client_uni_dir_nsock_timeout
 350         self.cut_thru_test("vcl_test_server", self.server_args,
 351                            "vcl_test_client",
 352                            self.client_uni_dir_nsock_test_args)
 353
 354     def test_vcl_cut_thru_bi_dir_nsock(self):
 355         """ run VCL cut thru bi-directional (multiple sockets) test """
 356
 357         self.timeout = self.client_bi_dir_nsock_timeout
 358         self.cut_thru_test("vcl_test_server", self.server_args,
 359                            "vcl_test_client",
 360                            self.client_bi_dir_nsock_test_args)
 361
 362
 363 class LDPThruHostStackEcho(VCLTestCase):
 364     """ LDP Thru Host Stack Echo """
 365
 366     @classmethod
 367     def setUpClass(cls):
 368         super(LDPThruHostStackEcho, cls).setUpClass()
 369
 370     @classmethod
 371     def tearDownClass(cls):
 372         super(LDPThruHostStackEcho, cls).tearDownClass()
 373
 374     def setUp(self):
 375         super(LDPThruHostStackEcho, self).setUp()
 376
 377         self.thru_host_stack_setup()
 378         self.client_echo_test_args = ["-E", self.echo_phrase, "-X",
 379                                       self.loop0.local_ip4,
 380                                       self.server_port]
 381
 382     def tearDown(self):
 383         self.thru_host_stack_tear_down()
 384         super(LDPThruHostStackEcho, self).tearDown()
 385
 386     def test_ldp_thru_host_stack_echo(self):
 387         """ run LDP thru host stack echo test """
 388
 389         self.thru_host_stack_test("sock_test_server", self.server_args,
 390                                   "sock_test_client",
 391                                   self.client_echo_test_args)
 392
 393
 394 class VCLThruHostStackEcho(VCLTestCase):
 395     """ VCL Thru Host Stack Echo """
 396
 397     @classmethod
 398     def setUpClass(cls):
 399         super(VCLThruHostStackEcho, cls).setUpClass()
 400
 401     @classmethod
 402     def tearDownClass(cls):
 403         super(VCLThruHostStackEcho, cls).tearDownClass()
 404
 405     def setUp(self):
 406         super(VCLThruHostStackEcho, self).setUp()
 407
 408         self.thru_host_stack_setup()
 409         self.client_bi_dir_nsock_timeout = 20
 410         self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 411                                               "-I", "2",
 412                                               self.loop0.local_ip4,
 413                                               self.server_port]
 414         self.client_echo_test_args = ["-E", self.echo_phrase, "-X",
 415                                       self.loop0.local_ip4,
 416                                       self.server_port]
 417
 418     def tearDown(self):
 419         self.logger.debug(self.vapi.cli("show app server"))
 420         self.logger.debug(self.vapi.cli("show session verbose"))
 421         self.thru_host_stack_tear_down()
 422         super(VCLThruHostStackEcho, self).tearDown()
 423
 424
 425 class VCLThruHostStackTLS(VCLTestCase):
 426     """ VCL Thru Host Stack TLS """
 427
 428     @classmethod
 429     def setUpClass(cls):
 430         super(VCLThruHostStackTLS, cls).setUpClass()
 431
 432     @classmethod
 433     def tearDownClass(cls):
 434         super(VCLThruHostStackTLS, cls).tearDownClass()
 435
 436     def setUp(self):
 437         super(VCLThruHostStackTLS, self).setUp()
 438
 439         self.thru_host_stack_setup()
 440         self.client_uni_dir_tls_timeout = 20
 441         self.server_tls_args = ["-S", self.server_port]
 442         self.client_uni_dir_tls_test_args = ["-N", "1000", "-U", "-X", "-S",
 443                                              self.loop0.local_ip4,
 444                                              self.server_port]
 445
 446     def test_vcl_thru_host_stack_tls_uni_dir(self):
 447         """ run VCL thru host stack uni-directional TLS test """
 448
 449         self.timeout = self.client_uni_dir_tls_timeout
 450         self.thru_host_stack_test("vcl_test_server", self.server_tls_args,
 451                                   "vcl_test_client",
 452                                   self.client_uni_dir_tls_test_args)
 453
 454     def tearDown(self):
 455         self.logger.debug(self.vapi.cli("show app server"))
 456         self.logger.debug(self.vapi.cli("show session verbose 2"))
 457         self.thru_host_stack_tear_down()
 458         super(VCLThruHostStackTLS, self).tearDown()
 459
 460
 461 class VCLThruHostStackBidirNsock(VCLTestCase):
 462     """ VCL Thru Host Stack Bidir Nsock """
 463
 464     @classmethod
 465     def setUpClass(cls):
 466         super(VCLThruHostStackBidirNsock, cls).setUpClass()
 467
 468     @classmethod
 469     def tearDownClass(cls):
 470         super(VCLThruHostStackBidirNsock, cls).tearDownClass()
 471
 472     def setUp(self):
 473         super(VCLThruHostStackBidirNsock, self).setUp()
 474
 475         self.thru_host_stack_setup()
 476         self.client_bi_dir_nsock_timeout = 20
 477         self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 478                                               "-I", "2",
 479                                               self.loop0.local_ip4,
 480                                               self.server_port]
 481         self.client_echo_test_args = ["-E", self.echo_phrase, "-X",
 482                                       self.loop0.local_ip4,
 483                                       self.server_port]
 484
 485     def tearDown(self):
 486         self.thru_host_stack_tear_down()
 487         super(VCLThruHostStackBidirNsock, self).tearDown()
 488
 489     def test_vcl_thru_host_stack_bi_dir_nsock(self):
 490         """ run VCL thru host stack bi-directional (multiple sockets) test """
 491
 492         self.timeout = self.client_bi_dir_nsock_timeout
 493         self.thru_host_stack_test("vcl_test_server", self.server_args,
 494                                   "vcl_test_client",
 495                                   self.client_bi_dir_nsock_test_args)
 496
 497
 498 class LDPThruHostStackBidirNsock(VCLTestCase):
 499     """ LDP Thru Host Stack Bidir Nsock """
 500
 501     @classmethod
 502     def setUpClass(cls):
 503         super(LDPThruHostStackBidirNsock, cls).setUpClass()
 504
 505     @classmethod
 506     def tearDownClass(cls):
 507         super(LDPThruHostStackBidirNsock, cls).tearDownClass()
 508
 509     def setUp(self):
 510         super(LDPThruHostStackBidirNsock, self).setUp()
 511
 512         self.thru_host_stack_setup()
 513         if self.vppDebug:
 514             self.client_bi_dir_nsock_timeout = 20
 515             self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 516                                                   # OUCH! Host Stack Bug?
 517                                                   # "-I", "2",
 518                                                   self.loop0.local_ip4,
 519                                                   self.server_port]
 520         else:
 521             self.client_bi_dir_nsock_timeout = 20
 522             self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 523                                                   # OUCH! Host Stack Bug?
 524                                                   # "-I", "2",
 525                                                   self.loop0.local_ip4,
 526                                                   self.server_port]
 527
 528     def tearDown(self):
 529         self.thru_host_stack_tear_down()
 530         super(LDPThruHostStackBidirNsock, self).tearDown()
 531
 532     def test_ldp_thru_host_stack_bi_dir_nsock(self):
 533         """ run LDP thru host stack bi-directional (multiple sockets) test """
 534
 535         self.timeout = self.client_bi_dir_nsock_timeout
 536         self.thru_host_stack_test("sock_test_server", self.server_args,
 537                                   "sock_test_client",
 538                                   self.client_bi_dir_nsock_test_args)
 539
 540
 541 class LDPThruHostStackNsock(VCLTestCase):
 542     """ LDP Thru Host Stack Nsock """
 543
 544     @classmethod
 545     def setUpClass(cls):
 546         super(LDPThruHostStackNsock, cls).setUpClass()
 547
 548     @classmethod
 549     def tearDownClass(cls):
 550         super(LDPThruHostStackNsock, cls).tearDownClass()
 551
 552     def setUp(self):
 553         super(LDPThruHostStackNsock, self).setUp()
 554
 555         self.thru_host_stack_setup()
 556         if self.vppDebug:
 557             self.client_uni_dir_nsock_timeout = 20
 558             self.numSockets = "2"
 559         else:
 560             self.client_uni_dir_nsock_timeout = 20
 561             self.numSockets = "5"
 562
 563         self.client_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 564                                                "-I", self.numSockets,
 565                                                self.loop0.local_ip4,
 566                                                self.server_port]
 567
 568     def tearDown(self):
 569         self.thru_host_stack_tear_down()
 570         super(LDPThruHostStackNsock, self).tearDown()
 571
 572     def test_ldp_thru_host_stack_uni_dir_nsock(self):
 573         """ run LDP thru host stack uni-directional (multiple sockets) test """
 574
 575         self.timeout = self.client_uni_dir_nsock_timeout
 576         self.thru_host_stack_test("sock_test_server", self.server_args,
 577                                   "sock_test_client",
 578                                   self.client_uni_dir_nsock_test_args)
 579
 580
 581 class VCLThruHostStackNsock(VCLTestCase):
 582     """ VCL Thru Host Stack Nsock """
 583
 584     @classmethod
 585     def setUpClass(cls):
 586         super(VCLThruHostStackNsock, cls).setUpClass()
 587
 588     @classmethod
 589     def tearDownClass(cls):
 590         super(VCLThruHostStackNsock, cls).tearDownClass()
 591
 592     def setUp(self):
 593         super(VCLThruHostStackNsock, self).setUp()
 594
 595         self.thru_host_stack_setup()
 596         if self.vppDebug:
 597             self.client_uni_dir_nsock_timeout = 20
 598             self.numSockets = "2"
 599         else:
 600             self.client_uni_dir_nsock_timeout = 20
 601             self.numSockets = "5"
 602
 603         self.client_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 604                                                "-I", self.numSockets,
 605                                                self.loop0.local_ip4,
 606                                                self.server_port]
 607
 608     def tearDown(self):
 609         self.thru_host_stack_tear_down()
 610         super(VCLThruHostStackNsock, self).tearDown()
 611
 612     def test_vcl_thru_host_stack_uni_dir_nsock(self):
 613         """ run VCL thru host stack uni-directional (multiple sockets) test """
 614
 615         self.timeout = self.client_uni_dir_nsock_timeout
 616         self.thru_host_stack_test("vcl_test_server", self.server_args,
 617                                   "vcl_test_client",
 618                                   self.client_uni_dir_nsock_test_args)
 619
 620
 621 class LDPThruHostStackIperf(VCLTestCase):
 622     """ LDP Thru Host Stack Iperf  """
 623
 624     @classmethod
 625     def setUpClass(cls):
 626         super(LDPThruHostStackIperf, cls).setUpClass()
 627
 628     @classmethod
 629     def tearDownClass(cls):
 630         super(LDPThruHostStackIperf, cls).tearDownClass()
 631
 632     def setUp(self):
 633         super(LDPThruHostStackIperf, self).setUp()
 634
 635         self.thru_host_stack_setup()
 636         self.client_iperf3_timeout = 20
 637         self.client_iperf3_args = ["-V4d", "-t 2", "-c", self.loop0.local_ip4]
 638         self.server_iperf3_args = ["-V4d", "-s"]
 639
 640     def tearDown(self):
 641         self.logger.debug(self.vapi.cli("show session verbose 2"))
 642         self.thru_host_stack_tear_down()
 643         super(LDPThruHostStackIperf, self).tearDown()
 644
 645     def test_ldp_thru_host_stack_iperf3(self):
 646         """ run LDP thru host stack iperf3 test """
 647
 648         try:
 649             subprocess.check_output(['iperf3', '-v'])
 650         except subprocess.CalledProcessError:
 651             self.logger.error("WARNING: 'iperf3' is not installed,")
 652             self.logger.error(
 653                 "         'test_ldp_thru_host_stack_iperf3' not run!")
 654             return
 655
 656         self.timeout = self.client_iperf3_timeout
 657         self.thru_host_stack_test("iperf3", self.server_iperf3_args,
 658                                   "iperf3", self.client_iperf3_args)
 659
 660
 661 class LDPIpv6CutThruTestCase(VCLTestCase):
 662     """ LDP IPv6 Cut Thru Tests """
 663
 664     @classmethod
 665     def setUpClass(cls):
 666         super(LDPIpv6CutThruTestCase, cls).setUpClass()
 667
 668     @classmethod
 669     def tearDownClass(cls):
 670         super(LDPIpv6CutThruTestCase, cls).tearDownClass()
 671
 672     def setUp(self):
 673         super(LDPIpv6CutThruTestCase, self).setUp()
 674
 675         self.cut_thru_setup()
 676         self.client_iperf3_timeout = 20
 677         self.client_uni_dir_nsock_timeout = 20
 678         self.client_bi_dir_nsock_timeout = 20
 679         self.client_ipv6_echo_test_args = ["-6", "-E", self.echo_phrase, "-X",
 680                                            self.server_ipv6_addr,
 681                                            self.server_port]
 682         self.client_ipv6_iperf3_args = ["-V6d", "-t 2", "-c",
 683                                         self.server_ipv6_addr]
 684         self.server_ipv6_iperf3_args = ["-V6d", "-s"]
 685         self.client_ipv6_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 686                                                     "-6",
 687                                                     "-I", "2",
 688                                                     self.server_ipv6_addr,
 689                                                     self.server_port]
 690         self.client_ipv6_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 691                                                    "-6",
 692                                                    "-I", "2",
 693                                                    self.server_ipv6_addr,
 694                                                    self.server_port]
 695
 696     def tearDown(self):
 697         self.cut_thru_tear_down()
 698
 699         super(LDPIpv6CutThruTestCase, self).tearDown()
 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         self.cut_thru_tear_down()
 777
 778         super(VCLIpv6CutThruTestCase, self).tearDown()
 779
 780     def test_vcl_ipv6_cut_thru_echo(self):
 781         """ run VCL IPv6 cut thru echo test """
 782
 783         self.cut_thru_test("vcl_test_server",
 784                            self.server_ipv6_args,
 785                            "vcl_test_client",
 786                            self.client_ipv6_echo_test_args)
 787
 788     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 789     def test_vcl_ipv6_cut_thru_uni_dir_nsock(self):
 790         """ run VCL IPv6 cut thru uni-directional (multiple sockets) test """
 791
 792         self.timeout = self.client_uni_dir_nsock_timeout
 793         self.cut_thru_test("vcl_test_server", self.server_ipv6_args,
 794                            "vcl_test_client",
 795                            self.client_ipv6_uni_dir_nsock_test_args)
 796
 797     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 798     def test_vcl_ipv6_cut_thru_bi_dir_nsock(self):
 799         """ run VCL IPv6 cut thru bi-directional (multiple sockets) test """
 800
 801         self.timeout = self.client_bi_dir_nsock_timeout
 802         self.cut_thru_test("vcl_test_server", self.server_ipv6_args,
 803                            "vcl_test_client",
 804                            self.client_ipv6_bi_dir_nsock_test_args)
 805
 806
 807 class VCLIpv6ThruHostStackEcho(VCLTestCase):
 808     """ VCL IPv6 Thru Host Stack Echo """
 809
 810     @classmethod
 811     def setUpClass(cls):
 812         super(VCLIpv6ThruHostStackEcho, cls).setUpClass()
 813
 814     @classmethod
 815     def tearDownClass(cls):
 816         super(VCLIpv6ThruHostStackEcho, cls).tearDownClass()
 817
 818     def setUp(self):
 819         super(VCLIpv6ThruHostStackEcho, self).setUp()
 820
 821         self.thru_host_stack_ipv6_setup()
 822         self.client_ipv6_echo_test_args = ["-6", "-E", self.echo_phrase, "-X",
 823                                            self.loop0.local_ip6,
 824                                            self.server_port]
 825
 826     def tearDown(self):
 827         self.thru_host_stack_ipv6_tear_down()
 828         super(VCLIpv6ThruHostStackEcho, self).tearDown()
 829
 830     def test_vcl_ipv6_thru_host_stack_echo(self):
 831         """ run VCL IPv6 thru host stack echo test """
 832
 833         self.thru_host_stack_test("vcl_test_server",
 834                                   self.server_ipv6_args,
 835                                   "vcl_test_client",
 836                                   self.client_ipv6_echo_test_args)
 837
 838
 839 if __name__ == '__main__':
 840     unittest.main(testRunner=VppTestRunner)