def test_server_attached_volume_protect_both(self):
"""Test checkpoint for server with attached volume
Test checkpoint for server which has attached one volume,
and add server and volume both in protect source
"""
volume = self.store(objects.Volume())
volume.create(1)
server = self.store(objects.Server())
server.create()
server.attach_volume(volume.id)
plan = self.store(objects.Plan())
plan.create(self.provider_id, [server, volume])
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id, plan.id, timeout=2400)
items = self.karbor_client.checkpoints.list(self.provider_id)
ids = [item.id for item in items]
self.assertTrue(checkpoint.id in ids)
search_opts = {"volume_id": volume.id}
backups = self.cinder_client.backups.list(search_opts=search_opts)
self.assertEqual(1, len(backups))
server.detach_volume(volume.id)
def test_server_boot_from_volume_with_attached_volume(self):
"""Test checkpoint for server with a bootable volume
Test checkpoint for server which has booted form one bootable
volume.
"""
bootable_volume = self.store(objects.Volume())
bootable_volume_id = bootable_volume.create(1, create_from_image=True)
volume = self.store(objects.Volume())
volume.create(1)
server = self.store(objects.Server())
server.create(volume=bootable_volume_id)
server.attach_volume(volume.id)
plan = self.store(objects.Plan())
plan.create(self.provider_id, [
server,
])
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id, plan.id, timeout=2400)
items = self.karbor_client.checkpoints.list(self.provider_id)
ids = [item.id for item in items]
self.assertTrue(checkpoint.id in ids)
search_opts = {"volume_id": volume.id}
backups = self.cinder_client.backups.list(search_opts=search_opts)
self.assertEqual(1, len(backups))
search_opts = {"volume_id": bootable_volume_id}
bootable_backups = self.cinder_client.backups.list(
search_opts=search_opts)
self.assertEqual(1, len(bootable_backups))
server.detach_volume(volume.id)
def _create_for_server(self,
trigger_properties=DEFAULT_PROPERTY,
operation_name=None):
server = self.store(objects.Server())
server.create()
return self._create_scheduled_operation([
server,
], trigger_properties, operation_name)
def test_protectables_get_with_server(self):
server_list = self.karbor_client.protectables.list_instances(
'OS::Nova::Server')
before_num = len(server_list)
server = self.store(objects.Server())
server.create()
server_list = self.karbor_client.protectables.list_instances(
'OS::Nova::Server')
after_num = len(server_list)
self.assertEqual(1, after_num - before_num)
def test_protectables_get_instance(self):
volume = self.store(objects.Volume())
volume.create(1)
instance = self.karbor_client.protectables.get_instance(
'OS::Cinder::Volume', volume.id)
self.assertEqual(volume.id, instance.id)
server = self.store(objects.Server())
server.create()
instance = self.karbor_client.protectables.get_instance(
'OS::Nova::Server', server.id)
self.assertEqual(server.id, instance.id)
def test_protectables_list_instances(self):
volume = self.store(objects.Volume())
volume.create(1)
items = self.karbor_client.protectables.list_instances(
'OS::Cinder::Volume')
ids = [item.id for item in items]
self.assertTrue(volume.id in ids)
server = self.store(objects.Server())
server.create()
items = self.karbor_client.protectables.list_instances(
'OS::Nova::Server')
ids = [item.id for item in items]
self.assertTrue(server.id in ids)
def test_checkpoint_for_server_attached_volume(self):
"""Test checkpoint for server which has attached some volumes"""
volume = self.store(objects.Volume())
volume.create(1)
server = self.store(objects.Server())
server.create()
server.attach_volume(volume.id)
plan0 = self.store(objects.Plan())
plan0.create(self.provider_id, [
server,
])
checkpoints = self.karbor_client.checkpoints.list(self.provider_id)
before_checkpoints_num = len(checkpoints)
backups = self.cinder_client.backups.list()
before_backups_num = len(backups)
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id, plan0.id, timeout=900)
checkpoints = self.karbor_client.checkpoints.list(self.provider_id)
after_checkpoints_num = len(checkpoints)
self.assertEqual(1, after_checkpoints_num - before_checkpoints_num)
backups = self.cinder_client.backups.list()
after_backups_num = len(backups)
self.assertEqual(1, after_backups_num - before_backups_num)
plan1 = self.store(objects.Plan())
plan1.create(self.provider_id, [server, volume])
checkpoints = self.karbor_client.checkpoints.list(self.provider_id)
before_checkpoints_num = len(checkpoints)
backups = self.cinder_client.backups.list()
before_backups_num = len(backups)
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id, plan1.id, timeout=720)
checkpoints = self.karbor_client.checkpoints.list(self.provider_id)
after_checkpoints_num = len(checkpoints)
self.assertEqual(1, after_checkpoints_num - before_checkpoints_num)
backups = self.cinder_client.backups.list()
after_backups_num = len(backups)
self.assertEqual(1, after_backups_num - before_backups_num)
server.detach_volume(volume.id)
def test_protectables_get_with_attach_volume(self):
server = self.store(objects.Server())
server.create()
volume = self.store(objects.Volume())
volume.create(1)
server.attach_volume(volume.id)
volume_item = self.cinder_client.volumes.get(volume.id)
ins_res = self.karbor_client.protectables.get_instance(
'OS::Nova::Server', volume_item.attachments[0]["server_id"])
self.assertTrue(ins_res.dependent_resources)
self.assertEqual('OS::Cinder::Volume',
ins_res.dependent_resources[0]["type"])
self.assertEqual(volume.id, ins_res.dependent_resources[0]["id"])
def _create_scheduled_operation_for_server(
self, trigger_properties=DEFAULT_PROPERTY, operation_name=None):
server = self.store(objects.Server())
server.create()
plan = self.store(objects.Plan())
plan.create(self.provider_id, [
server,
])
operation_definition = {
'plan_id': plan.id,
'provider_id': self.provider_id
}
return self._create_scheduled_operation(trigger_properties,
operation_definition,
operation_name)
def test_protectables_list_instances(self):
volume = self.store(objects.Volume())
volume.create(1)
items = self.karbor_client.protectables.list_instances(
'OS::Cinder::Volume')
ids = [item.id for item in items]
self.assertTrue(volume.id in ids)
server = self.store(objects.Server())
server.create()
items = self.karbor_client.protectables.list_instances(
'OS::Nova::Server')
ids = [item.id for item in items]
self.assertTrue(server.id in ids)
network = self.store(objects.Network())
network.create()
items = self.karbor_client.protectables.list_instances(
'OS::Neutron::Network')
self.assertEqual(items[0].id, network.project_id)
def test_server_attached_volume_only_protect_server(self):
"""Test checkpoint for server with attached volume
Test checkpoint for server which has attached one volume,
but only add server in protect source
"""
volume = self.store(objects.Volume())
volume.create(1)
server = self.store(objects.Server())
server.create()
server.attach_volume(volume.id)
plan = self.store(objects.Plan())
plan.create(self.provider_id_noop, [
server,
])
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id_noop, plan.id, timeout=2400)
items = self.karbor_client.checkpoints.list(self.provider_id_noop)
ids = [item.id for item in items]
self.assertTrue(checkpoint.id in ids)
