yardstick/tests/unit/benchmark/contexts/standalone/test_ovs_dpdk.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 import os
  16
  17 import mock
  18 import unittest
  19
  20 from yardstick.benchmark.contexts.standalone import ovs_dpdk
  21
  22
  23 class OvsDpdkContextTestCase(unittest.TestCase):
  24
  25     NODES_SAMPLE = "nodes_sample.yaml"
  26     NODES_ovs_dpdk_SAMPLE = "nodes_ovs_dpdk_sample.yaml"
  27     NODES_DUPLICATE_SAMPLE = "nodes_duplicate_sample.yaml"
  28
  29     NETWORKS = {
  30         'mgmt': {'cidr': '152.16.100.10/24'},
  31         'private_0': {
  32             'phy_port': "0000:05:00.0",
  33             'vpci': "0000:00:07.0",
  34             'cidr': '152.16.100.10/24',
  35             'interface': 'if0',
  36             'mac': "00:00:00:00:00:01",
  37             'vf_pci': {'vf_pci': 0},
  38             'gateway_ip': '152.16.100.20'},
  39         'public_0': {
  40             'phy_port': "0000:05:00.1",
  41             'vpci': "0000:00:08.0",
  42             'cidr': '152.16.40.10/24',
  43             'interface': 'if0',
  44             'vf_pci': {'vf_pci': 0},
  45             'mac': "00:00:00:00:00:01",
  46             'gateway_ip': '152.16.100.20'},
  47     }
  48
  49     def setUp(self):
  50         self.attrs = {
  51             'name': 'foo',
  52             'task_id': '1234567890',
  53             'file': self._get_file_abspath(self.NODES_ovs_dpdk_SAMPLE)
  54         }
  55         self.ovs_dpdk = ovs_dpdk.OvsDpdkContext()
  56         self.addCleanup(self._remove_contexts)
  57
  58     def _remove_contexts(self):
  59         if self.ovs_dpdk in self.ovs_dpdk.list:
  60             self.ovs_dpdk._delete_context()
  61
  62     @mock.patch('yardstick.benchmark.contexts.standalone.model.Server')
  63     @mock.patch('yardstick.benchmark.contexts.standalone.model.StandaloneContextHelper')
  64     def test___init__(self, mock_helper, mock_server):
  65         self.ovs_dpdk.helper = mock_helper
  66         self.ovs_dpdk.vnf_node = mock_server
  67         self.assertIsNone(self.ovs_dpdk.file_path)
  68         self.assertTrue(self.ovs_dpdk.first_run)
  69
  70     def test_init(self):
  71         ATTRS = {
  72             'name': 'StandaloneOvsDpdk',
  73             'task_id': '1234567890',
  74             'file': 'pod',
  75             'flavor': {},
  76             'servers': {},
  77             'networks': {},
  78         }
  79
  80         self.ovs_dpdk.helper.parse_pod_file = mock.Mock(
  81             return_value=[{}, {}, {}])
  82         self.assertIsNone(self.ovs_dpdk.init(ATTRS))
  83
  84     def test_setup_ovs(self):
  85         with mock.patch("yardstick.ssh.SSH") as ssh:
  86             ssh_mock = mock.Mock(autospec=ssh.SSH)
  87             ssh_mock.execute = \
  88                 mock.Mock(return_value=(0, "a", ""))
  89             ssh.return_value = ssh_mock
  90             self.ovs_dpdk.connection = ssh_mock
  91             self.ovs_dpdk.networks = self.NETWORKS
  92             self.ovs_dpdk.ovs_properties = {}
  93             self.assertIsNone(self.ovs_dpdk.setup_ovs())
  94
  95     def test_start_ovs_serverswitch(self):
  96         with mock.patch("yardstick.ssh.SSH") as ssh:
  97             ssh_mock = mock.Mock(autospec=ssh.SSH)
  98             ssh_mock.execute = \
  99                 mock.Mock(return_value=(0, "a", ""))
 100             ssh.return_value = ssh_mock
 101             self.ovs_dpdk.connection = ssh_mock
 102             self.ovs_dpdk.networks = self.NETWORKS
 103             self.ovs_dpdk.ovs_properties = {}
 104             self.ovs_dpdk.wait_for_vswitchd = 0
 105             self.assertIsNone(self.ovs_dpdk.start_ovs_serverswitch())
 106
 107     def test_setup_ovs_bridge_add_flows(self):
 108         with mock.patch("yardstick.ssh.SSH") as ssh:
 109             ssh_mock = mock.Mock(autospec=ssh.SSH)
 110             ssh_mock.execute = \
 111                 mock.Mock(return_value=(0, "a", ""))
 112             ssh.return_value = ssh_mock
 113             self.ovs_dpdk.connection = ssh_mock
 114             self.ovs_dpdk.networks = self.NETWORKS
 115             self.ovs_dpdk.ovs_properties = {
 116                 'version': {'ovs': '2.7.0'}
 117             }
 118             self.ovs_dpdk.wait_for_vswitchd = 0
 119             self.assertIsNone(self.ovs_dpdk.setup_ovs_bridge_add_flows())
 120
 121     @mock.patch("yardstick.ssh.SSH")
 122     def test_cleanup_ovs_dpdk_env(self, mock_ssh):
 123        mock_ssh.execute.return_value = 0, "a", ""
 124        self.ovs_dpdk.connection = mock_ssh
 125        self.ovs_dpdk.networks = self.NETWORKS
 126        self.ovs_dpdk.ovs_properties = {
 127            'version': {'ovs': '2.7.0'}
 128        }
 129        self.ovs_dpdk.wait_for_vswitchd = 0
 130        self.assertIsNone(self.ovs_dpdk.cleanup_ovs_dpdk_env())
 131
 132     @mock.patch('yardstick.benchmark.contexts.standalone.model.OvsDeploy')
 133     def test_check_ovs_dpdk_env(self, mock_ovs):
 134         with mock.patch("yardstick.ssh.SSH") as ssh:
 135             ssh_mock = mock.Mock(autospec=ssh.SSH)
 136             ssh_mock.execute = \
 137                 mock.Mock(return_value=(1, "a", ""))
 138             ssh.return_value = ssh_mock
 139             self.ovs_dpdk.connection = ssh_mock
 140             self.ovs_dpdk.networks = self.NETWORKS
 141             self.ovs_dpdk.ovs_properties = {
 142                 'version': {'ovs': '2.7.0', 'dpdk': '16.11.1'}
 143             }
 144             self.ovs_dpdk.wait_for_vswitchd = 0
 145             self.ovs_dpdk.cleanup_ovs_dpdk_env = mock.Mock()
 146             self.assertIsNone(self.ovs_dpdk.check_ovs_dpdk_env())
 147             self.ovs_dpdk.ovs_properties = {
 148                 'version': {'ovs': '2.0.0'}
 149             }
 150             self.ovs_dpdk.wait_for_vswitchd = 0
 151             self.cleanup_ovs_dpdk_env = mock.Mock()
 152             mock_ovs.deploy = mock.Mock()
 153             # NOTE(elfoley): Check for a specific Exception
 154             self.assertRaises(Exception, self.ovs_dpdk.check_ovs_dpdk_env)
 155
 156     @mock.patch('yardstick.ssh.SSH')
 157     def test_deploy(self, mock_ssh):
 158         mock_ssh.execute.return_value = 0, "a", ""
 159
 160         self.ovs_dpdk.vm_deploy = False
 161         self.assertIsNone(self.ovs_dpdk.deploy())
 162
 163         self.ovs_dpdk.vm_deploy = True
 164         self.ovs_dpdk.host_mgmt = {}
 165         self.ovs_dpdk.install_req_libs = mock.Mock()
 166         self.ovs_dpdk.helper.get_nic_details = mock.Mock(return_value={})
 167         self.ovs_dpdk.check_ovs_dpdk_env = mock.Mock(return_value={})
 168         self.ovs_dpdk.setup_ovs = mock.Mock(return_value={})
 169         self.ovs_dpdk.start_ovs_serverswitch = mock.Mock(return_value={})
 170         self.ovs_dpdk.setup_ovs_bridge_add_flows = mock.Mock(return_value={})
 171         self.ovs_dpdk.setup_ovs_dpdk_context = mock.Mock(return_value={})
 172         self.ovs_dpdk.wait_for_vnfs_to_start = mock.Mock(return_value={})
 173         # TODO(elfoley): This test should check states/sideeffects instead of
 174         # output.
 175         self.assertIsNone(self.ovs_dpdk.deploy())
 176
 177     @mock.patch('yardstick.benchmark.contexts.standalone.model.Libvirt')
 178     @mock.patch('yardstick.ssh.SSH')
 179     def test_undeploy(self, mock_ssh, *args):
 180         mock_ssh.execute.return_value = 0, "a", ""
 181
 182         self.ovs_dpdk.vm_deploy = False
 183         self.assertIsNone(self.ovs_dpdk.undeploy())
 184
 185         self.ovs_dpdk.vm_deploy = True
 186         self.ovs_dpdk.connection = mock_ssh
 187         self.ovs_dpdk.vm_names = ['vm_0', 'vm_1']
 188         self.ovs_dpdk.drivers = ['vm_0', 'vm_1']
 189         self.ovs_dpdk.cleanup_ovs_dpdk_env = mock.Mock()
 190         self.ovs_dpdk.networks = self.NETWORKS
 191         self.assertIsNone(self.ovs_dpdk.undeploy())
 192
 193     def _get_file_abspath(self, filename):
 194         curr_path = os.path.dirname(os.path.abspath(__file__))
 195         file_path = os.path.join(curr_path, filename)
 196         return file_path
 197
 198     def test__get_server_with_dic_attr_name(self):
 199
 200         self.ovs_dpdk.init(self.attrs)
 201
 202         attr_name = {'name': 'foo.bar'}
 203         result = self.ovs_dpdk._get_server(attr_name)
 204
 205         self.assertEqual(result, None)
 206
 207     def test__get_server_not_found(self):
 208
 209         self.ovs_dpdk.helper.parse_pod_file = mock.Mock(
 210             return_value=[{}, {}, {}])
 211         self.ovs_dpdk.init(self.attrs)
 212
 213         attr_name = 'bar.foo'
 214         result = self.ovs_dpdk._get_server(attr_name)
 215
 216         self.assertEqual(result, None)
 217
 218     def test__get_server_mismatch(self):
 219
 220         self.ovs_dpdk.init(self.attrs)
 221
 222         attr_name = 'bar.foo1'
 223         result = self.ovs_dpdk._get_server(attr_name)
 224
 225         self.assertEqual(result, None)
 226
 227     def test__get_server_duplicate(self):
 228
 229         self.attrs['file'] = self._get_file_abspath(self.NODES_DUPLICATE_SAMPLE)
 230
 231         self.ovs_dpdk.init(self.attrs)
 232
 233         attr_name = 'node1.foo-12345678'
 234         with self.assertRaises(ValueError):
 235             self.ovs_dpdk._get_server(attr_name)
 236
 237     def test__get_server_found(self):
 238
 239         self.ovs_dpdk.init(self.attrs)
 240
 241         attr_name = 'node1.foo-12345678'
 242         result = self.ovs_dpdk._get_server(attr_name)
 243
 244         self.assertEqual(result['ip'], '10.229.47.137')
 245         self.assertEqual(result['name'], 'node1.foo-12345678')
 246         self.assertEqual(result['user'], 'root')
 247         self.assertEqual(result['key_filename'], '/root/.yardstick_key')
 248
 249     # TODO(elfoley): Split this test for networks that exist and networks that
 250     #                don't
 251     def test__get_network(self):
 252         network1 = {
 253             'name': 'net_1',
 254             'vld_id': 'vld111',
 255             'segmentation_id': 'seg54',
 256             'network_type': 'type_a',
 257             'physical_network': 'phys',
 258         }
 259         network2 = {
 260             'name': 'net_2',
 261             'vld_id': 'vld999',
 262         }
 263         self.ovs_dpdk.networks = {
 264             'a': network1,
 265             'b': network2,
 266         }
 267
 268         # Tests for networks that do not exist
 269         attr_name = {}
 270         self.assertIsNone(self.ovs_dpdk._get_network(attr_name))
 271
 272         attr_name = {'vld_id': 'vld777'}
 273         self.assertIsNone(self.ovs_dpdk._get_network(attr_name))
 274
 275         self.assertIsNone(self.ovs_dpdk._get_network(None))
 276
 277         # TODO(elfoley): Split this test
 278         attr_name = 'vld777'
 279         self.assertIsNone(self.ovs_dpdk._get_network(attr_name))
 280
 281         # Tests for networks that exist
 282         attr_name = {'vld_id': 'vld999'}
 283         expected = {
 284             "name": 'net_2',
 285             "vld_id": 'vld999',
 286             "segmentation_id": None,
 287             "network_type": None,
 288             "physical_network": None,
 289         }
 290         result = self.ovs_dpdk._get_network(attr_name)
 291         self.assertDictEqual(result, expected)
 292
 293         attr_name = 'a'
 294         expected = network1
 295         result = self.ovs_dpdk._get_network(attr_name)
 296         self.assertDictEqual(result, expected)
 297
 298     def test_configure_nics_for_ovs_dpdk(self):
 299         with mock.patch("yardstick.ssh.SSH") as ssh:
 300             ssh_mock = mock.Mock(autospec=ssh.SSH)
 301             ssh_mock.execute = \
 302                 mock.Mock(return_value=(0, "a", ""))
 303             ssh.return_value = ssh_mock
 304         self.ovs_dpdk.vm_deploy = True
 305         self.ovs_dpdk.connection = ssh_mock
 306         self.ovs_dpdk.vm_names = ['vm_0', 'vm_1']
 307         self.ovs_dpdk.drivers = []
 308         self.ovs_dpdk.networks = self.NETWORKS
 309         self.ovs_dpdk.helper.get_mac_address = mock.Mock(return_value="")
 310         self.ovs_dpdk.get_vf_datas = mock.Mock(return_value="")
 311         self.assertIsNone(self.ovs_dpdk.configure_nics_for_ovs_dpdk())
 312
 313     @mock.patch('yardstick.benchmark.contexts.standalone.ovs_dpdk.Libvirt')
 314     def test__enable_interfaces(self, *args):
 315         with mock.patch("yardstick.ssh.SSH") as ssh:
 316             ssh_mock = mock.Mock(autospec=ssh.SSH)
 317             ssh_mock.execute = \
 318                 mock.Mock(return_value=(0, "a", ""))
 319             ssh.return_value = ssh_mock
 320         self.ovs_dpdk.vm_deploy = True
 321         self.ovs_dpdk.connection = ssh_mock
 322         self.ovs_dpdk.vm_names = ['vm_0', 'vm_1']
 323         self.ovs_dpdk.drivers = []
 324         self.ovs_dpdk.networks = self.NETWORKS
 325         self.ovs_dpdk.get_vf_datas = mock.Mock(return_value="")
 326         self.assertIsNone(self.ovs_dpdk._enable_interfaces(
 327             0, ["private_0"], 'test'))
 328
 329     @mock.patch('yardstick.benchmark.contexts.standalone.model.Server')
 330     @mock.patch('yardstick.benchmark.contexts.standalone.ovs_dpdk.Libvirt')
 331     def test_setup_ovs_dpdk_context(self, mock_libvirt, *args):
 332         with mock.patch("yardstick.ssh.SSH") as ssh:
 333             ssh_mock = mock.Mock(autospec=ssh.SSH)
 334             ssh_mock.execute = \
 335                 mock.Mock(return_value=(0, "a", ""))
 336             ssh_mock.put = \
 337                 mock.Mock(return_value=(0, "a", ""))
 338             ssh.return_value = ssh_mock
 339         self.ovs_dpdk.vm_deploy = True
 340         self.ovs_dpdk.connection = ssh_mock
 341         self.ovs_dpdk.vm_names = ['vm_0', 'vm_1']
 342         self.ovs_dpdk.drivers = []
 343         self.ovs_dpdk.servers = {
 344             'vnf_0': {
 345                 'network_ports': {
 346                     'mgmt': {'cidr': '152.16.100.10/24'},
 347                     'xe0': ['private_0'],
 348                     'xe1': ['public_0']
 349                 }
 350             }
 351         }
 352         self.ovs_dpdk.networks = self.NETWORKS
 353         self.ovs_dpdk.host_mgmt = {}
 354         self.ovs_dpdk.flavor = {}
 355         self.ovs_dpdk.configure_nics_for_ovs_dpdk = mock.Mock(return_value="")
 356         mock_libvirt.build_vm_xml.return_value = [6, "00:00:00:00:00:01"]
 357         self.ovs_dpdk._enable_interfaces = mock.Mock(return_value="")
 358         mock_libvirt.virsh_create_vm.return_value = ""
 359         mock_libvirt.pin_vcpu_for_perf.return_value = ""
 360         self.ovs_dpdk.vnf_node.generate_vnf_instance = mock.Mock(
 361             return_value={})
 362
 363         self.assertIsNotNone(self.ovs_dpdk.setup_ovs_dpdk_context())