| # |
| # Copyright 2015 ClusterHQ |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| |
| """ |
| Helper routines for converting ``errno`` style error codes from C functions |
| to Python exceptions defined by `libzfs_core` API. |
| |
| The conversion heavily depends on the context of the error: the attempted |
| operation and the input parameters. For this reason, there is a conversion |
| routine for each `libzfs_core` interface function. The conversion routines |
| have the return code as a parameter as well as all the parameters of the |
| corresponding interface functions. |
| |
| The parameters and exceptions are documented in the `libzfs_core` interfaces. |
| """ |
| from __future__ import absolute_import, division, print_function |
| |
| import errno |
| import re |
| import string |
| from . import exceptions as lzc_exc |
| from ._constants import ( |
| ECHRNG, |
| ECKSUM, |
| ETIME, |
| MAXNAMELEN, |
| ZFS_ERR_CHECKPOINT_EXISTS, |
| ZFS_ERR_DISCARDING_CHECKPOINT, |
| ZFS_ERR_NO_CHECKPOINT, |
| ZFS_ERR_DEVRM_IN_PROGRESS, |
| ZFS_ERR_VDEV_TOO_BIG, |
| ZFS_ERR_WRONG_PARENT, |
| zfs_errno |
| ) |
| |
| |
| def lzc_create_translate_error(ret, name, ds_type, props): |
| if ret == 0: |
| return |
| if ret == errno.EINVAL: |
| _validate_fs_name(name) |
| raise lzc_exc.PropertyInvalid(name) |
| if ret == errno.EEXIST: |
| raise lzc_exc.FilesystemExists(name) |
| if ret == errno.ENOENT: |
| raise lzc_exc.ParentNotFound(name) |
| if ret == ZFS_ERR_WRONG_PARENT: |
| raise lzc_exc.WrongParent(_fs_name(name)) |
| if ret == zfs_errno.ZFS_ERR_BADPROP: |
| raise lzc_exc.PropertyInvalid(name) |
| raise _generic_exception(ret, name, "Failed to create filesystem") |
| |
| |
| def lzc_clone_translate_error(ret, name, origin, props): |
| if ret == 0: |
| return |
| if ret == errno.EINVAL: |
| _validate_fs_name(name) |
| _validate_snap_name(origin) |
| raise lzc_exc.PropertyInvalid(name) |
| if ret == errno.EXDEV: |
| raise lzc_exc.PoolsDiffer(name) |
| if ret == errno.EEXIST: |
| raise lzc_exc.FilesystemExists(name) |
| if ret == errno.ENOENT: |
| if not _is_valid_snap_name(origin): |
| raise lzc_exc.SnapshotNameInvalid(origin) |
| raise lzc_exc.DatasetNotFound(name) |
| raise _generic_exception(ret, name, "Failed to create clone") |
| |
| |
| def lzc_rollback_translate_error(ret, name): |
| if ret == 0: |
| return |
| if ret == errno.ESRCH: |
| raise lzc_exc.SnapshotNotFound(name) |
| if ret == errno.EINVAL: |
| _validate_fs_name(name) |
| raise lzc_exc.NameInvalid(name) |
| if ret == errno.ENOENT: |
| if not _is_valid_fs_name(name): |
| raise lzc_exc.NameInvalid(name) |
| else: |
| raise lzc_exc.FilesystemNotFound(name) |
| raise _generic_exception(ret, name, "Failed to rollback") |
| |
| |
| def lzc_rollback_to_translate_error(ret, name, snap): |
| if ret == errno.EEXIST: |
| raise lzc_exc.SnapshotNotLatest(snap) |
| else: |
| lzc_rollback_translate_error(ret, name) |
| |
| |
| def lzc_snapshot_translate_errors(ret, errlist, snaps, props): |
| if ret == 0: |
| return |
| |
| def _map(ret, name): |
| if ret == errno.EXDEV: |
| pool_names = iter(map(_pool_name, snaps)) |
| pool_name = next(pool_names, None) |
| same_pool = all(x == pool_name for x in pool_names) |
| if same_pool: |
| return lzc_exc.DuplicateSnapshots(name) |
| else: |
| return lzc_exc.PoolsDiffer(name) |
| elif ret == errno.EINVAL: |
| if any(not _is_valid_snap_name(s) for s in snaps): |
| return lzc_exc.NameInvalid(name) |
| elif any(len(s) > MAXNAMELEN for s in snaps): |
| return lzc_exc.NameTooLong(name) |
| else: |
| return lzc_exc.PropertyInvalid(name) |
| |
| if ret == errno.EEXIST: |
| return lzc_exc.SnapshotExists(name) |
| if ret == errno.ENOENT: |
| return lzc_exc.FilesystemNotFound(name) |
| return _generic_exception(ret, name, "Failed to create snapshot") |
| |
| _handle_err_list(ret, errlist, snaps, lzc_exc.SnapshotFailure, _map) |
| |
| |
| def lzc_destroy_snaps_translate_errors(ret, errlist, snaps, defer): |
| if ret == 0: |
| return |
| |
| def _map(ret, name): |
| if ret == errno.EEXIST: |
| return lzc_exc.SnapshotIsCloned(name) |
| if ret == errno.ENOENT: |
| return lzc_exc.PoolNotFound(name) |
| if ret == errno.EBUSY: |
| return lzc_exc.SnapshotIsHeld(name) |
| return _generic_exception(ret, name, "Failed to destroy snapshot") |
| |
| _handle_err_list( |
| ret, errlist, snaps, lzc_exc.SnapshotDestructionFailure, _map) |
| |
| |
| def lzc_bookmark_translate_errors(ret, errlist, bookmarks): |
| |
| if ret == 0: |
| return |
| |
| def _map(ret, name): |
| source = bookmarks[name] |
| if ret == errno.EINVAL: |
| if name: |
| pool_names = map(_pool_name, bookmarks.keys()) |
| |
| # use _validate* functions for MAXNAMELEN check |
| try: |
| _validate_bmark_name(name) |
| except lzc_exc.ZFSError as e: |
| return e |
| |
| try: |
| _validate_snap_name(source) |
| source_is_snap = True |
| except lzc_exc.ZFSError: |
| source_is_snap = False |
| try: |
| _validate_bmark_name(source) |
| source_is_bmark = True |
| except lzc_exc.ZFSError: |
| source_is_bmark = False |
| if not source_is_snap and not source_is_bmark: |
| return lzc_exc.BookmarkSourceInvalid(source) |
| |
| if any(x != _pool_name(name) for x in pool_names): |
| return lzc_exc.PoolsDiffer(name) |
| else: |
| invalid_names = [ |
| b for b in bookmarks.keys() if not _is_valid_bmark_name(b)] |
| if invalid_names: |
| return lzc_exc.BookmarkNameInvalid(invalid_names[0]) |
| if ret == errno.EEXIST: |
| return lzc_exc.BookmarkExists(name) |
| if ret == errno.ENOENT: |
| return lzc_exc.SnapshotNotFound(name) |
| if ret == errno.ENOTSUP: |
| return lzc_exc.BookmarkNotSupported(name) |
| if ret == zfs_errno.ZFS_ERR_BOOKMARK_SOURCE_NOT_ANCESTOR: |
| return lzc_exc.BookmarkMismatch(source) |
| return _generic_exception(ret, name, "Failed to create bookmark") |
| |
| _handle_err_list( |
| ret, errlist, bookmarks.keys(), lzc_exc.BookmarkFailure, _map) |
| |
| |
| def lzc_get_bookmarks_translate_error(ret, fsname, props): |
| if ret == 0: |
| return |
| if ret == errno.ENOENT: |
| raise lzc_exc.FilesystemNotFound(fsname) |
| raise _generic_exception(ret, fsname, "Failed to list bookmarks") |
| |
| |
| def lzc_destroy_bookmarks_translate_errors(ret, errlist, bookmarks): |
| if ret == 0: |
| return |
| |
| def _map(ret, name): |
| if ret == errno.EINVAL: |
| return lzc_exc.NameInvalid(name) |
| return _generic_exception(ret, name, "Failed to destroy bookmark") |
| |
| _handle_err_list( |
| ret, errlist, bookmarks, lzc_exc.BookmarkDestructionFailure, _map) |
| |
| |
| def lzc_snaprange_space_translate_error(ret, firstsnap, lastsnap): |
| if ret == 0: |
| return |
| if ret == errno.EXDEV and firstsnap is not None: |
| if _pool_name(firstsnap) != _pool_name(lastsnap): |
| raise lzc_exc.PoolsDiffer(lastsnap) |
| else: |
| raise lzc_exc.SnapshotMismatch(lastsnap) |
| if ret == errno.EINVAL: |
| if not _is_valid_snap_name(firstsnap): |
| raise lzc_exc.NameInvalid(firstsnap) |
| elif not _is_valid_snap_name(lastsnap): |
| raise lzc_exc.NameInvalid(lastsnap) |
| elif len(firstsnap) > MAXNAMELEN: |
| raise lzc_exc.NameTooLong(firstsnap) |
| elif len(lastsnap) > MAXNAMELEN: |
| raise lzc_exc.NameTooLong(lastsnap) |
| elif _pool_name(firstsnap) != _pool_name(lastsnap): |
| raise lzc_exc.PoolsDiffer(lastsnap) |
| else: |
| raise lzc_exc.SnapshotMismatch(lastsnap) |
| if ret == errno.ENOENT: |
| raise lzc_exc.SnapshotNotFound(lastsnap) |
| raise _generic_exception( |
| ret, lastsnap, "Failed to calculate space used by range of snapshots") |
| |
| |
| def lzc_hold_translate_errors(ret, errlist, holds, fd): |
| if ret == 0: |
| return |
| |
| def _map(ret, name): |
| if ret == errno.EXDEV: |
| return lzc_exc.PoolsDiffer(name) |
| elif ret == errno.EINVAL: |
| if name: |
| pool_names = map(_pool_name, holds.keys()) |
| if not _is_valid_snap_name(name): |
| return lzc_exc.NameInvalid(name) |
| elif len(name) > MAXNAMELEN: |
| return lzc_exc.NameTooLong(name) |
| elif any(x != _pool_name(name) for x in pool_names): |
| return lzc_exc.PoolsDiffer(name) |
| else: |
| invalid_names = [ |
| b for b in holds.keys() if not _is_valid_snap_name(b)] |
| if invalid_names: |
| return lzc_exc.NameInvalid(invalid_names[0]) |
| fs_name = None |
| hold_name = None |
| pool_name = None |
| if name is not None: |
| fs_name = _fs_name(name) |
| pool_name = _pool_name(name) |
| hold_name = holds[name] |
| if ret == errno.ENOENT: |
| return lzc_exc.FilesystemNotFound(fs_name) |
| if ret == errno.EEXIST: |
| return lzc_exc.HoldExists(name) |
| if ret == errno.E2BIG: |
| return lzc_exc.NameTooLong(hold_name) |
| if ret == errno.ENOTSUP: |
| return lzc_exc.FeatureNotSupported(pool_name) |
| return _generic_exception(ret, name, "Failed to hold snapshot") |
| |
| if ret == errno.EBADF: |
| raise lzc_exc.BadHoldCleanupFD() |
| _handle_err_list(ret, errlist, holds.keys(), lzc_exc.HoldFailure, _map) |
| |
| |
| def lzc_release_translate_errors(ret, errlist, holds): |
| if ret == 0: |
| return |
| for snap in holds: |
| hold_list = holds[snap] |
| if not isinstance(hold_list, list): |
| raise lzc_exc.TypeError('holds must be in a list') |
| |
| def _map(ret, name): |
| if ret == errno.EXDEV: |
| return lzc_exc.PoolsDiffer(name) |
| elif ret == errno.EINVAL: |
| if name: |
| pool_names = map(_pool_name, holds.keys()) |
| if not _is_valid_snap_name(name): |
| return lzc_exc.NameInvalid(name) |
| elif len(name) > MAXNAMELEN: |
| return lzc_exc.NameTooLong(name) |
| elif any(x != _pool_name(name) for x in pool_names): |
| return lzc_exc.PoolsDiffer(name) |
| else: |
| invalid_names = [ |
| b for b in holds.keys() if not _is_valid_snap_name(b)] |
| if invalid_names: |
| return lzc_exc.NameInvalid(invalid_names[0]) |
| elif ret == errno.ENOENT: |
| return lzc_exc.HoldNotFound(name) |
| elif ret == errno.E2BIG: |
| tag_list = holds[name] |
| too_long_tags = [t for t in tag_list if len(t) > MAXNAMELEN] |
| return lzc_exc.NameTooLong(too_long_tags[0]) |
| elif ret == errno.ENOTSUP: |
| pool_name = None |
| if name is not None: |
| pool_name = _pool_name(name) |
| return lzc_exc.FeatureNotSupported(pool_name) |
| else: |
| return _generic_exception( |
| ret, name, "Failed to release snapshot hold") |
| |
| _handle_err_list( |
| ret, errlist, holds.keys(), lzc_exc.HoldReleaseFailure, _map) |
| |
| |
| def lzc_get_holds_translate_error(ret, snapname): |
| if ret == 0: |
| return |
| if ret == errno.EINVAL: |
| _validate_snap_name(snapname) |
| if ret == errno.ENOENT: |
| raise lzc_exc.SnapshotNotFound(snapname) |
| if ret == errno.ENOTSUP: |
| raise lzc_exc.FeatureNotSupported(_pool_name(snapname)) |
| raise _generic_exception(ret, snapname, "Failed to get holds on snapshot") |
| |
| |
| def lzc_send_translate_error(ret, snapname, fromsnap, fd, flags): |
| if ret == 0: |
| return |
| if ret == errno.EXDEV and fromsnap is not None: |
| if _pool_name(fromsnap) != _pool_name(snapname): |
| raise lzc_exc.PoolsDiffer(snapname) |
| else: |
| raise lzc_exc.SnapshotMismatch(snapname) |
| elif ret == errno.EINVAL: |
| if (fromsnap is not None and not _is_valid_snap_name(fromsnap) and |
| not _is_valid_bmark_name(fromsnap)): |
| raise lzc_exc.NameInvalid(fromsnap) |
| elif (not _is_valid_snap_name(snapname) and |
| not _is_valid_fs_name(snapname)): |
| raise lzc_exc.NameInvalid(snapname) |
| elif fromsnap is not None and len(fromsnap) > MAXNAMELEN: |
| raise lzc_exc.NameTooLong(fromsnap) |
| elif len(snapname) > MAXNAMELEN: |
| raise lzc_exc.NameTooLong(snapname) |
| elif (fromsnap is not None and |
| _pool_name(fromsnap) != _pool_name(snapname)): |
| raise lzc_exc.PoolsDiffer(snapname) |
| elif ret == errno.ENOENT: |
| if (fromsnap is not None and not _is_valid_snap_name(fromsnap) and |
| not _is_valid_bmark_name(fromsnap)): |
| raise lzc_exc.NameInvalid(fromsnap) |
| raise lzc_exc.SnapshotNotFound(snapname) |
| elif ret == errno.ENAMETOOLONG: |
| if fromsnap is not None and len(fromsnap) > MAXNAMELEN: |
| raise lzc_exc.NameTooLong(fromsnap) |
| else: |
| raise lzc_exc.NameTooLong(snapname) |
| raise lzc_exc.StreamIOError(ret) |
| |
| |
| def lzc_send_space_translate_error(ret, snapname, fromsnap): |
| if ret == 0: |
| return |
| if ret == errno.EXDEV and fromsnap is not None: |
| if _pool_name(fromsnap) != _pool_name(snapname): |
| raise lzc_exc.PoolsDiffer(snapname) |
| else: |
| raise lzc_exc.SnapshotMismatch(snapname) |
| elif ret == errno.EINVAL: |
| if fromsnap is not None and not _is_valid_snap_name(fromsnap): |
| raise lzc_exc.NameInvalid(fromsnap) |
| elif not _is_valid_snap_name(snapname): |
| raise lzc_exc.NameInvalid(snapname) |
| elif fromsnap is not None and len(fromsnap) > MAXNAMELEN: |
| raise lzc_exc.NameTooLong(fromsnap) |
| elif len(snapname) > MAXNAMELEN: |
| raise lzc_exc.NameTooLong(snapname) |
| elif (fromsnap is not None and |
| _pool_name(fromsnap) != _pool_name(snapname)): |
| raise lzc_exc.PoolsDiffer(snapname) |
| elif ret == errno.ENOENT and fromsnap is not None: |
| if not _is_valid_snap_name(fromsnap): |
| raise lzc_exc.NameInvalid(fromsnap) |
| if ret == errno.ENOENT: |
| raise lzc_exc.SnapshotNotFound(snapname) |
| raise _generic_exception( |
| ret, snapname, "Failed to estimate backup stream size") |
| |
| |
| def lzc_receive_translate_errors( |
| ret, snapname, fd, force, raw, resumable, embedded, origin, properrs |
| ): |
| if ret == 0: |
| if properrs is not None and len(properrs) > 0: |
| def _map(ret, name): |
| if ret == errno.EINVAL: |
| return lzc_exc.PropertyInvalid(name) |
| if ret == zfs_errno.ZFS_ERR_BADPROP: |
| return lzc_exc.PropertyInvalid(name) |
| return _generic_exception(ret, name, "Failed to set property") |
| _handle_err_list( |
| errno.EINVAL, properrs, [snapname], |
| lzc_exc.ReceivePropertyFailure, _map) |
| else: |
| return |
| if ret == errno.EINVAL: |
| if (not _is_valid_snap_name(snapname) and |
| not _is_valid_fs_name(snapname)): |
| raise lzc_exc.NameInvalid(snapname) |
| elif len(snapname) > MAXNAMELEN: |
| raise lzc_exc.NameTooLong(snapname) |
| elif origin is not None and not _is_valid_snap_name(origin): |
| raise lzc_exc.NameInvalid(origin) |
| elif resumable: |
| raise lzc_exc.StreamFeatureInvalid() |
| elif embedded and not raw: |
| raise lzc_exc.StreamFeatureIncompatible() |
| else: |
| raise lzc_exc.BadStream() |
| if ret == errno.ENOENT: |
| if not _is_valid_snap_name(snapname): |
| raise lzc_exc.NameInvalid(snapname) |
| else: |
| raise lzc_exc.DatasetNotFound(snapname) |
| if ret == errno.EEXIST: |
| raise lzc_exc.DatasetExists(snapname) |
| if ret == errno.ENOTSUP: |
| raise lzc_exc.StreamFeatureNotSupported() |
| if ret == errno.ENODEV: |
| raise lzc_exc.StreamMismatch(_fs_name(snapname)) |
| if ret == errno.ETXTBSY: |
| raise lzc_exc.DestinationModified(_fs_name(snapname)) |
| if ret == errno.EBUSY: |
| raise lzc_exc.DatasetBusy(_fs_name(snapname)) |
| if ret == errno.ENOSPC: |
| raise lzc_exc.NoSpace(_fs_name(snapname)) |
| if ret == errno.EDQUOT: |
| raise lzc_exc.QuotaExceeded(_fs_name(snapname)) |
| if ret == errno.ENAMETOOLONG: |
| raise lzc_exc.NameTooLong(snapname) |
| if ret == errno.EROFS: |
| raise lzc_exc.ReadOnlyPool(_pool_name(snapname)) |
| if ret == errno.EAGAIN: |
| raise lzc_exc.SuspendedPool(_pool_name(snapname)) |
| if ret == ECKSUM: |
| raise lzc_exc.BadStream() |
| if ret == ZFS_ERR_WRONG_PARENT: |
| raise lzc_exc.WrongParent(_fs_name(snapname)) |
| if ret == zfs_errno.ZFS_ERR_STREAM_TRUNCATED: |
| raise lzc_exc.StreamTruncated() |
| if ret == zfs_errno.ZFS_ERR_BADPROP: |
| raise lzc_exc.PropertyInvalid(snapname) |
| |
| raise lzc_exc.StreamIOError(ret) |
| |
| |
| def lzc_promote_translate_error(ret, name): |
| if ret == 0: |
| return |
| if ret == errno.EINVAL: |
| _validate_fs_name(name) |
| raise lzc_exc.NotClone(name) |
| if ret == errno.ENOTSOCK: |
| raise lzc_exc.NotClone(name) |
| if ret == errno.ENOENT: |
| raise lzc_exc.FilesystemNotFound(name) |
| if ret == errno.EEXIST: |
| raise lzc_exc.SnapshotExists(name) |
| raise _generic_exception(ret, name, "Failed to promote dataset") |
| |
| |
| def lzc_change_key_translate_error(ret, name): |
| if ret == 0: |
| return |
| if ret == errno.EINVAL: |
| _validate_fs_name(name) |
| raise lzc_exc.PropertyInvalid(name) |
| if ret == errno.ENOENT: |
| raise lzc_exc.FilesystemNotFound(name) |
| if ret == errno.EACCES: |
| raise lzc_exc.EncryptionKeyNotLoaded() |
| raise _generic_exception(ret, name, "Failed to change encryption key") |
| |
| |
| def lzc_load_key_translate_error(ret, name, noop): |
| if ret == 0: |
| return |
| if ret == errno.EINVAL: |
| _validate_fs_name(name) |
| raise lzc_exc.PropertyInvalid(name) |
| if ret == errno.ENOENT: |
| raise lzc_exc.FilesystemNotFound(name) |
| if ret == errno.EACCES: |
| raise lzc_exc.EncryptionKeyInvalid() |
| if ret == errno.EEXIST: |
| raise lzc_exc.EncryptionKeyAlreadyLoaded() |
| if noop: |
| raise _generic_exception(ret, name, "Failed to load encryption key") |
| else: |
| raise _generic_exception(ret, name, "Failed to verify encryption key") |
| |
| |
| def lzc_unload_key_translate_error(ret, name): |
| if ret == 0: |
| return |
| if ret == errno.EINVAL: |
| _validate_fs_name(name) |
| raise lzc_exc.PropertyInvalid(name) |
| if ret == errno.ENOENT: |
| raise lzc_exc.FilesystemNotFound(name) |
| if ret == errno.EACCES: |
| raise lzc_exc.EncryptionKeyNotLoaded() |
| raise _generic_exception(ret, name, "Failed to unload encryption key") |
| |
| |
| def lzc_sync_translate_error(ret, name): |
| if ret == 0: |
| return |
| if ret == errno.ENOENT: |
| raise lzc_exc.PoolNotFound(name) |
| raise _generic_exception(ret, name, "Failed to sync pool") |
| |
| |
| def lzc_reopen_translate_error(ret, name): |
| if ret == 0: |
| return |
| if ret == errno.ENOENT: |
| raise lzc_exc.PoolNotFound(name) |
| raise _generic_exception(ret, name, "Failed to reopen pool") |
| |
| |
| def lzc_channel_program_translate_error(ret, name, error): |
| if ret == 0: |
| return |
| if ret == errno.ENOENT: |
| raise lzc_exc.PoolNotFound(name) |
| if ret == ETIME: |
| raise lzc_exc.ZCPTimeout() |
| if ret == errno.ENOMEM: |
| raise lzc_exc.ZCPMemoryError() |
| if ret == errno.ENOSPC: |
| raise lzc_exc.ZCPSpaceError() |
| if ret == errno.EPERM: |
| raise lzc_exc.ZCPPermissionError() |
| if ret == ECHRNG: |
| raise lzc_exc.ZCPRuntimeError(error) |
| if ret == errno.EINVAL: |
| if error is None: |
| raise lzc_exc.ZCPLimitInvalid() |
| else: |
| raise lzc_exc.ZCPSyntaxError(error) |
| raise _generic_exception(ret, name, "Failed to execute channel program") |
| |
| |
| def lzc_pool_checkpoint_translate_error(ret, name, discard=False): |
| if ret == 0: |
| return |
| if ret == errno.ENOENT: |
| raise lzc_exc.PoolNotFound(name) |
| if ret == ZFS_ERR_CHECKPOINT_EXISTS: |
| raise lzc_exc.CheckpointExists() |
| if ret == ZFS_ERR_NO_CHECKPOINT: |
| raise lzc_exc.CheckpointNotFound() |
| if ret == ZFS_ERR_DISCARDING_CHECKPOINT: |
| raise lzc_exc.CheckpointDiscarding() |
| if ret == ZFS_ERR_DEVRM_IN_PROGRESS: |
| raise lzc_exc.DeviceRemovalRunning() |
| if ret == ZFS_ERR_VDEV_TOO_BIG: |
| raise lzc_exc.DeviceTooBig() |
| if discard: |
| raise _generic_exception( |
| ret, name, "Failed to discard pool checkpoint") |
| else: |
| raise _generic_exception(ret, name, "Failed to create pool checkpoint") |
| |
| |
| def lzc_pool_checkpoint_discard_translate_error(ret, name): |
| lzc_pool_checkpoint_translate_error(ret, name, discard=True) |
| |
| |
| def lzc_rename_translate_error(ret, source, target): |
| if ret == 0: |
| return |
| if ret == errno.EINVAL: |
| _validate_fs_name(source) |
| _validate_fs_name(target) |
| if _pool_name(source) != _pool_name(target): |
| raise lzc_exc.PoolsDiffer(source) |
| if ret == errno.EEXIST: |
| raise lzc_exc.FilesystemExists(target) |
| if ret == errno.ENOENT: |
| raise lzc_exc.FilesystemNotFound(source) |
| if ret == ZFS_ERR_WRONG_PARENT: |
| raise lzc_exc.WrongParent(target) |
| raise _generic_exception(ret, source, "Failed to rename dataset") |
| |
| |
| def lzc_destroy_translate_error(ret, name): |
| if ret == 0: |
| return |
| if ret == errno.EINVAL: |
| _validate_fs_name(name) |
| if ret == errno.ENOENT: |
| raise lzc_exc.FilesystemNotFound(name) |
| raise _generic_exception(ret, name, "Failed to destroy dataset") |
| |
| |
| def lzc_inherit_prop_translate_error(ret, name, prop): |
| if ret == 0: |
| return |
| if ret == errno.EINVAL: |
| _validate_fs_name(name) |
| raise lzc_exc.PropertyInvalid(prop) |
| if ret == errno.ENOENT: |
| raise lzc_exc.DatasetNotFound(name) |
| raise _generic_exception(ret, name, "Failed to inherit a property") |
| |
| |
| def lzc_set_prop_translate_error(ret, name, prop, val): |
| if ret == 0: |
| return |
| if ret == errno.EINVAL: |
| _validate_fs_or_snap_name(name) |
| raise lzc_exc.PropertyInvalid(prop) |
| if ret == errno.ENOENT: |
| raise lzc_exc.DatasetNotFound(name) |
| raise _generic_exception(ret, name, "Failed to set a property") |
| |
| |
| def lzc_get_props_translate_error(ret, name): |
| if ret == 0: |
| return |
| if ret == errno.EINVAL: |
| _validate_fs_or_snap_name(name) |
| if ret == errno.ENOENT: |
| raise lzc_exc.DatasetNotFound(name) |
| raise _generic_exception(ret, name, "Failed to get properties") |
| |
| |
| def lzc_list_children_translate_error(ret, name): |
| if ret == 0: |
| return |
| if ret == errno.EINVAL: |
| _validate_fs_name(name) |
| raise _generic_exception(ret, name, "Error while iterating children") |
| |
| |
| def lzc_list_snaps_translate_error(ret, name): |
| if ret == 0: |
| return |
| if ret == errno.EINVAL: |
| _validate_fs_name(name) |
| raise _generic_exception(ret, name, "Error while iterating snapshots") |
| |
| |
| def lzc_list_translate_error(ret, name, opts): |
| if ret == 0: |
| return |
| if ret == errno.ENOENT: |
| raise lzc_exc.DatasetNotFound(name) |
| if ret == errno.EINVAL: |
| _validate_fs_or_snap_name(name) |
| raise _generic_exception(ret, name, "Error obtaining a list") |
| |
| |
| def _handle_err_list(ret, errlist, names, exception, mapper): |
| ''' |
| Convert one or more errors from an operation into the requested exception. |
| |
| :param int ret: the overall return code. |
| :param errlist: the dictionary that maps entity names to their specific |
| error codes. |
| :type errlist: dict of bytes:int |
| :param names: the list of all names of the entities on which the operation |
| was attempted. |
| :param type exception: the type of the exception to raise if an error |
| occurred. The exception should be a subclass of |
| ``MultipleOperationsFailure``. |
| :param function mapper: the function that maps an error code and a name to |
| a Python exception. |
| |
| Unless ``ret`` is zero this function will raise the ``exception``. |
| If the ``errlist`` is not empty, then the compound exception will contain |
| a list of exceptions corresponding to each individual error code in the |
| ``errlist``. |
| Otherwise, the ``exception`` will contain a list with a single exception |
| corresponding to the ``ret`` value. If the ``names`` list contains only one |
| element, that is, the operation was attempted on a single entity, then the |
| name of that entity is passed to the ``mapper``. |
| If the operation was attempted on multiple entities, but the ``errlist`` |
| is empty, then we can not know which entity caused the error and, thus, |
| ``None`` is used as a name to signify that fact. |
| |
| .. note:: |
| Note that the ``errlist`` can contain a special element with a key of |
| "N_MORE_ERRORS". |
| That element means that there were too many errors to place on the |
| ``errlist``. |
| Those errors are suppressed and only their count is provided as a |
| value of the special ``N_MORE_ERRORS`` element. |
| ''' |
| if ret == 0: |
| return |
| |
| if len(errlist) == 0: |
| suppressed_count = 0 |
| names = list(zip(names, range(2))) |
| if len(names) == 1: |
| name, _ = names[0] |
| else: |
| name = None |
| errors = [mapper(ret, name)] |
| else: |
| errors = [] |
| suppressed_count = errlist.pop('N_MORE_ERRORS', 0) |
| for name in errlist: |
| err = errlist[name] |
| errors.append(mapper(err, name)) |
| |
| raise exception(errors, suppressed_count) |
| |
| |
| def _pool_name(name): |
| ''' |
| Extract a pool name from the given dataset or bookmark name. |
| |
| '/' separates dataset name components. |
| '@' separates a snapshot name from the rest of the dataset name. |
| '#' separates a bookmark name from the rest of the dataset name. |
| ''' |
| return re.split(b'[/@#]', name, 1)[0] |
| |
| |
| def _fs_name(name): |
| ''' |
| Extract a dataset name from the given snapshot or bookmark name. |
| |
| '@' separates a snapshot name from the rest of the dataset name. |
| '#' separates a bookmark name from the rest of the dataset name. |
| ''' |
| return re.split(b'[@#]', name, 1)[0] |
| |
| |
| def _is_valid_name_component(component): |
| allowed = string.ascii_letters + string.digits + u'-_.: ' |
| return component and all(x in allowed.encode() for x in component) |
| |
| |
| def _is_valid_fs_name(name): |
| return name and all(_is_valid_name_component(c) for c in name.split(b'/')) |
| |
| |
| def _is_valid_snap_name(name): |
| parts = name.split(b'@') |
| return (len(parts) == 2 and _is_valid_fs_name(parts[0]) and |
| _is_valid_name_component(parts[1])) |
| |
| |
| def _is_valid_bmark_name(name): |
| parts = name.split(b'#') |
| return (len(parts) == 2 and _is_valid_fs_name(parts[0]) and |
| _is_valid_name_component(parts[1])) |
| |
| |
| def _validate_fs_name(name): |
| if not _is_valid_fs_name(name): |
| raise lzc_exc.FilesystemNameInvalid(name) |
| elif len(name) > MAXNAMELEN: |
| raise lzc_exc.NameTooLong(name) |
| |
| |
| def _validate_snap_name(name): |
| if not _is_valid_snap_name(name): |
| raise lzc_exc.SnapshotNameInvalid(name) |
| elif len(name) > MAXNAMELEN: |
| raise lzc_exc.NameTooLong(name) |
| |
| |
| def _validate_bmark_name(name): |
| if not _is_valid_bmark_name(name): |
| raise lzc_exc.BookmarkNameInvalid(name) |
| elif len(name) > MAXNAMELEN: |
| raise lzc_exc.NameTooLong(name) |
| |
| |
| def _validate_fs_or_snap_name(name): |
| if not _is_valid_fs_name(name) and not _is_valid_snap_name(name): |
| raise lzc_exc.NameInvalid(name) |
| elif len(name) > MAXNAMELEN: |
| raise lzc_exc.NameTooLong(name) |
| |
| |
| def _generic_exception(err, name, message): |
| if err in _error_to_exception: |
| return _error_to_exception[err](name) |
| else: |
| return lzc_exc.ZFSGenericError(err, message, name) |
| |
| |
| _error_to_exception = {e.errno: e for e in [ |
| lzc_exc.ZIOError, |
| lzc_exc.NoSpace, |
| lzc_exc.QuotaExceeded, |
| lzc_exc.DatasetBusy, |
| lzc_exc.NameTooLong, |
| lzc_exc.ReadOnlyPool, |
| lzc_exc.SuspendedPool, |
| lzc_exc.PoolsDiffer, |
| lzc_exc.PropertyNotSupported, |
| ]} |
| |
| |
| # vim: softtabstop=4 tabstop=4 expandtab shiftwidth=4 |
