def test_assert_volume_raise(self):
model = model_root.StorageModelRoot()
uuid_ = "{0}".format(uuidutils.generate_uuid())
volume = element.Volume(uuid=uuid_)
model.add_volume(volume)
self.assertRaises(exception.IllegalArgumentException,
model.assert_volume, "obj")
def test_exception_empty_storage_model(self):
c_model = self.fake_c_cluster.generate_scenario_1()
self.m_c_model.return_value = c_model
s_model = model_root.StorageModelRoot()
self.m_s_model.return_value = s_model
self.assertRaises(exception.StorageClusterEmpty, self.strategy.execute)
def test_remove_pool(self):
model = model_root.StorageModelRoot()
pool_name = "host@backend#pool"
pool = element.Pool(name=pool_name)
model.add_pool(pool)
self.assertEqual(pool, model.get_pool_by_pool_name(pool_name))
model.remove_pool(pool)
self.assertRaises(exception.PoolNotFound, model.get_pool_by_pool_name,
pool_name)
def test_remove_node(self):
model = model_root.StorageModelRoot()
hostname = "host@backend"
node = element.StorageNode(host=hostname)
model.add_node(node)
self.assertEqual(node, model.get_node_by_name(hostname))
model.remove_node(node)
self.assertRaises(exception.StorageNodeNotFound,
model.get_node_by_name, hostname)
def test_remove_volume(self):
model = model_root.StorageModelRoot()
uuid_ = "{0}".format(uuidutils.generate_uuid())
volume = element.Volume(uuid=uuid_)
model.add_volume(volume)
self.assertEqual(volume, model.get_volume_by_uuid(uuid_))
model.remove_volume(volume)
self.assertRaises(exception.VolumeNotFound, model.get_volume_by_uuid,
uuid_)
def test_get_all_storage_nodes(self):
model = model_root.StorageModelRoot()
for i in range(10):
hostname = "host_{0}".format(i)
node = element.StorageNode(host=hostname)
model.add_node(node)
all_nodes = model.get_all_storage_nodes()
for hostname in all_nodes:
node = model.get_node_by_name(hostname)
model.assert_node(node)
def test_get_all_volumes(self):
model = model_root.StorageModelRoot()
for id_ in range(10):
uuid_ = "{0}".format(uuidutils.generate_uuid())
volume = element.Volume(uuid=uuid_)
model.add_volume(volume)
all_volumes = model.get_all_volumes()
for vol in all_volumes:
volume = model.get_volume_by_uuid(vol)
model.assert_volume(volume)
def test_get_node_pools(self):
model = model_root.StorageModelRoot()
hostname = "host@backend"
node = element.StorageNode(host=hostname)
model.add_node(node)
self.assertEqual(node, model.get_node_by_name(hostname))
pool_name = "host@backend#pool"
pool = element.Pool(name=pool_name)
model.add_pool(pool)
self.assertEqual(pool, model.get_pool_by_pool_name(pool_name))
model.map_pool(pool, node)
self.assertEqual([pool], model.get_node_pools(node))
def test_get_pool_volumes(self):
model = model_root.StorageModelRoot()
pool_name = "host@backend#pool"
pool = element.Pool(name=pool_name)
model.add_pool(pool)
self.assertEqual(pool, model.get_pool_by_pool_name(pool_name))
uuid_ = "{0}".format(uuidutils.generate_uuid())
volume = element.Volume(uuid=uuid_)
model.add_volume(volume)
self.assertEqual(volume, model.get_volume_by_uuid(uuid_))
model.map_volume(volume, pool)
self.assertEqual([volume], model.get_pool_volumes(pool))
def test_map_unmap_pool(self):
model = model_root.StorageModelRoot()
hostname = "host@backend"
node = element.StorageNode(host=hostname)
model.add_node(node)
self.assertEqual(node, model.get_node_by_name(hostname))
pool_name = "host@backend#pool"
pool = element.Pool(name=pool_name)
model.add_pool(pool)
self.assertEqual(pool, model.get_pool_by_pool_name(pool_name))
model.map_pool(pool, node)
self.assertTrue(pool.name in model.predecessors(node.host))
model.unmap_pool(pool, node)
self.assertFalse(pool.name in model.predecessors(node.host))
def test_map_unmap_volume(self):
model = model_root.StorageModelRoot()
pool_name = "host@backend#pool"
pool = element.Pool(name=pool_name)
model.add_pool(pool)
self.assertEqual(pool, model.get_pool_by_pool_name(pool_name))
uuid_ = "{0}".format(uuidutils.generate_uuid())
volume = element.Volume(uuid=uuid_)
model.add_volume(volume)
self.assertEqual(volume, model.get_volume_by_uuid(uuid_))
model.map_volume(volume, pool)
self.assertTrue(volume.uuid in model.predecessors(pool.name))
model.unmap_volume(volume, pool)
self.assertFalse(volume.uuid in model.predecessors(pool.name))
def build_scenario_1(self):
model = modelroot.StorageModelRoot()
# number of nodes
node_count = 2
# number of pools per node
pool_count = 2
# number of volumes
volume_count = 9
for i in range(0, node_count):
host = "host_{0}@backend_{0}".format(i)
zone = "zone_{0}".format(i)
volume_type = ["type_{0}".format(i)]
node_attributes = {
"host": host,
"zone": zone,
"status": 'enabled',
"state": 'up',
"volume_type": volume_type,
}
node = element.StorageNode(**node_attributes)
model.add_node(node)
for j in range(0, pool_count):
name = "host_{0}@backend_{0}#pool_{1}".format(i, j)
pool_attributes = {
"name": name,
"total_volumes": 2,
"total_capacity_gb": 500,
"free_capacity_gb": 420,
"provisioned_capacity_gb": 80,
"allocated_capacity_gb": 80,
"virtual_free": 420,
}
pool = element.Pool(**pool_attributes)
model.add_pool(pool)
mappings = [
("host_0@backend_0#pool_0", "host_0@backend_0"),
("host_0@backend_0#pool_1", "host_0@backend_0"),
("host_1@backend_1#pool_0", "host_1@backend_1"),
("host_1@backend_1#pool_1", "host_1@backend_1"),
]
for pool_name, node_name in mappings:
model.map_pool(
model.get_pool_by_pool_name(pool_name),
model.get_node_by_name(node_name),
)
volume_uuid_mapping = [
"5028b1eb-8749-48ae-a42c-5bdd1323976f",
"74454247-a064-4b34-8f43-89337987720e",
"a16c811e-2521-4fd3-8779-6a94ccb3be73",
"37856b95-5be4-4864-8a49-c83f55c66780",
"694f8fb1-df96-46be-b67d-49f2c14a495e",
"66b094b0-8fc3-4a94-913f-a5f9312b11a5",
"e9013810-4b4c-4b94-a056-4c36702d51a3",
"07976191-6a57-4c35-9f3c-55b3b5ecd6d5",
"4d1c952d-95d0-4aac-82aa-c3cb509af9f3",
]
for k in range(volume_count):
uuid = volume_uuid_mapping[k]
name = "name_{0}".format(k)
volume_attributes = {
"size": 40,
"status": "in-use",
"uuid": uuid,
"attachments":
'[{"server_id": "server","attachment_id": "attachment"}]',
"name": name,
"multiattach": 'True',
"snapshot_id": uuid,
"project_id": "91FFFE30-78A0-4152-ACD2-8310FF274DC9",
"metadata": '{"readonly": false,"attached_mode": "rw"}',
"bootable": 'False'
}
volume = element.Volume(**volume_attributes)
model.add_volume(volume)
mappings = [
(volume_uuid_mapping[0], "host_0@backend_0#pool_0"),
(volume_uuid_mapping[1], "host_0@backend_0#pool_0"),
(volume_uuid_mapping[2], "host_0@backend_0#pool_1"),
(volume_uuid_mapping[3], "host_0@backend_0#pool_1"),
(volume_uuid_mapping[4], "host_1@backend_1#pool_0"),
(volume_uuid_mapping[5], "host_1@backend_1#pool_0"),
(volume_uuid_mapping[6], "host_1@backend_1#pool_1"),
(volume_uuid_mapping[7], "host_1@backend_1#pool_1"),
]
for volume_uuid, pool_name in mappings:
model.map_volume(
model.get_volume_by_uuid(volume_uuid),
model.get_pool_by_pool_name(pool_name),
)
return model
def __init__(self, osc):
self.osc = osc
self.model = model_root.StorageModelRoot()
self.cinder = osc.cinder()
self.cinder_helper = cinder_helper.CinderHelper(osc=self.osc)
def test_assert_node_raise(self):
model = model_root.StorageModelRoot()
node = element.StorageNode(host="host@backend")
model.add_node(node)
self.assertRaises(exception.IllegalArgumentException,
model.assert_node, "obj")
def test_assert_pool_raise(self):
model = model_root.StorageModelRoot()
pool = element.Pool(name="host@backend#pool")
model.add_pool(pool)
self.assertRaises(exception.IllegalArgumentException,
model.assert_pool, "obj")
def test_add_node(self):
model = model_root.StorageModelRoot()
hostname = "host@backend"
node = element.StorageNode(host=hostname)
model.add_node(node)
self.assertEqual(node, model.get_node_by_name(hostname))
def test_add_pool(self):
model = model_root.StorageModelRoot()
pool_name = "host@backend#pool"
pool = element.Pool(name=pool_name)
model.add_pool(pool)
self.assertEqual(pool, model.get_pool_by_pool_name(pool_name))
def build_scenario_1(self):
model = modelroot.StorageModelRoot()
# number of nodes
node_count = 2
# number of pools per node
pool_count = 2
# number of volumes
volume_count = 9
for i in range(0, node_count):
host = "host_{0}@backend_{0}".format(i)
zone = "zone_{0}".format(i)
volume_type = "type_{0}".format(i)
node_attributes = {
"host": host,
"zone": zone,
"status": 'enabled',
"state": 'up',
"volume_type": volume_type,
}
node = element.StorageNode(**node_attributes)
model.add_node(node)
for j in range(0, pool_count):
name = "host_{0}@backend_{0}#pool_{1}".format(i, j)
pool_attributes = {
"name": name,
"total_volumes": 2,
"total_capacity_gb": 500,
"free_capacity_gb": 420,
"provisioned_capacity_gb": 80,
"allocated_capacity_gb": 80,
"virtual_free": 420,
}
pool = element.Pool(**pool_attributes)
model.add_pool(pool)
mappings = [
("host_0@backend_0#pool_0", "host_0@backend_0"),
("host_0@backend_0#pool_1", "host_0@backend_0"),
("host_1@backend_1#pool_0", "host_1@backend_1"),
("host_1@backend_1#pool_1", "host_1@backend_1"),
]
for pool_name, node_name in mappings:
model.map_pool(
model.get_pool_by_pool_name(pool_name),
model.get_node_by_name(node_name),
)
for k in range(volume_count):
uuid = "VOLUME_{0}".format(k)
name = "name_{0}".format(k)
project_id = "project_{0}".format(k)
volume_attributes = {
"size": 40,
"status": "in-use",
"uuid": uuid,
"attachments":
'[{"server_id": "server","attachment_id": "attachment"}]',
"name": name,
"multiattach": 'True',
"snapshot_id": uuid,
"project_id": project_id,
"metadata": '{"readonly": false,"attached_mode": "rw"}',
"bootable": 'False'
}
volume = element.Volume(**volume_attributes)
model.add_volume(volume)
mappings = [
("VOLUME_0", "host_0@backend_0#pool_0"),
("VOLUME_1", "host_0@backend_0#pool_0"),
("VOLUME_2", "host_0@backend_0#pool_1"),
("VOLUME_3", "host_0@backend_0#pool_1"),
("VOLUME_4", "host_1@backend_1#pool_0"),
("VOLUME_5", "host_1@backend_1#pool_0"),
("VOLUME_6", "host_1@backend_1#pool_1"),
("VOLUME_7", "host_1@backend_1#pool_1"),
]
for volume_uuid, pool_name in mappings:
model.map_volume(
model.get_volume_by_uuid(volume_uuid),
model.get_pool_by_pool_name(pool_name),
)
return model
def test_add_volume(self):
model = model_root.StorageModelRoot()
uuid_ = "{0}".format(uuidutils.generate_uuid())
volume = element.Volume(uuid=uuid_)
model.add_volume(volume)
self.assertEqual(volume, model.get_volume_by_uuid(uuid_))
