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         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_del(namespace_id=b"1", secret=1234,
 150                                         sw_if_index=self.loop0.sw_if_index)
 151         self.vapi.app_namespace_add_del(namespace_id=b"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.logger.debug(self.vapi.cli("show session verbose 2"))
 263         self.cut_thru_tear_down()
 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(
 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         self.cut_thru_tear_down()
 348
 349         super(VCLCutThruTestCase, self).tearDown()
 350
 351     def test_vcl_cut_thru_echo(self):
 352         """ run VCL cut thru echo test """
 353
 354         self.cut_thru_test("vcl_test_server", self.server_args,
 355                            "vcl_test_client", self.client_echo_test_args)
 356
 357     def test_vcl_cut_thru_uni_dir_nsock(self):
 358         """ run VCL cut thru uni-directional (multiple sockets) test """
 359
 360         self.timeout = self.client_uni_dir_nsock_timeout
 361         self.cut_thru_test("vcl_test_server", self.server_args,
 362                            "vcl_test_client",
 363                            self.client_uni_dir_nsock_test_args)
 364
 365     def test_vcl_cut_thru_bi_dir_nsock(self):
 366         """ run VCL cut thru bi-directional (multiple sockets) test """
 367
 368         self.timeout = self.client_bi_dir_nsock_timeout
 369         self.cut_thru_test("vcl_test_server", self.server_args,
 370                            "vcl_test_client",
 371                            self.client_bi_dir_nsock_test_args)
 372
 373
 374 class VCLThruHostStackEcho(VCLTestCase):
 375     """ VCL Thru Host Stack Echo """
 376
 377     @classmethod
 378     def setUpClass(cls):
 379         super(VCLThruHostStackEcho, cls).setUpClass()
 380
 381     @classmethod
 382     def tearDownClass(cls):
 383         super(VCLThruHostStackEcho, cls).tearDownClass()
 384
 385     def setUp(self):
 386         super(VCLThruHostStackEcho, self).setUp()
 387
 388         self.thru_host_stack_setup()
 389         self.client_bi_dir_nsock_timeout = 20
 390         self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 391                                               "-I", "2",
 392                                               self.loop0.local_ip4,
 393                                               self.server_port]
 394         self.client_echo_test_args = ["-E", self.echo_phrase, "-X",
 395                                       self.loop0.local_ip4,
 396                                       self.server_port]
 397
 398     def tearDown(self):
 399         self.logger.debug(self.vapi.cli("show app server"))
 400         self.logger.debug(self.vapi.cli("show session verbose"))
 401         self.thru_host_stack_tear_down()
 402         super(VCLThruHostStackEcho, self).tearDown()
 403
 404
 405 class VCLThruHostStackTLS(VCLTestCase):
 406     """ VCL Thru Host Stack TLS """
 407
 408     @classmethod
 409     def setUpClass(cls):
 410         super(VCLThruHostStackTLS, cls).setUpClass()
 411
 412     @classmethod
 413     def tearDownClass(cls):
 414         super(VCLThruHostStackTLS, cls).tearDownClass()
 415
 416     def setUp(self):
 417         super(VCLThruHostStackTLS, self).setUp()
 418
 419         self.thru_host_stack_setup()
 420         self.client_uni_dir_tls_timeout = 20
 421         self.server_tls_args = ["-S", self.server_port]
 422         self.client_uni_dir_tls_test_args = ["-N", "1000", "-U", "-X", "-S",
 423                                              self.loop0.local_ip4,
 424                                              self.server_port]
 425
 426     def test_vcl_thru_host_stack_tls_uni_dir(self):
 427         """ run VCL thru host stack uni-directional TLS test """
 428
 429         self.timeout = self.client_uni_dir_tls_timeout
 430         self.thru_host_stack_test("vcl_test_server", self.server_tls_args,
 431                                   "vcl_test_client",
 432                                   self.client_uni_dir_tls_test_args)
 433
 434     def tearDown(self):
 435         self.logger.debug(self.vapi.cli("show app server"))
 436         self.logger.debug(self.vapi.cli("show session verbose 2"))
 437         self.thru_host_stack_tear_down()
 438         super(VCLThruHostStackTLS, self).tearDown()
 439
 440
 441 class VCLThruHostStackBidirNsock(VCLTestCase):
 442     """ VCL Thru Host Stack Bidir Nsock """
 443
 444     @classmethod
 445     def setUpClass(cls):
 446         super(VCLThruHostStackBidirNsock, cls).setUpClass()
 447
 448     @classmethod
 449     def tearDownClass(cls):
 450         super(VCLThruHostStackBidirNsock, cls).tearDownClass()
 451
 452     def setUp(self):
 453         super(VCLThruHostStackBidirNsock, self).setUp()
 454
 455         self.thru_host_stack_setup()
 456         self.client_bi_dir_nsock_timeout = 20
 457         self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 458                                               "-I", "2",
 459                                               self.loop0.local_ip4,
 460                                               self.server_port]
 461         self.client_echo_test_args = ["-E", self.echo_phrase, "-X",
 462                                       self.loop0.local_ip4,
 463                                       self.server_port]
 464
 465     def tearDown(self):
 466         self.logger.debug(self.vapi.cli("show session verbose 2"))
 467         self.thru_host_stack_tear_down()
 468         super(VCLThruHostStackBidirNsock, self).tearDown()
 469
 470     def test_vcl_thru_host_stack_bi_dir_nsock(self):
 471         """ run VCL thru host stack bi-directional (multiple sockets) test """
 472
 473         self.timeout = self.client_bi_dir_nsock_timeout
 474         self.thru_host_stack_test("vcl_test_server", self.server_args,
 475                                   "vcl_test_client",
 476                                   self.client_bi_dir_nsock_test_args)
 477
 478
 479 class LDPThruHostStackBidirNsock(VCLTestCase):
 480     """ LDP Thru Host Stack Bidir Nsock """
 481
 482     @classmethod
 483     def setUpClass(cls):
 484         super(LDPThruHostStackBidirNsock, cls).setUpClass()
 485
 486     @classmethod
 487     def tearDownClass(cls):
 488         super(LDPThruHostStackBidirNsock, cls).tearDownClass()
 489
 490     def setUp(self):
 491         super(LDPThruHostStackBidirNsock, self).setUp()
 492
 493         self.thru_host_stack_setup()
 494         if self.vppDebug:
 495             self.client_bi_dir_nsock_timeout = 20
 496             self.client_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 497                                                   # OUCH! Host Stack Bug?
 498                                                   # "-I", "2",
 499                                                   self.loop0.local_ip4,
 500                                                   self.server_port]
 501         else:
 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
 509     def tearDown(self):
 510         self.logger.debug(self.vapi.cli("show session verbose 2"))
 511         self.thru_host_stack_tear_down()
 512         super(LDPThruHostStackBidirNsock, self).tearDown()
 513
 514     def test_ldp_thru_host_stack_bi_dir_nsock(self):
 515         """ run LDP thru host stack bi-directional (multiple sockets) test """
 516
 517         self.timeout = self.client_bi_dir_nsock_timeout
 518         self.thru_host_stack_test("sock_test_server", self.server_args,
 519                                   "sock_test_client",
 520                                   self.client_bi_dir_nsock_test_args)
 521
 522
 523 class LDPThruHostStackNsock(VCLTestCase):
 524     """ LDP Thru Host Stack Nsock """
 525
 526     @classmethod
 527     def setUpClass(cls):
 528         super(LDPThruHostStackNsock, cls).setUpClass()
 529
 530     @classmethod
 531     def tearDownClass(cls):
 532         super(LDPThruHostStackNsock, cls).tearDownClass()
 533
 534     def setUp(self):
 535         super(LDPThruHostStackNsock, self).setUp()
 536
 537         self.thru_host_stack_setup()
 538         if self.vppDebug:
 539             self.client_uni_dir_nsock_timeout = 20
 540             self.numSockets = "2"
 541         else:
 542             self.client_uni_dir_nsock_timeout = 20
 543             self.numSockets = "5"
 544
 545         self.client_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 546                                                "-I", self.numSockets,
 547                                                self.loop0.local_ip4,
 548                                                self.server_port]
 549
 550     def tearDown(self):
 551         self.thru_host_stack_tear_down()
 552         super(LDPThruHostStackNsock, self).tearDown()
 553
 554     def test_ldp_thru_host_stack_uni_dir_nsock(self):
 555         """ run LDP thru host stack uni-directional (multiple sockets) test """
 556
 557         self.timeout = self.client_uni_dir_nsock_timeout
 558         self.thru_host_stack_test("sock_test_server", self.server_args,
 559                                   "sock_test_client",
 560                                   self.client_uni_dir_nsock_test_args)
 561
 562
 563 class VCLThruHostStackNsock(VCLTestCase):
 564     """ VCL Thru Host Stack Nsock """
 565
 566     @classmethod
 567     def setUpClass(cls):
 568         super(VCLThruHostStackNsock, cls).setUpClass()
 569
 570     @classmethod
 571     def tearDownClass(cls):
 572         super(VCLThruHostStackNsock, cls).tearDownClass()
 573
 574     def setUp(self):
 575         super(VCLThruHostStackNsock, self).setUp()
 576
 577         self.thru_host_stack_setup()
 578         if self.vppDebug:
 579             self.client_uni_dir_nsock_timeout = 20
 580             self.numSockets = "2"
 581         else:
 582             self.client_uni_dir_nsock_timeout = 20
 583             self.numSockets = "5"
 584
 585         self.client_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 586                                                "-I", self.numSockets,
 587                                                self.loop0.local_ip4,
 588                                                self.server_port]
 589
 590     def tearDown(self):
 591         self.thru_host_stack_tear_down()
 592         super(VCLThruHostStackNsock, self).tearDown()
 593
 594     def test_vcl_thru_host_stack_uni_dir_nsock(self):
 595         """ run VCL thru host stack uni-directional (multiple sockets) test """
 596
 597         self.timeout = self.client_uni_dir_nsock_timeout
 598         self.thru_host_stack_test("vcl_test_server", self.server_args,
 599                                   "vcl_test_client",
 600                                   self.client_uni_dir_nsock_test_args)
 601
 602
 603 class LDPThruHostStackIperf(VCLTestCase):
 604     """ LDP Thru Host Stack Iperf  """
 605
 606     @classmethod
 607     def setUpClass(cls):
 608         super(LDPThruHostStackIperf, cls).setUpClass()
 609
 610     @classmethod
 611     def tearDownClass(cls):
 612         super(LDPThruHostStackIperf, cls).tearDownClass()
 613
 614     def setUp(self):
 615         super(LDPThruHostStackIperf, self).setUp()
 616
 617         self.thru_host_stack_setup()
 618         self.client_iperf3_timeout = 20
 619         self.client_iperf3_args = ["-V4d", "-t 2", "-c", self.loop0.local_ip4]
 620         self.server_iperf3_args = ["-V4d", "-s"]
 621
 622     def tearDown(self):
 623         self.logger.debug(self.vapi.cli("show session verbose 2"))
 624         self.thru_host_stack_tear_down()
 625         super(LDPThruHostStackIperf, self).tearDown()
 626
 627     def test_ldp_thru_host_stack_iperf3(self):
 628         """ run LDP thru host stack iperf3 test """
 629
 630         try:
 631             subprocess.check_output(['iperf3', '-v'])
 632         except subprocess.CalledProcessError:
 633             self.logger.error("WARNING: 'iperf3' is not installed,")
 634             self.logger.error(
 635                 "         'test_ldp_thru_host_stack_iperf3' not run!")
 636             return
 637         except OSError as e:
 638             self.logger.error("WARNING: 'iperf3' is not installed,")
 639             self.logger.error("         'test' not run!")
 640             return
 641         except Exception as e:
 642             self.logger.error("WARNING: 'iperf3' unexpected error,")
 643             self.logger.error("         'test' not run!")
 644             return
 645
 646         self.timeout = self.client_iperf3_timeout
 647         self.thru_host_stack_test("iperf3", self.server_iperf3_args,
 648                                   "iperf3", self.client_iperf3_args)
 649
 650
 651 class LDPIpv6CutThruTestCase(VCLTestCase):
 652     """ LDP IPv6 Cut Thru Tests """
 653
 654     @classmethod
 655     def setUpClass(cls):
 656         super(LDPIpv6CutThruTestCase, cls).setUpClass()
 657
 658     @classmethod
 659     def tearDownClass(cls):
 660         super(LDPIpv6CutThruTestCase, cls).tearDownClass()
 661
 662     def setUp(self):
 663         super(LDPIpv6CutThruTestCase, self).setUp()
 664
 665         self.cut_thru_setup()
 666         self.client_iperf3_timeout = 20
 667         self.client_uni_dir_nsock_timeout = 20
 668         self.client_bi_dir_nsock_timeout = 20
 669         self.client_ipv6_echo_test_args = ["-6", "-E", self.echo_phrase, "-X",
 670                                            self.server_ipv6_addr,
 671                                            self.server_port]
 672         self.client_ipv6_iperf3_args = ["-V6d", "-t 2", "-c",
 673                                         self.server_ipv6_addr]
 674         self.server_ipv6_iperf3_args = ["-V6d", "-s"]
 675         self.client_ipv6_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 676                                                     "-6",
 677                                                     "-I", "2",
 678                                                     self.server_ipv6_addr,
 679                                                     self.server_port]
 680         self.client_ipv6_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 681                                                    "-6",
 682                                                    "-I", "2",
 683                                                    self.server_ipv6_addr,
 684                                                    self.server_port]
 685
 686     def tearDown(self):
 687         self.cut_thru_tear_down()
 688
 689         super(LDPIpv6CutThruTestCase, self).tearDown()
 690
 691     def test_ldp_ipv6_cut_thru_echo(self):
 692         """ run LDP IPv6 cut thru echo test """
 693
 694         self.cut_thru_test("sock_test_server",
 695                            self.server_ipv6_args,
 696                            "sock_test_client",
 697                            self.client_ipv6_echo_test_args)
 698
 699     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 700     def test_ldp_ipv6_cut_thru_iperf3(self):
 701         """ run LDP IPv6 cut thru iperf3 test """
 702
 703         try:
 704             subprocess.check_output(['iperf3', '-v'])
 705         except:
 706             self.logger.error("WARNING: 'iperf3' is not installed,")
 707             self.logger.error(
 708                 "         'test_ldp_ipv6_cut_thru_iperf3' not run!")
 709             return
 710
 711         self.timeout = self.client_iperf3_timeout
 712         self.cut_thru_test("iperf3", self.server_ipv6_iperf3_args,
 713                            "iperf3", self.client_ipv6_iperf3_args)
 714
 715     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 716     def test_ldp_ipv6_cut_thru_uni_dir_nsock(self):
 717         """ run LDP IPv6 cut thru uni-directional (multiple sockets) test """
 718
 719         self.timeout = self.client_uni_dir_nsock_timeout
 720         self.cut_thru_test("sock_test_server", self.server_ipv6_args,
 721                            "sock_test_client",
 722                            self.client_ipv6_uni_dir_nsock_test_args)
 723
 724     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 725     def test_ldp_ipv6_cut_thru_bi_dir_nsock(self):
 726         """ run LDP IPv6 cut thru bi-directional (multiple sockets) test """
 727
 728         self.timeout = self.client_bi_dir_nsock_timeout
 729         self.cut_thru_test("sock_test_server", self.server_ipv6_args,
 730                            "sock_test_client",
 731                            self.client_ipv6_bi_dir_nsock_test_args)
 732
 733
 734 class VCLIpv6CutThruTestCase(VCLTestCase):
 735     """ VCL IPv6 Cut Thru Tests """
 736
 737     @classmethod
 738     def setUpClass(cls):
 739         super(VCLIpv6CutThruTestCase, cls).setUpClass()
 740
 741     @classmethod
 742     def tearDownClass(cls):
 743         super(VCLIpv6CutThruTestCase, cls).tearDownClass()
 744
 745     def setUp(self):
 746         super(VCLIpv6CutThruTestCase, self).setUp()
 747
 748         self.cut_thru_setup()
 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_uni_dir_nsock_test_args = ["-N", "1000", "-U", "-X",
 755                                                     "-6",
 756                                                     "-I", "2",
 757                                                     self.server_ipv6_addr,
 758                                                     self.server_port]
 759         self.client_ipv6_bi_dir_nsock_test_args = ["-N", "1000", "-B", "-X",
 760                                                    "-6",
 761                                                    "-I", "2",
 762                                                    self.server_ipv6_addr,
 763                                                    self.server_port]
 764
 765     def tearDown(self):
 766         self.cut_thru_tear_down()
 767
 768         super(VCLIpv6CutThruTestCase, self).tearDown()
 769
 770     def test_vcl_ipv6_cut_thru_echo(self):
 771         """ run VCL IPv6 cut thru echo test """
 772
 773         self.cut_thru_test("vcl_test_server",
 774                            self.server_ipv6_args,
 775                            "vcl_test_client",
 776                            self.client_ipv6_echo_test_args)
 777
 778     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 779     def test_vcl_ipv6_cut_thru_uni_dir_nsock(self):
 780         """ run VCL IPv6 cut thru uni-directional (multiple sockets) test """
 781
 782         self.timeout = self.client_uni_dir_nsock_timeout
 783         self.cut_thru_test("vcl_test_server", self.server_ipv6_args,
 784                            "vcl_test_client",
 785                            self.client_ipv6_uni_dir_nsock_test_args)
 786
 787     @unittest.skipUnless(running_extended_tests, "part of extended tests")
 788     def test_vcl_ipv6_cut_thru_bi_dir_nsock(self):
 789         """ run VCL IPv6 cut thru bi-directional (multiple sockets) test """
 790
 791         self.timeout = self.client_bi_dir_nsock_timeout
 792         self.cut_thru_test("vcl_test_server", self.server_ipv6_args,
 793                            "vcl_test_client",
 794                            self.client_ipv6_bi_dir_nsock_test_args)
 795
 796
 797 class VCLIpv6ThruHostStackEcho(VCLTestCase):
 798     """ VCL IPv6 Thru Host Stack Echo """
 799
 800     @classmethod
 801     def setUpClass(cls):
 802         super(VCLIpv6ThruHostStackEcho, cls).setUpClass()
 803
 804     @classmethod
 805     def tearDownClass(cls):
 806         super(VCLIpv6ThruHostStackEcho, cls).tearDownClass()
 807
 808     def setUp(self):
 809         super(VCLIpv6ThruHostStackEcho, self).setUp()
 810
 811         self.thru_host_stack_ipv6_setup()
 812         self.client_ipv6_echo_test_args = ["-6", "-E", self.echo_phrase, "-X",
 813                                            self.loop0.local_ip6,
 814                                            self.server_port]
 815
 816     def tearDown(self):
 817         self.thru_host_stack_ipv6_tear_down()
 818         super(VCLIpv6ThruHostStackEcho, self).tearDown()
 819
 820     def test_vcl_ipv6_thru_host_stack_echo(self):
 821         """ run VCL IPv6 thru host stack echo test """
 822
 823         self.thru_host_stack_test("vcl_test_server",
 824                                   self.server_ipv6_args,
 825                                   "vcl_test_client",
 826                                   self.client_ipv6_echo_test_args)
 827
 828
 829 if __name__ == '__main__':
 830     unittest.main(testRunner=VppTestRunner)