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