def test_remove_node_raise(self):
model = model_root.ModelRoot()
uuid_ = "{0}".format(uuidutils.generate_uuid())
node = element.ComputeNode(id=1)
node.uuid = uuid_
model.add_node(node)
uuid2 = "{0}".format(uuidutils.generate_uuid())
node2 = element.ComputeNode(id=2)
node2.uuid = uuid2
self.assertRaises(exception.ComputeNodeNotFound, model.remove_node,
node2)
def test_add_node(self):
model = model_root.ModelRoot()
uuid_ = "{0}".format(uuidutils.generate_uuid())
node = element.ComputeNode(id=1)
node.uuid = uuid_
model.add_node(node)
self.assertEqual(node, model.get_node_by_uuid(uuid_))
def create_compute_node(self, node_hostname):
"""Update the compute node by querying the Nova API."""
try:
_node = self.nova.get_compute_node_by_hostname(node_hostname)
node = element.ComputeNode(_node.id)
node.uuid = node_hostname
node.hostname = _node.hypervisor_hostname
node.state = _node.state
node.status = _node.status
self.update_capacity(element.ResourceType.memory, node,
_node.memory_mb)
self.update_capacity(element.ResourceType.cpu_cores, node,
_node.vcpus)
self.update_capacity(element.ResourceType.disk, node,
_node.free_disk_gb)
self.update_capacity(element.ResourceType.disk_capacity, node,
_node.local_gb)
return node
except Exception as exc:
LOG.exception(exc)
LOG.debug("Could not refresh the node %s.", node_hostname)
raise exception.ComputeNodeNotFound(name=node_hostname)
return False
def build_compute_node(self, node):
"""Build a compute node from a Nova compute node
:param node: A node hypervisor instance
:type node: :py:class:`~novaclient.v2.hypervisors.Hypervisor`
"""
# build up the compute node.
compute_service = self.nova_helper.get_service(node.service["id"])
node_attributes = {
"id": node.id,
"uuid": compute_service.host,
"hostname": node.hypervisor_hostname,
"memory": node.memory_mb,
"disk": node.free_disk_gb,
"disk_capacity": node.local_gb,
"vcpus": node.vcpus,
"state": node.state,
"status": node.status,
"disabled_reason": compute_service.disabled_reason
}
compute_node = element.ComputeNode(**node_attributes)
# compute_node = self._build_node("physical", "compute", "hypervisor",
# node_attributes)
return compute_node
def build_compute_node(self, node):
"""Build a compute node from a Nova compute node
:param node: A node hypervisor instance
:type node: :py:class:`~novaclient.v2.hypervisors.Hypervisor`
"""
inventories = self.placement_helper.get_inventories(node.id)
if inventories and orc.VCPU in inventories:
vcpus = inventories[orc.VCPU]['total']
vcpu_reserved = inventories[orc.VCPU]['reserved']
vcpu_ratio = inventories[orc.VCPU]['allocation_ratio']
else:
vcpus = node.vcpus
vcpu_reserved = 0
vcpu_ratio = 1.0
if inventories and orc.MEMORY_MB in inventories:
memory_mb = inventories[orc.MEMORY_MB]['total']
memory_mb_reserved = inventories[orc.MEMORY_MB]['reserved']
memory_ratio = inventories[orc.MEMORY_MB]['allocation_ratio']
else:
memory_mb = node.memory_mb
memory_mb_reserved = 0
memory_ratio = 1.0
# NOTE(licanwei): A nova BP support-shared-storage-resource-provider
# will move DISK_GB from compute node to shared storage RP.
# Here may need to be updated when the nova BP released.
if inventories and orc.DISK_GB in inventories:
disk_capacity = inventories[orc.DISK_GB]['total']
disk_gb_reserved = inventories[orc.DISK_GB]['reserved']
disk_ratio = inventories[orc.DISK_GB]['allocation_ratio']
else:
disk_capacity = node.local_gb
disk_gb_reserved = 0
disk_ratio = 1.0
# build up the compute node.
node_attributes = {
# The id of the hypervisor as a UUID from version 2.53.
"uuid": node.id,
"hostname": node.service["host"],
"memory": memory_mb,
"memory_ratio": memory_ratio,
"memory_mb_reserved": memory_mb_reserved,
"disk": disk_capacity,
"disk_gb_reserved": disk_gb_reserved,
"disk_ratio": disk_ratio,
"vcpus": vcpus,
"vcpu_reserved": vcpu_reserved,
"vcpu_ratio": vcpu_ratio,
"state": node.state,
"status": node.status,
"disabled_reason": node.service["disabled_reason"]}
compute_node = element.ComputeNode(**node_attributes)
# compute_node = self._build_node("physical", "compute", "hypervisor",
# node_attributes)
return compute_node
def test_assert_node_raise(self):
model = model_root.ModelRoot()
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 build_scenario_1(self):
instances = []
model = modelroot.ModelRoot()
# number of nodes
node_count = 5
# number max of instance per node
node_instance_count = 7
# total number of virtual machine
instance_count = (node_count * node_instance_count)
for id_ in range(0, node_count):
node_uuid = "Node_{0}".format(id_)
hostname = "hostname_{0}".format(id_)
node_attributes = {
"id": id_,
"uuid": node_uuid,
"hostname": hostname,
"memory": 132,
"disk": 250,
"disk_capacity": 250,
"vcpus": 40,
}
node = element.ComputeNode(**node_attributes)
model.add_node(node)
for i in range(0, instance_count):
instance_uuid = "INSTANCE_{0}".format(i)
instance_attributes = {
"uuid": instance_uuid,
"memory": 2,
"disk": 20,
"disk_capacity": 20,
"vcpus": 10,
}
instance = element.Instance(**instance_attributes)
instances.append(instance)
model.add_instance(instance)
mappings = [
("INSTANCE_0", "Node_0"),
("INSTANCE_1", "Node_0"),
("INSTANCE_2", "Node_1"),
("INSTANCE_3", "Node_2"),
("INSTANCE_4", "Node_2"),
("INSTANCE_5", "Node_2"),
("INSTANCE_6", "Node_3"),
("INSTANCE_7", "Node_4"),
]
for instance_uuid, node_uuid in mappings:
model.map_instance(
model.get_instance_by_uuid(instance_uuid),
model.get_node_by_uuid(node_uuid),
)
return model
def test_get_node_used_resources(self):
fake_cluster = faker_cluster_state.FakerModelCollector()
model = fake_cluster.generate_scenario_1()
node = element.ComputeNode(uuid="Node_0")
resources_used = model.get_node_used_resources(node)
self.assertEqual(20, resources_used.get('vcpu'))
self.assertEqual(4, resources_used.get('memory'))
self.assertEqual(40, resources_used.get('disk'))
def test_delete_node(self):
model = model_root.ModelRoot()
uuid_ = "{0}".format(uuidutils.generate_uuid())
node = element.ComputeNode(id=1)
node.uuid = uuid_
model.add_node(node)
self.assertEqual(node, model.get_node_by_uuid(uuid_))
model.remove_node(node)
self.assertRaises(exception.ComputeNodeNotFound,
model.get_node_by_uuid, uuid_)
def test_node_from_uuid_raise(self):
model = model_root.ModelRoot()
uuid_ = "{0}".format(uuidutils.generate_uuid())
node = element.ComputeNode(id=1)
node.uuid = uuid_
model.add_node(node)
uuid2 = "{0}".format(uuidutils.generate_uuid())
self.assertRaises(exception.ComputeNodeNotFound,
model.get_node_by_uuid, uuid2)
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]]
uuid_ = "{0}".format(uuid.uuid4())
node = element.ComputeNode(id=1)
node.uuid = uuid_
model.mapping.unmap_by_uuid(node.uuid, instance0.uuid)
def test_get_all_compute_nodes(self):
model = model_root.ModelRoot()
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 uuid_ in all_nodes:
node = model.get_node_by_uuid(uuid_)
model.assert_node(node)
def test_get_node_instances(self):
fake_cluster = faker_cluster_state.FakerModelCollector()
model = fake_cluster.generate_scenario_1()
node = element.ComputeNode(uuid="Node_0")
instance0 = model.get_instance_by_uuid("INSTANCE_0")
instance1 = model.get_instance_by_uuid("INSTANCE_1")
instances = model.get_node_instances(node)
self.assertEqual(2, len(instances))
self.assertIn(instance0, instances)
self.assertIn(instance1, instances)
def test_get_node_by_name(self):
model = model_root.ModelRoot()
uuid_ = "{0}".format(uuidutils.generate_uuid())
name = 'test_node'
node = element.ComputeNode()
node.uuid = uuid_
node.hostname = name
model.add_node(node)
compute_node = model.get_node_by_name(name)
model.assert_node(compute_node)
self.assertEqual(name, compute_node['hostname'])
self.assertEqual(uuid_, compute_node['uuid'])
def test_node_from_name_raise(self):
model = model_root.ModelRoot()
uuid_ = "{0}".format(uuidutils.generate_uuid())
name = 'test_node'
node = element.ComputeNode()
node.uuid = uuid_
node.hostname = name
model.add_node(node)
fake_name = 'fake_node'
self.assertRaises(exception.ComputeNodeNotFound,
model.get_node_by_name, fake_name)
def test_set_get_state_nodes(self):
model = model_root.ModelRoot()
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_by_uuid(uuid_)
node.state = element.ServiceState.OFFLINE.value
self.assertIn(node.state, [el.value for el in element.ServiceState])
def test_get_node_by_instance_uuid(self):
model = model_root.ModelRoot()
uuid_ = "{0}".format(uuidutils.generate_uuid())
node = element.ComputeNode(id=1)
node.uuid = uuid_
model.add_node(node)
self.assertEqual(node, model.get_node_by_uuid(uuid_))
uuid_ = "{0}".format(uuidutils.generate_uuid())
instance = element.Instance(id=1)
instance.uuid = uuid_
model.add_instance(instance)
self.assertEqual(instance, model.get_instance_by_uuid(uuid_))
model.map_instance(instance, node)
self.assertEqual(node, model.get_node_by_instance_uuid(instance.uuid))
def execute(self):
"""Build the compute cluster data model"""
LOG.debug("Building latest Nova cluster data model")
model = model_root.ModelRoot()
mem = element.Resource(element.ResourceType.memory)
num_cores = element.Resource(element.ResourceType.cpu_cores)
disk = element.Resource(element.ResourceType.disk)
disk_capacity = element.Resource(element.ResourceType.disk_capacity)
model.create_resource(mem)
model.create_resource(num_cores)
model.create_resource(disk)
model.create_resource(disk_capacity)
flavor_cache = {}
nodes = self.wrapper.get_compute_node_list()
for n in nodes:
service = self.wrapper.nova.services.find(id=n.service['id'])
# create node in cluster_model_collector
node = element.ComputeNode(n.id)
node.uuid = service.host
node.hostname = n.hypervisor_hostname
# set capacity
mem.set_capacity(node, n.memory_mb)
disk.set_capacity(node, n.free_disk_gb)
disk_capacity.set_capacity(node, n.local_gb)
num_cores.set_capacity(node, n.vcpus)
node.state = n.state
node.status = n.status
model.add_node(node)
instances = self.wrapper.get_instances_by_node(str(service.host))
for v in instances:
# create VM in cluster_model_collector
instance = element.Instance()
instance.uuid = v.id
# nova/nova/compute/instance_states.py
instance.state = getattr(v, 'OS-EXT-STS:vm_state')
# set capacity
self.wrapper.get_flavor_instance(v, flavor_cache)
mem.set_capacity(instance, v.flavor['ram'])
# FIXME: update all strategies to use disk_capacity
# for instances instead of disk
disk.set_capacity(instance, v.flavor['disk'])
disk_capacity.set_capacity(instance, v.flavor['disk'])
num_cores.set_capacity(instance, v.flavor['vcpus'])
model.map_instance(instance, node)
return model
def from_xml(cls, data):
model = cls()
root = etree.fromstring(data)
mem = element.Resource(element.ResourceType.memory)
num_cores = element.Resource(element.ResourceType.cpu_cores)
disk = element.Resource(element.ResourceType.disk)
disk_capacity = element.Resource(element.ResourceType.disk_capacity)
model.create_resource(mem)
model.create_resource(num_cores)
model.create_resource(disk)
model.create_resource(disk_capacity)
for cn in root.findall('.//ComputeNode'):
node = element.ComputeNode(cn.get('id'))
node.uuid = cn.get('uuid')
node.hostname = cn.get('hostname')
# set capacity
mem.set_capacity(node, int(cn.get(str(mem.name))))
disk.set_capacity(node, int(cn.get(str(disk.name))))
disk_capacity.set_capacity(node,
int(cn.get(str(disk_capacity.name))))
num_cores.set_capacity(node, int(cn.get(str(num_cores.name))))
node.state = cn.get('state')
node.status = cn.get('status')
model.add_node(node)
for inst in root.findall('.//Instance'):
instance = element.Instance()
instance.uuid = inst.get('uuid')
instance.state = inst.get('state')
mem.set_capacity(instance, int(inst.get(str(mem.name))))
disk.set_capacity(instance, int(inst.get(str(disk.name))))
disk_capacity.set_capacity(instance,
int(inst.get(str(disk_capacity.name))))
num_cores.set_capacity(instance,
int(inst.get(str(num_cores.name))))
parent = inst.getparent()
if parent.tag == 'ComputeNode':
node = model.get_node_by_uuid(parent.get('uuid'))
model.map_instance(instance, node)
else:
model.add_instance(instance)
return model
def build_compute_node(self, node):
"""Build a compute node from a Nova compute node
:param node: A node hypervisor instance
:type node: :py:class:`~novaclient.v2.hypervisors.Hypervisor`
"""
# build up the compute node.
compute_service = self.nova_helper.get_service(node.service["id"])
node_attributes = {
"id": node.id,
"uuid": compute_service.host,
"hostname": node.hypervisor_hostname,
"memory": node.memory_mb,
"disk": node.free_disk_gb,
"disk_capacity": node.local_gb,
"vcpus": node.vcpus,
"state": node.state,
"status": node.status}
if compute_service.status == 'enabled':
service_status = element.ServiceState.ENABLED.value
elif compute_service.disabled_reason == 'watcher_disabled':
service_status = element.ServiceState.DISABLED.value
elif compute_service.disabled_reason == 'watcher_maintaining':
service_status = element.ServiceState.MAINTAINING.value
# If compute node power off, set it in 'poweroff' status.
# If compute node power on, but not up, set it in 'poweron' status.
# If compute node power on, and up, set it in 'disabled' status,
# for further optimize.
elif compute_service.disabled_reason == 'watcher_poweroff':
service_status = element.ServiceState.POWEROFF.value
elif compute_service.disabled_reason == 'watcher_poweron' and
node.state == 'down':
service_status = element.ServiceState.POWERON.value
elif compute_service.disabled_reason == 'watcher_poweron' and
node.state == 'up':
service_status = element.ServiceState.DISABLED.value
else:
service_status = element.ServiceState.UNKNOWN.value
node_attributes["status"] = service_status
compute_node = element.ComputeNode(**node_attributes)
# compute_node = self._build_node("physical", "compute", "hypervisor",
# node_attributes)
return compute_node
def from_xml(cls, data):
model = cls()
root = etree.fromstring(data)
for cn in root.findall('.//ComputeNode'):
node = element.ComputeNode(**cn.attrib)
model.add_node(node)
for inst in root.findall('.//Instance'):
instance = element.Instance(**inst.attrib)
model.add_instance(instance)
parent = inst.getparent()
if parent.tag == 'ComputeNode':
node = model.get_node_by_uuid(parent.get('uuid'))
model.map_instance(instance, node)
else:
model.add_instance(instance)
return model
def create_compute_node(self, node_hostname):
"""Update the compute node by querying the Nova API."""
try:
_node = self.nova.get_compute_node_by_hostname(node_hostname)
node = element.ComputeNode(
id=_node.id,
uuid=node_hostname,
hostname=_node.hypervisor_hostname,
state=_node.state,
status=_node.status,
memory=_node.memory_mb,
vcpus=_node.vcpus,
disk=_node.free_disk_gb,
disk_capacity=_node.local_gb,
)
return node
except Exception as exc:
LOG.exception(exc)
LOG.debug("Could not refresh the node %s.", node_hostname)
raise exception.ComputeNodeNotFound(name=node_hostname)
return False
def build_scenario_1(self):
instances = []
current_state_cluster = modelroot.ModelRoot()
# number of nodes
node_count = 5
# number max of instance per node
node_instance_count = 7
# total number of virtual machine
instance_count = (node_count * node_instance_count)
# define ressouce ( CPU, MEM disk, ... )
mem = element.Resource(element.ResourceType.memory)
# 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 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(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)
for i in range(0, instance_count):
instance_uuid = "INSTANCE_{0}".format(i)
instance = element.Instance()
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.mapping.map(
current_state_cluster.get_node_by_uuid("Node_0"),
current_state_cluster.get_instance_by_uuid("INSTANCE_0"))
current_state_cluster.mapping.map(
current_state_cluster.get_node_by_uuid("Node_0"),
current_state_cluster.get_instance_by_uuid("INSTANCE_1"))
current_state_cluster.mapping.map(
current_state_cluster.get_node_by_uuid("Node_1"),
current_state_cluster.get_instance_by_uuid("INSTANCE_2"))
current_state_cluster.mapping.map(
current_state_cluster.get_node_by_uuid("Node_2"),
current_state_cluster.get_instance_by_uuid("INSTANCE_3"))
current_state_cluster.mapping.map(
current_state_cluster.get_node_by_uuid("Node_2"),
current_state_cluster.get_instance_by_uuid("INSTANCE_4"))
current_state_cluster.mapping.map(
current_state_cluster.get_node_by_uuid("Node_2"),
current_state_cluster.get_instance_by_uuid("INSTANCE_5"))
current_state_cluster.mapping.map(
current_state_cluster.get_node_by_uuid("Node_3"),
current_state_cluster.get_instance_by_uuid("INSTANCE_6"))
current_state_cluster.mapping.map(
current_state_cluster.get_node_by_uuid("Node_4"),
current_state_cluster.get_instance_by_uuid("INSTANCE_7"))
return current_state_cluster
def build_scenario_1(self):
instances = []
model = modelroot.ModelRoot()
# number of nodes
node_count = 5
# number max of instance per node
node_instance_count = 7
# total number of virtual machine
instance_count = (node_count * node_instance_count)
for id_ in range(0, node_count):
node_uuid = "Node_{0}".format(id_)
hostname = "hostname_{0}".format(id_)
node_attributes = {
"id": id_,
"uuid": node_uuid,
"hostname": hostname,
"memory": 132,
"disk": 250,
"disk_capacity": 250,
"vcpus": 40,
}
node = element.ComputeNode(**node_attributes)
model.add_node(node)
for i in range(0, instance_count):
instance_uuid = "INSTANCE_{0}".format(i)
if instance_uuid == "INSTANCE_1":
project_id = "26F03131-32CB-4697-9D61-9123F87A8147"
elif instance_uuid == "INSTANCE_2":
project_id = "109F7909-0607-4712-B32C-5CC6D49D2F15"
else:
project_id = "91FFFE30-78A0-4152-ACD2-8310FF274DC9"
instance_attributes = {
"uuid": instance_uuid,
"memory": 2,
"disk": 20,
"disk_capacity": 20,
"vcpus": 10,
"metadata":
'{"optimize": true,"top": "floor","nested": {"x": "y"}}',
"project_id": project_id
}
instance = element.Instance(**instance_attributes)
instances.append(instance)
model.add_instance(instance)
mappings = [
("INSTANCE_0", "Node_0"),
("INSTANCE_1", "Node_0"),
("INSTANCE_2", "Node_1"),
("INSTANCE_3", "Node_2"),
("INSTANCE_4", "Node_2"),
("INSTANCE_5", "Node_2"),
("INSTANCE_6", "Node_3"),
("INSTANCE_7", "Node_4"),
]
for instance_uuid, node_uuid in mappings:
model.map_instance(
model.get_instance_by_uuid(instance_uuid),
model.get_node_by_uuid(node_uuid),
)
return model
