Archive-Team
/
zfs
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 103 Wiki Activity

pyzfs: python3 support (library 1/2) 

These changes are efficient and valid in python 2 and 3. For the
most part, they are also pythonic.

* 2to3 conversion
* add __future__ imports
* iterator changes
* integer division
* relative import fixes

Reviewed-by: John Ramsden <johnramsden@riseup.net>
Reviewed-by: Neal Gompa <ngompa@datto.com>
Reviewed-by: loli10K <ezomori.nozomu@gmail.com>
Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
Signed-off-by: Antonio Russo <antonio.e.russo@gmail.com>
Closes #8096
This commit is contained in:
Antonio Russo 2018-08-22 06:59:51 -04:00 committed by Brian Behlendorf
parent 0b8e4418b6
commit 9de8c0cd7f
13 changed files with 141 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
contrib/pyzfs/libzfs_core/__init__.py
View File

@ -38,6 +38,7 @@ please visit its `GitHub repository <https://github.com/zfsonlinux/zfs>`_.
Maximum length of any ZFS name.
'''
from __future__ import absolute_import, division, print_function
from ._constants import (
MAXNAMELEN,

4
contrib/pyzfs/libzfs_core/_constants.py
View File

@ -18,10 +18,12 @@
Important `libzfs_core` constants.
"""
from __future__ import absolute_import, division, print_function
# https://stackoverflow.com/a/1695250
def enum(*sequential, **named):
enums = dict(zip(sequential, range(len(sequential))), **named)
enums = dict(((b, a) for a, b in enumerate(sequential)), **named)
return type('Enum', (), enums)

15
contrib/pyzfs/libzfs_core/_error_translation.py
View File

@ -26,6 +26,7 @@ corresponding interface functions.
The parameters and exceptions are documented in the `libzfs_core` interfaces.
"""
from __future__ import absolute_import, division, print_function
import errno
import re
@ -102,8 +103,9 @@ def lzc_snapshot_translate_errors(ret, errlist, snaps, props):
def _map(ret, name):
if ret == errno.EXDEV:
pool_names = map(_pool_name, snaps)
same_pool = all(x == pool_names[0] for x in pool_names)
pool_names = iter(map(_pool_name, snaps))
pool_name = next(pool_names, None)
same_pool = all(x == pool_name for x in pool_names)
if same_pool:
return lzc_exc.DuplicateSnapshots(name)
else:
@ -270,7 +272,8 @@ def lzc_hold_translate_errors(ret, errlist, holds, fd):
def lzc_release_translate_errors(ret, errlist, holds):
if ret == 0:
return
for _, hold_list in holds.iteritems():
for snap in holds:
hold_list = holds[snap]
if not isinstance(hold_list, list):
raise lzc_exc.TypeError('holds must be in a list')
@ -705,15 +708,17 @@ def _handle_err_list(ret, errlist, names, exception, mapper):
if len(errlist) == 0:
suppressed_count = 0
names = list(zip(names, range(2)))
if len(names) == 1:
name = names[0]
name, _ = names[0]
else:
name = None
errors = [mapper(ret, name)]
else:
errors = []
suppressed_count = errlist.pop('N_MORE_ERRORS', 0)
for name, err in errlist.iteritems():
for name in errlist:
err = errlist[name]
errors.append(mapper(err, name))
raise exception(errors, suppressed_count)

16
contrib/pyzfs/libzfs_core/_libzfs_core.py
View File

@ -26,6 +26,7 @@ increased convenience. Output parameters are not used and return values
are directly returned. Error conditions are signalled by exceptions
rather than by integer error codes.
"""
from __future__ import absolute_import, division, print_function
import errno
import functools
@ -485,8 +486,8 @@ def lzc_hold(holds, fd=None):
errors.lzc_hold_translate_errors(ret, errlist, holds, fd)
# If there is no error (no exception raised by _handleErrList), but errlist
# is not empty, then it contains missing snapshots.
assert all(x == errno.ENOENT for x in errlist.itervalues())
return errlist.keys()
assert all(errlist[x] == errno.ENOENT for x in errlist)
return list(errlist.keys())
def lzc_release(holds):
@ -521,7 +522,8 @@ def lzc_release(holds):
'''
errlist = {}
holds_dict = {}
for snap, hold_list in holds.iteritems():
for snap in holds:
hold_list = holds[snap]
if not isinstance(hold_list, list):
raise TypeError('holds must be in a list')
holds_dict[snap] = {hold: None for hold in hold_list}
@ -531,8 +533,8 @@ def lzc_release(holds):
errors.lzc_release_translate_errors(ret, errlist, holds)
# If there is no error (no exception raised by _handleErrList), but errlist
# is not empty, then it contains missing snapshots and tags.
assert all(x == errno.ENOENT for x in errlist.itervalues())
return errlist.keys()
assert all(errlist[x] == errno.ENOENT for x in errlist)
return list(errlist.keys())
def lzc_get_holds(snapname):
@ -1873,9 +1875,9 @@ def lzc_get_props(name):
mountpoint_val = '/' + name
else:
mountpoint_val = None
result = {k: v['value'] for k, v in result.iteritems()}
result = {k: result[k]['value'] for k in result}
if 'clones' in result:
result['clones'] = result['clones'].keys()
result['clones'] = list(result['clones'].keys())
if mountpoint_val is not None:
result['mountpoint'] = mountpoint_val
return result

