Arnike/watcher
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Fixed Tempest test due to notification issues"

Browse Source
This commit is contained in:
Jenkins
2016-09-15 09:55:33 +00:00
committed by Gerrit Code Review
parent 0873c26b17 72e6564549
commit 0a0f482f2d
27 changed files with 965 additions and 514 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
watcher/tests/decision_engine/model/notification/data/scenario3_notfound_instance-update.json Normal file
View File

@@ -0,0 +1,65 @@
{
"event_type": "instance.update",
"payload": {
"nova_object.data": {
"architecture": "x86_64",
"audit_period": {
"nova_object.data": {
"audit_period_beginning": "2012-10-01T00:00:00Z",
"audit_period_ending": "2012-10-29T13:42:11Z"},
"nova_object.name": "AuditPeriodPayload",
"nova_object.namespace": "nova",
"nova_object.version": "1.0"
},
"availability_zone": null,
"bandwidth": [],
"created_at": "2012-10-29T13:42:11Z",
"deleted_at": null,
"display_name": "NEW INSTANCE 9966d6bd-a45c-4e1c-9d57-3054899a3ec7",
"host": "Node_2",
"host_name": "NEW_INSTANCE_9966d6bd-a45c-4e1c-9d57-3054899a3ec7",
"image_uuid": "155d900f-4e14-4e4c-a73d-069cbf4541e6",
"kernel_id": "",
"launched_at": null,
"metadata": {},
"node": "hostname_0",
"old_display_name": null,
"os_type": null,
"progress": 0,
"ramdisk_id": "",
"reservation_id": "r-sd3ygfjj",
"state": "paused",
"task_state": "scheduling",
"power_state": "pending",
"ip_addresses": [],
"state_update": {
"nova_object.data": {
"old_task_state": null,
"new_task_state": null,
"old_state": "paused",
"state": "paused"},
"nova_object.name": "InstanceStateUpdatePayload",
"nova_object.namespace": "nova",
"nova_object.version": "1.0"},
"tenant_id": "6f70656e737461636b20342065766572",
"terminated_at": null,
"flavor": {
"nova_object.name": "FlavorPayload",
"nova_object.data": {
"flavorid": "a22d5517-147c-4147-a0d1-e698df5cd4e3",
"root_gb": 1,
"vcpus": 1,
"ephemeral_gb": 0,
"memory_mb": 512
},
"nova_object.version": "1.0",
"nova_object.namespace": "nova"
},
"user_id": "fake",
"uuid": "9966d6bd-a45c-4e1c-9d57-3054899a3ec7"},
"nova_object.name": "InstanceUpdatePayload",
"nova_object.namespace": "nova",
"nova_object.version": "1.0"},
"priority": "INFO",
"publisher_id": "nova-compute:Node_2"
}

52
watcher/tests/decision_engine/model/notification/data/scenario3_notfound_legacy_instance-update.json Normal file
View File

@@ -0,0 +1,52 @@
{
"publisher_id": "compute:Node_2",
"event_type": "compute.instance.update",
"payload": {
"access_ip_v4": null,
"access_ip_v6": null,
"architecture": null,
"audit_period_beginning": "2016-08-17T13:00:00.000000",
"audit_period_ending": "2016-08-17T13:56:05.262440",
"availability_zone": "nova",
"bandwidth": {},
"cell_name": "",
"created_at": "2016-08-17 13:53:23+00:00",
"deleted_at": "",
"disk_gb": 1,
"display_name": "NEW INSTANCE 9966d6bd-a45c-4e1c-9d57-3054899a3ec7",
"ephemeral_gb": 0,
"host": "Node_2",
"hostname": "NEW_INSTANCE_9966d6bd-a45c-4e1c-9d57-3054899a3ec7",
"image_meta": {
"base_image_ref": "205f96f5-91f9-42eb-9138-03fffcea2b97",
"container_format": "bare",
"disk_format": "qcow2",
"min_disk": "1",
"min_ram": "0"
},
"image_ref_url": "http://10.50.0.222:9292/images/205f96f5-91f9-42eb-9138-03fffcea2b97",
"instance_flavor_id": "1",
"instance_id": "9966d6bd-a45c-4e1c-9d57-3054899a3ec7",
"instance_type": "m1.tiny",
"instance_type_id": 2,
"kernel_id": "",
"launched_at": "2016-08-17T13:53:35.000000",
"memory_mb": 512,
"metadata": {},
"new_task_state": null,
"node": "hostname_0",
"old_state": "paused",
"old_task_state": null,
"os_type": null,
"progress": "",
"ramdisk_id": "",
"reservation_id": "r-0822ymml",
"root_gb": 1,
"state": "paused",
"state_description": "paused",
"tenant_id": "a4b4772d93c74d5e8b7c68cdd2a014e1",
"terminated_at": "",
"user_id": "ce64facc93354bbfa90f4f9f9a3e1e75",
"vcpus": 1
}
}

266
watcher/tests/decision_engine/model/notification/test_nova_notifications.py
View File

