def format(cls, sdUUID):
"""Format detached storage domain.
This removes all data from the storage domain.
"""
# Remove the directory tree
try:
domaindir = cls.findDomainPath(sdUUID)
except (se.StorageDomainDoesNotExist):
pass
else:
fileUtils.cleanupdir(domaindir, ignoreErrors=True)
# Remove special metadata and service volumes
# Remove all volumes LV if exists
_removeVMSfs(lvm.lvPath(sdUUID, MASTERLV))
try:
lvs = lvm.getLV(sdUUID)
except se.LogicalVolumeDoesNotExistError:
lvs = () # No LVs in this VG (domain)
for lv in lvs:
# Fix me: Should raise and get resource lock.
try:
lvm.removeLVs(sdUUID, lv.name)
except se.CannotRemoveLogicalVolume as e:
cls.log.warning("Remove logical volume failed %s/%s %s",
sdUUID, lv.name, str(e))
lvm.removeVG(sdUUID)
return True
def format(cls, sdUUID):
"""Format detached storage domain.
This removes all data from the storage domain.
"""
# Remove the directory tree
try:
domaindir = cls.findDomainPath(sdUUID)
except (se.StorageDomainDoesNotExist):
pass
else:
fileUtils.cleanupdir(domaindir, ignoreErrors=True)
# Remove special metadata and service volumes
# Remove all volumes LV if exists
_removeVMSfs(lvm.lvPath(sdUUID, MASTERLV))
try:
lvs = lvm.getLV(sdUUID)
except se.LogicalVolumeDoesNotExistError:
lvs = () # No LVs in this VG (domain)
for lv in lvs:
# Fix me: Should raise and get resource lock.
try:
lvm.removeLVs(sdUUID, lv.name)
except se.CannotRemoveLogicalVolume as e:
cls.log.warning("Remove logical volume failed %s/%s %s",
sdUUID, lv.name, str(e))
lvm.removeVG(sdUUID)
return True
def halfbakedVolumeRollback(cls, taskObj, sdUUID, volUUID, volPath):
cls.log.info("sdUUID=%s volUUID=%s volPath=%s" % (sdUUID, volUUID, volPath))
try:
#Fix me: assert resource lock.
lvm.getLV(sdUUID, volUUID)
lvm.removeLVs(sdUUID, volUUID)
except se.LogicalVolumeDoesNotExistError, e:
pass #It's OK: inexistent LV, don't try to remove.
def halfbakedVolumeRollback(cls, taskObj, sdUUID, volUUID, volPath):
cls.log.info("sdUUID=%s volUUID=%s volPath=%s" %
(sdUUID, volUUID, volPath))
try:
#Fix me: assert resource lock.
lvm.getLV(sdUUID, volUUID)
lvm.removeLVs(sdUUID, volUUID)
except se.LogicalVolumeDoesNotExistError, e:
pass #It's OK: inexistent LV, don't try to remove.
def halfbakedVolumeRollback(cls, taskObj, sdUUID, volUUID, volPath):
cls.log.info("sdUUID=%s volUUID=%s volPath=%s" %
(sdUUID, volUUID, volPath))
try:
# Fix me: assert resource lock.
lvm.getLV(sdUUID, volUUID)
lvm.removeLVs(sdUUID, volUUID)
except se.LogicalVolumeDoesNotExistError:
pass # It's OK: inexistent LV, don't try to remove.
except se.CannotRemoveLogicalVolume as e:
cls.log.warning("Remove logical volume failed %s/%s %s", sdUUID,
volUUID, str(e))
if os.path.lexists(volPath):
os.unlink(volPath)
def halfbakedVolumeRollback(cls, taskObj, sdUUID, volUUID, volPath):
cls.log.info("sdUUID=%s volUUID=%s volPath=%s" %
(sdUUID, volUUID, volPath))
try:
# Fix me: assert resource lock.
tags = lvm.getLV(sdUUID, volUUID).tags
except se.LogicalVolumeDoesNotExistError:
pass # It's OK: inexistent LV, don't try to remove.
else:
if TAG_VOL_UNINIT in tags:
try:
lvm.removeLVs(sdUUID, volUUID)
except se.CannotRemoveLogicalVolume as e:
cls.log.warning("Remove logical volume failed %s/%s %s",
sdUUID, volUUID, str(e))
if os.path.lexists(volPath):
cls.log.debug("Unlinking half baked volume: %s", volPath)
os.unlink(volPath)
def deleteVolumes(sdUUID, vols):
lvm.removeLVs(sdUUID, vols)
def delete(self, postZero, force):
""" Delete volume
'postZero' - zeroing file before deletion
'force' is required to remove shared and internal volumes
"""
self.log.info("Request to delete LV %s of image %s in VG %s ",
self.volUUID, self.imgUUID, self.sdUUID)
vol_path = self.getVolumePath()
size = self.getVolumeSize(bs=1)
offs = self.getMetaOffset()
# On block storage domains we store a volume's parent UUID in two
# places: 1) in the domain's metadata LV, and 2) in a LV tag attached
# to the volume LV itself. The LV tag is more efficient to access
# than the domain metadata but it may only be updated by the SPM.
#
# This means that after a live merge completes the domain metadata LV
# will be updated but the LV tag will not. We can detect this case
# here and fix the LV tag since this is an SPM verb.
#
# File domains do not have this complexity because the metadata is
# stored in only one place and that metadata is updated by the HSM
# host when the live merge finishes.
sync = False
for childID in self.getChildren():
child = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID,
childID)
metaParent = child.getParentMeta()
tagParent = child.getParentTag()
if metaParent != tagParent:
self.log.debug(
"Updating stale PUUID LV tag from %s to %s for "
"volume %s", tagParent, metaParent, child.volUUID)
child.setParentTag(metaParent)
sync = True
if sync:
self.recheckIfLeaf()
if not force:
self.validateDelete()
# Mark volume as illegal before deleting
self.setLegality(volume.ILLEGAL_VOL)
if postZero:
self.prepare(justme=True,
rw=True,
chainrw=force,
setrw=True,
force=True)
try:
misc.ddWatchCopy("/dev/zero", vol_path, vars.task.aborting,
int(size))
except utils.ActionStopped:
raise
except Exception:
self.log.error("Unexpected error", exc_info=True)
raise se.VolumesZeroingError(vol_path)
finally:
self.teardown(self.sdUUID, self.volUUID, justme=True)
# try to cleanup as much as possible
eFound = se.CannotDeleteVolume(self.volUUID)
puuid = None
try:
# We need to blank parent record in our metadata
# for parent to become leaf successfully.
puuid = self.getParent()
self.setParent(volume.BLANK_UUID)
if puuid and puuid != volume.BLANK_UUID:
pvol = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID,
puuid)
pvol.recheckIfLeaf()
except Exception as e:
eFound = e
self.log.warning("cannot finalize parent volume %s",
puuid,
exc_info=True)
try:
try:
lvm.removeLVs(self.sdUUID, self.volUUID)
except se.CannotRemoveLogicalVolume:
# At this point LV is already marked as illegal, we will
# try to cleanup whatever we can...
pass
self.removeMetadata([self.sdUUID, offs])
except Exception as e:
eFound = e
self.log.error("cannot remove volume %s/%s",
self.sdUUID,
self.volUUID,
exc_info=True)
try:
self.log.debug("Unlinking %s", vol_path)
os.unlink(vol_path)
return True
except Exception as e:
eFound = e
self.log.error("cannot delete volume's %s/%s link path: %s",
self.sdUUID,
self.volUUID,
vol_path,
exc_info=True)
raise eFound
def deleteMultipleVolumes(sdUUID, volumes, postZero):
"Delete multiple volumes (LVs) in the same domain (VG)."""
if postZero:
_postZero(sdUUID, volumes)
lvNames = [vol.volUUID for vol in volumes]
lvm.removeLVs(sdUUID, lvNames)
puuid = None
try:
# We need to blank parent record in our metadata
# for parent to become leaf successfully.
puuid = self.getParent()
self.setParent(volume.BLANK_UUID)
if puuid and puuid != volume.BLANK_UUID:
pvol = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID, puuid)
pvol.recheckIfLeaf()
except Exception, e:
eFound = e
self.log.warning("cannot finalize parent volume %s", puuid, exc_info=True)
try:
try:
lvm.removeLVs(self.sdUUID, self.volUUID)
except se.CannotRemoveLogicalVolume:
# At this point LV is already marked as illegal, we will try to cleanup whatever we can...
pass
self.removeMetadata([self.sdUUID, offs])
except Exception, e:
eFound = e
self.log.error("cannot remove volume %s/%s", self.sdUUID, self.volUUID, exc_info=True)
try:
os.unlink(vol_path)
return True
except Exception, e:
eFound = e
self.log.error("cannot delete volume's %s/%s link path: %s", self.sdUUID, self.volUUID,
def deleteVolumes(sdUUID, vols):
lvm.removeLVs(sdUUID, vols)
def delete(self, postZero, force):
""" Delete volume
'postZero' - zeroing file before deletion
'force' is required to remove shared and internal volumes
"""
self.log.info("Request to delete LV %s of image %s in VG %s ",
self.volUUID, self.imgUUID, self.sdUUID)
vol_path = self.getVolumePath()
size = self.getVolumeSize(bs=1)
offs = self.getMetaOffset()
if not force:
self.validateDelete()
# Mark volume as illegal before deleting
self.setLegality(volume.ILLEGAL_VOL)
if postZero:
self.prepare(justme=True,
rw=True,
chainrw=force,
setrw=True,
force=True)
try:
misc.ddWatchCopy("/dev/zero", vol_path, vars.task.aborting,
int(size))
except utils.ActionStopped:
raise
except Exception:
self.log.error("Unexpected error", exc_info=True)
raise se.VolumesZeroingError(vol_path)
finally:
self.teardown(self.sdUUID, self.volUUID, justme=True)
# try to cleanup as much as possible
eFound = se.CannotDeleteVolume(self.volUUID)
puuid = None
try:
# We need to blank parent record in our metadata
# for parent to become leaf successfully.
puuid = self.getParent()
self.setParent(volume.BLANK_UUID)
if puuid and puuid != volume.BLANK_UUID:
pvol = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID,
puuid)
pvol.recheckIfLeaf()
except Exception as e:
eFound = e
self.log.warning("cannot finalize parent volume %s",
puuid,
exc_info=True)
try:
try:
lvm.removeLVs(self.sdUUID, self.volUUID)
except se.CannotRemoveLogicalVolume:
# At this point LV is already marked as illegal, we will
# try to cleanup whatever we can...
pass
self.removeMetadata([self.sdUUID, offs])
except Exception as e:
eFound = e
self.log.error("cannot remove volume %s/%s",
self.sdUUID,
self.volUUID,
exc_info=True)
try:
self.log.debug("Unlinking %s", vol_path)
os.unlink(vol_path)
return True
except Exception as e:
eFound = e
self.log.error("cannot delete volume's %s/%s link path: %s",
self.sdUUID,
self.volUUID,
vol_path,
exc_info=True)
raise eFound
def delete(self, postZero, force):
""" Delete volume
'postZero' - zeroing file before deletion
'force' is required to remove shared and internal volumes
"""
self.log.info("Request to delete LV %s of image %s in VG %s ",
self.volUUID, self.imgUUID, self.sdUUID)
vol_path = self.getVolumePath()
size = self.getVolumeSize(bs=1)
offs = self.getMetaOffset()
# On block storage domains we store a volume's parent UUID in two
# places: 1) in the domain's metadata LV, and 2) in a LV tag attached
# to the volume LV itself. The LV tag is more efficient to access
# than the domain metadata but it may only be updated by the SPM.
#
# This means that after a live merge completes the domain metadata LV
# will be updated but the LV tag will not. We can detect this case
# here and fix the LV tag since this is an SPM verb.
#
# File domains do not have this complexity because the metadata is
# stored in only one place and that metadata is updated by the HSM
# host when the live merge finishes.
sync = False
for childID in self.getChildren():
child = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID,
childID)
metaParent = child.getParentMeta()
tagParent = child.getParentTag()
if metaParent != tagParent:
self.log.debug("Updating stale PUUID LV tag from %s to %s for "
"volume %s", tagParent, metaParent,
child.volUUID)
child.setParentTag(metaParent)
sync = True
if sync:
self.recheckIfLeaf()
if not force:
self.validateDelete()
# Mark volume as illegal before deleting
self.setLegality(sc.ILLEGAL_VOL)
discard = config.getboolean('irs', 'discard_enable')
if postZero or discard:
self.prepare(justme=True, rw=True, chainrw=force, setrw=True,
force=True)
try:
if postZero:
try:
misc.ddWatchCopy("/dev/zero", vol_path,
vars.task.aborting, int(size))
except exception.ActionStopped:
raise
except Exception:
self.log.error("Unexpected error", exc_info=True)
raise se.VolumesZeroingError(vol_path)
if discard:
try:
blkdiscard.blkdiscard(vol_path)
except cmdutils.Error as e:
log.warning('Discarding %s failed: %s', vol_path, e)
finally:
self.teardown(self.sdUUID, self.volUUID, justme=True)
# try to cleanup as much as possible
eFound = se.CannotDeleteVolume(self.volUUID)
puuid = None
try:
# We need to blank parent record in our metadata
# for parent to become leaf successfully.
puuid = self.getParent()
self.setParent(sc.BLANK_UUID)
if puuid and puuid != sc.BLANK_UUID:
pvol = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID,
puuid)
pvol.recheckIfLeaf()
except Exception as e:
eFound = e
self.log.warning("cannot finalize parent volume %s", puuid,
exc_info=True)
try:
try:
lvm.removeLVs(self.sdUUID, self.volUUID)
except se.CannotRemoveLogicalVolume:
# At this point LV is already marked as illegal, we will
# try to cleanup whatever we can...
pass
self.removeMetadata([self.sdUUID, offs])
except Exception as e:
eFound = e
self.log.error("cannot remove volume %s/%s", self.sdUUID,
self.volUUID, exc_info=True)
try:
self.log.debug("Unlinking %s", vol_path)
os.unlink(vol_path)
return True
except Exception as e:
eFound = e
self.log.error("cannot delete volume's %s/%s link path: %s",
self.sdUUID, self.volUUID, vol_path, exc_info=True)
raise eFound
def delete(self, postZero, force):
""" Delete volume
'postZero' - zeroing file before deletion
'force' is required to remove shared and internal volumes
"""
self.log.info("Request to delete LV %s of image %s in VG %s ",
self.volUUID, self.imgUUID, self.sdUUID)
vol_path = self.getVolumePath()
size = self.getVolumeSize(bs=1)
offs = self.getMetaOffset()
if not force:
self.validateDelete()
# Mark volume as illegal before deleting
self.setLegality(volume.ILLEGAL_VOL)
if postZero:
self.prepare(justme=True, rw=True, chainrw=force, setrw=True,
force=True)
try:
misc.ddWatchCopy(
"/dev/zero", vol_path, vars.task.aborting, int(size))
except utils.ActionStopped:
raise
except Exception:
self.log.error("Unexpected error", exc_info=True)
raise se.VolumesZeroingError(vol_path)
finally:
self.teardown(self.sdUUID, self.volUUID, justme=True)
# try to cleanup as much as possible
eFound = se.CannotDeleteVolume(self.volUUID)
puuid = None
try:
# We need to blank parent record in our metadata
# for parent to become leaf successfully.
puuid = self.getParent()
self.setParent(volume.BLANK_UUID)
if puuid and puuid != volume.BLANK_UUID:
pvol = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID,
puuid)
pvol.recheckIfLeaf()
except Exception as e:
eFound = e
self.log.warning("cannot finalize parent volume %s", puuid,
exc_info=True)
try:
try:
lvm.removeLVs(self.sdUUID, self.volUUID)
except se.CannotRemoveLogicalVolume:
# At this point LV is already marked as illegal, we will
# try to cleanup whatever we can...
pass
self.removeMetadata([self.sdUUID, offs])
except Exception as e:
eFound = e
self.log.error("cannot remove volume %s/%s", self.sdUUID,
self.volUUID, exc_info=True)
try:
self.log.debug("Unlinking %s", vol_path)
os.unlink(vol_path)
return True
except Exception as e:
eFound = e
self.log.error("cannot delete volume's %s/%s link path: %s",
self.sdUUID, self.volUUID, vol_path, exc_info=True)
raise eFound
def deleteMultipleVolumes(sdUUID, volumes, postZero):
"Delete multiple volumes (LVs) in the same domain (VG)." ""
if postZero:
_postZero(sdUUID, volumes)
lvNames = [vol.volUUID for vol in volumes]
lvm.removeLVs(sdUUID, lvNames)
# for parent to become leaf successfully.
puuid = self.getParent()
self.setParent(volume.BLANK_UUID)
if puuid and puuid != volume.BLANK_UUID:
pvol = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID,
puuid)
pvol.recheckIfLeaf()
except Exception, e:
eFound = e
self.log.warning("cannot finalize parent volume %s",
puuid,
exc_info=True)
try:
try:
lvm.removeLVs(self.sdUUID, self.volUUID)
except se.CannotRemoveLogicalVolume:
# At this point LV is already marked as illegal, we will try to cleanup whatever we can...
pass
self.removeMetadata([self.sdUUID, offs])
except Exception, e:
eFound = e
self.log.error("cannot remove volume %s/%s",
self.sdUUID,
self.volUUID,
exc_info=True)
try:
os.unlink(vol_path)
return True