1
contrib/pyzfs/libzfs_core/_nvlist.py
View File

@ -47,6 +47,7 @@ Format:
- a value can be a list of dictionaries that adhere to this format
- all elements of a list value must be of the same type
"""
from __future__ import absolute_import, division, print_function
import numbers
from collections import namedtuple

3
contrib/pyzfs/libzfs_core/bindings/__init__.py
View File

@ -19,6 +19,7 @@ The package that contains a module per each C library that
`libzfs_core` uses. The modules expose CFFI objects required
to make calls to functions in the libraries.
"""
from __future__ import absolute_import, division, print_function
import threading
import importlib
@ -47,7 +48,7 @@ def _setup_cffi():
ffi = FFI()
for module_name in MODULES:
module = importlib.import_module("." + module_name, __package__)
module = importlib.import_module("." + module_name, __name__)
ffi.cdef(module.CDEF)
lib = LazyLibrary(ffi, module.LIBRARY)
setattr(module, "ffi", ffi)

1
contrib/pyzfs/libzfs_core/bindings/libnvpair.py
View File

@ -17,6 +17,7 @@
"""
Python bindings for ``libnvpair``.
"""
from __future__ import absolute_import, division, print_function
CDEF = """
typedef ... nvlist_t;

1
contrib/pyzfs/libzfs_core/bindings/libzfs_core.py
View File

@ -17,6 +17,7 @@
"""
Python bindings for ``libzfs_core``.
"""
from __future__ import absolute_import, division, print_function
CDEF = """

1
contrib/pyzfs/libzfs_core/ctypes.py
View File

@ -17,6 +17,7 @@
"""
Utility functions for casting to a specific C type.
"""
from __future__ import absolute_import, division, print_function
from .bindings.libnvpair import ffi as _ffi

1
contrib/pyzfs/libzfs_core/exceptions.py
View File

