1 ##############################################################################
2 # Copyright (c) 2015 Ericsson AB and others.
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 ##############################################################################
13 from oslo_serialization import jsonutils
15 from yardstick.benchmark.scenarios.networking import pktgen
18 @mock.patch('yardstick.benchmark.scenarios.networking.pktgen.ssh')
19 class PktgenTestCase(unittest.TestCase):
26 'key_filename': 'mykey.key'
31 'key_filename': 'mykey.key',
32 'ipaddr': '172.16.0.138'
36 def test_pktgen_successful_setup(self, mock_ssh):
39 'options': {'packetsize': 60},
41 p = pktgen.Pktgen(args, self.ctx)
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)
49 def test_pktgen_successful_iptables_setup(self, mock_ssh):
52 'options': {'packetsize': 60, 'number_of_ports': 10},
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']
58 mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
62 mock_ssh.SSH.from_node().execute.assert_called_with(
64 "sudo iptables -A INPUT -p udp --dport 1000:%s -j DROP"
67 def test_pktgen_unsuccessful_iptables_setup(self, mock_ssh):
70 'options': {'packetsize': 60, 'number_of_ports': 10},
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']
77 mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
78 self.assertRaises(RuntimeError, p._iptables_setup)
80 def test_pktgen_successful_iptables_get_result(self, mock_ssh):
83 'options': {'packetsize': 60, 'number_of_ports': 10},
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']
90 mock_ssh.SSH.from_node().execute.return_value = (0, '150000', '')
91 p._iptables_get_result()
93 mock_ssh.SSH.from_node().execute.assert_called_with(
94 "sudo iptables -L INPUT -vnx |"
95 "awk '/dpts:1000:%s/ {{printf \"%%s\", $1}}'"
98 def test_pktgen_unsuccessful_iptables_get_result(self, mock_ssh):
101 'options': {'packetsize': 60, 'number_of_ports': 10},
104 p = pktgen.Pktgen(args, self.ctx)
106 p.server = mock_ssh.SSH.from_node()
107 p.number_of_ports = args['options']['number_of_ports']
109 mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
110 self.assertRaises(RuntimeError, p._iptables_get_result)
112 def test_pktgen_successful_no_sla(self, mock_ssh):
115 'options': {'packetsize': 60, 'number_of_ports': 10},
119 p = pktgen.Pktgen(args, self.ctx)
121 p.server = mock_ssh.SSH.from_node()
122 p.client = mock_ssh.SSH.from_node()
124 p._iptables_get_result = mock.Mock(return_value=149300)
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, '')
131 expected_result = jsonutils.loads(sample_output)
132 expected_result["packets_received"] = 149300
133 expected_result["packetsize"] = 60
134 self.assertEqual(result, expected_result)
136 def test_pktgen_successful_sla(self, mock_ssh):
139 'options': {'packetsize': 60, 'number_of_ports': 10},
140 'sla': {'max_ppm': 10000}
144 p = pktgen.Pktgen(args, self.ctx)
146 p.server = mock_ssh.SSH.from_node()
147 p.client = mock_ssh.SSH.from_node()
149 p._iptables_get_result = mock.Mock(return_value=149300)
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, '')
156 expected_result = jsonutils.loads(sample_output)
157 expected_result["packets_received"] = 149300
158 expected_result["packetsize"] = 60
159 self.assertEqual(result, expected_result)
161 def test_pktgen_unsuccessful_sla(self, mock_ssh):
164 'options': {'packetsize': 60, 'number_of_ports': 10},
165 'sla': {'max_ppm': 1000}
169 p = pktgen.Pktgen(args, self.ctx)
171 p.server = mock_ssh.SSH.from_node()
172 p.client = mock_ssh.SSH.from_node()
174 p._iptables_get_result = mock.Mock(return_value=149300)
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)
181 def test_pktgen_unsuccessful_script_error(self, mock_ssh):
184 'options': {'packetsize': 60, 'number_of_ports': 10},
185 'sla': {'max_ppm': 1000}
189 p = pktgen.Pktgen(args, self.ctx)
191 p.server = mock_ssh.SSH.from_node()
192 p.client = mock_ssh.SSH.from_node()
194 mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
195 self.assertRaises(RuntimeError, p.run, result)
197 def test_pktgen_get_vnic_driver_name(self, mock_ssh):
199 'options': {'packetsize': 60},
201 p = pktgen.Pktgen(args, self.ctx)
202 p.server = mock_ssh.SSH.from_node()
204 mock_ssh.SSH.from_node().execute.return_value = (0, 'ixgbevf', '')
206 vnic_driver_name = p._get_vnic_driver_name()
207 self.assertEqual(vnic_driver_name, 'ixgbevf')
209 def test_pktgen_unsuccessful_get_vnic_driver_name(self, mock_ssh):
211 'options': {'packetsize': 60},
213 p = pktgen.Pktgen(args, self.ctx)
214 p.server = mock_ssh.SSH.from_node()
216 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
218 self.assertRaises(RuntimeError, p._get_vnic_driver_name)
220 def test_pktgen_get_sriov_queue_number(self, mock_ssh):
222 'options': {'packetsize': 60},
224 p = pktgen.Pktgen(args, self.ctx)
225 p.server = mock_ssh.SSH.from_node()
227 mock_ssh.SSH.from_node().execute.return_value = (0, '2', '')
229 p.queue_number = p._get_sriov_queue_number()
230 self.assertEqual(p.queue_number, 2)
232 def test_pktgen_unsuccessful_get_sriov_queue_number(self, mock_ssh):
234 'options': {'packetsize': 60},
236 p = pktgen.Pktgen(args, self.ctx)
237 p.server = mock_ssh.SSH.from_node()
239 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
241 self.assertRaises(RuntimeError, p._get_sriov_queue_number)
243 def test_pktgen_get_available_queue_number(self, mock_ssh):
245 'options': {'packetsize': 60},
247 p = pktgen.Pktgen(args, self.ctx)
248 p.server = mock_ssh.SSH.from_node()
250 mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
252 p._get_available_queue_number()
254 mock_ssh.SSH.from_node().execute.assert_called_with(
255 "sudo ethtool -l eth0 | grep Combined | head -1 |"
258 def test_pktgen_unsuccessful_get_available_queue_number(self, mock_ssh):
260 'options': {'packetsize': 60},
262 p = pktgen.Pktgen(args, self.ctx)
263 p.server = mock_ssh.SSH.from_node()
265 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
267 self.assertRaises(RuntimeError, p._get_available_queue_number)
269 def test_pktgen_get_usable_queue_number(self, mock_ssh):
271 'options': {'packetsize': 60},
273 p = pktgen.Pktgen(args, self.ctx)
274 p.server = mock_ssh.SSH.from_node()
276 mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
278 p._get_usable_queue_number()
280 mock_ssh.SSH.from_node().execute.assert_called_with(
281 "sudo ethtool -l eth0 | grep Combined | tail -1 |"
284 def test_pktgen_unsuccessful_get_usable_queue_number(self, mock_ssh):
286 'options': {'packetsize': 60},
288 p = pktgen.Pktgen(args, self.ctx)
289 p.server = mock_ssh.SSH.from_node()
291 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
293 self.assertRaises(RuntimeError, p._get_usable_queue_number)
295 def test_pktgen_enable_ovs_multiqueue(self, mock_ssh):
297 'options': {'packetsize': 60},
299 p = pktgen.Pktgen(args, self.ctx)
300 p.server = mock_ssh.SSH.from_node()
301 p.client = mock_ssh.SSH.from_node()
303 mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
305 p._get_usable_queue_number = mock.Mock(return_value=1)
306 p._get_available_queue_number = mock.Mock(return_value=4)
308 p.queue_number = p._enable_ovs_multiqueue()
309 self.assertEqual(p.queue_number, 4)
311 def test_pktgen_enable_ovs_multiqueue_1q(self, mock_ssh):
313 'options': {'packetsize': 60},
315 p = pktgen.Pktgen(args, self.ctx)
316 p.server = mock_ssh.SSH.from_node()
317 p.client = mock_ssh.SSH.from_node()
319 mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
321 p._get_usable_queue_number = mock.Mock(return_value=1)
322 p._get_available_queue_number = mock.Mock(return_value=1)
324 p.queue_number = p._enable_ovs_multiqueue()
325 self.assertEqual(p.queue_number, 1)
327 def test_pktgen_unsuccessful_enable_ovs_multiqueue(self, mock_ssh):
329 'options': {'packetsize': 60},
331 p = pktgen.Pktgen(args, self.ctx)
332 p.server = mock_ssh.SSH.from_node()
333 p.client = mock_ssh.SSH.from_node()
335 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
337 p._get_usable_queue_number = mock.Mock(return_value=1)
338 p._get_available_queue_number = mock.Mock(return_value=4)
340 self.assertRaises(RuntimeError, p._enable_ovs_multiqueue)
342 def test_pktgen_setup_irqmapping_ovs(self, mock_ssh):
344 'options': {'packetsize': 60},
346 p = pktgen.Pktgen(args, self.ctx)
347 p.server = mock_ssh.SSH.from_node()
348 p.client = mock_ssh.SSH.from_node()
350 mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
352 p._setup_irqmapping_ovs(4)
354 mock_ssh.SSH.from_node().execute.assert_called_with(
355 "echo 8 | sudo tee /proc/irq/10/smp_affinity")
357 def test_pktgen_setup_irqmapping_ovs_1q(self, mock_ssh):
359 'options': {'packetsize': 60},
361 p = pktgen.Pktgen(args, self.ctx)
362 p.server = mock_ssh.SSH.from_node()
363 p.client = mock_ssh.SSH.from_node()
365 mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
367 p._setup_irqmapping_ovs(1)
369 mock_ssh.SSH.from_node().execute.assert_called_with(
370 "echo 1 | sudo tee /proc/irq/10/smp_affinity")
372 def test_pktgen_unsuccessful_setup_irqmapping_ovs(self, mock_ssh):
374 'options': {'packetsize': 60},
376 p = pktgen.Pktgen(args, self.ctx)
377 p.server = mock_ssh.SSH.from_node()
378 p.client = mock_ssh.SSH.from_node()
380 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
382 self.assertRaises(RuntimeError, p._setup_irqmapping_ovs, 4)
384 def test_pktgen_unsuccessful_setup_irqmapping_ovs_1q(self, mock_ssh):
386 'options': {'packetsize': 60},
388 p = pktgen.Pktgen(args, self.ctx)
389 p.server = mock_ssh.SSH.from_node()
390 p.client = mock_ssh.SSH.from_node()
392 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
394 self.assertRaises(RuntimeError, p._setup_irqmapping_ovs, 1)
396 def test_pktgen_setup_irqmapping_sriov(self, mock_ssh):
398 'options': {'packetsize': 60},
400 p = pktgen.Pktgen(args, self.ctx)
401 p.server = mock_ssh.SSH.from_node()
402 p.client = mock_ssh.SSH.from_node()
404 mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
406 p._setup_irqmapping_sriov(2)
408 mock_ssh.SSH.from_node().execute.assert_called_with(
409 "echo 2 | sudo tee /proc/irq/10/smp_affinity")
411 def test_pktgen_setup_irqmapping_sriov_1q(self, mock_ssh):
413 'options': {'packetsize': 60},
415 p = pktgen.Pktgen(args, self.ctx)
416 p.server = mock_ssh.SSH.from_node()
417 p.client = mock_ssh.SSH.from_node()
419 mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
421 p._setup_irqmapping_sriov(1)
423 mock_ssh.SSH.from_node().execute.assert_called_with(
424 "echo 1 | sudo tee /proc/irq/10/smp_affinity")
426 def test_pktgen_unsuccessful_setup_irqmapping_sriov(self, mock_ssh):
428 'options': {'packetsize': 60},
430 p = pktgen.Pktgen(args, self.ctx)
431 p.server = mock_ssh.SSH.from_node()
432 p.client = mock_ssh.SSH.from_node()
434 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
436 self.assertRaises(RuntimeError, p._setup_irqmapping_sriov, 2)
438 def test_pktgen_unsuccessful_setup_irqmapping_sriov_1q(self, mock_ssh):
440 'options': {'packetsize': 60},
442 p = pktgen.Pktgen(args, self.ctx)
443 p.server = mock_ssh.SSH.from_node()
444 p.client = mock_ssh.SSH.from_node()
446 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
448 self.assertRaises(RuntimeError, p._setup_irqmapping_sriov, 1)
450 def test_pktgen_is_irqbalance_disabled(self, mock_ssh):
452 'options': {'packetsize': 60},
454 p = pktgen.Pktgen(args, self.ctx)
455 p.server = mock_ssh.SSH.from_node()
457 mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
459 p._is_irqbalance_disabled()
461 mock_ssh.SSH.from_node().execute.assert_called_with(
462 "grep ENABLED /etc/default/irqbalance")
464 def test_pktgen_unsuccessful_is_irqbalance_disabled(self, mock_ssh):
466 'options': {'packetsize': 60},
468 p = pktgen.Pktgen(args, self.ctx)
469 p.server = mock_ssh.SSH.from_node()
471 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
473 self.assertRaises(RuntimeError, p._is_irqbalance_disabled)
475 def test_pktgen_disable_irqbalance(self, mock_ssh):
477 'options': {'packetsize': 60},
479 p = pktgen.Pktgen(args, self.ctx)
480 p.server = mock_ssh.SSH.from_node()
481 p.client = mock_ssh.SSH.from_node()
483 mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
485 p._disable_irqbalance()
487 mock_ssh.SSH.from_node().execute.assert_called_with(
488 "sudo service irqbalance disable")
490 def test_pktgen_unsuccessful_disable_irqbalance(self, mock_ssh):
492 'options': {'packetsize': 60},
494 p = pktgen.Pktgen(args, self.ctx)
495 p.server = mock_ssh.SSH.from_node()
496 p.client = mock_ssh.SSH.from_node()
498 mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
500 self.assertRaises(RuntimeError, p._disable_irqbalance)
502 def test_pktgen_multiqueue_setup_ovs(self, mock_ssh):
504 'options': {'packetsize': 60, 'multiqueue': True},
506 p = pktgen.Pktgen(args, self.ctx)
507 p.server = mock_ssh.SSH.from_node()
508 p.client = mock_ssh.SSH.from_node()
510 mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
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)
519 self.assertEqual(p.queue_number, 4)
521 def test_pktgen_multiqueue_setup_ovs_1q(self, mock_ssh):
523 'options': {'packetsize': 60, 'multiqueue': True},
525 p = pktgen.Pktgen(args, self.ctx)
526 p.server = mock_ssh.SSH.from_node()
527 p.client = mock_ssh.SSH.from_node()
529 mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
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)
538 self.assertEqual(p.queue_number, 1)
540 def test_pktgen_multiqueue_setup_sriov(self, mock_ssh):
542 'options': {'packetsize': 60, 'multiqueue': True},
544 p = pktgen.Pktgen(args, self.ctx)
545 p.server = mock_ssh.SSH.from_node()
546 p.client = mock_ssh.SSH.from_node()
548 mock_ssh.SSH.from_node().execute.return_value = (0, '2', '')
550 p._is_irqbalance_disabled = mock.Mock(return_value=False)
551 p._get_vnic_driver_name = mock.Mock(return_value="ixgbevf")
555 self.assertEqual(p.queue_number, 2)
557 def test_pktgen_multiqueue_setup_sriov_1q(self, mock_ssh):
559 'options': {'packetsize': 60, 'multiqueue': True},
561 p = pktgen.Pktgen(args, self.ctx)
562 p.server = mock_ssh.SSH.from_node()
563 p.client = mock_ssh.SSH.from_node()
565 mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
567 p._is_irqbalance_disabled = mock.Mock(return_value=False)
568 p._get_vnic_driver_name = mock.Mock(return_value="ixgbevf")
572 self.assertEqual(p.queue_number, 1)
574 def test_pktgen_run_with_setup_done(self, mock_ssh):
578 'number_of_ports': 10,
584 p = pktgen.Pktgen(args, self.ctx)
585 p.server = mock_ssh.SSH.from_node()
586 p.client = mock_ssh.SSH.from_node()
589 p.multiqueue_setup_done = True
591 mock_iptables_result = mock.Mock()
592 mock_iptables_result.return_value = 149300
593 p._iptables_get_result = mock_iptables_result
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, '')
600 expected_result = jsonutils.loads(sample_output)
601 expected_result["packets_received"] = 149300
602 expected_result["packetsize"] = 60
603 self.assertEqual(result, expected_result)
605 def test_pktgen_run_with_ovs_multiqueque(self, mock_ssh):
609 'number_of_ports': 10,
616 p = pktgen.Pktgen(args, self.ctx)
618 p.server = mock_ssh.SSH.from_node()
619 p.client = mock_ssh.SSH.from_node()
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)
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, '')
633 expected_result = jsonutils.loads(sample_output)
634 expected_result["packets_received"] = 149300
635 expected_result["packetsize"] = 60
636 self.assertEqual(result, expected_result)
638 def test_pktgen_run_with_sriov_multiqueque(self, mock_ssh):
642 'number_of_ports': 10,
649 p = pktgen.Pktgen(args, self.ctx)
651 p.server = mock_ssh.SSH.from_node()
652 p.client = mock_ssh.SSH.from_node()
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)
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, '')
664 expected_result = jsonutils.loads(sample_output)
665 expected_result["packets_received"] = 149300
666 expected_result["packetsize"] = 60
667 self.assertEqual(result, expected_result)
674 if __name__ == '__main__':