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_cli_volume(self, name, size_in_bytes, space_efficiency, pool):
logger.info(
"creating volume with name : {}. size : {} . in pool : {} with parameters : {}"
.format(name, size_in_bytes, pool, space_efficiency))
try:
size = self._convert_size_bytes(size_in_bytes)
cli_kwargs = build_kwargs_from_parameters(space_efficiency, pool,
name, size)
self.client.svctask.mkvolume(**cli_kwargs)
cli_volume = self._get_cli_volume(name)
logger.info("finished creating cli volume : {}".format(
cli_volume.name))
return cli_volume
except (svc_errors.CommandExecutionError, CLIFailureError) as ex:
if not is_warning_message(ex.my_message):
logger.error(msg="Cannot create volume {0}, "
"Reason is: {1}".format(name, ex))
if OBJ_ALREADY_EXIST in ex.my_message:
raise array_errors.VolumeAlreadyExists(name, self.endpoint)
if NAME_NOT_EXIST_OR_MEET_RULES in ex.my_message:
raise array_errors.PoolDoesNotExist(pool, self.endpoint)
if (POOL_NOT_MATCH_VOL_CAPABILITIES in ex.my_message
or NOT_REDUCTION_POOL in ex.my_message):
raise array_errors.PoolDoesNotMatchCapabilities(
pool, space_efficiency, ex)
if NOT_ENOUGH_EXTENTS_IN_POOL_CREATE in ex.my_message:
raise array_errors.NotEnoughSpaceInPool(id_or_name=pool)
if any(msg_id in ex.my_message
for msg_id in (NON_ASCII_CHARS, INVALID_NAME,
TOO_MANY_CHARS)):
raise array_errors.IllegalObjectName(ex.my_message)
raise ex
except Exception as ex:
logger.exception(ex)
raise ex
def _create_cli_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))
try:
size = self._convert_size_bytes(size_in_bytes)
cli_kwargs = build_kwargs_from_capabilities(
capabilities, pool, name, size)
self.client.svctask.mkvolume(**cli_kwargs)
vol = self._get_cli_volume(name)
logger.info("finished creating cli volume : {}".format(vol.name))
return vol
except (svc_errors.CommandExecutionError, CLIFailureError) as ex:
if not is_warning_message(ex.my_message):
logger.error(msg="Cannot create volume {0}, "
"Reason is: {1}".format(name, ex))
if OBJ_ALREADY_EXIST in ex.my_message:
raise controller_errors.VolumeAlreadyExists(
name, self.endpoint)
if NAME_NOT_MEET in ex.my_message:
raise controller_errors.PoolDoesNotExist(
pool, self.endpoint)
if (POOL_NOT_MATCH_VOL_CAPABILITIES in ex.my_message
or NOT_REDUCTION_POOL in ex.my_message):
raise controller_errors.PoolDoesNotMatchCapabilities(
pool, capabilities, ex)
if NOT_ENOUGH_EXTENTS_IN_POOL_CREATE in ex.my_message:
raise controller_errors.NotEnoughSpaceInPool(pool=pool)
raise ex
except Exception as ex:
logger.exception(ex)
raise ex
def _extend_volume(self, api_volume, new_size_in_bytes):
try:
self.client.extend_volume(volume_id=api_volume.id,
new_size_in_bytes=new_size_in_bytes)
except exceptions.NotFound:
raise array_errors.ObjectNotFoundError(api_volume.id)
except (exceptions.ClientError, exceptions.ClientException) as ex:
if ERROR_CODE_EXPAND_VOLUME_NOT_ENOUGH_EXTENTS in str(
ex.message).upper():
raise array_errors.NotEnoughSpaceInPool(api_volume.pool)
def _expand_cli_volume(self, cli_volume, increase_in_blocks):
try:
self.client.cmd.vol_resize(vol=cli_volume.name,
size_blocks=increase_in_blocks)
except xcli_errors.VolumeBadNameError as ex:
logger.exception(ex)
raise array_errors.ObjectNotFoundError(cli_volume.id)
except xcli_errors.CommandFailedRuntimeError as ex:
logger.exception(ex)
if NO_ALLOCATION_SPACE_ERROR in ex.status:
raise array_errors.NotEnoughSpaceInPool(cli_volume.pool_name)
raise ex
def _expand_cli_volume(self, cli_volume, increase_in_bytes):
volume_name = cli_volume.name
try:
self.client.svctask.expandvdisksize(vdisk_id=volume_name,
unit='b',
size=increase_in_bytes)
except (svc_errors.CommandExecutionError, CLIFailureError) as ex:
if not is_warning_message(ex.my_message):
logger.warning(
"Failed to expand volume {}".format(volume_name))
if OBJ_NOT_FOUND in ex.my_message or VOL_NOT_FOUND in ex.my_message:
raise array_errors.ObjectNotFoundError(volume_name)
if NOT_ENOUGH_EXTENTS_IN_POOL_EXPAND in ex.my_message:
raise array_errors.NotEnoughSpaceInPool(
id_or_name=cli_volume.mdisk_grp_name)
raise ex
def _create_api_volume(self, name, size_in_bytes, space_efficiency,
pool_id):
logger.info(
"Creating volume with name: {}, size: {}, in pool: {}, with parameters: {}"
.format(name, size_in_bytes, pool_id, space_efficiency))
try:
cli_kwargs = {}
cli_kwargs.update({
'name':
name,
'capacity_in_bytes':
size_in_bytes,
'pool_id':
pool_id,
'tp':
get_array_space_efficiency(space_efficiency),
})
logger.debug("Start to create volume with parameters: {}".format(
cli_kwargs))
# get the volume before creating again, to make sure it is not existing,
# because volume name is not unique in ds8k.
api_volume = self._get_api_volume_by_name(name, pool_id=pool_id)
logger.info("Found volume {}".format(name))
if api_volume is not None:
raise array_errors.VolumeAlreadyExists(name, self.identifier)
api_volume = self.client.create_volume(**cli_kwargs)
logger.info("finished creating volume {}".format(name))
return self.client.get_volume(api_volume.id)
except (exceptions.NotFound, exceptions.InternalServerError) as ex:
if ERROR_CODE_RESOURCE_NOT_EXISTS or INCORRECT_ID in str(
ex.message).upper():
raise array_errors.PoolDoesNotExist(pool_id, self.identifier)
logger.error(
"Failed to create volume {} on array {}, reason is: {}".format(
name, self.identifier, ex.details))
raise array_errors.VolumeCreationError(name)
except (exceptions.ClientError, exceptions.ClientException) as ex:
if ERROR_CODE_CREATE_VOLUME_NOT_ENOUGH_EXTENTS in str(
ex.message).upper():
raise array_errors.NotEnoughSpaceInPool(id_or_name=pool_id)
logger.error(
"Failed to create volume {} on array {}, reason is: {}".format(
name, self.identifier, ex.details))
raise array_errors.VolumeCreationError(name)
