def DeleteVolume(self, request, context):
        set_current_thread_name(request.volume_id)
        logger.info("DeleteVolume")
        secrets = request.secrets

        try:
            utils.validate_delete_volume_request(request)

            user, password, array_addresses = utils.get_array_connection_info_from_secret(
                secrets)

            try:
                array_type, vol_id = utils.get_volume_id_info(
                    request.volume_id)
            except controller_errors.VolumeNotFoundError as ex:
                logger.warning("volume id is invalid. error : {}".format(ex))
                return csi_pb2.DeleteVolumeResponse()

            with ArrayConnectionManager(user, password, array_addresses,
                                        array_type) as array_mediator:

                logger.debug(array_mediator)

                try:
                    array_mediator.delete_volume(vol_id)

                except controller_errors.VolumeNotFoundError as ex:
                    logger.debug(
                        "volume was not found during deletion: {0}".format(ex))

                except controller_errors.PermissionDeniedError as ex:
                    context.set_code(grpc.StatusCode.PERMISSION_DENIED)
                    context.set_details(ex)
                    return csi_pb2.DeleteVolumeResponse()

        except ValidationException as ex:
            logger.exception(ex)
            context.set_details(ex.message)
            context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
            return csi_pb2.DeleteVolumeResponse()

        except Exception as ex:
            logger.debug("an internal exception occurred")
            logger.exception(ex)
            context.set_code(grpc.StatusCode.INTERNAL)
            context.set_details(
                'an internal exception occurred : {}'.format(ex))
            return csi_pb2.DeleteVolumeResponse()

        logger.debug("generating delete volume response")
        res = csi_pb2.DeleteVolumeResponse()
        logger.info("finished DeleteVolume")
        return res
    def DeleteSnapshot(self, request, context):
        set_current_thread_name(request.snapshot_id)
        logger.info("Delete snapshot")
        secrets = request.secrets
        try:
            utils.validate_delete_snapshot_request(request)
            user, password, array_addresses = utils.get_array_connection_info_from_secret(
                secrets)
            try:
                array_type, snapshot_id = utils.get_snapshot_id_info(
                    request.snapshot_id)
            except ObjectIdError as ex:
                logger.warning("volume id is invalid. error : {}".format(ex))
                return csi_pb2.DeleteVolumeResponse()

            array_type = detect_array_type(array_addresses)
            with get_agent(user, password, array_addresses,
                           array_type).get_mediator() as array_mediator:
                logger.debug(array_mediator)
                try:
                    array_mediator.delete_snapshot(snapshot_id)

                except controller_errors.SnapshotNotFoundError as ex:
                    logger.debug(
                        "Snapshot was not found during deletion: {0}".format(
                            ex))

        except controller_errors.SnapshotNotFoundError:
            logger.debug(
                "snapshot was not found during deletion: {0}".format(ex))
            context.set_code(grpc.StatusCode.OK)
            return csi_pb2.DeleteSnapshotResponse()
        except controller_errors.SnapshotIsStillInUseError:
            logger.info(
                "could not delete snapshot while in use: {0}".format(ex))
            context.set_code(grpc.StatusCode.FAILED_PRECONDITION)
            context.set_details(ex)
            return csi_pb2.DeleteSnapshotResponse()
        except controller_errors.PermissionDeniedError as ex:
            context.set_code(grpc.StatusCode.PERMISSION_DENIED)
            context.set_details(ex)
            return csi_pb2.DeleteSnapshotResponse()
        except ValidationException as ex:
            logger.exception(ex)
            context.set_details(ex.message)
            context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
            return csi_pb2.DeleteSnapshotResponse()
        except Exception as ex:
            logger.debug("an internal exception occurred")
            logger.exception(ex)
            context.set_code(grpc.StatusCode.INTERNAL)
            context.set_details(
                'an internal exception occurred : {}'.format(ex))
            return csi_pb2.DeleteSnapshotResponse()

        logger.debug("generating delete snapshot response")
        res = csi_pb2.DeleteSnapshotResponse()
        logger.info("finished DeleteSnapshot")
        return res
    def DeleteVolume(self, request, context):
        set_current_thread_name(request.volume_id)
        logger.info("DeleteVolume")
        secrets = request.secrets
        utils.validate_delete_volume_request(request)

        try:
            volume_id_info = utils.get_volume_id_info(request.volume_id)
        except ObjectIdError as ex:
            logger.warning("volume id is invalid. error : {}".format(ex))
            return csi_pb2.DeleteVolumeResponse()

        system_id = volume_id_info.system_id
        array_type = volume_id_info.array_type
        volume_id = volume_id_info.object_id
        array_connection_info = utils.get_array_connection_info_from_secrets(
            secrets, system_id=system_id)

        with get_agent(array_connection_info,
                       array_type).get_mediator() as array_mediator:
            logger.debug(array_mediator)

            try:
                logger.debug("Deleting volume {0}".format(volume_id))
                array_mediator.delete_volume(volume_id)

            except array_errors.ObjectNotFoundError as ex:
                logger.debug(
                    "volume was not found during deletion: {0}".format(ex))
            except array_errors.PermissionDeniedError as ex:
                return handle_exception(ex, context,
                                        grpc.StatusCode.PERMISSION_DENIED,
                                        csi_pb2.DeleteVolumeResponse)

        logger.debug("generating delete volume response")
        res = csi_pb2.DeleteVolumeResponse()
        logger.info("finished DeleteVolume")
        return res
    def DeleteVolume(self, request, context):
        set_current_thread_name(request.volume_id)
        logger.info("DeleteVolume")
        secrets = request.secrets

        try:
            utils.validate_delete_volume_request(request)

            try:
                volume_id_info = utils.get_volume_id_info(request.volume_id)
            except ObjectIdError as ex:
                logger.warning("volume id is invalid. error : {}".format(ex))
                return csi_pb2.DeleteVolumeResponse()
            system_id = volume_id_info.system_id
            array_type = volume_id_info.array_type
            volume_id = volume_id_info.object_id
            array_connection_info = utils.get_array_connection_info_from_secrets(
                secrets, system_id=system_id)

            with get_agent(array_connection_info,
                           array_type).get_mediator() as array_mediator:
                logger.debug(array_mediator)

                try:

                    logger.debug("Deleting volume {0}".format(volume_id))
                    array_mediator.delete_volume(volume_id)

                except array_errors.ObjectNotFoundError as ex:
                    logger.debug(
                        "volume was not found during deletion: {0}".format(ex))

                except array_errors.PermissionDeniedError as ex:
                    context.set_code(grpc.StatusCode.PERMISSION_DENIED)
                    context.set_details(ex.message)
                    return csi_pb2.DeleteVolumeResponse()

        except array_errors.ObjectIsStillInUseError as ex:
            logger.info("could not delete volume while in use: {0}".format(ex))
            context.set_code(grpc.StatusCode.FAILED_PRECONDITION)
            context.set_details(ex.message)
            return csi_pb2.DeleteVolumeResponse()

        except (ValidationException, array_errors.IllegalObjectID) as ex:
            logger.exception(ex)
            context.set_details(ex.message)
            context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
            return csi_pb2.DeleteVolumeResponse()

        except Exception as ex:
            logger.debug("an internal exception occurred")
            logger.exception(ex)
            context.set_code(grpc.StatusCode.INTERNAL)
            context.set_details(
                'an internal exception occurred : {}'.format(ex))
            return csi_pb2.DeleteVolumeResponse()

        logger.debug("generating delete volume response")
        res = csi_pb2.DeleteVolumeResponse()
        logger.info("finished DeleteVolume")
        return res