5:50 a.m.
---
plugins/python/nbdkit-python-plugin.pod | 19 ++++++-
plugins/python/python.c | 75 +++++++++++++++++++++++++
tests/test-python-plugin.py | 8 ++-
tests/test_python.py | 73 +++++++++++++++++++++++-
4 files changed, 169 insertions(+), 6 deletions(-)
diff --git a/plugins/python/nbdkit-python-plugin.pod
b/plugins/python/nbdkit-python-plugin.pod
index b20f51f7..d7b6033f 100644
--- a/plugins/python/nbdkit-python-plugin.pod
+++ b/plugins/python/nbdkit-python-plugin.pod
@@ -271,6 +271,13 @@ contents will be garbage collected.
# return nbdkit.CACHE_NONE or nbdkit.CACHE_EMULATE
# or nbdkit.CACHE_NATIVE
+=item C<can_extents>
+
+(Optional)
+
+ def can_extents(h):
+ # return a boolean
+
=item C<pread>
(Required)
@@ -365,6 +372,14 @@ indicated range.
If the cache operation fails, your function should throw an exception,
optionally using C<nbdkit.set_error> first.
+=item C<extents>
+
+(Optional)
+
+ def extents(h, count, offset, flags):
+ # return a list of (offset, length, type) tuples:
+ return [ (off1, len1, type1), (off2, len2, type2), ... ]
+
=back
=head2 Missing callbacks
@@ -382,9 +397,7 @@ C<version>,
C<longname>,
C<description>,
C<config_help>,
-C<magic_config_key>,
-C<can_extents>,
-C<extents>.
+C<magic_config_key>.
These are not yet supported.
diff --git a/plugins/python/python.c b/plugins/python/python.c
index 398473f5..585cd9e6 100644
--- a/plugins/python/python.c
+++ b/plugins/python/python.c
@@ -1020,6 +1020,79 @@ py_can_cache (void *handle)
return NBDKIT_CACHE_NONE;
}
+static int
+py_can_extents (void *handle)
+{
+ ACQUIRE_PYTHON_GIL_FOR_CURRENT_SCOPE;
+ return boolean_callback (handle, "can_extents", "extents");
+}
+
+static int
+py_extents (void *handle, uint32_t count, uint64_t offset,
+ uint32_t flags, struct nbdkit_extents *extents)
+{
+ ACQUIRE_PYTHON_GIL_FOR_CURRENT_SCOPE;
+ struct handle *h = handle;
+ PyObject *fn;
+ PyObject *r;
+ Py_ssize_t i, size;
+
+ if (callback_defined ("extents", &fn)) {
+ PyErr_Clear ();
+
+ r = PyObject_CallFunction (fn, "OiLI", h->py_h, count, offset, flags);
+ Py_DECREF (fn);
+ if (check_python_failure ("extents") == -1)
+ return -1;
+
+ /* We expect a list of extents to be returned. Each extent is a
+ * tuple (offset, length, type).
+ */
+ if (!PyList_Check (r)) {
+ nbdkit_error ("extents method did not return a list");
+ Py_DECREF (r);
+ return -1;
+ }
+
+ size = PyList_Size (r);
+ for (i = 0; i < size; ++i) {
+ PyObject *t, *py_offset, *py_length, *py_type;
+ uint64_t extent_offset, extent_length;
+ uint32_t extent_type;
+
+ t = PyList_GetItem (r, i);
+ if (!PyTuple_Check (t) || PyTuple_Size (t) != 3) {
+ nbdkit_error ("extents method did not return a list of 3-tuples");
+ Py_DECREF (r);
+ return -1;
+ }
+ py_offset = PyTuple_GetItem (t, 0);
+ py_length = PyTuple_GetItem (t, 1);
+ py_type = PyTuple_GetItem (t, 2);
+ extent_offset = PyLong_AsUnsignedLongLong (py_offset);
+ extent_length = PyLong_AsUnsignedLongLong (py_length);
+ extent_type = PyLong_AsUnsignedLong (py_type);
+ if (check_python_failure ("PyLong") == -1) {
+ Py_DECREF (r);
+ return -1;
+ }
+ if (nbdkit_add_extent (extents,
+ extent_offset, extent_length, extent_type) == -1) {
+ Py_DECREF (r);
+ return -1;
+ }
+ }
+
+ Py_DECREF (r);
+ }
+ else {
+ nbdkit_error ("%s not implemented", "extents");
+ return -1;
+ }
+
+ return 0;
+}
+
#define py_config_help \
"script=<FILENAME> (required) The Python plugin to run.\n" \
"[other arguments may be used by the plugin that you load]"
@@ -1058,6 +1131,7 @@ static struct nbdkit_plugin plugin = {
.can_fast_zero = py_can_fast_zero,
.can_fua = py_can_fua,
.can_cache = py_can_cache,
+ .can_extents = py_can_extents,
.pread = py_pread,
.pwrite = py_pwrite,
@@ -1065,6 +1139,7 @@ static struct nbdkit_plugin plugin = {
.trim = py_trim,
.zero = py_zero,
.cache = py_cache,
+ .extents = py_extents,
};
NBDKIT_REGISTER_PLUGIN (plugin)
diff --git a/tests/test-python-plugin.py b/tests/test-python-plugin.py
index 8e90bc23..d7331df9 100644
--- a/tests/test-python-plugin.py
+++ b/tests/test-python-plugin.py
@@ -1,5 +1,5 @@
# nbdkit test plugin
-# Copyright (C) 2019 Red Hat Inc.
+# Copyright (C) 2019-2020 Red Hat Inc.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
@@ -95,6 +95,9 @@ def can_cache (h):
elif cache == "native":
return nbdkit.CACHE_NATIVE
+def can_extents (h):
+ return cfg.get ('can_extents', False)
+
def pread (h, buf, offset, flags):
assert flags == 0
end = offset + len(buf)
@@ -131,3 +134,6 @@ def zero (h, count, offset, flags):
def cache (h, count, offset, flags):
assert flags == 0
# do nothing
+
+def extents(h, count, offset, flags):
+ return cfg.get ('extents', [])
diff --git a/tests/test_python.py b/tests/test_python.py
index 6b9f2979..a8a1a79f 100755
--- a/tests/test_python.py
+++ b/tests/test_python.py
@@ -1,6 +1,6 @@
#!/usr/bin/env python3
# nbdkit
-# Copyright (C) 2019 Red Hat Inc.
+# Copyright (C) 2019-2020 Red Hat Inc.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
@@ -153,7 +153,19 @@ class Test (unittest.TestCase):
self.connect ({"size": 512, "can_cache":
"native"})
assert self.h.can_cache()
- # Not yet implemented: can_extents.
+ # In theory we could use a test like this, but nbdkit can
+ # always synthesize base:allocation block_status responses
+ # even if the plugin doesn't support them.
+ #
+ #def test_can_extents_true (self):
+ # self.h.add_meta_context ("base:allocation")
+ # self.connect ({"size": 512, "can_extents": True})
+ # assert self.h.can_meta_context ("base:allocation")
+ #
+ #def test_can_extents_false (self):
+ # self.h.add_meta_context ("base:allocation")
+ # self.connect ({"size": 512, "can_extents": False})
+ # assert not self.h.can_meta_context ("base:allocation")
def test_pread (self):
"""Test pread."""
@@ -220,3 +232,60 @@ class Test (unittest.TestCase):
"""Test cache."""
self.connect ({"size": 512, "can_cache":
"native"})
self.h.cache (512, 0)
+
+ # We don't have access to the magic constants defined in the
+ # nbdkit module, so redefine them here.
+ EXTENT_HOLE = 1
+ EXTENT_ZERO = 2
+
+ def test_extents_1 (self):
+ """Test extents."""
+
+ offset = None
+ entries = []
+
+ def f(meta_context, o, e, err):
+ nonlocal offset, entries
+ if meta_context != "base:allocation": return
+ offset = o
+ entries = e
+
+ self.h.add_meta_context ("base:allocation")
+ self.connect ({"size": 512,
+ "can_extents": True,
+ "extents":
+ [ (0, 512, self.EXTENT_HOLE|self.EXTENT_ZERO) ]})
+
+ self.h.block_status (512, 0, lambda *args : f (*args))
+ assert offset == 0
+ assert entries == [ 512, self.EXTENT_HOLE|self.EXTENT_ZERO ]
+
+ def test_extents_2 (self):
+ """Test extents."""
+
+ offset = None
+ entries = []
+
+ def f(meta_context, o, e, err):
+ nonlocal offset, entries
+ if meta_context != "base:allocation": return
+ offset = o
+ entries = e
+
+ self.h.add_meta_context ("base:allocation")
+ self.connect ({"size": 2048,
+ "can_extents": True,
+ "extents":
+ [ (0, 512, self.EXTENT_HOLE|self.EXTENT_ZERO),
+ (512, 512, 0),
+ (1024, 1024, self.EXTENT_ZERO) ]})
+
+ self.h.block_status (2048, 0, lambda *args : f (*args))
+ assert offset == 0
+ assert entries == [ 512, self.EXTENT_HOLE|self.EXTENT_ZERO,
+ 512, 0,
+ 1024, self.EXTENT_ZERO ]
+
+ self.h.block_status (1024, 1024, lambda *args : f (*args))
+ assert offset == 1024
+ assert entries == [ 1024, self.EXTENT_ZERO ]
--
2.27.0