src/vcl/test/test_vcl.py

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