Merge branch 'master' into paas
Change-Id: Ic445665bf024b0df89e16cadf1bea0ba4bb723b6
Signed-off-by: Mark Beierl <mark.beierl@canonical.com>
diff --git a/NG-RO/osm_ng_ro/ns_thread.py b/NG-RO/osm_ng_ro/ns_thread.py
index ed971dc..6e94956 100644
--- a/NG-RO/osm_ng_ro/ns_thread.py
+++ b/NG-RO/osm_ng_ro/ns_thread.py
@@ -1791,9 +1791,9 @@
)
plugin_name = ""
vim = None
+ step = "Getting {}={} from db".format(target, _id)
try:
- step = "Getting {}={} from db".format(target, _id)
# TODO process for wim, sdnc, ...
vim = self.db.get_one(target_database, {"_id": _id})
diff --git a/NG-RO/osm_ng_ro/ro_main.py b/NG-RO/osm_ng_ro/ro_main.py
index 9500ea2..86e839c 100644
--- a/NG-RO/osm_ng_ro/ro_main.py
+++ b/NG-RO/osm_ng_ro/ro_main.py
@@ -214,6 +214,8 @@
}
def _format_in(self, kwargs):
+
+ error_text = ""
try:
indata = None
diff --git a/RO-SDN-dynpac/osm_rosdn_dynpac/wimconn_dynpac.py b/RO-SDN-dynpac/osm_rosdn_dynpac/wimconn_dynpac.py
index dfd4b35..a2bd8d7 100644
--- a/RO-SDN-dynpac/osm_rosdn_dynpac/wimconn_dynpac.py
+++ b/RO-SDN-dynpac/osm_rosdn_dynpac/wimconn_dynpac.py
@@ -228,9 +228,11 @@
for connection_point in connection_points:
endpoint_id = connection_point.get(self.__SERVICE_ENDPOINT_PARAM)
- port = filter(
- lambda x: x.get(self.__WAN_SERVICE_ENDPOINT_PARAM) == endpoint_id,
- port_mapping,
+ port = list(
+ filter(
+ lambda x: x.get(self.__WAN_SERVICE_ENDPOINT_PARAM) == endpoint_id,
+ port_mapping,
+ )
)[0]
port_info = port.get(self.__WAN_MAPPING_INFO_PARAM)
selected_ports.append(port_info)
diff --git a/RO-SDN-juniper_contrail/osm_rosdn_juniper_contrail/rest_lib.py b/RO-SDN-juniper_contrail/osm_rosdn_juniper_contrail/rest_lib.py
index 31ea213..fff489d 100644
--- a/RO-SDN-juniper_contrail/osm_rosdn_juniper_contrail/rest_lib.py
+++ b/RO-SDN-juniper_contrail/osm_rosdn_juniper_contrail/rest_lib.py
@@ -162,9 +162,7 @@
except AuthError:
# If there is an auth error retry just once
if retry_auth_error:
- return self._request(
- self, op, url, headers, data, retry_auth_error=False
- )
+ return self._request(op, url, headers, data, retry_auth_error=False)
def _request_noauth(self, op, url, headers, data=None):
# Method to execute http requests with error control
diff --git a/RO-SDN-juniper_contrail/osm_rosdn_juniper_contrail/sdn_api.py b/RO-SDN-juniper_contrail/osm_rosdn_juniper_contrail/sdn_api.py
index 6d08def..0b4f9a8 100644
--- a/RO-SDN-juniper_contrail/osm_rosdn_juniper_contrail/sdn_api.py
+++ b/RO-SDN-juniper_contrail/osm_rosdn_juniper_contrail/sdn_api.py
@@ -197,9 +197,6 @@
"virtual-network"
)
- def get_virtual_networks(self):
- return self.get_all_by_type("virtual-networks")
-
def get_virtual_network(self, network_id):
return self.get_by_uuid("virtual-network", network_id)
@@ -239,9 +236,6 @@
def get_vpgs(self):
return self.get_all_by_type(self.controller_url, "virtual-port-groups")
- def get_vpg(self, vpg_id):
- return self.get_by_uuid(self.controller_url, "virtual-port-group", vpg_id)
-
def get_vpg_by_name(self, vpg_name):
fq_name = ["default-global-system-config", self.fabric, vpg_name]
@@ -306,11 +300,6 @@
"virtual-machine-interface"
)
- def get_vmi(self, vmi_uuid):
- return self.get_by_uuid(
- self.controller_url, "virtual-machine-interface", vmi_uuid
- )
-
def delete_vmi(self, uuid):
self.logger.debug("delete vmi uuid: {}".format(uuid))
self.delete_by_uuid(self.controller_url, "virtual-machine-interface", uuid)
diff --git a/RO-VIM-aws/osm_rovim_aws/vimconn_aws.py b/RO-VIM-aws/osm_rovim_aws/vimconn_aws.py
index 5fc0704..63184a1 100644
--- a/RO-VIM-aws/osm_rovim_aws/vimconn_aws.py
+++ b/RO-VIM-aws/osm_rovim_aws/vimconn_aws.py
@@ -606,52 +606,6 @@
except Exception as e:
self.format_vimconn_exception(e)
- def get_flavor_id_from_data(self, flavor_dict):
- """Obtain flavor id that match the flavor description
- Params:
- 'flavor_dict': dictionary that contains:
- 'disk': main hard disk in GB
- 'ram': memory in MB
- 'vcpus': number of virtual cpus
- #todo: complete parameters for EPA
- Returns the flavor_id or raises a vimconnNotFoundException
- """
- self.logger.debug("Getting flavor id from data")
-
- try:
- flavor = None
- for key, values in self.flavor_info.items():
- if (values["ram"], values["cpus"], values["disk"]) == (
- flavor_dict["ram"],
- flavor_dict["vcpus"],
- flavor_dict["disk"],
- ):
- flavor = (key, values)
- break
- elif (values["ram"], values["cpus"], values["disk"]) >= (
- flavor_dict["ram"],
- flavor_dict["vcpus"],
- flavor_dict["disk"],
- ):
- if not flavor:
- flavor = (key, values)
- else:
- if (flavor[1]["ram"], flavor[1]["cpus"], flavor[1]["disk"]) >= (
- values["ram"],
- values["cpus"],
- values["disk"],
- ):
- flavor = (key, values)
-
- if flavor:
- return flavor[0]
-
- raise vimconn.VimConnNotFoundException(
- "Cannot find flavor with this flavor ID/Name"
- )
- except Exception as e:
- self.format_vimconn_exception(e)
-
def new_image(self, image_dict):
"""Adds a tenant image to VIM
Params: image_dict
@@ -993,7 +947,6 @@
else:
raise vimconn.VimConnException(
"Failed to get instance_id for reservation",
- reservation,
http_code=vimconn.HTTP_Request_Timeout,
)
diff --git a/RO-VIM-openstack/osm_rovim_openstack/tests/test_vimconn_openstack.py b/RO-VIM-openstack/osm_rovim_openstack/tests/test_vimconn_openstack.py
index f4382ad..acf6be4 100644
--- a/RO-VIM-openstack/osm_rovim_openstack/tests/test_vimconn_openstack.py
+++ b/RO-VIM-openstack/osm_rovim_openstack/tests/test_vimconn_openstack.py
@@ -32,6 +32,7 @@
from mock import MagicMock, patch
from neutronclient.v2_0.client import Client
from novaclient import exceptions as nvExceptions
+from novaclient.exceptions import ClientException, Conflict
from osm_ro_plugin import vimconn
from osm_ro_plugin.vimconn import (
VimConnConnectionException,
@@ -79,6 +80,34 @@
}
+# Variables used in TestNewFlavor Class
+flavor_id = "075d2482-5edb-43e3-91b3-234e65b6268a"
+name1 = "sample-flavor"
+extended = (
+ {
+ "cpu-quota": {"limit": 3},
+ "mem-quota": {"limit": 1},
+ "mempage-size": "LARGE",
+ "cpu-pinning-policy": "DEDICATED",
+ "mem-policy": "STRICT",
+ },
+)
+flavor_data = {
+ "name": name1,
+ "ram": 3,
+ "vcpus": 8,
+ "disk": 50,
+ "extended": extended,
+}
+
+flavor_data2 = {
+ "name": name1,
+ "ram": 3,
+ "vcpus": 8,
+ "disk": 50,
+}
+
+
class TestSfcOperations(unittest.TestCase):
@mock.patch("logging.getLogger", autospec=True)
def setUp(self, mock_logger):
@@ -3071,7 +3100,7 @@
self.vimconn._neutron_create_float_ip(param, created_items)
self.assertEqual(created_items, expected_created_items)
- def test_neutron_create_float_ip_exception_occured(self):
+ def test_neutron_create_float_ip_exception_occurred(self):
"""Floating ip could not be created."""
param = {
"floatingip": {
@@ -3082,14 +3111,14 @@
created_items = {}
self.vimconn.neutron = CopyingMock()
self.vimconn.neutron.create_floatingip.side_effect = Exception(
- "Neutron floating ip create exception occured."
+ "Neutron floating ip create exception occurred."
)
with self.assertRaises(VimConnException) as err:
self.vimconn._neutron_create_float_ip(param, created_items)
self.assertEqual(created_items, {})
self.assertEqual(
str(err.exception),
- "Exception: Cannot create new floating_ip Neutron floating ip create exception occured.",
+ "Exception: Cannot create new floating_ip Neutron floating ip create exception occurred.",
)
@patch.object(vimconnector, "_neutron_create_float_ip")
@@ -4770,7 +4799,7 @@
k_id = floating_network_vim_id
k = f"floating_ip:{floating_network_vim_id}"
self.vimconn.neutron.delete_floatingip.side_effect = (
- nvExceptions.ClientException("Client exception occured.")
+ nvExceptions.ClientException("Client exception occurred.")
)
self.vimconn._delete_floating_ip_by_id(k, k_id, created_items)
self.vimconn.neutron.delete_floatingip.assert_called_once_with(k_id)
@@ -4782,7 +4811,7 @@
},
)
self.vimconn.logger.error.assert_called_once_with(
- "Error deleting floating ip: ClientException: Unknown Error (HTTP Client exception occured.)"
+ "Error deleting floating ip: ClientException: Unknown Error (HTTP Client exception occurred.)"
)
def test_delete_floating_ip_by_id_floating_ip_raises_vimconnexception(self):
@@ -5530,11 +5559,11 @@
mock_extract_items_wth_keep_flag_from_created_items.return_value = created_items
mock_sleep = MagicMock()
volumes_to_hold = []
- err = ConnectionError("ClientException occured.")
+ err = ConnectionError("ClientException occurred.")
mock_delete_created_items.side_effect = err
with self.assertRaises(ConnectionError) as err:
self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
- self.assertEqual(str(err), "ClientException occured.")
+ self.assertEqual(str(err), "ClientException occurred.")
mock_reload_connection.assert_called_once()
mock_delete_vm_ports_attached_to_network.assert_called_once_with(created_items)
self.vimconn.nova.servers.delete.assert_called_once_with(vm_id)
@@ -5564,12 +5593,12 @@
created_items = deepcopy(created_items_all_true)
mock_extract_items_wth_keep_flag_from_created_items.return_value = created_items
volumes_to_hold = [f"{volume_id}", f"{volume_id2}"]
- err = ConnectionError("ClientException occured.")
+ err = ConnectionError("ClientException occurred.")
mock_delete_vm_ports_attached_to_network.side_effect = err
mock_delete_created_items.side_effect = err
with self.assertRaises(ConnectionError) as err:
self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
- self.assertEqual(str(err), "ClientException occured.")
+ self.assertEqual(str(err), "ClientException occurred.")
mock_reload_connection.assert_called_once()
mock_delete_vm_ports_attached_to_network.assert_called_once_with(created_items)
self.vimconn.nova.servers.delete.assert_not_called()
@@ -5599,12 +5628,12 @@
created_items = deepcopy(created_items_all_true)
mock_extract_items_wth_keep_flag_from_created_items.return_value = created_items
volumes_to_hold = [f"{volume_id}", f"{volume_id2}"]
- err = VimConnConnectionException("ClientException occured.")
+ err = VimConnConnectionException("ClientException occurred.")
self.vimconn.nova.servers.delete.side_effect = err
mock_delete_created_items.side_effect = err
with self.assertRaises(VimConnConnectionException) as err:
self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
- self.assertEqual(str(err), "ClientException occured.")
+ self.assertEqual(str(err), "ClientException occurred.")
mock_reload_connection.assert_called_once()
mock_delete_vm_ports_attached_to_network.assert_called_once_with(created_items)
self.vimconn.nova.servers.delete.assert_called_once_with(vm_id)
@@ -5635,12 +5664,12 @@
mock_extract_items_wth_keep_flag_from_created_items.return_value = created_items
mock_sleep = MagicMock()
volumes_to_hold = [f"{volume_id}", f"{volume_id2}"]
- err = ConnectionError("ClientException occured.")
+ err = ConnectionError("ClientException occurred.")
mock_delete_created_items.return_value = False
mock_reload_connection.side_effect = err
with self.assertRaises(ConnectionError) as err:
self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
- self.assertEqual(str(err), "ClientException occured.")
+ self.assertEqual(str(err), "ClientException occurred.")
mock_reload_connection.assert_called_once()
mock_delete_vm_ports_attached_to_network.assert_not_called()
self.vimconn.nova.servers.delete.assert_not_called()
@@ -5889,5 +5918,1921 @@
self.vimconn._extract_items_wth_keep_flag_from_created_items(created_items)
+class TestNewFlavor(unittest.TestCase):
+ @patch("logging.getLogger", autospec=True)
+ def setUp(self, mock_logger):
+ # We are disabling the logging of exception not to print them to console.
+ mock_logger = logging.getLogger()
+ mock_logger.disabled = True
+ self.vimconn = vimconnector(
+ "123",
+ "openstackvim",
+ "456",
+ "789",
+ "http://dummy.url",
+ None,
+ "user",
+ "pass",
+ )
+ self.vimconn.nova = CopyingMock(autospec=True)
+ self.flavor1 = CopyingMock(autospec=True, name="sample-flavor")
+ self.flavor2 = CopyingMock(autospec=True, name="other-flavor")
+ self.new_flavor = CopyingMock(autospec=True, name="new_flavor")
+ self.new_flavor.id = "075d2482-5edb-43e3-91b3-234e65b6268a"
+ self.vimconn.nova.flavors.create.return_value = self.new_flavor
+
+ @staticmethod
+ def check_if_assert_not_called(mocks: list):
+ for mocking in mocks:
+ mocking.assert_not_called()
+
+ @patch.object(vimconnector, "process_numa_memory", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_vcpu", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "process_numa_paired_threads",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_numa_cores", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_threads", new_callable=CopyingMock())
+ def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_vio(
+ self,
+ mock_process_numa_threads,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ mock_process_numa_vcpu,
+ mock_process_numa_memory,
+ ):
+ """Process numa parameters, id, memory, vcpu exist, vim type is VIO,
+ paired-threads, cores, threads do not exist in numa.
+ """
+ numas = [
+ {"id": 0, "memory": 1, "vcpu": [1, 3]},
+ {"id": 1, "memory": 2, "vcpu": [2]},
+ ]
+ vcpus = 3
+ extra_specs = {}
+ expected_extra_specs = {
+ "hw:numa_nodes": "2",
+ "vmware:extra_config": '{"numa.nodeAffinity":"0"}',
+ "vmware:latency_sensitivity_level": "high",
+ "hw:cpu_sockets": "2",
+ }
+ self.vimconn.vim_type = "VIO"
+ result = self.vimconn._process_numa_parameters_of_flavor(
+ numas, extra_specs, vcpus
+ )
+ self.assertEqual(result, vcpus)
+ self.assertEqual(mock_process_numa_memory.call_count, 2)
+ self.assertEqual(mock_process_numa_vcpu.call_count, 2)
+ _call_mock_process_numa_memory = mock_process_numa_memory.call_args_list
+ self.assertEqual(
+ _call_mock_process_numa_memory[0].args,
+ (
+ {"id": 0, "memory": 1, "vcpu": [1, 3]},
+ 0,
+ {
+ "hw:numa_nodes": "2",
+ "vmware:extra_config": '{"numa.nodeAffinity":"0"}',
+ "vmware:latency_sensitivity_level": "high",
+ },
+ ),
+ )
+ self.assertEqual(
+ _call_mock_process_numa_memory[1].args,
+ (
+ {"id": 1, "memory": 2, "vcpu": [2]},
+ 1,
+ {
+ "hw:cpu_sockets": "2",
+ "hw:numa_nodes": "2",
+ "vmware:extra_config": '{"numa.nodeAffinity":"0"}',
+ "vmware:latency_sensitivity_level": "high",
+ },
+ ),
+ )
+ _call_mock_process_numa_vcpu = mock_process_numa_vcpu.call_args_list
+ self.assertEqual(
+ _call_mock_process_numa_vcpu[0].args,
+ (
+ {"id": 0, "memory": 1, "vcpu": [1, 3]},
+ 0,
+ {
+ "hw:numa_nodes": "2",
+ "vmware:extra_config": '{"numa.nodeAffinity":"0"}',
+ "vmware:latency_sensitivity_level": "high",
+ },
+ ),
+ )
+ self.assertEqual(
+ _call_mock_process_numa_vcpu[1].args,
+ (
+ {"id": 1, "memory": 2, "vcpu": [2]},
+ 1,
+ {
+ "hw:cpu_sockets": "2",
+ "hw:numa_nodes": "2",
+ "vmware:extra_config": '{"numa.nodeAffinity":"0"}',
+ "vmware:latency_sensitivity_level": "high",
+ },
+ ),
+ )
+ self.assertDictEqual(extra_specs, expected_extra_specs)
+ self.check_if_assert_not_called(
+ [
+ mock_process_numa_threads,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ ]
+ )
+
+ @patch.object(vimconnector, "process_numa_memory", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_vcpu", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "process_numa_paired_threads",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_numa_cores", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_threads", new_callable=CopyingMock())
+ def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_openstack(
+ self,
+ mock_process_numa_threads,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ mock_process_numa_vcpu,
+ mock_process_numa_memory,
+ ):
+ """Process numa parameters, id, memory, vcpu exist, vim type is openstack,
+ paired-threads, cores, threads do not exist in numa.
+ """
+ numas = [
+ {"id": 0, "memory": 1, "vcpu": [1, 3]},
+ {"id": 1, "memory": 2, "vcpu": [2]},
+ ]
+ vcpus = 3
+ extra_specs = {}
+ expected_extra_specs = {
+ "hw:numa_nodes": "2",
+ "hw:cpu_sockets": "2",
+ }
+ self.vimconn.vim_type = "openstack"
+ result = self.vimconn._process_numa_parameters_of_flavor(
+ numas, extra_specs, vcpus
+ )
+ self.assertEqual(result, vcpus)
+ self.assertEqual(mock_process_numa_memory.call_count, 2)
+ self.assertEqual(mock_process_numa_vcpu.call_count, 2)
+ _call_mock_process_numa_memory = mock_process_numa_memory.call_args_list
+ self.assertEqual(
+ _call_mock_process_numa_memory[0].args,
+ (
+ {"id": 0, "memory": 1, "vcpu": [1, 3]},
+ 0,
+ {"hw:numa_nodes": "2"},
+ ),
+ )
+ self.assertEqual(
+ _call_mock_process_numa_memory[1].args,
+ (
+ {"id": 1, "memory": 2, "vcpu": [2]},
+ 1,
+ {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
+ ),
+ )
+ _call_mock_process_numa_vcpu = mock_process_numa_vcpu.call_args_list
+ self.assertEqual(
+ _call_mock_process_numa_vcpu[0].args,
+ (
+ {"id": 0, "memory": 1, "vcpu": [1, 3]},
+ 0,
+ {"hw:numa_nodes": "2"},
+ ),
+ )
+ self.assertEqual(
+ _call_mock_process_numa_vcpu[1].args,
+ (
+ {"id": 1, "memory": 2, "vcpu": [2]},
+ 1,
+ {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
+ ),
+ )
+ self.assertDictEqual(extra_specs, expected_extra_specs)
+ self.check_if_assert_not_called(
+ [
+ mock_process_numa_threads,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ ]
+ )
+
+ @patch.object(vimconnector, "process_numa_memory", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_vcpu", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "process_numa_paired_threads",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_numa_cores", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_threads", new_callable=CopyingMock())
+ def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_openstack_extra_spec_not_empty(
+ self,
+ mock_process_numa_threads,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ mock_process_numa_vcpu,
+ mock_process_numa_memory,
+ ):
+ """Process numa parameters, id, paired-threads exist, vim type is openstack.
+ vcpus calculation according to paired-threads in numa, there is extra_spec.
+ ."""
+ numas = [{"id": 0, "paired-threads": 3}, {"id": 1, "paired-threads": 3}]
+ extra_specs = {"some-key": "some-value"}
+ expected_extra_specs = {
+ "hw:numa_nodes": "2",
+ "hw:cpu_sockets": "2",
+ "some-key": "some-value",
+ }
+ self.vimconn.vim_type = "openstack"
+ vcpus = 6
+ mock_process_numa_paired_threads.side_effect = [6, 6]
+ result = self.vimconn._process_numa_parameters_of_flavor(
+ numas, extra_specs, vcpus
+ )
+ self.assertEqual(result, vcpus)
+ self.check_if_assert_not_called(
+ [mock_process_numa_threads, mock_process_numa_cores]
+ )
+ self.assertEqual(mock_process_numa_memory.call_count, 2)
+ self.assertEqual(mock_process_numa_vcpu.call_count, 2)
+ self.assertEqual(mock_process_numa_paired_threads.call_count, 2)
+ _call_mock_process_numa_paired_threads = (
+ mock_process_numa_paired_threads.call_args_list
+ )
+ self.assertEqual(
+ _call_mock_process_numa_paired_threads[0].args,
+ (
+ {"id": 0, "paired-threads": 3},
+ {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
+ ),
+ )
+ self.assertEqual(
+ _call_mock_process_numa_paired_threads[1].args,
+ (
+ {"id": 1, "paired-threads": 3},
+ {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
+ ),
+ )
+ self.assertDictEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(vimconnector, "process_numa_memory", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_vcpu", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "process_numa_paired_threads",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_numa_cores", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_threads", new_callable=CopyingMock())
+ def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_vio_extra_spec_not_empty(
+ self,
+ mock_process_numa_threads,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ mock_process_numa_vcpu,
+ mock_process_numa_memory,
+ ):
+ """Process numa parameters, id, paired-threads exist, vim type is VIO.
+ vcpus calculation according to paired-threads in numa, there is extra_spec.
+ """
+ numas = [{"id": 0, "paired-threads": 3}, {"id": 1, "paired-threads": 3}]
+ extra_specs = {"some-key": "some-value"}
+ expected_extra_specs = {
+ "hw:numa_nodes": "2",
+ "vmware:extra_config": '{"numa.nodeAffinity":"0"}',
+ "vmware:latency_sensitivity_level": "high",
+ "hw:cpu_sockets": "2",
+ "some-key": "some-value",
+ }
+ self.vimconn.vim_type = "VIO"
+ vcpus = 6
+ mock_process_numa_paired_threads.side_effect = [6, 6]
+ result = self.vimconn._process_numa_parameters_of_flavor(
+ numas, extra_specs, vcpus
+ )
+ self.assertEqual(result, vcpus)
+ self.check_if_assert_not_called(
+ [mock_process_numa_threads, mock_process_numa_cores]
+ )
+ self.assertEqual(mock_process_numa_paired_threads.call_count, 2)
+ self.assertEqual(mock_process_numa_memory.call_count, 2)
+ self.assertEqual(mock_process_numa_vcpu.call_count, 2)
+ _call_mock_process_numa_paired_threads = (
+ mock_process_numa_paired_threads.call_args_list
+ )
+ self.assertEqual(
+ _call_mock_process_numa_paired_threads[0].args,
+ (
+ {"id": 0, "paired-threads": 3},
+ {
+ "hw:cpu_sockets": "2",
+ "hw:numa_nodes": "2",
+ "some-key": "some-value",
+ "vmware:extra_config": '{"numa.nodeAffinity":"0"}',
+ "vmware:latency_sensitivity_level": "high",
+ },
+ ),
+ )
+ self.assertEqual(
+ _call_mock_process_numa_paired_threads[1].args,
+ (
+ {"id": 1, "paired-threads": 3},
+ {
+ "hw:cpu_sockets": "2",
+ "hw:numa_nodes": "2",
+ "some-key": "some-value",
+ "vmware:extra_config": '{"numa.nodeAffinity":"0"}',
+ "vmware:latency_sensitivity_level": "high",
+ },
+ ),
+ )
+ self.assertDictEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(vimconnector, "process_numa_memory", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_vcpu", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "process_numa_paired_threads",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_numa_cores", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_threads", new_callable=CopyingMock())
+ def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_openstack(
+ self,
+ mock_process_numa_threads,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ mock_process_numa_vcpu,
+ mock_process_numa_memory,
+ ):
+ """Process numa parameters, id, cores exist, vim type is openstack.
+ vcpus calculation according to cores in numa.
+ """
+ numas = [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
+ extra_specs = {}
+ expected_extra_specs = {"hw:numa_nodes": "2", "hw:cpu_sockets": "2"}
+ self.vimconn.vim_type = "openstack"
+ vcpus = 2
+ mock_process_numa_cores.side_effect = [1, 2]
+ result = self.vimconn._process_numa_parameters_of_flavor(
+ numas, extra_specs, vcpus
+ )
+ self.assertEqual(result, vcpus)
+ self.check_if_assert_not_called(
+ [mock_process_numa_threads, mock_process_numa_paired_threads]
+ )
+ self.assertEqual(mock_process_numa_cores.call_count, 2)
+ self.assertEqual(mock_process_numa_memory.call_count, 2)
+ self.assertEqual(mock_process_numa_vcpu.call_count, 2)
+ _call_mock_process_numa_cores = mock_process_numa_cores.call_args_list
+ self.assertEqual(
+ _call_mock_process_numa_cores[0].args,
+ ({"id": 0, "cores": 1}, {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"}),
+ )
+ self.assertEqual(
+ _call_mock_process_numa_cores[1].args,
+ ({"id": 1, "cores": 2}, {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"}),
+ )
+ self.assertDictEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(vimconnector, "process_numa_memory", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_vcpu", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "process_numa_paired_threads",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_numa_cores", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_threads", new_callable=CopyingMock())
+ def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_vio(
+ self,
+ mock_process_numa_threads,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ mock_process_numa_vcpu,
+ mock_process_numa_memory,
+ ):
+ """Process numa parameters, id, cores exist, vim type is VIO.
+ vcpus calculation according to cores in numa.
+ """
+ numas = [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
+ extra_specs = {}
+ expected_extra_specs = {
+ "hw:numa_nodes": "2",
+ "hw:cpu_sockets": "2",
+ "vmware:extra_config": '{"numa.nodeAffinity":"0"}',
+ "vmware:latency_sensitivity_level": "high",
+ }
+ self.vimconn.vim_type = "VIO"
+ vcpus = 2
+ mock_process_numa_cores.side_effect = [1, 2]
+ result = self.vimconn._process_numa_parameters_of_flavor(
+ numas, extra_specs, vcpus
+ )
+ self.assertEqual(result, vcpus)
+ self.check_if_assert_not_called(
+ [mock_process_numa_threads, mock_process_numa_paired_threads]
+ )
+ self.assertEqual(mock_process_numa_memory.call_count, 2)
+ self.assertEqual(mock_process_numa_vcpu.call_count, 2)
+ self.assertEqual(mock_process_numa_cores.call_count, 2)
+ _call_mock_process_numa_cores = mock_process_numa_cores.call_args_list
+ self.assertEqual(
+ _call_mock_process_numa_cores[0].args,
+ ({"id": 0, "cores": 1}, expected_extra_specs),
+ )
+ self.assertEqual(
+ _call_mock_process_numa_cores[1].args,
+ ({"id": 1, "cores": 2}, expected_extra_specs),
+ )
+ self.assertDictEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(vimconnector, "process_numa_memory", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_vcpu", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "process_numa_paired_threads",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_numa_cores", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_threads", new_callable=CopyingMock())
+ def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_vio(
+ self,
+ mock_process_numa_threads,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ mock_process_numa_vcpu,
+ mock_process_numa_memory,
+ ):
+ """Process numa parameters, memory, vcpu, thread exist, vim type is VIO,
+ vcpus calculation according threads in numa, there are not numa ids.
+ """
+ numas = [
+ {"memory": 1, "vcpu": [1, 3], "threads": 3},
+ {"memory": 2, "vcpu": [2]},
+ ]
+ extra_specs = {}
+ expected_extra_specs = {
+ "hw:numa_nodes": "2",
+ "vmware:extra_config": '{"numa.nodeAffinity":"0"}',
+ "vmware:latency_sensitivity_level": "high",
+ "hw:cpu_sockets": "2",
+ }
+ self.vimconn.vim_type = "VIO"
+ vcpus = 3
+ mock_process_numa_threads.return_value = vcpus
+ result = self.vimconn._process_numa_parameters_of_flavor(
+ numas, extra_specs, vcpus
+ )
+ self.assertEqual(result, vcpus)
+ self.check_if_assert_not_called(
+ [
+ mock_process_numa_memory,
+ mock_process_numa_vcpu,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ ]
+ )
+ self.assertEqual(mock_process_numa_threads.call_count, 1)
+ _call_mock_process_numa_threads = mock_process_numa_threads.call_args_list
+ self.assertEqual(
+ _call_mock_process_numa_threads[0].args,
+ (
+ {"memory": 1, "vcpu": [1, 3], "threads": 3},
+ expected_extra_specs,
+ ),
+ )
+ self.assertDictEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(vimconnector, "process_numa_memory", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_vcpu", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "process_numa_paired_threads",
+ new_callable=CopyingMock(autospec=True),
+ )
+ @patch.object(vimconnector, "process_numa_cores", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_threads", new_callable=CopyingMock())
+ def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_openstack(
+ self,
+ mock_process_numa_threads,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ mock_process_numa_vcpu,
+ mock_process_numa_memory,
+ ):
+ """Process numa parameters, memory, vcpu, thread exist, vim type is openstack,
+ vcpus calculation according threads in numa, there are not numa ids.
+ """
+ numas = [
+ {"memory": 1, "vcpu": [1, 3], "threads": 3},
+ {"memory": 2, "vcpu": [2]},
+ ]
+ extra_specs = {}
+ expected_extra_specs = {
+ "hw:numa_nodes": "2",
+ "hw:cpu_sockets": "2",
+ }
+ self.vimconn.vim_type = "openstack"
+ vcpus = 3
+ mock_process_numa_threads.return_value = vcpus
+ result = self.vimconn._process_numa_parameters_of_flavor(
+ numas, extra_specs, vcpus
+ )
+ self.assertEqual(result, vcpus)
+ self.check_if_assert_not_called(
+ [
+ mock_process_numa_memory,
+ mock_process_numa_vcpu,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ ]
+ )
+ self.assertEqual(mock_process_numa_threads.call_count, 1)
+ _call_mock_process_numa_threads = mock_process_numa_threads.call_args_list
+ self.assertEqual(
+ _call_mock_process_numa_threads[0].args,
+ (
+ {"memory": 1, "vcpu": [1, 3], "threads": 3},
+ expected_extra_specs,
+ ),
+ )
+ self.assertDictEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(vimconnector, "process_numa_memory", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_vcpu", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "process_numa_paired_threads",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_numa_cores", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_threads", new_callable=CopyingMock())
+ def test_process_numa_parameters_of_flavor_empty_numas_list_type_vio(
+ self,
+ mock_process_numa_threads,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ mock_process_numa_vcpu,
+ mock_process_numa_memory,
+ ):
+ """Numa list is empty, vim type is VIO."""
+ numas = []
+ extra_specs = {}
+ expected_extra_specs = {
+ "hw:numa_nodes": "0",
+ "vmware:extra_config": '{"numa.nodeAffinity":"0"}',
+ "vmware:latency_sensitivity_level": "high",
+ }
+ self.vimconn.vim_type = "VIO"
+ vcpus = 4
+ mock_process_numa_threads.return_value = None
+ result = self.vimconn._process_numa_parameters_of_flavor(
+ numas, extra_specs, vcpus
+ )
+ self.assertEqual(result, vcpus)
+ self.check_if_assert_not_called(
+ [
+ mock_process_numa_memory,
+ mock_process_numa_vcpu,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ mock_process_numa_threads,
+ ]
+ )
+ self.assertDictEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(vimconnector, "process_numa_memory", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_vcpu", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "process_numa_paired_threads",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_numa_cores", new_callable=CopyingMock())
+ @patch.object(vimconnector, "process_numa_threads", new_callable=CopyingMock())
+ def test_process_numa_parameters_of_flavor_empty_numas_list_type_openstack(
+ self,
+ mock_process_numa_threads,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ mock_process_numa_vcpu,
+ mock_process_numa_memory,
+ ):
+ """Numa list is empty, vim type is openstack."""
+ numas = []
+ extra_specs = {}
+ expected_extra_specs = {"hw:numa_nodes": "0"}
+ self.vimconn.vim_type = "openstack"
+ vcpus = 5
+ mock_process_numa_threads.return_value = None
+ result = self.vimconn._process_numa_parameters_of_flavor(
+ numas, extra_specs, vcpus
+ )
+ self.assertEqual(result, vcpus)
+ self.check_if_assert_not_called(
+ [
+ mock_process_numa_memory,
+ mock_process_numa_vcpu,
+ mock_process_numa_cores,
+ mock_process_numa_paired_threads,
+ mock_process_numa_threads,
+ ]
+ )
+ self.assertDictEqual(extra_specs, expected_extra_specs)
+
+ def test_process_numa_memory_empty_extra_spec(self):
+ numa = {"memory": 2, "vcpu": [2]}
+ node_id = 2
+ extra_specs = {}
+ expected_extra_spec = {"hw:numa_mem.2": 2048}
+ self.vimconn.process_numa_memory(numa, node_id, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+
+ def test_process_numa_memory_not_exist(self):
+ numa = {"vcpu": [2]}
+ node_id = 2
+ extra_specs = {"vmware:latency_sensitivity_level": "high"}
+ self.vimconn.process_numa_memory(numa, node_id, extra_specs)
+ self.assertDictEqual(extra_specs, {"vmware:latency_sensitivity_level": "high"})
+
+ def test_process_numa_memory_node_id_is_none(self):
+ numa = {"memory": 2, "vcpu": [2]}
+ node_id = None
+ extra_specs = {}
+ expected_extra_spec = {"hw:numa_mem.None": 2048}
+ self.vimconn.process_numa_memory(numa, node_id, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+
+ def test_process_numa_memory_node_id_is_int(self):
+ numa = {"memory": 2, "vcpu": [2]}
+ node_id = 0
+ extra_specs = {}
+ expected_extra_spec = {"hw:numa_mem.0": 2048}
+ self.vimconn.process_numa_memory(numa, node_id, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+
+ def test_process_numa_vcpu_empty_extra_spec(self):
+ numa = {"vcpu": [2]}
+ node_id = 0
+ extra_specs = {}
+ expected_extra_spec = {"hw:numa_cpus.0": "2"}
+ self.vimconn.process_numa_vcpu(numa, node_id, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+
+ def test_process_numa_vcpu_not_exist(self):
+ numa = {"memory": 2}
+ node_id = 0
+ extra_specs = {"vmware:latency_sensitivity_level": "high"}
+ expected_extra_spec = {"vmware:latency_sensitivity_level": "high"}
+ self.vimconn.process_numa_vcpu(numa, node_id, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+
+ def test_process_numa_vcpu_empty_node_id(self):
+ numa = {"vcpu": [2]}
+ node_id = ""
+ extra_specs = {}
+ expected_extra_spec = {"hw:numa_cpus.": "2"}
+ self.vimconn.process_numa_vcpu(numa, node_id, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+
+ def test_process_numa_vcpu_empty_numa_dict(self):
+ numa = {}
+ node_id = 4
+ extra_specs = {}
+ self.vimconn.process_numa_vcpu(numa, node_id, extra_specs)
+ self.assertDictEqual(extra_specs, {})
+
+ def test_process_numa_vcpu_str_node_id(self):
+ numa = {"vcpu": [2]}
+ node_id = "12"
+ extra_specs = {}
+ expected_extra_spec = {"hw:numa_cpus.12": "2"}
+ self.vimconn.process_numa_vcpu(numa, node_id, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+
+ def test_process_numa_paired_threads_empty_extra_spec(self):
+ numa = {"id": 0, "paired-threads": 3}
+ extra_specs = {}
+ expected_extra_spec = {
+ "hw:cpu_thread_policy": "require",
+ "hw:cpu_policy": "dedicated",
+ }
+ result = self.vimconn.process_numa_paired_threads(numa, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+ self.assertEqual(result, 6)
+
+ def test_process_numa_paired_threads_empty_numa(self):
+ numa = {}
+ extra_specs = {}
+ result = self.vimconn.process_numa_paired_threads(numa, extra_specs)
+ self.assertDictEqual(extra_specs, {})
+ self.assertEqual(result, None)
+
+ def test_process_numa_paired_threads_not_exist(self):
+ numa = {"vcpu": [2]}
+ extra_specs = {}
+ result = self.vimconn.process_numa_paired_threads(numa, extra_specs)
+ self.assertDictEqual(extra_specs, {})
+ self.assertEqual(result, None)
+
+ def test_process_numa_paired_threads_str_thread_num(self):
+ numa = {"id": 0, "paired-threads": "3"}
+ extra_specs = {}
+ expected_extra_spec = {
+ "hw:cpu_thread_policy": "require",
+ "hw:cpu_policy": "dedicated",
+ }
+ result = self.vimconn.process_numa_paired_threads(numa, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+ self.assertEqual(result, "33")
+
+ def test_process_numa_paired_threads_none_thread_num(self):
+ numa = {"id": 0, "paired-threads": None}
+ extra_specs = {}
+ result = self.vimconn.process_numa_paired_threads(numa, extra_specs)
+ self.assertDictEqual(extra_specs, {})
+ self.assertEqual(result, None)
+
+ def test_process_numa_cores_empty_extra_spec(self):
+ numa = {"id": 0, "cores": 1}
+ extra_specs = {}
+ expected_extra_spec = {
+ "hw:cpu_policy": "dedicated",
+ "hw:cpu_thread_policy": "isolate",
+ }
+ result = self.vimconn.process_numa_cores(numa, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+ self.assertEqual(result, 1)
+
+ def test_process_numa_cores_not_exist(self):
+ numa = {"id": 0, "paired-threads": 3}
+ extra_specs = {}
+ result = self.vimconn.process_numa_cores(numa, extra_specs)
+ self.assertDictEqual(extra_specs, {})
+ self.assertEqual(result, None)
+
+ def test_process_numa_cores_empty_numa(self):
+ numa = {}
+ extra_specs = expected_extra_spec = {"some-key": "some-val"}
+ result = self.vimconn.process_numa_cores(numa, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+ self.assertEqual(result, None)
+
+ def test_process_numa_cores_none_core_num(self):
+ numa = {"memory": 1, "cores": None}
+ extra_specs = {}
+ result = self.vimconn.process_numa_cores(numa, extra_specs)
+ self.assertDictEqual(extra_specs, {})
+ self.assertEqual(result, None)
+
+ def test_process_numa_cores_string_core_num(self):
+ numa = {"id": 0, "cores": "1"}
+ extra_specs = {"some-key": "some-val"}
+ expected_extra_spec = {
+ "hw:cpu_policy": "dedicated",
+ "hw:cpu_thread_policy": "isolate",
+ "some-key": "some-val",
+ }
+ result = self.vimconn.process_numa_cores(numa, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+ self.assertEqual(result, "1")
+
+ def test_process_numa_cores_float_core_num(self):
+ numa = {"memory": 2, "cores": 10.03}
+ extra_specs = {"some-key": "some-val"}
+ expected_extra_spec = {
+ "hw:cpu_policy": "dedicated",
+ "hw:cpu_thread_policy": "isolate",
+ "some-key": "some-val",
+ }
+ result = self.vimconn.process_numa_cores(numa, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+ self.assertEqual(result, 10.03)
+
+ def test_process_numa_threads_empty_extra_spec_int_thread_num(self):
+ numa = {"memory": 1, "vcpu": [1, 3], "threads": 3}
+ extra_specs = {}
+ expected_extra_spec = {
+ "hw:cpu_policy": "dedicated",
+ "hw:cpu_thread_policy": "prefer",
+ }
+ result = self.vimconn.process_numa_threads(numa, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+ self.assertEqual(result, 3)
+
+ def test_process_numa_threads_empty_numa(self):
+ numa = {}
+ extra_specs = {"some-key": "some-val"}
+ expected_extra_spec = {"some-key": "some-val"}
+ result = self.vimconn.process_numa_threads(numa, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+ self.assertEqual(result, None)
+
+ def test_process_numa_threads_not_exist(self):
+ numa = {"memory": 1}
+ extra_specs = expected_extra_spec = {"some-key": "some-val"}
+ result = self.vimconn.process_numa_threads(numa, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+ self.assertEqual(result, None)
+
+ def test_process_numa_threads_str_thread_num(self):
+ numa = {"vcpu": [1, 3], "threads": "3"}
+ extra_specs = {}
+ expected_extra_spec = {
+ "hw:cpu_policy": "dedicated",
+ "hw:cpu_thread_policy": "prefer",
+ }
+ result = self.vimconn.process_numa_threads(numa, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+ self.assertEqual(result, "3")
+
+ def test_process_numa_threads_none_thread_num(self):
+ numa = {"vcpu": [1, 3], "threads": None}
+ extra_specs = {}
+ result = self.vimconn.process_numa_threads(numa, extra_specs)
+ self.assertDictEqual(extra_specs, {})
+ self.assertEqual(result, None)
+
+ def test_process_numa_threads_float_thread_num(self):
+ numa = {"memory": 1, "vcpu": [1, 3], "threads": 3.3}
+ extra_specs = {"some-key": "some-val"}
+ expected_extra_spec = {
+ "hw:cpu_policy": "dedicated",
+ "hw:cpu_thread_policy": "prefer",
+ "some-key": "some-val",
+ }
+ result = self.vimconn.process_numa_threads(numa, extra_specs)
+ self.assertDictEqual(extra_specs, expected_extra_spec)
+ self.assertEqual(result, 3.3)
+
+ def test_change_the_flavor_name_not_existing_name(self):
+ """Flavor name does not exist in Openstack flavor list."""
+ self.flavor1.name = "sample-flavor-3"
+ self.flavor2.name = "other-flavor-4"
+ self.vimconn.nova.flavors.list.return_value = [self.flavor1, self.flavor2]
+ name = "other-flavor-3"
+ name_suffix = 3
+ flavor_data = {"name": "other-flavor"}
+ result = self.vimconn._change_flavor_name(name, name_suffix, flavor_data)
+ self.assertEqual(result, name)
+ self.vimconn.nova.flavors.list.assert_called_once()
+ # Checking whether name_suffix changed or not.
+ self.assertEqual(name_suffix, 3)
+
+ def test_change_the_flavor_name_existing_name(self):
+ """Flavor name exists in Openstack flavor list."""
+ self.flavor1.name = "other-flavor-6"
+ self.flavor2.name = "other-flavor-3"
+ self.vimconn.nova.flavors.list.return_value = [self.flavor1, self.flavor2]
+ name = "other-flavor-3"
+ name_suffix = 5
+ flavor_data = {"name": "other-flavor"}
+ expected_result = "other-flavor-7"
+ result = self.vimconn._change_flavor_name(name, name_suffix, flavor_data)
+ self.assertEqual(result, expected_result)
+ # Checking whether name_suffix changed or not.
+ self.assertEqual(name_suffix, 5)
+ self.vimconn.nova.flavors.list.assert_called_once()
+
+ def test_change_the_flavor_name_flavor_data_does_not_have_name(self):
+ """Flavor data does not have name."""
+ self.flavor1.name = "other-flavor-6"
+ self.flavor2.name = "other-flavor-3"
+ self.vimconn.nova.flavors.list.return_value = [self.flavor1, self.flavor2]
+ name = "other-flavor-3"
+ name_suffix = 5
+ flavor_data = {}
+ with self.assertRaises(KeyError):
+ self.vimconn._change_flavor_name(name, name_suffix, flavor_data)
+ self.vimconn.nova.flavors.list.assert_called_once()
+ # Checking whether name_suffix changed or not.
+ self.assertEqual(name_suffix, 5)
+
+ def test_change_the_flavor_name_invalid_name_suffix(self):
+ """Name suffix is invalid."""
+ self.flavor1.name = "other-flavor-6"
+ self.flavor2.name = "other-flavor-3"
+ self.vimconn.nova.flavors.list.return_value = [self.flavor1, self.flavor2]
+ name = "other-flavor-3"
+ name_suffix = "a"
+ flavor_data = {"name": "other-flavor"}
+ with self.assertRaises(TypeError):
+ self.vimconn._change_flavor_name(name, name_suffix, flavor_data)
+ self.vimconn.nova.flavors.list.assert_called_once()
+ # Checking whether name_suffix changed or not.
+ self.assertEqual(name_suffix, "a")
+
+ def test_change_the_flavor_name_given_name_is_empty(self):
+ """Given name is empty string."""
+ self.flavor1.name = "other-flavor-6"
+ self.flavor2.name = "other-flavor-3"
+ self.vimconn.nova.flavors.list.return_value = [self.flavor1, self.flavor2]
+ name = ""
+ name_suffix = 3
+ flavor_data = {"name": "other-flavor"}
+ result = self.vimconn._change_flavor_name(name, name_suffix, flavor_data)
+ self.assertEqual(result, "")
+ self.vimconn.nova.flavors.list.assert_called_once()
+ # Checking whether name_suffix increased or not.
+ self.assertEqual(name_suffix, 3)
+
+ def test_change_the_flavor_name_given_name_is_none(self):
+ """Given name is None."""
+ self.flavor1.name = "other-flavor-6"
+ self.flavor2.name = "other-flavor-3"
+ self.vimconn.nova.flavors.list.return_value = [self.flavor1, self.flavor2]
+ name = None
+ name_suffix = 6
+ flavor_data = {"name": "other-flavor"}
+ result = self.vimconn._change_flavor_name(name, name_suffix, flavor_data)
+ self.assertEqual(result, None)
+ self.vimconn.nova.flavors.list.assert_called_once()
+ # Checking whether name_suffix increased or not.
+ self.assertEqual(name_suffix, 6)
+
+ def test_change_the_flavor_name_empty_nova_flavor_list(self):
+ """Nova flavor list is empty."""
+ self.vimconn.nova.flavors.list.return_value = []
+ name = "other-flavor-3"
+ name_suffix = 5
+ flavor_data = {"name": "other-flavor"}
+ result = self.vimconn._change_flavor_name(name, name_suffix, flavor_data)
+ self.vimconn.nova.flavors.list.assert_called_once()
+ self.assertEqual(result, name)
+ # Checking whether name_suffix increased or not.
+ self.assertEqual(name_suffix, 5)
+
+ @patch.object(
+ vimconnector,
+ "_process_numa_parameters_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_resource_quota", new_callable=CopyingMock())
+ def test_process_extended_config_of_flavor_with_numa_cpu_mem_vif_disk_quota(
+ self, mock_process_resource_quota, mock_process_numa_parameters_of_flavor
+ ):
+ """Process extended config, extended has numas, cpu, mem, vif and disk-io quota."""
+ numas = [
+ {"memory": 1, "vcpu": [1, 3], "threads": 3},
+ {"memory": 2, "vcpu": [2]},
+ ]
+ vcpus = 3
+ extended = {
+ "numas": numas,
+ "cpu-quota": {"limit": 3},
+ "mem-quota": {"limit": 1},
+ "vif-quota": {"limit": 10},
+ "disk-io-quota": {"limit": 50},
+ "mempage-size": "LARGE",
+ }
+ extra_specs = {}
+ expected_extra_specs = {
+ "hw:mem_page_size": "large",
+ }
+ mock_process_numa_parameters_of_flavor.return_value = vcpus
+ result = self.vimconn._process_extended_config_of_flavor(
+ extended, extra_specs, vcpus
+ )
+ self.assertEqual(result, vcpus)
+ self.assertEqual(mock_process_resource_quota.call_count, 4)
+ mock_process_numa_parameters_of_flavor.assert_called_once_with(numas, {}, vcpus)
+ self.assertEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(
+ vimconnector,
+ "_process_numa_parameters_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_resource_quota", new_callable=CopyingMock())
+ def test_process_extended_config_of_flavor_with_numa_wrong_disk_quota(
+ self, mock_process_resource_quota, mock_process_numa_parameters_of_flavor
+ ):
+ """Process extended config, extended has wrong disk quota key."""
+ numas = [
+ {"memory": 1, "threads": 3},
+ {"memory": 2, "vcpu": [2]},
+ ]
+ vcpus = 3
+ extended = {
+ "numas": numas,
+ "disk-quota": {"limit": 50},
+ "mempage-size": "PREFER_LARGE",
+ }
+ extra_specs = {}
+ expected_extra_specs = {
+ "hw:mem_page_size": "any",
+ }
+ mock_process_numa_parameters_of_flavor.return_value = vcpus
+ result = self.vimconn._process_extended_config_of_flavor(
+ extended, extra_specs, vcpus
+ )
+ self.assertEqual(result, vcpus)
+ mock_process_resource_quota.assert_not_called()
+ mock_process_numa_parameters_of_flavor.assert_called_once_with(numas, {}, vcpus)
+ self.assertEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(
+ vimconnector,
+ "_process_numa_parameters_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_resource_quota", new_callable=CopyingMock())
+ def test_process_extended_config_of_flavor_without_numa_cpu_mem_vif_disk_quota(
+ self, mock_process_resource_quota, mock_process_numa_parameters_of_flavor
+ ):
+ """Process extended config, extended has cpu, mem, vif and disk-io quota but not numas."""
+ vcpus = 3
+ extended = {
+ "cpu-quota": {"limit": 3},
+ "mem-quota": {"limit": 1},
+ "vif-quota": {"limit": 10},
+ "disk-io-quota": {"limit": 50},
+ "mempage-size": "SMALL",
+ }
+ extra_specs = {}
+ expected_extra_specs = {
+ "hw:mem_page_size": "small",
+ }
+ mock_process_numa_parameters_of_flavor.return_value = vcpus
+ result = self.vimconn._process_extended_config_of_flavor(
+ extended, extra_specs, vcpus
+ )
+ self.assertEqual(result, vcpus)
+ self.assertEqual(mock_process_resource_quota.call_count, 4)
+ mock_process_numa_parameters_of_flavor.assert_not_called()
+ self.assertEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(
+ vimconnector,
+ "_process_numa_parameters_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_resource_quota", new_callable=CopyingMock())
+ def test_process_extended_config_of_flavor_with_numa_with_cpu_pinning_mem_policy(
+ self, mock_process_resource_quota, mock_process_numa_parameters_of_flavor
+ ):
+ """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy."""
+ numas = [
+ {"memory": 1},
+ {"memory": 2, "vcpu": [2]},
+ ]
+ extended = {
+ "numas": numas,
+ "cpu-quota": {"limit": 3},
+ "mem-quota": {"limit": 1},
+ "mempage-size": "LARGE",
+ "cpu-pinning-policy": "DEDICATED",
+ "mem-policy": "STRICT",
+ }
+ extra_specs = {}
+ vcpus = 3
+ expected_extra_specs = {
+ "hw:mem_page_size": "large",
+ "hw:cpu_policy": "dedicated",
+ "hw:numa_mempolicy": "strict",
+ }
+ mock_process_numa_parameters_of_flavor.return_value = 4
+ result = self.vimconn._process_extended_config_of_flavor(
+ extended, extra_specs, vcpus
+ )
+ self.assertEqual(result, 4)
+ self.assertEqual(mock_process_resource_quota.call_count, 2)
+ mock_process_numa_parameters_of_flavor.assert_called_once_with(numas, {}, vcpus)
+ self.assertEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(
+ vimconnector,
+ "_process_numa_parameters_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_resource_quota", new_callable=CopyingMock())
+ def test_process_extended_config_of_flavor_without_numa_with_cpu_pinning_mem_policy(
+ self, mock_process_resource_quota, mock_process_numa_parameters_of_flavor
+ ):
+ """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy but not numas."""
+ extended = {
+ "cpu-quota": {"limit": 3},
+ "mem-quota": {"limit": 1},
+ "mempage-size": "LARGE",
+ "cpu-pinning-policy": "DEDICATED",
+ "mem-policy": "STRICT",
+ }
+ extra_specs = {}
+ vcpus = 3
+ expected_extra_specs = {
+ "hw:mem_page_size": "large",
+ "hw:cpu_policy": "dedicated",
+ "hw:numa_mempolicy": "strict",
+ }
+ result = self.vimconn._process_extended_config_of_flavor(
+ extended, extra_specs, vcpus
+ )
+ self.assertEqual(result, 3)
+ self.assertEqual(mock_process_resource_quota.call_count, 2)
+ mock_process_numa_parameters_of_flavor.assert_not_called()
+ self.assertEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(
+ vimconnector,
+ "_process_numa_parameters_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_resource_quota", new_callable=CopyingMock())
+ def test_process_extended_config_of_flavor_without_numa_with_wrong_mempage_size(
+ self, mock_process_resource_quota, mock_process_numa_parameters_of_flavor
+ ):
+ """Process extended config, extended has wrong mempage-size without numas."""
+ extended = {
+ "cpu-quota": {"limit": 3},
+ "mem-quota": {"limit": 1},
+ "mempage-size": "SIZE_2GB",
+ "cpu-pinning-policy": "DEDICATED",
+ "mem-policy": "STRICT",
+ }
+ extra_specs = {}
+ vcpus = 6
+ expected_extra_specs = {
+ "hw:cpu_policy": "dedicated",
+ "hw:numa_mempolicy": "strict",
+ }
+ result = self.vimconn._process_extended_config_of_flavor(
+ extended, extra_specs, vcpus
+ )
+ self.assertEqual(result, 6)
+ self.assertEqual(mock_process_resource_quota.call_count, 2)
+ mock_process_numa_parameters_of_flavor.assert_not_called()
+ self.assertEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(
+ vimconnector,
+ "_process_numa_parameters_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_resource_quota", new_callable=CopyingMock())
+ def test_process_extended_config_of_flavor_with_numa_with_wrong_mempage_size(
+ self, mock_process_resource_quota, mock_process_numa_parameters_of_flavor
+ ):
+ """Process extended config, extended has wrong mempage-size with numas."""
+ numas = [
+ {"memory": 1},
+ {"memory": 2, "vcpu": [2]},
+ ]
+ extended = {
+ "numas": numas,
+ "cpu-quota": {"limit": 3},
+ "mem-quota": {"limit": 1},
+ "mempage-size": "SIZE_2GB",
+ "cpu-pinning-policy": "DEDICATED",
+ "mem-policy": "STRICT",
+ }
+ extra_specs = {}
+ mock_process_numa_parameters_of_flavor.return_value = 4
+ vcpus = 1
+ expected_extra_specs = {
+ "hw:cpu_policy": "dedicated",
+ "hw:numa_mempolicy": "strict",
+ }
+ result = self.vimconn._process_extended_config_of_flavor(
+ extended, extra_specs, vcpus
+ )
+ self.assertEqual(result, 4)
+ self.assertEqual(mock_process_resource_quota.call_count, 2)
+ mock_process_numa_parameters_of_flavor.assert_called_once_with(numas, {}, vcpus)
+ self.assertEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(
+ vimconnector,
+ "_process_numa_parameters_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_resource_quota", new_callable=CopyingMock())
+ def test_process_extended_config_of_flavor_none_vcpus(
+ self, mock_process_resource_quota, mock_process_numa_parameters_of_flavor
+ ):
+ """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
+ numas = [
+ {"memory": 1},
+ {"memory": 2, "vcpu": [2]},
+ ]
+ extended = {
+ "numas": numas,
+ "cpu-quota": {"limit": 3},
+ "mem-quota": {"limit": 1},
+ "mempage-size": "SIZE_2GB",
+ "cpu-pinning-policy": "DEDICATED",
+ "mem-policy": "STRICT",
+ }
+ mock_process_numa_parameters_of_flavor.return_value = 1
+ extra_specs = {}
+ vcpus = None
+ expected_extra_specs = {
+ "hw:cpu_policy": "dedicated",
+ "hw:numa_mempolicy": "strict",
+ }
+ result = self.vimconn._process_extended_config_of_flavor(
+ extended, extra_specs, vcpus
+ )
+ self.assertEqual(result, 1)
+ self.assertEqual(mock_process_resource_quota.call_count, 2)
+ mock_process_numa_parameters_of_flavor.assert_called_once_with(numas, {}, vcpus)
+ self.assertEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(
+ vimconnector,
+ "_process_numa_parameters_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_resource_quota", new_callable=CopyingMock())
+ def test_process_extended_config_of_flavor_none_vcpus_without_numas(
+ self, mock_process_resource_quota, mock_process_numa_parameters_of_flavor
+ ):
+ """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
+ extended = {
+ "cpu-quota": {"limit": 3},
+ "mem-quota": {"limit": 1},
+ "mempage-size": "SIZE_2GB",
+ "cpu-pinning-policy": "DEDICATED",
+ "mem-policy": "STRICT",
+ }
+ extra_specs = {"some-key": "some-val"}
+ vcpus = None
+ expected_extra_specs = {
+ "hw:cpu_policy": "dedicated",
+ "hw:numa_mempolicy": "strict",
+ "some-key": "some-val",
+ }
+ result = self.vimconn._process_extended_config_of_flavor(
+ extended, extra_specs, vcpus
+ )
+ self.assertEqual(result, None)
+ self.assertEqual(mock_process_resource_quota.call_count, 2)
+ mock_process_numa_parameters_of_flavor.assert_not_called()
+ self.assertEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(
+ vimconnector,
+ "_process_numa_parameters_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_resource_quota", new_callable=CopyingMock())
+ def test_process_extended_config_of_flavor_wrong_cpu_pinning_mem_policy_empty_vcpus(
+ self, mock_process_resource_quota, mock_process_numa_parameters_of_flavor
+ ):
+ """Process extended config, extended has wrong cpu-pinning and mem-policy keys."""
+ numas = [
+ {"memory": 1},
+ {"memory": 2, "vcpu": [2]},
+ ]
+ extended = {
+ "numas": numas,
+ "cpu-quota": {"limit": 3},
+ "mem-quota": {"limit": 1},
+ "mempage-size": "SIZE_2GB",
+ "cpu-pinning-pol": "DEDICATED",
+ "mem-pol": "STRICT",
+ }
+ mock_process_numa_parameters_of_flavor.return_value = 1
+ extra_specs = {}
+ vcpus = ""
+ expected_extra_specs = {}
+ result = self.vimconn._process_extended_config_of_flavor(
+ extended, extra_specs, vcpus
+ )
+ self.assertEqual(result, 1)
+ self.assertEqual(mock_process_resource_quota.call_count, 2)
+ mock_process_numa_parameters_of_flavor.assert_called_once_with(
+ numas, extra_specs, vcpus
+ )
+ self.assertEqual(extra_specs, expected_extra_specs)
+
+ @patch.object(
+ vimconnector,
+ "_process_numa_parameters_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "process_resource_quota", new_callable=CopyingMock())
+ def test_process_extended_config_of_flavor_empty_extended(
+ self, mock_process_resource_quota, mock_process_numa_parameters_of_flavor
+ ):
+ """Process extended config, extended is empty."""
+ extended = {}
+ extra_specs = {}
+ vcpus = 2
+ result = self.vimconn._process_extended_config_of_flavor(
+ extended, extra_specs, vcpus
+ )
+ self.assertEqual(result, 2)
+ self.check_if_assert_not_called(
+ [mock_process_resource_quota, mock_process_numa_parameters_of_flavor]
+ )
+ self.assertEqual(extra_specs, {})
+
+ def test_get_flavor_details_empty_flavor_data(self):
+ flavor_data = {}
+ expected_result = (64, 1, {}, None)
+ result = self.vimconn._get_flavor_details(flavor_data)
+ self.assertEqual(result, expected_result)
+
+ def test_get_flavor_details_flavor_data_has_ram_vcpus_extended(self):
+ flavor_data = {
+ "ram": 32,
+ "vcpus": 3,
+ "extended": {
+ "some-key": "some-val",
+ },
+ }
+ expected_result = (32, 3, {}, {"some-key": "some-val"})
+ result = self.vimconn._get_flavor_details(flavor_data)
+ self.assertEqual(result, expected_result)
+
+ def test_get_flavor_details_flavor_data_is_none(self):
+ flavor_data = None
+ with self.assertRaises(AttributeError):
+ self.vimconn._get_flavor_details(flavor_data)
+
+ def test_get_flavor_details_flavor_data_has_only_extended(self):
+ flavor_data = {
+ "extended": {
+ "some-key": "some-val",
+ }
+ }
+ expected_result = (64, 1, {}, {"some-key": "some-val"})
+ result = self.vimconn._get_flavor_details(flavor_data)
+ self.assertEqual(result, expected_result)
+
+ @patch.object(vimconnector, "_get_flavor_details", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "_process_extended_config_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "_change_flavor_name", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_reload_connection", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_format_exception", new_callable=CopyingMock())
+ def test_new_flavor_with_extended_with_extra_specs(
+ self,
+ mock_format_exception,
+ mock_reload_connection,
+ mock_change_flavor_name,
+ mock_extended_config_of_flavor,
+ mock_get_flavor_details,
+ ):
+ """Create new flavor with using extended parameters and extra specs."""
+ name_suffix = 0
+ vcpus = 8
+ mock_change_flavor_name.return_value = name1
+ mock_extended_config_of_flavor.return_value = vcpus
+ mock_get_flavor_details.return_value = (
+ 3,
+ vcpus,
+ {"some-key": "some-value"},
+ extended,
+ )
+ expected_result = self.new_flavor.id
+ result = self.vimconn.new_flavor(flavor_data)
+ self.assertEqual(result, expected_result)
+ mock_reload_connection.assert_called_once()
+ self.new_flavor.set_keys.assert_called_once()
+ mock_get_flavor_details.assert_called_once_with(flavor_data)
+ mock_change_flavor_name.assert_called_once_with(name1, name_suffix, flavor_data)
+ mock_extended_config_of_flavor.assert_called_once_with(
+ extended, {"some-key": "some-value"}, vcpus
+ )
+ self.vimconn.nova.flavors.create.assert_called_once_with(
+ name=name1, ram=3, vcpus=8, disk=50, ephemeral=0, swap=0, is_public=True
+ )
+ mock_format_exception.assert_not_called()
+
+ @patch.object(vimconnector, "_get_flavor_details", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "_process_extended_config_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "_change_flavor_name", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_reload_connection", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_format_exception", new_callable=CopyingMock())
+ def test_new_flavor_with_extended_without_extra_specs(
+ self,
+ mock_format_exception,
+ mock_reload_connection,
+ mock_change_flavor_name,
+ mock_extended_config_of_flavor,
+ mock_get_flavor_details,
+ ):
+ """Create new flavor with using extended parameters without extra specs."""
+ name_suffix = 0
+ vcpus = 8
+ mock_change_flavor_name.return_value = name1
+ mock_extended_config_of_flavor.return_value = vcpus
+ mock_get_flavor_details.return_value = (3, vcpus, {}, extended)
+ expected_result = self.new_flavor.id
+ result = self.vimconn.new_flavor(flavor_data)
+ self.assertEqual(result, expected_result)
+ mock_reload_connection.assert_called_once()
+
+ mock_get_flavor_details.assert_called_once_with(flavor_data)
+ mock_change_flavor_name.assert_called_once_with(name1, name_suffix, flavor_data)
+ mock_extended_config_of_flavor.assert_called_once_with(extended, {}, vcpus)
+ self.vimconn.nova.flavors.create.assert_called_once_with(
+ name=name1, ram=3, vcpus=vcpus, disk=50, ephemeral=0, swap=0, is_public=True
+ )
+ self.check_if_assert_not_called(
+ [self.new_flavor.set_keys, mock_format_exception]
+ )
+
+ @patch.object(vimconnector, "_get_flavor_details", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "_process_extended_config_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "_change_flavor_name", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_reload_connection", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_format_exception", new_callable=CopyingMock())
+ def test_new_flavor_change_name_if_used_false_with_extended(
+ self,
+ mock_format_exception,
+ mock_reload_connection,
+ mock_change_flavor_name,
+ mock_extended_config_of_flavor,
+ mock_get_flavor_details,
+ ):
+ """Create new flavor, change_name_if_used_false, there is extended."""
+ vcpus = 8
+ mock_get_flavor_details.return_value = (3, vcpus, {}, extended)
+ mock_extended_config_of_flavor.return_value = 16
+ expected_result = self.new_flavor.id
+ result = self.vimconn.new_flavor(flavor_data, False)
+ self.assertEqual(result, expected_result)
+ mock_reload_connection.assert_called_once()
+ self.assertEqual(mock_get_flavor_details.call_count, 1)
+ mock_extended_config_of_flavor.assert_called_once_with(extended, {}, vcpus)
+ self.vimconn.nova.flavors.create.assert_called_once_with(
+ name=name1, ram=3, vcpus=16, disk=50, ephemeral=0, swap=0, is_public=True
+ )
+ self.check_if_assert_not_called(
+ [mock_change_flavor_name, mock_format_exception, self.new_flavor.set_keys]
+ )
+
+ @patch.object(vimconnector, "_get_flavor_details", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "_process_extended_config_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "_change_flavor_name", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_reload_connection", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_format_exception", new_callable=CopyingMock())
+ def test_new_flavor_change_name_if_used_true_without_extended(
+ self,
+ mock_format_exception,
+ mock_reload_connection,
+ mock_change_flavor_name,
+ mock_extended_config_of_flavor,
+ mock_get_flavor_details,
+ ):
+ """Create new flavor without extended parameters."""
+ name_suffix = 0
+ mock_change_flavor_name.return_value = name1
+ expected_result = self.new_flavor.id
+ mock_get_flavor_details.return_value = (3, 8, {}, None)
+ result = self.vimconn.new_flavor(flavor_data2)
+ self.assertEqual(result, expected_result)
+
+ mock_reload_connection.assert_called_once()
+ mock_change_flavor_name.assert_called_once_with(
+ name1, name_suffix, flavor_data2
+ )
+ self.assertEqual(mock_get_flavor_details.call_count, 1)
+
+ self.vimconn.nova.flavors.create.assert_called_once_with(
+ name=name1, ram=3, vcpus=8, disk=50, ephemeral=0, swap=0, is_public=True
+ )
+ self.check_if_assert_not_called(
+ [
+ self.new_flavor.set_keys,
+ mock_extended_config_of_flavor,
+ mock_format_exception,
+ ]
+ )
+
+ @patch.object(vimconnector, "_get_flavor_details", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "_process_extended_config_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "_change_flavor_name", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_reload_connection", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_format_exception", new_callable=CopyingMock())
+ def test_new_flavor_reload_connection_exception(
+ self,
+ mock_format_exception,
+ mock_reload_connection,
+ mock_change_flavor_name,
+ mock_extended_config_of_flavor,
+ mock_get_flavor_details,
+ ):
+ """Create new flavor, reload connection exception occurred."""
+ error_msg = "Can not connect to client APIs."
+ error = nvExceptions.ClientException(error_msg)
+ mock_change_flavor_name.return_value = name1
+ mock_reload_connection.side_effect = error
+ with self.assertRaises(Exception) as err:
+ self.vimconn.new_flavor(flavor_data2)
+ self.assertEqual(str(err.exception), "Can not connect to client APIs.")
+ self.assertEqual(mock_reload_connection.call_count, 1)
+ call_mock_format_exception = mock_format_exception.call_args
+ self.assertEqual(
+ str(call_mock_format_exception[0][0]), str(ClientException(error_msg))
+ )
+ self.check_if_assert_not_called(
+ [
+ mock_change_flavor_name,
+ mock_get_flavor_details,
+ mock_extended_config_of_flavor,
+ self.vimconn.nova.flavors.create,
+ ]
+ )
+
+ @patch.object(vimconnector, "_get_flavor_details", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "_process_extended_config_of_flavor",
+ new_callable=CopyingMock(autospec=True),
+ )
+ @patch.object(vimconnector, "_change_flavor_name", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_reload_connection", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_format_exception", new_callable=CopyingMock())
+ def test_new_flavor_flavor_data_without_name(
+ self,
+ mock_format_exception,
+ mock_reload_connection,
+ mock_change_flavor_name,
+ mock_extended_config_of_flavor,
+ mock_get_flavor_details,
+ ):
+ """Create new flavor, flavor data does not have name."""
+ flavor_data3 = {
+ "ram": 3,
+ "vcpus": 8,
+ "disk": 50,
+ }
+ error_msg = "name"
+ self.vimconn.new_flavor(flavor_data3)
+ mock_format_exception.assert_called_once()
+ call_mock_format_exception = mock_format_exception.call_args
+ self.assertEqual(
+ str(call_mock_format_exception[0][0]), str(KeyError(error_msg))
+ )
+ self.check_if_assert_not_called(
+ [
+ mock_reload_connection,
+ mock_change_flavor_name,
+ mock_get_flavor_details,
+ mock_extended_config_of_flavor,
+ self.vimconn.nova.flavors.create,
+ ]
+ )
+
+ @patch.object(vimconnector, "_get_flavor_details", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "_process_extended_config_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "_change_flavor_name", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_reload_connection", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_format_exception", new_callable=CopyingMock())
+ def test_new_flavor_change_flavor_name_has_extended_conflict_exception_recovered_in_retry(
+ self,
+ mock_format_exception,
+ mock_reload_connection,
+ mock_change_flavor_name,
+ mock_extended_config_of_flavor,
+ mock_get_flavor_details,
+ ):
+ """Create new flavor, nvExceptions.Conflict occurred and recovered, there is extended config."""
+ name_suffix = 0
+ error_msg = "Conflict has occurred while creating flavor name."
+ error2 = nvExceptions.Conflict(error_msg)
+ mock_change_flavor_name.side_effect = [error2, "sample-flavor-3"]
+ expected_result = self.new_flavor.id
+ mock_get_flavor_details.return_value = (3, 8, {}, extended)
+ mock_extended_config_of_flavor.return_value = 10
+ result = self.vimconn.new_flavor(flavor_data2)
+ self.assertEqual(result, expected_result)
+ self.assertEqual(mock_reload_connection.call_count, 2)
+
+ mock_change_flavor_name.assert_called_with(name1, name_suffix, flavor_data2)
+ self.assertEqual(mock_change_flavor_name.call_count, 2)
+ self.assertEqual(mock_get_flavor_details.call_count, 1)
+ self.assertEqual(mock_extended_config_of_flavor.call_count, 1)
+ self.vimconn.nova.flavors.create.assert_called_once_with(
+ name="sample-flavor-3",
+ ram=3,
+ vcpus=10,
+ disk=50,
+ ephemeral=0,
+ swap=0,
+ is_public=True,
+ )
+ self.check_if_assert_not_called(
+ [self.new_flavor.set_keys, mock_format_exception]
+ )
+
+ @patch.object(vimconnector, "_get_flavor_details", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "_process_extended_config_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "_change_flavor_name", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_reload_connection", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_format_exception", new_callable=CopyingMock())
+ def test_new_flavor_change_flavor_name_without_extended_conflict_exception_recovered_in_retry(
+ self,
+ mock_format_exception,
+ mock_reload_connection,
+ mock_change_flavor_name,
+ mock_extended_config_of_flavor,
+ mock_get_flavor_details,
+ ):
+ """Create new flavor, nvExceptions.Conflict occurred and recovered, there is not extended config."""
+ name_suffix = 0
+ error2 = nvExceptions.Conflict(
+ "Conflict has occurred while creating flavor name."
+ )
+ mock_change_flavor_name.side_effect = [error2, "sample-flavor-3"]
+ expected_result = self.new_flavor.id
+ mock_get_flavor_details.return_value = (3, 8, {}, None)
+ result = self.vimconn.new_flavor(flavor_data2)
+
+ self.assertEqual(result, expected_result)
+ self.assertEqual(mock_reload_connection.call_count, 2)
+ mock_change_flavor_name.assert_called_with(name1, name_suffix, flavor_data2)
+ self.assertEqual(mock_change_flavor_name.call_count, 2)
+ self.assertEqual(mock_get_flavor_details.call_count, 1)
+
+ self.vimconn.nova.flavors.create.assert_called_once_with(
+ name="sample-flavor-3",
+ ram=3,
+ vcpus=8,
+ disk=50,
+ ephemeral=0,
+ swap=0,
+ is_public=True,
+ )
+ self.check_if_assert_not_called(
+ [
+ self.new_flavor.set_keys,
+ mock_extended_config_of_flavor,
+ mock_format_exception,
+ ]
+ )
+
+ @patch.object(vimconnector, "_get_flavor_details", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "_process_extended_config_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "_change_flavor_name", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_reload_connection", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_format_exception", new_callable=CopyingMock())
+ def test_new_flavor_change_flavor_name_conflict_exception_change_name_if_used_false(
+ self,
+ mock_format_exception,
+ mock_reload_connection,
+ mock_change_flavor_name,
+ mock_extended_config_of_flavor,
+ mock_get_flavor_details,
+ ):
+ """Create new flavor, nvExceptions.Conflict occurred,
+ change_name_if_used is false."""
+ change_name_if_used = False
+ error_msg = "Conflict has occurred while creating flavor name."
+ error2 = nvExceptions.Conflict(error_msg)
+ mock_get_flavor_details.return_value = (4, 8, {}, None)
+ self.vimconn.nova.flavors.create.side_effect = error2
+ with self.assertRaises(Exception) as err:
+ self.vimconn.new_flavor(flavor_data2, change_name_if_used)
+ self.assertEqual(str(err.exception), error_msg)
+ self.assertEqual(type(err.exception), nvExceptions.Conflict)
+ self.vimconn.nova.flavors.create.assert_called_with(
+ name="sample-flavor",
+ ram=4,
+ vcpus=8,
+ disk=50,
+ ephemeral=0,
+ swap=0,
+ is_public=True,
+ )
+ self.assertEqual(mock_get_flavor_details.call_count, 3)
+ self.assertEqual(self.vimconn.nova.flavors.create.call_count, 3)
+ self.assertEqual(mock_reload_connection.call_count, 3)
+ self.check_if_assert_not_called(
+ [mock_change_flavor_name, mock_extended_config_of_flavor]
+ )
+ _call_mock_format_exception = mock_format_exception.call_args
+ self.assertEqual(
+ str(_call_mock_format_exception[0][0]), str(Conflict(error_msg))
+ )
+ self.assertEqual(mock_format_exception.call_count, 3)
+
+ @patch.object(vimconnector, "_get_flavor_details", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "_process_extended_config_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "_change_flavor_name", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_reload_connection", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_format_exception", new_callable=CopyingMock())
+ def test_new_flavor_client_exception_occurred_change_name_if_used_true(
+ self,
+ mock_format_exception,
+ mock_reload_connection,
+ mock_change_flavor_name,
+ mock_extended_config_of_flavor,
+ mock_get_flavor_details,
+ ):
+ """Create new flavor, nvExceptions.ClientException occurred,
+ change_name_if_used is true."""
+ error_msg = "Connection failed."
+ error2 = nvExceptions.ClientException(error_msg)
+ mock_change_flavor_name.side_effect = [
+ "sample-flavor-3",
+ "sample-flavor-4",
+ "sample-flavor-5",
+ ]
+ mock_get_flavor_details.return_value = (3, 8, {}, None)
+ self.vimconn.nova.flavors.create.side_effect = error2
+ with self.assertRaises(Exception) as err:
+ self.vimconn.new_flavor(flavor_data2)
+ self.assertEqual(
+ str(err.exception), "Conflict has occurred while creating flavor name."
+ )
+ self.assertEqual(type(err.exception), nvExceptions.Conflict)
+ self.assertEqual(self.vimconn.nova.flavors.create.call_count, 1)
+ _call_mock_nova_create_flavor = self.vimconn.nova.flavors.create.call_args_list
+ self.assertEqual(
+ _call_mock_nova_create_flavor[0][1],
+ (
+ {
+ "name": "sample-flavor-3",
+ "ram": 3,
+ "vcpus": 8,
+ "disk": 50,
+ "ephemeral": 0,
+ "swap": 0,
+ "is_public": True,
+ }
+ ),
+ )
+
+ self.assertEqual(mock_reload_connection.call_count, 1)
+ self.assertEqual(mock_get_flavor_details.call_count, 1)
+ _call_mock_change_flavor = mock_change_flavor_name.call_args_list
+ self.assertEqual(
+ _call_mock_change_flavor[0][0],
+ (
+ "sample-flavor",
+ 0,
+ {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
+ ),
+ )
+ self.assertEqual(mock_change_flavor_name.call_count, 1)
+ mock_extended_config_of_flavor.assert_not_called()
+ call_mock_format_exception = mock_format_exception.call_args
+ self.assertEqual(
+ str(call_mock_format_exception[0][0]), str(ClientException(error_msg))
+ )
+ self.assertEqual(mock_format_exception.call_count, 1)
+
+ @patch.object(vimconnector, "_get_flavor_details", new_callable=CopyingMock())
+ @patch.object(
+ vimconnector,
+ "_process_extended_config_of_flavor",
+ new_callable=CopyingMock(),
+ )
+ @patch.object(vimconnector, "_change_flavor_name", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_reload_connection", new_callable=CopyingMock())
+ @patch.object(vimconnector, "_format_exception", new_callable=CopyingMock())
+ def test_new_flavor_change_flavor_name_conflict_exception_occurred_change_name_if_used_true(
+ self,
+ mock_format_exception,
+ mock_reload_connection,
+ mock_change_flavor_name,
+ mock_extended_config_of_flavor,
+ mock_get_flavor_details,
+ ):
+ """Create new flavor, nvExceptions.Conflict occurred,
+ change_name_if_used is true."""
+ error_msg = "Conflict has occurred while creating flavor name."
+ error2 = nvExceptions.Conflict(error_msg)
+ mock_change_flavor_name.side_effect = [
+ "sample-flavor-3",
+ "sample-flavor-4",
+ "sample-flavor-5",
+ ]
+ mock_get_flavor_details.return_value = (3, 8, {}, None)
+ self.vimconn.nova.flavors.create.side_effect = error2
+ with self.assertRaises(Exception) as err:
+ self.vimconn.new_flavor(flavor_data2)
+ self.assertEqual(str(err.exception), error_msg)
+ self.assertEqual(type(err.exception), nvExceptions.Conflict)
+ self.assertEqual(self.vimconn.nova.flavors.create.call_count, 3)
+ _call_mock_nova_create_flavor = self.vimconn.nova.flavors.create.call_args_list
+ self.assertEqual(
+ _call_mock_nova_create_flavor[0][1],
+ (
+ {
+ "name": "sample-flavor-3",
+ "ram": 3,
+ "vcpus": 8,
+ "disk": 50,
+ "ephemeral": 0,
+ "swap": 0,
+ "is_public": True,
+ }
+ ),
+ )
+ self.assertEqual(
+ _call_mock_nova_create_flavor[1][1],
+ (
+ {
+ "name": "sample-flavor-4",
+ "ram": 3,
+ "vcpus": 8,
+ "disk": 50,
+ "ephemeral": 0,
+ "swap": 0,
+ "is_public": True,
+ }
+ ),
+ )
+ self.assertEqual(
+ _call_mock_nova_create_flavor[2][1],
+ (
+ {
+ "name": "sample-flavor-5",
+ "ram": 3,
+ "vcpus": 8,
+ "disk": 50,
+ "ephemeral": 0,
+ "swap": 0,
+ "is_public": True,
+ }
+ ),
+ )
+
+ self.assertEqual(mock_reload_connection.call_count, 3)
+ _call_mock_change_flavor = mock_change_flavor_name.call_args_list
+ self.assertEqual(
+ _call_mock_change_flavor[0][0],
+ (
+ "sample-flavor",
+ 0,
+ {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
+ ),
+ )
+ self.assertEqual(
+ _call_mock_change_flavor[1][0],
+ (
+ "sample-flavor-3",
+ 0,
+ {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
+ ),
+ )
+ self.assertEqual(
+ _call_mock_change_flavor[2][0],
+ (
+ "sample-flavor-4",
+ 0,
+ {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
+ ),
+ )
+ self.assertEqual(mock_change_flavor_name.call_count, 3)
+ mock_extended_config_of_flavor.assert_not_called()
+ call_mock_format_exception = mock_format_exception.call_args
+ self.assertEqual(
+ str(call_mock_format_exception[0][0]), str(Conflict(error_msg))
+ )
+ self.assertEqual(mock_format_exception.call_count, 1)
+
+
if __name__ == "__main__":
unittest.main()
diff --git a/RO-VIM-openstack/osm_rovim_openstack/vimconn_openstack.py b/RO-VIM-openstack/osm_rovim_openstack/vimconn_openstack.py
index 00558dc..7c57817 100644
--- a/RO-VIM-openstack/osm_rovim_openstack/vimconn_openstack.py
+++ b/RO-VIM-openstack/osm_rovim_openstack/vimconn_openstack.py
@@ -38,7 +38,7 @@
import random
import re
import time
-from typing import Dict, Optional, Tuple
+from typing import Dict, List, Optional, Tuple
from cinderclient import client as cClient
from glanceclient import client as glClient
@@ -1227,11 +1227,14 @@
) as e:
self._format_exception(e)
- def process_resource_quota(self, quota, prefix, extra_specs):
- """
- :param prefix:
- :param extra_specs:
- :return:
+ @staticmethod
+ def process_resource_quota(quota: dict, prefix: str, extra_specs: dict) -> None:
+ """Process resource quota and fill up extra_specs.
+ Args:
+ quota (dict): Keeping the quota of resurces
+ prefix (str) Prefix
+ extra_specs (dict) Dict to be filled to be used during flavor creation
+
"""
if "limit" in quota:
extra_specs["quota:" + prefix + "_limit"] = quota["limit"]
@@ -1243,11 +1246,253 @@
extra_specs["quota:" + prefix + "_shares_level"] = "custom"
extra_specs["quota:" + prefix + "_shares_share"] = quota["shares"]
- def new_flavor(self, flavor_data, change_name_if_used=True):
- """Adds a tenant flavor to openstack VIM
- if change_name_if_used is True, it will change name in case of conflict, because it is not supported name
- repetition
- Returns the flavor identifier
+ @staticmethod
+ def process_numa_memory(
+ numa: dict, node_id: Optional[int], extra_specs: dict
+ ) -> None:
+ """Set the memory in extra_specs.
+ Args:
+ numa (dict): A dictionary which includes numa information
+ node_id (int): ID of numa node
+ extra_specs (dict): To be filled.
+
+ """
+ if not numa.get("memory"):
+ return
+ memory_mb = numa["memory"] * 1024
+ memory = "hw:numa_mem.{}".format(node_id)
+ extra_specs[memory] = int(memory_mb)
+
+ @staticmethod
+ def process_numa_vcpu(numa: dict, node_id: int, extra_specs: dict) -> None:
+ """Set the cpu in extra_specs.
+ Args:
+ numa (dict): A dictionary which includes numa information
+ node_id (int): ID of numa node
+ extra_specs (dict): To be filled.
+
+ """
+ if not numa.get("vcpu"):
+ return
+ vcpu = numa["vcpu"]
+ cpu = "hw:numa_cpus.{}".format(node_id)
+ vcpu = ",".join(map(str, vcpu))
+ extra_specs[cpu] = vcpu
+
+ @staticmethod
+ def process_numa_paired_threads(numa: dict, extra_specs: dict) -> Optional[int]:
+ """Fill up extra_specs if numa has paired-threads.
+ Args:
+ numa (dict): A dictionary which includes numa information
+ extra_specs (dict): To be filled.
+
+ Returns:
+ vcpus (int) Number of virtual cpus
+
+ """
+ if not numa.get("paired-threads"):
+ return
+ # cpu_thread_policy "require" implies that compute node must have an STM architecture
+ vcpus = numa["paired-threads"] * 2
+ extra_specs["hw:cpu_thread_policy"] = "require"
+ extra_specs["hw:cpu_policy"] = "dedicated"
+ return vcpus
+
+ @staticmethod
+ def process_numa_cores(numa: dict, extra_specs: dict) -> Optional[int]:
+ """Fill up extra_specs if numa has cores.
+ Args:
+ numa (dict): A dictionary which includes numa information
+ extra_specs (dict): To be filled.
+
+ Returns:
+ vcpus (int) Number of virtual cpus
+
+ """
+ # cpu_thread_policy "isolate" implies that the host must not have an SMT
+ # architecture, or a non-SMT architecture will be emulated
+ if not numa.get("cores"):
+ return
+ vcpus = numa["cores"]
+ extra_specs["hw:cpu_thread_policy"] = "isolate"
+ extra_specs["hw:cpu_policy"] = "dedicated"
+ return vcpus
+
+ @staticmethod
+ def process_numa_threads(numa: dict, extra_specs: dict) -> Optional[int]:
+ """Fill up extra_specs if numa has threads.
+ Args:
+ numa (dict): A dictionary which includes numa information
+ extra_specs (dict): To be filled.
+
+ Returns:
+ vcpus (int) Number of virtual cpus
+
+ """
+ # cpu_thread_policy "prefer" implies that the host may or may not have an SMT architecture
+ if not numa.get("threads"):
+ return
+ vcpus = numa["threads"]
+ extra_specs["hw:cpu_thread_policy"] = "prefer"
+ extra_specs["hw:cpu_policy"] = "dedicated"
+ return vcpus
+
+ def _process_numa_parameters_of_flavor(
+ self, numas: List, extra_specs: Dict, vcpus: Optional[int]
+ ) -> int:
+ """Process numa parameters and fill up extra_specs.
+
+ Args:
+ numas (list): List of dictionary which includes numa information
+ extra_specs (dict): To be filled.
+ vcpus (int) Number of virtual cpus
+
+ Returns:
+ vcpus (int) Number of virtual cpus
+
+ """
+ numa_nodes = len(numas)
+ extra_specs["hw:numa_nodes"] = str(numa_nodes)
+
+ if self.vim_type == "VIO":
+ extra_specs["vmware:extra_config"] = '{"numa.nodeAffinity":"0"}'
+ extra_specs["vmware:latency_sensitivity_level"] = "high"
+
+ for numa in numas:
+ if "id" in numa:
+ node_id = numa["id"]
+ # overwrite ram and vcpus
+ # check if key "memory" is present in numa else use ram value at flavor
+ self.process_numa_memory(numa, node_id, extra_specs)
+ self.process_numa_vcpu(numa, node_id, extra_specs)
+
+ # See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/implemented/virt-driver-cpu-thread-pinning.html
+ extra_specs["hw:cpu_sockets"] = str(numa_nodes)
+
+ if "paired-threads" in numa:
+ vcpus = self.process_numa_paired_threads(numa, extra_specs)
+
+ elif "cores" in numa:
+ vcpus = self.process_numa_cores(numa, extra_specs)
+
+ elif "threads" in numa:
+ vcpus = self.process_numa_threads(numa, extra_specs)
+
+ return vcpus
+
+ def _change_flavor_name(
+ self, name: str, name_suffix: int, flavor_data: dict
+ ) -> str:
+ """Change the flavor name if the name already exists.
+
+ Args:
+ name (str): Flavor name to be checked
+ name_suffix (int): Suffix to be appended to name
+ flavor_data (dict): Flavor dict
+
+ Returns:
+ name (str): New flavor name to be used
+
+ """
+ # Get used names
+ fl = self.nova.flavors.list()
+ fl_names = [f.name for f in fl]
+
+ while name in fl_names:
+ name_suffix += 1
+ name = flavor_data["name"] + "-" + str(name_suffix)
+
+ return name
+
+ def _process_extended_config_of_flavor(
+ self, extended: dict, extra_specs: dict, vcpus: Optional[int]
+ ) -> int:
+ """Process the extended dict to fill up extra_specs.
+ Args:
+
+ extended (dict): Keeping the extra specification of flavor
+ extra_specs (dict) Dict to be filled to be used during flavor creation
+ vcpus (int) Number of virtual cpus
+
+ Returns:
+ vcpus (int) Number of virtual cpus
+
+ """
+ quotas = {
+ "cpu-quota": "cpu",
+ "mem-quota": "memory",
+ "vif-quota": "vif",
+ "disk-io-quota": "disk_io",
+ }
+
+ page_sizes = {
+ "LARGE": "large",
+ "SMALL": "small",
+ "SIZE_2MB": "2MB",
+ "SIZE_1GB": "1GB",
+ "PREFER_LARGE": "any",
+ }
+
+ policies = {
+ "cpu-pinning-policy": "hw:cpu_policy",
+ "cpu-thread-pinning-policy": "hw:cpu_thread_policy",
+ "mem-policy": "hw:numa_mempolicy",
+ }
+
+ numas = extended.get("numas")
+ if numas:
+ vcpus = self._process_numa_parameters_of_flavor(numas, extra_specs, vcpus)
+
+ for quota, item in quotas.items():
+ if quota in extended.keys():
+ self.process_resource_quota(extended.get(quota), item, extra_specs)
+
+ # Set the mempage size as specified in the descriptor
+ if extended.get("mempage-size"):
+ if extended["mempage-size"] in page_sizes.keys():
+ extra_specs["hw:mem_page_size"] = page_sizes[extended["mempage-size"]]
+ else:
+ # Normally, validations in NBI should not allow to this condition.
+ self.logger.debug(
+ "Invalid mempage-size %s. Will be ignored",
+ extended.get("mempage-size"),
+ )
+
+ for policy, hw_policy in policies.items():
+ if extended.get(policy):
+ extra_specs[hw_policy] = extended[policy].lower()
+
+ return vcpus
+
+ @staticmethod
+ def _get_flavor_details(flavor_data: dict) -> Tuple:
+ """Returns the details of flavor
+ Args:
+ flavor_data (dict): Dictionary that includes required flavor details
+
+ Returns:
+ ram, vcpus, extra_specs, extended (tuple): Main items of required flavor
+
+ """
+ return (
+ flavor_data.get("ram", 64),
+ flavor_data.get("vcpus", 1),
+ {},
+ flavor_data.get("extended"),
+ )
+
+ def new_flavor(self, flavor_data: dict, change_name_if_used: bool = True) -> str:
+ """Adds a tenant flavor to openstack VIM.
+ if change_name_if_used is True, it will change name in case of conflict,
+ because it is not supported name repetition.
+
+ Args:
+ flavor_data (dict): Flavor details to be processed
+ change_name_if_used (bool): Change name in case of conflict
+
+ Returns:
+ flavor_id (str): flavor identifier
+
"""
self.logger.debug("Adding flavor '%s'", str(flavor_data))
retry = 0
@@ -1262,138 +1507,18 @@
self._reload_connection()
if change_name_if_used:
- # get used names
- fl_names = []
- fl = self.nova.flavors.list()
+ name = self._change_flavor_name(name, name_suffix, flavor_data)
- for f in fl:
- fl_names.append(f.name)
-
- while name in fl_names:
- name_suffix += 1
- name = flavor_data["name"] + "-" + str(name_suffix)
-
- ram = flavor_data.get("ram", 64)
- vcpus = flavor_data.get("vcpus", 1)
- extra_specs = {}
-
- extended = flavor_data.get("extended")
+ ram, vcpus, extra_specs, extended = self._get_flavor_details(
+ flavor_data
+ )
if extended:
- numas = extended.get("numas")
+ vcpus = self._process_extended_config_of_flavor(
+ extended, extra_specs, vcpus
+ )
- if numas:
- numa_nodes = len(numas)
+ # Create flavor
- extra_specs["hw:numa_nodes"] = str(numa_nodes)
-
- if self.vim_type == "VIO":
- extra_specs[
- "vmware:extra_config"
- ] = '{"numa.nodeAffinity":"0"}'
- extra_specs["vmware:latency_sensitivity_level"] = "high"
-
- for numa in numas:
- if "id" in numa:
- node_id = numa["id"]
-
- if "memory" in numa:
- memory_mb = numa["memory"] * 1024
- memory = "hw:numa_mem.{}".format(node_id)
- extra_specs[memory] = int(memory_mb)
-
- if "vcpu" in numa:
- vcpu = numa["vcpu"]
- cpu = "hw:numa_cpus.{}".format(node_id)
- vcpu = ",".join(map(str, vcpu))
- extra_specs[cpu] = vcpu
-
- # overwrite ram and vcpus
- # check if key "memory" is present in numa else use ram value at flavor
- # See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/
- # implemented/virt-driver-cpu-thread-pinning.html
- extra_specs["hw:cpu_sockets"] = str(numa_nodes)
-
- if "paired-threads" in numa:
- vcpus = numa["paired-threads"] * 2
- # cpu_thread_policy "require" implies that the compute node must have an
- # STM architecture
- extra_specs["hw:cpu_thread_policy"] = "require"
- extra_specs["hw:cpu_policy"] = "dedicated"
- elif "cores" in numa:
- vcpus = numa["cores"]
- # cpu_thread_policy "prefer" implies that the host must not have an SMT
- # architecture, or a non-SMT architecture will be emulated
- extra_specs["hw:cpu_thread_policy"] = "isolate"
- extra_specs["hw:cpu_policy"] = "dedicated"
- elif "threads" in numa:
- vcpus = numa["threads"]
- # cpu_thread_policy "prefer" implies that the host may or may not have an SMT
- # architecture
- extra_specs["hw:cpu_thread_policy"] = "prefer"
- extra_specs["hw:cpu_policy"] = "dedicated"
- # for interface in numa.get("interfaces",() ):
- # if interface["dedicated"]=="yes":
- # raise vimconn.VimConnException("Passthrough interfaces are not supported
- # for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
- # #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"'
- # when a way to connect it is available
- elif extended.get("cpu-quota"):
- self.process_resource_quota(
- extended.get("cpu-quota"), "cpu", extra_specs
- )
-
- if extended.get("mem-quota"):
- self.process_resource_quota(
- extended.get("mem-quota"), "memory", extra_specs
- )
-
- if extended.get("vif-quota"):
- self.process_resource_quota(
- extended.get("vif-quota"), "vif", extra_specs
- )
-
- if extended.get("disk-io-quota"):
- self.process_resource_quota(
- extended.get("disk-io-quota"), "disk_io", extra_specs
- )
-
- # Set the mempage size as specified in the descriptor
- if extended.get("mempage-size"):
- if extended.get("mempage-size") == "LARGE":
- extra_specs["hw:mem_page_size"] = "large"
- elif extended.get("mempage-size") == "SMALL":
- extra_specs["hw:mem_page_size"] = "small"
- elif extended.get("mempage-size") == "SIZE_2MB":
- extra_specs["hw:mem_page_size"] = "2MB"
- elif extended.get("mempage-size") == "SIZE_1GB":
- extra_specs["hw:mem_page_size"] = "1GB"
- elif extended.get("mempage-size") == "PREFER_LARGE":
- extra_specs["hw:mem_page_size"] = "any"
- else:
- # The validations in NBI should make reaching here not possible.
- # If this message is shown, check validations
- self.logger.debug(
- "Invalid mempage-size %s. Will be ignored",
- extended.get("mempage-size"),
- )
- if extended.get("cpu-pinning-policy"):
- extra_specs["hw:cpu_policy"] = extended.get(
- "cpu-pinning-policy"
- ).lower()
-
- # Set the cpu thread pinning policy as specified in the descriptor
- if extended.get("cpu-thread-pinning-policy"):
- extra_specs["hw:cpu_thread_policy"] = extended.get(
- "cpu-thread-pinning-policy"
- ).lower()
-
- # Set the mem policy as specified in the descriptor
- if extended.get("mem-policy"):
- extra_specs["hw:numa_mempolicy"] = extended.get(
- "mem-policy"
- ).lower()
-
- # create flavor
new_flavor = self.nova.flavors.create(
name=name,
ram=ram,
@@ -1403,17 +1528,20 @@
swap=flavor_data.get("swap", 0),
is_public=flavor_data.get("is_public", True),
)
- # add metadata
+
+ # Add metadata
if extra_specs:
new_flavor.set_keys(extra_specs)
return new_flavor.id
+
except nvExceptions.Conflict as e:
+
if change_name_if_used and retry < max_retries:
continue
self._format_exception(e)
- # except nvExceptions.BadRequest as e:
+
except (
ksExceptions.ClientException,
nvExceptions.ClientException,
@@ -3320,60 +3448,6 @@
)
)
- # NOT USED FUNCTIONS
-
- def new_external_port(self, port_data):
- """Adds a external port to VIM
- Returns the port identifier"""
- # TODO openstack if needed
- return (
- -vimconn.HTTP_Internal_Server_Error,
- "osconnector.new_external_port() not implemented",
- )
-
- def connect_port_network(self, port_id, network_id, admin=False):
- """Connects a external port to a network
- Returns status code of the VIM response"""
- # TODO openstack if needed
- return (
- -vimconn.HTTP_Internal_Server_Error,
- "osconnector.connect_port_network() not implemented",
- )
-
- def new_user(self, user_name, user_passwd, tenant_id=None):
- """Adds a new user to openstack VIM
- Returns the user identifier"""
- self.logger.debug("osconnector: Adding a new user to VIM")
-
- try:
- self._reload_connection()
- user = self.keystone.users.create(
- user_name, password=user_passwd, default_project=tenant_id
- )
- # self.keystone.tenants.add_user(self.k_creds["username"], #role)
-
- return user.id
- except ksExceptions.ConnectionError as e:
- error_value = -vimconn.HTTP_Bad_Request
- error_text = (
- type(e).__name__
- + ": "
- + (str(e) if len(e.args) == 0 else str(e.args[0]))
- )
- except ksExceptions.ClientException as e: # TODO remove
- error_value = -vimconn.HTTP_Bad_Request
- error_text = (
- type(e).__name__
- + ": "
- + (str(e) if len(e.args) == 0 else str(e.args[0]))
- )
-
- # TODO insert exception vimconn.HTTP_Unauthorized
- # if reaching here is because an exception
- self.logger.debug("new_user " + error_text)
-
- return error_value, error_text
-
def delete_user(self, user_id):
"""Delete a user from openstack VIM
Returns the user identifier"""
diff --git a/RO-plugin/osm_ro_plugin/openflow_conn.py b/RO-plugin/osm_ro_plugin/openflow_conn.py
index afc0b82..c41d7bc 100644
--- a/RO-plugin/osm_ro_plugin/openflow_conn.py
+++ b/RO-plugin/osm_ro_plugin/openflow_conn.py
@@ -286,9 +286,9 @@
rules_to_delete = created_items.get("installed_rules_ids") or []
new_installed_rules_ids = []
error_list = []
+ step = "Checking ports and network type compatibility"
try:
- step = "Checking ports and network type compatibility"
if ifaces_nb < 2:
pass
elif net_type == "ELINE":
diff --git a/devops-stages/stage-build.sh b/devops-stages/stage-build.sh
index 8818289..c0ca188 100755
--- a/devops-stages/stage-build.sh
+++ b/devops-stages/stage-build.sh
@@ -39,7 +39,7 @@
TOX_ENV_LIST="$(echo $PACKAGES | sed "s/ /,/g")"
PROCESSES=$(expr `nproc --a` / 2)
-TOX_PARALLEL_NO_SPINNER=1 tox -e $TOX_ENV_LIST --parallel $PROCESSES
+TOX_PARALLEL_NO_SPINNER=1 tox -e $TOX_ENV_LIST
# Copying packages
# RO plugin
diff --git a/devops-stages/stage-test.sh b/devops-stages/stage-test.sh
index bfcdf9b..23f2dd6 100755
--- a/devops-stages/stage-test.sh
+++ b/devops-stages/stage-test.sh
@@ -14,6 +14,6 @@
# limitations under the License.
set -e
echo "Launching tox"
-tox --parallel=auto
+tox
diff --git a/releasenotes/notes/enabling_pylint-209bc644f489aa17.yaml b/releasenotes/notes/enabling_pylint-209bc644f489aa17.yaml
new file mode 100644
index 0000000..ec5848f
--- /dev/null
+++ b/releasenotes/notes/enabling_pylint-209bc644f489aa17.yaml
@@ -0,0 +1,22 @@
+#######################################################################################
+# Copyright ETSI Contributors and Others.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#######################################################################################
+---
+other:
+ - |
+ Enabling Pylint in tox.ini, removing some unused and erroneous methods,
+ updating required libraries.
+
diff --git a/releasenotes/notes/refactor_new_flavor-9717ff4c02776dda.yaml b/releasenotes/notes/refactor_new_flavor-9717ff4c02776dda.yaml
new file mode 100644
index 0000000..66d9d74
--- /dev/null
+++ b/releasenotes/notes/refactor_new_flavor-9717ff4c02776dda.yaml
@@ -0,0 +1,22 @@
+#######################################################################################
+# Copyright ETSI Contributors and Others.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#######################################################################################
+---
+other:
+ - |
+ Refactoring Openstack VIM Connector new_flavor method and adding unit tests
+
+
diff --git a/requirements-test.txt b/requirements-test.txt
index 89f7959..c7c2f90 100644
--- a/requirements-test.txt
+++ b/requirements-test.txt
@@ -16,13 +16,9 @@
#######################################################################################
-e RO-plugin
# via -r requirements-test.in
-coverage==6.4.1
- # via
- # -r requirements-test.in
- # nose2
-mock==4.0.3
+coverage==7.0.5
# via -r requirements-test.in
-nose2==0.11.0
+mock==5.0.1
# via -r requirements-test.in
-six==1.16.0
- # via nose2
+nose2==0.12.0
+ # via -r requirements-test.in
diff --git a/requirements.txt b/requirements.txt
index 336db96..3f146d0 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -18,7 +18,9 @@
# via msrestazure
appdirs==1.4.4
# via openstacksdk
-attrs==21.4.0
+atpublic==3.1.1
+ # via flufl-enum
+attrs==22.2.0
# via
# cmd2
# jsonschema
@@ -30,53 +32,52 @@
# azure-mgmt-compute
# azure-mgmt-network
# azure-mgmt-resource
-azure-core==1.24.1
+azure-core==1.26.2
# via
# azure-identity
# azure-mgmt-core
# msrest
-azure-identity==1.10.0
+azure-identity==1.12.0
# via -r RO-VIM-azure/requirements.in
-azure-mgmt-compute==27.1.0
+azure-mgmt-compute==29.0.0
# via -r RO-VIM-azure/requirements.in
-azure-mgmt-core==1.3.1
+azure-mgmt-core==1.3.2
# via
# azure-mgmt-compute
# azure-mgmt-network
# azure-mgmt-resource
-azure-mgmt-network==20.0.0
+azure-mgmt-network==22.2.0
# via -r RO-VIM-azure/requirements.in
-azure-mgmt-resource==21.1.0
+azure-mgmt-resource==22.0.0
# via -r RO-VIM-azure/requirements.in
-bcrypt==3.2.2
+bcrypt==4.0.1
# via paramiko
boto==2.49.0
# via -r RO-VIM-aws/requirements.in
-cachetools==5.2.0
+cachetools==5.2.1
# via google-auth
-certifi==2022.6.15
+certifi==2022.12.7
# via
# msrest
# requests
-cffi==1.15.0
+cffi==1.15.1
# via
- # bcrypt
# cryptography
# pynacl
-charset-normalizer==2.0.12
+charset-normalizer==3.0.1
# via requests
-cheroot==8.6.0
+cheroot==9.0.0
# via cherrypy
cherrypy==18.1.2
# via -r NG-RO/requirements.in
-cliff==3.10.1
+cliff==4.1.0
# via
# osc-lib
# python-neutronclient
# python-openstackclient
-cmd2==2.4.1
+cmd2==2.4.2
# via cliff
-cryptography==37.0.2
+cryptography==39.0.0
# via
# -r NG-RO/requirements.in
# adal
@@ -86,7 +87,7 @@
# paramiko
# pyjwt
# pyopenssl
-cvprac==1.2.0
+cvprac==1.2.2
# via -r RO-SDN-arista_cloudvision/requirements.in
debtcollector==2.5.0
# via
@@ -100,15 +101,15 @@
# via
# dogpile-cache
# openstacksdk
-dogpile-cache==1.1.6
+dogpile-cache==1.1.8
# via openstacksdk
-flufl-enum==4.1.1
+flufl-enum==5.0.1
# via pyvcloud
-google-api-core==2.8.2
+google-api-core==2.11.0
# via google-api-python-client
-google-api-python-client==2.51.0
+google-api-python-client==2.72.0
# via -r RO-VIM-gcp/requirements.in
-google-auth==2.8.0
+google-auth==2.16.0
# via
# -r RO-VIM-gcp/requirements.in
# google-api-core
@@ -118,21 +119,25 @@
# via google-api-python-client
google-cloud==0.34.0
# via -r RO-VIM-gcp/requirements.in
-googleapis-common-protos==1.56.3
+googleapis-common-protos==1.58.0
# via google-api-core
-httplib2==0.20.4
+httplib2==0.21.0
# via
# google-api-python-client
# google-auth-httplib2
humanfriendly==10.0
# via pyvcloud
-idna==3.3
+idna==3.4
# via requests
-importlib-metadata==4.11.4
- # via -r NG-RO/requirements.in
+importlib-metadata==6.0.0
+ # via
+ # -r NG-RO/requirements.in
+ # cliff
+importlib-resources==5.10.2
+ # via jsonschema
ipconflict==0.5.0
# via -r RO-VIM-aws/requirements.in
-iso8601==1.0.2
+iso8601==1.1.0
# via
# keystoneauth1
# openstacksdk
@@ -142,10 +147,8 @@
# python-openstackclient
isodate==0.6.1
# via msrest
-jaraco-functools==3.5.0
- # via
- # cheroot
- # tempora
+jaraco-functools==3.5.2
+ # via cheroot
jinja2==3.1.2
# via -r NG-RO/requirements.in
jmespath==1.0.1
@@ -156,9 +159,9 @@
# warlock
jsonpointer==2.3
# via jsonpatch
-jsonschema==3.2.0
+jsonschema==4.17.3
# via warlock
-keystoneauth1==4.6.0
+keystoneauth1==5.1.1
# via
# openstacksdk
# osc-lib
@@ -169,16 +172,16 @@
# python-novaclient
logutils==0.3.5
# via -r NG-RO/requirements.in
-lxml==4.9.0
+lxml==4.9.2
# via pyvcloud
markupsafe==2.1.1
# via jinja2
-more-itertools==8.13.0
+more-itertools==9.0.0
# via
# cheroot
# cherrypy
# jaraco-functools
-msal==1.18.0
+msal==1.20.0
# via
# azure-identity
# msal-extensions
@@ -213,9 +216,9 @@
# via
# openstacksdk
# oslo-utils
-oauthlib==3.2.0
+oauthlib==3.2.2
# via requests-oauthlib
-openstacksdk==0.99.0
+openstacksdk==0.103.0
# via
# os-client-config
# osc-lib
@@ -226,15 +229,15 @@
# via
# keystoneauth1
# openstacksdk
-osc-lib==2.6.0
+osc-lib==2.6.2
# via
# python-neutronclient
# python-openstackclient
-oslo-config==8.8.0
+oslo-config==9.1.0
# via
# oslo-log
# python-keystoneclient
-oslo-context==4.1.0
+oslo-context==5.0.0
# via oslo-log
oslo-i18n==5.1.0
# via
@@ -248,15 +251,15 @@
# python-neutronclient
# python-novaclient
# python-openstackclient
-oslo-log==5.0.0
+oslo-log==5.0.2
# via python-neutronclient
-oslo-serialization==4.3.0
+oslo-serialization==5.0.0
# via
# oslo-log
# python-keystoneclient
# python-neutronclient
# python-novaclient
-oslo-utils==6.0.0
+oslo-utils==6.1.0
# via
# osc-lib
# oslo-log
@@ -267,18 +270,17 @@
# python-neutronclient
# python-novaclient
# python-openstackclient
-packaging==21.3
+packaging==23.0
# via
# oslo-utils
# python-keystoneclient
-paramiko==2.11.0
+paramiko==2.12.0
# via
# -r RO-SDN-dpb/requirements.in
# -r RO-VIM-gcp/requirements.in
# -r RO-plugin/requirements.in
-pbr==5.9.0
+pbr==5.11.1
# via
- # cliff
# keystoneauth1
# openstacksdk
# os-service-types
@@ -294,11 +296,13 @@
# python-novaclient
# python-openstackclient
# stevedore
-portalocker==2.4.0
+pkgutil-resolve-name==1.3.10
+ # via jsonschema
+portalocker==2.6.0
# via msal-extensions
portend==3.1.0
# via cherrypy
-prettytable==3.3.0
+prettytable==3.6.0
# via
# -r RO-VIM-vmware/requirements.in
# cliff
@@ -307,7 +311,7 @@
# python-novaclient
progressbar==2.5
# via -r RO-VIM-vmware/requirements.in
-protobuf==4.21.1
+protobuf==4.21.12
# via
# google-api-core
# googleapis-common-protos
@@ -321,27 +325,25 @@
# via google-auth
pycparser==2.21
# via cffi
-pygments==2.12.0
+pygments==2.14.0
# via pyvcloud
pyinotify==0.9.6
# via oslo-log
-pyjwt[crypto]==2.4.0
+pyjwt[crypto]==2.6.0
# via
# adal
# msal
pynacl==1.5.0
# via paramiko
-pyopenssl==22.0.0
+pyopenssl==23.0.0
# via python-glanceclient
pyparsing==3.0.9
# via
- # cliff
# httplib2
# oslo-utils
- # packaging
pyperclip==1.8.2
# via cmd2
-pyrsistent==0.18.1
+pyrsistent==0.19.3
# via jsonschema
python-cinderclient==7.4.1
# via
@@ -351,29 +353,29 @@
# via
# adal
# oslo-log
-python-glanceclient==4.0.0
+python-glanceclient==4.2.0
# via -r RO-VIM-openstack/requirements.in
-python-keystoneclient==4.5.0
+python-keystoneclient==5.0.1
# via
# -r RO-VIM-openstack/requirements.in
# python-neutronclient
# python-openstackclient
-python-neutronclient==7.8.0
+python-neutronclient==8.2.1
# via -r RO-VIM-openstack/requirements.in
-python-novaclient==18.0.0
+python-novaclient==18.2.0
# via
# -r RO-VIM-openstack/requirements.in
# python-openstackclient
-python-openstackclient==5.8.0
+python-openstackclient==6.0.0
# via -r RO-VIM-openstack/requirements.in
-pytz==2022.1
+pytz==2022.7.1
# via
# oslo-serialization
# oslo-utils
# tempora
pyvcloud==19.1.1
# via -r RO-VIM-vmware/requirements.in
-pyvmomi==7.0.3
+pyvmomi==8.0.0.1.1
# via -r RO-VIM-vmware/requirements.in
pyyaml==5.4.1
# via
@@ -389,7 +391,7 @@
# openstacksdk
# oslo-config
# pyvcloud
-requests==2.28.0
+requests==2.28.2
# via
# -r NG-RO/requirements.in
# -r RO-SDN-arista_cloudvision/requirements.in
@@ -420,7 +422,6 @@
# python-keystoneclient
# python-neutronclient
# pyvcloud
- # pyvmomi
# requests-oauthlib
requests-oauthlib==1.3.1
# via msrest
@@ -428,9 +429,9 @@
# via openstacksdk
rfc3986==2.0.0
# via oslo-config
-rsa==4.8
+rsa==4.9
# via google-auth
-simplejson==3.17.6
+simplejson==3.18.1
# via
# osc-lib
# python-cinderclient
@@ -443,7 +444,6 @@
# google-auth
# google-auth-httplib2
# isodate
- # jsonschema
# keystoneauth1
# msrestazure
# munch
@@ -451,8 +451,7 @@
# python-dateutil
# python-keystoneclient
# pyvmomi
- # warlock
-stevedore==3.5.0
+stevedore==4.1.1
# via
# cliff
# dogpile-cache
@@ -463,21 +462,21 @@
# python-keystoneclient
# python-novaclient
# python-openstackclient
-tempora==5.0.1
+tempora==5.2.0
# via portend
-tqdm==4.64.0
+tqdm==4.64.1
# via ipconflict
-typing-extensions==4.2.0
+typing-extensions==4.4.0
# via azure-core
uritemplate==4.1.1
# via google-api-python-client
-urllib3==1.26.9
+urllib3==1.26.14
# via requests
uuid==1.30
# via -r RO-SDN-arista_cloudvision/requirements.in
-warlock==1.3.3
+warlock==2.0.1
# via python-glanceclient
-wcwidth==0.2.5
+wcwidth==0.2.6
# via
# cmd2
# prettytable
@@ -487,8 +486,10 @@
# python-glanceclient
zc-lockfile==2.0
# via cherrypy
-zipp==3.8.0
- # via importlib-metadata
+zipp==3.11.0
+ # via
+ # importlib-metadata
+ # importlib-resources
# The following packages are considered to be unsafe in a requirements file:
# setuptools
diff --git a/tox.ini b/tox.ini
index 04a5ad5..42dfdc4 100644
--- a/tox.ini
+++ b/tox.ini
@@ -16,7 +16,7 @@
#######################################################################################
[tox]
-envlist = black, flake8, safety, cover
+envlist = black, cover, flake8, pylint, safety
[tox:jenkins]
toxworkdir = /tmp/.tox
@@ -170,23 +170,23 @@
pylint
skip_install = true
commands =
- - pylint -E NG-RO/osm_ng_ro
- - pylint -E RO-plugin/osm_ro_plugin
- - pylint -E RO-SDN-arista_cloudvision/osm_rosdn_arista_cloudvision
- - pylint -E RO-SDN-dpb/osm_rosdn_dpb
- - pylint -E RO-SDN-dynpac/osm_rosdn_dynpac
- - pylint -E RO-SDN-floodlight_openflow/osm_rosdn_floodlightof
- - pylint -E RO-SDN-ietfl2vpn/osm_rosdn_ietfl2vpn
- - pylint -E RO-SDN-juniper_contrail/osm_rosdn_juniper_contrail
- - pylint -E RO-SDN-odl_openflow/osm_rosdn_odlof
- - pylint -E RO-SDN-onos_openflow/osm_rosdn_onosof
- - pylint -E RO-SDN-onos_vpls/osm_rosdn_onos_vpls
- - pylint -E RO-VIM-aws/osm_rovim_aws
- - pylint -E RO-VIM-azure/osm_rovim_azure
- - pylint -E RO-VIM-openstack/osm_rovim_openstack
- - pylint -E RO-VIM-openvim/osm_rovim_openvim
- - pylint -E RO-VIM-vmware/osm_rovim_vmware
- - pylint -E RO-VIM-gcp/osm_rovim_gcp
+ pylint -E NG-RO/osm_ng_ro --disable=E1101
+ pylint -E RO-plugin/osm_ro_plugin --disable=E1101
+ pylint -E RO-SDN-arista_cloudvision/osm_rosdn_arista_cloudvision --disable=all
+ pylint -E RO-SDN-dpb/osm_rosdn_dpb
+ pylint -E RO-SDN-dynpac/osm_rosdn_dynpac --disable=E1101
+ pylint -E RO-SDN-floodlight_openflow/osm_rosdn_floodlightof
+ pylint -E RO-SDN-ietfl2vpn/osm_rosdn_ietfl2vpn --disable=E1101
+ pylint -E RO-SDN-juniper_contrail/osm_rosdn_juniper_contrail
+ pylint -E RO-SDN-odl_openflow/osm_rosdn_odlof
+ pylint -E RO-SDN-onos_openflow/osm_rosdn_onosof
+ pylint -E RO-SDN-onos_vpls/osm_rosdn_onos_vpls --disable=E1101
+ pylint -E RO-VIM-aws/osm_rovim_aws
+ pylint -E RO-VIM-azure/osm_rovim_azure --disable=all
+ pylint -E RO-VIM-openstack/osm_rovim_openstack --disable=E1101
+ pylint -E RO-VIM-openvim/osm_rovim_openvim --disable=all
+ pylint -E RO-VIM-vmware/osm_rovim_vmware --disable=all
+ pylint -E RO-VIM-gcp/osm_rovim_gcp --disable=E1101
#######################################################################################