tests/unit/benchmark/contexts/standalone/test_sriov.py

   1 # Copyright (c) 2016-2017 Intel Corporation
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #      http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 from __future__ import absolute_import
  16
  17 import os
  18 import unittest
  19
  20 import mock
  21
  22 from yardstick.benchmark.contexts.standalone import sriov
  23
  24 NIC_INPUT = {
  25     'interface': {},
  26     'vf_macs': ['00:00:00:71:7d:25', '00:00:00:71:7d:26'],
  27     'pci': ['0000:06:00.0', '0000:06:00.1'],
  28     'phy_driver': 'i40e'}
  29 DRIVER = "i40e"
  30 NIC_DETAILS = {
  31     'interface': {0: 'enp6s0f0', 1: 'enp6s0f1'},
  32     'vf_macs': ['00:00:00:71:7d:25', '00:00:00:71:7d:26'],
  33     'pci': ['0000:06:00.0', '0000:06:00.1'],
  34     'phy_driver': 'i40e'}
  35
  36 CORRECT_FILE_PATH = "/etc/yardstick/nodes/pod_sriov.yaml"
  37 WRONG_FILE_PATH = "/etc/yardstick/wrong.yaml"
  38 SAMPLE_FILE = "sriov_sample_write_to_file.txt"
  39
  40 SRIOV = [{
  41     'auth_type': 'ssh_key',
  42     'name': 'sriov',
  43     'ssh_port': 22,
  44     'ip': '10.10.10.11',
  45     'key_filename': '/root/.ssh/id_rsa',
  46     'vf_macs': ['00:00:00:71:7d:25', '00:00:00:71:7d:26'],
  47     'role': 'Sriov',
  48     'user': 'root',
  49     'images': '/var/lib/libvirt/images/ubuntu1.img',
  50     'phy_driver': 'i40e',
  51     'phy_ports': ['0000:06:00.0', '0000:06:00.1']}]
  52
  53 SRIOV_PASSWORD = [{
  54     'auth_type': 'password',
  55     'name': 'sriov',
  56     'vf_macs': ['00:00:00:71:7d:25', '00:00:00:71:7d:26'],
  57     'ip': '10.10.10.11',
  58     'role': 'Sriov',
  59     'user': 'root',
  60     'images': '/var/lib/libvirt/images/ubuntu1.img',
  61     'phy_driver': 'i40e',
  62     'password': 'password',
  63     'phy_ports': ['0000:06:00.0', '0000:06:00.1']}]
  64
  65 vfnic = "i40evf"
  66 PCIS = ['0000:06:00.0', '0000:06:00.1']
  67
  68
  69 class SriovTestCase(unittest.TestCase):
  70
  71     NODES_SAMPLE_SSH = "sriov_sample_ssh_key.yaml"
  72     NODES_SAMPLE_PASSWORD = "sriov_sample_password.yaml"
  73
  74     def setUp(self):
  75         self.test_context = sriov.Sriov()
  76
  77     def test_construct(self):
  78         self.assertIsNone(self.test_context.name)
  79         self.assertIsNone(self.test_context.file_path)
  80         self.assertEqual(self.test_context.nodes, [])
  81         self.assertEqual(self.test_context.sriov, [])
  82         self.assertFalse(self.test_context.vm_deploy)
  83         self.assertTrue(self.test_context.first_run)
  84         self.assertEqual(self.test_context.user, "")
  85         self.assertEqual(self.test_context.ssh_ip, "")
  86         self.assertEqual(self.test_context.passwd, "")
  87         self.assertEqual(self.test_context.ssh_port, "")
  88         self.assertEqual(self.test_context.auth_type, "")
  89
  90     def test_init(self):
  91         self.test_context.parse_pod_and_get_data = mock.Mock()
  92         self.test_context.file_path = CORRECT_FILE_PATH
  93         self.test_context.init()
  94         self.assertIsNone(self.test_context.init())
  95
  96     def test_successful_init_with_ssh(self):
  97         CORRECT_FILE_PATH = self._get_file_abspath(self.NODES_SAMPLE_SSH)
  98         self.test_context.parse_pod_and_get_data(CORRECT_FILE_PATH)
  99
 100     def test_successful_init_with_password(self):
 101         CORRECT_FILE_PATH = self._get_file_abspath(self.NODES_SAMPLE_PASSWORD)
 102         self.test_context.parse_pod_and_get_data(CORRECT_FILE_PATH)
 103
 104     def test_unsuccessful_init(self):
 105         self.assertRaises(
 106             IOError,
 107             lambda: self.test_context.parse_pod_and_get_data(WRONG_FILE_PATH))
 108
 109     @mock.patch('yardstick.network_services.utils.provision_tool', return_value="a")
 110     def test_ssh_connection(self, mock_prov):
 111         with mock.patch("yardstick.ssh.SSH") as ssh:
 112             ssh_mock = mock.Mock(autospec=ssh.SSH)
 113             ssh_mock.execute = \
 114                 mock.Mock(return_value=(1, "a", ""))
 115             ssh.return_value = ssh_mock
 116             mock_prov.provision_tool = mock.Mock()
 117             sriov_obj = sriov.Sriov()
 118             sriov_obj.connection = ssh_mock
 119             sriov_obj.sriov = SRIOV_PASSWORD
 120             self.assertIsNone(sriov_obj.ssh_remote_machine())
 121
 122     @mock.patch('yardstick.network_services.utils.provision_tool', return_value="a")
 123     def test_ssh_connection_ssh_key(self, mock_prov):
 124         with mock.patch("yardstick.ssh.SSH") as ssh:
 125             ssh_mock = mock.Mock(autospec=ssh.SSH)
 126             ssh_mock.execute = \
 127                 mock.Mock(return_value=(1, "a", ""))
 128             ssh.return_value = ssh_mock
 129             mock_prov.provision_tool = mock.Mock()
 130             sriov_obj = sriov.Sriov()
 131             sriov_obj.connection = ssh_mock
 132             sriov_obj.sriov = SRIOV
 133             sriov_obj.key_filename = '/root/.ssh/id_rsa'
 134             self.assertIsNone(sriov_obj.ssh_remote_machine())
 135
 136     def test_get_nic_details(self):
 137         with mock.patch("yardstick.ssh.SSH") as ssh:
 138             ssh_mock = mock.Mock(autospec=ssh.SSH)
 139             ssh_mock.execute = \
 140                 mock.Mock(return_value=(0, "eth0 eth1", ""))
 141             ssh.return_value = ssh_mock
 142             sriov_obj = sriov.Sriov()
 143             sriov_obj.sriov = SRIOV
 144             sriov_obj.connection = ssh_mock
 145             self.assertIsNotNone(sriov_obj.get_nic_details())
 146
 147     def test_install_req_libs(self):
 148         with mock.patch("yardstick.ssh.SSH") as ssh:
 149             ssh_mock = mock.Mock(autospec=ssh.SSH)
 150             ssh_mock.execute = \
 151                 mock.Mock(return_value=(0, {}, ""))
 152             ssh.return_value = ssh_mock
 153             sriov_obj = sriov.Sriov()
 154             sriov_obj.first_run = True
 155             sriov_obj.connection = ssh_mock
 156             self.assertIsNone(sriov_obj.install_req_libs())
 157
 158     def test_configure_nics_for_sriov(self):
 159         with mock.patch("yardstick.ssh.SSH") as ssh:
 160             nic_details = {
 161                 'interface': {0: 'enp6s0f0', 1: 'enp6s0f1'},
 162                 'vf_macs': ['00:00:00:71:7d:25', '00:00:00:71:7d:26'],
 163                 'pci': ['0000:06:00.0', '0000:06:00.1'],
 164                 'phy_driver': 'i40e',
 165                 'vf_pci': [{}, {}]}
 166             ssh_mock = mock.Mock(autospec=ssh.SSH)
 167             ssh_mock.execute = \
 168                 mock.Mock((DRIVER), return_value=(0, "0 driver", ""))
 169             ssh.return_value = ssh_mock
 170             ssh_mock.execute = \
 171                 mock.Mock(return_value=(0, {}, ""))
 172             ssh.return_value = ssh_mock
 173             for i in range(len(NIC_DETAILS['pci'])):
 174                 ssh_mock.execute = \
 175                     mock.Mock(return_value=(0, {}, ""))
 176                 ssh_mock.execute = \
 177                     mock.Mock(return_value=(0, {}, ""))
 178                 sriov_obj = sriov.Sriov()
 179                 sriov_obj.connection = ssh_mock
 180                 ssh_mock.execute = \
 181                     mock.Mock(return_value=(
 182                         0,
 183                         "{'0':'06:02:00','1':'06:06:00'}",
 184                         ""))
 185                 sriov_obj.get_vf_datas = mock.Mock(return_value={
 186                     '0000:06:00.0': '0000:06:02.0'})
 187                 nic_details['vf_pci'][i] = sriov_obj.get_vf_datas.return_value
 188                 vf_pci = [[], []]
 189                 vf_pci[i] = sriov_obj.get_vf_datas.return_value
 190             with mock.patch("yardstick.benchmark.contexts.standalone.sriov.time"):
 191                 self.assertIsNotNone(sriov_obj.configure_nics_for_sriov(DRIVER, NIC_DETAILS))
 192
 193     def test_setup_sriov_context(self):
 194         with mock.patch("yardstick.ssh.SSH") as ssh:
 195             nic_details = {
 196                 'interface': {0: 'enp6s0f0', 1: 'enp6s0f1'},
 197                 'vf_macs': ['00:00:00:71:7d:25', '00:00:00:71:7d:26'],
 198                 'pci': ['0000:06:00.0', '0000:06:00.1'],
 199                 'phy_driver': 'i40e',
 200                 'vf_pci': [{'vf_pci': '06:02.00'}, {'vf_pci': '06:06.00'}]}
 201             vf = [{'vf_pci': '06:02.00'}, {'vf_pci': '06:06.00'}]
 202             ssh_mock = mock.Mock(autospec=ssh.SSH)
 203             ssh_mock.execute = \
 204                 mock.Mock(return_value=(0, {}, ""))
 205             ssh.return_value = ssh_mock
 206             sriov_obj = sriov.Sriov()
 207             sriov_obj.connection = ssh_mock
 208             sriov_obj.sriov = SRIOV
 209             blacklist = "/etc/modprobe.d/blacklist.conf"
 210             self.assertEqual(vfnic, "i40evf")
 211             mock_sriov = mock.Mock()
 212             mock_sriov.sriov_obj.read_from_file(blacklist)
 213             sriov_obj.read_from_file = mock.Mock(
 214                 return_value="some random text")
 215             ssh_mock.execute = \
 216                 mock.Mock(return_value=(0, {}, ""))
 217             sriov_obj.configure_nics_for_sriov = mock.Mock(
 218                 return_value=nic_details)
 219             nic_details = sriov_obj.configure_nics_for_sriov.return_value
 220             self.assertEqual(vf, nic_details['vf_pci'])
 221             vf = [
 222                 {'vf_pci': '06:02.00', 'mac': '00:00:00:00:00:0a'},
 223                 {'vf_pci': '06:06.00', 'mac': '00:00:00:00:00:0b'}]
 224             sriov_obj.add_sriov_interface = mock.Mock()
 225             ssh_mock.execute = \
 226                 mock.Mock(return_value=(0, {}, ""))
 227             ssh_mock.put = mock.Mock()
 228             sriov_obj.check_output = mock.Mock(return_value=(1, {}))
 229             with mock.patch("yardstick.benchmark.contexts.standalone.sriov.time"):
 230                 self.assertIsNone(sriov_obj.setup_sriov_context(PCIS, nic_details, DRIVER))
 231
 232     def test_setup_sriov_context_vm_already_present(self):
 233         with mock.patch("yardstick.ssh.SSH") as ssh:
 234             nic_details = {
 235                 'interface': {0: 'enp6s0f0', 1: 'enp6s0f1'},
 236                 'vf_macs': ['00:00:00:71:7d:25', '00:00:00:71:7d:26'],
 237                 'pci': ['0000:06:00.0', '0000:06:00.1'],
 238                 'phy_driver': 'i40e',
 239                 'vf_pci': [{'vf_pci': '06:02.00'}, {'vf_pci': '06:06.00'}]}
 240             vf = [{'vf_pci': '06:02.00'}, {'vf_pci': '06:06.00'}]
 241             ssh_mock = mock.Mock(autospec=ssh.SSH)
 242             ssh_mock.execute = \
 243                 mock.Mock(return_value=(0, {}, ""))
 244             ssh.return_value = ssh_mock
 245             sriov_obj = sriov.Sriov()
 246             sriov_obj.connection = ssh_mock
 247             sriov_obj.sriov = SRIOV
 248             blacklist = "/etc/modprobe.d/blacklist.conf"
 249             self.assertEqual(vfnic, "i40evf")
 250             mock_sriov = mock.Mock()
 251             mock_sriov.sriov_obj.read_from_file(blacklist)
 252             sriov_obj.read_from_file = mock.Mock(
 253                 return_value="some random text")
 254             ssh_mock.execute = \
 255                 mock.Mock(return_value=(0, {}, ""))
 256             sriov_obj.configure_nics_for_sriov = mock.Mock(
 257                 return_value=nic_details)
 258             nic_details = sriov_obj.configure_nics_for_sriov.return_value
 259             self.assertEqual(vf, nic_details['vf_pci'])
 260             vf = [
 261                 {'vf_pci': '06:02.00', 'mac': '00:00:00:00:00:0a'},
 262                 {'vf_pci': '06:06.00', 'mac': '00:00:00:00:00:0b'}]
 263             sriov_obj.add_sriov_interface = mock.Mock()
 264             ssh_mock.execute = \
 265                 mock.Mock(return_value=(0, {}, ""))
 266             ssh_mock.put = mock.Mock()
 267             sriov_obj.check_output = mock.Mock(return_value=(0, "vm1"))
 268             with mock.patch("yardstick.benchmark.contexts.standalone.sriov.time"):
 269                 self.assertIsNone(sriov_obj.setup_sriov_context(PCIS, nic_details, DRIVER))
 270
 271     @mock.patch(
 272         'yardstick.benchmark.contexts.standalone.sriov',
 273         return_value="Domain vm1 created from /tmp/vm_sriov.xml")
 274     def test_is_vm_created(self, NIC_INPUT):
 275         with mock.patch("yardstick.ssh.SSH") as ssh:
 276             ssh_mock = mock.Mock(autospec=ssh.SSH)
 277             ssh_mock.execute = \
 278                 mock.Mock(return_value=(0, {}, ""))
 279             ssh.return_value = ssh_mock
 280             mock_sriov = mock.Mock()
 281             pcis = NIC_DETAILS['pci']
 282             driver = NIC_DETAILS['phy_driver']
 283             self.assertIsNotNone(
 284                 mock_sriov.sriov_obj.setup_sriov_context(
 285                     pcis,
 286                     NIC_DETAILS,
 287                     driver))
 288
 289     def test_add_sriov_interface(self):
 290         with mock.patch("yardstick.ssh.SSH") as ssh:
 291             ssh_mock = mock.Mock(autospec=ssh.SSH)
 292             ssh_mock.execute = \
 293                 mock.Mock(return_value=(0, {}, ""))
 294             ssh.return_value = ssh_mock
 295             sriov_obj = sriov.Sriov()
 296             sriov_obj.connection = ssh_mock
 297             with mock.patch("xml.etree.ElementTree.parse") as parse:
 298                 with mock.patch("re.search") as re:
 299                     with mock.patch("xml.etree.ElementTree.SubElement") \
 300                         as elem:
 301                             parse = mock.Mock(return_value="root")
 302                             re = mock.Mock()
 303                             elem = mock.Mock()
 304                             print("{0} {1} {2}".format(parse, re, elem))
 305                             self.assertIsNone(sriov_obj.add_sriov_interface(
 306                                 0,
 307                                 "0000:06:02.0",
 308                                 "00:00:00:00:00:0a",
 309                                 "/tmp/vm_sriov.xml"))
 310
 311     def test_get_virtual_devices(self):
 312         with mock.patch("yardstick.ssh.SSH") as ssh:
 313             ssh_mock = mock.Mock(autospec=ssh.SSH)
 314             ssh_mock.execute = \
 315                 mock.Mock(return_value=(0, {}, ""))
 316             ssh.return_value = ssh_mock
 317             sriov_obj = sriov.Sriov()
 318             sriov_obj.connection = ssh_mock
 319             pci_out = " \
 320             PCI_CLASS=20000 \
 321             PCI_ID=8086:154C \
 322             PCI_SUBSYS_ID=8086:0000 \
 323             PCI_SLOT_NAME=0000:06:02.0 \
 324             MODALIAS= \
 325             pci:v00008086d0000154Csv00008086sd00000000bc02sc00i00"
 326             pci = "0000:06:00.0"
 327             sriov_obj.check_output = mock.Mock(return_value=(0, pci_out))
 328             with mock.patch("re.search") as re:
 329                 re = mock.Mock(return_value="a")
 330                 print("{0}".format(re))
 331                 self.assertIsNotNone(sriov_obj.get_virtual_devices(pci))
 332
 333     def test_get_vf_datas(self):
 334         with mock.patch("yardstick.ssh.SSH") as ssh:
 335             ssh_mock = mock.Mock(autospec=ssh.SSH)
 336             ssh_mock.execute = \
 337                 mock.Mock(return_value=(0, {}, ""))
 338             ssh.return_value = ssh_mock
 339             sriov_obj = sriov.Sriov()
 340             sriov_obj.connection = ssh_mock
 341             sriov_obj.get_virtual_devices = mock.Mock(
 342                 return_value={'0000:06:00.0': '0000:06:02.0'})
 343             with mock.patch("re.search") as re:
 344                 re = mock.Mock()
 345                 print("{0}".format(re))
 346                 self.assertIsNotNone(sriov_obj.get_vf_datas(
 347                     'vf_pci',
 348                     {'0000:06:00.0': '0000:06:02.0'},
 349                     "00:00:00:00:00:0a"))
 350
 351     def test_check_output(self):
 352         with mock.patch("yardstick.ssh.SSH") as ssh:
 353             cmd = "command"
 354             ssh_mock = mock.Mock(autospec=ssh.SSH)
 355             ssh_mock.execute = \
 356                 mock.Mock(return_value=(0, {}, ""))
 357             ssh.return_value = ssh_mock
 358             sriov_obj = sriov.Sriov()
 359             sriov_obj.connection = ssh_mock
 360             self.assertIsNotNone(sriov_obj.check_output(cmd, None))
 361
 362     def test_split_cpu_list_available(self):
 363         with mock.patch("itertools.chain") as iter1:
 364             iter1 = mock.Mock()
 365             print("{0}".format(iter1))
 366             sriov_obj = sriov.Sriov()
 367             self.assertIsNotNone(sriov_obj.split_cpu_list('0,5'))
 368
 369     def test_split_cpu_list_null(self):
 370         with mock.patch("itertools.chain") as iter1:
 371             iter1 = mock.Mock()
 372             print("{0}".format(iter1))
 373             sriov_obj = sriov.Sriov()
 374             self.assertEqual(sriov_obj.split_cpu_list([]), [])
 375
 376     def test_destroy_vm_successful(self):
 377         with mock.patch("yardstick.ssh.SSH") as ssh:
 378             ssh_mock = mock.Mock(autospec=ssh.SSH)
 379             ssh_mock.execute = \
 380                 mock.Mock(return_value=(0, {}, ""))
 381             ssh.return_value = ssh_mock
 382             sriov_obj = sriov.Sriov()
 383             sriov_obj.connection = ssh_mock
 384             sriov_obj.sriov = SRIOV
 385             sriov_obj.check_output = mock.Mock(return_value=(0, "vm1"))
 386             ssh_mock.execute = \
 387                 mock.Mock(return_value=(0, {}, ""))
 388             ssh_mock.execute = \
 389                 mock.Mock(return_value=(0, {}, ""))
 390             ssh_mock.execute = \
 391                 mock.Mock(return_value=(0, "0 i40e"))
 392             ssh_mock.execute = \
 393                 mock.Mock(return_value=(0, "0 i40e"))
 394             self.assertIsNone(sriov_obj.destroy_vm())
 395
 396     def test_destroy_vm_unsuccessful(self):
 397         with mock.patch("yardstick.ssh.SSH") as ssh:
 398             ssh_mock = mock.Mock(autospec=ssh.SSH)
 399             ssh_mock.execute = \
 400                 mock.Mock(return_value=(0, {}, ""))
 401             ssh.return_value = ssh_mock
 402             sriov_obj = sriov.Sriov()
 403             sriov_obj.connection = ssh_mock
 404             sriov_obj.sriov = SRIOV
 405             sriov_obj.check_output = mock.Mock(return_value=(1, {}))
 406             self.assertIsNone(sriov_obj.destroy_vm())
 407
 408     def test_read_from_file(self):
 409         CORRECT_FILE_PATH = self._get_file_abspath(self.NODES_SAMPLE_PASSWORD)
 410         sriov_obj = sriov.Sriov()
 411         self.assertIsNotNone(sriov_obj.read_from_file(CORRECT_FILE_PATH))
 412
 413     def test_write_to_file(self):
 414         sriov_obj = sriov.Sriov()
 415         self.assertIsNone(sriov_obj.write_to_file(SAMPLE_FILE, "some content"))
 416
 417     def _get_file_abspath(self, filename):
 418         curr_path = os.path.dirname(os.path.abspath(__file__))
 419         file_path = os.path.join(curr_path, filename)
 420         return file_path
 421
 422 if __name__ == '__main__':
 423     unittest.main()