@@ -23,6 +23,7 @@ from oslo_serialization import jsonutils
from watcher.common import context
from watcher.common import exception
from watcher.common import nova_helper
from watcher.common import service as watcher_service
from watcher.decision_engine.model import element
from watcher.decision_engine.model import model_root
@@ -125,7 +126,7 @@ class TestNovaNotifications(NotificationTestCase):
handler = novanotification.ServiceUpdated(self.fake_cdmc)
node0_uuid = 'Node_0'
node0 = compute_model.get_node_from_id(node0_uuid)
node0 = compute_model.get_node_by_uuid(node0_uuid)
message = self.load_message('scenario3_service-update.json')
@@ -151,7 +152,7 @@ class TestNovaNotifications(NotificationTestCase):
handler = novanotification.InstanceUpdated(self.fake_cdmc)
instance0_uuid = '73b09e16-35b7-4922-804e-e8f5d9b740fc'
instance0 = compute_model.get_instance_from_id(instance0_uuid)
instance0 = compute_model.get_instance_by_uuid(instance0_uuid)
message = self.load_message('scenario3_instance-update.json')
@@ -167,34 +168,46 @@ class TestNovaNotifications(NotificationTestCase):
self.assertEqual(element.InstanceState.PAUSED.value, instance0.state)
def test_nova_instance_update_notfound_creates(self):
@mock.patch.object(nova_helper, "NovaHelper")
def test_nova_instance_update_notfound_still_creates(
self, m_nova_helper_cls):
m_get_compute_node_by_hostname = mock.Mock(
side_effect=lambda uuid: mock.Mock(
name='m_get_compute_node_by_hostname',
id=3,
uuid=uuid,
memory_mb=7777,
vcpus=42,
free_disk_gb=974,
local_gb=1337))
m_nova_helper_cls.return_value = mock.Mock(
get_compute_node_by_hostname=m_get_compute_node_by_hostname,
name='m_nova_helper')
compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
self.fake_cdmc.cluster_data_model = compute_model
handler = novanotification.InstanceUpdated(self.fake_cdmc)
instance0_uuid = '73b09e16-35b7-4922-804e-e8f5d9b740fc'
instance0_uuid = '9966d6bd-a45c-4e1c-9d57-3054899a3ec7'
message = self.load_message('scenario3_instance-update.json')
message = self.load_message('scenario3_notfound_instance-update.json')
with mock.patch.object(
model_root.ModelRoot, 'get_instance_from_id'
) as m_get_instance_from_id:
m_get_instance_from_id.side_effect = exception.InstanceNotFound(
name='TEST')
handler.info(
ctxt=self.context,
publisher_id=message['publisher_id'],
event_type=message['event_type'],
payload=message['payload'],
metadata=self.FAKE_METADATA,
)
handler.info(
ctxt=self.context,
publisher_id=message['publisher_id'],
event_type=message['event_type'],
payload=message['payload'],
metadata=self.FAKE_METADATA,
)
instance0 = compute_model.get_instance_from_id(instance0_uuid)
cpu_capacity = compute_model.get_resource_from_id(
instance0 = compute_model.get_instance_by_uuid(instance0_uuid)
cpu_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.cpu_cores)
disk_capacity = compute_model.get_resource_from_id(
disk = compute_model.get_resource_by_uuid(
element.ResourceType.disk)
memory_capacity = compute_model.get_resource_from_id(
disk_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.disk_capacity)
memory_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.memory)
self.assertEqual(element.InstanceState.PAUSED.value, instance0.state)
@@ -202,6 +215,60 @@ class TestNovaNotifications(NotificationTestCase):
self.assertEqual(1, disk_capacity.get_capacity(instance0))
self.assertEqual(512, memory_capacity.get_capacity(instance0))
m_get_compute_node_by_hostname.assert_called_once_with('Node_2')
node_2 = compute_model.get_node_by_uuid('Node_2')
self.assertEqual(7777, memory_capacity.get_capacity(node_2))
self.assertEqual(42, cpu_capacity.get_capacity(node_2))
self.assertEqual(974, disk.get_capacity(node_2))
self.assertEqual(1337, disk_capacity.get_capacity(node_2))
@mock.patch.object(nova_helper, "NovaHelper")
def test_instance_update_node_notfound_set_unmapped(
self, m_nova_helper_cls):
m_get_compute_node_by_hostname = mock.Mock(
side_effect=exception.ComputeNodeNotFound)
m_nova_helper_cls.return_value = mock.Mock(
get_compute_node_by_hostname=m_get_compute_node_by_hostname,
name='m_nova_helper')
compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
self.fake_cdmc.cluster_data_model = compute_model
handler = novanotification.InstanceUpdated(self.fake_cdmc)
instance0_uuid = '9966d6bd-a45c-4e1c-9d57-3054899a3ec7'
message = self.load_message(
'scenario3_notfound_instance-update.json')
handler.info(
ctxt=self.context,
publisher_id=message['publisher_id'],
event_type=message['event_type'],
payload=message['payload'],
metadata=self.FAKE_METADATA,
)
instance0 = compute_model.get_instance_by_uuid(instance0_uuid)
cpu_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.cpu_cores)
disk = compute_model.get_resource_by_uuid(
element.ResourceType.disk)
disk_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.disk_capacity)
memory_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.memory)
self.assertEqual(element.InstanceState.PAUSED.value, instance0.state)
self.assertEqual(1, cpu_capacity.get_capacity(instance0))
self.assertEqual(1, disk.get_capacity(instance0))
self.assertEqual(1, disk_capacity.get_capacity(instance0))
self.assertEqual(512, memory_capacity.get_capacity(instance0))
m_get_compute_node_by_hostname.assert_any_call('Node_2')
self.assertRaises(
exception.ComputeNodeNotFound,
compute_model.get_node_by_uuid, 'Node_2')
def test_nova_instance_create(self):
compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
self.fake_cdmc.cluster_data_model = compute_model
@@ -211,7 +278,7 @@ class TestNovaNotifications(NotificationTestCase):
self.assertRaises(
exception.InstanceNotFound,
compute_model.get_instance_from_id, instance0_uuid)
compute_model.get_instance_by_uuid, instance0_uuid)
message = self.load_message('scenario3_instance-create.json')
handler.info(
@@ -222,12 +289,12 @@ class TestNovaNotifications(NotificationTestCase):
metadata=self.FAKE_METADATA,
)
instance0 = compute_model.get_instance_from_id(instance0_uuid)
cpu_capacity = compute_model.get_resource_from_id(
instance0 = compute_model.get_instance_by_uuid(instance0_uuid)
cpu_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.cpu_cores)
disk_capacity = compute_model.get_resource_from_id(
disk_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.disk)
memory_capacity = compute_model.get_resource_from_id(
memory_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.memory)
self.assertEqual(element.InstanceState.ACTIVE.value, instance0.state)
@@ -243,7 +310,7 @@ class TestNovaNotifications(NotificationTestCase):
instance0_uuid = '73b09e16-35b7-4922-804e-e8f5d9b740fc'
# Before
self.assertTrue(compute_model.get_instance_from_id(instance0_uuid))
self.assertTrue(compute_model.get_instance_by_uuid(instance0_uuid))
for resource in compute_model.resource.values():
self.assertIn(instance0_uuid, resource.mapping)
@@ -259,7 +326,7 @@ class TestNovaNotifications(NotificationTestCase):
# After
self.assertRaises(
exception.InstanceNotFound,
compute_model.get_instance_from_id, instance0_uuid)
compute_model.get_instance_by_uuid, instance0_uuid)
for resource in compute_model.resource.values():
self.assertNotIn(instance0_uuid, resource.mapping)
@@ -282,7 +349,7 @@ class TestLegacyNovaNotifications(NotificationTestCase):
instance0_uuid = 'c03c0bf9-f46e-4e4f-93f1-817568567ee2'
self.assertRaises(
exception.InstanceNotFound,
compute_model.get_instance_from_id, instance0_uuid)
compute_model.get_instance_by_uuid, instance0_uuid)
message = self.load_message(
'scenario3_legacy_instance-create-end.json')
@@ -295,12 +362,12 @@ class TestLegacyNovaNotifications(NotificationTestCase):
metadata=self.FAKE_METADATA,
)
instance0 = compute_model.get_instance_from_id(instance0_uuid)
cpu_capacity = compute_model.get_resource_from_id(
instance0 = compute_model.get_instance_by_uuid(instance0_uuid)
cpu_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.cpu_cores)
disk_capacity = compute_model.get_resource_from_id(
disk_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.disk)
memory_capacity = compute_model.get_resource_from_id(
memory_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.memory)
self.assertEqual(element.InstanceState.ACTIVE.value, instance0.state)
@@ -314,7 +381,7 @@ class TestLegacyNovaNotifications(NotificationTestCase):
handler = novanotification.LegacyInstanceUpdated(self.fake_cdmc)
instance0_uuid = '73b09e16-35b7-4922-804e-e8f5d9b740fc'
instance0 = compute_model.get_instance_from_id(instance0_uuid)
instance0 = compute_model.get_instance_by_uuid(instance0_uuid)
message = self.load_message('scenario3_legacy_instance-update.json')
@@ -330,7 +397,7 @@ class TestLegacyNovaNotifications(NotificationTestCase):
self.assertEqual(element.InstanceState.PAUSED.value, instance0.state)
def test_legacy_instance_update_notfound_creates(self):
def test_legacy_instance_update_instance_notfound_creates(self):
compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
self.fake_cdmc.cluster_data_model = compute_model
handler = novanotification.LegacyInstanceUpdated(self.fake_cdmc)
@@ -340,9 +407,9 @@ class TestLegacyNovaNotifications(NotificationTestCase):
message = self.load_message('scenario3_legacy_instance-update.json')
with mock.patch.object(
model_root.ModelRoot, 'get_instance_from_id'
) as m_get_instance_from_id:
m_get_instance_from_id.side_effect = exception.InstanceNotFound(
model_root.ModelRoot, 'get_instance_by_uuid'
) as m_get_instance_by_uuid:
m_get_instance_by_uuid.side_effect = exception.InstanceNotFound(
name='TEST')
handler.info(
ctxt=self.context,
@@ -352,58 +419,121 @@ class TestLegacyNovaNotifications(NotificationTestCase):
metadata=self.FAKE_METADATA,
)
instance0 = compute_model.get_instance_from_id(instance0_uuid)
instance0 = compute_model.get_instance_by_uuid(instance0_uuid)
self.assertEqual(element.InstanceState.PAUSED.value, instance0.state)
def test_legacy_instance_update_node_notfound_stil_creates(self):
@mock.patch.object(nova_helper, "NovaHelper")
def test_legacy_instance_update_node_notfound_still_creates(
self, m_nova_helper_cls):
m_get_compute_node_by_hostname = mock.Mock(
side_effect=lambda uuid: mock.Mock(
name='m_get_compute_node_by_hostname',
id=3,
uuid=uuid,
memory_mb=7777,
vcpus=42,
free_disk_gb=974,
local_gb=1337))
m_nova_helper_cls.return_value = mock.Mock(
get_compute_node_by_hostname=m_get_compute_node_by_hostname,
name='m_nova_helper')
compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
self.fake_cdmc.cluster_data_model = compute_model
handler = novanotification.LegacyInstanceUpdated(self.fake_cdmc)
instance0_uuid = '73b09e16-35b7-4922-804e-e8f5d9b740fc'
instance0_uuid = '9966d6bd-a45c-4e1c-9d57-3054899a3ec7'
message = self.load_message('scenario3_legacy_instance-update.json')
message = self.load_message(
'scenario3_notfound_legacy_instance-update.json')
with mock.patch.object(
model_root.ModelRoot, 'get_instance_from_id'
) as m_get_instance_from_id:
m_get_instance_from_id.side_effect = exception.InstanceNotFound(
name='TEST')
with mock.patch.object(
model_root.ModelRoot, 'get_node_from_id'
) as m_get_node_from_id:
m_get_node_from_id.side_effect = exception.ComputeNodeNotFound(
name='TEST')
handler.info(
ctxt=self.context,
publisher_id=message['publisher_id'],
event_type=message['event_type'],
payload=message['payload'],
metadata=self.FAKE_METADATA,
)
handler.info(
ctxt=self.context,
publisher_id=message['publisher_id'],
event_type=message['event_type'],
payload=message['payload'],
metadata=self.FAKE_METADATA,
)
instance0 = compute_model.get_instance_from_id(instance0_uuid)
cpu_capacity = compute_model.get_resource_from_id(
instance0 = compute_model.get_instance_by_uuid(instance0_uuid)
cpu_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.cpu_cores)
disk_capacity = compute_model.get_resource_from_id(
disk = compute_model.get_resource_by_uuid(
element.ResourceType.disk)
memory_capacity = compute_model.get_resource_from_id(
disk_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.disk_capacity)
memory_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.memory)
self.assertEqual(element.InstanceState.PAUSED.value, instance0.state)
self.assertEqual(1, cpu_capacity.get_capacity(instance0))
self.assertEqual(1, disk.get_capacity(instance0))
self.assertEqual(1, disk_capacity.get_capacity(instance0))
self.assertEqual(512, memory_capacity.get_capacity(instance0))
m_get_compute_node_by_hostname.assert_any_call('Node_2')
node_2 = compute_model.get_node_by_uuid('Node_2')
self.assertEqual(7777, memory_capacity.get_capacity(node_2))
self.assertEqual(42, cpu_capacity.get_capacity(node_2))
self.assertEqual(974, disk.get_capacity(node_2))
self.assertEqual(1337, disk_capacity.get_capacity(node_2))
@mock.patch.object(nova_helper, "NovaHelper")
def test_legacy_instance_update_node_notfound_set_unmapped(
self, m_nova_helper_cls):
m_get_compute_node_by_hostname = mock.Mock(
side_effect=exception.ComputeNodeNotFound)
m_nova_helper_cls.return_value = mock.Mock(
get_compute_node_by_hostname=m_get_compute_node_by_hostname,
name='m_nova_helper')
compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
self.fake_cdmc.cluster_data_model = compute_model
handler = novanotification.LegacyInstanceUpdated(self.fake_cdmc)
instance0_uuid = '9966d6bd-a45c-4e1c-9d57-3054899a3ec7'
message = self.load_message(
'scenario3_notfound_legacy_instance-update.json')
handler.info(
ctxt=self.context,
publisher_id=message['publisher_id'],
event_type=message['event_type'],
payload=message['payload'],
metadata=self.FAKE_METADATA,
)
instance0 = compute_model.get_instance_by_uuid(instance0_uuid)
cpu_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.cpu_cores)
disk = compute_model.get_resource_by_uuid(
element.ResourceType.disk)
disk_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.disk_capacity)
memory_capacity = compute_model.get_resource_by_uuid(
element.ResourceType.memory)
self.assertEqual(element.InstanceState.PAUSED.value, instance0.state)
self.assertEqual(1, cpu_capacity.get_capacity(instance0))
self.assertEqual(1, disk.get_capacity(instance0))
self.assertEqual(1, disk_capacity.get_capacity(instance0))
self.assertEqual(512, memory_capacity.get_capacity(instance0))
m_get_compute_node_by_hostname.assert_any_call('Node_2')
self.assertRaises(
exception.ComputeNodeNotFound,
compute_model.get_node_by_uuid, 'Node_2')
def test_legacy_live_migrated_end(self):
compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
self.fake_cdmc.cluster_data_model = compute_model
handler = novanotification.LegacyLiveMigratedEnd(self.fake_cdmc)
instance0_uuid = '73b09e16-35b7-4922-804e-e8f5d9b740fc'
instance0 = compute_model.get_instance_from_id(instance0_uuid)
instance0 = compute_model.get_instance_by_uuid(instance0_uuid)
node = compute_model.get_node_from_instance_id(instance0_uuid)
node = compute_model.get_node_by_instance_uuid(instance0_uuid)
self.assertEqual('Node_0', node.uuid)
message = self.load_message(
@@ -415,7 +545,7 @@ class TestLegacyNovaNotifications(NotificationTestCase):
payload=message['payload'],
metadata=self.FAKE_METADATA,
)
node = compute_model.get_node_from_instance_id(instance0_uuid)
node = compute_model.get_node_by_instance_uuid(instance0_uuid)
self.assertEqual('Node_1', node.uuid)
self.assertEqual(element.InstanceState.ACTIVE.value, instance0.state)
@@ -427,7 +557,7 @@ class TestLegacyNovaNotifications(NotificationTestCase):
instance0_uuid = '73b09e16-35b7-4922-804e-e8f5d9b740fc'
# Before
self.assertTrue(compute_model.get_instance_from_id(instance0_uuid))
self.assertTrue(compute_model.get_instance_by_uuid(instance0_uuid))
for resource in compute_model.resource.values():
self.assertIn(instance0_uuid, resource.mapping)
@@ -444,7 +574,7 @@ class TestLegacyNovaNotifications(NotificationTestCase):
# After
self.assertRaises(
exception.InstanceNotFound,
compute_model.get_instance_from_id, instance0_uuid)
compute_model.get_instance_by_uuid, instance0_uuid)
for resource in compute_model.resource.values():
self.assertNotIn(instance0_uuid, resource.mapping)

