def restore_backup(self, cntxt, checkpoint, **kwargs):
resource_node = kwargs.get("node")
resource_id = resource_node.value.id
heat_template = kwargs.get("heat_template")
name = kwargs.get("restore_name",
"%s@%s" % (checkpoint.id, resource_id))
description = kwargs.get("restore_description")
heat_resource_id = uuidutils.generate_uuid()
heat_resource = HeatResource(heat_resource_id,
constants.VOLUME_RESOURCE_TYPE)
bank_section = checkpoint.get_resource_bank_section(resource_id)
try:
resource_definition = bank_section.get_object("metadata")
backup_id = resource_definition["backup_id"]
properties = {"backup_id": backup_id, "name": name}
if description is not None:
properties["description"] = description
for key, value in properties.items():
heat_resource.set_property(key, value)
heat_template.put_resource(resource_id, heat_resource)
except Exception as e:
LOG.error(_LE("restore volume backup failed, volume_id: %s."),
resource_id)
raise exception.RestoreBackupFailed(
reason=six.text_type(e),
resource_id=resource_id,
resource_type=constants.VOLUME_RESOURCE_TYPE)
def _heat_restore_server_instance(self, heat_template, image_id,
original_id, restore_name,
resource_definition):
server_metadata = resource_definition["server_metadata"]
properties = {
"availability_zone": server_metadata["availability_zone"],
"flavor": server_metadata["flavor"],
"image": image_id,
"name": restore_name,
}
if server_metadata["key_name"] is not None:
properties["key_name"] = server_metadata["key_name"]
if server_metadata["security_groups"] is not None:
security_groups = []
for security_group in server_metadata["security_groups"]:
security_groups.append(security_group["name"])
properties["security_groups"] = security_groups
networks = []
for network in server_metadata["networks"]:
networks.append({"network": network})
properties["networks"] = networks
heat_resource_id = uuidutils.generate_uuid()
heat_server_resource = HeatResource(heat_resource_id,
constants.SERVER_RESOURCE_TYPE)
for key, value in properties.items():
heat_server_resource.set_property(key, value)
heat_template.put_resource(original_id, heat_server_resource)
def restore_backup(self, cntxt, checkpoint, **kwargs):
resource_node = kwargs.get("node")
resource_id = resource_node.value.id
heat_template = kwargs.get("heat_template")
name = kwargs.get("restore_name",
"%s@%s" % (checkpoint.id, resource_id))
description = kwargs.get("restore_description")
heat_resource_id = uuidutils.generate_uuid()
heat_resource = HeatResource(heat_resource_id,
constants.VOLUME_RESOURCE_TYPE)
bank_section = checkpoint.get_resource_bank_section(resource_id)
try:
resource_definition = bank_section.get_object("metadata")
backup_id = resource_definition["backup_id"]
properties = {"backup_id": backup_id,
"name": name}
if description is not None:
properties["description"] = description
for key, value in properties.items():
heat_resource.set_property(key, value)
heat_template.put_resource(resource_id, heat_resource)
except Exception as e:
LOG.error(_LE("restore volume backup failed, volume_id: %s."),
resource_id)
raise exception.RestoreBackupFailed(
reason=six.text_type(e),
resource_id=resource_id,
resource_type=constants.VOLUME_RESOURCE_TYPE
)
def _heat_restore_server_instance(self, heat_template, image_id,
original_id, restore_name,
resource_definition):
server_metadata = resource_definition["server_metadata"]
properties = {
"availability_zone": server_metadata["availability_zone"],
"flavor": server_metadata["flavor"],
"image": image_id,
"name": restore_name,
}
if server_metadata["key_name"] is not None:
properties["key_name"] = server_metadata["key_name"]
if server_metadata["security_groups"] is not None:
security_groups = []
for security_group in server_metadata["security_groups"]:
security_groups.append(security_group["name"])
properties["security_groups"] = security_groups
networks = []
for network in server_metadata["networks"]:
networks.append({"network": network})
properties["networks"] = networks
heat_resource_id = uuidutils.generate_uuid()
heat_server_resource = HeatResource(heat_resource_id,
constants.SERVER_RESOURCE_TYPE)
for key, value in properties.items():
heat_server_resource.set_property(key, value)
heat_template.put_resource(original_id,
heat_server_resource)
def test_dump_to_yaml_file(self):
fake_original_id = "123456"
temp_dir = tempfile.mkdtemp()
temp_file = temp_dir + "/template.yaml"
fake_resource_id = "restore_123456"
fake_resource_type = "OS::Cinder::Volume"
heat_resource = HeatResource(fake_resource_id, fake_resource_type)
properties = {
"volume_type": "lvmdriver-1",
"size": 1
}
for key, value in properties.items():
heat_resource.set_property(key, value)
self.heat_template.put_resource(fake_original_id, heat_resource)
self.heat_template.dump_to_yaml_file(temp_file)
with open(temp_file, "r") as f:
template_dict = yaml.load(f)
target_dict = {
"heat_template_version": str(datetime.date(2015, 10, 15)),
"description": "karbor restore template",
"resources": {
"restore_123456": {
"type": "OS::Cinder::Volume",
"properties": {
"volume_type": "lvmdriver-1",
"size": 1
}
}
}
}
self.assertEqual(target_dict, template_dict)
def test_to_dict(self):
fake_original_id = "123456"
fake_resource_id = "restore_123456"
fake_resource_type = "OS::Cinder::Volume"
heat_resource = HeatResource(fake_resource_id, fake_resource_type)
properties = {
"volume_type": "lvmdriver-1",
"size": 1
}
for key, value in properties.items():
heat_resource.set_property(key, value)
self.heat_template.put_resource(fake_original_id, heat_resource)
fake_original_id_2 = '23456'
fake_parameter = 'restored_23456'
self.heat_template.put_parameter(fake_original_id_2, fake_parameter)
template_dict = self.heat_template.to_dict()
target_dict = {
"heat_template_version": str(datetime.date(2015, 10, 15)),
"description": "karbor restore template",
"resources": {
"restore_123456": {
"type": "OS::Cinder::Volume",
"properties": {
"volume_type": "lvmdriver-1",
"size": 1
}
}
}
}
self.assertEqual(target_dict, template_dict)
def _heat_restore_server_instance(self, heat_template,
original_id, restore_name,
resource_definition):
server_metadata = resource_definition["server_metadata"]
properties = {
"availability_zone": server_metadata["availability_zone"],
"flavor": server_metadata["flavor"],
"name": restore_name,
}
# server boot device
boot_metadata = resource_definition["boot_metadata"]
boot_device_type = boot_metadata["boot_device_type"]
if boot_device_type == "image":
original_image_id = boot_metadata["boot_image_id"]
image_id = heat_template.get_resource_reference(
original_image_id)
properties["image"] = image_id
elif boot_device_type == "volume":
original_volume_id = boot_metadata["boot_volume_id"]
volume_id = heat_template.get_resource_reference(
original_volume_id)
properties["block_device_mapping_v2"] = [{
"volume_id": volume_id,
"delete_on_termination": False,
"boot_index": 0,
}]
else:
LOG.exception("Restore server backup failed, server_id: %s.",
original_id)
raise exception.RestoreBackupFailed(
reason="Can not find the boot device of the server.",
resource_id=original_id,
resource_type=constants.SERVER_RESOURCE_TYPE
)
# server key_name, security_groups, networks
if server_metadata["key_name"] is not None:
properties["key_name"] = server_metadata["key_name"]
if server_metadata["security_groups"] is not None:
security_groups = []
for security_group in server_metadata["security_groups"]:
security_groups.append(security_group["name"])
properties["security_groups"] = security_groups
networks = []
for network in server_metadata["networks"]:
networks.append({"network": network})
properties["networks"] = networks
heat_resource_id = uuidutils.generate_uuid()
heat_server_resource = HeatResource(heat_resource_id,
constants.SERVER_RESOURCE_TYPE)
for key, value in properties.items():
heat_server_resource.set_property(key, value)
heat_template.put_resource(original_id,
heat_server_resource)
def test_put_resource(self):
fake_original_id = "123456"
fake_resource_id = "restore_123456"
fake_resource_type = "OS::Cinder::Volume"
heat_resource = HeatResource(fake_resource_id, fake_resource_type)
properties = {
"volume_type": "lvmdriver-1",
"size": 1
}
for key, value in properties.items():
heat_resource.set_property(key, value)
self.heat_template.put_resource(fake_original_id, heat_resource)
self.assertEqual(1, len(self.heat_template._resources))
self.assertEqual(
fake_resource_id,
self.heat_template._original_id_resource_map[fake_original_id]
)
def _heat_restore_floating_association(self, heat_template,
original_server_id,
resource_definition):
server_metadata = resource_definition["server_metadata"]
for floating_ip in server_metadata["floating_ips"]:
instance_uuid = heat_template.get_resource_reference(
original_server_id)
properties = {"instance_uuid": instance_uuid,
"floating_ip": floating_ip}
heat_resource_id = uuidutils.generate_uuid()
heat_floating_resource = HeatResource(
heat_resource_id, FLOATING_IP_ASSOCIATION)
for key, value in properties.items():
heat_floating_resource.set_property(key, value)
heat_template.put_resource(
"%s_%s" % (original_server_id, floating_ip),
heat_floating_resource)
def _heat_restore_floating_association(self, heat_template,
original_server_id,
resource_definition):
server_metadata = resource_definition["server_metadata"]
for floating_ip in server_metadata["floating_ips"]:
instance_uuid = heat_template.get_resource_reference(
original_server_id)
properties = {"instance_uuid": instance_uuid,
"floating_ip": floating_ip}
heat_resource_id = uuidutils.generate_uuid()
heat_floating_resource = HeatResource(
heat_resource_id, FLOATING_IP_ASSOCIATION)
for key, value in properties.items():
heat_floating_resource.set_property(key, value)
heat_template.put_resource(
"%s_%s" % (original_server_id, floating_ip),
heat_floating_resource)
def test_get_resource_reference(self):
fake_original_id = "123456"
fake_resource_id = "restore_123456"
fake_resource_type = "OS::Cinder::Volume"
heat_resource = HeatResource(fake_resource_id, fake_resource_type)
properties = {
"volume_type": "lvmdriver-1",
"size": 1
}
for key, value in properties.items():
heat_resource.set_property(key, value)
self.heat_template.put_resource(fake_original_id, heat_resource)
reference = self.heat_template.get_resource_reference(fake_original_id)
self.assertEqual({"get_resource": "restore_123456"}, reference)
fake_original_id = '23456'
fake_parameter = 'restored_23456'
self.heat_template.put_parameter(fake_original_id, fake_parameter)
reference = self.heat_template.get_resource_reference(fake_original_id)
self.assertEqual(fake_parameter, reference)
def _heat_restore_volume_attachment(self, heat_template,
original_server_id,
resource_definition):
attach_metadata = resource_definition["attach_metadata"]
for original_volume_id, device in attach_metadata.items():
instance_uuid = heat_template.get_resource_reference(
original_server_id)
volume_id = heat_template.get_resource_reference(
original_volume_id)
properties = {"mountpoint": device,
"instance_uuid": instance_uuid,
"volume_id": volume_id}
heat_resource_id = uuidutils.generate_uuid()
heat_attachment_resource = HeatResource(
heat_resource_id,
VOLUME_ATTACHMENT_RESOURCE)
for key, value in properties.items():
heat_attachment_resource.set_property(key, value)
heat_template.put_resource(
"%s_%s" % (original_server_id, original_volume_id),
heat_attachment_resource)
def _heat_restore_volume_attachment(self, heat_template,
original_server_id,
resource_definition):
attach_metadata = resource_definition["attach_metadata"]
for original_volume_id, device in attach_metadata.items():
instance_uuid = heat_template.get_resource_reference(
original_server_id)
volume_id = heat_template.get_resource_reference(
original_volume_id)
properties = {
"mountpoint": device,
"instance_uuid": instance_uuid,
"volume_id": volume_id
}
heat_resource_id = uuidutils.generate_uuid()
heat_attachment_resource = HeatResource(
heat_resource_id, VOLUME_ATTACHMENT_RESOURCE)
for key, value in properties.items():
heat_attachment_resource.set_property(key, value)
heat_template.put_resource(
"%s_%s" % (original_server_id, original_volume_id),
heat_attachment_resource)
def on_main(self, checkpoint, resource, context, parameters, heat_template,
**kwargs):
resource_id = resource.id
bank_section = checkpoint.get_resource_bank_section(resource_id)
resource_metadata = bank_section.get_object('metadata')
name = parameters.get('restore_name',
'%s@%s' % (checkpoint.id, resource_id))
heat_resource_id = uuidutils.generate_uuid()
heat_resource = HeatResource(heat_resource_id,
constants.VOLUME_RESOURCE_TYPE)
heat_resource.set_property('name', name)
if 'restore_description' in parameters:
heat_resource.set_property('description',
parameters['restore_description'])
heat_resource.set_property('backup_id', resource_metadata['backup_id'])
heat_template.put_resource(resource_id, heat_resource)
class HeatResourceTest(base.TestCase):
def setUp(self):
super(HeatResourceTest, self).setUp()
fake_resource_id = "restore_123456"
fake_resource_type = "OS::Cinder::Volume"
self.heat_resource = HeatResource(fake_resource_id, fake_resource_type)
def test_set_property(self):
key = "volume_type"
value = "lvmdriver-1"
self.heat_resource.set_property(key, value)
self.assertEqual({"volume_type": "lvmdriver-1"},
self.heat_resource._properties)
def test_to_dict(self):
properties = {
"volume_type": "lvmdriver-1",
"size": 1
}
for key, value in properties.items():
self.heat_resource.set_property(key, value)
resource_dict = self.heat_resource.to_dict()
target_dict = {
"restore_123456": {
"type": "OS::Cinder::Volume",
"properties": {
"volume_type": "lvmdriver-1",
"size": 1
}
}
}
self.assertEqual(target_dict, resource_dict)
def tearDown(self):
super(HeatResourceTest, self).tearDown()
def setUp(self):
super(HeatResourceTest, self).setUp()
fake_resource_id = "restore_123456"
fake_resource_type = "OS::Cinder::Volume"
self.heat_resource = HeatResource(fake_resource_id, fake_resource_type)
