diff options
| author | Brian Behlendorf <[email protected]> | 2019-01-06 10:41:16 -0800 |
|---|---|---|
| committer | Brian Behlendorf <[email protected]> | 2019-01-06 10:54:12 -0800 |
| commit | c87db591967507de027d6bb0c683ffd09dd70105 (patch) | |
| tree | e308115e563c7011194dc55d4f3bd65c0ec664b1 | |
| parent | 0b8e4418b615eb6e46d409b3de61bfffe1000c68 (diff) | |
| parent | dffce3c282f74991e740c1e1887001fe059fe05a (diff) | |
Python 2 and 3 compatibility
With Python 2 (slowly) approaching EOL and its removal from distribitions
already being planned (Fedora), the existing Python 2 code needs to be
transitioned to Python 3. This patch stack updates the Python code to
be compatible with Python 2.7, 3.4, 3.5, 3.6, and 3.7.
Reviewed-by: John Ramsden <[email protected]>
Reviewed-by: Neal Gompa <[email protected]>
Reviewed-by: loli10K <[email protected]>
Reviewed-by: Brian Behlendorf <[email protected]>
Reviewed-by: John Wren Kennedy <[email protected]>
Reviewed-by: Antonio Russo <[email protected]>
Closes #8096
45 files changed, 1594 insertions, 1395 deletions
diff --git a/.gitignore b/.gitignore index 3a8cb2e86..6367ebf77 100644 --- a/.gitignore +++ b/.gitignore @@ -22,6 +22,8 @@ *.swp *.gcno *.gcda +*.pyc +*.pyo .deps .libs .dirstamp diff --git a/cmd/arc_summary/Makefile.am b/cmd/arc_summary/Makefile.am index ac7b0d48d..a83edffad 100644 --- a/cmd/arc_summary/Makefile.am +++ b/cmd/arc_summary/Makefile.am @@ -1 +1,13 @@ -dist_bin_SCRIPTS = arc_summary.py arc_summary3.py +EXTRA_DIST = arc_summary2 arc_summary3 + +if USING_PYTHON_2 +dist_bin_SCRIPTS = arc_summary2 +install-exec-hook: + mv $(DESTDIR)$(bindir)/arc_summary2 $(DESTDIR)$(bindir)/arc_summary +endif + +if USING_PYTHON_3 +dist_bin_SCRIPTS = arc_summary3 +install-exec-hook: + mv $(DESTDIR)$(bindir)/arc_summary3 $(DESTDIR)$(bindir)/arc_summary +endif diff --git a/cmd/arc_summary/arc_summary.py b/cmd/arc_summary/arc_summary2 index 642c94b69..ab4a3c574 100755 --- a/cmd/arc_summary/arc_summary.py +++ b/cmd/arc_summary/arc_summary2 @@ -1,4 +1,4 @@ -#!/usr/bin/python +#!/usr/bin/python2 # # $Id: arc_summary.pl,v 388:e27800740aa2 2011-07-08 02:53:29Z jhell $ # @@ -35,6 +35,8 @@ # Note some of this code uses older code (eg getopt instead of argparse, # subprocess.Popen() instead of subprocess.run()) because we need to support # some very old versions of Python. +# + """Print statistics on the ZFS Adjustable Replacement Cache (ARC) Provides basic information on the ARC, its efficiency, the L2ARC (if present), @@ -1005,7 +1007,7 @@ def zfs_header(): def usage(): """Print usage information""" - sys.stdout.write("Usage: arc_summary.py [-h] [-a] [-d] [-p PAGE]\n\n") + sys.stdout.write("Usage: arc_summary [-h] [-a] [-d] [-p PAGE]\n\n") sys.stdout.write("\t -h, --help : " "Print this help message and exit\n") sys.stdout.write("\t -a, --alternate : " @@ -1018,10 +1020,10 @@ def usage(): "should be an integer between 1 and " + str(len(unSub)) + "\n\n") sys.stdout.write("Examples:\n") - sys.stdout.write("\tarc_summary.py -a\n") - sys.stdout.write("\tarc_summary.py -p 4\n") - sys.stdout.write("\tarc_summary.py -ad\n") - sys.stdout.write("\tarc_summary.py --page=2\n") + sys.stdout.write("\tarc_summary -a\n") + sys.stdout.write("\tarc_summary -p 4\n") + sys.stdout.write("\tarc_summary -ad\n") + sys.stdout.write("\tarc_summary --page=2\n") def main(): diff --git a/cmd/arc_summary/arc_summary3.py b/cmd/arc_summary/arc_summary3 index e70f2a35e..e67cd90f7 100755 --- a/cmd/arc_summary/arc_summary3.py +++ b/cmd/arc_summary/arc_summary3 @@ -346,7 +346,7 @@ def get_version(request): error_msg = '(ERROR: "{0}" requested)'.format(request) return error_msg - # The original arc_summary.py called /sbin/modinfo/{spl,zfs} to get + # The original arc_summary called /sbin/modinfo/{spl,zfs} to get # the version information. We switch to /sys/module/{spl,zfs}/version # to make sure we get what is really loaded in the kernel command = ["cat", "/sys/module/{0}/version".format(request)] @@ -374,7 +374,7 @@ def print_header(): """ # datetime is now recommended over time but we keep the exact formatting - # from the older version of arc_summary.py in case there are scripts + # from the older version of arc_summary in case there are scripts # that expect it in this way daydate = time.strftime(DATE_FORMAT) spc_date = LINE_LENGTH-len(daydate) @@ -586,7 +586,7 @@ def section_archits(kstats_dict): # For some reason, anon_hits can turn negative, which is weird. Until we # have figured out why this happens, we just hide the problem, following - # the behavior of the original arc_summary.py + # the behavior of the original arc_summary. if anon_hits >= 0: prt_i2('Anonymously used:', f_perc(anon_hits, arc_stats['hits']), f_hits(anon_hits)) diff --git a/cmd/arcstat/Makefile.am b/cmd/arcstat/Makefile.am index 8987b2414..462e9a619 100644 --- a/cmd/arcstat/Makefile.am +++ b/cmd/arcstat/Makefile.am @@ -1 +1,13 @@ -dist_bin_SCRIPTS = arcstat.py +dist_bin_SCRIPTS = arcstat + +# +# The arcstat script is compatibile with both Python 2.6 and 3.4. +# As such the python 3 shebang can be replaced at install time when +# targeting a python 2 system. This allows us to maintain a single +# version of the source. +# +if USING_PYTHON_2 +install-exec-hook: + sed --in-place 's|^#!/usr/bin/python3|#!/usr/bin/python2|' \ + $(DESTDIR)$(bindir)/arcstat +endif diff --git a/cmd/arcstat/arcstat.py b/cmd/arcstat/arcstat index a2c52ddb3..57a2d621f 100755 --- a/cmd/arcstat/arcstat.py +++ b/cmd/arcstat/arcstat @@ -1,4 +1,4 @@ -#!/usr/bin/python +#!/usr/bin/python3 # # Print out ZFS ARC Statistics exported via kstat(1) # For a definition of fields, or usage, use arctstat.pl -v @@ -42,7 +42,8 @@ # @hdr is the array of fields that needs to be printed, so we # just iterate over this array and print the values using our pretty printer. # - +# This script must remain compatible with Python 2.6+ and Python 3.4+. +# import sys import time @@ -109,7 +110,7 @@ opfile = None sep = " " # Default separator is 2 spaces version = "0.4" l2exist = False -cmd = ("Usage: arcstat.py [-hvx] [-f fields] [-o file] [-s string] [interval " +cmd = ("Usage: arcstat [-hvx] [-f fields] [-o file] [-s string] [interval " "[count]]\n") cur = {} d = {} @@ -138,10 +139,10 @@ def usage(): sys.stderr.write("\t -s : Override default field separator with custom " "character or string\n") sys.stderr.write("\nExamples:\n") - sys.stderr.write("\tarcstat.py -o /tmp/a.log 2 10\n") - sys.stderr.write("\tarcstat.py -s \",\" -o /tmp/a.log 2 10\n") - sys.stderr.write("\tarcstat.py -v\n") - sys.stderr.write("\tarcstat.py -f time,hit%,dh%,ph%,mh% 1\n") + sys.stderr.write("\tarcstat -o /tmp/a.log 2 10\n") + sys.stderr.write("\tarcstat -s \",\" -o /tmp/a.log 2 10\n") + sys.stderr.write("\tarcstat -v\n") + sys.stderr.write("\tarcstat -f time,hit%,dh%,ph%,mh% 1\n") sys.stderr.write("\n") sys.exit(1) diff --git a/cmd/dbufstat/Makefile.am b/cmd/dbufstat/Makefile.am index 19bffb020..968a76077 100644 --- a/cmd/dbufstat/Makefile.am +++ b/cmd/dbufstat/Makefile.am @@ -1 +1,13 @@ -dist_bin_SCRIPTS = dbufstat.py +dist_bin_SCRIPTS = dbufstat + +# +# The dbufstat script is compatibile with both Python 2.6 and 3.4. +# As such the python 3 shebang can be replaced at install time when +# targeting a python 2 system. This allows us to maintain a single +# version of the source. +# +if USING_PYTHON_2 +install-exec-hook: + sed --in-place 's|^#!/usr/bin/python3|#!/usr/bin/python2|' \ + $(DESTDIR)$(bindir)/dbufstat +endif diff --git a/cmd/dbufstat/dbufstat.py b/cmd/dbufstat/dbufstat index 5e2217a54..e6c947fbc 100755 --- a/cmd/dbufstat/dbufstat.py +++ b/cmd/dbufstat/dbufstat @@ -1,4 +1,4 @@ -#!/usr/bin/python +#!/usr/bin/python3 # # Print out statistics for all cached dmu buffers. This information # is available through the dbufs kstat and may be post-processed as @@ -27,6 +27,8 @@ # Copyright (C) 2013 Lawrence Livermore National Security, LLC. # Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER). # +# This script must remain compatible with Python 2.6+ and Python 3.4+. +# import sys import getopt @@ -106,7 +108,7 @@ cols = { hdr = None xhdr = None sep = " " # Default separator is 2 spaces -cmd = ("Usage: dbufstat.py [-bdhnrtvx] [-i file] [-f fields] [-o file] " +cmd = ("Usage: dbufstat [-bdhnrtvx] [-i file] [-f fields] [-o file] " "[-s string] [-F filter]\n") raw = 0 @@ -167,11 +169,11 @@ def usage(): "character or string\n") sys.stderr.write("\t -F : Filter output by value or regex\n") sys.stderr.write("\nExamples:\n") - sys.stderr.write("\tdbufstat.py -d -o /tmp/d.log\n") - sys.stderr.write("\tdbufstat.py -t -s \",\" -o /tmp/t.log\n") - sys.stderr.write("\tdbufstat.py -v\n") - sys.stderr.write("\tdbufstat.py -d -f pool,object,objset,dsize,cached\n") - sys.stderr.write("\tdbufstat.py -bx -F dbc=1,objset=54,pool=testpool\n") + sys.stderr.write("\tdbufstat -d -o /tmp/d.log\n") + sys.stderr.write("\tdbufstat -t -s \",\" -o /tmp/t.log\n") + sys.stderr.write("\tdbufstat -v\n") + sys.stderr.write("\tdbufstat -d -f pool,object,objset,dsize,cached\n") + sys.stderr.write("\tdbufstat -bx -F dbc=1,objset=54,pool=testpool\n") sys.stderr.write("\n") sys.exit(1) diff --git a/config/always-python.m4 b/config/always-python.m4 new file mode 100644 index 000000000..858ab7b01 --- /dev/null +++ b/config/always-python.m4 @@ -0,0 +1,102 @@ +dnl # +dnl # ZFS_AC_PYTHON_VERSION(version, [action-if-true], [action-if-false]) +dnl # +dnl # Verify Python version +dnl # +AC_DEFUN([ZFS_AC_PYTHON_VERSION], [ + ver_check=`$PYTHON -c "import sys; print (sys.version.split()[[0]] $1)"` + AS_IF([test "$ver_check" = "True"], [ + m4_ifvaln([$2], [$2]) + ], [ + m4_ifvaln([$3], [$3]) + ]) +]) + +dnl # +dnl # ZFS_AC_PYTHON_MODULE(module_name, [action-if-true], [action-if-false]) +dnl # +dnl # Checks for Python module. Freely inspired by AX_PYTHON_MODULE +dnl # https://www.gnu.org/software/autoconf-archive/ax_python_module.html +dnl # Required by ZFS_AC_CONFIG_ALWAYS_PYZFS. +dnl # +AC_DEFUN([ZFS_AC_PYTHON_MODULE], [ + PYTHON_NAME=`basename $PYTHON` + AC_MSG_CHECKING([for $PYTHON_NAME module: $1]) + AS_IF([$PYTHON -c "import $1" 2>/dev/null], [ + AC_MSG_RESULT(yes) + m4_ifvaln([$2], [$2]) + ], [ + AC_MSG_RESULT(no) + m4_ifvaln([$3], [$3]) + ]) +]) + +dnl # +dnl # The majority of the python scripts are written to be compatible +dnl # with Python 2.6 and Python 3.4. Therefore, they may be installed +dnl # and used with either interpreter. This option is intended to +dnl # to provide a method to specify the default system version, and +dnl # set the PYTHON environment variable accordingly. +dnl # +AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_PYTHON], [ + AC_ARG_WITH([python], + AC_HELP_STRING([--with-python[=VERSION]], + [default system python version @<:@default=check@:>@]), + [with_python=$withval], + [with_python=check]) + + AS_CASE([$with_python], + [check], + [AS_IF([test -x /usr/bin/python3], + [PYTHON="python3"], + [AS_IF([test -x /usr/bin/python2], + [PYTHON="python2"], + [PYTHON=""] + )] + )], + [2*], [PYTHON="python${with_python}"], + [*python2*], [PYTHON="${with_python}"], + [3*], [PYTHON="python${with_python}"], + [*python3*], [PYTHON="${with_python}"], + [no], [PYTHON=""], + [AC_MSG_ERROR([Unknown --with-python value '$with_python'])] + ) + + AS_IF([$PYTHON --version >/dev/null 2>&1], [ /bin/true ], [ + AC_MSG_ERROR([Cannot find $PYTHON in your system path]) + ]) + + AM_PATH_PYTHON([2.6], [], [:]) + AM_CONDITIONAL([USING_PYTHON], [test "$PYTHON" != :]) + AM_CONDITIONAL([USING_PYTHON_2], [test "${PYTHON_VERSION:0:2}" = "2."]) + AM_CONDITIONAL([USING_PYTHON_3], [test "${PYTHON_VERSION:0:2}" = "3."]) + + dnl # + dnl # Minimum supported Python versions for utilities: + dnl # Python 2.6.x, or Python 3.4.x + dnl # + AS_IF([test "${PYTHON_VERSION:0:2}" = "2."], [ + ZFS_AC_PYTHON_VERSION([>= '2.6'], [ /bin/true ], + [AC_MSG_ERROR("Python >= 2.6.x is not available")]) + ]) + + AS_IF([test "${PYTHON_VERSION:0:2}" = "3."], [ + ZFS_AC_PYTHON_VERSION([>= '3.4'], [ /bin/true ], + [AC_MSG_ERROR("Python >= 3.4.x is not available")]) + ]) + + dnl # + dnl # Request that packages be built for a specific Python version. + dnl # + AS_IF([test $with_python != check], [ + PYTHON_PKG_VERSION=`echo ${PYTHON} | tr -d 'a-zA-Z.'` + DEFINE_PYTHON_PKG_VERSION='--define "__use_python_pkg_version '${PYTHON_PKG_VERSION}'"' + DEFINE_PYTHON_VERSION='--define "__use_python '${PYTHON}'"' + ], [ + DEFINE_PYTHON_VERSION='' + DEFINE_PYTHON_PKG_VERSION='' + ]) + + AC_SUBST(DEFINE_PYTHON_VERSION) + AC_SUBST(DEFINE_PYTHON_PKG_VERSION) +]) diff --git a/config/always-pyzfs.m4 b/config/always-pyzfs.m4 index c50acb099..d74d6f1a7 100644 --- a/config/always-pyzfs.m4 +++ b/config/always-pyzfs.m4 @@ -1,80 +1,44 @@ dnl # -dnl # ZFS_AC_PYTHON_MODULE(module_name, [action-if-true], [action-if-false]) +dnl # Determines if pyzfs can be built, requires Python 2.7 or latter. dnl # -dnl # Checks for Python module. Freely inspired by AX_PYTHON_MODULE -dnl # https://www.gnu.org/software/autoconf-archive/ax_python_module.html -dnl # -AC_DEFUN([ZFS_AC_PYTHON_MODULE],[ - PYTHON_NAME=`basename $PYTHON` - AC_MSG_CHECKING([for $PYTHON_NAME module: $1]) - $PYTHON -c "import $1" 2>/dev/null - if test $? -eq 0; - then - AC_MSG_RESULT(yes) - m4_ifvaln([$2], [$2]) - else - AC_MSG_RESULT(no) - m4_ifvaln([$3], [$3]) - fi -]) - -dnl # -dnl # ZFS_AC_PYTHON_VERSION(version, [action-if-true], [action-if-false]) -dnl # -dnl # Verify Python version -dnl # -AC_DEFUN([ZFS_AC_PYTHON_VERSION], [ - AC_MSG_CHECKING([for a version of Python $1]) - version_check=`$PYTHON -c "import sys; print (sys.version.split()[[0]] $1)"` - if test "$version_check" = "True"; - then - AC_MSG_RESULT(yes) - m4_ifvaln([$2], [$2]) - else - AC_MSG_RESULT(no) - m4_ifvaln([$3], [$3]) - fi - -]) - AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_PYZFS], [ - PYTHON_REQUIRED_VERSION="<= '2.7.x'" - AC_ARG_ENABLE([pyzfs], AC_HELP_STRING([--enable-pyzfs], [install libzfs_core python bindings @<:@default=check@:>@]), [enable_pyzfs=$enableval], [enable_pyzfs=check]) - AM_PATH_PYTHON([2.7], [], [ + dnl # + dnl # Packages for pyzfs specifically enabled/disabled. + dnl # + AS_IF([test "x$enable_pyzfs" != xcheck], [ AS_IF([test "x$enable_pyzfs" = xyes], [ - AC_MSG_ERROR("python >= 2.7 is not installed") - ], [test ! "x$enable_pyzfs" = xno], [ - enable_pyzfs=no + DEFINE_PYZFS='--with pyzfs' + ], [ + DEFINE_PYZFS='--without pyzfs' ]) + ], [ + DEFINE_PYZFS='' ]) - AM_CONDITIONAL([HAVE_PYTHON], [test "$PYTHON" != :]) + AC_SUBST(DEFINE_PYZFS) dnl # - dnl # Python 2.7.x is supported, other versions (3.5) are not yet + dnl # Require python-devel libraries dnl # - AS_IF([test "x$enable_pyzfs" = xcheck], [ - ZFS_AC_PYTHON_VERSION([$PYTHON_REQUIRED_VERSION], [], [ - AS_IF([test "x$enable_pyzfs" = xyes], [ - AC_MSG_ERROR("Python $PYTHON_REQUIRED_VERSION is not available") - ], [test ! "x$enable_pyzfs" = xno], [ - enable_pyzfs=no + AS_IF([test "x$enable_pyzfs" = xcheck -o "x$enable_pyzfs" = xyes], [ + AS_IF([test "${PYTHON_VERSION:0:2}" = "2."], [ + PYTHON_REQUIRED_VERSION=">= '2.7.0'" + ], [ + AS_IF([test "${PYTHON_VERSION:0:2}" = "3."], [ + PYTHON_REQUIRED_VERSION=">= '3.4.0'" + ], [ + AC_MSG_ERROR("Python $PYTHON_VERSION unknown") ]) ]) - ]) - dnl # - dnl # Require python-devel libraries - dnl # - AS_IF([test "x$enable_pyzfs" = xcheck], [ AX_PYTHON_DEVEL([$PYTHON_REQUIRED_VERSION], [ AS_IF([test "x$enable_pyzfs" = xyes], [ - AC_MSG_ERROR("Python development library is not available") + AC_MSG_ERROR("Python $PYTHON_REQUIRED_VERSION development library is not installed") ], [test ! "x$enable_pyzfs" = xno], [ enable_pyzfs=no ]) @@ -84,10 +48,10 @@ AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_PYZFS], [ dnl # dnl # Python "setuptools" module is required to build and install pyzfs dnl # - AS_IF([test "x$enable_pyzfs" = xcheck], [ + AS_IF([test "x$enable_pyzfs" = xcheck -o "x$enable_pyzfs" = xyes], [ ZFS_AC_PYTHON_MODULE([setuptools], [], [ AS_IF([test "x$enable_pyzfs" = xyes], [ - AC_MSG_ERROR("python-setuptools is not installed") + AC_MSG_ERROR("Python $PYTHON_VERSION setuptools is not installed") ], [test ! "x$enable_pyzfs" = xno], [ enable_pyzfs=no ]) @@ -97,10 +61,10 @@ AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_PYZFS], [ dnl # dnl # Python "cffi" module is required to run pyzfs dnl # - AS_IF([test "x$enable_pyzfs" = xcheck], [ + AS_IF([test "x$enable_pyzfs" = xcheck -o "x$enable_pyzfs" = xyes], [ ZFS_AC_PYTHON_MODULE([cffi], [], [ AS_IF([test "x$enable_pyzfs" = xyes], [ - AC_MSG_ERROR("python-cffi is not installed") + AC_MSG_ERROR("Python $PYTHON_VERSION cffi is not installed") ], [test ! "x$enable_pyzfs" = xno], [ enable_pyzfs=no ]) @@ -114,12 +78,8 @@ AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_PYZFS], [ AM_CONDITIONAL([PYZFS_ENABLED], [test x$enable_pyzfs = xyes]) AC_SUBST([PYZFS_ENABLED], [$enable_pyzfs]) - - AS_IF([test "x$enable_pyzfs" = xyes], [ - DEFINE_PYZFS='--define "_pyzfs 1"' - ],[ - DEFINE_PYZFS='' - ]) - AC_SUBST(DEFINE_PYZFS) AC_SUBST(pythonsitedir, [$PYTHON_SITE_PKG]) + + AC_MSG_CHECKING([whether to enable pyzfs: ]) + AC_MSG_RESULT($enable_pyzfs) ]) diff --git a/config/deb.am b/config/deb.am index eb4e5bbda..e405547aa 100644 --- a/config/deb.am +++ b/config/deb.am @@ -47,7 +47,7 @@ deb-utils: deb-local rpm-utils pkg7=$${name}-test-$${version}.$${arch}.rpm; \ pkg8=$${name}-dracut-$${version}.$${arch}.rpm; \ pkg9=$${name}-initramfs-$${version}.$${arch}.rpm; \ - pkg10=pyzfs-$${version}.noarch.rpm; \ + pkg10=`ls python*-pyzfs-$${version}* | tail -1`; \ ## Arguments need to be passed to dh_shlibdeps. Alien provides no mechanism ## to do this, so we install a shim onto the path which calls the real ## dh_shlibdeps with the required arguments. diff --git a/config/zfs-build.m4 b/config/zfs-build.m4 index 1d47b0384..6e305996e 100644 --- a/config/zfs-build.m4 +++ b/config/zfs-build.m4 @@ -160,6 +160,7 @@ AC_DEFUN([ZFS_AC_CONFIG_ALWAYS], [ ZFS_AC_CONFIG_ALWAYS_CC_ASAN ZFS_AC_CONFIG_ALWAYS_TOOLCHAIN_SIMD ZFS_AC_CONFIG_ALWAYS_ARCH + ZFS_AC_CONFIG_ALWAYS_PYTHON ZFS_AC_CONFIG_ALWAYS_PYZFS ]) @@ -264,10 +265,13 @@ AC_DEFUN([ZFS_AC_RPM], [ RPM_DEFINE_UTIL+=' $(DEFINE_INITRAMFS)' RPM_DEFINE_UTIL+=' $(DEFINE_SYSTEMD)' RPM_DEFINE_UTIL+=' $(DEFINE_PYZFS)' + RPM_DEFINE_UTIL+=' $(DEFINE_PYTHON_VERSION)' + RPM_DEFINE_UTIL+=' $(DEFINE_PYTHON_PKG_VERSION)' - dnl # Override default lib directory on Debian/Ubuntu systems. The provided - dnl # /usr/lib/rpm/platform/<arch>/macros files do not specify the correct - dnl # path for multiarch systems as described by the packaging guidelines. + dnl # Override default lib directory on Debian/Ubuntu systems. The + dnl # provided /usr/lib/rpm/platform/<arch>/macros files do not + dnl # specify the correct path for multiarch systems as described + dnl # by the packaging guidelines. dnl # dnl # https://wiki.ubuntu.com/MultiarchSpec dnl # https://wiki.debian.org/Multiarch/Implementation diff --git a/contrib/pyzfs/Makefile.am b/contrib/pyzfs/Makefile.am index f27216a77..36290661f 100644 --- a/contrib/pyzfs/Makefile.am +++ b/contrib/pyzfs/Makefile.am @@ -27,7 +27,7 @@ install-exec-local: $(PYTHON) $(srcdir)/setup.py install \ --prefix $(prefix) \ --root $(DESTDIR)/ \ - --install-lib $(pythondir) \ + --install-lib $(pythonsitedir) \ --single-version-externally-managed \ --verbose diff --git a/contrib/pyzfs/libzfs_core/__init__.py b/contrib/pyzfs/libzfs_core/__init__.py index 6ad9fa129..a195b05f5 100644 --- a/contrib/pyzfs/libzfs_core/__init__.py +++ b/contrib/pyzfs/libzfs_core/__init__.py @@ -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, diff --git a/contrib/pyzfs/libzfs_core/_constants.py b/contrib/pyzfs/libzfs_core/_constants.py index 4e1af55d7..917feee01 100644 --- a/contrib/pyzfs/libzfs_core/_constants.py +++ b/contrib/pyzfs/libzfs_core/_constants.py @@ -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) diff --git a/contrib/pyzfs/libzfs_core/_error_translation.py b/contrib/pyzfs/libzfs_core/_error_translation.py index b9db026d7..b5f4bebce 100644 --- a/contrib/pyzfs/libzfs_core/_error_translation.py +++ b/contrib/pyzfs/libzfs_core/_error_translation.py @@ -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) @@ -727,7 +732,7 @@ def _pool_name(name): '@' separates a snapshot name from the rest of the dataset name. '#' separates a bookmark name from the rest of the dataset name. ''' - return re.split('[/@#]', name, 1)[0] + return re.split(b'[/@#]', name, 1)[0] def _fs_name(name): @@ -737,26 +742,26 @@ def _fs_name(name): '@' separates a snapshot name from the rest of the dataset name. '#' separates a bookmark name from the rest of the dataset name. ''' - return re.split('[@#]', name, 1)[0] + return re.split(b'[@#]', name, 1)[0] def _is_valid_name_component(component): - allowed = string.ascii_letters + string.digits + '-_.: ' - return component and all(x in allowed for x in component) + allowed = string.ascii_letters + string.digits + u'-_.: ' + return component and all(x in allowed.encode() for x in component) def _is_valid_fs_name(name): - return name and all(_is_valid_name_component(c) for c in name.split('/')) + return name and all(_is_valid_name_component(c) for c in name.split(b'/')) def _is_valid_snap_name(name): - parts = name.split('@') + parts = name.split(b'@') return (len(parts) == 2 and _is_valid_fs_name(parts[0]) and _is_valid_name_component(parts[1])) def _is_valid_bmark_name(name): - parts = name.split('#') + parts = name.split(b'#') return (len(parts) == 2 and _is_valid_fs_name(parts[0]) and _is_valid_name_component(parts[1])) diff --git a/contrib/pyzfs/libzfs_core/_libzfs_core.py b/contrib/pyzfs/libzfs_core/_libzfs_core.py index 157dc16e9..589926ba8 100644 --- a/contrib/pyzfs/libzfs_core/_libzfs_core.py +++ b/contrib/pyzfs/libzfs_core/_libzfs_core.py @@ -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 @@ -112,7 +113,7 @@ def lzc_create(name, ds_type='zfs', props=None, key=None): if props is None: props = {} if key is None: - key = bytes("") + key = b"" else: key = bytes(key) if ds_type == 'zfs': @@ -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): @@ -846,7 +848,7 @@ def lzc_change_key(fsname, crypt_cmd, props=None, key=None): if props is None: props = {} if key is None: - key = bytes("") + key = b"" else: key = bytes(key) cmd = { @@ -929,13 +931,13 @@ def lzc_channel_program( error. ''' output = {} - params_nv = nvlist_in({"argv": params}) + params_nv = nvlist_in({b"argv": params}) with nvlist_out(output) as outnvl: ret = _lib.lzc_channel_program( poolname, program, instrlimit, memlimit, params_nv, outnvl) errors.lzc_channel_program_translate_error( - ret, poolname, output.get("error")) - return output.get("return") + ret, poolname, output.get(b"error")) + return output.get(b"return") def lzc_channel_program_nosync( @@ -974,13 +976,13 @@ def lzc_channel_program_nosync( error. ''' output = {} - params_nv = nvlist_in({"argv": params}) + params_nv = nvlist_in({b"argv": params}) with nvlist_out(output) as outnvl: ret = _lib.lzc_channel_program_nosync( poolname, program, instrlimit, memlimit, params_nv, outnvl) errors.lzc_channel_program_translate_error( - ret, poolname, output.get("error")) - return output.get("return") + ret, poolname, output.get(b"error")) + return output.get(b"return") def lzc_receive_resumable( @@ -1404,7 +1406,7 @@ def lzc_receive_with_cmdprops( if cmdprops is None: cmdprops = {} if key is None: - key = bytes("") + key = b"" else: key = bytes(key) @@ -1509,7 +1511,7 @@ def lzc_sync(poolname, force=False): `innvl` has been replaced by the `force` boolean and `outnvl` has been conveniently removed since it's not used. ''' - innvl = nvlist_in({"force": force}) + innvl = nvlist_in({b"force": force}) with nvlist_out({}) as outnvl: ret = _lib.lzc_sync(poolname, innvl, outnvl) errors.lzc_sync_translate_error(ret, poolname) @@ -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 diff --git a/contrib/pyzfs/libzfs_core/_nvlist.py b/contrib/pyzfs/libzfs_core/_nvlist.py index 75c2e20f3..fe4239a3c 100644 --- a/contrib/pyzfs/libzfs_core/_nvlist.py +++ b/contrib/pyzfs/libzfs_core/_nvlist.py @@ -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 @@ -159,10 +160,10 @@ def _type_info(typeid): # only integer properties need to be here _prop_name_to_type_str = { - "rewind-request": "uint32", - "type": "uint32", - "N_MORE_ERRORS": "int32", - "pool_context": "int32", + b"rewind-request": "uint32", + b"type": "uint32", + b"N_MORE_ERRORS": "int32", + b"pool_context": "int32", } diff --git a/contrib/pyzfs/libzfs_core/bindings/__init__.py b/contrib/pyzfs/libzfs_core/bindings/__init__.py index f1b756208..4bdd9ea31 100644 --- a/contrib/pyzfs/libzfs_core/bindings/__init__.py +++ b/contrib/pyzfs/libzfs_core/bindings/__init__.py @@ -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) diff --git a/contrib/pyzfs/libzfs_core/bindings/libnvpair.py b/contrib/pyzfs/libzfs_core/bindings/libnvpair.py index 03cc75f7f..3cd72d490 100644 --- a/contrib/pyzfs/libzfs_core/bindings/libnvpair.py +++ b/contrib/pyzfs/libzfs_core/bindings/libnvpair.py @@ -17,6 +17,7 @@ """ Python bindings for ``libnvpair``. """ +from __future__ import absolute_import, division, print_function CDEF = """ typedef ... nvlist_t; diff --git a/contrib/pyzfs/libzfs_core/bindings/libzfs_core.py b/contrib/pyzfs/libzfs_core/bindings/libzfs_core.py index 658394a3f..ce2d9d62c 100644 --- a/contrib/pyzfs/libzfs_core/bindings/libzfs_core.py +++ b/contrib/pyzfs/libzfs_core/bindings/libzfs_core.py @@ -17,6 +17,7 @@ """ Python bindings for ``libzfs_core``. """ +from __future__ import absolute_import, division, print_function CDEF = """ diff --git a/contrib/pyzfs/libzfs_core/ctypes.py b/contrib/pyzfs/libzfs_core/ctypes.py index 8e6dfa622..d337f46ed 100644 --- a/contrib/pyzfs/libzfs_core/ctypes.py +++ b/contrib/pyzfs/libzfs_core/ctypes.py @@ -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 @@ -30,8 +31,8 @@ def _ffi_cast(type_name): try: type_info.elements[value] except KeyError as e: - raise OverflowError('Invalid enum <%s> value %s' % - (type_info.cname, e.message)) + raise OverflowError('Invalid enum <%s> value %s: %s' % + (type_info.cname, value, e)) else: _ffi.new(type_name + '*', value) return _ffi.cast(type_name, value) diff --git a/contrib/pyzfs/libzfs_core/exceptions.py b/contrib/pyzfs/libzfs_core/exceptions.py index d274b5b06..c54459ec8 100644 --- a/contrib/pyzfs/libzfs_core/exceptions.py +++ b/contrib/pyzfs/libzfs_core/exceptions.py @@ -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 ( diff --git a/contrib/pyzfs/libzfs_core/test/test_libzfs_core.py b/contrib/pyzfs/libzfs_core/test/test_libzfs_core.py index 14303871a..97fd36ce7 100644 --- a/contrib/pyzfs/libzfs_core/test/test_libzfs_core.py +++ b/contrib/pyzfs/libzfs_core/test/test_libzfs_core.py @@ -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 @@ -32,6 +33,7 @@ import resource import shutil import stat import subprocess +import sys import tempfile import time import uuid @@ -44,8 +46,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 +78,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) @@ -167,7 +169,7 @@ def temp_file_in_fs(fs): 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 @@ -176,7 +178,7 @@ def make_snapshots(fs, before, modified, after): 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 @@ -205,16 +207,16 @@ def streams(fs, first, second): @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) @@ -272,7 +274,7 @@ def needs_support(function): 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 @@ -322,17 +324,17 @@ class ZFSTest(unittest.TestCase): 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) @@ -343,14 +345,14 @@ class ZFSTest(unittest.TestCase): 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') @@ -358,15 +360,15 @@ class ZFSTest(unittest.TestCase): # 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) @@ -374,83 +376,83 @@ class ZFSTest(unittest.TestCase): 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.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"), b"aes-256-ccm") + self.assertEqual(fs.getProperty("encryptionroot"), name) + 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) @@ -460,108 +462,108 @@ class ZFSTest(unittest.TestCase): 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.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) 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: 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) 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: 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) 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: 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) 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: 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) 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: 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) 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: 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) 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) @@ -569,27 +571,27 @@ 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) 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: 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) 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) @@ -597,8 +599,8 @@ class ZFSTest(unittest.TestCase): 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) @@ -611,9 +613,9 @@ class ZFSTest(unittest.TestCase): 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] @@ -628,9 +630,9 @@ class ZFSTest(unittest.TestCase): 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] @@ -654,30 +656,30 @@ class ZFSTest(unittest.TestCase): 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: 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) 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: 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. @@ -687,62 +689,62 @@ class ZFSTest(unittest.TestCase): 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: 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) 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: 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) 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: 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) 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) @@ -750,24 +752,24 @@ class ZFSTest(unittest.TestCase): # 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): @@ -776,9 +778,9 @@ class ZFSTest(unittest.TestCase): 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: @@ -802,8 +804,8 @@ class ZFSTest(unittest.TestCase): # 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]) @@ -811,8 +813,8 @@ class ZFSTest(unittest.TestCase): 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 @@ -822,8 +824,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -832,8 +834,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -844,8 +846,8 @@ class ZFSTest(unittest.TestCase): 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) @@ -854,16 +856,16 @@ class ZFSTest(unittest.TestCase): 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]) @@ -872,8 +874,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -882,8 +884,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -892,8 +894,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -903,9 +905,9 @@ class ZFSTest(unittest.TestCase): 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) @@ -914,16 +916,16 @@ 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: 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) @@ -935,17 +937,17 @@ class ZFSTest(unittest.TestCase): 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]) @@ -953,31 +955,31 @@ class ZFSTest(unittest.TestCase): 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): @@ -990,28 +992,28 @@ class ZFSTest(unittest.TestCase): 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) @@ -1020,9 +1022,9 @@ class ZFSTest(unittest.TestCase): @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) @@ -1035,8 +1037,8 @@ class ZFSTest(unittest.TestCase): @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) @@ -1048,8 +1050,8 @@ class ZFSTest(unittest.TestCase): @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) @@ -1061,8 +1063,8 @@ class ZFSTest(unittest.TestCase): @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) @@ -1074,8 +1076,8 @@ class ZFSTest(unittest.TestCase): @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) @@ -1087,8 +1089,8 @@ class ZFSTest(unittest.TestCase): @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) @@ -1101,9 +1103,9 @@ class ZFSTest(unittest.TestCase): @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) @@ -1116,9 +1118,9 @@ class ZFSTest(unittest.TestCase): @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) @@ -1131,9 +1133,9 @@ class ZFSTest(unittest.TestCase): @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]) @@ -1147,9 +1149,9 @@ class ZFSTest(unittest.TestCase): @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]) @@ -1162,9 +1164,9 @@ class ZFSTest(unittest.TestCase): @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: @@ -1175,9 +1177,9 @@ class ZFSTest(unittest.TestCase): @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]) @@ -1185,9 +1187,9 @@ class ZFSTest(unittest.TestCase): @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} @@ -1197,9 +1199,9 @@ class ZFSTest(unittest.TestCase): @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} @@ -1214,11 +1216,11 @@ class ZFSTest(unittest.TestCase): @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} @@ -1228,61 +1230,61 @@ class ZFSTest(unittest.TestCase): lzc.lzc_bookmark(bmark_dict2) lzc.lzc_destroy_snaps([snap1, snap2], defer=False) - bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName('fs1')) - self.assertEquals(len(bmarks), 3) - for b in 'bmark', 'bmark1', 'bmark2': + bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName(b'fs1')) + self.assertEqual(len(bmarks), 3) + for b in b'bmark', b'bmark1', b'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) - for b in 'bmark', 'bmark1', 'bmark2': + bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName(b'fs1'), + [b'guid', b'createtxg', b'creation']) + self.assertEqual(len(bmarks), 3) + for b in b'bmark', b'bmark1', b'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): - 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']) - self.assertEquals(len(bmarks), 1) - for b in ('bmark', ): + ZFSTest.pool.makeName(b'fs1'), [b'badprop']) + self.assertEqual(len(bmarks), 1) + for b in (b'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): 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')) - self.assertEquals(len(bmarks), 0) + [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]) @@ -1290,48 +1292,49 @@ class ZFSTest(unittest.TestCase): 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')) - self.assertEquals(len(bmarks), 1) - self.assertIn('bmark', bmarks) + bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName(b'fs1')) + self.assertEqual(len(bmarks), 1) + 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]) 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") - 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]) @@ -1344,22 +1347,22 @@ class ZFSTest(unittest.TestCase): 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]) 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") - 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]) @@ -1368,8 +1371,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -1378,8 +1381,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -1388,22 +1391,22 @@ class ZFSTest(unittest.TestCase): 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]) 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") - 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]) @@ -1411,8 +1414,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -1422,8 +1425,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -1433,37 +1436,37 @@ class ZFSTest(unittest.TestCase): 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]) 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") - 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]) @@ -1481,17 +1484,17 @@ 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") + 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]) @@ -1500,8 +1503,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -1510,8 +1513,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -1520,42 +1523,42 @@ class ZFSTest(unittest.TestCase): 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]) 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") - 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]) 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") - snap2 = ZFSTest.pool.makeName("fs1") + snap1 = ZFSTest.pool.makeName(b"fs1@snap1") + snap2 = ZFSTest.pool.makeName(b"fs1") lzc.lzc_snapshot([snap1]) @@ -1567,8 +1570,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -1578,12 +1581,12 @@ class ZFSTest(unittest.TestCase): 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]) @@ -1594,17 +1597,17 @@ 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") - 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]) @@ -1615,11 +1618,11 @@ 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'] - snap = ZFSTest.pool.makeName("fs1@snap") + snap = ZFSTest.pool.makeName(b"fs1@snap") lzc.lzc_snapshot([snap]) for c in range(len(flags)): @@ -1628,14 +1631,14 @@ class ZFSTest(unittest.TestCase): 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() @@ -1643,8 +1646,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -1655,8 +1658,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -1667,8 +1670,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -1679,8 +1682,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -1688,19 +1691,19 @@ 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") - 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]) @@ -1708,21 +1711,21 @@ 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 # 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]) @@ -1732,8 +1735,8 @@ class ZFSTest(unittest.TestCase): 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]) @@ -1744,9 +1747,9 @@ class ZFSTest(unittest.TestCase): @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]) @@ -1762,9 +1765,9 @@ class ZFSTest(unittest.TestCase): @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]) @@ -1776,7 +1779,7 @@ class ZFSTest(unittest.TestCase): 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: @@ -1784,18 +1787,18 @@ 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") + snap = ZFSTest.pool.makeName(b"fs1@snap") lzc.lzc_snapshot([snap]) 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") + snap = ZFSTest.pool.makeName(b"fs1@snap") lzc.lzc_snapshot([snap]) with tempfile.TemporaryFile() as tmp: @@ -1805,35 +1808,49 @@ 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") + 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.assertEquals(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( @@ -1845,13 +1862,13 @@ 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") - 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: @@ -1866,13 +1883,13 @@ class ZFSTest(unittest.TestCase): 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: @@ -1895,12 +1912,12 @@ class ZFSTest(unittest.TestCase): # 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()) @@ -1909,11 +1926,11 @@ class ZFSTest(unittest.TestCase): 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: @@ -1929,11 +1946,11 @@ class ZFSTest(unittest.TestCase): 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: @@ -1946,11 +1963,11 @@ class ZFSTest(unittest.TestCase): 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()) @@ -1959,19 +1976,19 @@ class ZFSTest(unittest.TestCase): 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): @@ -1983,14 +2000,14 @@ class ZFSTest(unittest.TestCase): 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) @@ -1999,11 +2016,11 @@ class ZFSTest(unittest.TestCase): 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]) @@ -2014,10 +2031,10 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2026,19 +2043,19 @@ class ZFSTest(unittest.TestCase): 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') - self.assertEquals(origin, origin1) + 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 with self.assertRaises(( @@ -2047,11 +2064,11 @@ class ZFSTest(unittest.TestCase): 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, _)): @@ -2071,12 +2088,12 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2084,12 +2101,12 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2098,12 +2115,12 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2112,13 +2129,13 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2126,13 +2143,13 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2142,13 +2159,13 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2159,16 +2176,16 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2178,13 +2195,13 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2194,11 +2211,11 @@ class ZFSTest(unittest.TestCase): 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) @@ -2206,32 +2223,32 @@ class ZFSTest(unittest.TestCase): 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: @@ -2248,11 +2265,11 @@ class ZFSTest(unittest.TestCase): 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: @@ -2268,15 +2285,15 @@ class ZFSTest(unittest.TestCase): 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: @@ -2295,12 +2312,12 @@ class ZFSTest(unittest.TestCase): 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: @@ -2318,11 +2335,11 @@ class ZFSTest(unittest.TestCase): 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) @@ -2335,11 +2352,11 @@ class ZFSTest(unittest.TestCase): 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) @@ -2350,7 +2367,7 @@ class ZFSTest(unittest.TestCase): 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. @@ -2362,17 +2379,17 @@ class ZFSTest(unittest.TestCase): # 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()) @@ -2380,11 +2397,11 @@ class ZFSTest(unittest.TestCase): 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) @@ -2399,10 +2416,10 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2411,12 +2428,12 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2425,19 +2442,19 @@ class ZFSTest(unittest.TestCase): 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. @@ -2446,13 +2463,13 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2465,12 +2482,12 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2481,13 +2498,13 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2495,7 +2512,7 @@ class ZFSTest(unittest.TestCase): 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) @@ -2503,14 +2520,14 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2525,13 +2542,13 @@ class ZFSTest(unittest.TestCase): 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()) @@ -2546,10 +2563,10 @@ class ZFSTest(unittest.TestCase): 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: @@ -2558,9 +2575,9 @@ class ZFSTest(unittest.TestCase): (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: @@ -2569,42 +2586,42 @@ class ZFSTest(unittest.TestCase): 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]) @@ -2618,20 +2635,27 @@ class ZFSTest(unittest.TestCase): # 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) @@ -2639,9 +2663,9 @@ class ZFSTest(unittest.TestCase): 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() @@ -2651,10 +2675,10 @@ class ZFSTest(unittest.TestCase): 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]) @@ -2668,19 +2692,26 @@ class ZFSTest(unittest.TestCase): # 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) @@ -2688,26 +2719,26 @@ class ZFSTest(unittest.TestCase): 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: @@ -2717,8 +2748,8 @@ class ZFSTest(unittest.TestCase): 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: @@ -2730,12 +2761,12 @@ class ZFSTest(unittest.TestCase): 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]) @@ -2745,16 +2776,16 @@ 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"), 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]) @@ -2766,19 +2797,19 @@ 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"), b"off") for e in ctx.exception.errors: self.assertIsInstance(e, lzc_exc.PropertyInvalid) - self.assertEquals(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]) @@ -2790,22 +2821,22 @@ 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"), 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]) @@ -2817,27 +2848,27 @@ 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), 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) @@ -2849,19 +2880,19 @@ class ZFSTest(unittest.TestCase): 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) @@ -2873,20 +2904,20 @@ class ZFSTest(unittest.TestCase): 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) @@ -2897,8 +2928,8 @@ class ZFSTest(unittest.TestCase): 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): @@ -2906,12 +2937,12 @@ class ZFSTest(unittest.TestCase): @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) @@ -2921,11 +2952,11 @@ class ZFSTest(unittest.TestCase): @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]) @@ -2938,7 +2969,7 @@ class ZFSTest(unittest.TestCase): @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) @@ -2951,7 +2982,7 @@ class ZFSTest(unittest.TestCase): 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): @@ -2959,7 +2990,7 @@ class ZFSTest(unittest.TestCase): 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): @@ -2969,7 +3000,7 @@ class ZFSTest(unittest.TestCase): (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): @@ -2979,14 +3010,14 @@ class ZFSTest(unittest.TestCase): 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: @@ -3000,7 +3031,7 @@ class ZFSTest(unittest.TestCase): 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) @@ -3018,8 +3049,8 @@ class ZFSTest(unittest.TestCase): 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() @@ -3028,7 +3059,7 @@ class ZFSTest(unittest.TestCase): 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() @@ -3036,7 +3067,7 @@ class ZFSTest(unittest.TestCase): 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) @@ -3045,7 +3076,7 @@ class ZFSTest(unittest.TestCase): 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])) @@ -3058,8 +3089,8 @@ class ZFSTest(unittest.TestCase): ZFSTest.pool.getRoot().getFilesystem() snap = ZFSTest.pool.getRoot().getFilesystem().getSnap() - snaps = lzc.lzc_hold({snap: 'tag'}) - self.assertEquals([snap], snaps) + snaps = lzc.lzc_hold({snap: b'tag'}) + self.assertEqual([snap], snaps) def test_hold_missing_fs_auto_cleanup(self): # XXX skip pre-created filesystems @@ -3071,17 +3102,17 @@ class ZFSTest(unittest.TestCase): snap = ZFSTest.pool.getRoot().getFilesystem().getSnap() with cleanup_fd() as fd: - snaps = lzc.lzc_hold({snap: 'tag'}, fd) - self.assertEquals([snap], snaps) + snaps = lzc.lzc_hold({snap: b'tag'}, fd) + self.assertEqual([snap], snaps) def test_hold_duplicate(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) 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) @@ -3093,13 +3124,13 @@ class ZFSTest(unittest.TestCase): 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: @@ -3107,7 +3138,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. @@ -3116,62 +3147,62 @@ class ZFSTest(unittest.TestCase): 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.assertEquals(e.name, snap) + self.assertEqual(e.name, snap) def test_hold_too_long_snap_name_2(self): 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.assertEquals(e.name, snap) + 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.assertEquals(e.name, snap) + self.assertEqual(e.name, snap) def test_hold_invalid_snap_name_2(self): 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.assertEquals(e.name, snap) + self.assertEqual(e.name, snap) def test_get_holds(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.assertEquals(len(holds), 2) - self.assertIn('tag1', holds) - self.assertIn('tag2', holds) - self.assertIsInstance(holds['tag1'], (int, long)) + self.assertEqual(len(holds), 2) + 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.assertEquals(len(holds), 0) + self.assertEqual(len(holds), 0) self.assertIsInstance(holds, dict) def test_get_holds_nonexistent_snap(self): @@ -3190,7 +3221,7 @@ class ZFSTest(unittest.TestCase): 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) @@ -3206,13 +3237,13 @@ class ZFSTest(unittest.TestCase): snap = ZFSTest.pool.getRoot().getSnap() lzc.lzc_snapshot([snap]) - lzc.lzc_hold({snap: 'tag'}) - ret = lzc.lzc_release({snap: ['tag']}) - self.assertEquals(len(ret), 0) + lzc.lzc_hold({snap: b'tag'}) + ret = lzc.lzc_release({snap: [b'tag']}) + 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() @@ -3221,63 +3252,63 @@ class ZFSTest(unittest.TestCase): 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.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'], - snap2: ['tag'], - snap3: ['tag2'], + snap1: [b'tag1', b'tag2'], + snap2: [b'tag'], + snap3: [b'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) + ret = lzc.lzc_release({snap3: [b'tag1']}) + 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() lzc.lzc_snapshot([snap]) with cleanup_fd() as fd: - lzc.lzc_hold({snap: 'tag'}, fd) - ret = lzc.lzc_release({snap: ['tag']}) - self.assertEquals(len(ret), 0) + 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): 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) 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): @@ -3285,7 +3316,7 @@ class ZFSTest(unittest.TestCase): 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) @@ -3293,30 +3324,30 @@ class ZFSTest(unittest.TestCase): 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']}) - self.assertEquals(len(ret), 1) - self.assertEquals(ret[0], snap + '#tag') + ret = lzc.lzc_release({snap: [b'tag']}) + self.assertEqual(len(ret), 1) + 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']}) - self.assertEquals(len(ret), 1) - self.assertEquals(ret[0], snap) + 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']}) - self.assertEquals(len(ret), 1) - self.assertEquals(ret[0], snap) + ret = lzc.lzc_release({snap: [b'tag', b'another']}) + self.assertEqual(len(ret), 1) + self.assertEqual(ret[0], snap) def test_release_hold_across_pools(self): snap1 = ZFSTest.pool.getRoot().getSnap() @@ -3325,10 +3356,10 @@ class ZFSTest(unittest.TestCase): 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) @@ -3337,7 +3368,7 @@ class ZFSTest(unittest.TestCase): @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): @@ -3350,34 +3381,34 @@ class ZFSTest(unittest.TestCase): 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.assertEquals(e.name, snap) + 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.assertEquals(e.name, snap) + 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.assertEquals(e.name, snap) + 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) @@ -3386,7 +3417,7 @@ class ZFSTest(unittest.TestCase): 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) @@ -3395,15 +3426,15 @@ class ZFSTest(unittest.TestCase): 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): @@ -3411,9 +3442,9 @@ end 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): @@ -3421,7 +3452,7 @@ end def test_channel_program_invalid_limits(self): pool = ZFSTest.pool.getRoot().getName() - zcp = """ + zcp = b""" return {} """ with self.assertRaises(lzc_exc.ZCPLimitInvalid): @@ -3431,18 +3462,18 @@ return {} 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) @@ -3452,38 +3483,38 @@ zfs.sync.snapshot('""" + 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): @@ -3492,13 +3523,13 @@ zfs.sync.snapshot('""" + pool + """@zcp') 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, _): @@ -3524,7 +3555,7 @@ zfs.sync.snapshot('""" + pool + """@zcp') 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)) @@ -3534,7 +3565,7 @@ zfs.sync.snapshot('""" + pool + """@zcp') 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) @@ -3552,14 +3583,14 @@ zfs.sync.snapshot('""" + pool + """@zcp') 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): @@ -3572,7 +3603,7 @@ zfs.sync.snapshot('""" + pool + """@zcp') lzc.lzc_remap(name) def test_remap(self): - name = ZFSTest.pool.makeName("fs1") + name = ZFSTest.pool.makeName(b"fs1") lzc.lzc_remap(name) @@ -3582,7 +3613,7 @@ zfs.sync.snapshot('""" + pool + """@zcp') 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) @@ -3601,7 +3632,7 @@ zfs.sync.snapshot('""" + pool + """@zcp') 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) @@ -3614,12 +3645,12 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3630,14 +3661,14 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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)) @@ -3645,12 +3676,12 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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]) @@ -3661,14 +3692,14 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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)) @@ -3676,8 +3707,8 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3685,10 +3716,10 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3699,9 +3730,9 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3709,7 +3740,7 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3721,9 +3752,9 @@ zfs.sync.snapshot('""" + pool + """@zcp') 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) @@ -3740,9 +3771,9 @@ zfs.sync.snapshot('""" + pool + """@zcp') 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) @@ -3760,9 +3791,9 @@ zfs.sync.snapshot('""" + pool + """@zcp') 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) @@ -3771,14 +3802,14 @@ zfs.sync.snapshot('""" + pool + """@zcp') # 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]) @@ -3790,8 +3821,8 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3800,16 +3831,16 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3818,8 +3849,8 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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): @@ -3827,7 +3858,7 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3835,18 +3866,18 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3856,8 +3887,8 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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"} @@ -3869,9 +3900,9 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3880,9 +3911,9 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3891,11 +3922,11 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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}) @@ -3909,9 +3940,9 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3920,9 +3951,9 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3931,17 +3962,17 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3951,8 +3982,8 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3961,8 +3992,8 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3971,8 +4002,8 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3981,8 +4012,8 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -3991,8 +4022,8 @@ zfs.sync.snapshot('""" + pool + """@zcp') @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) @@ -4003,8 +4034,8 @@ zfs.sync.snapshot('""" + pool + """@zcp') 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" @@ -4015,7 +4046,11 @@ class _TempPool(object): 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-') @@ -4059,10 +4094,10 @@ class _TempPool(object): 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 + print('command failed: ', e.output) raise except Exception: self.cleanUp() @@ -4103,12 +4138,12 @@ class _TempPool(object): 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 else: - print 'command failed: ', e.output + print('command failed: ', e.output) raise for fs in self._filesystems: lzc.lzc_create(self.makeName(fs)) @@ -4138,22 +4173,22 @@ class _TempPool(object): 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: @@ -4164,7 +4199,7 @@ class _TempPool(object): 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( @@ -4176,7 +4211,7 @@ class _TempPool(object): 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): @@ -4196,7 +4231,7 @@ 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 @@ -4211,14 +4246,14 @@ class _Filesystem(object): 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 @@ -4226,23 +4261,23 @@ class _Filesystem(object): 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: diff --git a/contrib/pyzfs/libzfs_core/test/test_nvlist.py b/contrib/pyzfs/libzfs_core/test/test_nvlist.py index 7dab17853..c3c61142d 100644 --- a/contrib/pyzfs/libzfs_core/test/test_nvlist.py +++ b/contrib/pyzfs/libzfs_core/test/test_nvlist.py @@ -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 @@ -43,25 +44,25 @@ class TestNVList(unittest.TestCase): 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): @@ -69,564 +70,564 @@ class TestNVList(unittest.TestCase): 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) diff --git a/contrib/pyzfs/setup.py b/contrib/pyzfs/setup.py index 3baa25c1b..3ff6c04c6 100644 --- a/contrib/pyzfs/setup.py +++ b/contrib/pyzfs/setup.py @@ -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 @@ -28,8 +29,13 @@ setup( "Development Status :: 4 - Beta", "Intended Audience :: Developers", "License :: OSI Approved :: Apache Software License", - "Programming Language :: Python :: 2 :: Only", + "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.7", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.4", + "Programming Language :: Python :: 3.5", + "Programming Language :: Python :: 3.6", + "Programming Language :: Python :: 3.7", "Topic :: System :: Filesystems", "Topic :: Software Development :: Libraries", ], @@ -47,7 +53,7 @@ setup( setup_requires=[ "cffi", ], - python_requires='>=2.7,<3', + python_requires='>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,<4', zip_safe=False, test_suite="libzfs_core.test", ) diff --git a/rpm/generic/zfs.spec.in b/rpm/generic/zfs.spec.in index 55edbc83f..533792989 100644 --- a/rpm/generic/zfs.spec.in +++ b/rpm/generic/zfs.spec.in @@ -53,16 +53,6 @@ %bcond_with asan %bcond_with systemd -# Python permits the !/usr/bin/python shebang for scripts that are cross -# compatible between python2 and python3, but Fedora 28 does not. Fedora -# wants us to choose python3 for cross-compatible scripts. Since we want -# to support python2 and python3 users, exclude our scripts from Fedora 28's -# RPM build check, so that we don't get a bunch of build warnings. -# -# Details: https://github.com/zfsonlinux/zfs/issues/7360 -# -%global __brp_mangle_shebangs_exclude_from arc_summary.py|arcstat.py|dbufstat.py|test-runner.py|zts-report.py - # Generic enable switch for systemd %if %{with systemd} %define _systemd 1 @@ -85,6 +75,32 @@ %define _systemd 1 %endif +# When not specified default to distribution provided version. This +# is normally Python 3, but for RHEL <= 7 only Python 2 is provided. +%if %{undefined __use_python} +%if 0%{?rhel} && 0%{?rhel} <= 7 +%define __python /usr/bin/python2 +%define __python_pkg_version 2 +%define __python_cffi_pkg python-cffi +%else +%define __python /usr/bin/python3 +%define __python_pkg_version 3 +%define __python_cffi_pkg python3-cffi +%endif +%else +%define __python %{__use_python} +%define __python_pkg_version %{__use_python_pkg_version} +%define __python_cffi_pkg python%{__python_pkg_version}-cffi +%endif + +# By default python-pyzfs is enabled, with the exception of +# RHEL 6 which by default uses Python 2.6 which is too old. +%if 0%{?rhel} == 6 +%bcond_with pyzfs +%else +%bcond_without pyzfs +%endif + Name: @PACKAGE@ Version: @VERSION@ Release: @RELEASE@%{?dist} @@ -135,7 +151,7 @@ Requires: util-linux Requires: sysstat %description -This package contains the ZFS command line utilities. +This package contains the core ZFS command line utilities. %package -n libzpool2 Summary: Native ZFS pool library for Linux @@ -219,6 +235,7 @@ Requires: acl Requires: sudo Requires: sysstat Requires: libaio +Requires: python%{__python_pkg_version} %if 0%{?rhel}%{?fedora}%{?suse_version} BuildRequires: libaio-devel %endif @@ -240,23 +257,23 @@ Requires: grep This package contains a dracut module used to construct an initramfs image which is ZFS aware. -%if 0%{?_pyzfs} -%package -n pyzfs -Summary: Python wrapper for libzfs_core +%if %{with pyzfs} +%package -n python%{__python_pkg_version}-pyzfs +Summary: Python %{python_version} wrapper for libzfs_core Group: Development/Languages/Python License: Apache-2.0 BuildArch: noarch Requires: libzfs2 = %{version} Requires: libnvpair1 = %{version} Requires: libffi -Requires: python >= 2.7 -Requires: python-cffi +Requires: python%{__python_pkg_version} +Requires: %{__python_cffi_pkg} %if 0%{?rhel}%{?fedora}%{?suse_version} -BuildRequires: python-devel +BuildRequires: python%{__python_pkg_version}-devel BuildRequires: libffi-devel %endif -%description -n pyzfs +%description -n python%{__python_pkg_version}-pyzfs This package provides a python wrapper for the libzfs_core C library. %endif @@ -299,6 +316,12 @@ image which is ZFS aware. %define systemd --enable-sysvinit --disable-systemd %endif +%if %{with pyzfs} + %define pyzfs --enable-pyzfs +%else + %define pyzfs --disable-pyzfs +%endif + %setup -q %build @@ -307,11 +330,13 @@ image which is ZFS aware. --with-udevdir=%{_udevdir} \ --with-udevruledir=%{_udevruledir} \ --with-dracutdir=%{_dracutdir} \ + --with-python=%{__python} \ --disable-static \ %{debug} \ %{debuginfo} \ %{asan} \ - %{systemd} + %{systemd}\ + %{pyzfs} make %{?_smp_mflags} %install @@ -379,12 +404,20 @@ systemctl --system daemon-reload >/dev/null || true %endif %files +# Core utilities %{_sbindir}/* -%{_bindir}/* -%{_libexecdir}/%{name} +%{_bindir}/raidz_test +%{_bindir}/zgenhostid +# Optional Python 2/3 scripts +%{_bindir}/arc_summary +%{_bindir}/arcstat +%{_bindir}/dbufstat +# Man pages %{_mandir}/man1/* %{_mandir}/man5/* %{_mandir}/man8/* +# Configuration files and scripts +%{_libexecdir}/%{name} %{_udevdir}/vdev_id %{_udevdir}/zvol_id %{_udevdir}/rules.d/* @@ -426,8 +459,8 @@ systemctl --system daemon-reload >/dev/null || true %doc contrib/dracut/README.dracut.markdown %{_dracutdir}/modules.d/* -%if 0%{?_pyzfs} -%files -n pyzfs +%if %{with pyzfs} +%files -n python%{__python_pkg_version}-pyzfs %doc contrib/pyzfs/README %doc contrib/pyzfs/LICENSE %defattr(-,root,root,-) diff --git a/scripts/zfs-tests.sh b/scripts/zfs-tests.sh index cc80909ff..f00a28484 100755 --- a/scripts/zfs-tests.sh +++ b/scripts/zfs-tests.sh @@ -247,6 +247,10 @@ constrain_path() { ln -fs "$STF_PATH/gunzip" "$STF_PATH/uncompress" ln -fs "$STF_PATH/exportfs" "$STF_PATH/share" ln -fs "$STF_PATH/exportfs" "$STF_PATH/unshare" + + if [ -L "$STF_PATH/arc_summary3" ]; then + ln -fs "$STF_PATH/arc_summary3" "$STF_PATH/arc_summary" + fi } # diff --git a/tests/runfiles/linux.run b/tests/runfiles/linux.run index f33a91649..4463bfa1e 100644 --- a/tests/runfiles/linux.run +++ b/tests/runfiles/linux.run @@ -477,8 +477,7 @@ tests = ['zdb_001_neg', 'zfs_001_neg', 'zfs_allow_001_neg', 'zpool_offline_001_neg', 'zpool_online_001_neg', 'zpool_remove_001_neg', 'zpool_replace_001_neg', 'zpool_scrub_001_neg', 'zpool_set_001_neg', 'zpool_status_001_neg', 'zpool_upgrade_001_neg', 'arcstat_001_pos', - 'arc_summary_001_pos', 'arc_summary_002_neg', - 'arc_summary3_001_pos', 'dbufstat_001_pos'] + 'arc_summary_001_pos', 'arc_summary_002_neg', 'dbufstat_001_pos'] user = tags = ['functional', 'cli_user', 'misc'] diff --git a/tests/test-runner/bin/Makefile.am b/tests/test-runner/bin/Makefile.am index e843e4e09..30c564e55 100644 --- a/tests/test-runner/bin/Makefile.am +++ b/tests/test-runner/bin/Makefile.am @@ -2,3 +2,14 @@ pkgdatadir = $(datadir)/@PACKAGE@/test-runner/bin dist_pkgdata_SCRIPTS = \ test-runner.py \ zts-report.py +# +# These scripts are compatibile with both Python 2.6 and 3.4. As such the +# python 3 shebang can be replaced at install time when targeting a python +# 2 system. This allows us to maintain a single version of the source. +# +if USING_PYTHON_2 +install-data-hook: + sed --in-place 's|^#!/usr/bin/python3|#!/usr/bin/python2|' \ + $(DESTDIR)$(pkgdatadir)/test-runner.py \ + $(DESTDIR)$(pkgdatadir)/zts-report.py +endif diff --git a/tests/test-runner/bin/test-runner.py b/tests/test-runner/bin/test-runner.py index 7ef8a87ed..f353f9d72 100755 --- a/tests/test-runner/bin/test-runner.py +++ b/tests/test-runner/bin/test-runner.py @@ -12,9 +12,11 @@ # # -# Copyright (c) 2012, 2015 by Delphix. All rights reserved. +# Copyright (c) 2012, 2018 by Delphix. All rights reserved. # Copyright (c) 2017 Datto Inc. # +# This script must remain compatible with Python 2.6+ and Python 3.4+. +# # some python 2.7 system don't have a configparser shim try: @@ -23,7 +25,8 @@ except ImportError: import ConfigParser as configparser import os -import logging +import sys + from datetime import datetime from optparse import OptionParser from pwd import getpwnam @@ -31,8 +34,6 @@ from pwd import getpwuid from select import select from subprocess import PIPE from subprocess import Popen -from sys import argv -from sys import maxsize from threading import Timer from time import time @@ -41,6 +42,10 @@ TESTDIR = '/usr/share/zfs/' KILL = 'kill' TRUE = 'true' SUDO = 'sudo' +LOG_FILE = 'LOG_FILE' +LOG_OUT = 'LOG_OUT' +LOG_ERR = 'LOG_ERR' +LOG_FILE_OBJ = None class Result(object): @@ -84,7 +89,7 @@ class Output(object): """ def __init__(self, stream): self.stream = stream - self._buf = '' + self._buf = b'' self.lines = [] def fileno(self): @@ -109,15 +114,15 @@ class Output(object): buf = os.read(fd, 4096) if not buf: return None - if '\n' not in buf: + if b'\n' not in buf: self._buf += buf return [] buf = self._buf + buf - tmp, rest = buf.rsplit('\n', 1) + tmp, rest = buf.rsplit(b'\n', 1) self._buf = rest now = datetime.now() - rows = tmp.split('\n') + rows = tmp.split(b'\n') self.lines += [(now, r) for r in rows] @@ -225,7 +230,7 @@ class Cmd(object): proc = Popen(privcmd, stdout=PIPE, stderr=PIPE) # Allow a special timeout value of 0 to mean infinity if int(self.timeout) == 0: - self.timeout = maxsize + self.timeout = sys.maxsize t = Timer(int(self.timeout), self.kill_cmd, [proc]) try: @@ -252,50 +257,52 @@ class Cmd(object): self.result.runtime = '%02d:%02d' % (m, s) self.result.result = 'SKIP' - def log(self, logger, options): + def log(self, options): """ This function is responsible for writing all output. This includes the console output, the logfile of all results (with timestamped merged stdout and stderr), and for each test, the unmodified stdout/stderr/merged in it's own file. """ - if logger is None: - return logname = getpwuid(os.getuid()).pw_name user = ' (run as %s)' % (self.user if len(self.user) else logname) msga = 'Test: %s%s ' % (self.pathname, user) - msgb = '[%s] [%s]' % (self.result.runtime, self.result.result) + msgb = '[%s] [%s]\n' % (self.result.runtime, self.result.result) pad = ' ' * (80 - (len(msga) + len(msgb))) + result_line = msga + pad + msgb - # If -q is specified, only print a line for tests that didn't pass. - # This means passing tests need to be logged as DEBUG, or the one - # line summary will only be printed in the logfile for failures. + # The result line is always written to the log file. If -q was + # specified only failures are written to the console, otherwise + # the result line is written to the console. + write_log(bytearray(result_line, encoding='utf-8'), LOG_FILE) if not options.quiet: - logger.info('%s%s%s' % (msga, pad, msgb)) - elif self.result.result is not 'PASS': - logger.info('%s%s%s' % (msga, pad, msgb)) - else: - logger.debug('%s%s%s' % (msga, pad, msgb)) + write_log(result_line, LOG_OUT) + elif options.quiet and self.result.result is not 'PASS': + write_log(result_line, LOG_OUT) lines = sorted(self.result.stdout + self.result.stderr, key=lambda x: x[0]) + # Write timestamped output (stdout and stderr) to the logfile for dt, line in lines: - logger.debug('%s %s' % (dt.strftime("%H:%M:%S.%f ")[:11], line)) + timestamp = bytearray(dt.strftime("%H:%M:%S.%f ")[:11], + encoding='utf-8') + write_log(b'%s %s\n' % (timestamp, line), LOG_FILE) + # Write the separate stdout/stderr/merged files, if the data exists if len(self.result.stdout): - with open(os.path.join(self.outputdir, 'stdout'), 'w') as out: + with open(os.path.join(self.outputdir, 'stdout'), 'wb') as out: for _, line in self.result.stdout: - os.write(out.fileno(), '%s\n' % line) + os.write(out.fileno(), b'%s\n' % line) if len(self.result.stderr): - with open(os.path.join(self.outputdir, 'stderr'), 'w') as err: + with open(os.path.join(self.outputdir, 'stderr'), 'wb') as err: for _, line in self.result.stderr: - os.write(err.fileno(), '%s\n' % line) + os.write(err.fileno(), b'%s\n' % line) if len(self.result.stdout) and len(self.result.stderr): - with open(os.path.join(self.outputdir, 'merged'), 'w') as merged: + with open(os.path.join(self.outputdir, 'merged'), 'wb') as merged: for _, line in lines: - os.write(merged.fileno(), '%s\n' % line) + os.write(merged.fileno(), b'%s\n' % line) class Test(Cmd): @@ -323,7 +330,7 @@ class Test(Cmd): (self.pathname, self.outputdir, self.timeout, self.pre, pre_user, self.post, post_user, self.user, self.tags) - def verify(self, logger): + def verify(self): """ Check the pre/post scripts, user and Test. Omit the Test from this run if there are any problems. @@ -333,19 +340,19 @@ class Test(Cmd): for f in [f for f in files if len(f)]: if not verify_file(f): - logger.info("Warning: Test '%s' not added to this run because" - " it failed verification." % f) + write_log("Warning: Test '%s' not added to this run because" + " it failed verification.\n" % f, LOG_ERR) return False for user in [user for user in users if len(user)]: - if not verify_user(user, logger): - logger.info("Not adding Test '%s' to this run." % - self.pathname) + if not verify_user(user): + write_log("Not adding Test '%s' to this run.\n" % + self.pathname, LOG_ERR) return False return True - def run(self, logger, options): + def run(self, options): """ Create Cmd instances for the pre/post scripts. If the pre script doesn't pass, skip this Test. Run the post script regardless. @@ -363,18 +370,18 @@ class Test(Cmd): if len(pretest.pathname): pretest.run(options) cont = pretest.result.result is 'PASS' - pretest.log(logger, options) + pretest.log(options) if cont: test.run(options) else: test.skip() - test.log(logger, options) + test.log(options) if len(posttest.pathname): posttest.run(options) - posttest.log(logger, options) + posttest.log(options) class TestGroup(Test): @@ -398,7 +405,7 @@ class TestGroup(Test): (self.pathname, self.outputdir, self.tests, self.timeout, self.pre, pre_user, self.post, post_user, self.user, self.tags) - def verify(self, logger): + def verify(self): """ Check the pre/post scripts, user and tests in this TestGroup. Omit the TestGroup entirely, or simply delete the relevant tests in the @@ -416,34 +423,34 @@ class TestGroup(Test): for f in [f for f in auxfiles if len(f)]: if self.pathname != os.path.dirname(f): - logger.info("Warning: TestGroup '%s' not added to this run. " - "Auxiliary script '%s' exists in a different " - "directory." % (self.pathname, f)) + write_log("Warning: TestGroup '%s' not added to this run. " + "Auxiliary script '%s' exists in a different " + "directory.\n" % (self.pathname, f), LOG_ERR) return False if not verify_file(f): - logger.info("Warning: TestGroup '%s' not added to this run. " - "Auxiliary script '%s' failed verification." % - (self.pathname, f)) + write_log("Warning: TestGroup '%s' not added to this run. " + "Auxiliary script '%s' failed verification.\n" % + (self.pathname, f), LOG_ERR) return False for user in [user for user in users if len(user)]: - if not verify_user(user, logger): - logger.info("Not adding TestGroup '%s' to this run." % - self.pathname) + if not verify_user(user): + write_log("Not adding TestGroup '%s' to this run.\n" % + self.pathname, LOG_ERR) return False # If one of the tests is invalid, delete it, log it, and drive on. for test in self.tests: if not verify_file(os.path.join(self.pathname, test)): del self.tests[self.tests.index(test)] - logger.info("Warning: Test '%s' removed from TestGroup '%s' " - "because it failed verification." % - (test, self.pathname)) + write_log("Warning: Test '%s' removed from TestGroup '%s' " + "because it failed verification.\n" % + (test, self.pathname), LOG_ERR) return len(self.tests) is not 0 - def run(self, logger, options): + def run(self, options): """ Create Cmd instances for the pre/post scripts. If the pre script doesn't pass, skip all the tests in this TestGroup. Run the post @@ -464,7 +471,7 @@ class TestGroup(Test): if len(pretest.pathname): pretest.run(options) cont = pretest.result.result is 'PASS' - pretest.log(logger, options) + pretest.log(options) for fname in self.tests: test = Cmd(os.path.join(self.pathname, fname), @@ -475,11 +482,11 @@ class TestGroup(Test): else: test.skip() - test.log(logger, options) + test.log(options) if len(posttest.pathname): posttest.run(options) - posttest.log(logger, options) + posttest.log(options) class TestRun(object): @@ -491,7 +498,7 @@ class TestRun(object): self.starttime = time() self.timestamp = datetime.now().strftime('%Y%m%dT%H%M%S') self.outputdir = os.path.join(options.outputdir, self.timestamp) - self.logger = self.setup_logging(options) + self.setup_logging(options) self.defaults = [ ('outputdir', BASEDIR), ('quiet', False), @@ -524,7 +531,7 @@ class TestRun(object): for prop in Test.props: setattr(test, prop, getattr(options, prop)) - if test.verify(self.logger): + if test.verify(): self.tests[pathname] = test def addtestgroup(self, dirname, filenames, options): @@ -546,9 +553,9 @@ class TestRun(object): self.testgroups[dirname] = testgroup self.testgroups[dirname].tests = sorted(filenames) - testgroup.verify(self.logger) + testgroup.verify() - def read(self, logger, options): + def read(self, options): """ Read in the specified runfile, and apply the TestRun properties listed in the 'DEFAULT' section to our TestRun. Then read each @@ -589,7 +596,7 @@ class TestRun(object): # Repopulate tests using eval to convert the string to a list testgroup.tests = eval(config.get(section, 'tests')) - if testgroup.verify(logger): + if testgroup.verify(): self.testgroups[section] = testgroup else: test = Test(section) @@ -598,7 +605,7 @@ class TestRun(object): if config.has_option(sect, prop): setattr(test, prop, config.get(sect, prop)) - if test.verify(logger): + if test.verify(): self.tests[section] = test def write(self, options): @@ -661,42 +668,23 @@ class TestRun(object): def setup_logging(self, options): """ - Two loggers are set up here. The first is for the logfile which - will contain one line summarizing the test, including the test - name, result, and running time. This logger will also capture the - timestamped combined stdout and stderr of each run. The second - logger is optional console output, which will contain only the one - line summary. The loggers are initialized at two different levels - to facilitate segregating the output. + This funtion creates the output directory and gets a file object + for the logfile. This function must be called before write_log() + can be used. """ if options.dryrun is True: return - testlogger = logging.getLogger(__name__) - testlogger.setLevel(logging.DEBUG) - + global LOG_FILE_OBJ if options.cmd is not 'wrconfig': try: old = os.umask(0) os.makedirs(self.outputdir, mode=0o777) os.umask(old) + filename = os.path.join(self.outputdir, 'log') + LOG_FILE_OBJ = open(filename, buffering=0, mode='wb') except OSError as e: fail('%s' % e) - filename = os.path.join(self.outputdir, 'log') - - logfile = logging.FileHandler(filename) - logfile.setLevel(logging.DEBUG) - logfilefmt = logging.Formatter('%(message)s') - logfile.setFormatter(logfilefmt) - testlogger.addHandler(logfile) - - cons = logging.StreamHandler() - cons.setLevel(logging.INFO) - consfmt = logging.Formatter('%(message)s') - cons.setFormatter(consfmt) - testlogger.addHandler(cons) - - return testlogger def run(self, options): """ @@ -713,14 +701,14 @@ class TestRun(object): if not os.path.exists(logsymlink): os.symlink(self.outputdir, logsymlink) else: - print('Could not make a symlink to directory %s' % ( - self.outputdir)) + write_log('Could not make a symlink to directory %s\n' % + self.outputdir, LOG_ERR) iteration = 0 while iteration < options.iterations: for test in sorted(self.tests.keys()): - self.tests[test].run(self.logger, options) + self.tests[test].run(options) for testgroup in sorted(self.testgroups.keys()): - self.testgroups[testgroup].run(self.logger, options) + self.testgroups[testgroup].run(options) iteration += 1 def summary(self): @@ -748,6 +736,23 @@ class TestRun(object): return 0 +def write_log(msg, target): + """ + Write the provided message to standard out, standard error or + the logfile. If specifying LOG_FILE, then `msg` must be a bytes + like object. This way we can still handle output from tests that + may be in unexpected encodings. + """ + if target == LOG_OUT: + os.write(sys.stdout.fileno(), bytearray(msg, encoding='utf-8')) + elif target == LOG_ERR: + os.write(sys.stderr.fileno(), bytearray(msg, encoding='utf-8')) + elif target == LOG_FILE: + os.write(LOG_FILE_OBJ.fileno(), msg) + else: + fail('log_msg called with unknown target "%s"' % target) + + def verify_file(pathname): """ Verify that the supplied pathname is an executable regular file. @@ -763,7 +768,7 @@ def verify_file(pathname): return False -def verify_user(user, logger): +def verify_user(user): """ Verify that the specified user exists on this system, and can execute sudo without being prompted for a password. @@ -776,13 +781,15 @@ def verify_user(user, logger): try: getpwnam(user) except KeyError: - logger.info("Warning: user '%s' does not exist.", user) + write_log("Warning: user '%s' does not exist.\n" % user, + LOG_ERR) return False p = Popen(testcmd) p.wait() if p.returncode is not 0: - logger.info("Warning: user '%s' cannot use passwordless sudo.", user) + write_log("Warning: user '%s' cannot use passwordless sudo.\n" % user, + LOG_ERR) return False else: Cmd.verified_users.append(user) @@ -810,7 +817,7 @@ def find_tests(testrun, options): def fail(retstr, ret=1): - print('%s: %s' % (argv[0], retstr)) + print('%s: %s' % (sys.argv[0], retstr)) exit(ret) @@ -900,7 +907,7 @@ def main(): if options.cmd is 'runtests': find_tests(testrun, options) elif options.cmd is 'rdconfig': - testrun.read(testrun.logger, options) + testrun.read(options) elif options.cmd is 'wrconfig': find_tests(testrun, options) testrun.write(options) diff --git a/tests/test-runner/bin/zts-report.py b/tests/test-runner/bin/zts-report.py index 950295601..4e51bc94e 100755 --- a/tests/test-runner/bin/zts-report.py +++ b/tests/test-runner/bin/zts-report.py @@ -1,4 +1,4 @@ -#!/usr/bin/python +#!/usr/bin/python3 # # This file and its contents are supplied under the terms of the @@ -15,6 +15,8 @@ # Copyright (c) 2017 by Delphix. All rights reserved. # Copyright (c) 2018 by Lawrence Livermore National Security, LLC. # +# This script must remain compatible with Python 2.6+ and Python 3.4+. +# import os import re diff --git a/tests/zfs-tests/include/commands.cfg b/tests/zfs-tests/include/commands.cfg index 5efcb6102..8ced03e93 100644 --- a/tests/zfs-tests/include/commands.cfg +++ b/tests/zfs-tests/include/commands.cfg @@ -146,10 +146,10 @@ export ZFS_FILES='zdb zpool ztest raidz_test - arc_summary.py - arc_summary3.py - arcstat.py - dbufstat.py + arc_summary + arc_summary3 + arcstat + dbufstat zed zgenhostid zstreamdump' diff --git a/tests/zfs-tests/tests/functional/arc/dbufstats_001_pos.ksh b/tests/zfs-tests/tests/functional/arc/dbufstats_001_pos.ksh index 5ceff962d..7ec9eaf4c 100755 --- a/tests/zfs-tests/tests/functional/arc/dbufstats_001_pos.ksh +++ b/tests/zfs-tests/tests/functional/arc/dbufstats_001_pos.ksh @@ -37,7 +37,7 @@ # 2. Store output from dbufs kstat # 3. Store output from dbufstats kstat # 4. Compare stats presented in dbufstats with stat generated using -# dbufstat.py and the dbufs kstat output +# dbufstat and the dbufs kstat output # DBUFSTATS_FILE=$(mktemp $TEST_BASE_DIR/dbufstats.out.XXXXXX) @@ -56,7 +56,7 @@ function testdbufstat # stat_name dbufstat_filter [[ -n "$2" ]] && filter="-F $2" from_dbufstat=$(grep -w "$name" "$DBUFSTATS_FILE" | awk '{ print $3 }') - from_dbufs=$(dbufstat.py -bxn -i "$DBUFS_FILE" "$filter" | wc -l) + from_dbufs=$(dbufstat -bxn -i "$DBUFS_FILE" "$filter" | wc -l) within_tolerance $from_dbufstat $from_dbufs 9 \ || log_fail "Stat $name exceeded tolerance" diff --git a/tests/zfs-tests/tests/functional/arc/dbufstats_002_pos.ksh b/tests/zfs-tests/tests/functional/arc/dbufstats_002_pos.ksh index e256bfabe..dc30b6606 100755 --- a/tests/zfs-tests/tests/functional/arc/dbufstats_002_pos.ksh +++ b/tests/zfs-tests/tests/functional/arc/dbufstats_002_pos.ksh @@ -62,18 +62,18 @@ objid=$(stat --format="%i" "$TESTDIR/file") log_note "Object ID for $TESTDIR/file is $objid" log_must eval "cat /proc/spl/kstat/zfs/dbufs > $DBUFS_FILE" -dbuf=$(dbufstat.py -bxn -i "$DBUFS_FILE" -F "object=$objid" | wc -l) -mru=$(dbufstat.py -bxn -i "$DBUFS_FILE" -F "object=$objid,list=1" | wc -l) -mfu=$(dbufstat.py -bxn -i "$DBUFS_FILE" -F "object=$objid,list=3" | wc -l) +dbuf=$(dbufstat -bxn -i "$DBUFS_FILE" -F "object=$objid" | wc -l) +mru=$(dbufstat -bxn -i "$DBUFS_FILE" -F "object=$objid,list=1" | wc -l) +mfu=$(dbufstat -bxn -i "$DBUFS_FILE" -F "object=$objid,list=3" | wc -l) log_note "dbuf count is $dbuf, mru count is $mru, mfu count is $mfu" verify_ne "0" "$mru" "mru count" verify_eq "0" "$mfu" "mfu count" log_must eval "cat $TESTDIR/file > /dev/null" log_must eval "cat /proc/spl/kstat/zfs/dbufs > $DBUFS_FILE" -dbuf=$(dbufstat.py -bxn -i "$DBUFS_FILE" -F "object=$objid" | wc -l) -mru=$(dbufstat.py -bxn -i "$DBUFS_FILE" -F "object=$objid,list=1" | wc -l) -mfu=$(dbufstat.py -bxn -i "$DBUFS_FILE" -F "object=$objid,list=3" | wc -l) +dbuf=$(dbufstat -bxn -i "$DBUFS_FILE" -F "object=$objid" | wc -l) +mru=$(dbufstat -bxn -i "$DBUFS_FILE" -F "object=$objid,list=1" | wc -l) +mfu=$(dbufstat -bxn -i "$DBUFS_FILE" -F "object=$objid,list=3" | wc -l) log_note "dbuf count is $dbuf, mru count is $mru, mfu count is $mfu" verify_ne "0" "$mfu" "mfu count" diff --git a/tests/zfs-tests/tests/functional/cli_user/misc/Makefile.am b/tests/zfs-tests/tests/functional/cli_user/misc/Makefile.am index ff7b4906f..29c034290 100644 --- a/tests/zfs-tests/tests/functional/cli_user/misc/Makefile.am +++ b/tests/zfs-tests/tests/functional/cli_user/misc/Makefile.am @@ -46,7 +46,6 @@ dist_pkgdata_SCRIPTS = \ arcstat_001_pos.ksh \ arc_summary_001_pos.ksh \ arc_summary_002_neg.ksh \ - arc_summary3_001_pos.ksh \ dbufstat_001_pos.ksh dist_pkgdata_DATA = \ diff --git a/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary3_001_pos.ksh b/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary3_001_pos.ksh deleted file mode 100755 index 22dceaaf4..000000000 --- a/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary3_001_pos.ksh +++ /dev/null @@ -1,56 +0,0 @@ -#! /bin/ksh -p -# -# CDDL HEADER START -# -# The contents of this file are subject to the terms of the -# Common Development and Distribution License (the "License"). -# You may not use this file except in compliance with the License. -# -# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE -# or http://www.opensolaris.org/os/licensing. -# See the License for the specific language governing permissions -# and limitations under the License. -# -# When distributing Covered Code, include this CDDL HEADER in each -# file and include the License file at usr/src/OPENSOLARIS.LICENSE. -# If applicable, add the following below this CDDL HEADER, with the -# fields enclosed by brackets "[]" replaced with your own identifying -# information: Portions Copyright [yyyy] [name of copyright owner] -# -# CDDL HEADER END -# - -# -# Copyright (c) 2015 by Lawrence Livermore National Security, LLC. -# All rights reserved. -# - -. $STF_SUITE/include/libtest.shlib - -# Keep the following test until Python 3 is installed on all test systems, -# then remove -python3 -V 2>&1 > /dev/null -if (( $? )); then - log_unsupported "Python3 is not installed" -fi - - -# Some systems have Python 3 installed, but only older versions that don't -# have the subprocess.run() functionality. We catch these with a separate -# test. Remove this when all systems have reached 3.5 or greater -VERSIONPYTEST=$(python3 -V) -if [[ ${VERSIONPYTEST:9:1} -lt 5 ]]; then - log_unsupported "Python3 must be version 3.5 or greater" -fi - - -set -A args "" "-a" "-d" "-p 1" "-g" "-s arc" "-r" -log_assert "arc_summary3.py generates output and doesn't return an error code" - -typeset -i i=0 -while [[ $i -lt ${#args[*]} ]]; do - log_must eval "arc_summary3.py ${args[i]} > /dev/null" - ((i = i + 1)) -done - -log_pass "arc_summary3.py generates output and doesn't return an error code" diff --git a/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary_001_pos.ksh b/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary_001_pos.ksh index 6653b9c1a..a445fbb48 100755 --- a/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary_001_pos.ksh +++ b/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary_001_pos.ksh @@ -27,17 +27,34 @@ . $STF_SUITE/include/libtest.shlib -set -A args "" "-a" "-d" "-p 1" +log_assert "arc_summary generates output and doesn't return an error code" -log_assert "arc_summary.py generates output and doesn't return an error code" +# Depending on which version of arc_summary is installed some command +# line options may not be available. The python3 version includes +# several additional flags. +python3 -V 2>&1 > /dev/null +if (( $? )); then + # Some systems have Python 3 installed, but only older versions + # that don't have the subprocess.run() functionality. We catch + # these with a separate test. Remove this when all systems have + # reached 3.5 or greater + VERSIONPYTEST=$(python3 -V) + if [[ ${VERSIONPYTEST:9:1} -lt 5 ]]; then + set -A args "" "-a" "-d" "-p 1" + else + set -A args "" "-a" "-d" "-p 1" "-g" "-s arc" "-r" + fi +else + set -A args "" "-a" "-d" "-p 1" +fi typeset -i i=0 while [[ $i -lt ${#args[*]} ]]; do - log_must eval "arc_summary.py ${args[i]} > /dev/null" - ((i = i + 1)) + log_must eval "arc_summary ${args[i]} > /dev/null" + ((i = i + 1)) done -log_must eval "arc_summary.py | head > /dev/null" -log_must eval "arc_summary.py | head -1 > /dev/null" +log_must eval "arc_summary | head > /dev/null" +log_must eval "arc_summary | head -1 > /dev/null" -log_pass "arc_summary.py generates output and doesn't return an error code" +log_pass "arc_summary generates output and doesn't return an error code" diff --git a/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary_002_neg.ksh b/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary_002_neg.ksh index e63552feb..de747fba8 100755 --- a/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary_002_neg.ksh +++ b/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary_002_neg.ksh @@ -27,12 +27,12 @@ . $STF_SUITE/include/libtest.shlib -typeset args=("-x" "-r" "-5" "-p 7" "--err" "-@") +typeset args=("-x" "-5" "-p 7" "--err" "-@") -log_assert "arc_summary.py generates an error code with invalid options" +log_assert "arc_summary generates an error code with invalid options" for arg in "${args[@]}"; do - log_mustnot eval "arc_summary.py $arg > /dev/null" + log_mustnot eval "arc_summary $arg > /dev/null" done -log_pass "arc_summary.py generates an error code with invalid options" +log_pass "arc_summary generates an error code with invalid options" diff --git a/tests/zfs-tests/tests/functional/cli_user/misc/arcstat_001_pos.ksh b/tests/zfs-tests/tests/functional/cli_user/misc/arcstat_001_pos.ksh index c8a89f8c4..ab574731f 100755 --- a/tests/zfs-tests/tests/functional/cli_user/misc/arcstat_001_pos.ksh +++ b/tests/zfs-tests/tests/functional/cli_user/misc/arcstat_001_pos.ksh @@ -30,12 +30,12 @@ set -A args "" "-s \",\"" "-x" "-v" \ "-f time,hit%,dh%,ph%,mh%" -log_assert "arcstat.py generates output and doesn't return an error code" +log_assert "arcstat generates output and doesn't return an error code" typeset -i i=0 while [[ $i -lt ${#args[*]} ]]; do - log_must eval "arcstat.py ${args[i]} > /dev/null" + log_must eval "arcstat ${args[i]} > /dev/null" ((i = i + 1)) done -log_pass "arcstat.py generates output and doesn't return an error code" +log_pass "arcstat generates output and doesn't return an error code" diff --git a/tests/zfs-tests/tests/functional/cli_user/misc/cleanup.ksh b/tests/zfs-tests/tests/functional/cli_user/misc/cleanup.ksh index 874a9fd2d..e3dc8c179 100755 --- a/tests/zfs-tests/tests/functional/cli_user/misc/cleanup.ksh +++ b/tests/zfs-tests/tests/functional/cli_user/misc/cleanup.ksh @@ -32,19 +32,20 @@ . $STF_SUITE/include/libtest.shlib . $STF_SUITE/tests/functional/cli_user/misc/misc.cfg -if poolexists $TESTPOOL.virt -then +if poolexists $TESTPOOL.virt; then log_must zpool destroy $TESTPOOL.virt fi -if poolexists v1-pool -then +if poolexists v1-pool; then log_must zpool destroy v1-pool fi -if [[ -f $TEST_BASE_DIR/zfstest_datastream.dat ]] -then - log_must rm -f $TEST_BASE_DIR/zfstest_datastream.dat -fi +log_must rm -f $TEST_BASE_DIR/zfstest_datastream.dat +log_must rm -f $TEST_BASE_DIR/disk1.dat $TEST_BASE_DIR/disk2.dat \ + $TEST_BASE_DIR/disk3.dat $TEST_BASE_DIR/disk-additional.dat \ + $TEST_BASE_DIR/disk-export.dat $TEST_BASE_DIR/disk-offline.dat \ + $TEST_BASE_DIR/disk-spare1.dat $TEST_BASE_DIR/disk-spare2.dat +log_must rm -f $TEST_BASE_DIR/zfs-pool-v1.dat \ + $TEST_BASE_DIR/zfs-pool-v1.dat.bz2 default_cleanup diff --git a/tests/zfs-tests/tests/functional/cli_user/misc/dbufstat_001_pos.ksh b/tests/zfs-tests/tests/functional/cli_user/misc/dbufstat_001_pos.ksh index 1c267d6af..95f0598c6 100755 --- a/tests/zfs-tests/tests/functional/cli_user/misc/dbufstat_001_pos.ksh +++ b/tests/zfs-tests/tests/functional/cli_user/misc/dbufstat_001_pos.ksh @@ -29,15 +29,15 @@ set -A args "" "-b" "-d" "-r" "-v" "-s \",\"" "-x" "-n" -log_assert "dbufstat.py generates output and doesn't return an error code" +log_assert "dbufstat generates output and doesn't return an error code" typeset -i i=0 while [[ $i -lt ${#args[*]} ]]; do - log_must eval "dbufstat.py ${args[i]} > /dev/null" + log_must eval "dbufstat ${args[i]} > /dev/null" ((i = i + 1)) done -# A simple test of dbufstat.py filter functionality -log_must eval "dbufstat.py -F object=10,dbc=1,pool=$TESTPOOL > /dev/null" +# A simple test of dbufstat filter functionality +log_must eval "dbufstat -F object=10,dbc=1,pool=$TESTPOOL > /dev/null" -log_pass "dbufstat.py generates output and doesn't return an error code" +log_pass "dbufstat generates output and doesn't return an error code" diff --git a/tests/zfs-tests/tests/functional/pyzfs/.gitignore b/tests/zfs-tests/tests/functional/pyzfs/.gitignore new file mode 100644 index 000000000..bcbe0573e --- /dev/null +++ b/tests/zfs-tests/tests/functional/pyzfs/.gitignore @@ -0,0 +1 @@ +pyzfs_unittest.ksh diff --git a/tests/zfs-tests/tests/functional/pyzfs/Makefile.am b/tests/zfs-tests/tests/functional/pyzfs/Makefile.am index 61cb3d074..0a27adecc 100644 --- a/tests/zfs-tests/tests/functional/pyzfs/Makefile.am +++ b/tests/zfs-tests/tests/functional/pyzfs/Makefile.am @@ -1,4 +1,18 @@ -pkgdatadir = $(datadir)/@PACKAGE@/zfs-tests/tests/functional/pyzfs - -dist_pkgdata_SCRIPTS = \ +pkgpyzfsdir = $(datadir)/@PACKAGE@/zfs-tests/tests/functional/pyzfs +pkgpyzfs_SCRIPTS = \ pyzfs_unittest.ksh + +EXTRA_DIST = \ + pyzfs_unittest.ksh.in + +# +# The pyzfs module is built either for Python 2 or Python 3. In order +# to properly test it the unit tests must be updated to the matching vesion. +# +$(pkgpyzfs_SCRIPTS):%:%.in + -$(SED) -e 's,@PYTHON\@,$(PYTHON),g' \ + $< >'$@' + -chmod 775 $@ + +distclean-local:: + -$(RM) $(pkgpyzfs_SCRIPTS) diff --git a/tests/zfs-tests/tests/functional/pyzfs/pyzfs_unittest.ksh b/tests/zfs-tests/tests/functional/pyzfs/pyzfs_unittest.ksh.in index fb4b60361..4ca610e5f 100755 --- a/tests/zfs-tests/tests/functional/pyzfs/pyzfs_unittest.ksh +++ b/tests/zfs-tests/tests/functional/pyzfs/pyzfs_unittest.ksh.in @@ -28,7 +28,7 @@ verify_runnable "global" # Verify that the required dependencies for testing are installed. -python -c "import cffi" 2>/dev/null +@PYTHON@ -c "import cffi" 2>/dev/null if [ $? -eq 1 ]; then log_unsupported "python-cffi not found by Python" fi @@ -37,7 +37,7 @@ fi # only if pyzfs was not installed due to missing, build-time, dependencies; if # we cannot load "libzfs_core" due to other reasons, for instance an API/ABI # mismatch, we want to report it. -python -c ' +@PYTHON@ -c ' import pkgutil, sys sys.exit(pkgutil.find_loader("libzfs_core") is None)' if [ $? -eq 1 ]; then @@ -47,7 +47,7 @@ fi log_assert "Verify the nvlist and libzfs_core Python unittest run successfully" # NOTE: don't use log_must() here because it makes output unreadable -python -m unittest --verbose \ +@PYTHON@ -m unittest --verbose \ libzfs_core.test.test_nvlist.TestNVList \ libzfs_core.test.test_libzfs_core.ZFSTest if [ $? -ne 0 ]; then |