28
watcher/tests/decision_engine/model/test_mapping.py
View File

@@ -44,10 +44,10 @@ class TestMapping(base.TestCase):
node = model.mapping.get_node_from_instance(instance)
self.assertEqual('Node_0', node.uuid)
def test_get_node_from_instance_id(self):
def test_get_node_by_instance_uuid(self):
model = self.fake_cluster.generate_scenario_3_with_2_nodes()
nodes = model.mapping.get_node_instances_from_id("BLABLABLA")
nodes = model.mapping.get_node_instances_by_uuid("BLABLABLA")
self.assertEqual(0, len(nodes))
def test_get_all_instances(self):
@@ -74,9 +74,9 @@ class TestMapping(base.TestCase):
instances = model.get_all_instances()
keys = list(instances.keys())
instance0 = instances[keys[0]]
node0 = model.mapping.get_node_from_instance_id(instance0.uuid)
node0 = model.mapping.get_node_by_instance_uuid(instance0.uuid)
instance1 = instances[keys[1]]
node1 = model.mapping.get_node_from_instance_id(instance1.uuid)
node1 = model.mapping.get_node_by_instance_uuid(instance1.uuid)
self.assertEqual(
False,
@@ -91,26 +91,24 @@ class TestMapping(base.TestCase):
True,
model.migrate_instance(instance1, node0, node1))
def test_unmap_from_id_log_warning(self):
def test_unmap_by_uuid_log_warning(self):
model = self.fake_cluster.generate_scenario_3_with_2_nodes()
instances = model.get_all_instances()
keys = list(instances.keys())
instance0 = instances[keys[0]]
id_ = "{0}".format(uuid.uuid4())
node = element.ComputeNode()
node.uuid = id_
uuid_ = "{0}".format(uuid.uuid4())
node = element.ComputeNode(id=1)
node.uuid = uuid_
model.mapping.unmap_from_id(node.uuid, instance0.uuid)
# self.assertEqual(len(model.mapping.get_node_instances_from_id(
# node.uuid)), 1)
model.mapping.unmap_by_uuid(node.uuid, instance0.uuid)
def test_unmap_from_id(self):
def test_unmap_by_uuid(self):
model = self.fake_cluster.generate_scenario_3_with_2_nodes()
instances = model.get_all_instances()
keys = list(instances.keys())
instance0 = instances[keys[0]]
node0 = model.mapping.get_node_from_instance_id(instance0.uuid)
node0 = model.mapping.get_node_by_instance_uuid(instance0.uuid)
model.mapping.unmap_from_id(node0.uuid, instance0.uuid)
self.assertEqual(0, len(model.mapping.get_node_instances_from_id(
model.mapping.unmap_by_uuid(node0.uuid, instance0.uuid)
self.assertEqual(0, len(model.mapping.get_node_instances_by_uuid(
node0.uuid)))

314
watcher/tests/decision_engine/model/test_model.py
View File

@@ -16,9 +16,8 @@
# See the License for the specific language governing permissions and
# limitations under the License.
import uuid
from lxml import etree
from oslo_utils import uuidutils
import six
from watcher.common import exception
@@ -41,131 +40,136 @@ class TestModel(base.TestCase):
expected_struct_str = """
<ModelRoot>
<ComputeNode ResourceType.cpu_cores="40" ResourceType.disk="250"
ResourceType.memory="132" hostname="hostname_0" human_id=""
state="up" status="enabled" uuid="Node_0">
<ComputeNode ResourceType.cpu_cores="40" ResourceType.disk="250"
ResourceType.disk_capacity="250" ResourceType.memory="132"
hostname="hostname_0" human_id="" id="0" state="up"
status="enabled" uuid="Node_0">
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_0"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_1"/>
</ComputeNode>
<ComputeNode ResourceType.cpu_cores="40" ResourceType.disk="250"
ResourceType.disk_capacity="250" ResourceType.memory="132"
hostname="hostname_1" human_id="" id="1" state="up"
status="enabled" uuid="Node_1">
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_2"/>
</ComputeNode>
<ComputeNode ResourceType.cpu_cores="40" ResourceType.disk="250"
ResourceType.disk_capacity="250" ResourceType.memory="132"
hostname="hostname_2" human_id="" id="2" state="up"
status="enabled" uuid="Node_2">
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_3"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_4"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_5"/>
</ComputeNode>
<ComputeNode ResourceType.cpu_cores="40" ResourceType.disk="250"
ResourceType.disk_capacity="250" ResourceType.memory="132"
hostname="hostname_3" human_id="" id="3" state="up"
status="enabled" uuid="Node_3">
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_6"/>
</ComputeNode>
<ComputeNode ResourceType.cpu_cores="40" ResourceType.disk="250"
ResourceType.disk_capacity="250" ResourceType.memory="132"
hostname="hostname_4" human_id="" id="4" state="up"
status="enabled" uuid="Node_4">
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_7"/>
</ComputeNode>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_0"/>
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_10"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_1"/>
</ComputeNode>
<ComputeNode ResourceType.cpu_cores="40" ResourceType.disk="250"
ResourceType.memory="132" hostname="hostname_1" human_id=""
state="up" status="enabled" uuid="Node_1">
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_11"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_2"/>
</ComputeNode>
<ComputeNode ResourceType.cpu_cores="40" ResourceType.disk="250"
ResourceType.memory="132" hostname="hostname_2" human_id=""
state="up" status="enabled" uuid="Node_2">
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_12"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_3"/>
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_13"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_4"/>
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_14"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_5"/>
</ComputeNode>
<ComputeNode ResourceType.cpu_cores="40" ResourceType.disk="250"
ResourceType.memory="132" hostname="hostname_3" human_id=""
state="up" status="enabled" uuid="Node_3">
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_15"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_6"/>
</ComputeNode>
<ComputeNode ResourceType.cpu_cores="40" ResourceType.disk="250"
ResourceType.memory="132" hostname="hostname_4" human_id=""
state="up" status="enabled" uuid="Node_4">
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_16"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_7"/>
</ComputeNode>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_10"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_11"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_12"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_13"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_14"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_15"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_16"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_17"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_18"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_19"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_20"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_21"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_22"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_23"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_24"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_25"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_26"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_27"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_28"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_29"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_30"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_31"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_32"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_33"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_34"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_8"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.memory="2" hostname="" human_id=""
state="active" uuid="INSTANCE_9"/>
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_17"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_18"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_19"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_20"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_21"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_22"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_23"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_24"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_25"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_26"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_27"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_28"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_29"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_30"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_31"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_32"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_33"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_34"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_8"/>
<Instance ResourceType.cpu_cores="10" ResourceType.disk="20"
ResourceType.disk_capacity="20" ResourceType.memory="2"
hostname="" human_id="" state="active" uuid="INSTANCE_9"/>
</ModelRoot>
"""
parser = etree.XMLParser(remove_blank_text=True)
@@ -184,87 +188,87 @@ class TestModel(base.TestCase):
def test_add_node(self):
model = model_root.ModelRoot()
id_ = "{0}".format(uuid.uuid4())
node = element.ComputeNode()
node.uuid = id_
uuid_ = "{0}".format(uuidutils.generate_uuid())
node = element.ComputeNode(id=1)
node.uuid = uuid_
model.add_node(node)
self.assertEqual(node, model.get_node_from_id(id_))
self.assertEqual(node, model.get_node_by_uuid(uuid_))
def test_delete_node(self):
model = model_root.ModelRoot()
id_ = "{0}".format(uuid.uuid4())
node = element.ComputeNode()
node.uuid = id_
uuid_ = "{0}".format(uuidutils.generate_uuid())
node = element.ComputeNode(id=1)
node.uuid = uuid_
model.add_node(node)
self.assertEqual(node, model.get_node_from_id(id_))
self.assertEqual(node, model.get_node_by_uuid(uuid_))
model.remove_node(node)
self.assertRaises(exception.ComputeNodeNotFound,
model.get_node_from_id, id_)
model.get_node_by_uuid, uuid_)
def test_get_all_compute_nodes(self):
model = model_root.ModelRoot()
for _ in range(10):
id_ = "{0}".format(uuid.uuid4())
node = element.ComputeNode()
node.uuid = id_
for id_ in range(10):
uuid_ = "{0}".format(uuidutils.generate_uuid())
node = element.ComputeNode(id_)
node.uuid = uuid_
model.add_node(node)
all_nodes = model.get_all_compute_nodes()
for id_ in all_nodes:
node = model.get_node_from_id(id_)
for uuid_ in all_nodes:
node = model.get_node_by_uuid(uuid_)
model.assert_node(node)
def test_set_get_state_nodes(self):
model = model_root.ModelRoot()
id_ = "{0}".format(uuid.uuid4())
node = element.ComputeNode()
node.uuid = id_
uuid_ = "{0}".format(uuidutils.generate_uuid())
node = element.ComputeNode(id=1)
node.uuid = uuid_
model.add_node(node)
self.assertIn(node.state, [el.value for el in element.ServiceState])
node = model.get_node_from_id(id_)
node = model.get_node_by_uuid(uuid_)
node.state = element.ServiceState.OFFLINE.value
self.assertIn(node.state, [el.value for el in element.ServiceState])
def test_node_from_id_raise(self):
def test_node_from_uuid_raise(self):
model = model_root.ModelRoot()
id_ = "{0}".format(uuid.uuid4())
node = element.ComputeNode()
node.uuid = id_
uuid_ = "{0}".format(uuidutils.generate_uuid())
node = element.ComputeNode(id=1)
node.uuid = uuid_
model.add_node(node)
id2 = "{0}".format(uuid.uuid4())
uuid2 = "{0}".format(uuidutils.generate_uuid())
self.assertRaises(exception.ComputeNodeNotFound,
model.get_node_from_id, id2)
model.get_node_by_uuid, uuid2)
def test_remove_node_raise(self):
model = model_root.ModelRoot()
id_ = "{0}".format(uuid.uuid4())
node = element.ComputeNode()
node.uuid = id_
uuid_ = "{0}".format(uuidutils.generate_uuid())
node = element.ComputeNode(id=1)
node.uuid = uuid_
model.add_node(node)
id2 = "{0}".format(uuid.uuid4())
node2 = element.ComputeNode()
node2.uuid = id2
uuid2 = "{0}".format(uuidutils.generate_uuid())
node2 = element.ComputeNode(id=2)
node2.uuid = uuid2
self.assertRaises(exception.ComputeNodeNotFound,
model.remove_node, node2)
def test_assert_node_raise(self):
model = model_root.ModelRoot()
id_ = "{0}".format(uuid.uuid4())
node = element.ComputeNode()
node.uuid = id_
uuid_ = "{0}".format(uuidutils.generate_uuid())
node = element.ComputeNode(id=1)
node.uuid = uuid_
model.add_node(node)
self.assertRaises(exception.IllegalArgumentException,
model.assert_node, "objet_qcq")
def test_instance_from_id_raise(self):
def test_instance_from_uuid_raise(self):
fake_cluster = faker_cluster_state.FakerModelCollector()
model = fake_cluster.generate_scenario_1()
self.assertRaises(exception.InstanceNotFound,
model.get_instance_from_id, "valeur_qcq")
model.get_instance_by_uuid, "valeur_qcq")
def test_assert_instance_raise(self):
model = model_root.ModelRoot()

