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