import shutil
import stat
import subprocess
+import sys
import tempfile
import time
import uuid
with zfs_mount(fs) as mntdir:
with tempfile.NamedTemporaryFile(dir=mntdir) as f:
for i in range(1024):
- f.write('x' * 1024)
+ f.write(b'x' * 1024)
f.flush()
yield f.name
def _maybe_snap(snap):
if snap is not None:
if not snap.startswith(fs):
- snap = fs + '@' + snap
+ snap = fs + b'@' + snap
lzc.lzc_snapshot([snap])
return snap
@contextlib.contextmanager
def encrypted_filesystem():
- fs = ZFSTest.pool.getFilesystem("encrypted")
+ fs = ZFSTest.pool.getFilesystem(b"encrypted")
name = fs.getName()
filename = None
key = os.urandom(lzc.WRAPPING_KEY_LEN)
with tempfile.NamedTemporaryFile() as f:
filename = "file://" + f.name
props = {
- "encryption": lzc.zio_encrypt.ZIO_CRYPT_AES_256_CCM,
- "keylocation": filename,
- "keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW,
+ b"encryption": lzc.zio_encrypt.ZIO_CRYPT_AES_256_CCM,
+ b"keylocation": filename.encode(),
+ b"keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW,
}
lzc.lzc_create(name, 'zfs', props=props, key=key)
yield (name, key)
class ZFSTest(unittest.TestCase):
POOL_FILE_SIZE = 128 * 1024 * 1024
- FILESYSTEMS = ['fs1', 'fs2', 'fs1/fs']
+ FILESYSTEMS = [b'fs1', b'fs2', b'fs1/fs']
pool = None
misc_pool = None
self.assertExists(ZFSTest.readonly_pool.makeName())
def test_exists_failure(self):
- self.assertNotExists(ZFSTest.pool.makeName('nonexistent'))
+ self.assertNotExists(ZFSTest.pool.makeName(b'nonexistent'))
def test_create_fs(self):
- name = ZFSTest.pool.makeName("fs1/fs/test1")
+ name = ZFSTest.pool.makeName(b"fs1/fs/test1")
lzc.lzc_create(name)
self.assertExists(name)
def test_create_zvol(self):
- name = ZFSTest.pool.makeName("fs1/fs/zvol")
- props = {"volsize": 1024 * 1024}
+ name = ZFSTest.pool.makeName(b"fs1/fs/zvol")
+ props = {b"volsize": 1024 * 1024}
lzc.lzc_create(name, ds_type='zvol', props=props)
self.assertExists(name)
time.sleep(0.1)
def test_create_fs_with_prop(self):
- name = ZFSTest.pool.makeName("fs1/fs/test2")
- props = {"atime": 0}
+ name = ZFSTest.pool.makeName(b"fs1/fs/test2")
+ props = {b"atime": 0}
lzc.lzc_create(name, props=props)
self.assertExists(name)
def test_create_fs_wrong_ds_type(self):
- name = ZFSTest.pool.makeName("fs1/fs/test1")
+ name = ZFSTest.pool.makeName(b"fs1/fs/test1")
with self.assertRaises(lzc_exc.DatasetTypeInvalid):
lzc.lzc_create(name, ds_type='wrong')
# XXX: we should have a way to raise lzc_exc.WrongParent from lzc_create()
@unittest.expectedFailure
def test_create_fs_below_zvol(self):
- name = ZFSTest.pool.makeName("fs1/fs/zvol")
- props = {"volsize": 1024 * 1024}
+ name = ZFSTest.pool.makeName(b"fs1/fs/zvol")
+ props = {b"volsize": 1024 * 1024}
lzc.lzc_create(name, ds_type='zvol', props=props)
with self.assertRaises(lzc_exc.WrongParent):
- lzc.lzc_create(name + '/fs')
+ lzc.lzc_create(name + b'/fs')
def test_create_fs_duplicate(self):
- name = ZFSTest.pool.makeName("fs1/fs/test6")
+ name = ZFSTest.pool.makeName(b"fs1/fs/test6")
lzc.lzc_create(name)
lzc.lzc_create(name)
def test_create_fs_in_ro_pool(self):
- name = ZFSTest.readonly_pool.makeName("fs")
+ name = ZFSTest.readonly_pool.makeName(b"fs")
with self.assertRaises(lzc_exc.ReadOnlyPool):
lzc.lzc_create(name)
def test_create_fs_without_parent(self):
- name = ZFSTest.pool.makeName("fs1/nonexistent/test")
+ name = ZFSTest.pool.makeName(b"fs1/nonexistent/test")
with self.assertRaises(lzc_exc.ParentNotFound):
lzc.lzc_create(name)
self.assertNotExists(name)
def test_create_fs_in_nonexistent_pool(self):
- name = "no-such-pool/fs"
+ name = b"no-such-pool/fs"
with self.assertRaises(lzc_exc.ParentNotFound):
lzc.lzc_create(name)
self.assertNotExists(name)
def test_create_fs_with_invalid_prop(self):
- name = ZFSTest.pool.makeName("fs1/fs/test3")
- props = {"BOGUS": 0}
+ name = ZFSTest.pool.makeName(b"fs1/fs/test3")
+ props = {b"BOGUS": 0}
with self.assertRaises(lzc_exc.PropertyInvalid):
lzc.lzc_create(name, 'zfs', props)
self.assertNotExists(name)
def test_create_fs_with_invalid_prop_type(self):
- name = ZFSTest.pool.makeName("fs1/fs/test4")
- props = {"recordsize": "128k"}
+ name = ZFSTest.pool.makeName(b"fs1/fs/test4")
+ props = {b"recordsize": b"128k"}
with self.assertRaises(lzc_exc.PropertyInvalid):
lzc.lzc_create(name, 'zfs', props)
self.assertNotExists(name)
def test_create_fs_with_invalid_prop_val(self):
- name = ZFSTest.pool.makeName("fs1/fs/test5")
- props = {"atime": 20}
+ name = ZFSTest.pool.makeName(b"fs1/fs/test5")
+ props = {b"atime": 20}
with self.assertRaises(lzc_exc.PropertyInvalid):
lzc.lzc_create(name, 'zfs', props)
self.assertNotExists(name)
def test_create_fs_with_invalid_name(self):
- name = ZFSTest.pool.makeName("@badname")
+ name = ZFSTest.pool.makeName(b"@badname")
with self.assertRaises(lzc_exc.NameInvalid):
lzc.lzc_create(name)
self.assertNotExists(name)
def test_create_fs_with_invalid_pool_name(self):
- name = "bad!pool/fs"
+ name = b"bad!pool/fs"
with self.assertRaises(lzc_exc.NameInvalid):
lzc.lzc_create(name)
self.assertNotExists(name)
def test_create_encrypted_fs(self):
- fs = ZFSTest.pool.getFilesystem("encrypted")
+ fs = ZFSTest.pool.getFilesystem(b"encrypted")
name = fs.getName()
filename = None
with tempfile.NamedTemporaryFile() as f:
filename = "file://" + f.name
props = {
- "encryption": lzc.zio_encrypt.ZIO_CRYPT_AES_256_CCM,
- "keylocation": filename,
- "keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW,
+ b"encryption": lzc.zio_encrypt.ZIO_CRYPT_AES_256_CCM,
+ b"keylocation": filename.encode(),
+ b"keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW,
}
key = os.urandom(lzc.WRAPPING_KEY_LEN)
lzc.lzc_create(name, 'zfs', props=props, key=key)
- self.assertEqual(fs.getProperty("encryption"), "aes-256-ccm")
+ self.assertEqual(fs.getProperty("encryption"), b"aes-256-ccm")
self.assertEqual(fs.getProperty("encryptionroot"), name)
- self.assertEqual(fs.getProperty("keylocation"), filename)
- self.assertEqual(fs.getProperty("keyformat"), "raw")
+ self.assertEqual(fs.getProperty("keylocation"), filename.encode())
+ self.assertEqual(fs.getProperty("keyformat"), b"raw")
def test_snapshot(self):
- snapname = ZFSTest.pool.makeName("@snap")
+ snapname = ZFSTest.pool.makeName(b"@snap")
snaps = [snapname]
lzc.lzc_snapshot(snaps)
lzc.lzc_snapshot([])
def test_snapshot_user_props(self):
- snapname = ZFSTest.pool.makeName("@snap")
+ snapname = ZFSTest.pool.makeName(b"@snap")
snaps = [snapname]
- props = {"user:foo": "bar"}
+ props = {b"user:foo": b"bar"}
lzc.lzc_snapshot(snaps, props)
self.assertExists(snapname)
def test_snapshot_invalid_props(self):
- snapname = ZFSTest.pool.makeName("@snap")
+ snapname = ZFSTest.pool.makeName(b"@snap")
snaps = [snapname]
- props = {"foo": "bar"}
+ props = {b"foo": b"bar"}
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
lzc.lzc_snapshot(snaps, props)
self.assertNotExists(snapname)
def test_snapshot_ro_pool(self):
- snapname1 = ZFSTest.readonly_pool.makeName("@snap")
- snapname2 = ZFSTest.readonly_pool.makeName("fs1@snap")
+ snapname1 = ZFSTest.readonly_pool.makeName(b"@snap")
+ snapname2 = ZFSTest.readonly_pool.makeName(b"fs1@snap")
snaps = [snapname1, snapname2]
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
self.assertNotExists(snapname2)
def test_snapshot_nonexistent_pool(self):
- snapname = "no-such-pool@snap"
+ snapname = b"no-such-pool@snap"
snaps = [snapname]
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
self.assertIsInstance(e, lzc_exc.FilesystemNotFound)
def test_snapshot_nonexistent_fs(self):
- snapname = ZFSTest.pool.makeName("nonexistent@snap")
+ snapname = ZFSTest.pool.makeName(b"nonexistent@snap")
snaps = [snapname]
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
self.assertIsInstance(e, lzc_exc.FilesystemNotFound)
def test_snapshot_nonexistent_and_existent_fs(self):
- snapname1 = ZFSTest.pool.makeName("@snap")
- snapname2 = ZFSTest.pool.makeName("nonexistent@snap")
+ snapname1 = ZFSTest.pool.makeName(b"@snap")
+ snapname2 = ZFSTest.pool.makeName(b"nonexistent@snap")
snaps = [snapname1, snapname2]
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
self.assertNotExists(snapname2)
def test_multiple_snapshots_nonexistent_fs(self):
- snapname1 = ZFSTest.pool.makeName("nonexistent@snap1")
- snapname2 = ZFSTest.pool.makeName("nonexistent@snap2")
+ snapname1 = ZFSTest.pool.makeName(b"nonexistent@snap1")
+ snapname2 = ZFSTest.pool.makeName(b"nonexistent@snap2")
snaps = [snapname1, snapname2]
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
self.assertNotExists(snapname2)
def test_multiple_snapshots_multiple_nonexistent_fs(self):
- snapname1 = ZFSTest.pool.makeName("nonexistent1@snap")
- snapname2 = ZFSTest.pool.makeName("nonexistent2@snap")
+ snapname1 = ZFSTest.pool.makeName(b"nonexistent1@snap")
+ snapname2 = ZFSTest.pool.makeName(b"nonexistent2@snap")
snaps = [snapname1, snapname2]
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
self.assertNotExists(snapname2)
def test_snapshot_already_exists(self):
- snapname = ZFSTest.pool.makeName("@snap")
+ snapname = ZFSTest.pool.makeName(b"@snap")
snaps = [snapname]
lzc.lzc_snapshot(snaps)
self.assertIsInstance(e, lzc_exc.SnapshotExists)
def test_multiple_snapshots_for_same_fs(self):
- snapname1 = ZFSTest.pool.makeName("@snap1")
- snapname2 = ZFSTest.pool.makeName("@snap2")
+ snapname1 = ZFSTest.pool.makeName(b"@snap1")
+ snapname2 = ZFSTest.pool.makeName(b"@snap2")
snaps = [snapname1, snapname2]
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
self.assertNotExists(snapname2)
def test_multiple_snapshots(self):
- snapname1 = ZFSTest.pool.makeName("@snap")
- snapname2 = ZFSTest.pool.makeName("fs1@snap")
+ snapname1 = ZFSTest.pool.makeName(b"@snap")
+ snapname2 = ZFSTest.pool.makeName(b"fs1@snap")
snaps = [snapname1, snapname2]
lzc.lzc_snapshot(snaps)
self.assertExists(snapname2)
def test_multiple_existing_snapshots(self):
- snapname1 = ZFSTest.pool.makeName("@snap")
- snapname2 = ZFSTest.pool.makeName("fs1@snap")
+ snapname1 = ZFSTest.pool.makeName(b"@snap")
+ snapname2 = ZFSTest.pool.makeName(b"fs1@snap")
snaps = [snapname1, snapname2]
lzc.lzc_snapshot(snaps)
self.assertIsInstance(e, lzc_exc.SnapshotExists)
def test_multiple_new_and_existing_snapshots(self):
- snapname1 = ZFSTest.pool.makeName("@snap")
- snapname2 = ZFSTest.pool.makeName("fs1@snap")
- snapname3 = ZFSTest.pool.makeName("fs2@snap")
+ snapname1 = ZFSTest.pool.makeName(b"@snap")
+ snapname2 = ZFSTest.pool.makeName(b"fs1@snap")
+ snapname3 = ZFSTest.pool.makeName(b"fs2@snap")
snaps = [snapname1, snapname2]
more_snaps = snaps + [snapname3]
self.assertNotExists(snapname3)
def test_snapshot_multiple_errors(self):
- snapname1 = ZFSTest.pool.makeName("@snap")
- snapname2 = ZFSTest.pool.makeName("nonexistent@snap")
- snapname3 = ZFSTest.pool.makeName("fs1@snap")
+ snapname1 = ZFSTest.pool.makeName(b"@snap")
+ snapname2 = ZFSTest.pool.makeName(b"nonexistent@snap")
+ snapname3 = ZFSTest.pool.makeName(b"fs1@snap")
snaps = [snapname1]
more_snaps = [snapname1, snapname2, snapname3]
self.assertNotExists(snapname3)
def test_snapshot_different_pools(self):
- snapname1 = ZFSTest.pool.makeName("@snap")
- snapname2 = ZFSTest.misc_pool.makeName("@snap")
+ snapname1 = ZFSTest.pool.makeName(b"@snap")
+ snapname2 = ZFSTest.misc_pool.makeName(b"@snap")
snaps = [snapname1, snapname2]
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
self.assertNotExists(snapname2)
def test_snapshot_different_pools_ro_pool(self):
- snapname1 = ZFSTest.pool.makeName("@snap")
- snapname2 = ZFSTest.readonly_pool.makeName("@snap")
+ snapname1 = ZFSTest.pool.makeName(b"@snap")
+ snapname2 = ZFSTest.readonly_pool.makeName(b"@snap")
snaps = [snapname1, snapname2]
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
self.assertNotExists(snapname2)
def test_snapshot_invalid_name(self):
- snapname1 = ZFSTest.pool.makeName("@bad&name")
- snapname2 = ZFSTest.pool.makeName("fs1@bad*name")
- snapname3 = ZFSTest.pool.makeName("fs2@snap")
+ snapname1 = ZFSTest.pool.makeName(b"@bad&name")
+ snapname2 = ZFSTest.pool.makeName(b"fs1@bad*name")
+ snapname3 = ZFSTest.pool.makeName(b"fs2@snap")
snaps = [snapname1, snapname2, snapname3]
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
self.assertIsNone(e.name)
def test_snapshot_too_long_complete_name(self):
- snapname1 = ZFSTest.pool.makeTooLongName("fs1@")
- snapname2 = ZFSTest.pool.makeTooLongName("fs2@")
- snapname3 = ZFSTest.pool.makeName("@snap")
+ snapname1 = ZFSTest.pool.makeTooLongName(b"fs1@")
+ snapname2 = ZFSTest.pool.makeTooLongName(b"fs2@")
+ snapname3 = ZFSTest.pool.makeName(b"@snap")
snaps = [snapname1, snapname2, snapname3]
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
self.assertIsNotNone(e.name)
def test_snapshot_too_long_snap_name(self):
- snapname1 = ZFSTest.pool.makeTooLongComponent("fs1@")
- snapname2 = ZFSTest.pool.makeTooLongComponent("fs2@")
- snapname3 = ZFSTest.pool.makeName("@snap")
+ snapname1 = ZFSTest.pool.makeTooLongComponent(b"fs1@")
+ snapname2 = ZFSTest.pool.makeTooLongComponent(b"fs2@")
+ snapname3 = ZFSTest.pool.makeName(b"@snap")
snaps = [snapname1, snapname2, snapname3]
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
self.assertIsNone(e.name)
def test_destroy_nonexistent_snapshot(self):
- lzc.lzc_destroy_snaps([ZFSTest.pool.makeName("@nonexistent")], False)
- lzc.lzc_destroy_snaps([ZFSTest.pool.makeName("@nonexistent")], True)
+ lzc.lzc_destroy_snaps([ZFSTest.pool.makeName(b"@nonexistent")], False)
+ lzc.lzc_destroy_snaps([ZFSTest.pool.makeName(b"@nonexistent")], True)
def test_destroy_snapshot_of_nonexistent_pool(self):
with self.assertRaises(lzc_exc.SnapshotDestructionFailure) as ctx:
- lzc.lzc_destroy_snaps(["no-such-pool@snap"], False)
+ lzc.lzc_destroy_snaps([b"no-such-pool@snap"], False)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.PoolNotFound)
with self.assertRaises(lzc_exc.SnapshotDestructionFailure) as ctx:
- lzc.lzc_destroy_snaps(["no-such-pool@snap"], True)
+ lzc.lzc_destroy_snaps([b"no-such-pool@snap"], True)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.PoolNotFound)
# NB: note the difference from the nonexistent pool test.
def test_destroy_snapshot_of_nonexistent_fs(self):
lzc.lzc_destroy_snaps(
- [ZFSTest.pool.makeName("nonexistent@snap")], False)
+ [ZFSTest.pool.makeName(b"nonexistent@snap")], False)
lzc.lzc_destroy_snaps(
- [ZFSTest.pool.makeName("nonexistent@snap")], True)
+ [ZFSTest.pool.makeName(b"nonexistent@snap")], True)
# Apparently the name is not checked for validity.
@unittest.expectedFailure
def test_destroy_invalid_snap_name(self):
with self.assertRaises(lzc_exc.SnapshotDestructionFailure):
lzc.lzc_destroy_snaps(
- [ZFSTest.pool.makeName("@non$&*existent")], False)
+ [ZFSTest.pool.makeName(b"@non$&*existent")], False)
with self.assertRaises(lzc_exc.SnapshotDestructionFailure):
lzc.lzc_destroy_snaps(
- [ZFSTest.pool.makeName("@non$&*existent")], True)
+ [ZFSTest.pool.makeName(b"@non$&*existent")], True)
# Apparently the full name is not checked for length.
@unittest.expectedFailure
def test_destroy_too_long_full_snap_name(self):
- snapname1 = ZFSTest.pool.makeTooLongName("fs1@")
+ snapname1 = ZFSTest.pool.makeTooLongName(b"fs1@")
snaps = [snapname1]
with self.assertRaises(lzc_exc.SnapshotDestructionFailure):
lzc.lzc_destroy_snaps(snaps, True)
def test_destroy_too_long_short_snap_name(self):
- snapname1 = ZFSTest.pool.makeTooLongComponent("fs1@")
- snapname2 = ZFSTest.pool.makeTooLongComponent("fs2@")
- snapname3 = ZFSTest.pool.makeName("@snap")
+ snapname1 = ZFSTest.pool.makeTooLongComponent(b"fs1@")
+ snapname2 = ZFSTest.pool.makeTooLongComponent(b"fs2@")
+ snapname3 = ZFSTest.pool.makeName(b"@snap")
snaps = [snapname1, snapname2, snapname3]
with self.assertRaises(lzc_exc.SnapshotDestructionFailure) as ctx:
# Since currently we can not destroy filesystems,
# it would be impossible to destroy the snapshot,
# so no point in attempting to clean it up.
- snapname = ZFSTest.pool.makeName("fs2@origin1")
- name = ZFSTest.pool.makeName("fs1/fs/clone1")
+ snapname = ZFSTest.pool.makeName(b"fs2@origin1")
+ name = ZFSTest.pool.makeName(b"fs1/fs/clone1")
lzc.lzc_snapshot([snapname])
self.assertExists(name)
def test_clone_nonexistent_snapshot(self):
- snapname = ZFSTest.pool.makeName("fs2@nonexistent")
- name = ZFSTest.pool.makeName("fs1/fs/clone2")
+ snapname = ZFSTest.pool.makeName(b"fs2@nonexistent")
+ name = ZFSTest.pool.makeName(b"fs1/fs/clone2")
# XXX The error should be SnapshotNotFound
# but limitations of C interface do not allow
self.assertNotExists(name)
def test_clone_nonexistent_parent_fs(self):
- snapname = ZFSTest.pool.makeName("fs2@origin3")
- name = ZFSTest.pool.makeName("fs1/nonexistent/clone3")
+ snapname = ZFSTest.pool.makeName(b"fs2@origin3")
+ name = ZFSTest.pool.makeName(b"fs1/nonexistent/clone3")
lzc.lzc_snapshot([snapname])
self.assertNotExists(name)
def test_clone_to_nonexistent_pool(self):
- snapname = ZFSTest.pool.makeName("fs2@snap")
- name = "no-such-pool/fs"
+ snapname = ZFSTest.pool.makeName(b"fs2@snap")
+ name = b"no-such-pool/fs"
lzc.lzc_snapshot([snapname])
def test_clone_invalid_snap_name(self):
# Use a valid filesystem name of filesystem that
# exists as a snapshot name
- snapname = ZFSTest.pool.makeName("fs1/fs")
- name = ZFSTest.pool.makeName("fs2/clone")
+ snapname = ZFSTest.pool.makeName(b"fs1/fs")
+ name = ZFSTest.pool.makeName(b"fs2/clone")
with self.assertRaises(lzc_exc.SnapshotNameInvalid):
lzc.lzc_clone(name, snapname)
def test_clone_invalid_snap_name_2(self):
# Use a valid filesystem name of filesystem that
# doesn't exist as a snapshot name
- snapname = ZFSTest.pool.makeName("fs1/nonexistent")
- name = ZFSTest.pool.makeName("fs2/clone")
+ snapname = ZFSTest.pool.makeName(b"fs1/nonexistent")
+ name = ZFSTest.pool.makeName(b"fs2/clone")
with self.assertRaises(lzc_exc.SnapshotNameInvalid):
lzc.lzc_clone(name, snapname)
self.assertNotExists(name)
def test_clone_invalid_name(self):
- snapname = ZFSTest.pool.makeName("fs2@snap")
- name = ZFSTest.pool.makeName("fs1/bad#name")
+ snapname = ZFSTest.pool.makeName(b"fs2@snap")
+ name = ZFSTest.pool.makeName(b"fs1/bad#name")
lzc.lzc_snapshot([snapname])
self.assertNotExists(name)
def test_clone_invalid_pool_name(self):
- snapname = ZFSTest.pool.makeName("fs2@snap")
- name = "bad!pool/fs1"
+ snapname = ZFSTest.pool.makeName(b"fs2@snap")
+ name = b"bad!pool/fs1"
lzc.lzc_snapshot([snapname])
self.assertNotExists(name)
def test_clone_across_pools(self):
- snapname = ZFSTest.pool.makeName("fs2@snap")
- name = ZFSTest.misc_pool.makeName("clone1")
+ snapname = ZFSTest.pool.makeName(b"fs2@snap")
+ name = ZFSTest.misc_pool.makeName(b"clone1")
lzc.lzc_snapshot([snapname])
self.assertNotExists(name)
def test_clone_across_pools_to_ro_pool(self):
- snapname = ZFSTest.pool.makeName("fs2@snap")
- name = ZFSTest.readonly_pool.makeName("fs1/clone1")
+ snapname = ZFSTest.pool.makeName(b"fs2@snap")
+ name = ZFSTest.readonly_pool.makeName(b"fs1/clone1")
lzc.lzc_snapshot([snapname])
self.assertNotExists(name)
def test_destroy_cloned_fs(self):
- snapname1 = ZFSTest.pool.makeName("fs2@origin4")
- snapname2 = ZFSTest.pool.makeName("fs1@snap")
- clonename = ZFSTest.pool.makeName("fs1/fs/clone4")
+ snapname1 = ZFSTest.pool.makeName(b"fs2@origin4")
+ snapname2 = ZFSTest.pool.makeName(b"fs1@snap")
+ clonename = ZFSTest.pool.makeName(b"fs1/fs/clone4")
snaps = [snapname1, snapname2]
lzc.lzc_snapshot(snaps)
self.assertExists(snap)
def test_deferred_destroy_cloned_fs(self):
- snapname1 = ZFSTest.pool.makeName("fs2@origin5")
- snapname2 = ZFSTest.pool.makeName("fs1@snap")
- clonename = ZFSTest.pool.makeName("fs1/fs/clone5")
+ snapname1 = ZFSTest.pool.makeName(b"fs2@origin5")
+ snapname2 = ZFSTest.pool.makeName(b"fs1@snap")
+ clonename = ZFSTest.pool.makeName(b"fs1/fs/clone5")
snaps = [snapname1, snapname2]
lzc.lzc_snapshot(snaps)
self.assertNotExists(snapname2)
def test_rollback(self):
- name = ZFSTest.pool.makeName("fs1")
- snapname = name + "@snap"
+ name = ZFSTest.pool.makeName(b"fs1")
+ snapname = name + b"@snap"
lzc.lzc_snapshot([snapname])
ret = lzc.lzc_rollback(name)
self.assertEqual(ret, snapname)
def test_rollback_2(self):
- name = ZFSTest.pool.makeName("fs1")
- snapname1 = name + "@snap1"
- snapname2 = name + "@snap2"
+ name = ZFSTest.pool.makeName(b"fs1")
+ snapname1 = name + b"@snap1"
+ snapname2 = name + b"@snap2"
lzc.lzc_snapshot([snapname1])
lzc.lzc_snapshot([snapname2])
self.assertEqual(ret, snapname2)
def test_rollback_no_snaps(self):
- name = ZFSTest.pool.makeName("fs1")
+ name = ZFSTest.pool.makeName(b"fs1")
with self.assertRaises(lzc_exc.SnapshotNotFound):
lzc.lzc_rollback(name)
def test_rollback_non_existent_fs(self):
- name = ZFSTest.pool.makeName("nonexistent")
+ name = ZFSTest.pool.makeName(b"nonexistent")
with self.assertRaises(lzc_exc.FilesystemNotFound):
lzc.lzc_rollback(name)
def test_rollback_invalid_fs_name(self):
- name = ZFSTest.pool.makeName("bad~name")
+ name = ZFSTest.pool.makeName(b"bad~name")
with self.assertRaises(lzc_exc.NameInvalid):
lzc.lzc_rollback(name)
def test_rollback_snap_name(self):
- name = ZFSTest.pool.makeName("fs1@snap")
+ name = ZFSTest.pool.makeName(b"fs1@snap")
with self.assertRaises(lzc_exc.NameInvalid):
lzc.lzc_rollback(name)
def test_rollback_snap_name_2(self):
- name = ZFSTest.pool.makeName("fs1@snap")
+ name = ZFSTest.pool.makeName(b"fs1@snap")
lzc.lzc_snapshot([name])
with self.assertRaises(lzc_exc.NameInvalid):
lzc.lzc_rollback(name)
def test_rollback_to_snap_name(self):
- name = ZFSTest.pool.makeName("fs1")
- snap = name + "@snap"
+ name = ZFSTest.pool.makeName(b"fs1")
+ snap = name + b"@snap"
lzc.lzc_snapshot([snap])
lzc.lzc_rollback_to(name, snap)
def test_rollback_to_not_latest(self):
- fsname = ZFSTest.pool.makeName('fs1')
- snap1 = fsname + "@snap1"
- snap2 = fsname + "@snap2"
+ fsname = ZFSTest.pool.makeName(b'fs1')
+ snap1 = fsname + b"@snap1"
+ snap2 = fsname + b"@snap2"
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2])
with self.assertRaises(lzc_exc.SnapshotNotLatest):
- lzc.lzc_rollback_to(fsname, fsname + "@snap1")
+ lzc.lzc_rollback_to(fsname, fsname + b"@snap1")
@skipUnlessBookmarksSupported
def test_bookmarks(self):
snaps = [ZFSTest.pool.makeName(
- 'fs1@snap1'), ZFSTest.pool.makeName('fs2@snap1')]
+ b'fs1@snap1'), ZFSTest.pool.makeName(b'fs2@snap1')]
bmarks = [ZFSTest.pool.makeName(
- 'fs1#bmark1'), ZFSTest.pool.makeName('fs2#bmark1')]
+ b'fs1#bmark1'), ZFSTest.pool.makeName(b'fs2#bmark1')]
bmark_dict = {x: y for x, y in zip(bmarks, snaps)}
lzc.lzc_snapshot(snaps)
@skipUnlessBookmarksSupported
def test_bookmarks_2(self):
snaps = [ZFSTest.pool.makeName(
- 'fs1@snap1'), ZFSTest.pool.makeName('fs2@snap1')]
+ b'fs1@snap1'), ZFSTest.pool.makeName(b'fs2@snap1')]
bmarks = [ZFSTest.pool.makeName(
- 'fs1#bmark1'), ZFSTest.pool.makeName('fs2#bmark1')]
+ b'fs1#bmark1'), ZFSTest.pool.makeName(b'fs2#bmark1')]
bmark_dict = {x: y for x, y in zip(bmarks, snaps)}
lzc.lzc_snapshot(snaps)
@skipUnlessBookmarksSupported
def test_bookmarks_mismatching_name(self):
- snaps = [ZFSTest.pool.makeName('fs1@snap1')]
- bmarks = [ZFSTest.pool.makeName('fs2#bmark1')]
+ snaps = [ZFSTest.pool.makeName(b'fs1@snap1')]
+ bmarks = [ZFSTest.pool.makeName(b'fs2#bmark1')]
bmark_dict = {x: y for x, y in zip(bmarks, snaps)}
lzc.lzc_snapshot(snaps)
@skipUnlessBookmarksSupported
def test_bookmarks_invalid_name(self):
- snaps = [ZFSTest.pool.makeName('fs1@snap1')]
- bmarks = [ZFSTest.pool.makeName('fs1#bmark!')]
+ snaps = [ZFSTest.pool.makeName(b'fs1@snap1')]
+ bmarks = [ZFSTest.pool.makeName(b'fs1#bmark!')]
bmark_dict = {x: y for x, y in zip(bmarks, snaps)}
lzc.lzc_snapshot(snaps)
@skipUnlessBookmarksSupported
def test_bookmarks_invalid_name_2(self):
- snaps = [ZFSTest.pool.makeName('fs1@snap1')]
- bmarks = [ZFSTest.pool.makeName('fs1@bmark')]
+ snaps = [ZFSTest.pool.makeName(b'fs1@snap1')]
+ bmarks = [ZFSTest.pool.makeName(b'fs1@bmark')]
bmark_dict = {x: y for x, y in zip(bmarks, snaps)}
lzc.lzc_snapshot(snaps)
@skipUnlessBookmarksSupported
def test_bookmarks_too_long_name(self):
- snaps = [ZFSTest.pool.makeName('fs1@snap1')]
- bmarks = [ZFSTest.pool.makeTooLongName('fs1#')]
+ snaps = [ZFSTest.pool.makeName(b'fs1@snap1')]
+ bmarks = [ZFSTest.pool.makeTooLongName(b'fs1#')]
bmark_dict = {x: y for x, y in zip(bmarks, snaps)}
lzc.lzc_snapshot(snaps)
@skipUnlessBookmarksSupported
def test_bookmarks_too_long_name_2(self):
- snaps = [ZFSTest.pool.makeName('fs1@snap1')]
- bmarks = [ZFSTest.pool.makeTooLongComponent('fs1#')]
+ snaps = [ZFSTest.pool.makeName(b'fs1@snap1')]
+ bmarks = [ZFSTest.pool.makeTooLongComponent(b'fs1#')]
bmark_dict = {x: y for x, y in zip(bmarks, snaps)}
lzc.lzc_snapshot(snaps)
@skipUnlessBookmarksSupported
def test_bookmarks_mismatching_names(self):
snaps = [ZFSTest.pool.makeName(
- 'fs1@snap1'), ZFSTest.pool.makeName('fs2@snap1')]
+ b'fs1@snap1'), ZFSTest.pool.makeName(b'fs2@snap1')]
bmarks = [ZFSTest.pool.makeName(
- 'fs2#bmark1'), ZFSTest.pool.makeName('fs1#bmark1')]
+ b'fs2#bmark1'), ZFSTest.pool.makeName(b'fs1#bmark1')]
bmark_dict = {x: y for x, y in zip(bmarks, snaps)}
lzc.lzc_snapshot(snaps)
@skipUnlessBookmarksSupported
def test_bookmarks_partially_mismatching_names(self):
snaps = [ZFSTest.pool.makeName(
- 'fs1@snap1'), ZFSTest.pool.makeName('fs2@snap1')]
+ b'fs1@snap1'), ZFSTest.pool.makeName(b'fs2@snap1')]
bmarks = [ZFSTest.pool.makeName(
- 'fs2#bmark'), ZFSTest.pool.makeName('fs2#bmark1')]
+ b'fs2#bmark'), ZFSTest.pool.makeName(b'fs2#bmark1')]
bmark_dict = {x: y for x, y in zip(bmarks, snaps)}
lzc.lzc_snapshot(snaps)
@skipUnlessBookmarksSupported
def test_bookmarks_cross_pool(self):
snaps = [ZFSTest.pool.makeName(
- 'fs1@snap1'), ZFSTest.misc_pool.makeName('@snap1')]
+ b'fs1@snap1'), ZFSTest.misc_pool.makeName(b'@snap1')]
bmarks = [ZFSTest.pool.makeName(
- 'fs1#bmark1'), ZFSTest.misc_pool.makeName('#bmark1')]
+ b'fs1#bmark1'), ZFSTest.misc_pool.makeName(b'#bmark1')]
bmark_dict = {x: y for x, y in zip(bmarks, snaps)}
lzc.lzc_snapshot(snaps[0:1])
@skipUnlessBookmarksSupported
def test_bookmarks_missing_snap(self):
snaps = [ZFSTest.pool.makeName(
- 'fs1@snap1'), ZFSTest.pool.makeName('fs2@snap1')]
+ b'fs1@snap1'), ZFSTest.pool.makeName(b'fs2@snap1')]
bmarks = [ZFSTest.pool.makeName(
- 'fs1#bmark1'), ZFSTest.pool.makeName('fs2#bmark1')]
+ b'fs1#bmark1'), ZFSTest.pool.makeName(b'fs2#bmark1')]
bmark_dict = {x: y for x, y in zip(bmarks, snaps)}
lzc.lzc_snapshot(snaps[0:1])
@skipUnlessBookmarksSupported
def test_bookmarks_missing_snaps(self):
snaps = [ZFSTest.pool.makeName(
- 'fs1@snap1'), ZFSTest.pool.makeName('fs2@snap1')]
+ b'fs1@snap1'), ZFSTest.pool.makeName(b'fs2@snap1')]
bmarks = [ZFSTest.pool.makeName(
- 'fs1#bmark1'), ZFSTest.pool.makeName('fs2#bmark1')]
+ b'fs1#bmark1'), ZFSTest.pool.makeName(b'fs2#bmark1')]
bmark_dict = {x: y for x, y in zip(bmarks, snaps)}
with self.assertRaises(lzc_exc.BookmarkFailure) as ctx:
@skipUnlessBookmarksSupported
def test_bookmarks_for_the_same_snap(self):
- snap = ZFSTest.pool.makeName('fs1@snap1')
- bmark1 = ZFSTest.pool.makeName('fs1#bmark1')
- bmark2 = ZFSTest.pool.makeName('fs1#bmark2')
+ snap = ZFSTest.pool.makeName(b'fs1@snap1')
+ bmark1 = ZFSTest.pool.makeName(b'fs1#bmark1')
+ bmark2 = ZFSTest.pool.makeName(b'fs1#bmark2')
bmark_dict = {bmark1: snap, bmark2: snap}
lzc.lzc_snapshot([snap])
@skipUnlessBookmarksSupported
def test_bookmarks_for_the_same_snap_2(self):
- snap = ZFSTest.pool.makeName('fs1@snap1')
- bmark1 = ZFSTest.pool.makeName('fs1#bmark1')
- bmark2 = ZFSTest.pool.makeName('fs1#bmark2')
+ snap = ZFSTest.pool.makeName(b'fs1@snap1')
+ bmark1 = ZFSTest.pool.makeName(b'fs1#bmark1')
+ bmark2 = ZFSTest.pool.makeName(b'fs1#bmark2')
bmark_dict1 = {bmark1: snap}
bmark_dict2 = {bmark2: snap}
@skipUnlessBookmarksSupported
def test_bookmarks_duplicate_name(self):
- snap1 = ZFSTest.pool.makeName('fs1@snap1')
- snap2 = ZFSTest.pool.makeName('fs1@snap2')
- bmark = ZFSTest.pool.makeName('fs1#bmark')
+ snap1 = ZFSTest.pool.makeName(b'fs1@snap1')
+ snap2 = ZFSTest.pool.makeName(b'fs1@snap2')
+ bmark = ZFSTest.pool.makeName(b'fs1#bmark')
bmark_dict1 = {bmark: snap1}
bmark_dict2 = {bmark: snap2}
@skipUnlessBookmarksSupported
def test_get_bookmarks(self):
- snap1 = ZFSTest.pool.makeName('fs1@snap1')
- snap2 = ZFSTest.pool.makeName('fs1@snap2')
- bmark = ZFSTest.pool.makeName('fs1#bmark')
- bmark1 = ZFSTest.pool.makeName('fs1#bmark1')
- bmark2 = ZFSTest.pool.makeName('fs1#bmark2')
+ snap1 = ZFSTest.pool.makeName(b'fs1@snap1')
+ snap2 = ZFSTest.pool.makeName(b'fs1@snap2')
+ bmark = ZFSTest.pool.makeName(b'fs1#bmark')
+ bmark1 = ZFSTest.pool.makeName(b'fs1#bmark1')
+ bmark2 = ZFSTest.pool.makeName(b'fs1#bmark2')
bmark_dict1 = {bmark1: snap1, bmark2: snap2}
bmark_dict2 = {bmark: snap2}
lzc.lzc_bookmark(bmark_dict2)
lzc.lzc_destroy_snaps([snap1, snap2], defer=False)
- bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName('fs1'))
+ bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName(b'fs1'))
self.assertEqual(len(bmarks), 3)
- for b in 'bmark', 'bmark1', 'bmark2':
+ for b in b'bmark', b'bmark1', b'bmark2':
self.assertIn(b, bmarks)
self.assertIsInstance(bmarks[b], dict)
self.assertEqual(len(bmarks[b]), 0)
- bmarks = lzc.lzc_get_bookmarks(
- ZFSTest.pool.makeName('fs1'), ['guid', 'createtxg', 'creation'])
+ bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName(b'fs1'),
+ [b'guid', b'createtxg', b'creation'])
self.assertEqual(len(bmarks), 3)
- for b in 'bmark', 'bmark1', 'bmark2':
+ for b in b'bmark', b'bmark1', b'bmark2':
self.assertIn(b, bmarks)
self.assertIsInstance(bmarks[b], dict)
self.assertEqual(len(bmarks[b]), 3)
@skipUnlessBookmarksSupported
def test_get_bookmarks_invalid_property(self):
- snap = ZFSTest.pool.makeName('fs1@snap')
- bmark = ZFSTest.pool.makeName('fs1#bmark')
+ snap = ZFSTest.pool.makeName(b'fs1@snap')
+ bmark = ZFSTest.pool.makeName(b'fs1#bmark')
bmark_dict = {bmark: snap}
lzc.lzc_snapshot([snap])
lzc.lzc_bookmark(bmark_dict)
bmarks = lzc.lzc_get_bookmarks(
- ZFSTest.pool.makeName('fs1'), ['badprop'])
+ ZFSTest.pool.makeName(b'fs1'), [b'badprop'])
self.assertEqual(len(bmarks), 1)
- for b in ('bmark', ):
+ for b in (b'bmark', ):
self.assertIn(b, bmarks)
self.assertIsInstance(bmarks[b], dict)
self.assertEqual(len(bmarks[b]), 0)
@skipUnlessBookmarksSupported
def test_get_bookmarks_nonexistent_fs(self):
with self.assertRaises(lzc_exc.FilesystemNotFound):
- lzc.lzc_get_bookmarks(ZFSTest.pool.makeName('nonexistent'))
+ lzc.lzc_get_bookmarks(ZFSTest.pool.makeName(b'nonexistent'))
@skipUnlessBookmarksSupported
def test_destroy_bookmarks(self):
- snap = ZFSTest.pool.makeName('fs1@snap')
- bmark = ZFSTest.pool.makeName('fs1#bmark')
+ snap = ZFSTest.pool.makeName(b'fs1@snap')
+ bmark = ZFSTest.pool.makeName(b'fs1#bmark')
bmark_dict = {bmark: snap}
lzc.lzc_snapshot([snap])
lzc.lzc_bookmark(bmark_dict)
lzc.lzc_destroy_bookmarks(
- [bmark, ZFSTest.pool.makeName('fs1#nonexistent')])
- bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName('fs1'))
+ [bmark, ZFSTest.pool.makeName(b'fs1#nonexistent')])
+ bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName(b'fs1'))
self.assertEqual(len(bmarks), 0)
@skipUnlessBookmarksSupported
def test_destroy_bookmarks_invalid_name(self):
- snap = ZFSTest.pool.makeName('fs1@snap')
- bmark = ZFSTest.pool.makeName('fs1#bmark')
+ snap = ZFSTest.pool.makeName(b'fs1@snap')
+ bmark = ZFSTest.pool.makeName(b'fs1#bmark')
bmark_dict = {bmark: snap}
lzc.lzc_snapshot([snap])
with self.assertRaises(lzc_exc.BookmarkDestructionFailure) as ctx:
lzc.lzc_destroy_bookmarks(
- [bmark, ZFSTest.pool.makeName('fs1/nonexistent')])
+ [bmark, ZFSTest.pool.makeName(b'fs1/nonexistent')])
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameInvalid)
- bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName('fs1'))
+ bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName(b'fs1'))
self.assertEqual(len(bmarks), 1)
- self.assertIn('bmark', bmarks)
+ self.assertIn(b'bmark', bmarks)
@skipUnlessBookmarksSupported
def test_destroy_bookmark_nonexistent_fs(self):
- lzc.lzc_destroy_bookmarks([ZFSTest.pool.makeName('nonexistent#bmark')])
+ lzc.lzc_destroy_bookmarks(
+ [ZFSTest.pool.makeName(b'nonexistent#bmark')])
@skipUnlessBookmarksSupported
def test_destroy_bookmarks_empty(self):
lzc.lzc_bookmark({})
def test_snaprange_space(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@snap2")
- snap3 = ZFSTest.pool.makeName("fs1@snap")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
+ snap3 = ZFSTest.pool.makeName(b"fs1@snap")
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2])
self.assertIsInstance(space, (int, int))
def test_snaprange_space_2(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@snap2")
- snap3 = ZFSTest.pool.makeName("fs1@snap")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
+ snap3 = ZFSTest.pool.makeName(b"fs1@snap")
lzc.lzc_snapshot([snap1])
- with zfs_mount(ZFSTest.pool.makeName("fs1")) as mntdir:
+ with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
with tempfile.NamedTemporaryFile(dir=mntdir) as f:
for i in range(1024):
- f.write('x' * 1024)
+ f.write(b'x' * 1024)
f.flush()
lzc.lzc_snapshot([snap2])
lzc.lzc_snapshot([snap3])
self.assertGreater(space, 1024 * 1024)
def test_snaprange_space_same_snap(self):
- snap = ZFSTest.pool.makeName("fs1@snap")
+ snap = ZFSTest.pool.makeName(b"fs1@snap")
- with zfs_mount(ZFSTest.pool.makeName("fs1")) as mntdir:
+ with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
with tempfile.NamedTemporaryFile(dir=mntdir) as f:
for i in range(1024):
- f.write('x' * 1024)
+ f.write(b'x' * 1024)
f.flush()
lzc.lzc_snapshot([snap])
self.assertAlmostEqual(space, 1024 * 1024, delta=1024 * 1024 // 20)
def test_snaprange_space_wrong_order(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@snap2")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2])
lzc.lzc_snaprange_space(snap2, snap1)
def test_snaprange_space_unrelated(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs2@snap2")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs2@snap2")
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2])
lzc.lzc_snaprange_space(snap1, snap2)
def test_snaprange_space_across_pools(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.misc_pool.makeName("@snap2")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.misc_pool.makeName(b"@snap2")
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2])
lzc.lzc_snaprange_space(snap1, snap2)
def test_snaprange_space_nonexistent(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@snap2")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
lzc.lzc_snapshot([snap1])
self.assertEqual(ctx.exception.name, snap1)
def test_snaprange_space_invalid_name(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@sn#p")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@sn#p")
lzc.lzc_snapshot([snap1])
lzc.lzc_snaprange_space(snap1, snap2)
def test_snaprange_space_not_snap(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1")
lzc.lzc_snapshot([snap1])
lzc.lzc_snaprange_space(snap2, snap1)
def test_snaprange_space_not_snap_2(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1#bmark")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1#bmark")
lzc.lzc_snapshot([snap1])
lzc.lzc_snaprange_space(snap2, snap1)
def test_send_space(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@snap2")
- snap3 = ZFSTest.pool.makeName("fs1@snap")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
+ snap3 = ZFSTest.pool.makeName(b"fs1@snap")
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2])
self.assertIsInstance(space, (int, int))
def test_send_space_2(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@snap2")
- snap3 = ZFSTest.pool.makeName("fs1@snap")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
+ snap3 = ZFSTest.pool.makeName(b"fs1@snap")
lzc.lzc_snapshot([snap1])
- with zfs_mount(ZFSTest.pool.makeName("fs1")) as mntdir:
+ with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
with tempfile.NamedTemporaryFile(dir=mntdir) as f:
for i in range(1024):
- f.write('x' * 1024)
+ f.write(b'x' * 1024)
f.flush()
lzc.lzc_snapshot([snap2])
lzc.lzc_snapshot([snap3])
self.assertEqual(space, space_empty)
def test_send_space_same_snap(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
lzc.lzc_snapshot([snap1])
with self.assertRaises(lzc_exc.SnapshotMismatch):
lzc.lzc_send_space(snap1, snap1)
def test_send_space_wrong_order(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@snap2")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2])
lzc.lzc_send_space(snap1, snap2)
def test_send_space_unrelated(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs2@snap2")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs2@snap2")
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2])
lzc.lzc_send_space(snap1, snap2)
def test_send_space_across_pools(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.misc_pool.makeName("@snap2")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.misc_pool.makeName(b"@snap2")
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2])
lzc.lzc_send_space(snap1, snap2)
def test_send_space_nonexistent(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs2@snap2")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs2@snap2")
lzc.lzc_snapshot([snap1])
self.assertEqual(ctx.exception.name, snap2)
def test_send_space_invalid_name(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@sn!p")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@sn!p")
lzc.lzc_snapshot([snap1])
self.assertEqual(ctx.exception.name, snap2)
def test_send_space_not_snap(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1")
lzc.lzc_snapshot([snap1])
lzc.lzc_send_space(snap2)
def test_send_space_not_snap_2(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1#bmark")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1#bmark")
lzc.lzc_snapshot([snap1])
lzc.lzc_send_space(snap2)
def test_send_full(self):
- snap = ZFSTest.pool.makeName("fs1@snap")
+ snap = ZFSTest.pool.makeName(b"fs1@snap")
- with zfs_mount(ZFSTest.pool.makeName("fs1")) as mntdir:
+ with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
with tempfile.NamedTemporaryFile(dir=mntdir) as f:
for i in range(1024):
- f.write('x' * 1024)
+ f.write(b'x' * 1024)
f.flush()
lzc.lzc_snapshot([snap])
self.assertAlmostEqual(st.st_size, estimate, delta=estimate // 20)
def test_send_incremental(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@snap2")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
lzc.lzc_snapshot([snap1])
- with zfs_mount(ZFSTest.pool.makeName("fs1")) as mntdir:
+ with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
with tempfile.NamedTemporaryFile(dir=mntdir) as f:
for i in range(1024):
- f.write('x' * 1024)
+ f.write(b'x' * 1024)
f.flush()
lzc.lzc_snapshot([snap2])
def test_send_flags(self):
flags = ['embedded_data', 'large_blocks', 'compress', 'raw']
- snap = ZFSTest.pool.makeName("fs1@snap")
+ snap = ZFSTest.pool.makeName(b"fs1@snap")
lzc.lzc_snapshot([snap])
for c in range(len(flags)):
lzc.lzc_send(snap, None, fd, list(flag))
def test_send_unknown_flags(self):
- snap = ZFSTest.pool.makeName("fs1@snap")
+ snap = ZFSTest.pool.makeName(b"fs1@snap")
lzc.lzc_snapshot([snap])
with dev_null() as fd:
with self.assertRaises(lzc_exc.UnknownStreamFeature):
lzc.lzc_send(snap, None, fd, ['embedded_data', 'UNKNOWN'])
def test_send_same_snap(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
lzc.lzc_snapshot([snap1])
with tempfile.TemporaryFile(suffix='.ztream') as output:
fd = output.fileno()
lzc.lzc_send(snap1, snap1, fd)
def test_send_wrong_order(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@snap2")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2])
lzc.lzc_send(snap1, snap2, fd)
def test_send_unrelated(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs2@snap2")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs2@snap2")
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2])
lzc.lzc_send(snap1, snap2, fd)
def test_send_across_pools(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.misc_pool.makeName("@snap2")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.misc_pool.makeName(b"@snap2")
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2])
lzc.lzc_send(snap1, snap2, fd)
def test_send_nonexistent(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@snap2")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
lzc.lzc_snapshot([snap1])
self.assertEqual(ctx.exception.name, snap2)
def test_send_invalid_name(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@sn!p")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@sn!p")
lzc.lzc_snapshot([snap1])
# is taken at some time after the call is made and before the stream
# starts being produced.
def test_send_filesystem(self):
- snap = ZFSTest.pool.makeName("fs1@snap1")
- fs = ZFSTest.pool.makeName("fs1")
+ snap = ZFSTest.pool.makeName(b"fs1@snap1")
+ fs = ZFSTest.pool.makeName(b"fs1")
lzc.lzc_snapshot([snap])
lzc.lzc_send(fs, None, fd)
def test_send_from_filesystem(self):
- snap = ZFSTest.pool.makeName("fs1@snap1")
- fs = ZFSTest.pool.makeName("fs1")
+ snap = ZFSTest.pool.makeName(b"fs1@snap1")
+ fs = ZFSTest.pool.makeName(b"fs1")
lzc.lzc_snapshot([snap])
@skipUnlessBookmarksSupported
def test_send_bookmark(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@snap2")
- bmark = ZFSTest.pool.makeName("fs1#bmark")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
+ bmark = ZFSTest.pool.makeName(b"fs1#bmark")
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2])
@skipUnlessBookmarksSupported
def test_send_from_bookmark(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@snap2")
- bmark = ZFSTest.pool.makeName("fs1#bmark")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
+ bmark = ZFSTest.pool.makeName(b"fs1#bmark")
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2])
lzc.lzc_send(snap2, bmark, fd)
def test_send_bad_fd(self):
- snap = ZFSTest.pool.makeName("fs1@snap")
+ snap = ZFSTest.pool.makeName(b"fs1@snap")
lzc.lzc_snapshot([snap])
with tempfile.TemporaryFile() as tmp:
self.assertEqual(ctx.exception.errno, errno.EBADF)
def test_send_bad_fd_2(self):
- snap = ZFSTest.pool.makeName("fs1@snap")
+ snap = ZFSTest.pool.makeName(b"fs1@snap")
lzc.lzc_snapshot([snap])
with self.assertRaises(lzc_exc.StreamIOError) as ctx:
self.assertEqual(ctx.exception.errno, errno.EBADF)
def test_send_bad_fd_3(self):
- snap = ZFSTest.pool.makeName("fs1@snap")
+ snap = ZFSTest.pool.makeName(b"fs1@snap")
lzc.lzc_snapshot([snap])
with tempfile.TemporaryFile() as tmp:
self.assertEqual(ctx.exception.errno, errno.EBADF)
def test_send_to_broken_pipe(self):
- snap = ZFSTest.pool.makeName("fs1@snap")
+ snap = ZFSTest.pool.makeName(b"fs1@snap")
lzc.lzc_snapshot([snap])
- proc = subprocess.Popen(['true'], stdin=subprocess.PIPE)
- proc.wait()
- with self.assertRaises(lzc_exc.StreamIOError) as ctx:
- lzc.lzc_send(snap, None, proc.stdin.fileno())
- self.assertEqual(ctx.exception.errno, errno.EPIPE)
+ if sys.version_info < (3, 0):
+ proc = subprocess.Popen(['true'], stdin=subprocess.PIPE)
+ proc.wait()
+ with self.assertRaises(lzc_exc.StreamIOError) as ctx:
+ lzc.lzc_send(snap, None, proc.stdin.fileno())
+ self.assertEqual(ctx.exception.errno, errno.EPIPE)
+ else:
+ with subprocess.Popen(['true'], stdin=subprocess.PIPE) as proc:
+ proc.wait()
+ with self.assertRaises(lzc_exc.StreamIOError) as ctx:
+ lzc.lzc_send(snap, None, proc.stdin.fileno())
+ self.assertEqual(ctx.exception.errno, errno.EPIPE)
def test_send_to_broken_pipe_2(self):
- snap = ZFSTest.pool.makeName("fs1@snap")
- with zfs_mount(ZFSTest.pool.makeName("fs1")) as mntdir:
+ snap = ZFSTest.pool.makeName(b"fs1@snap")
+ with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
with tempfile.NamedTemporaryFile(dir=mntdir) as f:
for i in range(1024):
- f.write('x' * 1024)
+ f.write(b'x' * 1024)
f.flush()
lzc.lzc_snapshot([snap])
- proc = subprocess.Popen(['sleep', '2'], stdin=subprocess.PIPE)
- with self.assertRaises(lzc_exc.StreamIOError) as ctx:
- lzc.lzc_send(snap, None, proc.stdin.fileno())
- self.assertTrue(ctx.exception.errno == errno.EPIPE or
- ctx.exception.errno == errno.EINTR)
+ if sys.version_info < (3, 0):
+ p = subprocess.Popen(['sleep', '2'], stdin=subprocess.PIPE)
+ with self.assertRaises(lzc_exc.StreamIOError) as ctx:
+ lzc.lzc_send(snap, None, p.stdin.fileno())
+ self.assertTrue(ctx.exception.errno == errno.EPIPE or
+ ctx.exception.errno == errno.EINTR)
+ else:
+ with subprocess.Popen(['sleep', '2'], stdin=subprocess.PIPE) as p:
+ with self.assertRaises(lzc_exc.StreamIOError) as ctx:
+ lzc.lzc_send(snap, None, p.stdin.fileno())
+ self.assertTrue(ctx.exception.errno == errno.EPIPE or
+ ctx.exception.errno == errno.EINTR)
def test_send_to_ro_file(self):
- snap = ZFSTest.pool.makeName("fs1@snap")
+ snap = ZFSTest.pool.makeName(b"fs1@snap")
lzc.lzc_snapshot([snap])
with tempfile.NamedTemporaryFile(
self.assertEqual(ctx.exception.errno, errno.EBADF)
def test_recv_full(self):
- src = ZFSTest.pool.makeName("fs1@snap")
- dst = ZFSTest.pool.makeName("fs2/received-1@snap")
+ src = ZFSTest.pool.makeName(b"fs1@snap")
+ dst = ZFSTest.pool.makeName(b"fs2/received-1@snap")
- with temp_file_in_fs(ZFSTest.pool.makeName("fs1")) as name:
+ with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")) as name:
lzc.lzc_snapshot([src])
with tempfile.TemporaryFile(suffix='.ztream') as stream:
os.path.join(mnt1, name), os.path.join(mnt2, name), False))
def test_recv_incremental(self):
- src1 = ZFSTest.pool.makeName("fs1@snap1")
- src2 = ZFSTest.pool.makeName("fs1@snap2")
- dst1 = ZFSTest.pool.makeName("fs2/received-2@snap1")
- dst2 = ZFSTest.pool.makeName("fs2/received-2@snap2")
+ src1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ src2 = ZFSTest.pool.makeName(b"fs1@snap2")
+ dst1 = ZFSTest.pool.makeName(b"fs2/received-2@snap1")
+ dst2 = ZFSTest.pool.makeName(b"fs2/received-2@snap2")
lzc.lzc_snapshot([src1])
- with temp_file_in_fs(ZFSTest.pool.makeName("fs1")) as name:
+ with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")) as name:
lzc.lzc_snapshot([src2])
with tempfile.TemporaryFile(suffix='.ztream') as stream:
# is applied to libzfs_core, otherwise it succeeds.
@unittest.skip("fails with unpatched libzfs_core")
def test_recv_without_explicit_snap_name(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-100")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-100")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dstfs, full.fileno())
self.assertExists(dst2)
def test_recv_clone(self):
- orig_src = ZFSTest.pool.makeName("fs2@send-origin")
- clone = ZFSTest.pool.makeName("fs1/fs/send-clone")
- clone_snap = clone + "@snap"
- orig_dst = ZFSTest.pool.makeName("fs1/fs/recv-origin@snap")
- clone_dst = ZFSTest.pool.makeName("fs1/fs/recv-clone@snap")
+ orig_src = ZFSTest.pool.makeName(b"fs2@send-origin")
+ clone = ZFSTest.pool.makeName(b"fs1/fs/send-clone")
+ clone_snap = clone + b"@snap"
+ orig_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-origin@snap")
+ clone_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-clone@snap")
lzc.lzc_snapshot([orig_src])
with tempfile.TemporaryFile(suffix='.ztream') as stream:
lzc.lzc_receive(clone_dst, stream.fileno(), origin=orig_dst)
def test_recv_full_already_existing_empty_fs(self):
- src = ZFSTest.pool.makeName("fs1@snap")
- dstfs = ZFSTest.pool.makeName("fs2/received-3")
- dst = dstfs + '@snap'
+ src = ZFSTest.pool.makeName(b"fs1@snap")
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-3")
+ dst = dstfs + b'@snap'
- with temp_file_in_fs(ZFSTest.pool.makeName("fs1")):
+ with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
lzc.lzc_snapshot([src])
lzc.lzc_create(dstfs)
with tempfile.TemporaryFile(suffix='.ztream') as stream:
def test_recv_full_into_root_empty_pool(self):
empty_pool = None
try:
- srcfs = ZFSTest.pool.makeName("fs1")
+ srcfs = ZFSTest.pool.makeName(b"fs1")
empty_pool = _TempPool()
- dst = empty_pool.makeName('@snap')
+ dst = empty_pool.makeName(b'@snap')
- with streams(srcfs, "snap", None) as (_, (stream, _)):
+ with streams(srcfs, b"snap", None) as (_, (stream, _)):
with self.assertRaises((
lzc_exc.DestinationModified, lzc_exc.DatasetExists)):
lzc.lzc_receive(dst, stream.fileno())
empty_pool.cleanUp()
def test_recv_full_into_ro_pool(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- dst = ZFSTest.readonly_pool.makeName('fs2/received@snap')
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ dst = ZFSTest.readonly_pool.makeName(b'fs2/received@snap')
- with streams(srcfs, "snap", None) as (_, (stream, _)):
+ with streams(srcfs, b"snap", None) as (_, (stream, _)):
with self.assertRaises(lzc_exc.ReadOnlyPool):
lzc.lzc_receive(dst, stream.fileno())
def test_recv_full_already_existing_modified_fs(self):
- src = ZFSTest.pool.makeName("fs1@snap")
- dstfs = ZFSTest.pool.makeName("fs2/received-5")
- dst = dstfs + '@snap'
+ src = ZFSTest.pool.makeName(b"fs1@snap")
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-5")
+ dst = dstfs + b'@snap'
- with temp_file_in_fs(ZFSTest.pool.makeName("fs1")):
+ with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
lzc.lzc_snapshot([src])
lzc.lzc_create(dstfs)
with temp_file_in_fs(dstfs):
lzc.lzc_receive(dst, stream.fileno())
def test_recv_full_already_existing_with_snapshots(self):
- src = ZFSTest.pool.makeName("fs1@snap")
- dstfs = ZFSTest.pool.makeName("fs2/received-4")
- dst = dstfs + '@snap'
+ src = ZFSTest.pool.makeName(b"fs1@snap")
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-4")
+ dst = dstfs + b'@snap'
- with temp_file_in_fs(ZFSTest.pool.makeName("fs1")):
+ with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
lzc.lzc_snapshot([src])
lzc.lzc_create(dstfs)
- lzc.lzc_snapshot([dstfs + "@snap1"])
+ lzc.lzc_snapshot([dstfs + b"@snap1"])
with tempfile.TemporaryFile(suffix='.ztream') as stream:
lzc.lzc_send(src, None, stream.fileno())
stream.seek(0)
lzc.lzc_receive(dst, stream.fileno())
def test_recv_full_already_existing_snapshot(self):
- src = ZFSTest.pool.makeName("fs1@snap")
- dstfs = ZFSTest.pool.makeName("fs2/received-6")
- dst = dstfs + '@snap'
+ src = ZFSTest.pool.makeName(b"fs1@snap")
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-6")
+ dst = dstfs + b'@snap'
- with temp_file_in_fs(ZFSTest.pool.makeName("fs1")):
+ with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
lzc.lzc_snapshot([src])
lzc.lzc_create(dstfs)
lzc.lzc_snapshot([dst])
lzc.lzc_receive(dst, stream.fileno())
def test_recv_full_missing_parent_fs(self):
- src = ZFSTest.pool.makeName("fs1@snap")
- dst = ZFSTest.pool.makeName("fs2/nonexistent/fs@snap")
+ src = ZFSTest.pool.makeName(b"fs1@snap")
+ dst = ZFSTest.pool.makeName(b"fs2/nonexistent/fs@snap")
- with temp_file_in_fs(ZFSTest.pool.makeName("fs1")):
+ with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
lzc.lzc_snapshot([src])
with tempfile.TemporaryFile(suffix='.ztream') as stream:
lzc.lzc_send(src, None, stream.fileno())
lzc.lzc_receive(dst, stream.fileno())
def test_recv_full_but_specify_origin(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src = srcfs + "@snap"
- dstfs = ZFSTest.pool.makeName("fs2/received-30")
- dst = dstfs + '@snap'
- origin1 = ZFSTest.pool.makeName("fs2@snap1")
- origin2 = ZFSTest.pool.makeName("fs2@snap2")
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src = srcfs + b"@snap"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-30")
+ dst = dstfs + b'@snap'
+ origin1 = ZFSTest.pool.makeName(b"fs2@snap1")
+ origin2 = ZFSTest.pool.makeName(b"fs2@snap2")
lzc.lzc_snapshot([origin1])
with streams(srcfs, src, None) as (_, (stream, _)):
lzc.lzc_receive(dst, stream.fileno(), origin=origin1)
- origin = ZFSTest.pool.getFilesystem("fs2/received-30").getProperty(
- 'origin')
+ origin = ZFSTest.pool.getFilesystem(
+ b"fs2/received-30").getProperty('origin')
self.assertEqual(origin, origin1)
stream.seek(0)
# because origin snap does not exist can't receive as a clone of it
lzc.lzc_receive(dst, stream.fileno(), origin=origin2)
def test_recv_full_existing_empty_fs_and_origin(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src = srcfs + "@snap"
- dstfs = ZFSTest.pool.makeName("fs2/received-31")
- dst = dstfs + '@snap'
- origin = dstfs + '@dummy'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src = srcfs + b"@snap"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-31")
+ dst = dstfs + b'@snap'
+ origin = dstfs + b'@dummy'
lzc.lzc_create(dstfs)
with streams(srcfs, src, None) as (_, (stream, _)):
lzc.lzc_receive(dst, stream.fileno(), origin=origin)
def test_recv_incremental_mounted_fs(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-7")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-7")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
lzc.lzc_receive(dst2, incr.fileno())
def test_recv_incremental_modified_fs(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-15")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-15")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
lzc.lzc_receive(dst2, incr.fileno())
def test_recv_incremental_snapname_used(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-8")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-8")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
lzc.lzc_receive(dst2, incr.fileno())
def test_recv_incremental_more_recent_snap_with_no_changes(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-9")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
- dst_snap = dstfs + '@snap'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-9")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
+ dst_snap = dstfs + b'@snap'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
lzc.lzc_receive(dst2, incr.fileno())
def test_recv_incremental_non_clone_but_set_origin(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-20")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
- dst_snap = dstfs + '@snap'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-20")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
+ dst_snap = dstfs + b'@snap'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
lzc.lzc_receive(dst2, incr.fileno(), origin=dst1)
def test_recv_incremental_non_clone_but_set_random_origin(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-21")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
- dst_snap = dstfs + '@snap'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-21")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
+ dst_snap = dstfs + b'@snap'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
lzc_exc.BadStream)):
lzc.lzc_receive(
dst2, incr.fileno(),
- origin=ZFSTest.pool.makeName("fs2/fs@snap"))
+ origin=ZFSTest.pool.makeName(b"fs2/fs@snap"))
def test_recv_incremental_more_recent_snap(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-10")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
- dst_snap = dstfs + '@snap'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-10")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
+ dst_snap = dstfs + b'@snap'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
lzc.lzc_receive(dst2, incr.fileno())
def test_recv_incremental_duplicate(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-11")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
- dst_snap = dstfs + '@snap'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-11")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
+ dst_snap = dstfs + b'@snap'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
lzc.lzc_receive(dst_snap, incr.fileno())
def test_recv_incremental_unrelated_fs(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-12")
- dst_snap = dstfs + '@snap'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-12")
+ dst_snap = dstfs + b'@snap'
with streams(srcfs, src1, src2) as (_, (_, incr)):
lzc.lzc_create(dstfs)
lzc.lzc_receive(dst_snap, incr.fileno())
def test_recv_incremental_nonexistent_fs(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-13")
- dst_snap = dstfs + '@snap'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-13")
+ dst_snap = dstfs + b'@snap'
with streams(srcfs, src1, src2) as (_, (_, incr)):
with self.assertRaises(lzc_exc.DatasetNotFound):
lzc.lzc_receive(dst_snap, incr.fileno())
def test_recv_incremental_same_fs(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- src_snap = srcfs + '@snap'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ src_snap = srcfs + b'@snap'
with streams(srcfs, src1, src2) as (_, (_, incr)):
with self.assertRaises(lzc_exc.DestinationModified):
lzc.lzc_receive(src_snap, incr.fileno())
def test_recv_clone_without_specifying_origin(self):
- orig_src = ZFSTest.pool.makeName("fs2@send-origin-2")
- clone = ZFSTest.pool.makeName("fs1/fs/send-clone-2")
- clone_snap = clone + "@snap"
- orig_dst = ZFSTest.pool.makeName("fs1/fs/recv-origin-2@snap")
- clone_dst = ZFSTest.pool.makeName("fs1/fs/recv-clone-2@snap")
+ orig_src = ZFSTest.pool.makeName(b"fs2@send-origin-2")
+ clone = ZFSTest.pool.makeName(b"fs1/fs/send-clone-2")
+ clone_snap = clone + b"@snap"
+ orig_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-origin-2@snap")
+ clone_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-clone-2@snap")
lzc.lzc_snapshot([orig_src])
with tempfile.TemporaryFile(suffix='.ztream') as stream:
lzc.lzc_receive(clone_dst, stream.fileno())
def test_recv_clone_invalid_origin(self):
- orig_src = ZFSTest.pool.makeName("fs2@send-origin-3")
- clone = ZFSTest.pool.makeName("fs1/fs/send-clone-3")
- clone_snap = clone + "@snap"
- orig_dst = ZFSTest.pool.makeName("fs1/fs/recv-origin-3@snap")
- clone_dst = ZFSTest.pool.makeName("fs1/fs/recv-clone-3@snap")
+ orig_src = ZFSTest.pool.makeName(b"fs2@send-origin-3")
+ clone = ZFSTest.pool.makeName(b"fs1/fs/send-clone-3")
+ clone_snap = clone + b"@snap"
+ orig_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-origin-3@snap")
+ clone_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-clone-3@snap")
lzc.lzc_snapshot([orig_src])
with tempfile.TemporaryFile(suffix='.ztream') as stream:
with self.assertRaises(lzc_exc.NameInvalid):
lzc.lzc_receive(
clone_dst, stream.fileno(),
- origin=ZFSTest.pool.makeName("fs1/fs"))
+ origin=ZFSTest.pool.makeName(b"fs1/fs"))
def test_recv_clone_wrong_origin(self):
- orig_src = ZFSTest.pool.makeName("fs2@send-origin-4")
- clone = ZFSTest.pool.makeName("fs1/fs/send-clone-4")
- clone_snap = clone + "@snap"
- orig_dst = ZFSTest.pool.makeName("fs1/fs/recv-origin-4@snap")
- clone_dst = ZFSTest.pool.makeName("fs1/fs/recv-clone-4@snap")
- wrong_origin = ZFSTest.pool.makeName("fs1/fs@snap")
+ orig_src = ZFSTest.pool.makeName(b"fs2@send-origin-4")
+ clone = ZFSTest.pool.makeName(b"fs1/fs/send-clone-4")
+ clone_snap = clone + b"@snap"
+ orig_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-origin-4@snap")
+ clone_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-clone-4@snap")
+ wrong_origin = ZFSTest.pool.makeName(b"fs1/fs@snap")
lzc.lzc_snapshot([orig_src])
with tempfile.TemporaryFile(suffix='.ztream') as stream:
clone_dst, stream.fileno(), origin=wrong_origin)
def test_recv_clone_nonexistent_origin(self):
- orig_src = ZFSTest.pool.makeName("fs2@send-origin-5")
- clone = ZFSTest.pool.makeName("fs1/fs/send-clone-5")
- clone_snap = clone + "@snap"
- orig_dst = ZFSTest.pool.makeName("fs1/fs/recv-origin-5@snap")
- clone_dst = ZFSTest.pool.makeName("fs1/fs/recv-clone-5@snap")
- wrong_origin = ZFSTest.pool.makeName("fs1/fs@snap")
+ orig_src = ZFSTest.pool.makeName(b"fs2@send-origin-5")
+ clone = ZFSTest.pool.makeName(b"fs1/fs/send-clone-5")
+ clone_snap = clone + b"@snap"
+ orig_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-origin-5@snap")
+ clone_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-clone-5@snap")
+ wrong_origin = ZFSTest.pool.makeName(b"fs1/fs@snap")
lzc.lzc_snapshot([orig_src])
with tempfile.TemporaryFile(suffix='.ztream') as stream:
clone_dst, stream.fileno(), origin=wrong_origin)
def test_force_recv_full_existing_fs(self):
- src = ZFSTest.pool.makeName("fs1@snap")
- dstfs = ZFSTest.pool.makeName("fs2/received-50")
- dst = dstfs + '@snap'
+ src = ZFSTest.pool.makeName(b"fs1@snap")
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-50")
+ dst = dstfs + b'@snap'
- with temp_file_in_fs(ZFSTest.pool.makeName("fs1")):
+ with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
lzc.lzc_snapshot([src])
lzc.lzc_create(dstfs)
lzc.lzc_receive(dst, stream.fileno(), force=True)
def test_force_recv_full_existing_modified_mounted_fs(self):
- src = ZFSTest.pool.makeName("fs1@snap")
- dstfs = ZFSTest.pool.makeName("fs2/received-53")
- dst = dstfs + '@snap'
+ src = ZFSTest.pool.makeName(b"fs1@snap")
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-53")
+ dst = dstfs + b'@snap'
- with temp_file_in_fs(ZFSTest.pool.makeName("fs1")):
+ with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
lzc.lzc_snapshot([src])
lzc.lzc_create(dstfs)
with zfs_mount(dstfs) as mntdir:
f = tempfile.NamedTemporaryFile(dir=mntdir, delete=False)
for i in range(1024):
- f.write('x' * 1024)
+ f.write(b'x' * 1024)
lzc.lzc_receive(dst, stream.fileno(), force=True)
# The temporary file dissappears and any access, even close(),
# results in EIO.
# at the moment it may fail with DatasetExists or StreamMismatch
# depending on the implementation.
def test_force_recv_full_already_existing_with_snapshots(self):
- src = ZFSTest.pool.makeName("fs1@snap")
- dstfs = ZFSTest.pool.makeName("fs2/received-51")
- dst = dstfs + '@snap'
+ src = ZFSTest.pool.makeName(b"fs1@snap")
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-51")
+ dst = dstfs + b'@snap'
- with temp_file_in_fs(ZFSTest.pool.makeName("fs1")):
+ with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
lzc.lzc_snapshot([src])
lzc.lzc_create(dstfs)
with temp_file_in_fs(dstfs):
pass # enough to taint the fs
- lzc.lzc_snapshot([dstfs + "@snap1"])
+ lzc.lzc_snapshot([dstfs + b"@snap1"])
with tempfile.TemporaryFile(suffix='.ztream') as stream:
lzc.lzc_send(src, None, stream.fileno())
lzc.lzc_receive(dst, stream.fileno(), force=True)
def test_force_recv_full_already_existing_with_same_snap(self):
- src = ZFSTest.pool.makeName("fs1@snap")
- dstfs = ZFSTest.pool.makeName("fs2/received-52")
- dst = dstfs + '@snap'
+ src = ZFSTest.pool.makeName(b"fs1@snap")
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-52")
+ dst = dstfs + b'@snap'
- with temp_file_in_fs(ZFSTest.pool.makeName("fs1")):
+ with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
lzc.lzc_snapshot([src])
lzc.lzc_create(dstfs)
lzc.lzc_receive(dst, stream.fileno(), force=True)
def test_force_recv_full_missing_parent_fs(self):
- src = ZFSTest.pool.makeName("fs1@snap")
- dst = ZFSTest.pool.makeName("fs2/nonexistent/fs@snap")
+ src = ZFSTest.pool.makeName(b"fs1@snap")
+ dst = ZFSTest.pool.makeName(b"fs2/nonexistent/fs@snap")
- with temp_file_in_fs(ZFSTest.pool.makeName("fs1")):
+ with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
lzc.lzc_snapshot([src])
with tempfile.TemporaryFile(suffix='.ztream') as stream:
lzc.lzc_send(src, None, stream.fileno())
lzc.lzc_receive(dst, stream.fileno(), force=True)
def test_force_recv_incremental_modified_fs(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-60")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-60")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
lzc.lzc_receive(dst2, incr.fileno(), force=True)
def test_force_recv_incremental_modified_mounted_fs(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-64")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-64")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
with zfs_mount(dstfs) as mntdir:
f = tempfile.NamedTemporaryFile(dir=mntdir, delete=False)
for i in range(1024):
- f.write('x' * 1024)
+ f.write(b'x' * 1024)
lzc.lzc_receive(dst2, incr.fileno(), force=True)
# The temporary file dissappears and any access, even close(),
# results in EIO.
f.close()
def test_force_recv_incremental_modified_fs_plus_later_snap(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-61")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
- dst3 = dstfs + '@snap'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-61")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
+ dst3 = dstfs + b'@snap'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
self.assertNotExists(dst3)
def test_force_recv_incremental_modified_fs_plus_same_name_snap(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-62")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-62")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
lzc.lzc_receive(dst2, incr.fileno(), force=True)
def test_force_recv_incremental_modified_fs_plus_held_snap(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-63")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
- dst3 = dstfs + '@snap'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-63")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
+ dst3 = dstfs + b'@snap'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
pass # enough to taint the fs
lzc.lzc_snapshot([dst3])
with cleanup_fd() as cfd:
- lzc.lzc_hold({dst3: 'tag'}, cfd)
+ lzc.lzc_hold({dst3: b'tag'}, cfd)
with self.assertRaises(lzc_exc.DatasetBusy):
lzc.lzc_receive(dst2, incr.fileno(), force=True)
self.assertExists(dst1)
self.assertExists(dst3)
def test_force_recv_incremental_modified_fs_plus_cloned_snap(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-70")
- dst1 = dstfs + '@snap1'
- dst2 = dstfs + '@snap2'
- dst3 = dstfs + '@snap'
- cloned = ZFSTest.pool.makeName("fs2/received-cloned-70")
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-70")
+ dst1 = dstfs + b'@snap1'
+ dst2 = dstfs + b'@snap2'
+ dst3 = dstfs + b'@snap'
+ cloned = ZFSTest.pool.makeName(b"fs2/received-cloned-70")
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
self.assertExists(dst3)
def test_recv_incremental_into_cloned_fs(self):
- srcfs = ZFSTest.pool.makeName("fs1")
- src1 = srcfs + "@snap1"
- src2 = srcfs + "@snap2"
- dstfs = ZFSTest.pool.makeName("fs2/received-71")
- dst1 = dstfs + '@snap1'
- cloned = ZFSTest.pool.makeName("fs2/received-cloned-71")
- dst2 = cloned + '@snap'
+ srcfs = ZFSTest.pool.makeName(b"fs1")
+ src1 = srcfs + b"@snap1"
+ src2 = srcfs + b"@snap2"
+ dstfs = ZFSTest.pool.makeName(b"fs2/received-71")
+ dst1 = dstfs + b'@snap1'
+ cloned = ZFSTest.pool.makeName(b"fs2/received-cloned-71")
+ dst2 = cloned + b'@snap'
with streams(srcfs, src1, src2) as (_, (full, incr)):
lzc.lzc_receive(dst1, full.fileno())
self.assertNotExists(dst2)
def test_recv_with_header_full(self):
- src = ZFSTest.pool.makeName("fs1@snap")
- dst = ZFSTest.pool.makeName("fs2/received")
+ src = ZFSTest.pool.makeName(b"fs1@snap")
+ dst = ZFSTest.pool.makeName(b"fs2/received")
- with temp_file_in_fs(ZFSTest.pool.makeName("fs1")) as name:
+ with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")) as name:
lzc.lzc_snapshot([src])
with tempfile.TemporaryFile(suffix='.ztream') as stream:
(header, c_header) = lzc.receive_header(stream.fileno())
self.assertEqual(src, header['drr_toname'])
- snap = header['drr_toname'].split('@', 1)[1]
+ snap = header['drr_toname'].split(b'@', 1)[1]
lzc.lzc_receive_with_header(
- dst + '@' + snap, stream.fileno(), c_header)
+ dst + b'@' + snap, stream.fileno(), c_header)
name = os.path.basename(name)
with zfs_mount(src) as mnt1, zfs_mount(dst) as mnt2:
os.path.join(mnt1, name), os.path.join(mnt2, name), False))
def test_send_full_across_clone_branch_point(self):
- origfs = ZFSTest.pool.makeName("fs2")
+ origfs = ZFSTest.pool.makeName(b"fs2")
(_, (fromsnap, origsnap, _)) = make_snapshots(
- origfs, "snap1", "send-origin-20", None)
+ origfs, b"snap1", b"send-origin-20", None)
- clonefs = ZFSTest.pool.makeName("fs1/fs/send-clone-20")
+ clonefs = ZFSTest.pool.makeName(b"fs1/fs/send-clone-20")
lzc.lzc_clone(clonefs, origsnap)
- (_, (_, tosnap, _)) = make_snapshots(clonefs, None, "snap", None)
+ (_, (_, tosnap, _)) = make_snapshots(clonefs, None, b"snap", None)
with tempfile.TemporaryFile(suffix='.ztream') as stream:
lzc.lzc_send(tosnap, None, stream.fileno())
def test_send_incr_across_clone_branch_point(self):
- origfs = ZFSTest.pool.makeName("fs2")
+ origfs = ZFSTest.pool.makeName(b"fs2")
(_, (fromsnap, origsnap, _)) = make_snapshots(
- origfs, "snap1", "send-origin-21", None)
+ origfs, b"snap1", b"send-origin-21", None)
- clonefs = ZFSTest.pool.makeName("fs1/fs/send-clone-21")
+ clonefs = ZFSTest.pool.makeName(b"fs1/fs/send-clone-21")
lzc.lzc_clone(clonefs, origsnap)
- (_, (_, tosnap, _)) = make_snapshots(clonefs, None, "snap", None)
+ (_, (_, tosnap, _)) = make_snapshots(clonefs, None, b"snap", None)
with tempfile.TemporaryFile(suffix='.ztream') as stream:
lzc.lzc_send(tosnap, fromsnap, stream.fileno())
def test_send_resume_token_full(self):
- src = ZFSTest.pool.makeName("fs1@snap")
- dstfs = ZFSTest.pool.getFilesystem("fs2/received")
+ src = ZFSTest.pool.makeName(b"fs1@snap")
+ dstfs = ZFSTest.pool.getFilesystem(b"fs2/received")
dst = dstfs.getSnap()
- with zfs_mount(ZFSTest.pool.makeName("fs1")) as mntdir:
+ with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
for i in range(1, 10):
with tempfile.NamedTemporaryFile(dir=mntdir) as f:
- f.write('x' * 1024 * i)
+ f.write(b'x' * 1024 * i)
f.flush()
lzc.lzc_snapshot([src])
# XXX: if used more than twice move this code into an external func
# format: <version>-<cksum>-<packed-size>-<compressed-payload>
token = dstfs.getProperty("receive_resume_token")
- self.assertNotEqual(token, '-')
- tokens = token.split('-')
+ self.assertNotEqual(token, b'-')
+ tokens = token.split(b'-')
self.assertEqual(len(tokens), 4)
version = tokens[0]
packed_size = int(tokens[2], 16)
compressed_nvs = tokens[3]
# Validate resume token
- self.assertEqual(version, '1') # ZFS_SEND_RESUME_TOKEN_VERSION
- payload = zlib.decompress(str(bytearray.fromhex(compressed_nvs)))
+ self.assertEqual(version, b'1') # ZFS_SEND_RESUME_TOKEN_VERSION
+ if sys.version_info < (3, 0):
+ payload = (
+ zlib.decompress(str(bytearray.fromhex(compressed_nvs)))
+ )
+ else:
+ payload = (
+ zlib.decompress(bytearray.fromhex(compressed_nvs.decode()))
+ )
self.assertEqual(len(payload), packed_size)
# Unpack
resume_values = packed_nvlist_out(payload, packed_size)
- resumeobj = resume_values.get('object')
- resumeoff = resume_values.get('offset')
+ resumeobj = resume_values.get(b'object')
+ resumeoff = resume_values.get(b'offset')
with tempfile.NamedTemporaryFile(suffix='.ztream') as rstream:
lzc.lzc_send_resume(
src, None, rstream.fileno(), None, resumeobj, resumeoff)
lzc.lzc_receive_resumable(dst, rstream.fileno())
def test_send_resume_token_incremental(self):
- snap1 = ZFSTest.pool.makeName("fs1@snap1")
- snap2 = ZFSTest.pool.makeName("fs1@snap2")
- dstfs = ZFSTest.pool.getFilesystem("fs2/received")
+ snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
+ snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
+ dstfs = ZFSTest.pool.getFilesystem(b"fs2/received")
dst1 = dstfs.getSnap()
dst2 = dstfs.getSnap()
stream.seek(0)
lzc.lzc_receive(dst1, stream.fileno())
- with zfs_mount(ZFSTest.pool.makeName("fs1")) as mntdir:
+ with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
for i in range(1, 10):
with tempfile.NamedTemporaryFile(dir=mntdir) as f:
- f.write('x' * 1024 * i)
+ f.write(b'x' * 1024 * i)
f.flush()
lzc.lzc_snapshot([snap2])
# format: <version>-<cksum>-<packed-size>-<compressed-payload>
token = dstfs.getProperty("receive_resume_token")
self.assertNotEqual(token, '-')
- tokens = token.split('-')
+ tokens = token.split(b'-')
self.assertEqual(len(tokens), 4)
version = tokens[0]
packed_size = int(tokens[2], 16)
compressed_nvs = tokens[3]
# Validate resume token
- self.assertEqual(version, '1') # ZFS_SEND_RESUME_TOKEN_VERSION
- payload = zlib.decompress(str(bytearray.fromhex(compressed_nvs)))
+ self.assertEqual(version, b'1') # ZFS_SEND_RESUME_TOKEN_VERSION
+ if sys.version_info < (3, 0):
+ payload = (
+ zlib.decompress(str(bytearray.fromhex(compressed_nvs)))
+ )
+ else:
+ payload = (
+ zlib.decompress(bytearray.fromhex(compressed_nvs.decode()))
+ )
self.assertEqual(len(payload), packed_size)
# Unpack
resume_values = packed_nvlist_out(payload, packed_size)
- resumeobj = resume_values.get('object')
- resumeoff = resume_values.get('offset')
+ resumeobj = resume_values.get(b'object')
+ resumeoff = resume_values.get(b'offset')
with tempfile.NamedTemporaryFile(suffix='.ztream') as rstream:
lzc.lzc_send_resume(
snap2, snap1, rstream.fileno(), None, resumeobj, resumeoff)
lzc.lzc_receive_resumable(dst2, rstream.fileno())
def test_recv_full_across_clone_branch_point(self):
- origfs = ZFSTest.pool.makeName("fs2")
+ origfs = ZFSTest.pool.makeName(b"fs2")
(_, (fromsnap, origsnap, _)) = make_snapshots(
- origfs, "snap1", "send-origin-30", None)
+ origfs, b"snap1", b"send-origin-30", None)
- clonefs = ZFSTest.pool.makeName("fs1/fs/send-clone-30")
+ clonefs = ZFSTest.pool.makeName(b"fs1/fs/send-clone-30")
lzc.lzc_clone(clonefs, origsnap)
- (_, (_, tosnap, _)) = make_snapshots(clonefs, None, "snap", None)
+ (_, (_, tosnap, _)) = make_snapshots(clonefs, None, b"snap", None)
- recvfs = ZFSTest.pool.makeName("fs1/recv-clone-30")
- recvsnap = recvfs + "@snap"
+ recvfs = ZFSTest.pool.makeName(b"fs1/recv-clone-30")
+ recvsnap = recvfs + b"@snap"
with tempfile.TemporaryFile(suffix='.ztream') as stream:
lzc.lzc_send(tosnap, None, stream.fileno())
stream.seek(0)
lzc.lzc_receive(recvsnap, stream.fileno())
def test_recv_one(self):
- fromsnap = ZFSTest.pool.makeName("fs1@snap1")
- tosnap = ZFSTest.pool.makeName("recv@snap1")
+ fromsnap = ZFSTest.pool.makeName(b"fs1@snap1")
+ tosnap = ZFSTest.pool.makeName(b"recv@snap1")
lzc.lzc_snapshot([fromsnap])
with tempfile.TemporaryFile(suffix='.ztream') as stream:
lzc.lzc_receive_one(tosnap, stream.fileno(), c_header)
def test_recv_one_size(self):
- fromsnap = ZFSTest.pool.makeName("fs1@snap1")
- tosnap = ZFSTest.pool.makeName("recv@snap1")
+ fromsnap = ZFSTest.pool.makeName(b"fs1@snap1")
+ tosnap = ZFSTest.pool.makeName(b"recv@snap1")
lzc.lzc_snapshot([fromsnap])
with tempfile.TemporaryFile(suffix='.ztream') as stream:
self.assertAlmostEqual(read, size, delta=read * 0.05)
def test_recv_one_props(self):
- fromsnap = ZFSTest.pool.makeName("fs1@snap1")
- fs = ZFSTest.pool.getFilesystem("recv")
- tosnap = fs.getName() + "@snap1"
+ fromsnap = ZFSTest.pool.makeName(b"fs1@snap1")
+ fs = ZFSTest.pool.getFilesystem(b"recv")
+ tosnap = fs.getName() + b"@snap1"
props = {
- "compression": 0x01,
- "ns:prop": "val"
+ b"compression": 0x01,
+ b"ns:prop": b"val"
}
lzc.lzc_snapshot([fromsnap])
(header, c_header) = lzc.receive_header(stream.fileno())
lzc.lzc_receive_one(tosnap, stream.fileno(), c_header, props=props)
self.assertExists(tosnap)
- self.assertEqual(fs.getProperty("compression", "received"), "on")
- self.assertEqual(fs.getProperty("ns:prop", "received"), "val")
+ self.assertEqual(fs.getProperty("compression", "received"), b"on")
+ self.assertEqual(fs.getProperty("ns:prop", "received"), b"val")
def test_recv_one_invalid_prop(self):
- fromsnap = ZFSTest.pool.makeName("fs1@snap1")
- fs = ZFSTest.pool.getFilesystem("recv")
- tosnap = fs.getName() + "@snap1"
+ fromsnap = ZFSTest.pool.makeName(b"fs1@snap1")
+ fs = ZFSTest.pool.getFilesystem(b"recv")
+ tosnap = fs.getName() + b"@snap1"
props = {
- "exec": 0xff,
- "atime": 0x00
+ b"exec": 0xff,
+ b"atime": 0x00
}
lzc.lzc_snapshot([fromsnap])
lzc.lzc_receive_one(
tosnap, stream.fileno(), c_header, props=props)
self.assertExists(tosnap)
- self.assertEqual(fs.getProperty("atime", "received"), "off")
+ self.assertEqual(fs.getProperty("atime", "received"), b"off")
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.PropertyInvalid)
- self.assertEqual(e.name, "exec")
+ self.assertEqual(e.name, b"exec")
def test_recv_with_cmdprops(self):
- fromsnap = ZFSTest.pool.makeName("fs1@snap1")
- fs = ZFSTest.pool.getFilesystem("recv")
- tosnap = fs.getName() + "@snap1"
+ fromsnap = ZFSTest.pool.makeName(b"fs1@snap1")
+ fs = ZFSTest.pool.getFilesystem(b"recv")
+ tosnap = fs.getName() + b"@snap1"
props = {}
cmdprops = {
- "compression": 0x01,
- "ns:prop": "val"
+ b"compression": 0x01,
+ b"ns:prop": b"val"
}
lzc.lzc_snapshot([fromsnap])
tosnap, stream.fileno(), c_header, props=props,
cmdprops=cmdprops)
self.assertExists(tosnap)
- self.assertEqual(fs.getProperty("compression"), "on")
- self.assertEqual(fs.getProperty("ns:prop"), "val")
+ self.assertEqual(fs.getProperty("compression"), b"on")
+ self.assertEqual(fs.getProperty("ns:prop"), b"val")
def test_recv_with_cmdprops_and_recvprops(self):
- fromsnap = ZFSTest.pool.makeName("fs1@snap1")
- fs = ZFSTest.pool.getFilesystem("recv")
- tosnap = fs.getName() + "@snap1"
+ fromsnap = ZFSTest.pool.makeName(b"fs1@snap1")
+ fs = ZFSTest.pool.getFilesystem(b"recv")
+ tosnap = fs.getName() + b"@snap1"
props = {
- "atime": 0x01,
- "exec": 0x00,
- "ns:prop": "abc"
+ b"atime": 0x01,
+ b"exec": 0x00,
+ b"ns:prop": b"abc"
}
cmdprops = {
- "compression": 0x01,
- "ns:prop": "def",
- "exec": None,
+ b"compression": 0x01,
+ b"ns:prop": b"def",
+ b"exec": None,
}
lzc.lzc_snapshot([fromsnap])
tosnap, stream.fileno(), c_header, props=props,
cmdprops=cmdprops)
self.assertExists(tosnap)
- self.assertEqual(fs.getProperty("atime", True), "on")
- self.assertEqual(fs.getProperty("exec", True), "off")
- self.assertEqual(fs.getProperty("ns:prop", True), "abc")
- self.assertEqual(fs.getProperty("compression"), "on")
- self.assertEqual(fs.getProperty("ns:prop"), "def")
- self.assertEqual(fs.getProperty("exec"), "on")
+ self.assertEqual(fs.getProperty("atime", True), b"on")
+ self.assertEqual(fs.getProperty("exec", True), b"off")
+ self.assertEqual(fs.getProperty("ns:prop", True), b"abc")
+ self.assertEqual(fs.getProperty("compression"), b"on")
+ self.assertEqual(fs.getProperty("ns:prop"), b"def")
+ self.assertEqual(fs.getProperty("exec"), b"on")
def test_recv_incr_across_clone_branch_point_no_origin(self):
- origfs = ZFSTest.pool.makeName("fs2")
+ origfs = ZFSTest.pool.makeName(b"fs2")
(_, (fromsnap, origsnap, _)) = make_snapshots(
- origfs, "snap1", "send-origin-32", None)
+ origfs, b"snap1", b"send-origin-32", None)
- clonefs = ZFSTest.pool.makeName("fs1/fs/send-clone-32")
+ clonefs = ZFSTest.pool.makeName(b"fs1/fs/send-clone-32")
lzc.lzc_clone(clonefs, origsnap)
- (_, (_, tosnap, _)) = make_snapshots(clonefs, None, "snap", None)
+ (_, (_, tosnap, _)) = make_snapshots(clonefs, None, b"snap", None)
- recvfs = ZFSTest.pool.makeName("fs1/recv-clone-32")
- recvsnap1 = recvfs + "@snap1"
- recvsnap2 = recvfs + "@snap2"
+ recvfs = ZFSTest.pool.makeName(b"fs1/recv-clone-32")
+ recvsnap1 = recvfs + b"@snap1"
+ recvsnap2 = recvfs + b"@snap2"
with tempfile.TemporaryFile(suffix='.ztream') as stream:
lzc.lzc_send(fromsnap, None, stream.fileno())
stream.seek(0)
lzc.lzc_receive(recvsnap2, stream.fileno())
def test_recv_incr_across_clone_branch_point(self):
- origfs = ZFSTest.pool.makeName("fs2")
+ origfs = ZFSTest.pool.makeName(b"fs2")
(_, (fromsnap, origsnap, _)) = make_snapshots(
- origfs, "snap1", "send-origin-31", None)
+ origfs, b"snap1", b"send-origin-31", None)
- clonefs = ZFSTest.pool.makeName("fs1/fs/send-clone-31")
+ clonefs = ZFSTest.pool.makeName(b"fs1/fs/send-clone-31")
lzc.lzc_clone(clonefs, origsnap)
- (_, (_, tosnap, _)) = make_snapshots(clonefs, None, "snap", None)
+ (_, (_, tosnap, _)) = make_snapshots(clonefs, None, b"snap", None)
- recvfs = ZFSTest.pool.makeName("fs1/recv-clone-31")
- recvsnap1 = recvfs + "@snap1"
- recvsnap2 = recvfs + "@snap2"
+ recvfs = ZFSTest.pool.makeName(b"fs1/recv-clone-31")
+ recvsnap1 = recvfs + b"@snap1"
+ recvsnap2 = recvfs + b"@snap2"
with tempfile.TemporaryFile(suffix='.ztream') as stream:
lzc.lzc_send(fromsnap, None, stream.fileno())
stream.seek(0)
lzc.lzc_receive(recvsnap2, stream.fileno(), origin=recvsnap1)
def test_recv_incr_across_clone_branch_point_new_fs(self):
- origfs = ZFSTest.pool.makeName("fs2")
+ origfs = ZFSTest.pool.makeName(b"fs2")
(_, (fromsnap, origsnap, _)) = make_snapshots(
- origfs, "snap1", "send-origin-33", None)
+ origfs, b"snap1", b"send-origin-33", None)
- clonefs = ZFSTest.pool.makeName("fs1/fs/send-clone-33")
+ clonefs = ZFSTest.pool.makeName(b"fs1/fs/send-clone-33")
lzc.lzc_clone(clonefs, origsnap)
- (_, (_, tosnap, _)) = make_snapshots(clonefs, None, "snap", None)
+ (_, (_, tosnap, _)) = make_snapshots(clonefs, None, b"snap", None)
- recvfs1 = ZFSTest.pool.makeName("fs1/recv-clone-33")
- recvsnap1 = recvfs1 + "@snap"
- recvfs2 = ZFSTest.pool.makeName("fs1/recv-clone-33_2")
- recvsnap2 = recvfs2 + "@snap"
+ recvfs1 = ZFSTest.pool.makeName(b"fs1/recv-clone-33")
+ recvsnap1 = recvfs1 + b"@snap"
+ recvfs2 = ZFSTest.pool.makeName(b"fs1/recv-clone-33_2")
+ recvsnap2 = recvfs2 + b"@snap"
with tempfile.TemporaryFile(suffix='.ztream') as stream:
lzc.lzc_send(fromsnap, None, stream.fileno())
stream.seek(0)
lzc.lzc_receive(recvsnap2, stream.fileno(), origin=recvsnap1)
def test_recv_bad_stream(self):
- dstfs = ZFSTest.pool.makeName("fs2/received")
- dst_snap = dstfs + '@snap'
+ dstfs = ZFSTest.pool.makeName(b"fs2/received")
+ dst_snap = dstfs + b'@snap'
with dev_zero() as fd:
with self.assertRaises(lzc_exc.BadStream):
@needs_support(lzc.lzc_promote)
def test_promote(self):
- origfs = ZFSTest.pool.makeName("fs2")
- snap = "@promote-snap-1"
+ origfs = ZFSTest.pool.makeName(b"fs2")
+ snap = b"@promote-snap-1"
origsnap = origfs + snap
lzc.lzc_snap([origsnap])
- clonefs = ZFSTest.pool.makeName("fs1/fs/promote-clone-1")
+ clonefs = ZFSTest.pool.makeName(b"fs1/fs/promote-clone-1")
lzc.lzc_clone(clonefs, origsnap)
lzc.lzc_promote(clonefs)
@needs_support(lzc.lzc_promote)
def test_promote_too_long_snapname(self):
# origfs name must be shorter than clonefs name
- origfs = ZFSTest.pool.makeName("fs2")
- clonefs = ZFSTest.pool.makeName("fs1/fs/promote-clone-2")
- snapprefix = "@promote-snap-2-"
+ origfs = ZFSTest.pool.makeName(b"fs2")
+ clonefs = ZFSTest.pool.makeName(b"fs1/fs/promote-clone-2")
+ snapprefix = b"@promote-snap-2-"
pad_len = 1 + lzc.MAXNAMELEN - len(clonefs) - len(snapprefix)
- snap = snapprefix + 'x' * pad_len
+ snap = snapprefix + b'x' * pad_len
origsnap = origfs + snap
lzc.lzc_snap([origsnap])
@needs_support(lzc.lzc_promote)
def test_promote_not_cloned(self):
- fs = ZFSTest.pool.makeName("fs2")
+ fs = ZFSTest.pool.makeName(b"fs2")
with self.assertRaises(lzc_exc.NotClone):
lzc.lzc_promote(fs)
bad_fd = tmp.fileno()
with self.assertRaises(lzc_exc.BadHoldCleanupFD):
- lzc.lzc_hold({snap: 'tag'}, bad_fd)
+ lzc.lzc_hold({snap: b'tag'}, bad_fd)
@unittest.skipIf(*illumos_bug_6379())
def test_hold_bad_fd_2(self):
lzc.lzc_snapshot([snap])
with self.assertRaises(lzc_exc.BadHoldCleanupFD):
- lzc.lzc_hold({snap: 'tag'}, -2)
+ lzc.lzc_hold({snap: b'tag'}, -2)
@unittest.skipIf(*illumos_bug_6379())
def test_hold_bad_fd_3(self):
(soft, hard) = resource.getrlimit(resource.RLIMIT_NOFILE)
bad_fd = hard + 1
with self.assertRaises(lzc_exc.BadHoldCleanupFD):
- lzc.lzc_hold({snap: 'tag'}, bad_fd)
+ lzc.lzc_hold({snap: b'tag'}, bad_fd)
@unittest.skipIf(*illumos_bug_6379())
def test_hold_wrong_fd(self):
with tempfile.TemporaryFile() as tmp:
fd = tmp.fileno()
with self.assertRaises(lzc_exc.BadHoldCleanupFD):
- lzc.lzc_hold({snap: 'tag'}, fd)
+ lzc.lzc_hold({snap: b'tag'}, fd)
def test_hold_fd(self):
snap = ZFSTest.pool.getRoot().getSnap()
lzc.lzc_snapshot([snap])
with cleanup_fd() as fd:
- lzc.lzc_hold({snap: 'tag'}, fd)
+ lzc.lzc_hold({snap: b'tag'}, fd)
def test_hold_empty(self):
with cleanup_fd() as fd:
lzc.lzc_snapshot([snap])
with cleanup_fd() as fd:
- lzc.lzc_hold({snap: 'tag'}, fd)
+ lzc.lzc_hold({snap: b'tag'}, fd)
with self.assertRaises(lzc_exc.SnapshotDestructionFailure) as ctx:
lzc.lzc_destroy_snaps([snap], defer=False)
lzc.lzc_snapshot([snap])
with cleanup_fd() as fd:
- lzc.lzc_hold({snap: 'tag1'}, fd)
- lzc.lzc_hold({snap: 'tag2'}, fd)
+ lzc.lzc_hold({snap: b'tag1'}, fd)
+ lzc.lzc_hold({snap: b'tag2'}, fd)
def test_hold_many_snaps(self):
snap1 = ZFSTest.pool.getRoot().getSnap()
lzc.lzc_snapshot([snap2])
with cleanup_fd() as fd:
- lzc.lzc_hold({snap1: 'tag', snap2: 'tag'}, fd)
+ lzc.lzc_hold({snap1: b'tag', snap2: b'tag'}, fd)
def test_hold_many_with_one_missing(self):
snap1 = ZFSTest.pool.getRoot().getSnap()
lzc.lzc_snapshot([snap1])
with cleanup_fd() as fd:
- missing = lzc.lzc_hold({snap1: 'tag', snap2: 'tag'}, fd)
+ missing = lzc.lzc_hold({snap1: b'tag', snap2: b'tag'}, fd)
self.assertEqual(len(missing), 1)
self.assertEqual(missing[0], snap2)
snap2 = ZFSTest.pool.getRoot().getSnap()
with cleanup_fd() as fd:
- missing = lzc.lzc_hold({snap1: 'tag', snap2: 'tag'}, fd)
+ missing = lzc.lzc_hold({snap1: b'tag', snap2: b'tag'}, fd)
self.assertEqual(len(missing), 2)
self.assertEqual(sorted(missing), sorted([snap1, snap2]))
ZFSTest.pool.getRoot().getFilesystem()
snap = ZFSTest.pool.getRoot().getFilesystem().getSnap()
- snaps = lzc.lzc_hold({snap: 'tag'})
+ snaps = lzc.lzc_hold({snap: b'tag'})
self.assertEqual([snap], snaps)
def test_hold_missing_fs_auto_cleanup(self):
snap = ZFSTest.pool.getRoot().getFilesystem().getSnap()
with cleanup_fd() as fd:
- snaps = lzc.lzc_hold({snap: 'tag'}, fd)
+ snaps = lzc.lzc_hold({snap: b'tag'}, fd)
self.assertEqual([snap], snaps)
def test_hold_duplicate(self):
lzc.lzc_snapshot([snap])
with cleanup_fd() as fd:
- lzc.lzc_hold({snap: 'tag'}, fd)
+ lzc.lzc_hold({snap: b'tag'}, fd)
with self.assertRaises(lzc_exc.HoldFailure) as ctx:
- lzc.lzc_hold({snap: 'tag'}, fd)
+ lzc.lzc_hold({snap: b'tag'}, fd)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.HoldExists)
with cleanup_fd() as fd:
with self.assertRaises(lzc_exc.HoldFailure) as ctx:
- lzc.lzc_hold({snap1: 'tag', snap2: 'tag'}, fd)
+ lzc.lzc_hold({snap1: b'tag', snap2: b'tag'}, fd)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.PoolsDiffer)
def test_hold_too_long_tag(self):
snap = ZFSTest.pool.getRoot().getSnap()
- tag = 't' * 256
+ tag = b't' * 256
lzc.lzc_snapshot([snap])
with cleanup_fd() as fd:
snap = ZFSTest.pool.getRoot().getTooLongSnap(False)
with cleanup_fd() as fd:
with self.assertRaises(lzc_exc.HoldFailure) as ctx:
- lzc.lzc_hold({snap: 'tag'}, fd)
+ lzc.lzc_hold({snap: b'tag'}, fd)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameTooLong)
self.assertEqual(e.name, snap)
snap = ZFSTest.pool.getRoot().getTooLongSnap(True)
with cleanup_fd() as fd:
with self.assertRaises(lzc_exc.HoldFailure) as ctx:
- lzc.lzc_hold({snap: 'tag'}, fd)
+ lzc.lzc_hold({snap: b'tag'}, fd)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameTooLong)
self.assertEqual(e.name, snap)
def test_hold_invalid_snap_name(self):
- snap = ZFSTest.pool.getRoot().getSnap() + '@bad'
+ snap = ZFSTest.pool.getRoot().getSnap() + b'@bad'
with cleanup_fd() as fd:
with self.assertRaises(lzc_exc.HoldFailure) as ctx:
- lzc.lzc_hold({snap: 'tag'}, fd)
+ lzc.lzc_hold({snap: b'tag'}, fd)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameInvalid)
self.assertEqual(e.name, snap)
snap = ZFSTest.pool.getRoot().getFilesystem().getName()
with cleanup_fd() as fd:
with self.assertRaises(lzc_exc.HoldFailure) as ctx:
- lzc.lzc_hold({snap: 'tag'}, fd)
+ lzc.lzc_hold({snap: b'tag'}, fd)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameInvalid)
self.assertEqual(e.name, snap)
lzc.lzc_snapshot([snap])
with cleanup_fd() as fd:
- lzc.lzc_hold({snap: 'tag1'}, fd)
- lzc.lzc_hold({snap: 'tag2'}, fd)
+ lzc.lzc_hold({snap: b'tag1'}, fd)
+ lzc.lzc_hold({snap: b'tag2'}, fd)
holds = lzc.lzc_get_holds(snap)
self.assertEqual(len(holds), 2)
- self.assertIn('tag1', holds)
- self.assertIn('tag2', holds)
- self.assertIsInstance(holds['tag1'], (int, int))
+ self.assertIn(b'tag1', holds)
+ self.assertIn(b'tag2', holds)
+ self.assertIsInstance(holds[b'tag1'], (int, int))
def test_get_holds_after_auto_cleanup(self):
snap = ZFSTest.pool.getRoot().getSnap()
lzc.lzc_snapshot([snap])
with cleanup_fd() as fd:
- lzc.lzc_hold({snap: 'tag1'}, fd)
- lzc.lzc_hold({snap: 'tag2'}, fd)
+ lzc.lzc_hold({snap: b'tag1'}, fd)
+ lzc.lzc_hold({snap: b'tag2'}, fd)
holds = lzc.lzc_get_holds(snap)
self.assertEqual(len(holds), 0)
lzc.lzc_get_holds(snap)
def test_get_holds_invalid_snap_name(self):
- snap = ZFSTest.pool.getRoot().getSnap() + '@bad'
+ snap = ZFSTest.pool.getRoot().getSnap() + b'@bad'
with self.assertRaises(lzc_exc.NameInvalid):
lzc.lzc_get_holds(snap)
snap = ZFSTest.pool.getRoot().getSnap()
lzc.lzc_snapshot([snap])
- lzc.lzc_hold({snap: 'tag'})
- ret = lzc.lzc_release({snap: ['tag']})
+ lzc.lzc_hold({snap: b'tag'})
+ ret = lzc.lzc_release({snap: [b'tag']})
self.assertEqual(len(ret), 0)
def test_release_hold_empty(self):
lzc.lzc_snapshot([snap1])
lzc.lzc_snapshot([snap2, snap3])
- lzc.lzc_hold({snap1: 'tag1'})
- lzc.lzc_hold({snap1: 'tag2'})
- lzc.lzc_hold({snap2: 'tag'})
- lzc.lzc_hold({snap3: 'tag1'})
- lzc.lzc_hold({snap3: 'tag2'})
+ lzc.lzc_hold({snap1: b'tag1'})
+ lzc.lzc_hold({snap1: b'tag2'})
+ lzc.lzc_hold({snap2: b'tag'})
+ lzc.lzc_hold({snap3: b'tag1'})
+ lzc.lzc_hold({snap3: b'tag2'})
holds = lzc.lzc_get_holds(snap1)
self.assertEqual(len(holds), 2)
self.assertEqual(len(holds), 2)
release = {
- snap1: ['tag1', 'tag2'],
- snap2: ['tag'],
- snap3: ['tag2'],
+ snap1: [b'tag1', b'tag2'],
+ snap2: [b'tag'],
+ snap3: [b'tag2'],
}
ret = lzc.lzc_release(release)
self.assertEqual(len(ret), 0)
holds = lzc.lzc_get_holds(snap3)
self.assertEqual(len(holds), 1)
- ret = lzc.lzc_release({snap3: ['tag1']})
+ ret = lzc.lzc_release({snap3: [b'tag1']})
self.assertEqual(len(ret), 0)
holds = lzc.lzc_get_holds(snap3)
self.assertEqual(len(holds), 0)
lzc.lzc_snapshot([snap])
with cleanup_fd() as fd:
- lzc.lzc_hold({snap: 'tag'}, fd)
- ret = lzc.lzc_release({snap: ['tag']})
+ lzc.lzc_hold({snap: b'tag'}, fd)
+ ret = lzc.lzc_release({snap: [b'tag']})
self.assertEqual(len(ret), 0)
def test_release_hold_and_snap_destruction(self):
lzc.lzc_snapshot([snap])
with cleanup_fd() as fd:
- lzc.lzc_hold({snap: 'tag1'}, fd)
- lzc.lzc_hold({snap: 'tag2'}, fd)
+ lzc.lzc_hold({snap: b'tag1'}, fd)
+ lzc.lzc_hold({snap: b'tag2'}, fd)
lzc.lzc_destroy_snaps([snap], defer=True)
self.assertExists(snap)
- lzc.lzc_release({snap: ['tag1']})
+ lzc.lzc_release({snap: [b'tag1']})
self.assertExists(snap)
- lzc.lzc_release({snap: ['tag2']})
+ lzc.lzc_release({snap: [b'tag2']})
self.assertNotExists(snap)
def test_release_hold_and_multiple_snap_destruction(self):
lzc.lzc_snapshot([snap])
with cleanup_fd() as fd:
- lzc.lzc_hold({snap: 'tag'}, fd)
+ lzc.lzc_hold({snap: b'tag'}, fd)
lzc.lzc_destroy_snaps([snap], defer=True)
self.assertExists(snap)
lzc.lzc_destroy_snaps([snap], defer=True)
self.assertExists(snap)
- lzc.lzc_release({snap: ['tag']})
+ lzc.lzc_release({snap: [b'tag']})
self.assertNotExists(snap)
def test_release_hold_missing_tag(self):
snap = ZFSTest.pool.getRoot().getSnap()
lzc.lzc_snapshot([snap])
- ret = lzc.lzc_release({snap: ['tag']})
+ ret = lzc.lzc_release({snap: [b'tag']})
self.assertEqual(len(ret), 1)
- self.assertEqual(ret[0], snap + '#tag')
+ self.assertEqual(ret[0], snap + b'#tag')
def test_release_hold_missing_snap(self):
snap = ZFSTest.pool.getRoot().getSnap()
- ret = lzc.lzc_release({snap: ['tag']})
+ ret = lzc.lzc_release({snap: [b'tag']})
self.assertEqual(len(ret), 1)
self.assertEqual(ret[0], snap)
def test_release_hold_missing_snap_2(self):
snap = ZFSTest.pool.getRoot().getSnap()
- ret = lzc.lzc_release({snap: ['tag', 'another']})
+ ret = lzc.lzc_release({snap: [b'tag', b'another']})
self.assertEqual(len(ret), 1)
self.assertEqual(ret[0], snap)
lzc.lzc_snapshot([snap2])
with cleanup_fd() as fd:
- lzc.lzc_hold({snap1: 'tag'}, fd)
- lzc.lzc_hold({snap2: 'tag'}, fd)
+ lzc.lzc_hold({snap1: b'tag'}, fd)
+ lzc.lzc_hold({snap2: b'tag'}, fd)
with self.assertRaises(lzc_exc.HoldReleaseFailure) as ctx:
- lzc.lzc_release({snap1: ['tag'], snap2: ['tag']})
+ lzc.lzc_release({snap1: [b'tag'], snap2: [b'tag']})
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.PoolsDiffer)
@unittest.expectedFailure
def test_release_hold_too_long_tag(self):
snap = ZFSTest.pool.getRoot().getSnap()
- tag = 't' * 256
+ tag = b't' * 256
lzc.lzc_snapshot([snap])
with self.assertRaises(lzc_exc.HoldReleaseFailure):
snap = ZFSTest.pool.getRoot().getTooLongSnap(False)
with self.assertRaises(lzc_exc.HoldReleaseFailure):
- lzc.lzc_release({snap: ['tag']})
+ lzc.lzc_release({snap: [b'tag']})
def test_release_hold_too_long_snap_name_2(self):
snap = ZFSTest.pool.getRoot().getTooLongSnap(True)
with self.assertRaises(lzc_exc.HoldReleaseFailure) as ctx:
- lzc.lzc_release({snap: ['tag']})
+ lzc.lzc_release({snap: [b'tag']})
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameTooLong)
self.assertEqual(e.name, snap)
def test_release_hold_invalid_snap_name(self):
- snap = ZFSTest.pool.getRoot().getSnap() + '@bad'
+ snap = ZFSTest.pool.getRoot().getSnap() + b'@bad'
with self.assertRaises(lzc_exc.HoldReleaseFailure) as ctx:
- lzc.lzc_release({snap: ['tag']})
+ lzc.lzc_release({snap: [b'tag']})
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameInvalid)
self.assertEqual(e.name, snap)
def test_release_hold_invalid_snap_name_2(self):
snap = ZFSTest.pool.getRoot().getFilesystem().getName()
with self.assertRaises(lzc_exc.HoldReleaseFailure) as ctx:
- lzc.lzc_release({snap: ['tag']})
+ lzc.lzc_release({snap: [b'tag']})
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameInvalid)
self.assertEqual(e.name, snap)
def test_sync_missing_pool(self):
- pool = "nonexistent"
+ pool = b"nonexistent"
with self.assertRaises(lzc_exc.PoolNotFound):
lzc.lzc_sync(pool)
lzc.lzc_sync(pool, True)
def test_reopen_missing_pool(self):
- pool = "nonexistent"
+ pool = b"nonexistent"
with self.assertRaises(lzc_exc.PoolNotFound):
lzc.lzc_reopen(pool)
lzc.lzc_reopen(pool, False)
def test_channel_program_missing_pool(self):
- pool = "nonexistent"
+ pool = b"nonexistent"
with self.assertRaises(lzc_exc.PoolNotFound):
- lzc.lzc_channel_program(pool, "return {}")
+ lzc.lzc_channel_program(pool, b"return {}")
def test_channel_program_timeout(self):
pool = ZFSTest.pool.getRoot().getName()
- zcp = """
+ zcp = b"""
for i = 1,10000 do
- zfs.sync.snapshot('""" + pool + """@zcp' .. i)
+ zfs.sync.snapshot('""" + pool + b"""@zcp' .. i)
end
"""
with self.assertRaises(lzc_exc.ZCPTimeout):
def test_channel_program_memory_limit(self):
pool = ZFSTest.pool.getRoot().getName()
- zcp = """
+ zcp = b"""
for i = 1,10000 do
- zfs.sync.snapshot('""" + pool + """@zcp' .. i)
+ zfs.sync.snapshot('""" + pool + b"""@zcp' .. i)
end
"""
with self.assertRaises(lzc_exc.ZCPSpaceError):
def test_channel_program_invalid_limits(self):
pool = ZFSTest.pool.getRoot().getName()
- zcp = """
+ zcp = b"""
return {}
"""
with self.assertRaises(lzc_exc.ZCPLimitInvalid):
def test_channel_program_syntax_error(self):
pool = ZFSTest.pool.getRoot().getName()
- zcp = """
+ zcp = b"""
inv+val:id
"""
with self.assertRaises(lzc_exc.ZCPSyntaxError) as ctx:
lzc.lzc_channel_program(pool, zcp)
- self.assertTrue("syntax error" in ctx.exception.details)
+ self.assertTrue(b"syntax error" in ctx.exception.details)
def test_channel_program_sync_snapshot(self):
pool = ZFSTest.pool.getRoot().getName()
- snapname = ZFSTest.pool.makeName("@zcp")
- zcp = """
-zfs.sync.snapshot('""" + snapname + """')
+ snapname = ZFSTest.pool.makeName(b"@zcp")
+ zcp = b"""
+zfs.sync.snapshot('""" + snapname + b"""')
"""
lzc.lzc_channel_program(pool, zcp)
self.assertExists(snapname)
# failing an assertion raises a runtime error
with self.assertRaises(lzc_exc.ZCPRuntimeError) as ctx:
- lzc.lzc_channel_program(pool, "assert(1 == 2)")
+ lzc.lzc_channel_program(pool, b"assert(1 == 2)")
self.assertTrue(
- "assertion failed" in ctx.exception.details)
+ b"assertion failed" in ctx.exception.details)
# invoking the error() function raises a runtime error
with self.assertRaises(lzc_exc.ZCPRuntimeError) as ctx:
- lzc.lzc_channel_program(pool, "error()")
+ lzc.lzc_channel_program(pool, b"error()")
def test_channel_program_nosync_runtime_error(self):
pool = ZFSTest.pool.getRoot().getName()
- zcp = """
-zfs.sync.snapshot('""" + pool + """@zcp')
+ zcp = b"""
+zfs.sync.snapshot('""" + pool + b"""@zcp')
"""
# lzc_channel_program_nosync() allows only "read-only" operations
with self.assertRaises(lzc_exc.ZCPRuntimeError) as ctx:
lzc.lzc_channel_program_nosync(pool, zcp)
self.assertTrue(
- "running functions from the zfs.sync" in ctx.exception.details)
+ b"running functions from the zfs.sync" in ctx.exception.details)
def test_change_key_new(self):
with encrypted_filesystem() as (fs, _):
lzc.lzc_change_key(
fs, 'new_key',
- props={"keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW},
+ props={b"keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW},
key=os.urandom(lzc.WRAPPING_KEY_LEN))
def test_change_key_missing_fs(self):
- name = "nonexistent"
+ name = b"nonexistent"
with self.assertRaises(lzc_exc.FilesystemNotFound):
lzc.lzc_change_key(
name, 'new_key',
- props={"keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW},
+ props={b"keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW},
key=os.urandom(lzc.WRAPPING_KEY_LEN))
def test_change_key_not_loaded(self):
with self.assertRaises(lzc_exc.EncryptionKeyNotLoaded):
lzc.lzc_change_key(
fs, 'new_key',
- props={"keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW},
+ props={b"keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW},
key=os.urandom(lzc.WRAPPING_KEY_LEN))
def test_change_key_invalid_property(self):
with encrypted_filesystem() as (fs, _):
with self.assertRaises(lzc_exc.PropertyInvalid):
- lzc.lzc_change_key(fs, 'new_key', props={"invalid": "prop"})
+ lzc.lzc_change_key(fs, 'new_key', props={b"invalid": b"prop"})
def test_change_key_invalid_crypt_command(self):
with encrypted_filesystem() as (fs, _):
lzc.lzc_load_key(fs, False, key)
def test_load_key_missing_fs(self):
- name = "nonexistent"
+ name = b"nonexistent"
with self.assertRaises(lzc_exc.FilesystemNotFound):
lzc.lzc_load_key(name, False, key=os.urandom(lzc.WRAPPING_KEY_LEN))
lzc.lzc_unload_key(fs)
def test_unload_key_missing_fs(self):
- name = "nonexistent"
+ name = b"nonexistent"
with self.assertRaises(lzc_exc.FilesystemNotFound):
lzc.lzc_unload_key(name)
lzc.lzc_unload_key(fs)
def test_remap_missing_fs(self):
- name = "nonexistent"
+ name = b"nonexistent"
with self.assertRaises(lzc_exc.DatasetNotFound):
lzc.lzc_remap(name)
def test_remap_invalid_fs(self):
- ds = ZFSTest.pool.makeName("fs1")
- snap = ds + "@snap1"
+ ds = ZFSTest.pool.makeName(b"fs1")
+ snap = ds + b"@snap1"
lzc.lzc_snapshot([snap])
with self.assertRaises(lzc_exc.NameInvalid):
lzc.lzc_remap(name)
def test_remap(self):
- name = ZFSTest.pool.makeName("fs1")
+ name = ZFSTest.pool.makeName(b"fs1")
lzc.lzc_remap(name)
lzc.lzc_pool_checkpoint(pool)
def test_checkpoint_missing_pool(self):
- pool = "nonexistent"
+ pool = b"nonexistent"
with self.assertRaises(lzc_exc.PoolNotFound):
lzc.lzc_pool_checkpoint(pool)
lzc.lzc_pool_checkpoint_discard(pool)
def test_checkpoint_discard_missing_pool(self):
- pool = "nonexistent"
+ pool = b"nonexistent"
with self.assertRaises(lzc_exc.PoolNotFound):
lzc.lzc_pool_checkpoint_discard(pool)
@needs_support(lzc.lzc_list_children)
def test_list_children(self):
- name = ZFSTest.pool.makeName("fs1/fs")
- names = [ZFSTest.pool.makeName("fs1/fs/test1"),
- ZFSTest.pool.makeName("fs1/fs/test2"),
- ZFSTest.pool.makeName("fs1/fs/test3"), ]
+ name = ZFSTest.pool.makeName(b"fs1/fs")
+ names = [ZFSTest.pool.makeName(b"fs1/fs/test1"),
+ ZFSTest.pool.makeName(b"fs1/fs/test2"),
+ ZFSTest.pool.makeName(b"fs1/fs/test3"), ]
# and one snap to see that it is not listed
- snap = ZFSTest.pool.makeName("fs1/fs@test")
+ snap = ZFSTest.pool.makeName(b"fs1/fs@test")
for fs in names:
lzc.lzc_create(fs)
@needs_support(lzc.lzc_list_children)
def test_list_children_nonexistent(self):
- fs = ZFSTest.pool.makeName("nonexistent")
+ fs = ZFSTest.pool.makeName(b"nonexistent")
with self.assertRaises(lzc_exc.DatasetNotFound):
list(lzc.lzc_list_children(fs))
@needs_support(lzc.lzc_list_children)
def test_list_children_of_snap(self):
- snap = ZFSTest.pool.makeName("@newsnap")
+ snap = ZFSTest.pool.makeName(b"@newsnap")
lzc.lzc_snapshot([snap])
children = list(lzc.lzc_list_children(snap))
@needs_support(lzc.lzc_list_snaps)
def test_list_snaps(self):
- name = ZFSTest.pool.makeName("fs1/fs")
- names = [ZFSTest.pool.makeName("fs1/fs@test1"),
- ZFSTest.pool.makeName("fs1/fs@test2"),
- ZFSTest.pool.makeName("fs1/fs@test3"), ]
+ name = ZFSTest.pool.makeName(b"fs1/fs")
+ names = [ZFSTest.pool.makeName(b"fs1/fs@test1"),
+ ZFSTest.pool.makeName(b"fs1/fs@test2"),
+ ZFSTest.pool.makeName(b"fs1/fs@test3"), ]
# and one filesystem to see that it is not listed
- fs = ZFSTest.pool.makeName("fs1/fs/test")
+ fs = ZFSTest.pool.makeName(b"fs1/fs/test")
for snap in names:
lzc.lzc_snapshot([snap])
@needs_support(lzc.lzc_list_snaps)
def test_list_snaps_nonexistent(self):
- fs = ZFSTest.pool.makeName("nonexistent")
+ fs = ZFSTest.pool.makeName(b"nonexistent")
with self.assertRaises(lzc_exc.DatasetNotFound):
list(lzc.lzc_list_snaps(fs))
@needs_support(lzc.lzc_list_snaps)
def test_list_snaps_of_snap(self):
- snap = ZFSTest.pool.makeName("@newsnap")
+ snap = ZFSTest.pool.makeName(b"@newsnap")
lzc.lzc_snapshot([snap])
snaps = list(lzc.lzc_list_snaps(snap))
@needs_support(lzc.lzc_get_props)
def test_get_fs_props(self):
- fs = ZFSTest.pool.makeName("new")
- props = {"user:foo": "bar"}
+ fs = ZFSTest.pool.makeName(b"new")
+ props = {b"user:foo": b"bar"}
lzc.lzc_create(fs, props=props)
actual_props = lzc.lzc_get_props(fs)
@needs_support(lzc.lzc_get_props)
def test_get_fs_props_with_child(self):
- parent = ZFSTest.pool.makeName("parent")
- child = ZFSTest.pool.makeName("parent/child")
- parent_props = {"user:foo": "parent"}
- child_props = {"user:foo": "child"}
+ parent = ZFSTest.pool.makeName(b"parent")
+ child = ZFSTest.pool.makeName(b"parent/child")
+ parent_props = {b"user:foo": b"parent"}
+ child_props = {b"user:foo": b"child"}
lzc.lzc_create(parent, props=parent_props)
lzc.lzc_create(child, props=child_props)
@needs_support(lzc.lzc_get_props)
def test_get_snap_props(self):
- snapname = ZFSTest.pool.makeName("@snap")
+ snapname = ZFSTest.pool.makeName(b"@snap")
snaps = [snapname]
- props = {"user:foo": "bar"}
+ props = {b"user:foo": b"bar"}
lzc.lzc_snapshot(snaps, props)
actual_props = lzc.lzc_get_props(snapname)
@needs_support(lzc.lzc_get_props)
def test_get_props_nonexistent(self):
- fs = ZFSTest.pool.makeName("nonexistent")
+ fs = ZFSTest.pool.makeName(b"nonexistent")
with self.assertRaises(lzc_exc.DatasetNotFound):
lzc.lzc_get_props(fs)
value is returned as `bytes` "none".
Also, a child filesystem inherits that value.
'''
- fs = ZFSTest.pool.makeName("new")
- child = ZFSTest.pool.makeName("new/child")
- props = {"mountpoint": "none"}
+ fs = ZFSTest.pool.makeName(b"new")
+ child = ZFSTest.pool.makeName(b"new/child")
+ props = {b"mountpoint": b"none"}
lzc.lzc_create(fs, props=props)
lzc.lzc_create(child)
value is returned as `bytes` "legacy".
Also, a child filesystem inherits that value.
'''
- fs = ZFSTest.pool.makeName("new")
- child = ZFSTest.pool.makeName("new/child")
- props = {"mountpoint": "legacy"}
+ fs = ZFSTest.pool.makeName(b"new")
+ child = ZFSTest.pool.makeName(b"new/child")
+ props = {b"mountpoint": b"legacy"}
lzc.lzc_create(fs, props=props)
lzc.lzc_create(child)
value is that of the parent filesystem with the child's
name appended using the '/' separator.
'''
- fs = ZFSTest.pool.makeName("new")
- child = ZFSTest.pool.makeName("new/child")
- props = {"mountpoint": "/mnt"}
+ fs = ZFSTest.pool.makeName(b"new")
+ child = ZFSTest.pool.makeName(b"new/child")
+ props = {b"mountpoint": b"/mnt"}
lzc.lzc_create(fs, props=props)
lzc.lzc_create(child)
# check that mountpoint value is correctly inherited
child_props = lzc.lzc_get_props(child)
self.assertDictContainsSubset(
- {"mountpoint": "/mnt/child"}, child_props)
+ {b"mountpoint": b"/mnt/child"}, child_props)
@needs_support(lzc.lzc_get_props)
def test_get_snap_clones(self):
- fs = ZFSTest.pool.makeName("new")
- snap = ZFSTest.pool.makeName("@snap")
- clone1 = ZFSTest.pool.makeName("clone1")
- clone2 = ZFSTest.pool.makeName("clone2")
+ fs = ZFSTest.pool.makeName(b"new")
+ snap = ZFSTest.pool.makeName(b"@snap")
+ clone1 = ZFSTest.pool.makeName(b"clone1")
+ clone2 = ZFSTest.pool.makeName(b"clone2")
lzc.lzc_create(fs)
lzc.lzc_snapshot([snap])
@needs_support(lzc.lzc_rename)
def test_rename(self):
- src = ZFSTest.pool.makeName("source")
- tgt = ZFSTest.pool.makeName("target")
+ src = ZFSTest.pool.makeName(b"source")
+ tgt = ZFSTest.pool.makeName(b"target")
lzc.lzc_create(src)
lzc.lzc_rename(src, tgt)
@needs_support(lzc.lzc_rename)
def test_rename_nonexistent(self):
- src = ZFSTest.pool.makeName("source")
- tgt = ZFSTest.pool.makeName("target")
+ src = ZFSTest.pool.makeName(b"source")
+ tgt = ZFSTest.pool.makeName(b"target")
with self.assertRaises(lzc_exc.FilesystemNotFound):
lzc.lzc_rename(src, tgt)
@needs_support(lzc.lzc_rename)
def test_rename_existing_target(self):
- src = ZFSTest.pool.makeName("source")
- tgt = ZFSTest.pool.makeName("target")
+ src = ZFSTest.pool.makeName(b"source")
+ tgt = ZFSTest.pool.makeName(b"target")
lzc.lzc_create(src)
lzc.lzc_create(tgt)
@needs_support(lzc.lzc_rename)
def test_rename_nonexistent_target_parent(self):
- src = ZFSTest.pool.makeName("source")
- tgt = ZFSTest.pool.makeName("parent/target")
+ src = ZFSTest.pool.makeName(b"source")
+ tgt = ZFSTest.pool.makeName(b"parent/target")
lzc.lzc_create(src)
with self.assertRaises(lzc_exc.FilesystemNotFound):
@needs_support(lzc.lzc_destroy)
def test_destroy(self):
- fs = ZFSTest.pool.makeName("test-fs")
+ fs = ZFSTest.pool.makeName(b"test-fs")
lzc.lzc_create(fs)
lzc.lzc_destroy(fs)
@needs_support(lzc.lzc_destroy)
def test_destroy_nonexistent(self):
- fs = ZFSTest.pool.makeName("test-fs")
+ fs = ZFSTest.pool.makeName(b"test-fs")
with self.assertRaises(lzc_exc.FilesystemNotFound):
lzc.lzc_destroy(fs)
@needs_support(lzc.lzc_inherit_prop)
def test_inherit_prop(self):
- parent = ZFSTest.pool.makeName("parent")
- child = ZFSTest.pool.makeName("parent/child")
- the_prop = "user:foo"
- parent_props = {the_prop: "parent"}
- child_props = {the_prop: "child"}
+ parent = ZFSTest.pool.makeName(b"parent")
+ child = ZFSTest.pool.makeName(b"parent/child")
+ the_prop = b"user:foo"
+ parent_props = {the_prop: b"parent"}
+ child_props = {the_prop: b"child"}
lzc.lzc_create(parent, props=parent_props)
lzc.lzc_create(child, props=child_props)
@needs_support(lzc.lzc_inherit_prop)
def test_inherit_missing_prop(self):
- parent = ZFSTest.pool.makeName("parent")
- child = ZFSTest.pool.makeName("parent/child")
+ parent = ZFSTest.pool.makeName(b"parent")
+ child = ZFSTest.pool.makeName(b"parent/child")
the_prop = "user:foo"
child_props = {the_prop: "child"}
@needs_support(lzc.lzc_inherit_prop)
def test_inherit_readonly_prop(self):
- parent = ZFSTest.pool.makeName("parent")
- child = ZFSTest.pool.makeName("parent/child")
- the_prop = "createtxg"
+ parent = ZFSTest.pool.makeName(b"parent")
+ child = ZFSTest.pool.makeName(b"parent/child")
+ the_prop = b"createtxg"
lzc.lzc_create(parent)
lzc.lzc_create(child)
@needs_support(lzc.lzc_inherit_prop)
def test_inherit_unknown_prop(self):
- parent = ZFSTest.pool.makeName("parent")
- child = ZFSTest.pool.makeName("parent/child")
- the_prop = "nosuchprop"
+ parent = ZFSTest.pool.makeName(b"parent")
+ child = ZFSTest.pool.makeName(b"parent/child")
+ the_prop = b"nosuchprop"
lzc.lzc_create(parent)
lzc.lzc_create(child)
@needs_support(lzc.lzc_inherit_prop)
def test_inherit_prop_on_snap(self):
- fs = ZFSTest.pool.makeName("new")
- snapname = ZFSTest.pool.makeName("new@snap")
- prop = "user:foo"
- fs_val = "fs"
- snap_val = "snap"
+ fs = ZFSTest.pool.makeName(b"new")
+ snapname = ZFSTest.pool.makeName(b"new@snap")
+ prop = b"user:foo"
+ fs_val = b"fs"
+ snap_val = b"snap"
lzc.lzc_create(fs, props={prop: fs_val})
lzc.lzc_snapshot([snapname], props={prop: snap_val})
@needs_support(lzc.lzc_set_prop)
def test_set_fs_prop(self):
- fs = ZFSTest.pool.makeName("new")
- prop = "user:foo"
- val = "bar"
+ fs = ZFSTest.pool.makeName(b"new")
+ prop = b"user:foo"
+ val = b"bar"
lzc.lzc_create(fs)
lzc.lzc_set_prop(fs, prop, val)
@needs_support(lzc.lzc_set_prop)
def test_set_snap_prop(self):
- snapname = ZFSTest.pool.makeName("@snap")
- prop = "user:foo"
- val = "bar"
+ snapname = ZFSTest.pool.makeName(b"@snap")
+ prop = b"user:foo"
+ val = b"bar"
lzc.lzc_snapshot([snapname])
lzc.lzc_set_prop(snapname, prop, val)
@needs_support(lzc.lzc_set_prop)
def test_set_prop_nonexistent(self):
- fs = ZFSTest.pool.makeName("nonexistent")
- prop = "user:foo"
- val = "bar"
+ fs = ZFSTest.pool.makeName(b"nonexistent")
+ prop = b"user:foo"
+ val = b"bar"
with self.assertRaises(lzc_exc.DatasetNotFound):
lzc.lzc_set_prop(fs, prop, val)
@needs_support(lzc.lzc_set_prop)
def test_set_sys_prop(self):
- fs = ZFSTest.pool.makeName("new")
- prop = "recordsize"
+ fs = ZFSTest.pool.makeName(b"new")
+ prop = b"recordsize"
val = 4096
lzc.lzc_create(fs)
@needs_support(lzc.lzc_set_prop)
def test_set_invalid_prop(self):
- fs = ZFSTest.pool.makeName("new")
- prop = "nosuchprop"
+ fs = ZFSTest.pool.makeName(b"new")
+ prop = b"nosuchprop"
val = 0
lzc.lzc_create(fs)
@needs_support(lzc.lzc_set_prop)
def test_set_invalid_value_prop(self):
- fs = ZFSTest.pool.makeName("new")
- prop = "atime"
+ fs = ZFSTest.pool.makeName(b"new")
+ prop = b"atime"
val = 100
lzc.lzc_create(fs)
@needs_support(lzc.lzc_set_prop)
def test_set_invalid_value_prop_2(self):
- fs = ZFSTest.pool.makeName("new")
- prop = "readonly"
+ fs = ZFSTest.pool.makeName(b"new")
+ prop = b"readonly"
val = 100
lzc.lzc_create(fs)
@needs_support(lzc.lzc_set_prop)
def test_set_prop_too_small_quota(self):
- fs = ZFSTest.pool.makeName("new")
- prop = "refquota"
+ fs = ZFSTest.pool.makeName(b"new")
+ prop = b"refquota"
val = 1
lzc.lzc_create(fs)
@needs_support(lzc.lzc_set_prop)
def test_set_readonly_prop(self):
- fs = ZFSTest.pool.makeName("new")
- prop = "creation"
+ fs = ZFSTest.pool.makeName(b"new")
+ prop = b"creation"
val = 0
lzc.lzc_create(fs)
class _TempPool(object):
- SNAPSHOTS = ['snap', 'snap1', 'snap2']
- BOOKMARKS = ['bmark', 'bmark1', 'bmark2']
+ SNAPSHOTS = [b'snap', b'snap1', b'snap2']
+ BOOKMARKS = [b'bmark', b'bmark1', b'bmark2']
_cachefile_suffix = ".cachefile"
def __init__(self, size=128 * 1024 * 1024, readonly=False, filesystems=[]):
self._filesystems = filesystems
self._readonly = readonly
- self._pool_name = 'pool.' + bytes(uuid.uuid4())
+ if sys.version_info < (3, 0):
+ self._pool_name = b'pool.' + bytes(uuid.uuid4())
+ else:
+ self._pool_name = b'pool.' + bytes(str(uuid.uuid4()),
+ encoding='utf-8')
self._root = _Filesystem(self._pool_name)
(fd, self._pool_file_path) = tempfile.mkstemp(
suffix='.zpool', prefix='tmp-')
except subprocess.CalledProcessError as e:
self.cleanUp()
- if 'permission denied' in e.output:
+ if b'permission denied' in e.output:
raise unittest.SkipTest(
'insufficient privileges to run libzfs_core tests')
print('command failed: ', e.output)
self._zpool_create, stderr=subprocess.STDOUT)
break
except subprocess.CalledProcessError as e:
- if 'pool is busy' in e.output and retry < 5:
+ if b'pool is busy' in e.output and retry < 5:
retry += 1
time.sleep(1)
continue
def makeName(self, relative=None):
if not relative:
return self._pool_name
- if relative.startswith(('@', '#')):
+ if relative.startswith((b'@', b'#')):
return self._pool_name + relative
- return self._pool_name + '/' + relative
+ return self._pool_name + b'/' + relative
def makeTooLongName(self, prefix=None):
if not prefix:
- prefix = 'x'
+ prefix = b'x'
prefix = self.makeName(prefix)
pad_len = lzc.MAXNAMELEN + 1 - len(prefix)
if pad_len > 0:
- return prefix + 'x' * pad_len
+ return prefix + b'x' * pad_len
else:
return prefix
def makeTooLongComponent(self, prefix=None):
- padding = 'x' * (lzc.MAXNAMELEN + 1)
+ padding = b'x' * (lzc.MAXNAMELEN + 1)
if not prefix:
prefix = padding
else:
return self._root
def getFilesystem(self, fsname):
- return _Filesystem(self._pool_name + '/' + fsname)
+ return _Filesystem(self._pool_name + b'/' + fsname)
def isPoolFeatureAvailable(self, feature):
output = subprocess.check_output(
output = subprocess.check_output(
['zpool', 'get', '-H', 'feature@' + feature, self._pool_name])
output = output.split()[2]
- return output in ['active', 'enabled']
+ return output in [b'active', b'enabled']
class _Filesystem(object):
def getFilesystem(self):
self._fs_id += 1
- fsname = self._name + '/fs' + bytes(self._fs_id)
+ fsname = self._name + b'/fs' + str(self._fs_id).encode()
fs = _Filesystem(fsname)
self._children.append(fs)
return fs
return output.strip()
def _makeSnapName(self, i):
- return self._name + '@snap' + bytes(i)
+ return self._name + b'@snap' + str(i).encode()
def getSnap(self):
self._snap_id += 1
return self._makeSnapName(self._snap_id)
def _makeBookmarkName(self, i):
- return self._name + '#bmark' + bytes(i)
+ return self._name + b'#bmark' + bytes(i)
def getBookmark(self):
self._bmark_id += 1
def _makeTooLongName(self, too_long_component):
if too_long_component:
- return 'x' * (lzc.MAXNAMELEN + 1)
+ return b'x' * (lzc.MAXNAMELEN + 1)
# Note that another character is used for one of '/', '@', '#'.
comp_len = lzc.MAXNAMELEN - len(self._name)
if comp_len > 0:
- return 'x' * comp_len
+ return b'x' * comp_len
else:
- return 'x'
+ return b'x'
def getTooLongFilesystemName(self, too_long_component):
- return self._name + '/' + self._makeTooLongName(too_long_component)
+ return self._name + b'/' + self._makeTooLongName(too_long_component)
def getTooLongSnap(self, too_long_component):
- return self._name + '@' + self._makeTooLongName(too_long_component)
+ return self._name + b'@' + self._makeTooLongName(too_long_component)
def getTooLongBookmark(self, too_long_component):
- return self._name + '#' + self._makeTooLongName(too_long_component)
+ return self._name + b'#' + self._makeTooLongName(too_long_component)
def _visitFilesystems(self, visitor):
for child in self._children:
def _assertIntDictsEqual(self, dict1, dict2):
self.assertEqual(
len(dict1), len(dict1),
- "resulting dictionary is of different size")
+ b"resulting dictionary is of different size")
for key in dict1.keys():
self.assertEqual(int(dict1[key]), int(dict2[key]))
def _assertIntArrayDictsEqual(self, dict1, dict2):
self.assertEqual(
len(dict1), len(dict1),
- "resulting dictionary is of different size")
+ b"resulting dictionary is of different size")
for key in dict1.keys():
val1 = dict1[key]
val2 = dict2[key]
self.assertEqual(
- len(val1), len(val2), "array values of different sizes")
+ len(val1), len(val2), b"array values of different sizes")
for x, y in zip(val1, val2):
self.assertEqual(int(x), int(y))
def test_empty(self):
res = self._dict_to_nvlist_to_dict({})
- self.assertEqual(len(res), 0, "expected empty dict")
+ self.assertEqual(len(res), 0, b"expected empty dict")
def test_invalid_key_type(self):
with self.assertRaises(TypeError):
def test_invalid_val_type__tuple(self):
with self.assertRaises(TypeError):
- self._dict_to_nvlist_to_dict({"key": (1, 2)})
+ self._dict_to_nvlist_to_dict({b"key": (1, 2)})
def test_invalid_val_type__set(self):
with self.assertRaises(TypeError):
- self._dict_to_nvlist_to_dict({"key": set(1, 2)})
+ self._dict_to_nvlist_to_dict({b"key": set(1, 2)})
def test_invalid_array_val_type(self):
with self.assertRaises(TypeError):
- self._dict_to_nvlist_to_dict({"key": [(1, 2), (3, 4)]})
+ self._dict_to_nvlist_to_dict({b"key": [(1, 2), (3, 4)]})
def test_invalid_array_of_arrays_val_type(self):
with self.assertRaises(TypeError):
- self._dict_to_nvlist_to_dict({"key": [[1, 2], [3, 4]]})
+ self._dict_to_nvlist_to_dict({b"key": [[1, 2], [3, 4]]})
def test_string_value(self):
- props = {"key": "value"}
+ props = {b"key": b"value"}
res = self._dict_to_nvlist_to_dict(props)
self.assertEqual(props, res)
def test_implicit_boolean_value(self):
- props = {"key": None}
+ props = {b"key": None}
res = self._dict_to_nvlist_to_dict(props)
self.assertEqual(props, res)
def test_boolean_values(self):
- props = {"key1": True, "key2": False}
+ props = {b"key1": True, b"key2": False}
res = self._dict_to_nvlist_to_dict(props)
self.assertEqual(props, res)
def test_explicit_boolean_true_value(self):
- props = {"key": boolean_t(1)}
+ props = {b"key": boolean_t(1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_boolean_false_value(self):
- props = {"key": boolean_t(0)}
+ props = {b"key": boolean_t(0)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_boolean_invalid_value(self):
with self.assertRaises(OverflowError):
- props = {"key": boolean_t(2)}
+ props = {b"key": boolean_t(2)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_boolean_another_invalid_value(self):
with self.assertRaises(OverflowError):
- props = {"key": boolean_t(-1)}
+ props = {b"key": boolean_t(-1)}
self._dict_to_nvlist_to_dict(props)
def test_uint64_value(self):
- props = {"key": 1}
+ props = {b"key": 1}
res = self._dict_to_nvlist_to_dict(props)
self.assertEqual(props, res)
def test_uint64_max_value(self):
- props = {"key": 2 ** 64 - 1}
+ props = {b"key": 2 ** 64 - 1}
res = self._dict_to_nvlist_to_dict(props)
self.assertEqual(props, res)
def test_uint64_too_large_value(self):
- props = {"key": 2 ** 64}
+ props = {b"key": 2 ** 64}
with self.assertRaises(OverflowError):
self._dict_to_nvlist_to_dict(props)
def test_uint64_negative_value(self):
- props = {"key": -1}
+ props = {b"key": -1}
with self.assertRaises(OverflowError):
self._dict_to_nvlist_to_dict(props)
def test_explicit_uint64_value(self):
- props = {"key": uint64_t(1)}
+ props = {b"key": uint64_t(1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_uint64_max_value(self):
- props = {"key": uint64_t(2 ** 64 - 1)}
+ props = {b"key": uint64_t(2 ** 64 - 1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_uint64_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": uint64_t(2 ** 64)}
+ props = {b"key": uint64_t(2 ** 64)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_uint64_negative_value(self):
with self.assertRaises(OverflowError):
- props = {"key": uint64_t(-1)}
+ props = {b"key": uint64_t(-1)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_uint32_value(self):
- props = {"key": uint32_t(1)}
+ props = {b"key": uint32_t(1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_uint32_max_value(self):
- props = {"key": uint32_t(2 ** 32 - 1)}
+ props = {b"key": uint32_t(2 ** 32 - 1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_uint32_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": uint32_t(2 ** 32)}
+ props = {b"key": uint32_t(2 ** 32)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_uint32_negative_value(self):
with self.assertRaises(OverflowError):
- props = {"key": uint32_t(-1)}
+ props = {b"key": uint32_t(-1)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_uint16_value(self):
- props = {"key": uint16_t(1)}
+ props = {b"key": uint16_t(1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_uint16_max_value(self):
- props = {"key": uint16_t(2 ** 16 - 1)}
+ props = {b"key": uint16_t(2 ** 16 - 1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_uint16_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": uint16_t(2 ** 16)}
+ props = {b"key": uint16_t(2 ** 16)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_uint16_negative_value(self):
with self.assertRaises(OverflowError):
- props = {"key": uint16_t(-1)}
+ props = {b"key": uint16_t(-1)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_uint8_value(self):
- props = {"key": uint8_t(1)}
+ props = {b"key": uint8_t(1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_uint8_max_value(self):
- props = {"key": uint8_t(2 ** 8 - 1)}
+ props = {b"key": uint8_t(2 ** 8 - 1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_uint8_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": uint8_t(2 ** 8)}
+ props = {b"key": uint8_t(2 ** 8)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_uint8_negative_value(self):
with self.assertRaises(OverflowError):
- props = {"key": uint8_t(-1)}
+ props = {b"key": uint8_t(-1)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_byte_value(self):
- props = {"key": uchar_t(1)}
+ props = {b"key": uchar_t(1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_byte_max_value(self):
- props = {"key": uchar_t(2 ** 8 - 1)}
+ props = {b"key": uchar_t(2 ** 8 - 1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_byte_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": uchar_t(2 ** 8)}
+ props = {b"key": uchar_t(2 ** 8)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_byte_negative_value(self):
with self.assertRaises(OverflowError):
- props = {"key": uchar_t(-1)}
+ props = {b"key": uchar_t(-1)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_int64_value(self):
- props = {"key": int64_t(1)}
+ props = {b"key": int64_t(1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_int64_max_value(self):
- props = {"key": int64_t(2 ** 63 - 1)}
+ props = {b"key": int64_t(2 ** 63 - 1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_int64_min_value(self):
- props = {"key": int64_t(-(2 ** 63))}
+ props = {b"key": int64_t(-(2 ** 63))}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_int64_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": int64_t(2 ** 63)}
+ props = {b"key": int64_t(2 ** 63)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_int64_too_small_value(self):
with self.assertRaises(OverflowError):
- props = {"key": int64_t(-(2 ** 63) - 1)}
+ props = {b"key": int64_t(-(2 ** 63) - 1)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_int32_value(self):
- props = {"key": int32_t(1)}
+ props = {b"key": int32_t(1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_int32_max_value(self):
- props = {"key": int32_t(2 ** 31 - 1)}
+ props = {b"key": int32_t(2 ** 31 - 1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_int32_min_value(self):
- props = {"key": int32_t(-(2 ** 31))}
+ props = {b"key": int32_t(-(2 ** 31))}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_int32_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": int32_t(2 ** 31)}
+ props = {b"key": int32_t(2 ** 31)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_int32_too_small_value(self):
with self.assertRaises(OverflowError):
- props = {"key": int32_t(-(2 ** 31) - 1)}
+ props = {b"key": int32_t(-(2 ** 31) - 1)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_int16_value(self):
- props = {"key": int16_t(1)}
+ props = {b"key": int16_t(1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_int16_max_value(self):
- props = {"key": int16_t(2 ** 15 - 1)}
+ props = {b"key": int16_t(2 ** 15 - 1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_int16_min_value(self):
- props = {"key": int16_t(-(2 ** 15))}
+ props = {b"key": int16_t(-(2 ** 15))}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_int16_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": int16_t(2 ** 15)}
+ props = {b"key": int16_t(2 ** 15)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_int16_too_small_value(self):
with self.assertRaises(OverflowError):
- props = {"key": int16_t(-(2 ** 15) - 1)}
+ props = {b"key": int16_t(-(2 ** 15) - 1)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_int8_value(self):
- props = {"key": int8_t(1)}
+ props = {b"key": int8_t(1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_int8_max_value(self):
- props = {"key": int8_t(2 ** 7 - 1)}
+ props = {b"key": int8_t(2 ** 7 - 1)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_int8_min_value(self):
- props = {"key": int8_t(-(2 ** 7))}
+ props = {b"key": int8_t(-(2 ** 7))}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_explicit_int8_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": int8_t(2 ** 7)}
+ props = {b"key": int8_t(2 ** 7)}
self._dict_to_nvlist_to_dict(props)
def test_explicit_int8_too_small_value(self):
with self.assertRaises(OverflowError):
- props = {"key": int8_t(-(2 ** 7) - 1)}
+ props = {b"key": int8_t(-(2 ** 7) - 1)}
self._dict_to_nvlist_to_dict(props)
def test_nested_dict(self):
- props = {"key": {}}
+ props = {b"key": {}}
res = self._dict_to_nvlist_to_dict(props)
self.assertEqual(props, res)
def test_nested_nested_dict(self):
- props = {"key": {"key": {}}}
+ props = {b"key": {b"key": {}}}
res = self._dict_to_nvlist_to_dict(props)
self.assertEqual(props, res)
def test_mismatching_values_array(self):
- props = {"key": [1, "string"]}
+ props = {b"key": [1, b"string"]}
with self.assertRaises(TypeError):
self._dict_to_nvlist_to_dict(props)
def test_mismatching_values_array2(self):
- props = {"key": [True, 10]}
+ props = {b"key": [True, 10]}
with self.assertRaises(TypeError):
self._dict_to_nvlist_to_dict(props)
def test_mismatching_values_array3(self):
- props = {"key": [1, False]}
+ props = {b"key": [1, False]}
with self.assertRaises(TypeError):
self._dict_to_nvlist_to_dict(props)
def test_string_array(self):
- props = {"key": ["value", "value2"]}
+ props = {b"key": [b"value", b"value2"]}
res = self._dict_to_nvlist_to_dict(props)
self.assertEqual(props, res)
def test_boolean_array(self):
- props = {"key": [True, False]}
+ props = {b"key": [True, False]}
res = self._dict_to_nvlist_to_dict(props)
self.assertEqual(props, res)
def test_explicit_boolean_array(self):
- props = {"key": [boolean_t(False), boolean_t(True)]}
+ props = {b"key": [boolean_t(False), boolean_t(True)]}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntArrayDictsEqual(props, res)
def test_uint64_array(self):
- props = {"key": [0, 1, 2 ** 64 - 1]}
+ props = {b"key": [0, 1, 2 ** 64 - 1]}
res = self._dict_to_nvlist_to_dict(props)
self.assertEqual(props, res)
def test_uint64_array_too_large_value(self):
- props = {"key": [0, 2 ** 64]}
+ props = {b"key": [0, 2 ** 64]}
with self.assertRaises(OverflowError):
self._dict_to_nvlist_to_dict(props)
def test_uint64_array_negative_value(self):
- props = {"key": [0, -1]}
+ props = {b"key": [0, -1]}
with self.assertRaises(OverflowError):
self._dict_to_nvlist_to_dict(props)
def test_mixed_explict_int_array(self):
with self.assertRaises(TypeError):
- props = {"key": [uint64_t(0), uint32_t(0)]}
+ props = {b"key": [uint64_t(0), uint32_t(0)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_uint64_array(self):
- props = {"key": [uint64_t(0), uint64_t(1), uint64_t(2 ** 64 - 1)]}
+ props = {b"key": [uint64_t(0), uint64_t(1), uint64_t(2 ** 64 - 1)]}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntArrayDictsEqual(props, res)
def test_explict_uint64_array_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [uint64_t(0), uint64_t(2 ** 64)]}
+ props = {b"key": [uint64_t(0), uint64_t(2 ** 64)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_uint64_array_negative_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [uint64_t(0), uint64_t(-1)]}
+ props = {b"key": [uint64_t(0), uint64_t(-1)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_uint32_array(self):
- props = {"key": [uint32_t(0), uint32_t(1), uint32_t(2 ** 32 - 1)]}
+ props = {b"key": [uint32_t(0), uint32_t(1), uint32_t(2 ** 32 - 1)]}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntArrayDictsEqual(props, res)
def test_explict_uint32_array_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [uint32_t(0), uint32_t(2 ** 32)]}
+ props = {b"key": [uint32_t(0), uint32_t(2 ** 32)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_uint32_array_negative_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [uint32_t(0), uint32_t(-1)]}
+ props = {b"key": [uint32_t(0), uint32_t(-1)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_uint16_array(self):
- props = {"key": [uint16_t(0), uint16_t(1), uint16_t(2 ** 16 - 1)]}
+ props = {b"key": [uint16_t(0), uint16_t(1), uint16_t(2 ** 16 - 1)]}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntArrayDictsEqual(props, res)
def test_explict_uint16_array_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [uint16_t(0), uint16_t(2 ** 16)]}
+ props = {b"key": [uint16_t(0), uint16_t(2 ** 16)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_uint16_array_negative_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [uint16_t(0), uint16_t(-1)]}
+ props = {b"key": [uint16_t(0), uint16_t(-1)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_uint8_array(self):
- props = {"key": [uint8_t(0), uint8_t(1), uint8_t(2 ** 8 - 1)]}
+ props = {b"key": [uint8_t(0), uint8_t(1), uint8_t(2 ** 8 - 1)]}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntArrayDictsEqual(props, res)
def test_explict_uint8_array_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [uint8_t(0), uint8_t(2 ** 8)]}
+ props = {b"key": [uint8_t(0), uint8_t(2 ** 8)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_uint8_array_negative_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [uint8_t(0), uint8_t(-1)]}
+ props = {b"key": [uint8_t(0), uint8_t(-1)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_byte_array(self):
- props = {"key": [uchar_t(0), uchar_t(1), uchar_t(2 ** 8 - 1)]}
+ props = {b"key": [uchar_t(0), uchar_t(1), uchar_t(2 ** 8 - 1)]}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntArrayDictsEqual(props, res)
def test_explict_byte_array_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [uchar_t(0), uchar_t(2 ** 8)]}
+ props = {b"key": [uchar_t(0), uchar_t(2 ** 8)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_byte_array_negative_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [uchar_t(0), uchar_t(-1)]}
+ props = {b"key": [uchar_t(0), uchar_t(-1)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_int64_array(self):
- props = {"key": [
+ props = {b"key": [
int64_t(0), int64_t(1), int64_t(2 ** 63 - 1), int64_t(-(2 ** 63))]}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntArrayDictsEqual(props, res)
def test_explict_int64_array_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [int64_t(0), int64_t(2 ** 63)]}
+ props = {b"key": [int64_t(0), int64_t(2 ** 63)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_int64_array_too_small_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [int64_t(0), int64_t(-(2 ** 63) - 1)]}
+ props = {b"key": [int64_t(0), int64_t(-(2 ** 63) - 1)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_int32_array(self):
- props = {"key": [
+ props = {b"key": [
int32_t(0), int32_t(1), int32_t(2 ** 31 - 1), int32_t(-(2 ** 31))]}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntArrayDictsEqual(props, res)
def test_explict_int32_array_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [int32_t(0), int32_t(2 ** 31)]}
+ props = {b"key": [int32_t(0), int32_t(2 ** 31)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_int32_array_too_small_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [int32_t(0), int32_t(-(2 ** 31) - 1)]}
+ props = {b"key": [int32_t(0), int32_t(-(2 ** 31) - 1)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_int16_array(self):
- props = {"key": [
+ props = {b"key": [
int16_t(0), int16_t(1), int16_t(2 ** 15 - 1), int16_t(-(2 ** 15))]}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntArrayDictsEqual(props, res)
def test_explict_int16_array_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [int16_t(0), int16_t(2 ** 15)]}
+ props = {b"key": [int16_t(0), int16_t(2 ** 15)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_int16_array_too_small_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [int16_t(0), int16_t(-(2 ** 15) - 1)]}
+ props = {b"key": [int16_t(0), int16_t(-(2 ** 15) - 1)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_int8_array(self):
- props = {"key": [
+ props = {b"key": [
int8_t(0), int8_t(1), int8_t(2 ** 7 - 1), int8_t(-(2 ** 7))]}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntArrayDictsEqual(props, res)
def test_explict_int8_array_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [int8_t(0), int8_t(2 ** 7)]}
+ props = {b"key": [int8_t(0), int8_t(2 ** 7)]}
self._dict_to_nvlist_to_dict(props)
def test_explict_int8_array_too_small_value(self):
with self.assertRaises(OverflowError):
- props = {"key": [int8_t(0), int8_t(-(2 ** 7) - 1)]}
+ props = {b"key": [int8_t(0), int8_t(-(2 ** 7) - 1)]}
self._dict_to_nvlist_to_dict(props)
def test_dict_array(self):
- props = {"key": [{"key": 1}, {"key": None}, {"key": {}}]}
+ props = {b"key": [{b"key": 1}, {b"key": None}, {b"key": {}}]}
res = self._dict_to_nvlist_to_dict(props)
self.assertEqual(props, res)
def test_implicit_uint32_value(self):
- props = {"rewind-request": 1}
+ props = {b"rewind-request": 1}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_implicit_uint32_max_value(self):
- props = {"rewind-request": 2 ** 32 - 1}
+ props = {b"rewind-request": 2 ** 32 - 1}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_implicit_uint32_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"rewind-request": 2 ** 32}
+ props = {b"rewind-request": 2 ** 32}
self._dict_to_nvlist_to_dict(props)
def test_implicit_uint32_negative_value(self):
with self.assertRaises(OverflowError):
- props = {"rewind-request": -1}
+ props = {b"rewind-request": -1}
self._dict_to_nvlist_to_dict(props)
def test_implicit_int32_value(self):
- props = {"pool_context": 1}
+ props = {b"pool_context": 1}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_implicit_int32_max_value(self):
- props = {"pool_context": 2 ** 31 - 1}
+ props = {b"pool_context": 2 ** 31 - 1}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_implicit_int32_min_value(self):
- props = {"pool_context": -(2 ** 31)}
+ props = {b"pool_context": -(2 ** 31)}
res = self._dict_to_nvlist_to_dict(props)
self._assertIntDictsEqual(props, res)
def test_implicit_int32_too_large_value(self):
with self.assertRaises(OverflowError):
- props = {"pool_context": 2 ** 31}
+ props = {b"pool_context": 2 ** 31}
self._dict_to_nvlist_to_dict(props)
def test_implicit_int32_too_small_value(self):
with self.assertRaises(OverflowError):
- props = {"pool_context": -(2 ** 31) - 1}
+ props = {b"pool_context": -(2 ** 31) - 1}
self._dict_to_nvlist_to_dict(props)
def test_complex_dict(self):
props = {
- "key1": "str",
- "key2": 10,
- "key3": {
- "skey1": True,
- "skey2": None,
- "skey3": [
+ b"key1": b"str",
+ b"key2": 10,
+ b"key3": {
+ b"skey1": True,
+ b"skey2": None,
+ b"skey3": [
True,
False,
True
]
},
- "key4": [
- "ab",
- "bc"
+ b"key4": [
+ b"ab",
+ b"bc"
],
- "key5": [
+ b"key5": [
2 ** 64 - 1,
1,
2,
3
],
- "key6": [
+ b"key6": [
{
- "skey71": "a",
- "skey72": "b",
+ b"skey71": b"a",
+ b"skey72": b"b",
},
{
- "skey71": "c",
- "skey72": "d",
+ b"skey71": b"c",
+ b"skey72": b"d",
},
{
- "skey71": "e",
- "skey72": "f",
+ b"skey71": b"e",
+ b"skey72": b"f",
}
],
- "type": 2 ** 32 - 1,
- "pool_context": -(2 ** 31)
+ b"type": 2 ** 32 - 1,
+ b"pool_context": -(2 ** 31)
}
res = self._dict_to_nvlist_to_dict(props)
self.assertEqual(props, res)
projects / zfs / commitdiff