52
watcher/tests/decision_engine/strategy/strategies/faker_cluster_and_metrics.py
View File

@@ -56,11 +56,11 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
current_state_cluster.create_resource(disk)
current_state_cluster.create_resource(disk_capacity)
for i in range(0, count_node):
node_uuid = "Node_{0}".format(i)
node = element.ComputeNode()
for id_ in range(0, count_node):
node_uuid = "Node_{0}".format(id_)
node = element.ComputeNode(id_)
node.uuid = node_uuid
node.hostname = "hostname_{0}".format(i)
node.hostname = "hostname_{0}".format(id_)
node.state = 'enabled'
mem.set_capacity(node, 64)
@@ -79,12 +79,12 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
current_state_cluster.add_instance(instance)
current_state_cluster.get_mapping().map(
current_state_cluster.get_node_from_id("Node_0"),
current_state_cluster.get_instance_from_id("INSTANCE_0"))
current_state_cluster.get_node_by_uuid("Node_0"),
current_state_cluster.get_instance_by_uuid("INSTANCE_0"))
current_state_cluster.get_mapping().map(
current_state_cluster.get_node_from_id("Node_1"),
current_state_cluster.get_instance_from_id("INSTANCE_1"))
current_state_cluster.get_node_by_uuid("Node_1"),
current_state_cluster.get_instance_by_uuid("INSTANCE_1"))
return current_state_cluster
@@ -109,11 +109,11 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
current_state_cluster.create_resource(disk)
current_state_cluster.create_resource(disk_capacity)
for i in range(0, count_node):
node_uuid = "Node_{0}".format(i)
node = element.ComputeNode()
for id_ in range(0, count_node):
node_uuid = "Node_{0}".format(id_)
node = element.ComputeNode(id_)
node.uuid = node_uuid
node.hostname = "hostname_{0}".format(i)
node.hostname = "hostname_{0}".format(id_)
node.state = 'up'
mem.set_capacity(node, 64)
@@ -132,8 +132,8 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
current_state_cluster.add_instance(instance)
current_state_cluster.get_mapping().map(
current_state_cluster.get_node_from_id("Node_0"),
current_state_cluster.get_instance_from_id("INSTANCE_%s" % i))
current_state_cluster.get_node_by_uuid("Node_0"),
current_state_cluster.get_instance_by_uuid("INSTANCE_%s" % i))
return current_state_cluster
@@ -158,11 +158,11 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
current_state_cluster.create_resource(disk)
current_state_cluster.create_resource(disk_capacity)
for i in range(0, count_node):
node_uuid = "Node_{0}".format(i)
node = element.ComputeNode()
for id_ in range(0, count_node):
node_uuid = "Node_{0}".format(id_)
node = element.ComputeNode(id_)
node.uuid = node_uuid
node.hostname = "hostname_{0}".format(i)
node.hostname = "hostname_{0}".format(id_)
node.state = 'up'
mem.set_capacity(node, 64)
@@ -177,12 +177,12 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
instance.state = element.InstanceState.ACTIVE.value
mem.set_capacity(instance, 2)
disk.set_capacity(instance, 20)
num_cores.set_capacity(instance, 2 ** (i-6))
num_cores.set_capacity(instance, 2 ** (i - 6))
current_state_cluster.add_instance(instance)
current_state_cluster.get_mapping().map(
current_state_cluster.get_node_from_id("Node_0"),
current_state_cluster.get_instance_from_id("INSTANCE_%s" % i))
current_state_cluster.get_node_by_uuid("Node_0"),
current_state_cluster.get_instance_by_uuid("INSTANCE_%s" % i))
return current_state_cluster
@@ -213,14 +213,14 @@ class FakeCeilometerMetrics(object):
"""
id = '%s_%s' % (r_id.split('_')[0], r_id.split('_')[1])
instances = self.model.get_mapping().get_node_instances_from_id(id)
instances = self.model.get_mapping().get_node_instances_by_uuid(id)
util_sum = 0.0
node_cpu_cores = self.model.get_resource_from_id(
element.ResourceType.cpu_cores).get_capacity_from_id(id)
node_cpu_cores = self.model.get_resource_by_uuid(
element.ResourceType.cpu_cores).get_capacity_by_uuid(id)
for instance_uuid in instances:
instance_cpu_cores = self.model.get_resource_from_id(
instance_cpu_cores = self.model.get_resource_by_uuid(
element.ResourceType.cpu_cores).\
get_capacity(self.model.get_instance_from_id(instance_uuid))
get_capacity(self.model.get_instance_by_uuid(instance_uuid))
total_cpu_util = instance_cpu_cores * self.get_instance_cpu_util(
instance_uuid)
util_sum += total_cpu_util / 100.0

158
watcher/tests/decision_engine/strategy/strategies/faker_cluster_state.py
View File

@@ -53,19 +53,22 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
# 2199.954 Mhz
num_cores = element.Resource(element.ResourceType.cpu_cores)
disk = element.Resource(element.ResourceType.disk)
disk_capacity = element.Resource(element.ResourceType.disk_capacity)
current_state_cluster.create_resource(mem)
current_state_cluster.create_resource(num_cores)
current_state_cluster.create_resource(disk)
current_state_cluster.create_resource(disk_capacity)
for i in range(0, node_count):
node_uuid = "Node_{0}".format(i)
node = element.ComputeNode()
for id_ in range(0, node_count):
node_uuid = "Node_{0}".format(id_)
node = element.ComputeNode(id_)
node.uuid = node_uuid
node.hostname = "hostname_{0}".format(i)
node.hostname = "hostname_{0}".format(id_)
mem.set_capacity(node, 132)
disk.set_capacity(node, 250)
disk_capacity.set_capacity(node, 250)
num_cores.set_capacity(node, 40)
current_state_cluster.add_node(node)
@@ -75,48 +78,49 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
instance.uuid = instance_uuid
mem.set_capacity(instance, 2)
disk.set_capacity(instance, 20)
disk_capacity.set_capacity(instance, 20)
num_cores.set_capacity(instance, 10)
instances.append(instance)
current_state_cluster.add_instance(instance)
current_state_cluster.get_mapping().map(
current_state_cluster.get_node_from_id("Node_0"),
current_state_cluster.get_instance_from_id("INSTANCE_0"))
current_state_cluster.get_node_by_uuid("Node_0"),
current_state_cluster.get_instance_by_uuid("INSTANCE_0"))
current_state_cluster.get_mapping().map(
current_state_cluster.get_node_from_id("Node_0"),
current_state_cluster.get_instance_from_id("INSTANCE_1"))
current_state_cluster.get_node_by_uuid("Node_0"),
current_state_cluster.get_instance_by_uuid("INSTANCE_1"))
current_state_cluster.get_mapping().map(
current_state_cluster.get_node_from_id("Node_1"),
current_state_cluster.get_instance_from_id("INSTANCE_2"))
current_state_cluster.get_node_by_uuid("Node_1"),
current_state_cluster.get_instance_by_uuid("INSTANCE_2"))
current_state_cluster.get_mapping().map(
current_state_cluster.get_node_from_id("Node_2"),
current_state_cluster.get_instance_from_id("INSTANCE_3"))
current_state_cluster.get_node_by_uuid("Node_2"),
current_state_cluster.get_instance_by_uuid("INSTANCE_3"))
current_state_cluster.get_mapping().map(
current_state_cluster.get_node_from_id("Node_2"),
current_state_cluster.get_instance_from_id("INSTANCE_4"))
current_state_cluster.get_node_by_uuid("Node_2"),
current_state_cluster.get_instance_by_uuid("INSTANCE_4"))
current_state_cluster.get_mapping().map(
current_state_cluster.get_node_from_id("Node_2"),
current_state_cluster.get_instance_from_id("INSTANCE_5"))
current_state_cluster.get_node_by_uuid("Node_2"),
current_state_cluster.get_instance_by_uuid("INSTANCE_5"))
current_state_cluster.get_mapping().map(
current_state_cluster.get_node_from_id("Node_3"),
current_state_cluster.get_instance_from_id("INSTANCE_6"))
current_state_cluster.get_node_by_uuid("Node_3"),
current_state_cluster.get_instance_by_uuid("INSTANCE_6"))
current_state_cluster.get_mapping().map(
current_state_cluster.get_node_from_id("Node_4"),
current_state_cluster.get_instance_from_id("INSTANCE_7"))
current_state_cluster.get_node_by_uuid("Node_4"),
current_state_cluster.get_instance_by_uuid("INSTANCE_7"))
return current_state_cluster
def map(self, model, h_id, instance_id):
model.get_mapping().map(
model.get_node_from_id(h_id),
model.get_instance_from_id(instance_id))
model.get_node_by_uuid(h_id),
model.get_instance_by_uuid(instance_id))
def generate_scenario_3_with_2_nodes(self):
instances = []
@@ -130,19 +134,22 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
# 2199.954 Mhz
num_cores = element.Resource(element.ResourceType.cpu_cores)
disk = element.Resource(element.ResourceType.disk)
disk_capacity = element.Resource(element.ResourceType.disk_capacity)
root.create_resource(mem)
root.create_resource(num_cores)
root.create_resource(disk)
root.create_resource(disk_capacity)
for i in range(0, node_count):
node_uuid = "Node_{0}".format(i)
node = element.ComputeNode()
for id_ in range(0, node_count):
node_uuid = "Node_{0}".format(id_)
node = element.ComputeNode(id_)
node.uuid = node_uuid
node.hostname = "hostname_{0}".format(i)
node.hostname = "hostname_{0}".format(id_)
mem.set_capacity(node, 132)
disk.set_capacity(node, 250)
disk_capacity.set_capacity(node, 250)
num_cores.set_capacity(node, 40)
root.add_node(node)
@@ -150,6 +157,7 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
instance1.uuid = "73b09e16-35b7-4922-804e-e8f5d9b740fc"
mem.set_capacity(instance1, 2)
disk.set_capacity(instance1, 20)
disk_capacity.set_capacity(instance1, 20)
num_cores.set_capacity(instance1, 10)
instances.append(instance1)
root.add_instance(instance1)
@@ -158,15 +166,16 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
instance2.uuid = "a4cab39b-9828-413a-bf88-f76921bf1517"
mem.set_capacity(instance2, 2)
disk.set_capacity(instance2, 20)
disk_capacity.set_capacity(instance2, 20)
num_cores.set_capacity(instance2, 10)
instances.append(instance2)
root.add_instance(instance2)
root.get_mapping().map(root.get_node_from_id("Node_0"),
root.get_instance_from_id(str(instance1.uuid)))
root.get_mapping().map(root.get_node_by_uuid("Node_0"),
root.get_instance_by_uuid(str(instance1.uuid)))
root.get_mapping().map(root.get_node_from_id("Node_1"),
root.get_instance_from_id(str(instance2.uuid)))
root.get_mapping().map(root.get_node_by_uuid("Node_1"),
root.get_instance_by_uuid(str(instance2.uuid)))
return root
@@ -180,19 +189,22 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
# 2199.954 Mhz
num_cores = element.Resource(element.ResourceType.cpu_cores)
disk = element.Resource(element.ResourceType.disk)
disk_capacity = element.Resource(element.ResourceType.disk_capacity)
current_state_cluster.create_resource(mem)
current_state_cluster.create_resource(num_cores)
current_state_cluster.create_resource(disk)
current_state_cluster.create_resource(disk_capacity)
for i in range(0, node_count):
node_uuid = "Node_{0}".format(i)
node = element.ComputeNode()
for id_ in range(0, node_count):
node_uuid = "Node_{0}".format(id_)
node = element.ComputeNode(id_)
node.uuid = node_uuid
node.hostname = "hostname_{0}".format(i)
node.hostname = "hostname_{0}".format(id_)
mem.set_capacity(node, 1)
disk.set_capacity(node, 1)
disk_capacity.set_capacity(node, 1)
num_cores.set_capacity(node, 1)
current_state_cluster.add_node(node)
@@ -211,19 +223,22 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
# 2199.954 Mhz
num_cores = element.Resource(element.ResourceType.cpu_cores)
disk = element.Resource(element.ResourceType.disk)
disk_capacity = element.Resource(element.ResourceType.disk_capacity)
current_state_cluster.create_resource(mem)
current_state_cluster.create_resource(num_cores)
current_state_cluster.create_resource(disk)
current_state_cluster.create_resource(disk_capacity)
for i in range(0, node_count):
node_uuid = "Node_{0}".format(i)
node = element.ComputeNode()
for id_ in range(0, node_count):
node_uuid = "Node_{0}".format(id_)
node = element.ComputeNode(id_)
node.uuid = node_uuid
node.hostname = "hostname_{0}".format(i)
node.hostname = "hostname_{0}".format(id_)
mem.set_capacity(node, 4)
disk.set_capacity(node, 4)
disk_capacity.set_capacity(node, 4)
num_cores.set_capacity(node, 4)
current_state_cluster.add_node(node)
@@ -233,13 +248,14 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
instance.uuid = instance_uuid
mem.set_capacity(instance, 2)
disk.set_capacity(instance, 0)
disk_capacity.set_capacity(instance, 0)
num_cores.set_capacity(instance, 4)
instances.append(instance)
current_state_cluster.add_instance(instance)
current_state_cluster.get_mapping().map(
current_state_cluster.get_node_from_id("Node_0"),
current_state_cluster.get_instance_from_id("INSTANCE_0"))
current_state_cluster.get_node_by_uuid("Node_0"),
current_state_cluster.get_instance_by_uuid("INSTANCE_0"))
return current_state_cluster
@@ -254,19 +270,22 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
# 2199.954 Mhz
num_cores = element.Resource(element.ResourceType.cpu_cores)
disk = element.Resource(element.ResourceType.disk)
disk_capacity = element.Resource(element.ResourceType.disk_capacity)
root.create_resource(mem)
root.create_resource(num_cores)
root.create_resource(disk)
root.create_resource(disk_capacity)
for i in range(0, node_count):
node_uuid = "Node_{0}".format(i)
node = element.ComputeNode()
for id_ in range(0, node_count):
node_uuid = "Node_{0}".format(id_)
node = element.ComputeNode(id_)
node.uuid = node_uuid
node.hostname = "hostname_{0}".format(i)
node.hostname = "hostname_{0}".format(id_)
mem.set_capacity(node, 132)
disk.set_capacity(node, 250)
disk_capacity.set_capacity(node, 250)
num_cores.set_capacity(node, 40)
root.add_node(node)
@@ -274,6 +293,7 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
instance1.uuid = "INSTANCE_1"
mem.set_capacity(instance1, 2)
disk.set_capacity(instance1, 20)
disk_capacity.set_capacity(instance1, 20)
num_cores.set_capacity(instance1, 10)
instances.append(instance1)
root.add_instance(instance1)
@@ -282,6 +302,7 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
instance11.uuid = "73b09e16-35b7-4922-804e-e8f5d9b740fc"
mem.set_capacity(instance11, 2)
disk.set_capacity(instance11, 20)
disk_capacity.set_capacity(instance11, 20)
num_cores.set_capacity(instance11, 10)
instances.append(instance11)
root.add_instance(instance11)
@@ -290,6 +311,7 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
instance2.uuid = "INSTANCE_3"
mem.set_capacity(instance2, 2)
disk.set_capacity(instance2, 20)
disk_capacity.set_capacity(instance2, 20)
num_cores.set_capacity(instance2, 10)
instances.append(instance2)
root.add_instance(instance2)
@@ -298,19 +320,20 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
instance21.uuid = "INSTANCE_4"
mem.set_capacity(instance21, 2)
disk.set_capacity(instance21, 20)
disk_capacity.set_capacity(instance21, 20)
num_cores.set_capacity(instance21, 10)
instances.append(instance21)
root.add_instance(instance21)
root.get_mapping().map(root.get_node_from_id("Node_0"),
root.get_instance_from_id(str(instance1.uuid)))
root.get_mapping().map(root.get_node_from_id("Node_0"),
root.get_instance_from_id(str(instance11.uuid)))
root.get_mapping().map(root.get_node_by_uuid("Node_0"),
root.get_instance_by_uuid(str(instance1.uuid)))
root.get_mapping().map(root.get_node_by_uuid("Node_0"),
root.get_instance_by_uuid(str(instance11.uuid)))
root.get_mapping().map(root.get_node_from_id("Node_1"),
root.get_instance_from_id(str(instance2.uuid)))
root.get_mapping().map(root.get_node_from_id("Node_1"),
root.get_instance_from_id(str(instance21.uuid)))
root.get_mapping().map(root.get_node_by_uuid("Node_1"),
root.get_instance_by_uuid(str(instance2.uuid)))
root.get_mapping().map(root.get_node_by_uuid("Node_1"),
root.get_instance_by_uuid(str(instance21.uuid)))
return root
def generate_scenario_7_with_2_nodes(self):
@@ -324,19 +347,22 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
# 2199.954 Mhz
num_cores = element.Resource(element.ResourceType.cpu_cores)
disk = element.Resource(element.ResourceType.disk)
disk_capacity = element.Resource(element.ResourceType.disk_capacity)
root.create_resource(mem)
root.create_resource(num_cores)
root.create_resource(disk)
root.create_resource(disk_capacity)
for i in range(0, count_node):
node_uuid = "Node_{0}".format(i)
node = element.ComputeNode()
for id_ in range(0, count_node):
node_uuid = "Node_{0}".format(id_)
node = element.ComputeNode(id_)
node.uuid = node_uuid
node.hostname = "hostname_{0}".format(i)
node.hostname = "hostname_{0}".format(id_)
mem.set_capacity(node, 132)
disk.set_capacity(node, 250)
disk_capacity.set_capacity(node, 250)
num_cores.set_capacity(node, 50)
root.add_node(node)
@@ -344,6 +370,7 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
instance1.uuid = "cae81432-1631-4d4e-b29c-6f3acdcde906"
mem.set_capacity(instance1, 2)
disk.set_capacity(instance1, 20)
disk_capacity.set_capacity(instance1, 20)
num_cores.set_capacity(instance1, 15)
instances.append(instance1)
root.add_instance(instance1)
@@ -352,6 +379,7 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
instance11.uuid = "73b09e16-35b7-4922-804e-e8f5d9b740fc"
mem.set_capacity(instance11, 2)
disk.set_capacity(instance11, 20)
disk_capacity.set_capacity(instance11, 20)
num_cores.set_capacity(instance11, 10)
instances.append(instance11)
root.add_instance(instance11)
@@ -360,6 +388,7 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
instance2.uuid = "INSTANCE_3"
mem.set_capacity(instance2, 2)
disk.set_capacity(instance2, 20)
disk_capacity.set_capacity(instance2, 20)
num_cores.set_capacity(instance2, 10)
instances.append(instance2)
root.add_instance(instance2)
@@ -368,17 +397,18 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
instance21.uuid = "INSTANCE_4"
mem.set_capacity(instance21, 2)
disk.set_capacity(instance21, 20)
disk_capacity.set_capacity(instance21, 20)
num_cores.set_capacity(instance21, 10)
instances.append(instance21)
root.add_instance(instance21)
root.get_mapping().map(root.get_node_from_id("Node_0"),
root.get_instance_from_id(str(instance1.uuid)))
root.get_mapping().map(root.get_node_from_id("Node_0"),
root.get_instance_from_id(str(instance11.uuid)))
root.get_mapping().map(root.get_node_by_uuid("Node_0"),
root.get_instance_by_uuid(str(instance1.uuid)))
root.get_mapping().map(root.get_node_by_uuid("Node_0"),
root.get_instance_by_uuid(str(instance11.uuid)))
root.get_mapping().map(root.get_node_from_id("Node_1"),
root.get_instance_from_id(str(instance2.uuid)))
root.get_mapping().map(root.get_node_from_id("Node_1"),
root.get_instance_from_id(str(instance21.uuid)))
root.get_mapping().map(root.get_node_by_uuid("Node_1"),
root.get_instance_by_uuid(str(instance2.uuid)))
root.get_mapping().map(root.get_node_by_uuid("Node_1"),
root.get_instance_by_uuid(str(instance21.uuid)))
return root

38
watcher/tests/decision_engine/strategy/strategies/test_basic_consolidation.py
View File

@@ -20,7 +20,9 @@ import collections
import mock
from watcher.applier.loading import default
from watcher.common import clients
from watcher.common import exception
from watcher.decision_engine.model.collector import nova
from watcher.decision_engine.model import model_root
from watcher.decision_engine.strategy import strategies
from watcher.tests import base
@@ -39,9 +41,13 @@ class TestBasicConsolidation(base.TestCase):
# fake cluster
self.fake_cluster = faker_cluster_state.FakerModelCollector()
p_osc = mock.patch.object(
clients, "OpenStackClients")
self.m_osc = p_osc.start()
self.addCleanup(p_osc.stop)
p_model = mock.patch.object(
strategies.BasicConsolidation, "compute_model",
new_callable=mock.PropertyMock)
nova.NovaClusterDataModelCollector, "execute")
self.m_model = p_model.start()
self.addCleanup(p_model.stop)
@@ -67,39 +73,39 @@ class TestBasicConsolidation(base.TestCase):
self.m_model.return_value = model
node_1_score = 0.023333333333333317
self.assertEqual(node_1_score, self.strategy.calculate_score_node(
model.get_node_from_id("Node_1")))
model.get_node_by_uuid("Node_1")))
node_2_score = 0.26666666666666666
self.assertEqual(node_2_score, self.strategy.calculate_score_node(
model.get_node_from_id("Node_2")))
model.get_node_by_uuid("Node_2")))
node_0_score = 0.023333333333333317
self.assertEqual(node_0_score, self.strategy.calculate_score_node(
model.get_node_from_id("Node_0")))
model.get_node_by_uuid("Node_0")))
def test_basic_consolidation_score_instance(self):
model = self.fake_cluster.generate_scenario_1()
self.m_model.return_value = model
instance_0 = model.get_instance_from_id("INSTANCE_0")
instance_0 = model.get_instance_by_uuid("INSTANCE_0")
instance_0_score = 0.023333333333333317
self.assertEqual(
instance_0_score,
self.strategy.calculate_score_instance(instance_0))
instance_1 = model.get_instance_from_id("INSTANCE_1")
instance_1 = model.get_instance_by_uuid("INSTANCE_1")
instance_1_score = 0.023333333333333317
self.assertEqual(
instance_1_score,
self.strategy.calculate_score_instance(instance_1))
instance_2 = model.get_instance_from_id("INSTANCE_2")
instance_2 = model.get_instance_by_uuid("INSTANCE_2")
instance_2_score = 0.033333333333333326
self.assertEqual(
instance_2_score,
self.strategy.calculate_score_instance(instance_2))
instance_6 = model.get_instance_from_id("INSTANCE_6")
instance_6 = model.get_instance_by_uuid("INSTANCE_6")
instance_6_score = 0.02666666666666669
self.assertEqual(
instance_6_score,
self.strategy.calculate_score_instance(instance_6))
instance_7 = model.get_instance_from_id("INSTANCE_7")
instance_7 = model.get_instance_by_uuid("INSTANCE_7")
instance_7_score = 0.013333333333333345
self.assertEqual(
instance_7_score,
@@ -108,7 +114,7 @@ class TestBasicConsolidation(base.TestCase):
def test_basic_consolidation_score_instance_disk(self):
model = self.fake_cluster.generate_scenario_5_with_instance_disk_0()
self.m_model.return_value = model
instance_0 = model.get_instance_from_id("INSTANCE_0")
instance_0 = model.get_instance_by_uuid("INSTANCE_0")
instance_0_score = 0.023333333333333355
self.assertEqual(
instance_0_score,
@@ -117,7 +123,7 @@ class TestBasicConsolidation(base.TestCase):
def test_basic_consolidation_weight(self):
model = self.fake_cluster.generate_scenario_1()
self.m_model.return_value = model
instance_0 = model.get_instance_from_id("INSTANCE_0")
instance_0 = model.get_instance_by_uuid("INSTANCE_0")
cores = 16
# 80 Go
disk = 80
@@ -162,6 +168,14 @@ class TestBasicConsolidation(base.TestCase):
self.assertFalse(self.strategy.check_threshold(
node0, 1000, 1000, 1000))
def test_basic_consolidation_works_on_model_copy(self):
model = self.fake_cluster.generate_scenario_3_with_2_nodes()
self.m_model.return_value = model
self.assertEqual(
model.to_string(), self.strategy.compute_model.to_string())
self.assertIsNot(model, self.strategy.compute_model)
def test_basic_consolidation_migration(self):
model = self.fake_cluster.generate_scenario_3_with_2_nodes()
self.m_model.return_value = model

8
watcher/tests/decision_engine/strategy/strategies/test_outlet_temp_control.py
View File

@@ -65,10 +65,10 @@ class TestOutletTempControl(base.TestCase):
def test_calc_used_res(self):
model = self.fake_cluster.generate_scenario_3_with_2_nodes()
self.m_model.return_value = model
node = model.get_node_from_id('Node_0')
cap_cores = model.get_resource_from_id(element.ResourceType.cpu_cores)
cap_mem = model.get_resource_from_id(element.ResourceType.memory)
cap_disk = model.get_resource_from_id(element.ResourceType.disk)
node = model.get_node_by_uuid('Node_0')
cap_cores = model.get_resource_by_uuid(element.ResourceType.cpu_cores)
cap_mem = model.get_resource_by_uuid(element.ResourceType.memory)
cap_disk = model.get_resource_by_uuid(element.ResourceType.disk)
cores_used, mem_used, disk_used = self.strategy.calc_used_res(
node, cap_cores, cap_mem, cap_disk)

8
watcher/tests/decision_engine/strategy/strategies/test_uniform_airflow.py
View File

@@ -70,10 +70,10 @@ class TestUniformAirflow(base.TestCase):
def test_calc_used_res(self):
model = self.fake_cluster.generate_scenario_7_with_2_nodes()
self.m_model.return_value = model
node = model.get_node_from_id('Node_0')
cap_cores = model.get_resource_from_id(element.ResourceType.cpu_cores)
cap_mem = model.get_resource_from_id(element.ResourceType.memory)
cap_disk = model.get_resource_from_id(element.ResourceType.disk)
node = model.get_node_by_uuid('Node_0')
cap_cores = model.get_resource_by_uuid(element.ResourceType.cpu_cores)
cap_mem = model.get_resource_by_uuid(element.ResourceType.memory)
cap_disk = model.get_resource_by_uuid(element.ResourceType.disk)
cores_used, mem_used, disk_used = self.\
strategy.calculate_used_resource(
node, cap_cores, cap_mem, cap_disk)

34
watcher/tests/decision_engine/strategy/strategies/test_vm_workload_consolidation.py
View File

@@ -69,7 +69,7 @@ class TestVMWorkloadConsolidation(base.TestCase):
model = self.fake_cluster.generate_scenario_1()
self.m_model.return_value = model
self.fake_metrics.model = model
instance_0 = model.get_instance_from_id("INSTANCE_0")
instance_0 = model.get_instance_by_uuid("INSTANCE_0")
instance_util = dict(cpu=1.0, ram=1, disk=10)
self.assertEqual(
instance_util,
@@ -79,7 +79,7 @@ class TestVMWorkloadConsolidation(base.TestCase):
model = self.fake_cluster.generate_scenario_1()
self.m_model.return_value = model
self.fake_metrics.model = model
node_0 = model.get_node_from_id("Node_0")
node_0 = model.get_node_by_uuid("Node_0")
node_util = dict(cpu=1.0, ram=1, disk=10)
self.assertEqual(
node_util,
@@ -89,7 +89,7 @@ class TestVMWorkloadConsolidation(base.TestCase):
model = self.fake_cluster.generate_scenario_1()
self.m_model.return_value = model
self.fake_metrics.model = model
node_0 = model.get_node_from_id("Node_0")
node_0 = model.get_node_by_uuid("Node_0")
node_util = dict(cpu=40, ram=64, disk=250)
self.assertEqual(node_util,
self.strategy.get_node_capacity(node_0, model))
@@ -98,7 +98,7 @@ class TestVMWorkloadConsolidation(base.TestCase):
model = self.fake_cluster.generate_scenario_1()
self.m_model.return_value = model
self.fake_metrics.model = model
node = model.get_node_from_id('Node_0')
node = model.get_node_by_uuid('Node_0')
rhu = self.strategy.get_relative_node_utilization(
node, model)
expected_rhu = {'disk': 0.04, 'ram': 0.015625, 'cpu': 0.025}
@@ -116,8 +116,8 @@ class TestVMWorkloadConsolidation(base.TestCase):
model = self.fake_cluster.generate_scenario_1()
self.m_model.return_value = model
self.fake_metrics.model = model
n1 = model.get_node_from_id('Node_0')
n2 = model.get_node_from_id('Node_1')
n1 = model.get_node_by_uuid('Node_0')
n2 = model.get_node_by_uuid('Node_1')
instance_uuid = 'INSTANCE_0'
self.strategy.add_migration(instance_uuid, n1, n2, model)
self.assertEqual(1, len(self.strategy.solution.actions))
@@ -132,7 +132,7 @@ class TestVMWorkloadConsolidation(base.TestCase):
model = self.fake_cluster.generate_scenario_1()
self.m_model.return_value = model
self.fake_metrics.model = model
n1 = model.get_node_from_id('Node_0')
n1 = model.get_node_by_uuid('Node_0')
cc = {'cpu': 1.0, 'ram': 1.0, 'disk': 1.0}
res = self.strategy.is_overloaded(n1, model, cc)
self.assertFalse(res)
@@ -149,7 +149,7 @@ class TestVMWorkloadConsolidation(base.TestCase):
model = self.fake_cluster.generate_scenario_1()
self.m_model.return_value = model
self.fake_metrics.model = model
n = model.get_node_from_id('Node_1')
n = model.get_node_by_uuid('Node_1')
instance_uuid = 'INSTANCE_0'
cc = {'cpu': 1.0, 'ram': 1.0, 'disk': 1.0}
res = self.strategy.instance_fits(instance_uuid, n, model, cc)
@@ -163,7 +163,7 @@ class TestVMWorkloadConsolidation(base.TestCase):
model = self.fake_cluster.generate_scenario_1()
self.m_model.return_value = model
self.fake_metrics.model = model
n = model.get_node_from_id('Node_0')
n = model.get_node_by_uuid('Node_0')
self.strategy.add_action_enable_compute_node(n)
expected = [{'action_type': 'change_nova_service_state',
'input_parameters': {'state': 'enabled',
@@ -174,7 +174,7 @@ class TestVMWorkloadConsolidation(base.TestCase):
model = self.fake_cluster.generate_scenario_1()
self.m_model.return_value = model
self.fake_metrics.model = model
n = model.get_node_from_id('Node_0')
n = model.get_node_by_uuid('Node_0')
self.strategy.add_action_disable_node(n)
expected = [{'action_type': 'change_nova_service_state',
'input_parameters': {'state': 'disabled',
@@ -185,8 +185,8 @@ class TestVMWorkloadConsolidation(base.TestCase):
model = self.fake_cluster.generate_scenario_1()
self.m_model.return_value = model
self.fake_metrics.model = model
n1 = model.get_node_from_id('Node_0')
n2 = model.get_node_from_id('Node_1')
n1 = model.get_node_by_uuid('Node_0')
n2 = model.get_node_by_uuid('Node_1')
instance_uuid = 'INSTANCE_0'
self.strategy.disable_unused_nodes(model)
self.assertEqual(0, len(self.strategy.solution.actions))
@@ -214,8 +214,8 @@ class TestVMWorkloadConsolidation(base.TestCase):
model = self.fake_cluster.generate_scenario_1()
self.m_model.return_value = model
self.fake_metrics.model = model
n1 = model.get_node_from_id('Node_0')
n2 = model.get_node_from_id('Node_1')
n1 = model.get_node_by_uuid('Node_0')
n2 = model.get_node_by_uuid('Node_1')
instance_uuid = 'INSTANCE_0'
cc = {'cpu': 1.0, 'ram': 1.0, 'disk': 1.0}
self.strategy.consolidation_phase(model, cc)
@@ -230,7 +230,7 @@ class TestVMWorkloadConsolidation(base.TestCase):
model = self.fake_cluster.generate_scenario_2()
self.m_model.return_value = model
self.fake_metrics.model = model
n1 = model.get_node_from_id('Node_0')
n1 = model.get_node_by_uuid('Node_0')
cc = {'cpu': 1.0, 'ram': 1.0, 'disk': 1.0}
self.strategy.offload_phase(model, cc)
self.strategy.consolidation_phase(model, cc)
@@ -254,8 +254,8 @@ class TestVMWorkloadConsolidation(base.TestCase):
model = self.fake_cluster.generate_scenario_3()
self.m_model.return_value = model
self.fake_metrics.model = model
n1 = model.get_node_from_id('Node_0')
n2 = model.get_node_from_id('Node_1')
n1 = model.get_node_by_uuid('Node_0')
n2 = model.get_node_by_uuid('Node_1')
cc = {'cpu': 1.0, 'ram': 1.0, 'disk': 1.0}
self.strategy.offload_phase(model, cc)
expected = [{'action_type': 'migrate',

8
watcher/tests/decision_engine/strategy/strategies/test_workload_balance.py
View File

@@ -66,10 +66,10 @@ class TestWorkloadBalance(base.TestCase):
def test_calc_used_res(self):
model = self.fake_cluster.generate_scenario_6_with_2_nodes()
self.m_model.return_value = model
node = model.get_node_from_id('Node_0')
cap_cores = model.get_resource_from_id(element.ResourceType.cpu_cores)
cap_mem = model.get_resource_from_id(element.ResourceType.memory)
cap_disk = model.get_resource_from_id(element.ResourceType.disk)
node = model.get_node_by_uuid('Node_0')
cap_cores = model.get_resource_by_uuid(element.ResourceType.cpu_cores)
cap_mem = model.get_resource_by_uuid(element.ResourceType.memory)
cap_disk = model.get_resource_by_uuid(element.ResourceType.disk)
cores_used, mem_used, disk_used = (
self.strategy.calculate_used_resource(
node, cap_cores, cap_mem, cap_disk))