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

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