@ -17,6 +17,7 @@
"""
Exceptions that can be raised by libzfs_core operations.
"""
from __future__ import absolute_import, division, print_function
import errno
from ._constants import (

217
contrib/pyzfs/libzfs_core/test/test_libzfs_core.py
View File

@ -21,6 +21,7 @@ These are mostly functional and conformance tests that validate
that the operations produce expected effects or fail with expected
exceptions.
"""
from __future__ import absolute_import, division, print_function
import unittest
import contextlib
@ -44,8 +45,8 @@ from .._nvlist import packed_nvlist_out
def _print(*args):
for arg in args:
print arg,
print
print(arg, end=' ')
print()
@contextlib.contextmanager
@ -76,7 +77,7 @@ def _zfs_mount(fs):
with suppress():
subprocess.check_output(unmount_cmd, stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e:
print 'failed to mount %s @ %s : %s' % (fs, mntdir, e.output)
print('failed to mount %s @ %s : %s' % (fs, mntdir, e.output))
raise
finally:
os.rmdir(mntdir)
@ -444,10 +445,10 @@ class ZFSTest(unittest.TestCase):
}
key = os.urandom(lzc.WRAPPING_KEY_LEN)
lzc.lzc_create(name, 'zfs', props=props, key=key)
self.assertEquals(fs.getProperty("encryption"), "aes-256-ccm")
self.assertEquals(fs.getProperty("encryptionroot"), name)
self.assertEquals(fs.getProperty("keylocation"), filename)
self.assertEquals(fs.getProperty("keyformat"), "raw")
self.assertEqual(fs.getProperty("encryption"), "aes-256-ccm")
self.assertEqual(fs.getProperty("encryptionroot"), name)
self.assertEqual(fs.getProperty("keylocation"), filename)
self.assertEqual(fs.getProperty("keyformat"), "raw")
def test_snapshot(self):
snapname = ZFSTest.pool.makeName("@snap")
@ -475,7 +476,7 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
lzc.lzc_snapshot(snaps, props)
self.assertEquals(len(ctx.exception.errors), len(snaps))
self.assertEqual(len(ctx.exception.errors), len(snaps))
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.PropertyInvalid)
self.assertNotExists(snapname)
@ -489,7 +490,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_snapshot(snaps)
# NB: one common error is reported.
self.assertEquals(len(ctx.exception.errors), 1)
self.assertEqual(len(ctx.exception.errors), 1)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.ReadOnlyPool)
self.assertNotExists(snapname1)
@ -502,7 +503,7 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
lzc.lzc_snapshot(snaps)
self.assertEquals(len(ctx.exception.errors), 1)
self.assertEqual(len(ctx.exception.errors), 1)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.FilesystemNotFound)
@ -513,7 +514,7 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
lzc.lzc_snapshot(snaps)
self.assertEquals(len(ctx.exception.errors), 1)
self.assertEqual(len(ctx.exception.errors), 1)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.FilesystemNotFound)
@ -525,7 +526,7 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
lzc.lzc_snapshot(snaps)
self.assertEquals(len(ctx.exception.errors), 1)
self.assertEqual(len(ctx.exception.errors), 1)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.FilesystemNotFound)
self.assertNotExists(snapname1)
@ -540,7 +541,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_snapshot(snaps)
# XXX two errors should be reported but alas
self.assertEquals(len(ctx.exception.errors), 1)
self.assertEqual(len(ctx.exception.errors), 1)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.DuplicateSnapshots)
self.assertNotExists(snapname1)
@ -554,7 +555,7 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
lzc.lzc_snapshot(snaps)
self.assertEquals(len(ctx.exception.errors), 2)
self.assertEqual(len(ctx.exception.errors), 2)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.FilesystemNotFound)
self.assertNotExists(snapname1)
@ -569,7 +570,7 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
lzc.lzc_snapshot(snaps)
self.assertEquals(len(ctx.exception.errors), 1)
self.assertEqual(len(ctx.exception.errors), 1)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.SnapshotExists)
@ -581,7 +582,7 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
lzc.lzc_snapshot(snaps)
self.assertEquals(len(ctx.exception.errors), 1)
self.assertEqual(len(ctx.exception.errors), 1)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.DuplicateSnapshots)
self.assertNotExists(snapname1)
@ -662,7 +663,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_snapshot(snaps)
# NB: one common error is reported.
self.assertEquals(len(ctx.exception.errors), 1)
self.assertEqual(len(ctx.exception.errors), 1)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.PoolsDiffer)
self.assertNotExists(snapname1)
@ -677,7 +678,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_snapshot(snaps)
# NB: one common error is reported.
self.assertEquals(len(ctx.exception.errors), 1)
self.assertEqual(len(ctx.exception.errors), 1)
for e in ctx.exception.errors:
# NB: depending on whether the first attempted snapshot is
# for the read-only pool a different error is reported.
@ -696,7 +697,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_snapshot(snaps)
# NB: one common error is reported.
self.assertEquals(len(ctx.exception.errors), 1)
self.assertEqual(len(ctx.exception.errors), 1)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameInvalid)
self.assertIsNone(e.name)
@ -710,7 +711,7 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
lzc.lzc_snapshot(snaps)
self.assertEquals(len(ctx.exception.errors), 2)
self.assertEqual(len(ctx.exception.errors), 2)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameTooLong)
self.assertIsNotNone(e.name)
@ -725,7 +726,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_snapshot(snaps)
# NB: one common error is reported.
self.assertEquals(len(ctx.exception.errors), 1)
self.assertEqual(len(ctx.exception.errors), 1)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameTooLong)
self.assertIsNone(e.name)
@ -914,7 +915,7 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.SnapshotDestructionFailure) as ctx:
lzc.lzc_destroy_snaps(snaps, False)
self.assertEquals(len(ctx.exception.errors), 1)
self.assertEqual(len(ctx.exception.errors), 1)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.SnapshotIsCloned)
for snap in snaps:
@ -1229,19 +1230,19 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_destroy_snaps([snap1, snap2], defer=False)
bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName('fs1'))
self.assertEquals(len(bmarks), 3)
self.assertEqual(len(bmarks), 3)
for b in 'bmark', 'bmark1', 'bmark2':
self.assertIn(b, bmarks)
self.assertIsInstance(bmarks[b], dict)
self.assertEquals(len(bmarks[b]), 0)
self.assertEqual(len(bmarks[b]), 0)
bmarks = lzc.lzc_get_bookmarks(
ZFSTest.pool.makeName('fs1'), ['guid', 'createtxg', 'creation'])
self.assertEquals(len(bmarks), 3)
self.assertEqual(len(bmarks), 3)
for b in 'bmark', 'bmark1', 'bmark2':
self.assertIn(b, bmarks)
self.assertIsInstance(bmarks[b], dict)
self.assertEquals(len(bmarks[b]), 3)
self.assertEqual(len(bmarks[b]), 3)
@skipUnlessBookmarksSupported
def test_get_bookmarks_invalid_property(self):
@ -1254,11 +1255,11 @@ class ZFSTest(unittest.TestCase):
bmarks = lzc.lzc_get_bookmarks(
ZFSTest.pool.makeName('fs1'), ['badprop'])
self.assertEquals(len(bmarks), 1)
self.assertEqual(len(bmarks), 1)
for b in ('bmark', ):
self.assertIn(b, bmarks)
self.assertIsInstance(bmarks[b], dict)
self.assertEquals(len(bmarks[b]), 0)
self.assertEqual(len(bmarks[b]), 0)
@skipUnlessBookmarksSupported
def test_get_bookmarks_nonexistent_fs(self):
@ -1277,7 +1278,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_destroy_bookmarks(
[bmark, ZFSTest.pool.makeName('fs1#nonexistent')])
bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName('fs1'))
self.assertEquals(len(bmarks), 0)
self.assertEqual(len(bmarks), 0)
@skipUnlessBookmarksSupported
def test_destroy_bookmarks_invalid_name(self):
@ -1295,7 +1296,7 @@ class ZFSTest(unittest.TestCase):
self.assertIsInstance(e, lzc_exc.NameInvalid)
bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName('fs1'))
self.assertEquals(len(bmarks), 1)
self.assertEqual(len(bmarks), 1)
self.assertIn('bmark', bmarks)
@skipUnlessBookmarksSupported
@ -1316,11 +1317,11 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_snapshot([snap3])
space = lzc.lzc_snaprange_space(snap1, snap2)
self.assertIsInstance(space, (int, long))
self.assertIsInstance(space, (int, int))
space = lzc.lzc_snaprange_space(snap2, snap3)
self.assertIsInstance(space, (int, long))
self.assertIsInstance(space, (int, int))
space = lzc.lzc_snaprange_space(snap1, snap3)
self.assertIsInstance(space, (int, long))
self.assertIsInstance(space, (int, int))
def test_snaprange_space_2(self):
snap1 = ZFSTest.pool.makeName("fs1@snap1")
@ -1355,7 +1356,7 @@ class ZFSTest(unittest.TestCase):
space = lzc.lzc_snaprange_space(snap, snap)
self.assertGreater(space, 1024 * 1024)
self.assertAlmostEqual(space, 1024 * 1024, delta=1024 * 1024 / 20)
self.assertAlmostEqual(space, 1024 * 1024, delta=1024 * 1024 // 20)
def test_snaprange_space_wrong_order(self):
snap1 = ZFSTest.pool.makeName("fs1@snap1")
@ -1395,11 +1396,11 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
lzc.lzc_snaprange_space(snap1, snap2)
self.assertEquals(ctx.exception.name, snap2)
self.assertEqual(ctx.exception.name, snap2)
with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
lzc.lzc_snaprange_space(snap2, snap1)
self.assertEquals(ctx.exception.name, snap1)
self.assertEqual(ctx.exception.name, snap1)
def test_snaprange_space_invalid_name(self):
snap1 = ZFSTest.pool.makeName("fs1@snap1")
@ -1442,17 +1443,17 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_snapshot([snap3])
space = lzc.lzc_send_space(snap2, snap1)
self.assertIsInstance(space, (int, long))
self.assertIsInstance(space, (int, int))
space = lzc.lzc_send_space(snap3, snap2)
self.assertIsInstance(space, (int, long))
self.assertIsInstance(space, (int, int))
space = lzc.lzc_send_space(snap3, snap1)
self.assertIsInstance(space, (int, long))
self.assertIsInstance(space, (int, int))
space = lzc.lzc_send_space(snap1)
self.assertIsInstance(space, (int, long))
self.assertIsInstance(space, (int, int))
space = lzc.lzc_send_space(snap2)
self.assertIsInstance(space, (int, long))
self.assertIsInstance(space, (int, int))
space = lzc.lzc_send_space(snap3)
self.assertIsInstance(space, (int, long))
self.assertIsInstance(space, (int, int))
def test_send_space_2(self):
snap1 = ZFSTest.pool.makeName("fs1@snap1")
@ -1481,7 +1482,7 @@ class ZFSTest(unittest.TestCase):
self.assertGreater(space, 1024 * 1024)
space = lzc.lzc_send_space(snap3)
self.assertEquals(space, space_empty)
self.assertEqual(space, space_empty)
def test_send_space_same_snap(self):
snap1 = ZFSTest.pool.makeName("fs1@snap1")
@ -1527,15 +1528,15 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
lzc.lzc_send_space(snap1, snap2)
self.assertEquals(ctx.exception.name, snap1)
self.assertEqual(ctx.exception.name, snap1)
with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
lzc.lzc_send_space(snap2, snap1)
self.assertEquals(ctx.exception.name, snap2)
self.assertEqual(ctx.exception.name, snap2)
with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
lzc.lzc_send_space(snap2)
self.assertEquals(ctx.exception.name, snap2)
self.assertEqual(ctx.exception.name, snap2)
def test_send_space_invalid_name(self):
snap1 = ZFSTest.pool.makeName("fs1@snap1")
@ -1545,13 +1546,13 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.NameInvalid) as ctx:
lzc.lzc_send_space(snap2, snap1)
self.assertEquals(ctx.exception.name, snap2)
self.assertEqual(ctx.exception.name, snap2)
with self.assertRaises(lzc_exc.NameInvalid) as ctx:
lzc.lzc_send_space(snap2)
self.assertEquals(ctx.exception.name, snap2)
self.assertEqual(ctx.exception.name, snap2)
with self.assertRaises(lzc_exc.NameInvalid) as ctx:
lzc.lzc_send_space(snap1, snap2)
self.assertEquals(ctx.exception.name, snap2)
self.assertEqual(ctx.exception.name, snap2)
def test_send_space_not_snap(self):
snap1 = ZFSTest.pool.makeName("fs1@snap1")
@ -1594,7 +1595,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_send(snap, None, fd)
st = os.fstat(fd)
# 5%, arbitrary.
self.assertAlmostEqual(st.st_size, estimate, delta=estimate / 20)
self.assertAlmostEqual(st.st_size, estimate, delta=estimate // 20)
def test_send_incremental(self):
snap1 = ZFSTest.pool.makeName("fs1@snap1")
@ -1615,7 +1616,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_send(snap2, snap1, fd)
st = os.fstat(fd)
# 5%, arbitrary.
self.assertAlmostEqual(st.st_size, estimate, delta=estimate / 20)
self.assertAlmostEqual(st.st_size, estimate, delta=estimate // 20)
def test_send_flags(self):
flags = ['embedded_data', 'large_blocks', 'compress', 'raw']
@ -1688,15 +1689,15 @@ class ZFSTest(unittest.TestCase):
fd = output.fileno()
with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
lzc.lzc_send(snap1, snap2, fd)
self.assertEquals(ctx.exception.name, snap1)
self.assertEqual(ctx.exception.name, snap1)
with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
lzc.lzc_send(snap2, snap1, fd)
self.assertEquals(ctx.exception.name, snap2)
self.assertEqual(ctx.exception.name, snap2)
with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
lzc.lzc_send(snap2, None, fd)
self.assertEquals(ctx.exception.name, snap2)
self.assertEqual(ctx.exception.name, snap2)
def test_send_invalid_name(self):
snap1 = ZFSTest.pool.makeName("fs1@snap1")
@ -1708,13 +1709,13 @@ class ZFSTest(unittest.TestCase):
fd = output.fileno()
with self.assertRaises(lzc_exc.NameInvalid) as ctx:
lzc.lzc_send(snap2, snap1, fd)
self.assertEquals(ctx.exception.name, snap2)
self.assertEqual(ctx.exception.name, snap2)
with self.assertRaises(lzc_exc.NameInvalid) as ctx:
lzc.lzc_send(snap2, None, fd)
self.assertEquals(ctx.exception.name, snap2)
self.assertEqual(ctx.exception.name, snap2)
with self.assertRaises(lzc_exc.NameInvalid) as ctx:
lzc.lzc_send(snap1, snap2, fd)
self.assertEquals(ctx.exception.name, snap2)
self.assertEqual(ctx.exception.name, snap2)
# XXX Although undocumented the API allows to create an incremental
# or full stream for a filesystem as if a temporary unnamed snapshot
@ -1784,7 +1785,7 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.StreamIOError) as ctx:
lzc.lzc_send(snap, None, bad_fd)
self.assertEquals(ctx.exception.errno, errno.EBADF)
self.assertEqual(ctx.exception.errno, errno.EBADF)
def test_send_bad_fd_2(self):
snap = ZFSTest.pool.makeName("fs1@snap")
@ -1792,7 +1793,7 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.StreamIOError) as ctx:
lzc.lzc_send(snap, None, -2)
self.assertEquals(ctx.exception.errno, errno.EBADF)
self.assertEqual(ctx.exception.errno, errno.EBADF)
def test_send_bad_fd_3(self):
snap = ZFSTest.pool.makeName("fs1@snap")
@ -1805,7 +1806,7 @@ class ZFSTest(unittest.TestCase):
bad_fd = hard + 1
with self.assertRaises(lzc_exc.StreamIOError) as ctx:
lzc.lzc_send(snap, None, bad_fd)
self.assertEquals(ctx.exception.errno, errno.EBADF)
self.assertEqual(ctx.exception.errno, errno.EBADF)
def test_send_to_broken_pipe(self):
snap = ZFSTest.pool.makeName("fs1@snap")
@ -1815,7 +1816,7 @@ class ZFSTest(unittest.TestCase):
proc.wait()
with self.assertRaises(lzc_exc.StreamIOError) as ctx:
lzc.lzc_send(snap, None, proc.stdin.fileno())
self.assertEquals(ctx.exception.errno, errno.EPIPE)
self.assertEqual(ctx.exception.errno, errno.EPIPE)
def test_send_to_broken_pipe_2(self):
snap = ZFSTest.pool.makeName("fs1@snap")
@ -1845,7 +1846,7 @@ class ZFSTest(unittest.TestCase):
with self.assertRaises(lzc_exc.StreamIOError) as ctx:
lzc.lzc_send(snap, None, fd)
os.close(fd)
self.assertEquals(ctx.exception.errno, errno.EBADF)
self.assertEqual(ctx.exception.errno, errno.EBADF)
def test_recv_full(self):
src = ZFSTest.pool.makeName("fs1@snap")
@ -2038,7 +2039,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_receive(dst, stream.fileno(), origin=origin1)
origin = ZFSTest.pool.getFilesystem("fs2/received-30").getProperty(
'origin')
self.assertEquals(origin, origin1)
self.assertEqual(origin, origin1)
stream.seek(0)
# because origin snap does not exist can't receive as a clone of it
with self.assertRaises((
@ -2745,8 +2746,8 @@ class ZFSTest(unittest.TestCase):
(header, c_header) = lzc.receive_header(stream.fileno())
lzc.lzc_receive_one(tosnap, stream.fileno(), c_header, props=props)
self.assertExists(tosnap)
self.assertEquals(fs.getProperty("compression", "received"), "on")
self.assertEquals(fs.getProperty("ns:prop", "received"), "val")
self.assertEqual(fs.getProperty("compression", "received"), "on")
self.assertEqual(fs.getProperty("ns:prop", "received"), "val")
def test_recv_one_invalid_prop(self):
fromsnap = ZFSTest.pool.makeName("fs1@snap1")
@ -2766,10 +2767,10 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_receive_one(
tosnap, stream.fileno(), c_header, props=props)
self.assertExists(tosnap)
self.assertEquals(fs.getProperty("atime", "received"), "off")
self.assertEqual(fs.getProperty("atime", "received"), "off")
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.PropertyInvalid)
self.assertEquals(e.name, "exec")
self.assertEqual(e.name, "exec")
def test_recv_with_cmdprops(self):
fromsnap = ZFSTest.pool.makeName("fs1@snap1")
@ -2790,8 +2791,8 @@ class ZFSTest(unittest.TestCase):
tosnap, stream.fileno(), c_header, props=props,
cmdprops=cmdprops)
self.assertExists(tosnap)
self.assertEquals(fs.getProperty("compression"), "on")
self.assertEquals(fs.getProperty("ns:prop"), "val")
self.assertEqual(fs.getProperty("compression"), "on")
self.assertEqual(fs.getProperty("ns:prop"), "val")
def test_recv_with_cmdprops_and_recvprops(self):
fromsnap = ZFSTest.pool.makeName("fs1@snap1")
@ -2817,12 +2818,12 @@ class ZFSTest(unittest.TestCase):
tosnap, stream.fileno(), c_header, props=props,
cmdprops=cmdprops)
self.assertExists(tosnap)
self.assertEquals(fs.getProperty("atime", True), "on")
self.assertEquals(fs.getProperty("exec", True), "off")
self.assertEquals(fs.getProperty("ns:prop", True), "abc")
self.assertEquals(fs.getProperty("compression"), "on")
self.assertEquals(fs.getProperty("ns:prop"), "def")
self.assertEquals(fs.getProperty("exec"), "on")
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")
def test_recv_incr_across_clone_branch_point_no_origin(self):
origfs = ZFSTest.pool.makeName("fs2")
@ -3059,7 +3060,7 @@ class ZFSTest(unittest.TestCase):
snap = ZFSTest.pool.getRoot().getFilesystem().getSnap()
snaps = lzc.lzc_hold({snap: 'tag'})
self.assertEquals([snap], snaps)
self.assertEqual([snap], snaps)
def test_hold_missing_fs_auto_cleanup(self):
# XXX skip pre-created filesystems
@ -3072,7 +3073,7 @@ class ZFSTest(unittest.TestCase):
with cleanup_fd() as fd:
snaps = lzc.lzc_hold({snap: 'tag'}, fd)
self.assertEquals([snap], snaps)
self.assertEqual([snap], snaps)
def test_hold_duplicate(self):
snap = ZFSTest.pool.getRoot().getSnap()
@ -3107,7 +3108,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_hold({snap: tag}, fd)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameTooLong)
self.assertEquals(e.name, tag)
self.assertEqual(e.name, tag)
# Apparently the full snapshot name is not checked for length
# and this snapshot is treated as simply missing.
@ -3119,7 +3120,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_hold({snap: 'tag'}, fd)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameTooLong)
self.assertEquals(e.name, snap)
self.assertEqual(e.name, snap)
def test_hold_too_long_snap_name_2(self):
snap = ZFSTest.pool.getRoot().getTooLongSnap(True)
@ -3128,7 +3129,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_hold({snap: 'tag'}, fd)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameTooLong)
self.assertEquals(e.name, snap)
self.assertEqual(e.name, snap)
def test_hold_invalid_snap_name(self):
snap = ZFSTest.pool.getRoot().getSnap() + '@bad'
@ -3137,7 +3138,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_hold({snap: 'tag'}, fd)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameInvalid)
self.assertEquals(e.name, snap)
self.assertEqual(e.name, snap)
def test_hold_invalid_snap_name_2(self):
snap = ZFSTest.pool.getRoot().getFilesystem().getName()
@ -3146,7 +3147,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_hold({snap: 'tag'}, fd)
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameInvalid)
self.assertEquals(e.name, snap)
self.assertEqual(e.name, snap)
def test_get_holds(self):
snap = ZFSTest.pool.getRoot().getSnap()
@ -3157,10 +3158,10 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_hold({snap: 'tag2'}, fd)
holds = lzc.lzc_get_holds(snap)
self.assertEquals(len(holds), 2)
self.assertEqual(len(holds), 2)
self.assertIn('tag1', holds)
self.assertIn('tag2', holds)
self.assertIsInstance(holds['tag1'], (int, long))
self.assertIsInstance(holds['tag1'], (int, int))
def test_get_holds_after_auto_cleanup(self):
snap = ZFSTest.pool.getRoot().getSnap()
@ -3171,7 +3172,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_hold({snap: 'tag2'}, fd)
holds = lzc.lzc_get_holds(snap)
self.assertEquals(len(holds), 0)
self.assertEqual(len(holds), 0)
self.assertIsInstance(holds, dict)
def test_get_holds_nonexistent_snap(self):
@ -3208,11 +3209,11 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_hold({snap: 'tag'})
ret = lzc.lzc_release({snap: ['tag']})
self.assertEquals(len(ret), 0)
self.assertEqual(len(ret), 0)
def test_release_hold_empty(self):
ret = lzc.lzc_release({})
self.assertEquals(len(ret), 0)
self.assertEqual(len(ret), 0)
def test_release_hold_complex(self):
snap1 = ZFSTest.pool.getRoot().getSnap()
@ -3228,11 +3229,11 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_hold({snap3: 'tag2'})
holds = lzc.lzc_get_holds(snap1)
self.assertEquals(len(holds), 2)
self.assertEqual(len(holds), 2)
holds = lzc.lzc_get_holds(snap2)
self.assertEquals(len(holds), 1)
self.assertEqual(len(holds), 1)
holds = lzc.lzc_get_holds(snap3)
self.assertEquals(len(holds), 2)
self.assertEqual(len(holds), 2)
release = {
snap1: ['tag1', 'tag2'],
@ -3240,19 +3241,19 @@ class ZFSTest(unittest.TestCase):
snap3: ['tag2'],
}
ret = lzc.lzc_release(release)
self.assertEquals(len(ret), 0)
self.assertEqual(len(ret), 0)
holds = lzc.lzc_get_holds(snap1)
self.assertEquals(len(holds), 0)
self.assertEqual(len(holds), 0)
holds = lzc.lzc_get_holds(snap2)
self.assertEquals(len(holds), 0)
self.assertEqual(len(holds), 0)
holds = lzc.lzc_get_holds(snap3)
self.assertEquals(len(holds), 1)
self.assertEqual(len(holds), 1)
ret = lzc.lzc_release({snap3: ['tag1']})
self.assertEquals(len(ret), 0)
self.assertEqual(len(ret), 0)
holds = lzc.lzc_get_holds(snap3)
self.assertEquals(len(holds), 0)
self.assertEqual(len(holds), 0)
def test_release_hold_before_auto_cleanup(self):
snap = ZFSTest.pool.getRoot().getSnap()
@ -3261,7 +3262,7 @@ class ZFSTest(unittest.TestCase):
with cleanup_fd() as fd:
lzc.lzc_hold({snap: 'tag'}, fd)
ret = lzc.lzc_release({snap: ['tag']})
self.assertEquals(len(ret), 0)
self.assertEqual(len(ret), 0)
def test_release_hold_and_snap_destruction(self):
snap = ZFSTest.pool.getRoot().getSnap()
@ -3301,22 +3302,22 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_snapshot([snap])
ret = lzc.lzc_release({snap: ['tag']})
self.assertEquals(len(ret), 1)
self.assertEquals(ret[0], snap + '#tag')
self.assertEqual(len(ret), 1)
self.assertEqual(ret[0], snap + '#tag')
def test_release_hold_missing_snap(self):
snap = ZFSTest.pool.getRoot().getSnap()
ret = lzc.lzc_release({snap: ['tag']})
self.assertEquals(len(ret), 1)
self.assertEquals(ret[0], snap)
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']})
self.assertEquals(len(ret), 1)
self.assertEquals(ret[0], snap)
self.assertEqual(len(ret), 1)
self.assertEqual(ret[0], snap)
def test_release_hold_across_pools(self):
snap1 = ZFSTest.pool.getRoot().getSnap()
@ -3358,7 +3359,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_release({snap: ['tag']})
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameTooLong)
self.assertEquals(e.name, snap)
self.assertEqual(e.name, snap)
def test_release_hold_invalid_snap_name(self):
snap = ZFSTest.pool.getRoot().getSnap() + '@bad'
@ -3366,7 +3367,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_release({snap: ['tag']})
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameInvalid)
self.assertEquals(e.name, snap)
self.assertEqual(e.name, snap)
def test_release_hold_invalid_snap_name_2(self):
snap = ZFSTest.pool.getRoot().getFilesystem().getName()
@ -3374,7 +3375,7 @@ class ZFSTest(unittest.TestCase):
lzc.lzc_release({snap: ['tag']})
for e in ctx.exception.errors:
self.assertIsInstance(e, lzc_exc.NameInvalid)
self.assertEquals(e.name, snap)
self.assertEqual(e.name, snap)
def test_sync_missing_pool(self):
pool = "nonexistent"
@ -4062,7 +4063,7 @@ class _TempPool(object):
if 'permission denied' in e.output:
raise unittest.SkipTest(
'insufficient privileges to run libzfs_core tests')
print 'command failed: ', e.output
print('command failed: ', e.output)
raise
except Exception:
self.cleanUp()
@ -4108,7 +4109,7 @@ class _TempPool(object):
time.sleep(1)
continue
else:
print 'command failed: ', e.output
print('command failed: ', e.output)
raise
for fs in self._filesystems:
lzc.lzc_create(self.makeName(fs))

1
contrib/pyzfs/libzfs_core/test/test_nvlist.py
View File

@ -21,6 +21,7 @@ and verify that no information is lost and value types are correct.
The tests also check that various error conditions like unsupported
value types or out of bounds values are detected.
"""
from __future__ import absolute_import, division, print_function
import unittest

1
contrib/pyzfs/setup.py
View File

@ -13,6 +13,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
from __future__ import absolute_import, division, print_function
from setuptools import setup, find_packages