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