tests/unit/benchmark/scenarios/networking/test_pktgen.py

   1 #!/usr/bin/env python
   2
   3 ##############################################################################
   4 # Copyright (c) 2015 Ericsson AB and others.
   5 #
   6 # All rights reserved. This program and the accompanying materials
   7 # are made available under the terms of the Apache License, Version 2.0
   8 # which accompanies this distribution, and is available at
   9 # http://www.apache.org/licenses/LICENSE-2.0
  10 ##############################################################################
  11
  12 # Unittest for yardstick.benchmark.scenarios.networking.pktgen.Pktgen
  13
  14 from __future__ import absolute_import
  15
  16 import unittest
  17
  18 import mock
  19 from oslo_serialization import jsonutils
  20
  21 from yardstick.benchmark.scenarios.networking import pktgen
  22
  23
  24 @mock.patch('yardstick.benchmark.scenarios.networking.pktgen.ssh')
  25 class PktgenTestCase(unittest.TestCase):
  26
  27     def setUp(self):
  28         self.ctx = {
  29             'host': {
  30                 'ip': '172.16.0.137',
  31                 'user': 'root',
  32                 'key_filename': 'mykey.key'
  33             },
  34             'target': {
  35                 'ip': '172.16.0.138',
  36                 'user': 'root',
  37                 'key_filename': 'mykey.key',
  38                 'ipaddr': '172.16.0.138'
  39             }
  40         }
  41
  42     def test_pktgen_successful_setup(self, mock_ssh):
  43
  44         args = {
  45             'options': {'packetsize': 60},
  46         }
  47         p = pktgen.Pktgen(args, self.ctx)
  48         p.setup()
  49
  50         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
  51         self.assertIsNotNone(p.server)
  52         self.assertIsNotNone(p.client)
  53         self.assertEqual(p.setup_done, True)
  54
  55     def test_pktgen_successful_iptables_setup(self, mock_ssh):
  56
  57         args = {
  58             'options': {'packetsize': 60, 'number_of_ports': 10},
  59         }
  60         p = pktgen.Pktgen(args, self.ctx)
  61         p.server = mock_ssh.SSH.from_node()
  62         p.number_of_ports = args['options']['number_of_ports']
  63
  64         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
  65
  66         p._iptables_setup()
  67
  68         mock_ssh.SSH.from_node().execute.assert_called_with(
  69             "sudo iptables -F; "
  70             "sudo iptables -A INPUT -p udp --dport 1000:%s -j DROP"
  71             % 1010, timeout=60)
  72
  73     def test_pktgen_unsuccessful_iptables_setup(self, mock_ssh):
  74
  75         args = {
  76             'options': {'packetsize': 60, 'number_of_ports': 10},
  77         }
  78
  79         p = pktgen.Pktgen(args, self.ctx)
  80         p.server = mock_ssh.SSH.from_node()
  81         p.number_of_ports = args['options']['number_of_ports']
  82
  83         mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
  84         self.assertRaises(RuntimeError, p._iptables_setup)
  85
  86     def test_pktgen_successful_iptables_get_result(self, mock_ssh):
  87
  88         args = {
  89             'options': {'packetsize': 60, 'number_of_ports': 10},
  90         }
  91
  92         p = pktgen.Pktgen(args, self.ctx)
  93         p.server = mock_ssh.SSH.from_node()
  94         p.number_of_ports = args['options']['number_of_ports']
  95
  96         mock_ssh.SSH.from_node().execute.return_value = (0, '150000', '')
  97         p._iptables_get_result()
  98
  99         mock_ssh.SSH.from_node().execute.assert_called_with(
 100             "sudo iptables -L INPUT -vnx |"
 101             "awk '/dpts:1000:%s/ {{printf \"%%s\", $1}}'"
 102             % 1010)
 103
 104     def test_pktgen_unsuccessful_iptables_get_result(self, mock_ssh):
 105
 106         args = {
 107             'options': {'packetsize': 60, 'number_of_ports': 10},
 108         }
 109
 110         p = pktgen.Pktgen(args, self.ctx)
 111
 112         p.server = mock_ssh.SSH.from_node()
 113         p.number_of_ports = args['options']['number_of_ports']
 114
 115         mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
 116         self.assertRaises(RuntimeError, p._iptables_get_result)
 117
 118     def test_pktgen_successful_no_sla(self, mock_ssh):
 119
 120         args = {
 121             'options': {'packetsize': 60, 'number_of_ports': 10},
 122         }
 123         result = {}
 124
 125         p = pktgen.Pktgen(args, self.ctx)
 126
 127         p.server = mock_ssh.SSH.from_node()
 128         p.client = mock_ssh.SSH.from_node()
 129
 130         mock_iptables_result = mock.Mock()
 131         mock_iptables_result.return_value = 149300
 132         p._iptables_get_result = mock_iptables_result
 133
 134         sample_output = '{"packets_per_second": 9753, "errors": 0, \
 135             "packets_sent": 149776, "packetsize": 60, "flows": 110, "ppm": 3179}'
 136         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 137
 138         p.run(result)
 139         expected_result = jsonutils.loads(sample_output)
 140         expected_result["packets_received"] = 149300
 141         expected_result["packetsize"] = 60
 142         self.assertEqual(result, expected_result)
 143
 144     def test_pktgen_successful_sla(self, mock_ssh):
 145
 146         args = {
 147             'options': {'packetsize': 60, 'number_of_ports': 10},
 148             'sla': {'max_ppm': 10000}
 149         }
 150         result = {}
 151
 152         p = pktgen.Pktgen(args, self.ctx)
 153
 154         p.server = mock_ssh.SSH.from_node()
 155         p.client = mock_ssh.SSH.from_node()
 156
 157         mock_iptables_result = mock.Mock()
 158         mock_iptables_result.return_value = 149300
 159         p._iptables_get_result = mock_iptables_result
 160
 161         sample_output = '{"packets_per_second": 9753, "errors": 0, \
 162             "packets_sent": 149776, "packetsize": 60, "flows": 110, "ppm": 3179}'
 163         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 164
 165         p.run(result)
 166         expected_result = jsonutils.loads(sample_output)
 167         expected_result["packets_received"] = 149300
 168         expected_result["packetsize"] = 60
 169         self.assertEqual(result, expected_result)
 170
 171     def test_pktgen_unsuccessful_sla(self, mock_ssh):
 172
 173         args = {
 174             'options': {'packetsize': 60, 'number_of_ports': 10},
 175             'sla': {'max_ppm': 1000}
 176         }
 177         result = {}
 178
 179         p = pktgen.Pktgen(args, self.ctx)
 180
 181         p.server = mock_ssh.SSH.from_node()
 182         p.client = mock_ssh.SSH.from_node()
 183
 184         mock_iptables_result = mock.Mock()
 185         mock_iptables_result.return_value = 149300
 186         p._iptables_get_result = mock_iptables_result
 187
 188         sample_output = '{"packets_per_second": 9753, "errors": 0, \
 189             "packets_sent": 149776, "packetsize": 60, "flows": 110}'
 190         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 191         self.assertRaises(AssertionError, p.run, result)
 192
 193     def test_pktgen_unsuccessful_script_error(self, mock_ssh):
 194
 195         args = {
 196             'options': {'packetsize': 60, 'number_of_ports': 10},
 197             'sla': {'max_ppm': 1000}
 198         }
 199         result = {}
 200
 201         p = pktgen.Pktgen(args, self.ctx)
 202
 203         p.server = mock_ssh.SSH.from_node()
 204         p.client = mock_ssh.SSH.from_node()
 205
 206         mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
 207         self.assertRaises(RuntimeError, p.run, result)
 208
 209     def test_pktgen_get_vnic_driver_name(self, mock_ssh):
 210         args = {
 211             'options': {'packetsize': 60},
 212         }
 213         p = pktgen.Pktgen(args, self.ctx)
 214         p.server = mock_ssh.SSH.from_node()
 215
 216         mock_ssh.SSH.from_node().execute.return_value = (0, 'ixgbevf', '')
 217
 218         vnic_driver_name = p._get_vnic_driver_name()
 219         self.assertEqual(vnic_driver_name, 'ixgbevf')
 220
 221     def test_pktgen_unsuccessful_get_vnic_driver_name(self, mock_ssh):
 222         args = {
 223             'options': {'packetsize': 60},
 224         }
 225         p = pktgen.Pktgen(args, self.ctx)
 226         p.server = mock_ssh.SSH.from_node()
 227
 228         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 229
 230         self.assertRaises(RuntimeError, p._get_vnic_driver_name)
 231
 232     def test_pktgen_get_sriov_queue_number(self, mock_ssh):
 233         args = {
 234             'options': {'packetsize': 60},
 235         }
 236         p = pktgen.Pktgen(args, self.ctx)
 237         p.server = mock_ssh.SSH.from_node()
 238
 239         mock_ssh.SSH.from_node().execute.return_value = (0, '2', '')
 240
 241         p.queue_number = p._get_sriov_queue_number()
 242         self.assertEqual(p.queue_number, 2)
 243
 244     def test_pktgen_unsuccessful_get_sriov_queue_number(self, mock_ssh):
 245         args = {
 246             'options': {'packetsize': 60},
 247         }
 248         p = pktgen.Pktgen(args, self.ctx)
 249         p.server = mock_ssh.SSH.from_node()
 250
 251         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 252
 253         self.assertRaises(RuntimeError, p._get_sriov_queue_number)
 254
 255     def test_pktgen_get_available_queue_number(self, mock_ssh):
 256         args = {
 257             'options': {'packetsize': 60},
 258         }
 259         p = pktgen.Pktgen(args, self.ctx)
 260         p.server = mock_ssh.SSH.from_node()
 261
 262         mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
 263
 264         p._get_available_queue_number()
 265
 266         mock_ssh.SSH.from_node().execute.assert_called_with(
 267             "sudo ethtool -l eth0 | grep Combined | head -1 |" \
 268             "awk '{printf $2}'")
 269
 270     def test_pktgen_unsuccessful_get_available_queue_number(self, mock_ssh):
 271         args = {
 272             'options': {'packetsize': 60},
 273         }
 274         p = pktgen.Pktgen(args, self.ctx)
 275         p.server = mock_ssh.SSH.from_node()
 276
 277         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 278
 279         self.assertRaises(RuntimeError, p._get_available_queue_number)
 280
 281     def test_pktgen_get_usable_queue_number(self, mock_ssh):
 282         args = {
 283             'options': {'packetsize': 60},
 284         }
 285         p = pktgen.Pktgen(args, self.ctx)
 286         p.server = mock_ssh.SSH.from_node()
 287
 288         mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
 289
 290         p._get_usable_queue_number()
 291
 292         mock_ssh.SSH.from_node().execute.assert_called_with(
 293             "sudo ethtool -l eth0 | grep Combined | tail -1 |" \
 294             "awk '{printf $2}'")
 295
 296     def test_pktgen_unsuccessful_get_usable_queue_number(self, mock_ssh):
 297         args = {
 298             'options': {'packetsize': 60},
 299         }
 300         p = pktgen.Pktgen(args, self.ctx)
 301         p.server = mock_ssh.SSH.from_node()
 302
 303         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 304
 305         self.assertRaises(RuntimeError, p._get_usable_queue_number)
 306
 307     def test_pktgen_enable_ovs_multiqueue(self, mock_ssh):
 308         args = {
 309             'options': {'packetsize': 60},
 310         }
 311         p = pktgen.Pktgen(args, self.ctx)
 312         p.server = mock_ssh.SSH.from_node()
 313         p.client = mock_ssh.SSH.from_node()
 314
 315         mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
 316
 317         mock_result1 = mock.Mock()
 318         mock_result1.return_value = 1
 319         p._get_usable_queue_number = mock_result1
 320
 321         mock_result2 = mock.Mock()
 322         mock_result2.return_value = 4
 323         p._get_available_queue_number = mock_result2
 324
 325         p.queue_number = p._enable_ovs_multiqueue()
 326         self.assertEqual(p.queue_number, 4)
 327
 328     def test_pktgen_enable_ovs_multiqueue_1q(self, mock_ssh):
 329         args = {
 330             'options': {'packetsize': 60},
 331         }
 332         p = pktgen.Pktgen(args, self.ctx)
 333         p.server = mock_ssh.SSH.from_node()
 334         p.client = mock_ssh.SSH.from_node()
 335
 336         mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
 337
 338         mock_result1 = mock.Mock()
 339         mock_result1.return_value = 1
 340         p._get_usable_queue_number = mock_result1
 341
 342         mock_result2 = mock.Mock()
 343         mock_result2.return_value = 1
 344         p._get_available_queue_number = mock_result2
 345
 346         p.queue_number = p._enable_ovs_multiqueue()
 347         self.assertEqual(p.queue_number, 1)
 348
 349     def test_pktgen_unsuccessful_enable_ovs_multiqueue(self, mock_ssh):
 350         args = {
 351             'options': {'packetsize': 60},
 352         }
 353         p = pktgen.Pktgen(args, self.ctx)
 354         p.server = mock_ssh.SSH.from_node()
 355         p.client = mock_ssh.SSH.from_node()
 356
 357         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 358
 359         mock_result1 = mock.Mock()
 360         mock_result1.return_value = 1
 361         p._get_usable_queue_number = mock_result1
 362
 363         mock_result2 = mock.Mock()
 364         mock_result2.return_value = 4
 365         p._get_available_queue_number = mock_result2
 366
 367         self.assertRaises(RuntimeError, p._enable_ovs_multiqueue)
 368
 369     def test_pktgen_setup_irqmapping_ovs(self, mock_ssh):
 370         args = {
 371             'options': {'packetsize': 60},
 372         }
 373         p = pktgen.Pktgen(args, self.ctx)
 374         p.server = mock_ssh.SSH.from_node()
 375         p.client = mock_ssh.SSH.from_node()
 376
 377         mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
 378
 379         p._setup_irqmapping_ovs(4)
 380
 381         mock_ssh.SSH.from_node().execute.assert_called_with(
 382             "echo 8 | sudo tee /proc/irq/10/smp_affinity")
 383
 384     def test_pktgen_setup_irqmapping_ovs_1q(self, mock_ssh):
 385         args = {
 386             'options': {'packetsize': 60},
 387         }
 388         p = pktgen.Pktgen(args, self.ctx)
 389         p.server = mock_ssh.SSH.from_node()
 390         p.client = mock_ssh.SSH.from_node()
 391
 392         mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
 393
 394         p._setup_irqmapping_ovs(1)
 395
 396         mock_ssh.SSH.from_node().execute.assert_called_with(
 397             "echo 1 | sudo tee /proc/irq/10/smp_affinity")
 398
 399     def test_pktgen_unsuccessful_setup_irqmapping_ovs(self, mock_ssh):
 400         args = {
 401             'options': {'packetsize': 60},
 402         }
 403         p = pktgen.Pktgen(args, self.ctx)
 404         p.server = mock_ssh.SSH.from_node()
 405         p.client = mock_ssh.SSH.from_node()
 406
 407         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 408
 409         self.assertRaises(RuntimeError, p._setup_irqmapping_ovs, 4)
 410
 411     def test_pktgen_unsuccessful_setup_irqmapping_ovs_1q(self, mock_ssh):
 412         args = {
 413             'options': {'packetsize': 60},
 414         }
 415         p = pktgen.Pktgen(args, self.ctx)
 416         p.server = mock_ssh.SSH.from_node()
 417         p.client = mock_ssh.SSH.from_node()
 418
 419         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 420
 421         self.assertRaises(RuntimeError, p._setup_irqmapping_ovs, 1)
 422
 423     def test_pktgen_setup_irqmapping_sriov(self, mock_ssh):
 424         args = {
 425             'options': {'packetsize': 60},
 426         }
 427         p = pktgen.Pktgen(args, self.ctx)
 428         p.server = mock_ssh.SSH.from_node()
 429         p.client = mock_ssh.SSH.from_node()
 430
 431         mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
 432
 433         p._setup_irqmapping_sriov(2)
 434
 435         mock_ssh.SSH.from_node().execute.assert_called_with(
 436             "echo 2 | sudo tee /proc/irq/10/smp_affinity")
 437
 438     def test_pktgen_setup_irqmapping_sriov_1q(self, mock_ssh):
 439         args = {
 440             'options': {'packetsize': 60},
 441         }
 442         p = pktgen.Pktgen(args, self.ctx)
 443         p.server = mock_ssh.SSH.from_node()
 444         p.client = mock_ssh.SSH.from_node()
 445
 446         mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
 447
 448         p._setup_irqmapping_sriov(1)
 449
 450         mock_ssh.SSH.from_node().execute.assert_called_with(
 451             "echo 1 | sudo tee /proc/irq/10/smp_affinity")
 452
 453     def test_pktgen_unsuccessful_setup_irqmapping_sriov(self, mock_ssh):
 454         args = {
 455             'options': {'packetsize': 60},
 456         }
 457         p = pktgen.Pktgen(args, self.ctx)
 458         p.server = mock_ssh.SSH.from_node()
 459         p.client = mock_ssh.SSH.from_node()
 460
 461         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 462
 463         self.assertRaises(RuntimeError, p._setup_irqmapping_sriov, 2)
 464
 465     def test_pktgen_unsuccessful_setup_irqmapping_sriov_1q(self, mock_ssh):
 466         args = {
 467             'options': {'packetsize': 60},
 468         }
 469         p = pktgen.Pktgen(args, self.ctx)
 470         p.server = mock_ssh.SSH.from_node()
 471         p.client = mock_ssh.SSH.from_node()
 472
 473         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 474
 475         self.assertRaises(RuntimeError, p._setup_irqmapping_sriov, 1)
 476
 477     def test_pktgen_is_irqbalance_disabled(self, mock_ssh):
 478         args = {
 479             'options': {'packetsize': 60},
 480         }
 481         p = pktgen.Pktgen(args, self.ctx)
 482         p.server = mock_ssh.SSH.from_node()
 483
 484         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 485
 486         p._is_irqbalance_disabled()
 487
 488         mock_ssh.SSH.from_node().execute.assert_called_with(
 489             "grep ENABLED /etc/default/irqbalance")
 490
 491     def test_pktgen_unsuccessful_is_irqbalance_disabled(self, mock_ssh):
 492         args = {
 493             'options': {'packetsize': 60},
 494         }
 495         p = pktgen.Pktgen(args, self.ctx)
 496         p.server = mock_ssh.SSH.from_node()
 497
 498         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 499
 500         self.assertRaises(RuntimeError, p._is_irqbalance_disabled)
 501
 502     def test_pktgen_disable_irqbalance(self, mock_ssh):
 503         args = {
 504             'options': {'packetsize': 60},
 505         }
 506         p = pktgen.Pktgen(args, self.ctx)
 507         p.server = mock_ssh.SSH.from_node()
 508         p.client = mock_ssh.SSH.from_node()
 509
 510         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 511
 512         p._disable_irqbalance()
 513
 514         mock_ssh.SSH.from_node().execute.assert_called_with(
 515             "sudo service irqbalance disable")
 516
 517     def test_pktgen_unsuccessful_disable_irqbalance(self, mock_ssh):
 518         args = {
 519             'options': {'packetsize': 60},
 520         }
 521         p = pktgen.Pktgen(args, self.ctx)
 522         p.server = mock_ssh.SSH.from_node()
 523         p.client = mock_ssh.SSH.from_node()
 524
 525         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 526
 527         self.assertRaises(RuntimeError, p._disable_irqbalance)
 528
 529     def test_pktgen_multiqueue_setup_ovs(self, mock_ssh):
 530         args = {
 531             'options': {'packetsize': 60, 'multiqueue': True},
 532         }
 533         p = pktgen.Pktgen(args, self.ctx)
 534         p.server = mock_ssh.SSH.from_node()
 535         p.client = mock_ssh.SSH.from_node()
 536
 537         mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
 538
 539         mock_result1 = mock.Mock()
 540         mock_result1.return_value = False
 541         p._is_irqbalance_disabled = mock_result1
 542
 543         mock_result2 = mock.Mock()
 544         mock_result2.return_value = "virtio_net"
 545         p._get_vnic_driver_name = mock_result2
 546
 547         mock_result3 = mock.Mock()
 548         mock_result3.return_value = 1
 549         p._get_usable_queue_number = mock_result3
 550
 551         mock_result4 = mock.Mock()
 552         mock_result4.return_value = 4
 553         p._get_available_queue_number = mock_result4
 554
 555         p.multiqueue_setup()
 556
 557         self.assertEqual(p.queue_number, 4)
 558
 559     def test_pktgen_multiqueue_setup_ovs_1q(self, mock_ssh):
 560         args = {
 561             'options': {'packetsize': 60, 'multiqueue': True},
 562         }
 563         p = pktgen.Pktgen(args, self.ctx)
 564         p.server = mock_ssh.SSH.from_node()
 565         p.client = mock_ssh.SSH.from_node()
 566
 567         mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
 568
 569         mock_result1 = mock.Mock()
 570         mock_result1.return_value = False
 571         p._is_irqbalance_disabled = mock_result1
 572
 573         mock_result2 = mock.Mock()
 574         mock_result2.return_value = "virtio_net"
 575         p._get_vnic_driver_name = mock_result2
 576
 577         mock_result3 = mock.Mock()
 578         mock_result3.return_value = 1
 579         p._get_usable_queue_number = mock_result3
 580
 581         mock_result4 = mock.Mock()
 582         mock_result4.return_value = 1
 583         p._get_available_queue_number = mock_result4
 584
 585         p.multiqueue_setup()
 586
 587         self.assertEqual(p.queue_number, 1)
 588
 589     def test_pktgen_multiqueue_setup_sriov(self, mock_ssh):
 590         args = {
 591             'options': {'packetsize': 60, 'multiqueue': True},
 592         }
 593         p = pktgen.Pktgen(args, self.ctx)
 594         p.server = mock_ssh.SSH.from_node()
 595         p.client = mock_ssh.SSH.from_node()
 596
 597         mock_ssh.SSH.from_node().execute.return_value = (0, '2', '')
 598
 599         mock_result1 = mock.Mock()
 600         mock_result1.return_value = False
 601         p._is_irqbalance_disabled = mock_result1
 602
 603         mock_result2 = mock.Mock()
 604         mock_result2.return_value = "ixgbevf"
 605         p._get_vnic_driver_name = mock_result2
 606
 607         p.multiqueue_setup()
 608
 609         self.assertEqual(p.queue_number, 2)
 610
 611     def test_pktgen_multiqueue_setup_sriov_1q(self, mock_ssh):
 612         args = {
 613             'options': {'packetsize': 60, 'multiqueue': True},
 614         }
 615         p = pktgen.Pktgen(args, self.ctx)
 616         p.server = mock_ssh.SSH.from_node()
 617         p.client = mock_ssh.SSH.from_node()
 618
 619         mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
 620
 621         mock_result1 = mock.Mock()
 622         mock_result1.return_value = False
 623         p._is_irqbalance_disabled = mock_result1
 624
 625         mock_result2 = mock.Mock()
 626         mock_result2.return_value = "ixgbevf"
 627         p._get_vnic_driver_name = mock_result2
 628
 629         p.multiqueue_setup()
 630
 631         self.assertEqual(p.queue_number, 1)
 632
 633     def test_pktgen_run_with_setup_done(self, mock_ssh):
 634         args = {
 635             'options': {'packetsize': 60, 'number_of_ports': 10, 'duration': 20, 'multiqueue': True},
 636             'sla': {'max_ppm': 1}
 637         }
 638         result = {}
 639         p = pktgen.Pktgen(args, self.ctx)
 640         p.server = mock_ssh.SSH.from_node()
 641         p.client = mock_ssh.SSH.from_node()
 642
 643         p.setup_done = True
 644         p.multiqueue_setup_done = True
 645
 646         mock_iptables_result = mock.Mock()
 647         mock_iptables_result.return_value = 149300
 648         p._iptables_get_result = mock_iptables_result
 649
 650         sample_output = '{"packets_per_second": 9753, "errors": 0, \
 651             "packets_sent": 149300, "flows": 110, "ppm": 0}'
 652         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 653
 654         p.run(result)
 655         expected_result = jsonutils.loads(sample_output)
 656         expected_result["packets_received"] = 149300
 657         expected_result["packetsize"] = 60
 658         self.assertEqual(result, expected_result)
 659
 660     def test_pktgen_run_with_ovs_multiqueque(self, mock_ssh):
 661         args = {
 662             'options': {'packetsize': 60, 'number_of_ports': 10, 'duration': 20, 'multiqueue': True},
 663             'sla': {'max_ppm': 1}
 664         }
 665         result = {}
 666
 667         p = pktgen.Pktgen(args, self.ctx)
 668
 669         p.server = mock_ssh.SSH.from_node()
 670         p.client = mock_ssh.SSH.from_node()
 671
 672         mock_result = mock.Mock()
 673         mock_result.return_value = "virtio_net"
 674         p._get_vnic_driver_name = mock_result
 675
 676         mock_result1 = mock.Mock()
 677         mock_result1.return_value = 1
 678         p._get_usable_queue_number = mock_result1
 679
 680         mock_result2 = mock.Mock()
 681         mock_result2.return_value = 4
 682         p._get_available_queue_number = mock_result2
 683
 684         mock_result3 = mock.Mock()
 685         mock_result3.return_value = 4
 686         p._enable_ovs_multiqueue  = mock_result3
 687
 688         mock_result4 = mock.Mock()
 689         p._setup_irqmapping_ovs = mock_result4
 690
 691         mock_iptables_result = mock.Mock()
 692         mock_iptables_result.return_value = 149300
 693         p._iptables_get_result = mock_iptables_result
 694
 695         sample_output = '{"packets_per_second": 9753, "errors": 0, \
 696             "packets_sent": 149300, "flows": 110, "ppm": 0}'
 697         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 698
 699         p.run(result)
 700         expected_result = jsonutils.loads(sample_output)
 701         expected_result["packets_received"] = 149300
 702         expected_result["packetsize"] = 60
 703         self.assertEqual(result, expected_result)
 704
 705     def test_pktgen_run_with_sriov_multiqueque(self, mock_ssh):
 706         args = {
 707             'options': {'packetsize': 60, 'number_of_ports': 10, 'duration': 20, 'multiqueue': True},
 708             'sla': {'max_ppm': 1}
 709         }
 710         result = {}
 711
 712         p = pktgen.Pktgen(args, self.ctx)
 713
 714         p.server = mock_ssh.SSH.from_node()
 715         p.client = mock_ssh.SSH.from_node()
 716
 717         mock_result1 = mock.Mock()
 718         mock_result1.return_value = "ixgbevf"
 719         p._get_vnic_driver_name = mock_result1
 720
 721         mock_result2 = mock.Mock()
 722         mock_result2.return_value = 2
 723         p._get_sriov_queue_number = mock_result2
 724
 725         mock_result3 = mock.Mock()
 726         p._setup_irqmapping_sriov = mock_result3
 727
 728         mock_iptables_result = mock.Mock()
 729         mock_iptables_result.return_value = 149300
 730         p._iptables_get_result = mock_iptables_result
 731
 732         sample_output = '{"packets_per_second": 9753, "errors": 0, \
 733             "packets_sent": 149300, "flows": 110, "ppm": 0}'
 734         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 735
 736         p.run(result)
 737         expected_result = jsonutils.loads(sample_output)
 738         expected_result["packets_received"] = 149300
 739         expected_result["packetsize"] = 60
 740         self.assertEqual(result, expected_result)
 741
 742 def main():
 743     unittest.main()
 744
 745 if __name__ == '__main__':
 746     main()