def delete_volume(self, volume):
ldev = self.get_ldev(volume)
if ldev is None:
LOG.warning(
basic_lib.set_msg(304, method='delete_volume',
id=volume['id']))
return
self.add_volinfo(ldev, volume['id'])
if not self.volume_info[ldev]['in_use'].lock.acquire(False):
desc = self.volume_info[ldev]['in_use'].desc
basic_lib.output_err(660, desc=desc)
raise exception.VolumeIsBusy(volume_name=volume['name'])
try:
is_vvol = self.get_volume_is_vvol(volume)
try:
self.delete_ldev(ldev, is_vvol)
except exception.HBSDNotFound:
with self.volinfo_lock:
if ldev in self.volume_info:
self.volume_info.pop(ldev)
LOG.warning(
basic_lib.set_msg(305, type='volume', id=volume['id']))
except exception.HBSDBusy:
raise exception.VolumeIsBusy(volume_name=volume['name'])
finally:
if ldev in self.volume_info:
self.volume_info[ldev]['in_use'].lock.release()
def _delete_lun(self, volume):
"""
Deletes a lun.
The equivalent CLI command is "no lun create container
<container_name> name <lun_name>"
Arguments:
volume -- volume object provided by the Manager
"""
v = self.vmem_vip
LOG.info(_("Deleting lun %s"), volume['id'])
try:
self._send_cmd(v.lun.bulk_delete_luns, 'LUN deletion started',
self.container, volume['id'])
except ViolinBackendErrNotFound:
LOG.info(_("Lun %s already deleted, continuing"), volume['id'])
except ViolinBackendErrExists:
LOG.warn(_("Lun %s has dependent snapshots, skipping"),
volume['id'])
raise exception.VolumeIsBusy(volume_name=volume['id'])
except Exception:
LOG.exception(_("Lun delete failed!"))
raise
self.lun_tracker.free_lun_id_for_volume(volume)
def unmanage(self, volume):
"""Prepare the volume for removing it from Cinder management."""
ldev = utils.get_ldev(volume)
if ldev is None:
utils.output_log(MSG.INVALID_LDEV_FOR_DELETION, method='unmanage',
id=volume['id'])
return
if self.check_pair_svol(ldev):
utils.output_log(
MSG.INVALID_LDEV_TYPE_FOR_UNMANAGE, volume_id=volume['id'],
volume_type=utils.NORMAL_LDEV_TYPE)
raise exception.VolumeIsBusy(volume_name=volume['name'])
try:
self.delete_pair(ldev)
except utils.HBSDBusy:
raise exception.VolumeIsBusy(volume_name=volume['name'])
def _delete_lun(self, volume):
"""
Deletes a lun.
The equivalent CLI command is "no lun create container
<container_name> name <lun_name>"
Arguments:
volume -- volume object provided by the Manager
"""
v = self.vmem_vip
LOG.info(_("Deleting lun %s"), volume['name'])
try:
self._send_cmd(v.lun.bulk_delete_luns, 'LUN deletion started',
self.container, volume['name'])
except ViolinBackendErrNotFound:
LOG.info(_("Lun %s already deleted, continuing"), volume['name'])
# TODO(RDL): not used in g5.x, backend returns this error
# stupidly whenever an attempt to grab the lvm lock happens
# when it is arleady locked. If this happens during a
# deletion request, the infrastructure above will give up and
# mark the lun as available.
#
except ViolinBackendErrExists:
LOG.info(_("Lun %s has dependent snapshots, skipping"),
volume['name'])
raise exception.VolumeIsBusy(volume_name=volume['name'])
except Exception:
LOG.exception(_("Lun delete failed!"))
raise
def _delete_lun(self, volume):
"""Deletes a lun.
:param volume: volume object provided by the Manager
"""
success_msgs = ['Delete resource successfully', '']
LOG.debug("Deleting lun %s.", volume['id'])
try:
# If the LUN has ever had a snapshot, it has an SRA and
# policy that must be deleted first.
self._delete_lun_snapshot_bookkeeping(volume['id'])
# TODO(rdl) force the delete for now to deal with pending
# snapshot issues. Should revisit later for a better fix.
self._send_cmd(self.vmem_mg.lun.delete_lun, success_msgs,
volume['id'], True)
except exception.VolumeBackendAPIException:
LOG.exception(
_LE("Lun %s has dependent snapshots, "
"skipping lun deletion."), volume['id'])
raise exception.VolumeIsBusy(volume_name=volume['id'])
except Exception:
LOG.exception(_LE("Lun delete for %s failed!"), volume['id'])
raise
def delete_vol_or_snap(self,
volume_url,
volume_name='',
ignore_non_exist=False):
try:
try:
volume = self._get_volume(volume_url)
except sushy_exceptions.ResourceNotFoundError:
if ignore_non_exist:
LOG.warning("Deleted non existent vol/snap %s", volume_url)
else:
raise
if volume.links.endpoints:
LOG.warning("Delete vol/snap failed, attached: %s", volume_url)
raise exception.VolumeIsBusy(_("Volume is already attached"),
volume_name=volume_name)
volume.delete()
except sushy_exceptions.BadRequestError as e:
try:
msg = e.body['@Message.ExtendedInfo'][0]['Message']
if (msg == "Cannot delete source snapshot volume when "
"other clone volumes are based on this snapshot."):
LOG.warning("Delete vol/snap failed, has-deps: %s",
volume_url)
raise exception.SnapshotIsBusy(snapshot_name=volume_name)
except Exception:
LOG.exception("Delete vol/snap failed")
raise exception.VolumeBackendAPIException(
data=(_('Unable to delete volume %s.') % volume_url))
except Exception:
LOG.exception("Delete vol/snap failed")
raise exception.VolumeBackendAPIException(
data=(_('Unable to delete volume %s.') % volume_url))
LOG.info("RSD volume deleted: %s", volume_url)
def delete_volume(self, volume):
"""Deletes a logical volume."""
# NOTE(jdg): We don't need to explicitly call
# remove export here because we already did it
# in the manager before we got here.
if self._volume_not_present(volume['name']):
# If the volume isn't present, then don't attempt to delete
return True
if self.vg.lv_has_snapshot(volume['name']):
LOG.error(
_LE('Unabled to delete due to existing snapshot '
'for volume: %s') % volume['name'])
raise exception.VolumeIsBusy(volume_name=volume['name'])
self._delete_volume(volume)
# [MRA] remove it from the reservation map.
resv_fpath = ioarbresv.get_resv_filepath(
'/dev/' + self.vg.vg_name.split('-')[-1])
ioarbresv.delete_resv_info(resv_fpath, volume['id'])
LOG.info(_LI('Successfully deleted volume: %s'), volume['id'])
def delete_volume(self, volume):
try:
volume_name = self._get_3par_vol_name(volume['id'])
# Try and delete the volume, it might fail here because
# the volume is part of a volume set which will have the
# volume set name in the error.
try:
self.client.deleteVolume(volume_name)
except hpexceptions.HTTPBadRequest as ex:
if ex.get_code() == 29:
if self.client.isOnlinePhysicalCopy(volume_name):
LOG.debug(_("Found an online copy for %(volume)s")
% {'volume': volume_name})
# the volume is in process of being cloned.
# stopOnlinePhysicalCopy will also delete
# the volume once it stops the copy.
self.client.stopOnlinePhysicalCopy(volume_name)
else:
LOG.error(str(ex))
raise ex
else:
LOG.error(str(ex))
raise ex
except hpexceptions.HTTPConflict as ex:
if ex.get_code() == 34:
# This is a special case which means the
# volume is part of a volume set.
vvset_name = self.client.findVolumeSet(volume_name)
LOG.debug("Returned vvset_name = %s" % vvset_name)
if vvset_name is not None and \
vvset_name.startswith('vvs-'):
# We have a single volume per volume set, so
# remove the volume set.
self.client.deleteVolumeSet(
self._get_3par_vvs_name(volume['id']))
elif vvset_name is not None:
# We have a pre-defined volume set just remove the
# volume and leave the volume set.
self.client.removeVolumeFromVolumeSet(vvset_name,
volume_name)
self.client.deleteVolume(volume_name)
else:
LOG.error(str(ex))
raise ex
except hpexceptions.HTTPNotFound as ex:
# We'll let this act as if it worked
# it helps clean up the cinder entries.
msg = _("Delete volume id not found. Removing from cinder: "
"%(id)s Ex: %(msg)s") % {'id': volume['id'], 'msg': ex}
LOG.warning(msg)
except hpexceptions.HTTPForbidden as ex:
LOG.error(str(ex))
raise exception.NotAuthorized(ex.get_description())
except hpexceptions.HTTPConflict as ex:
LOG.error(str(ex))
raise exception.VolumeIsBusy(ex.get_description())
except Exception as ex:
LOG.error(str(ex))
raise exception.CinderException(ex)
def delete(self, volume_path):
ret = self.client.Unlink(str(volume_path), self.user)
if ret < 0:
try:
raise make_ex(ret, 'error deleting image')
except ImageBusy:
raise exception.VolumeIsBusy(volume_name=volume_path)
def _delete_lun(self, volume):
"""Deletes a lun.
The equivalent CLI command is "no lun create container
<container_name> name <lun_name>"
Arguments:
volume -- volume object provided by the Manager
"""
success_msgs = ['lun deletion started', '']
LOG.debug("Deleting lun %s.", volume['id'])
try:
self._send_cmd(self.vip.lun.bulk_delete_luns, success_msgs,
self.container, volume['id'])
except exception.ViolinBackendErrNotFound:
LOG.debug("Lun %s already deleted, continuing.", volume['id'])
except exception.ViolinBackendErrExists:
LOG.warning(_LW("Lun %s has dependent snapshots, skipping."),
volume['id'])
raise exception.VolumeIsBusy(volume_name=volume['id'])
except Exception:
LOG.exception(_LE("Lun delete for %s failed!"), volume['id'])
raise
def delete_volume(self, volume):
"""Destroy a zvol on appliance.
:param volume: volume reference
"""
volume_name = self._get_zvol_name(volume['name'])
props = self.nms.zvol.get_child_props(volume_name, 'origin') or {}
try:
self.nms.zvol.destroy(volume_name, '')
except nexenta.NexentaException as exc:
if 'does not exist' in exc.args[0]:
LOG.info(_('Volume %s does not exist, it seems it was already '
'deleted.'), volume_name)
return
if 'zvol has children' in exc.args[0]:
raise exception.VolumeIsBusy(volume_name=volume_name)
raise
origin = props.get('origin')
if origin and self._is_clone_snapshot_name(origin):
volume, snapshot = origin.split('@')
volume = volume.lstrip('%s/' % self.configuration.nexenta_volume)
try:
self.delete_snapshot({'volume_name': volume, 'name': snapshot})
except nexenta.NexentaException as exc:
LOG.warning(_('Cannot delete snapshot %(origin)s: %(exc)s'),
{'origin': origin, 'exc': exc})
def delete_volume(self, volume):
"""Deletes a logical volume."""
with RADOSClient(self) as client:
try:
self.rbd.RBD().remove(client.ioctx, str(volume['name']))
except self.rbd.ImageHasSnapshots:
raise exception.VolumeIsBusy(volume_name=volume['name'])
def _delete_lun(self, volume):
"""Deletes a lun.
:param volume: volume object provided by the Manager
"""
success_msgs = ['Delete resource successfully', '']
LOG.debug("Deleting lun %s.", volume['id'])
# If the LUN has ever had a snapshot, it has an SRA and
# policy that must be deleted first.
self._delete_lun_snapshot_bookkeeping(volume['id'])
try:
self._send_cmd(self.vmem_mg.lun.delete_lun,
success_msgs, volume['id'])
except vmemclient.core.error.NoMatchingObjectIdError:
LOG.debug("Lun %s already deleted, continuing.", volume['id'])
except exception.ViolinBackendErrExists:
LOG.exception("Lun %s has dependent snapshots, "
"skipping lun deletion.", volume['id'])
raise exception.VolumeIsBusy(volume_name=volume['id'])
except Exception:
LOG.exception("Lun delete for %s failed!", volume['id'])
raise
def _delete_lun(self, volume):
"""Deletes a lun.
Arguments:
volume -- volume object provided by the Manager
"""
success_msgs = ['Delete resource successfully', '']
LOG.debug("Deleting lun %s.", volume['id'])
# If the LUN has ever had a snapshot, it has an SRA and policy
# that must be deleted first.
self._delete_lun_snapshot_bookkeeping(volume['id'])
try:
self._send_cmd(self.vmem_mg.lun.delete_lun, success_msgs,
volume['id'])
except vmemclient.core.error.NoMatchingObjectIdError:
LOG.debug("Lun %s already deleted, continuing.", volume['id'])
except ViolinBackendErrNotFound:
LOG.debug("Lun %s already deleted, continuing.", volume['id'])
except ViolinBackendErrExists:
# To REVISIT: This may not be the case anymore. Please
# revisit this issue after adding snapshot support
LOG.warn(_("Lun %s has dependent snapshots, skipping."),
volume['id'])
raise exception.VolumeIsBusy(volume_name=volume['id'])
except Exception:
LOG.exception(_("Lun delete for %s failed!"), volume['id'])
raise
def _gc_delete(self, vname):
"""Delete volume and its hidden parents
Deletes volume by going recursively to the first active
parent and cals recursive deletion on storage side
"""
vol = None
try:
vol = self.ra.get_lun(vname)
except jexc.JDSSResourceNotFoundException:
LOG.debug('volume %s does not exist, it was already '
'deleted.', vname)
return
except jexc.JDSSException as jerr:
raise exception.VolumeBackendAPIException(jerr)
if vol['is_clone']:
self._delete_back_recursively(jcom.origin_volume(vol['origin']),
jcom.origin_snapshot(vol['origin']))
else:
try:
self.ra.delete_lun(vname, force_umount=True)
except jexc.JDSSRESTException as jerr:
LOG.debug(
"Unable to delete physical volume %(volume)s "
"with error %(err)s.", {
"volume": vname,
"err": jerr
})
raise exception.VolumeIsBusy(jerr)
def unmanage(self, volume):
vol = self.volumes.get(volume['provider_location'], None)
if vol is not None:
if vol.get('is_busy') is True:
raise exception.VolumeIsBusy(
volume_name=volume['provider_location'])
del self.volumes[volume['provider_location']]
def delete_volume(self, volume):
"""Deletes a logical volume."""
stdout, _ = self._execute('rbd', 'snap', 'ls', '--pool',
FLAGS.rbd_pool, volume['name'])
if stdout.count('\n') > 1:
raise exception.VolumeIsBusy(volume_name=volume['name'])
self._try_execute('rbd', 'rm', '--pool', FLAGS.rbd_pool,
volume['name'])
def unmanage(self, volume):
"""Prepare the volume for removing it from Cinder management."""
ldev = utils.get_ldev(volume)
# When 'ldev' is 0, it should be true.
# Therefore, it cannot remove 'is None'.
if ldev is None:
utils.output_log(MSG.INVALID_LDEV_FOR_DELETION, method='unmanage',
id=volume['id'])
return
if self.check_vvol(ldev):
utils.output_log(
MSG.INVALID_LDEV_TYPE_FOR_UNMANAGE, volume_id=volume['id'],
volume_type=utils.NORMAL_LDEV_TYPE)
raise exception.VolumeIsBusy(volume_name=volume['name'])
try:
self.delete_pair(ldev)
except exception.VSPBusy:
raise exception.VolumeIsBusy(volume_name=volume['name'])
def delete_volume(self, volume):
"""Deletes a logical volume."""
if self._volume_not_present(volume['name']):
# If the volume isn't present, then don't attempt to delete
return True
if self.vg.lv_has_snapshot(volume['name']):
raise exception.VolumeIsBusy(volume_name=volume['name'])
self._delete_volume(volume)
def delete_volume(self, volume):
"""Delete a volume from the backend."""
try:
volume_name = self._make_volume_name(volume)
volume = self._get_infinidat_volume_by_name(volume_name)
if volume['has_children']:
# can't delete a volume that has a live snapshot
raise exception.VolumeIsBusy(volume_name=volume_name)
self._delete(DELETE_URI % volume['id'])
except (exception.InvalidVolume, exception.NotFound):
return # volume not found
def delete_volume(self, volume):
"""Delete a volume from the backend."""
volume_name = self._make_volume_name(volume)
try:
infinidat_volume = self._get_infinidat_volume_by_name(volume_name)
except exception.InvalidVolume:
return # volume not found
if infinidat_volume.has_children():
# can't delete a volume that has a live snapshot
raise exception.VolumeIsBusy(volume_name=volume_name)
infinidat_volume.safe_delete()
def copy_file_to_volume(self, context, src_file, volume):
"""Copies a file to a volume."""
if self._volume_not_present(volume['name']):
# The underlying volume is gone. We need to re-create it.
self.create_volume(volume)
elif self.vg.lv_has_snapshot(volume['name']):
LOG.error(
'Unable to copy due to existing snapshot '
'for volume: %s', volume['name'])
raise exception.VolumeIsBusy(volume_name=volume['name'])
# Use O_DIRECT to avoid thrashing the system buffer cache
extra_flags = []
if volutils.check_for_odirect_support(src_file,
self.local_path(volume),
'iflag=direct'):
extra_flags.append('iflag=direct')
if volutils.check_for_odirect_support(src_file,
self.local_path(volume),
'oflag=direct'):
extra_flags.append('oflag=direct')
conv = []
if not extra_flags:
conv.append('fdatasync')
if conv:
conv_options = 'conv=' + ",".join(conv)
extra_flags.append(conv_options)
try:
size_in_bytes = int(volume['size']) * 1024**3 # vol size is GB
blocksize = volutils._check_blocksize(
self.configuration.volume_dd_blocksize)
# Perform the copy
cmd = [
'dd',
'if=%s' % src_file,
'of=%s' % self.local_path(volume),
'count=%d' % size_in_bytes,
'bs=%s' % blocksize
]
cmd.extend(extra_flags)
utils.execute(*cmd, run_as_root=True)
except Exception:
msg = (_("Failed to copy %(src)s to volume %(dest)s") % {
'src': src_file,
'dest': volume['id']
})
LOG.error(msg)
raise
self.restore_configuration()
def delete_volume(self, volume):
"""Destroy a zvol on appliance.
:param volume: volume reference
"""
try:
self.nms.zvol.destroy(self._get_zvol_name(volume['name']), '')
except nexenta.NexentaException as exc:
if "zvol has children" in exc.args[1]:
raise exception.VolumeIsBusy(volume_name=volume['name'])
else:
raise
def delete_volume(self, volume):
"""Delete the specified volume."""
ldev = utils.get_ldev(volume)
if ldev is None:
utils.output_log(MSG.INVALID_LDEV_FOR_DELETION,
method='delete_volume',
id=volume['id'])
return
try:
self.delete_ldev(ldev)
except utils.HBSDBusy:
raise exception.VolumeIsBusy(volume_name=volume['name'])
def delete_lun(self, volume_name,
recursively_children=False,
recursively_dependents=False,
force_umount=False):
"""delete_volume.
DELETE /volumes/<string:volumename>
:param volume_name:
:return:
"""
jbody = {}
if recursively_children:
jbody['recursively_children'] = True
if recursively_dependents:
jbody['recursively_dependents'] = True
if force_umount:
jbody['force_umount'] = True
req = '/volumes/' + volume_name
LOG.debug(("delete volume:%(vol)s "
"recursively children:%(args)s"),
{'vol': volume_name,
'args': jbody})
if len(jbody) > 0:
resp = self.rproxy.pool_request('DELETE', req, json_data=jbody)
else:
resp = self.rproxy.pool_request('DELETE', req)
if resp["code"] == 204:
LOG.debug(
"volume %s deleted", volume_name)
return
# Handle DNE case
if resp["code"] == 500:
if 'message' in resp['error']:
if self.resource_dne_msg.match(resp['error']['message']):
LOG.debug("volume %s do not exists, delition success",
volume_name)
return
# Handle volume busy
if resp["code"] == 500 and resp["error"]:
if resp["error"]["errno"] == 1000:
LOG.warning(
"volume %s is busy", volume_name)
raise exception.VolumeIsBusy(volume_name=volume_name)
raise jexc.JDSSRESTException('Failed to delete volume.')
def _destroy_lvm(self, volume):
vg = self._get_lvm_vg(volume)
if vg.lv_has_snapshot(volume['name']):
LOG.error(
_LE('Unable to delete due to existing snapshot '
'for volume: %s.'), volume['name'])
raise exception.VolumeIsBusy(volume_name=volume['name'])
vg.destroy_vg()
# NOTE(joachim) Force lvm vg flush through a vgs command
vgs = vg.get_all_volume_groups(root_helper='sudo', vg_name=vg.vg_name)
if len(vgs) != 0:
LOG.warning(_LW('Removed volume group %s still appears in vgs.'),
vg.vg_name)
def delete_volume(self, volume):
"""Delete the specified volume."""
ldev = utils.get_ldev(volume)
# When 'ldev' is 0, it should be true.
# Therefore, it cannot remove 'is not None'.
if ldev is None:
utils.output_log(MSG.INVALID_LDEV_FOR_DELETION,
method='delete_volume', id=volume['id'])
return
try:
self._delete_ldev(ldev)
except exception.VSPBusy:
raise exception.VolumeIsBusy(volume_name=volume['name'])
def delete_volume(self, volume):
"""Deletes a logical volume."""
if self._volume_not_present(volume):
# If the volume isn't present, then don't attempt to delete
return True
root_helper = utils.get_root_helper()
zvol = self._zfs_volume(volume)
# Check zvol for snapshots
try:
out, err = self._execute('zfs',
'list',
'-r',
'-H',
'-t',
'snapshot',
zvol,
root_helper=root_helper,
run_as_root=True)
except processutils.ProcessExecutionError:
exception_message = (_("Failed to list snapshots "
"error message was: %s") %
six.text_type(exc.stderr))
raise exception.VolumeBackendAPIException(data=exception_message)
# At this point, clone-snap snapshots should be promoted
snapshots = [x for x in out.splitlines() if "clone-snap" not in x]
if len(snapshots) > 0:
LOG.error(
_('Unable to delete due to existing snapshot '
'for volume: %s'), volume['name'])
raise exception.VolumeIsBusy(volume_name=volume['name'])
# Delete zvol
try:
self._execute('zfs',
'destroy',
'-r',
zvol,
root_helper=root_helper,
run_as_root=True)
except processutils.ProcessExecutionError as exc:
exception_message = (_("Failed to delete zvol, "
"error message was: %s") %
six.text_type(exc.stderr))
raise exception.VolumeBackendAPIException(data=exception_message)
LOG.info(_('Successfully deleted volume: %s'), volume['id'])
def delete_volume(self, volume):
"""Destroy a zvol on appliance.
:param volume: volume reference
"""
try:
self.nms.zvol.destroy(self._get_zvol_name(volume['name']), '')
except nexenta.NexentaException as exc:
if "does not exist" in exc.args[0]:
LOG.info(_('Volume %s does not exist, it seems it was already '
'deleted'), volume['name'])
return
if "zvol has children" in exc.args[0]:
raise exception.VolumeIsBusy(volume_name=volume['name'])
raise
def delete_volume(self, volume):
"""Delete the specified volume."""
ldev = utils.get_ldev(volume)
if ldev is None:
utils.output_log(MSG.INVALID_LDEV_FOR_DELETION,
method='delete_volume',
id=volume['id'])
return
try:
self.delete_ldev(ldev)
except exception.VolumeDriverException as ex:
if ex.msg == utils.BUSY_MESSAGE:
raise exception.VolumeIsBusy(volume_name=volume['name'])
else:
raise ex
