def test_publish_volume_map_volume_excpetions(self, enter):
context = utils.FakeContext()
self.mediator.map_volume.side_effect = [
array_errors.PermissionDeniedError("msg")
]
enter.return_value = self.mediator
self.servicer.ControllerPublishVolume(self.request, context)
self.assertEqual(context.code, grpc.StatusCode.PERMISSION_DENIED)
self.mediator.map_volume.side_effect = [
array_errors.VolumeNotFoundError("vol")
]
enter.return_value = self.mediator
self.servicer.ControllerPublishVolume(self.request, context)
self.assertEqual(context.code, grpc.StatusCode.NOT_FOUND)
self.mediator.map_volume.side_effect = [
array_errors.HostNotFoundError("host")
]
enter.return_value = self.mediator
self.servicer.ControllerPublishVolume(self.request, context)
self.assertEqual(context.code, grpc.StatusCode.NOT_FOUND)
self.mediator.map_volume.side_effect = [
array_errors.MappingError("", "", "")
]
enter.return_value = self.mediator
self.servicer.ControllerPublishVolume(self.request, context)
self.assertEqual(context.code, grpc.StatusCode.INTERNAL)
def map_volume(self, volume_id, host_name):
logger.debug("mapping volume : {0} to host : {1}".format(
volume_id, host_name))
vol_name = self._get_object_name_by_wwn(volume_id)
lun = self._get_next_available_lun(host_name)
try:
self.client.cmd.map_vol(host=host_name, vol=vol_name, lun=lun)
except xcli_errors.OperationForbiddenForUserCategoryError as ex:
logger.exception(ex)
raise controller_errors.PermissionDeniedError(
"map volume : {0} to host : {1}".format(volume_id, host_name))
except xcli_errors.VolumeBadNameError as ex:
logger.exception(ex)
raise controller_errors.ObjectNotFoundError(vol_name)
except xcli_errors.HostBadNameError as ex:
logger.exception(ex)
raise controller_errors.HostNotFoundError(host_name)
except xcli_errors.CommandFailedRuntimeError as ex:
logger.exception(ex)
if LUN_IS_ALREADY_IN_USE_ERROR in ex.status:
raise controller_errors.LunAlreadyInUseError(lun, host_name)
else:
raise controller_errors.MappingError(vol_name, host_name, ex)
return str(lun)
def unmap_volume(self, volume_id, host_name):
logger.debug("un-mapping volume : {0} from host : {1}".format(
volume_id, host_name))
vol_name = self._get_object_name_by_wwn(volume_id)
try:
self.client.cmd.unmap_vol(host=host_name, vol=vol_name)
except xcli_errors.VolumeBadNameError as ex:
logger.exception(ex)
raise controller_errors.ObjectNotFoundError(vol_name)
except xcli_errors.HostBadNameError as ex:
logger.exception(ex)
raise controller_errors.HostNotFoundError(host_name)
except xcli_errors.OperationForbiddenForUserCategoryError as ex:
logger.exception(ex)
raise controller_errors.PermissionDeniedError(
"unmap volume : {0} from host : {1}".format(
volume_id, host_name))
except xcli_errors.CommandFailedRuntimeError as ex:
logger.exception(ex)
if UNDEFINED_MAPPING_ERROR in ex.status:
raise controller_errors.VolumeAlreadyUnmappedError(vol_name)
else:
raise controller_errors.UnMappingError(vol_name, host_name, ex)
def create_volume(self, name, size_in_bytes, capabilities, pool):
logger.info(
"creating volume with name : {}. size : {} . in pool : {} with capabilities : {}"
.format(name, size_in_bytes, pool, capabilities))
size_in_blocks = self._convert_size_bytes_to_blocks(size_in_bytes)
try:
cli_volume = self.client.cmd.vol_create(
vol=name, size_blocks=size_in_blocks,
pool=pool).as_single_element
logger.info("finished creating cli volume : {}".format(cli_volume))
return self._generate_volume_response(cli_volume)
except xcli_errors.IllegalNameForObjectError as ex:
logger.exception(ex)
raise controller_errors.IllegalObjectName(ex.status)
except xcli_errors.VolumeExistsError as ex:
logger.exception(ex)
raise controller_errors.VolumeAlreadyExists(name, self.endpoint)
except xcli_errors.PoolDoesNotExistError as ex:
logger.exception(ex)
raise controller_errors.PoolDoesNotExist(pool, self.endpoint)
except xcli_errors.OperationForbiddenForUserCategoryError as ex:
logger.exception(ex)
raise controller_errors.PermissionDeniedError(
"create vol : {0}".format(name))
except xcli_errors.CommandFailedRuntimeError as ex:
logger.exception(ex)
if NO_ALLOCATION_SPACE_ERROR in ex.status:
raise controller_errors.NotEnoughSpaceInPool(pool=pool)
def create_snapshot(self, name, volume_name, pool_id=None):
logger.info("creating snapshot {0} from volume {1}".format(
name, volume_name))
try:
cli_snapshot = self.client.cmd.snapshot_create(
name=name, vol=volume_name).as_single_element
logger.info(
"finished creating cli snapshot {0} from volume {1}".format(
name, volume_name))
return self._generate_snapshot_response(cli_snapshot)
except xcli_errors.IllegalNameForObjectError as ex:
logger.exception(ex)
raise controller_errors.IllegalObjectName(ex.status)
except xcli_errors.VolumeExistsError as ex:
logger.exception(ex)
raise controller_errors.SnapshotAlreadyExists(name, self.endpoint)
except xcli_errors.VolumeBadNameError as ex:
logger.exception(ex)
raise controller_errors.ObjectNotFoundError(volume_name)
except xcli_errors.OperationForbiddenForUserCategoryError as ex:
logger.exception(ex)
raise controller_errors.PermissionDeniedError(
"create snapshot {0} from volume {1}".format(
name, volume_name))
def create_snapshot(self, volume_id, snapshot_name, pool=None):
logger.info("creating snapshot {0} from volume {1}".format(
snapshot_name, volume_id))
source_cli_volume = self._get_cli_object_by_wwn(volume_id)
if pool and pool != source_cli_volume.pool_name:
raise array_errors.SnapshotSourcePoolMismatch(
snapshot_pool=pool, source_pool=source_cli_volume.pool_name)
try:
cli_snapshot = self.client.cmd.snapshot_create(
name=snapshot_name,
vol=source_cli_volume.name).as_single_element
logger.info(
"finished creating cli snapshot {0} from volume {1}".format(
snapshot_name, volume_id))
return self._generate_snapshot_response(cli_snapshot)
except xcli_errors.IllegalNameForObjectError as ex:
logger.exception(ex)
raise array_errors.IllegalObjectName(ex.status)
except xcli_errors.VolumeExistsError as ex:
logger.exception(ex)
raise array_errors.SnapshotAlreadyExists(snapshot_name,
self.endpoint)
except xcli_errors.VolumeBadNameError as ex:
logger.exception(ex)
raise array_errors.ObjectNotFoundError(volume_id)
except xcli_errors.OperationForbiddenForUserCategoryError as ex:
logger.exception(ex)
raise array_errors.PermissionDeniedError(
"create snapshot {0} from volume {1}".format(
snapshot_name, volume_id))
def copy_to_existing_volume_from_snapshot(self, name, src_snap_name, src_snap_capacity_in_bytes,
min_vol_size_in_bytes, pool=None):
logger.debug(
"Copy snapshot {0} data to volume {1}. Snapshot capacity {2}. Minimal requested volume capacity {3}".format(
name, src_snap_name, src_snap_capacity_in_bytes, min_vol_size_in_bytes))
try:
logger.debug("Formatting volume {0}".format(name))
self.client.cmd.vol_format(vol=name)
logger.debug("Copying Snapshot {0} data to volume {1}.".format(name, src_snap_name))
self.client.cmd.vol_copy(vol_src=src_snap_name, vol_trg=name)
if min_vol_size_in_bytes > src_snap_capacity_in_bytes:
min_vol_size_in_blocks = self._convert_size_bytes_to_blocks(min_vol_size_in_bytes)
logger.debug(
"Increasing volume {0} size to {1} blocks.".format(name, min_vol_size_in_blocks))
self.client.cmd.vol_resize(vol=name, size_blocks=min_vol_size_in_blocks)
except xcli_errors.IllegalNameForObjectError as ex:
logger.exception(ex)
raise controller_errors.IllegalObjectName(ex.status)
except xcli_errors.SourceVolumeBadNameError as ex:
logger.exception(ex)
raise controller_errors.SnapshotNotFoundError(src_snap_name)
except (xcli_errors.VolumeBadNameError, xcli_errors.TargetVolumeBadNameError) as ex:
logger.exception(ex)
raise controller_errors.VolumeNotFoundError(name)
except xcli_errors.OperationForbiddenForUserCategoryError as ex:
logger.exception(ex)
raise controller_errors.PermissionDeniedError("create vol : {0}".format(name))
def delete_snapshot(self, snapshot_id):
logger.info("Deleting snapshot with id : {0}".format(snapshot_id))
snapshot_name = self._get_object_name_by_wwn(snapshot_id)
try:
self.client.cmd.snapshot_delete(snapshot=snapshot_name)
except xcli_errors.VolumeBadNameError as ex:
logger.exception(ex)
raise array_errors.ObjectNotFoundError(snapshot_name)
except xcli_errors.OperationForbiddenForUserCategoryError as ex:
logger.exception(ex)
raise array_errors.PermissionDeniedError(
"delete snapshot : {0}".format(snapshot_name))
logger.info("Finished snapshot deletion. id : {0}".format(snapshot_id))
def delete_volume(self, volume_id):
logger.info("Deleting volume with id : {0}".format(volume_id))
vol_name = self._get_vol_by_wwn(volume_id)
try:
self.client.cmd.vol_delete(vol=vol_name)
except xcli_errors.VolumeBadNameError as ex:
logger.exception(ex)
raise controller_errors.VolumeNotFoundError(vol_name)
except xcli_errors.OperationForbiddenForUserCategoryError as ex:
logger.exception(ex)
raise controller_errors.PermissionDeniedError("delete vol : {0}".format(vol_name))
logger.info("Finished volume deletion. id : {0}".format(volume_id))
def delete_volume(self, volume_id):
logger.info("Deleting volume with id : {0}".format(volume_id))
volume_name = self._get_object_name_by_wwn(volume_id)
cli_snapshots = self.client.cmd.snapshot_list(vol=volume_name).as_list
if cli_snapshots:
raise controller_errors.ObjectIsStillInUseError(
id_or_name=volume_id, used_by=cli_snapshots)
try:
self.client.cmd.vol_delete(vol=volume_name)
except xcli_errors.VolumeBadNameError as ex:
logger.exception(ex)
raise controller_errors.ObjectNotFoundError(volume_name)
except xcli_errors.OperationForbiddenForUserCategoryError as ex:
logger.exception(ex)
raise controller_errors.PermissionDeniedError(
"delete vol : {0}".format(volume_name))
logger.info("Finished volume deletion. id : {0}".format(volume_id))
