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