def copyCollapsed(self, sdUUID, vmUUID, srcImgUUID, srcVolUUID, dstImgUUID,
dstVolUUID, descr, dstSdUUID, volType, volFormat,
preallocate, postZero, force, discard):
"""
Create new template/volume from VM.
Do it by collapse and copy the whole chain (baseVolUUID->srcVolUUID)
"""
self.log.info(
"sdUUID=%s vmUUID=%s srcImgUUID=%s srcVolUUID=%s "
"dstImgUUID=%s dstVolUUID=%s dstSdUUID=%s volType=%s "
"volFormat=%s preallocate=%s force=%s postZero=%s "
"discard=%s", sdUUID, vmUUID, srcImgUUID, srcVolUUID, dstImgUUID,
dstVolUUID, dstSdUUID, volType, sc.type2name(volFormat),
sc.type2name(preallocate), str(force), str(postZero), discard)
try:
srcVol = dstVol = None
# Find out dest sdUUID
if dstSdUUID == sd.BLANK_UUID:
dstSdUUID = sdUUID
volclass = sdCache.produce(sdUUID).getVolumeClass()
destDom = sdCache.produce(dstSdUUID)
# find src volume
try:
srcVol = volclass(self.repoPath, sdUUID, srcImgUUID,
srcVolUUID)
except se.StorageException:
raise
except Exception as e:
self.log.error(e, exc_info=True)
raise se.SourceImageActionError(srcImgUUID, sdUUID, str(e))
# Create dst volume
try:
# Before reading source volume parameters from volume metadata,
# prepare the volume. This ensure that the volume capacity will
# match the actual virtual size, see
# https://bugzilla.redhat.com/1700623.
srcVol.prepare(rw=False)
volParams = srcVol.getVolumeParams()
if volFormat in [sc.COW_FORMAT, sc.RAW_FORMAT]:
dstVolFormat = volFormat
else:
dstVolFormat = volParams['volFormat']
# TODO: This is needed only when copying to qcow2-thin volume
# on block storage. Move into calculate_initial_size.
dst_vol_allocation = self.calculate_vol_alloc(
sdUUID, volParams, dstSdUUID, dstVolFormat)
# Find out dest volume parameters
if preallocate in [sc.PREALLOCATED_VOL, sc.SPARSE_VOL]:
volParams['prealloc'] = preallocate
initial_size = self.calculate_initial_size(
destDom.supportsSparseness, dstVolFormat,
volParams['prealloc'], dst_vol_allocation)
self.log.info(
"Copy source %s:%s:%s to destination %s:%s:%s "
"capacity=%s, initial size=%s", sdUUID, srcImgUUID,
srcVolUUID, dstSdUUID, dstImgUUID, dstVolUUID,
volParams['capacity'], initial_size)
# If image already exists check whether it illegal/fake,
# overwrite it
if not self.isLegal(dstSdUUID, dstImgUUID):
force = True
# We must first remove the previous instance of image (if
# exists) in destination domain, if we got the overwrite
# command
if force:
self.log.info(
"delete image %s on domain %s before "
"overwriting", dstImgUUID, dstSdUUID)
_deleteImage(destDom, dstImgUUID, postZero, discard)
destDom.createVolume(imgUUID=dstImgUUID,
capacity=volParams['capacity'],
volFormat=dstVolFormat,
preallocate=volParams['prealloc'],
diskType=volParams['disktype'],
volUUID=dstVolUUID,
desc=descr,
srcImgUUID=sc.BLANK_UUID,
srcVolUUID=sc.BLANK_UUID,
initial_size=initial_size)
dstVol = sdCache.produce(dstSdUUID).produceVolume(
imgUUID=dstImgUUID, volUUID=dstVolUUID)
except se.StorageException:
self.log.error("Unexpected error", exc_info=True)
raise
except Exception as e:
self.log.error("Unexpected error", exc_info=True)
raise se.CopyImageError("Destination volume %s error: %s" %
(dstVolUUID, str(e)))
try:
# Start the actual copy image procedure
dstVol.prepare(rw=True, setrw=True)
if (destDom.supportsSparseness
and dstVol.getType() == sc.PREALLOCATED_VOL):
preallocation = qemuimg.PREALLOCATION.FALLOC
else:
preallocation = None
try:
operation = qemuimg.convert(
volParams['path'],
dstVol.getVolumePath(),
srcFormat=sc.fmt2str(volParams['volFormat']),
dstFormat=sc.fmt2str(dstVolFormat),
dstQcow2Compat=destDom.qcow2_compat(),
preallocation=preallocation,
unordered_writes=destDom.recommends_unordered_writes(
dstVolFormat),
create=not destDom.is_block(),
)
with utils.stopwatch("Copy volume %s" % srcVol.volUUID):
self._run_qemuimg_operation(operation)
except ActionStopped:
raise
except cmdutils.Error as e:
self.log.exception('conversion failure for volume %s',
srcVol.volUUID)
raise se.CopyImageError(str(e))
# Mark volume as SHARED
if volType == sc.SHARED_VOL:
dstVol.setShared()
dstVol.setLegality(sc.LEGAL_VOL)
if force:
# Now we should re-link all deleted hardlinks, if exists
destDom.templateRelink(dstImgUUID, dstVolUUID)
except se.StorageException:
self.log.error("Unexpected error", exc_info=True)
raise
except Exception as e:
self.log.error("Unexpected error", exc_info=True)
raise se.CopyImageError("src image=%s, dst image=%s: msg=%s" %
(srcImgUUID, dstImgUUID, str(e)))
self.log.info("Finished copying %s:%s -> %s:%s", sdUUID,
srcVolUUID, dstSdUUID, dstVolUUID)
# TODO: handle return status
return dstVolUUID
finally:
self.__cleanupCopy(srcVol=srcVol, dstVol=dstVol)
def _createTargetImage(self, destDom, srcSdUUID, imgUUID):
# Before actual data copying we need perform several operation
# such as: create all volumes, create fake template if needed, ...
try:
# Find all volumes of source image
srcChain = self.getChain(srcSdUUID, imgUUID)
log_str = logutils.volume_chain_to_str(vol.volUUID
for vol in srcChain)
self.log.info("Source chain=%s ", log_str)
except se.StorageException:
self.log.error("Unexpected error", exc_info=True)
raise
except Exception as e:
self.log.error("Unexpected error", exc_info=True)
raise se.SourceImageActionError(imgUUID, srcSdUUID, str(e))
fakeTemplate = False
pimg = sc.BLANK_UUID # standalone chain
# check if the chain is build above a template, or it is a standalone
pvol = srcChain[0].getParentVolume()
if pvol:
# find out parent volume parameters
volParams = pvol.getVolumeParams()
pimg = volParams['imgUUID'] # pimg == template image
if destDom.isBackup():
# FIXME: This workaround help as copy VM to the backup domain
# without its template. We will create fake template
# for future VM creation and mark it as FAKE volume.
# This situation is relevant for backup domain only.
fakeTemplate = True
@contextmanager
def justLogIt(img):
self.log.debug("You don't really need lock parent of image %s",
img)
yield
dstImageResourcesNamespace = rm.getNamespace(sc.IMAGE_NAMESPACE,
destDom.sdUUID)
# In destination domain we need to lock image's template if exists
with rm.acquireResource(dstImageResourcesNamespace, pimg, rm.SHARED) \
if pimg != sc.BLANK_UUID else justLogIt(imgUUID):
if fakeTemplate:
self.createFakeTemplate(destDom.sdUUID, volParams)
dstChain = []
for srcVol in srcChain:
# Create the dst volume
try:
# find out src volume parameters
volParams = srcVol.getVolumeParams()
# To avoid prezeroing preallocated volumes on NFS domains
# we create the target as a sparse volume (since it will be
# soon filled with the data coming from the copy) and then
# we change its metadata back to the original value.
if (destDom.supportsSparseness
or volParams['volFormat'] != sc.RAW_FORMAT):
tmpVolPreallocation = sc.SPARSE_VOL
else:
tmpVolPreallocation = sc.PREALLOCATED_VOL
destDom.createVolume(imgUUID=imgUUID,
capacity=volParams['capacity'],
volFormat=volParams['volFormat'],
preallocate=tmpVolPreallocation,
diskType=volParams['disktype'],
volUUID=srcVol.volUUID,
desc=volParams['descr'],
srcImgUUID=pimg,
srcVolUUID=volParams['parent'])
dstVol = destDom.produceVolume(imgUUID=imgUUID,
volUUID=srcVol.volUUID)
# Extend volume (for LV only) size to the actual size
dstVol.extend(volParams['apparentsize'])
# Change destination volume metadata to preallocated in
# case we've used a sparse volume to accelerate the
# volume creation
if volParams['prealloc'] == sc.PREALLOCATED_VOL \
and tmpVolPreallocation != sc.PREALLOCATED_VOL:
dstVol.setType(sc.PREALLOCATED_VOL)
dstChain.append(dstVol)
except se.StorageException:
self.log.error("Unexpected error", exc_info=True)
raise
except Exception as e:
self.log.error("Unexpected error", exc_info=True)
raise se.DestImageActionError(imgUUID, destDom.sdUUID,
str(e))
# only base may have a different parent image
pimg = imgUUID
return {'srcChain': srcChain, 'dstChain': dstChain}