def clone(diskguid, snapshotid, devicename, pmachineguid, machinename, machineguid=None):
"""
Clone a disk
"""
pmachine = PMachine(pmachineguid)
hypervisor = Factory.get(pmachine)
description = '{} {}'.format(machinename, devicename)
properties_to_clone = ['description', 'size', 'type', 'retentionpolicyguid',
'snapshotpolicyguid', 'autobackup']
vdisk = VDisk(diskguid)
location = hypervisor.get_backing_disk_path(machinename, devicename)
new_vdisk = VDisk()
new_vdisk.copy(vdisk, include=properties_to_clone)
new_vdisk.parent_vdisk = vdisk
new_vdisk.name = '{0}-clone'.format(vdisk.name)
new_vdisk.description = description
new_vdisk.devicename = hypervisor.clean_backing_disk_filename(location)
new_vdisk.parentsnapshot = snapshotid
new_vdisk.vmachine = VMachine(machineguid) if machineguid else vdisk.vmachine
new_vdisk.vpool = vdisk.vpool
new_vdisk.save()
try:
storagedriver = StorageDriverList.get_by_storagedriver_id(vdisk.storagedriver_id)
if storagedriver is None:
raise RuntimeError('Could not find StorageDriver with id {0}'.format(vdisk.storagedriver_id))
mds_service = MDSServiceController.get_preferred_mds(storagedriver.storagerouter, vdisk.vpool)
if mds_service is None:
raise RuntimeError('Could not find a MDS service')
logger.info('Clone snapshot {} of disk {} to location {}'.format(snapshotid, vdisk.name, location))
volume_id = vdisk.storagedriver_client.create_clone(
target_path=location,
metadata_backend_config=MDSMetaDataBackendConfig([MDSNodeConfig(address=str(mds_service.service.storagerouter.ip),
port=mds_service.service.ports[0])]),
parent_volume_id=str(vdisk.volume_id),
parent_snapshot_id=str(snapshotid),
node_id=str(vdisk.storagedriver_id)
)
except Exception as ex:
logger.error('Caught exception during clone, trying to delete the volume. {0}'.format(ex))
new_vdisk.delete()
VDiskController.delete_volume(location)
raise
new_vdisk.volume_id = volume_id
new_vdisk.save()
try:
MDSServiceController.ensure_safety(new_vdisk)
except Exception as ex:
logger.error('Caught exception during "ensure_safety" {0}'.format(ex))
return {'diskguid': new_vdisk.guid,
'name': new_vdisk.name,
'backingdevice': location}
def create_from_template(diskguid, machinename, devicename, pmachineguid, machineguid=None, storagedriver_guid=None):
"""
Create a disk from a template
@param parentdiskguid: guid of the disk
@param location: location where virtual device should be created (eg: myVM)
@param devicename: device file name for the disk (eg: mydisk-flat.vmdk)
@param machineguid: guid of the machine to assign disk to
@return diskguid: guid of new disk
"""
pmachine = PMachine(pmachineguid)
hypervisor = Factory.get(pmachine)
disk_path = hypervisor.get_disk_path(machinename, devicename)
description = '{} {}'.format(machinename, devicename)
properties_to_clone = [
'description', 'size', 'type', 'retentionpolicyid',
'snapshotpolicyid', 'vmachine', 'vpool']
disk = VDisk(diskguid)
if disk.vmachine and not disk.vmachine.is_vtemplate:
# Disk might not be attached to a vmachine, but still be a template
raise RuntimeError('The given disk does not belong to a template')
if storagedriver_guid is not None:
storagedriver_id = StorageDriver(storagedriver_guid).storagedriver_id
else:
storagedriver_id = disk.storagedriver_id
new_disk = VDisk()
new_disk.copy(disk, include=properties_to_clone)
new_disk.vpool = disk.vpool
new_disk.devicename = hypervisor.clean_backing_disk_filename(disk_path)
new_disk.parent_vdisk = disk
new_disk.name = '{}-clone'.format(disk.name)
new_disk.description = description
new_disk.vmachine = VMachine(machineguid) if machineguid else disk.vmachine
new_disk.save()
logger.info('Create disk from template {} to new disk {} to location {}'.format(
disk.name, new_disk.name, disk_path
))
try:
volume_id = disk.storagedriver_client.create_clone_from_template(disk_path, str(disk.volume_id), node_id=str(storagedriver_id))
new_disk.volume_id = volume_id
new_disk.save()
except Exception as ex:
logger.error('Clone disk on volumedriver level failed with exception: {0}'.format(str(ex)))
new_disk.delete()
raise
return {'diskguid': new_disk.guid, 'name': new_disk.name,
'backingdevice': disk_path}
def clean_bad_disk(vdiskguid):
"""
Cleanup bad vdisk:
- in case create_from_template failed
- remove mds_services so the vdisk can be properly cleaned up
:param vdiskguid: guid of vdisk
:return: None
"""
vdisk = VDisk(vdiskguid)
logger.info('Cleanup vdisk {0}'.format(vdisk.name))
for mdss in vdisk.mds_services:
mdss.delete()
storagedriver = StorageDriverList.get_by_storagedriver_id(vdisk.storagedriver_id)
if storagedriver is not None and vdisk.devicename is not None:
logger.debug('Removing volume from filesystem')
volumepath = vdisk.devicename
mountpoint = storagedriver.mountpoint
devicepath = '{0}/{1}'.format(mountpoint, volumepath)
VDiskController.delete_volume(devicepath)
logger.debug('Deleting vdisk {0} from model'.format(vdisk.name))
vdisk.delete()
def create_from_template(diskguid, machinename, devicename, pmachineguid, machineguid=None, storagedriver_guid=None):
"""
Create a disk from a template
@param devicename: device file name for the disk (eg: mydisk-flat.vmdk)
@param machineguid: guid of the machine to assign disk to
@return diskguid: guid of new disk
"""
pmachine = PMachine(pmachineguid)
hypervisor = Factory.get(pmachine)
disk_path = hypervisor.get_disk_path(machinename, devicename)
description = '{} {}'.format(machinename, devicename)
properties_to_clone = [
'description', 'size', 'type', 'retentionpolicyid',
'snapshotpolicyid', 'vmachine', 'vpool']
vdisk = VDisk(diskguid)
if vdisk.vmachine and not vdisk.vmachine.is_vtemplate:
# Disk might not be attached to a vmachine, but still be a template
raise RuntimeError('The given vdisk does not belong to a template')
if storagedriver_guid is not None:
storagedriver_id = StorageDriver(storagedriver_guid).storagedriver_id
else:
storagedriver_id = vdisk.storagedriver_id
storagedriver = StorageDriverList.get_by_storagedriver_id(storagedriver_id)
if storagedriver is None:
raise RuntimeError('Could not find StorageDriver with id {0}'.format(storagedriver_id))
new_vdisk = VDisk()
new_vdisk.copy(vdisk, include=properties_to_clone)
new_vdisk.vpool = vdisk.vpool
new_vdisk.devicename = hypervisor.clean_backing_disk_filename(disk_path)
new_vdisk.parent_vdisk = vdisk
new_vdisk.name = '{}-clone'.format(vdisk.name)
new_vdisk.description = description
new_vdisk.vmachine = VMachine(machineguid) if machineguid else vdisk.vmachine
new_vdisk.save()
mds_service = MDSServiceController.get_preferred_mds(storagedriver.storagerouter, vdisk.vpool)
if mds_service is None:
raise RuntimeError('Could not find a MDS service')
logger.info('Create disk from template {} to new disk {} to location {}'.format(
vdisk.name, new_vdisk.name, disk_path
))
try:
volume_id = vdisk.storagedriver_client.create_clone_from_template(
target_path=disk_path,
metadata_backend_config=MDSMetaDataBackendConfig([MDSNodeConfig(address=str(mds_service.service.storagerouter.ip),
port=mds_service.service.ports[0])]),
parent_volume_id=str(vdisk.volume_id),
node_id=str(storagedriver_id)
)
new_vdisk.volume_id = volume_id
new_vdisk.save()
MDSServiceController.ensure_safety(new_vdisk)
except Exception as ex:
logger.error('Clone disk on volumedriver level failed with exception: {0}'.format(str(ex)))
new_vdisk.delete()
raise
return {'diskguid': new_vdisk.guid, 'name': new_vdisk.name,
'backingdevice': disk_path}
def test_happypath(self):
"""
Validates the happy path; Hourly snapshots are taken with a few manual consistents
every now an then. The delelete policy is exectued every day
"""
# Setup
# There are 2 machines; one with two disks, one with one disk and an additional disk
vmachine_1 = VMachine()
vmachine_1.name = 'vmachine_1'
vmachine_1.save()
vdisk_1_1 = VDisk()
vdisk_1_1.name = 'vdisk_1_1'
vdisk_1_1.volume_id = 'vdisk_1_1'
vdisk_1_1.vmachine = vmachine_1
vdisk_1_1.save()
vdisk_1_2 = VDisk()
vdisk_1_2.name = 'vdisk_1_2'
vdisk_1_2.volume_id = 'vdisk_1_2'
vdisk_1_2.vmachine = vmachine_1
vdisk_1_2.save()
vmachine_2 = VMachine()
vmachine_2.name = 'vmachine_2'
vmachine_2.save()
vdisk_2_1 = VDisk()
vdisk_2_1.name = 'vdisk_2_1'
vdisk_2_1.volume_id = 'vdisk_2_1'
vdisk_2_1.vmachine = vmachine_2
vdisk_2_1.save()
vdisk_3 = VDisk()
vdisk_3.name = 'vdisk_3'
vdisk_3.volume_id = 'vdisk_3'
vdisk_3.save()
for disk in [vdisk_1_1, vdisk_1_2, vdisk_2_1, vdisk_3]:
[
dynamic for dynamic in disk._dynamics
if dynamic.name == 'snapshots'
][0].timeout = 0
# Run the testing scenario
debug = True
amount_of_days = 50
now = int(mktime(datetime.now().date().timetuple())) # Last night
minute = 60
hour = minute * 60
day = hour * 24
for d in xrange(0, amount_of_days):
base_timestamp = now + (day * d)
print ''
print 'Day cycle: {}: {}'.format(
d,
datetime.fromtimestamp(base_timestamp).strftime('%Y-%m-%d'))
# At the start of the day, delete snapshot policy runs at 00:30
print '- Deleting snapshots'
ScheduledTaskController.deletescrubsnapshots(
timestamp=base_timestamp + (minute * 30))
# Validate snapshots
print '- Validating snapshots'
for vdisk in [vdisk_3
]: # [vdisk_1_1, vdisk_1_2, vdisk_2_1, vdisk_3]:
self._validate(vdisk, d, now, amount_of_days, debug)
# During the day, snapshots are taken
# - Create non consistent snapshot every hour, between 2:00 and 22:00
# - Create consistent snapshot at 6:30, 12:30, 18:30
print '- Creating snapshots'
for h in xrange(2, 23):
timestamp = base_timestamp + (hour * h)
for vm in [vmachine_1, vmachine_2]:
VMachineController.snapshot(machineguid=vm.guid,
label='ss_i_{}:00'.format(
str(h)),
is_consistent=False,
timestamp=timestamp)
if h in [6, 12, 18]:
ts = (timestamp + (minute * 30))
VMachineController.snapshot(machineguid=vm.guid,
label='ss_c_{}:30'.format(
str(h)),
is_consistent=True,
timestamp=ts)
VDiskController.create_snapshot(diskguid=vdisk_3.guid,
metadata={
'label':
'ss_i_{}:00'.format(
str(h)),
'is_consistent':
False,
'timestamp':
timestamp,
'machineguid':
None
})
if h in [6, 12, 18]:
ts = (timestamp + (minute * 30))
VDiskController.create_snapshot(diskguid=vdisk_3.guid,
metadata={
'label':
'ss_c_{}:30'.format(
str(h)),
'is_consistent':
True,
'timestamp':
ts,
'machineguid':
None
})
for vdisk in vmachine_1.vdisks:
vdisk.delete()
vmachine_1.delete()
for vdisk in vmachine_2.vdisks:
vdisk.delete()
vmachine_2.delete()
vdisk_3.delete()
def clone(diskguid, snapshotid, devicename, pmachineguid, machinename=None, machineguid=None, detached=False):
"""
Clone a disk
"""
pmachine = PMachine(pmachineguid)
hypervisor = Factory.get(pmachine)
if machinename is None:
description = devicename
else:
description = '{0} {1}'.format(machinename, devicename)
properties_to_clone = ['description', 'size', 'type', 'retentionpolicyguid',
'snapshotpolicyguid', 'autobackup']
vdisk = VDisk(diskguid)
location = hypervisor.get_backing_disk_path(machinename, devicename)
if machineguid is not None and detached is True:
raise ValueError('A vMachine GUID was specified while detached is True')
if snapshotid is None:
# Create a new snapshot
timestamp = str(int(time.time()))
metadata = {'label': '',
'is_consistent': False,
'timestamp': timestamp,
'machineguid': machineguid,
'is_automatic': True}
VDiskController.create_snapshot(diskguid, metadata)
tries = 25 # About 5 minutes
while snapshotid is None and tries > 0:
tries -= 1
time.sleep(25 - tries)
vdisk.invalidate_dynamics(['snapshots'])
snapshots = [snapshot for snapshot in vdisk.snapshots
if snapshot['in_backend'] is True and snapshot['timestamp'] == timestamp]
if len(snapshots) == 1:
snapshotid = snapshots[0]['guid']
if snapshotid is None:
raise RuntimeError('Could not find created snapshot in time')
new_vdisk = VDisk()
new_vdisk.copy(vdisk, include=properties_to_clone)
new_vdisk.parent_vdisk = vdisk
new_vdisk.name = '{0}-clone'.format(vdisk.name)
new_vdisk.description = description
new_vdisk.devicename = hypervisor.clean_backing_disk_filename(location)
new_vdisk.parentsnapshot = snapshotid
if detached is False:
new_vdisk.vmachine = VMachine(machineguid) if machineguid else vdisk.vmachine
new_vdisk.vpool = vdisk.vpool
new_vdisk.save()
try:
storagedriver = StorageDriverList.get_by_storagedriver_id(vdisk.storagedriver_id)
if storagedriver is None:
raise RuntimeError('Could not find StorageDriver with id {0}'.format(vdisk.storagedriver_id))
mds_service = MDSServiceController.get_preferred_mds(storagedriver.storagerouter, vdisk.vpool)
if mds_service is None:
raise RuntimeError('Could not find a MDS service')
logger.info('Clone snapshot {0} of disk {1} to location {2}'.format(snapshotid, vdisk.name, location))
volume_id = vdisk.storagedriver_client.create_clone(
target_path=location,
metadata_backend_config=MDSMetaDataBackendConfig([MDSNodeConfig(address=str(mds_service.service.storagerouter.ip),
port=mds_service.service.ports[0])]),
parent_volume_id=str(vdisk.volume_id),
parent_snapshot_id=str(snapshotid),
node_id=str(vdisk.storagedriver_id)
)
except Exception as ex:
logger.error('Caught exception during clone, trying to delete the volume. {0}'.format(ex))
new_vdisk.delete()
VDiskController.delete_volume(location)
raise
new_vdisk.volume_id = volume_id
new_vdisk.save()
try:
MDSServiceController.ensure_safety(new_vdisk)
except Exception as ex:
logger.error('Caught exception during "ensure_safety" {0}'.format(ex))
return {'diskguid': new_vdisk.guid,
'name': new_vdisk.name,
'backingdevice': location}
def create_from_template(diskguid,
machinename,
devicename,
pmachineguid,
machineguid=None,
storagedriver_guid=None):
"""
Create a disk from a template
@param parentdiskguid: guid of the disk
@param location: location where virtual device should be created (eg: myVM)
@param devicename: device file name for the disk (eg: mydisk-flat.vmdk)
@param machineguid: guid of the machine to assign disk to
@return diskguid: guid of new disk
"""
pmachine = PMachine(pmachineguid)
hypervisor = Factory.get(pmachine)
disk_path = hypervisor.get_disk_path(machinename, devicename)
description = '{} {}'.format(machinename, devicename)
properties_to_clone = [
'description', 'size', 'type', 'retentionpolicyid',
'snapshotpolicyid', 'vmachine', 'vpool'
]
disk = VDisk(diskguid)
if disk.vmachine and not disk.vmachine.is_vtemplate:
# Disk might not be attached to a vmachine, but still be a template
raise RuntimeError('The given disk does not belong to a template')
if storagedriver_guid is not None:
storagedriver_id = StorageDriver(
storagedriver_guid).storagedriver_id
else:
storagedriver_id = disk.storagedriver_id
new_disk = VDisk()
new_disk.copy(disk, include=properties_to_clone)
new_disk.vpool = disk.vpool
new_disk.devicename = hypervisor.clean_backing_disk_filename(disk_path)
new_disk.parent_vdisk = disk
new_disk.name = '{}-clone'.format(disk.name)
new_disk.description = description
new_disk.vmachine = VMachine(
machineguid) if machineguid else disk.vmachine
new_disk.save()
logger.info(
'Create disk from template {} to new disk {} to location {}'.
format(disk.name, new_disk.name, disk_path))
try:
volume_id = disk.storagedriver_client.create_clone_from_template(
disk_path, str(disk.volume_id), node_id=str(storagedriver_id))
new_disk.volume_id = volume_id
new_disk.save()
except Exception as ex:
logger.error(
'Clone disk on volumedriver level failed with exception: {0}'.
format(str(ex)))
new_disk.delete()
raise
return {
'diskguid': new_disk.guid,
'name': new_disk.name,
'backingdevice': disk_path
}
def create_from_template(
diskguid, machinename, devicename, pmachineguid, machineguid=None, storagedriver_guid=None
):
"""
Create a disk from a template
@param parentdiskguid: guid of the disk
@param location: location where virtual device should be created (eg: myVM)
@param devicename: device file name for the disk (eg: mydisk-flat.vmdk)
@param machineguid: guid of the machine to assign disk to
@return diskguid: guid of new disk
"""
pmachine = PMachine(pmachineguid)
hypervisor = Factory.get(pmachine)
disk_path = hypervisor.get_disk_path(machinename, devicename)
description = "{} {}".format(machinename, devicename)
properties_to_clone = [
"description",
"size",
"type",
"retentionpolicyid",
"snapshotpolicyid",
"vmachine",
"vpool",
]
vdisk = VDisk(diskguid)
if vdisk.vmachine and not vdisk.vmachine.is_vtemplate:
# Disk might not be attached to a vmachine, but still be a template
raise RuntimeError("The given vdisk does not belong to a template")
if storagedriver_guid is not None:
storagedriver_id = StorageDriver(storagedriver_guid).storagedriver_id
else:
storagedriver_id = vdisk.storagedriver_id
storagedriver = StorageDriverList.get_by_storagedriver_id(storagedriver_id)
if storagedriver is None:
raise RuntimeError("Could not find StorageDriver with id {0}".format(storagedriver_id))
new_vdisk = VDisk()
new_vdisk.copy(vdisk, include=properties_to_clone)
new_vdisk.vpool = vdisk.vpool
new_vdisk.devicename = hypervisor.clean_backing_disk_filename(disk_path)
new_vdisk.parent_vdisk = vdisk
new_vdisk.name = "{}-clone".format(vdisk.name)
new_vdisk.description = description
new_vdisk.vmachine = VMachine(machineguid) if machineguid else vdisk.vmachine
new_vdisk.save()
mds_service = MDSServiceController.get_preferred_mds(storagedriver.storagerouter, vdisk.vpool)
if mds_service is None:
raise RuntimeError("Could not find a MDS service")
logger.info(
"Create disk from template {} to new disk {} to location {}".format(vdisk.name, new_vdisk.name, disk_path)
)
try:
volume_id = vdisk.storagedriver_client.create_clone_from_template(
target_path=disk_path,
metadata_backend_config=MDSMetaDataBackendConfig(
[
MDSNodeConfig(
address=str(mds_service.service.storagerouter.ip), port=mds_service.service.ports[0]
)
]
),
parent_volume_id=str(vdisk.volume_id),
node_id=str(storagedriver_id),
)
new_vdisk.volume_id = volume_id
new_vdisk.save()
MDSServiceController.ensure_safety(new_vdisk)
except Exception as ex:
logger.error("Clone disk on volumedriver level failed with exception: {0}".format(str(ex)))
new_vdisk.delete()
raise
# Allow "regular" users to use this volume
# Do not use run for other user than ovs as it blocks asking for root password
# Do not use run_local for other user as it doesn't have permission
# So this method only works if this is called by root or ovs
storagerouter = StorageRouter(new_vdisk.storagerouter_guid)
mountpoint = storagedriver.mountpoint
location = "{0}{1}".format(mountpoint, disk_path)
client = SSHClient.load(storagerouter.pmachine.ip)
print(client.run('chmod 664 "{0}"'.format(location)))
print(client.run('chown ovs:ovs "{0}"'.format(location)))
return {"diskguid": new_vdisk.guid, "name": new_vdisk.name, "backingdevice": disk_path}
def create_from_template(diskguid,
machinename,
devicename,
pmachineguid,
machineguid=None,
storagedriver_guid=None):
"""
Create a disk from a template
@param devicename: device file name for the disk (eg: mydisk-flat.vmdk)
@param machineguid: guid of the machine to assign disk to
@return diskguid: guid of new disk
"""
pmachine = PMachine(pmachineguid)
hypervisor = Factory.get(pmachine)
disk_path = hypervisor.get_disk_path(machinename, devicename)
description = '{} {}'.format(machinename, devicename)
properties_to_clone = [
'description', 'size', 'type', 'retentionpolicyid',
'snapshotpolicyid', 'vmachine', 'vpool'
]
vdisk = VDisk(diskguid)
if vdisk.vmachine and not vdisk.vmachine.is_vtemplate:
# Disk might not be attached to a vmachine, but still be a template
raise RuntimeError('The given vdisk does not belong to a template')
if storagedriver_guid is not None:
storagedriver_id = StorageDriver(
storagedriver_guid).storagedriver_id
else:
storagedriver_id = vdisk.storagedriver_id
storagedriver = StorageDriverList.get_by_storagedriver_id(
storagedriver_id)
if storagedriver is None:
raise RuntimeError(
'Could not find StorageDriver with id {0}'.format(
storagedriver_id))
new_vdisk = VDisk()
new_vdisk.copy(vdisk, include=properties_to_clone)
new_vdisk.vpool = vdisk.vpool
new_vdisk.devicename = hypervisor.clean_backing_disk_filename(
disk_path)
new_vdisk.parent_vdisk = vdisk
new_vdisk.name = '{}-clone'.format(vdisk.name)
new_vdisk.description = description
new_vdisk.vmachine = VMachine(
machineguid) if machineguid else vdisk.vmachine
new_vdisk.save()
mds_service = MDSServiceController.get_preferred_mds(
storagedriver.storagerouter, vdisk.vpool)
if mds_service is None:
raise RuntimeError('Could not find a MDS service')
logger.info(
'Create disk from template {} to new disk {} to location {}'.
format(vdisk.name, new_vdisk.name, disk_path))
try:
volume_id = vdisk.storagedriver_client.create_clone_from_template(
target_path=disk_path,
metadata_backend_config=MDSMetaDataBackendConfig([
MDSNodeConfig(address=str(
mds_service.service.storagerouter.ip),
port=mds_service.service.ports[0])
]),
parent_volume_id=str(vdisk.volume_id),
node_id=str(storagedriver_id))
new_vdisk.volume_id = volume_id
new_vdisk.save()
MDSServiceController.ensure_safety(new_vdisk)
except Exception as ex:
logger.error(
'Clone disk on volumedriver level failed with exception: {0}'.
format(str(ex)))
new_vdisk.delete()
raise
return {
'diskguid': new_vdisk.guid,
'name': new_vdisk.name,
'backingdevice': disk_path
}
def clone(diskguid,
snapshotid,
devicename,
pmachineguid,
machinename,
machineguid=None):
"""
Clone a disk
"""
pmachine = PMachine(pmachineguid)
hypervisor = Factory.get(pmachine)
description = '{} {}'.format(machinename, devicename)
properties_to_clone = [
'description', 'size', 'type', 'retentionpolicyguid',
'snapshotpolicyguid', 'autobackup'
]
vdisk = VDisk(diskguid)
location = hypervisor.get_backing_disk_path(machinename, devicename)
new_vdisk = VDisk()
new_vdisk.copy(vdisk, include=properties_to_clone)
new_vdisk.parent_vdisk = vdisk
new_vdisk.name = '{0}-clone'.format(vdisk.name)
new_vdisk.description = description
new_vdisk.devicename = hypervisor.clean_backing_disk_filename(location)
new_vdisk.parentsnapshot = snapshotid
new_vdisk.vmachine = VMachine(
machineguid) if machineguid else vdisk.vmachine
new_vdisk.vpool = vdisk.vpool
new_vdisk.save()
try:
storagedriver = StorageDriverList.get_by_storagedriver_id(
vdisk.storagedriver_id)
if storagedriver is None:
raise RuntimeError(
'Could not find StorageDriver with id {0}'.format(
vdisk.storagedriver_id))
mds_service = MDSServiceController.get_preferred_mds(
storagedriver.storagerouter, vdisk.vpool)
if mds_service is None:
raise RuntimeError('Could not find a MDS service')
logger.info('Clone snapshot {} of disk {} to location {}'.format(
snapshotid, vdisk.name, location))
volume_id = vdisk.storagedriver_client.create_clone(
target_path=location,
metadata_backend_config=MDSMetaDataBackendConfig([
MDSNodeConfig(address=str(
mds_service.service.storagerouter.ip),
port=mds_service.service.ports[0])
]),
parent_volume_id=str(vdisk.volume_id),
parent_snapshot_id=str(snapshotid),
node_id=str(vdisk.storagedriver_id))
except Exception as ex:
logger.error(
'Caught exception during clone, trying to delete the volume. {0}'
.format(ex))
new_vdisk.delete()
VDiskController.delete_volume(location)
raise
new_vdisk.volume_id = volume_id
new_vdisk.save()
try:
MDSServiceController.ensure_safety(new_vdisk)
except Exception as ex:
logger.error(
'Caught exception during "ensure_safety" {0}'.format(ex))
return {
'diskguid': new_vdisk.guid,
'name': new_vdisk.name,
'backingdevice': location
}
