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 ##############################################################################
14 from oslo_serialization import jsonutils
16 from yardstick import ssh
17 from yardstick.benchmark.scenarios.networking import pktgen
18 from yardstick.common import exceptions as y_exc
21 logging.disable(logging.CRITICAL)
24 class PktgenTestCase(unittest.TestCase):
31 'key_filename': 'mykey.key'
36 'key_filename': 'mykey.key',
37 'ipaddr': '172.16.0.138'
41 'options': {'packetsize': 60}
44 self._mock_SSH = mock.patch.object(ssh, 'SSH')
45 self.mock_SSH = self._mock_SSH.start()
47 self.mock_SSH.from_node().execute.return_value = (0, '', '')
48 self.mock_SSH.from_node().run.return_value = 0
50 self.addCleanup(self._stop_mock)
52 self.scenario = pktgen.Pktgen(self.scenario_cfg, self.context_cfg)
58 def test_setup_successful(self):
59 self.assertIsNotNone(self.scenario.server)
60 self.assertIsNotNone(self.scenario.client)
61 self.assertTrue(self.scenario.setup_done)
63 def test_iptables_setup_successful(self):
64 self.scenario.number_of_ports = 10
65 self.scenario._iptables_setup()
67 self.mock_SSH.from_node().run.assert_called_with(
69 "sudo iptables -A INPUT -p udp --dport 1000:%s -j DROP"
72 def test_iptables_setup_unsuccessful(self):
73 self.scenario.number_of_ports = 10
74 self.mock_SSH.from_node().run.side_effect = y_exc.SSHError
76 with self.assertRaises(y_exc.SSHError):
77 self.scenario._iptables_setup()
79 def test_iptables_get_result_successful(self):
80 self.scenario.number_of_ports = 10
81 self.mock_SSH.from_node().execute.return_value = (0, '150000', '')
83 result = self.scenario._iptables_get_result()
85 self.assertEqual(result, 150000)
86 self.mock_SSH.from_node().execute.assert_called_with(
87 "sudo iptables -L INPUT -vnx |"
88 "awk '/dpts:1000:%s/ {{printf \"%%s\", $1}}'"
89 % 1010, raise_on_error=True)
91 def test_iptables_get_result_unsuccessful(self):
92 self.scenario.number_of_ports = 10
93 self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
95 with self.assertRaises(y_exc.SSHError):
96 self.scenario._iptables_get_result()
98 def test_run_successful_no_sla(self):
99 self.scenario._iptables_get_result = mock.Mock(return_value=149300)
100 sample_output = jsonutils.dumps({"packets_per_second": 9753,
102 "packets_sent": 149776,
106 self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
109 self.scenario.run(result)
111 expected_result = jsonutils.loads(sample_output)
112 expected_result["packets_received"] = 149300
113 expected_result["packetsize"] = 60
114 self.assertEqual(result, expected_result)
116 def test_run_successful_sla(self):
117 self.scenario_cfg['sla'] = {'max_ppm': 10000}
118 scenario = pktgen.Pktgen(self.scenario_cfg, self.context_cfg)
120 scenario._iptables_get_result = mock.Mock(return_value=149300)
121 sample_output = jsonutils.dumps({"packets_per_second": 9753,
123 "packets_sent": 149776,
127 self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
132 expected_result = jsonutils.loads(sample_output)
133 expected_result["packets_received"] = 149300
134 expected_result["packetsize"] = 60
135 self.assertEqual(result, expected_result)
137 def test_run_unsuccessful_sla(self):
138 self.scenario_cfg['sla'] = {'max_ppm': 1000}
139 scenario = pktgen.Pktgen(self.scenario_cfg, self.context_cfg)
141 scenario._iptables_get_result = mock.Mock(return_value=149300)
142 sample_output = jsonutils.dumps({"packets_per_second": 9753,
144 "packets_sent": 149776,
147 self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
149 with self.assertRaises(y_exc.SLAValidationError):
152 def test_run_ssh_error_not_caught(self):
153 self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
155 with self.assertRaises(y_exc.SSHError):
156 self.scenario.run({})
158 def test_get_vnic_driver_name(self):
159 self.mock_SSH.from_node().execute.return_value = (0, 'ixgbevf', '')
160 vnic_driver_name = self.scenario._get_vnic_driver_name()
162 self.assertEqual(vnic_driver_name, 'ixgbevf')
164 def test_get_vnic_driver_name_unsuccessful(self):
165 self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
167 with self.assertRaises(y_exc.SSHError):
168 self.scenario._get_vnic_driver_name()
170 def test_get_sriov_queue_number(self):
171 self.mock_SSH.from_node().execute.return_value = (0, '2', '')
173 self.scenario.queue_number = self.scenario._get_sriov_queue_number()
174 self.assertEqual(self.scenario.queue_number, 2)
176 def test_get_sriov_queue_number_unsuccessful(self):
177 self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
179 with self.assertRaises(y_exc.SSHError):
180 self.scenario._get_sriov_queue_number()
182 def test_get_available_queue_number(self):
183 self.mock_SSH.from_node().execute.return_value = (0, '4', '')
185 self.assertEqual(self.scenario._get_available_queue_number(), 4)
186 self.mock_SSH.from_node().execute.assert_called_with(
187 "sudo ethtool -l eth0 | grep Combined | head -1 |"
188 "awk '{printf $2}'", raise_on_error=True)
190 def test_get_available_queue_number_unsuccessful(self):
191 self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
193 with self.assertRaises(y_exc.SSHError):
194 self.scenario._get_available_queue_number()
196 def test_get_usable_queue_number(self):
197 self.mock_SSH.from_node().execute.return_value = (0, '1', '')
199 self.assertEqual(self.scenario._get_usable_queue_number(), 1)
200 self.mock_SSH.from_node().execute.assert_called_with(
201 "sudo ethtool -l eth0 | grep Combined | tail -1 |"
202 "awk '{printf $2}'", raise_on_error=True)
204 def test_get_usable_queue_number_unsuccessful(self):
205 self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
207 with self.assertRaises(y_exc.SSHError):
208 self.scenario._get_usable_queue_number()
210 def test_enable_ovs_multiqueue(self):
211 self.scenario._get_usable_queue_number = mock.Mock(return_value=1)
212 self.scenario._get_available_queue_number = mock.Mock(return_value=4)
213 self.scenario.queue_number = self.scenario._enable_ovs_multiqueue()
215 self.assertEqual(self.scenario.queue_number, 4)
216 self.mock_SSH.from_node().run.assert_has_calls(
217 (mock.call("sudo ethtool -L eth0 combined 4"),
218 mock.call("sudo ethtool -L eth0 combined 4")))
220 def test_enable_ovs_multiqueue_1q(self):
221 self.scenario._get_usable_queue_number = mock.Mock(return_value=1)
222 self.scenario._get_available_queue_number = mock.Mock(return_value=1)
223 self.scenario.queue_number = self.scenario._enable_ovs_multiqueue()
225 self.assertEqual(self.scenario.queue_number, 1)
226 self.mock_SSH.from_node().run.assert_not_called()
228 def test_enable_ovs_multiqueue_unsuccessful(self):
229 self.mock_SSH.from_node().run.side_effect = y_exc.SSHError
230 self.scenario._get_usable_queue_number = mock.Mock(return_value=1)
231 self.scenario._get_available_queue_number = mock.Mock(return_value=4)
233 with self.assertRaises(y_exc.SSHError):
234 self.scenario._enable_ovs_multiqueue()
236 def test_setup_irqmapping_ovs(self):
237 self.mock_SSH.from_node().execute.return_value = (0, '10', '')
238 self.scenario._setup_irqmapping_ovs(4)
240 self.mock_SSH.from_node().run.assert_called_with(
241 "echo 8 | sudo tee /proc/irq/10/smp_affinity")
243 def test_setup_irqmapping_ovs_1q(self):
244 self.mock_SSH.from_node().execute.return_value = (0, '10', '')
245 self.scenario._setup_irqmapping_ovs(1)
247 self.mock_SSH.from_node().run.assert_called_with(
248 "echo 1 | sudo tee /proc/irq/10/smp_affinity")
250 def test_setup_irqmapping_ovs_unsuccessful(self):
251 self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
253 with self.assertRaises(y_exc.SSHError):
254 self.scenario._setup_irqmapping_ovs(4)
256 def test_setup_irqmapping_ovs_1q_unsuccessful(self):
257 self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
259 with self.assertRaises(y_exc.SSHError):
260 self.scenario._setup_irqmapping_ovs(1)
262 def test_setup_irqmapping_sriov(self):
263 self.mock_SSH.from_node().execute.return_value = (0, '10', '')
264 self.scenario._setup_irqmapping_sriov(2)
266 self.mock_SSH.from_node().run.assert_called_with(
267 "echo 2 | sudo tee /proc/irq/10/smp_affinity")
269 def test_setup_irqmapping_sriov_1q(self):
270 self.mock_SSH.from_node().execute.return_value = (0, '10', '')
271 self.scenario._setup_irqmapping_sriov(1)
273 self.mock_SSH.from_node().run.assert_called_with(
274 "echo 1 | sudo tee /proc/irq/10/smp_affinity")
276 def test_setup_irqmapping_sriov_unsuccessful(self):
277 self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
279 with self.assertRaises(y_exc.SSHError):
280 self.scenario._setup_irqmapping_sriov(2)
282 def test_setup_irqmapping_sriov_1q_unsuccessful(self):
283 self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
285 with self.assertRaises(y_exc.SSHError):
286 self.scenario._setup_irqmapping_sriov(1)
288 def test_is_irqbalance_disabled(self):
289 self.mock_SSH.from_node().execute.return_value = (0, '', '')
291 self.assertFalse(self.scenario._is_irqbalance_disabled())
292 self.mock_SSH.from_node().execute.assert_called_with(
293 "grep ENABLED /etc/default/irqbalance", raise_on_error=True)
295 def test_is_irqbalance_disabled_unsuccessful(self):
296 self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
298 with self.assertRaises(y_exc.SSHError):
299 self.scenario._is_irqbalance_disabled()
301 def test_disable_irqbalance(self):
302 self.scenario._disable_irqbalance()
304 self.mock_SSH.from_node().run.assert_called_with(
305 "sudo service irqbalance disable")
307 def test_disable_irqbalance_unsuccessful(self):
308 self.mock_SSH.from_node().run.side_effect = y_exc.SSHError
310 with self.assertRaises(y_exc.SSHError):
311 self.scenario._disable_irqbalance()
313 def test_multiqueue_setup_ovs(self):
314 self.mock_SSH.from_node().execute.return_value = (0, '4', '')
315 self.scenario._is_irqbalance_disabled = mock.Mock(return_value=False)
316 self.scenario._get_vnic_driver_name = mock.Mock(
317 return_value="virtio_net")
318 self.scenario._get_usable_queue_number = mock.Mock(return_value=1)
319 self.scenario._get_available_queue_number = mock.Mock(return_value=4)
321 self.scenario.multiqueue_setup()
323 self.assertEqual(self.scenario.queue_number, 4)
324 self.assertTrue(self.scenario.multiqueue_setup_done)
326 def test_multiqueue_setup_ovs_1q(self):
327 self.mock_SSH.from_node().execute.return_value = (0, '1', '')
328 self.scenario._is_irqbalance_disabled = mock.Mock(return_value=False)
329 self.scenario._get_vnic_driver_name = mock.Mock(
330 return_value="virtio_net")
331 self.scenario._get_usable_queue_number = mock.Mock(return_value=1)
332 self.scenario._get_available_queue_number = mock.Mock(return_value=1)
334 self.scenario.multiqueue_setup()
336 self.assertEqual(self.scenario.queue_number, 1)
337 self.assertTrue(self.scenario.multiqueue_setup_done)
339 def test_multiqueue_setup_sriov(self):
340 self.mock_SSH.from_node().execute.return_value = (0, '2', '')
341 self.scenario._is_irqbalance_disabled = mock.Mock(return_value=False)
342 self.scenario._get_vnic_driver_name = mock.Mock(return_value="ixgbevf")
344 self.scenario.multiqueue_setup()
346 self.assertEqual(self.scenario.queue_number, 2)
347 self.assertTrue(self.scenario.multiqueue_setup_done)
349 def test_multiqueue_setup_sriov_1q(self):
350 self.mock_SSH.from_node().execute.return_value = (0, '1', '')
351 self.scenario._is_irqbalance_disabled = mock.Mock(return_value=False)
352 self.scenario._get_vnic_driver_name = mock.Mock(return_value="ixgbevf")
354 self.scenario.multiqueue_setup()
356 self.assertEqual(self.scenario.queue_number, 1)
357 self.assertTrue(self.scenario.multiqueue_setup_done)
359 def test_run_with_setup_done(self):
363 'number_of_ports': 10,
369 scenario = pktgen.Pktgen(scenario_cfg, self.context_cfg)
370 scenario.server = self.mock_SSH.from_node()
371 scenario.client = self.mock_SSH.from_node()
372 scenario.setup_done = True
373 scenario.multiqueue_setup_done = True
374 scenario._iptables_get_result = mock.Mock(return_value=149300)
376 sample_output = jsonutils.dumps({"packets_per_second": 9753,
378 "packets_sent": 149300,
381 self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
386 expected_result = jsonutils.loads(sample_output)
387 expected_result["packets_received"] = 149300
388 expected_result["packetsize"] = 60
389 self.assertEqual(result, expected_result)
391 def test_run_with_ovs_multiqueque(self):
395 'number_of_ports': 10,
398 'sla': {'max_ppm': 1}
400 scenario = pktgen.Pktgen(scenario_cfg, self.context_cfg)
402 scenario._get_vnic_driver_name = mock.Mock(return_value="virtio_net")
403 scenario._get_usable_queue_number = mock.Mock(return_value=1)
404 scenario._get_available_queue_number = mock.Mock(return_value=4)
405 scenario._enable_ovs_multiqueue = mock.Mock(return_value=4)
406 scenario._setup_irqmapping_ovs = mock.Mock()
407 scenario._iptables_get_result = mock.Mock(return_value=149300)
409 sample_output = jsonutils.dumps({"packets_per_second": 9753,
411 "packets_sent": 149300,
414 self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
419 expected_result = jsonutils.loads(sample_output)
420 expected_result["packets_received"] = 149300
421 expected_result["packetsize"] = 60
422 self.assertEqual(result, expected_result)
424 def test_run_with_sriov_multiqueque(self):
428 'number_of_ports': 10,
431 'sla': {'max_ppm': 1}
433 scenario = pktgen.Pktgen(scenario_cfg, self.context_cfg)
435 scenario._get_vnic_driver_name = mock.Mock(return_value="ixgbevf")
436 scenario._get_sriov_queue_number = mock.Mock(return_value=2)
437 scenario._setup_irqmapping_sriov = mock.Mock()
438 scenario._iptables_get_result = mock.Mock(return_value=149300)
440 sample_output = jsonutils.dumps({"packets_per_second": 9753,
442 "packets_sent": 149300,
445 self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
450 expected_result = jsonutils.loads(sample_output)
451 expected_result["packets_received"] = 149300
452 expected_result["packetsize"] = 60
453 self.assertEqual(result, expected_result)