test/test_vcl.py

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