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 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 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)