[PATCH nbdkit] plugins: python: Add imageio plugin example

6 Aug 2020

This is mainly for testing the new parallel python threading model, but
it also an example how to manage multiple connection from a plugin.

I tested this with local imageio server, serving qcow2 image on local
SSD.

Start imageio server from imageio source:

    ./ovirt-imageio -c test

Create test disk:

    qemu-img create -f qcow2 /var/tmp/disk.qcow2 6g

Add ticket to accessing the image, using nbd example ticket:

    curl --unix-socket ../daemon/test/daemon.sock \
        --upload-file examples/nbd.json http://localhost/ticket/nbd

Start qemu-nbd, serving the image for imageio:

    qemu-nbd --socket=/tmp/nbd.sock --persistent --shared=8 --format=qcow2 \
        --aio=native --cache=none --discard=unmap  /var/tmp/disk.qcow2

Start nbdkit with this plugin:

    ./nbdkit -U nbd.sock -t4 -f python ./plugins/python/examples/imageio.py \
        transfer_url=https://localhost:54322/images/nbd connections=4 secure=no

Finally, upload the image using qemu-img:

    time qemu-img convert -n -f raw -O raw -W /var/tmp/fedora-32.raw \
        nbd+unix:///?socket=./nbd.sock

I tested with 1 and 4 threads/connections, creating new empty qcow2
image before each test.

1 connections, 4 threads:

real	0m7.885s
user	0m0.663s
sys	0m0.803s

4 connections, 4 threads:

real	0m3.336s
user	0m0.439s
sys	0m0.651s

This is what we see on imageio side:

1 connection:

[connection 1 ops, 7.866482 s]
[dispatch 2630 ops, 6.488580 s]
[extents 1 ops, 0.002326 s]
[zero 1176 ops, 0.661475 s, 4.73 GiB, 7.15 GiB/s]
[write 1451 ops, 5.475842 s, 1.27 GiB, 237.08 MiB/s]
[flush 2 ops, 0.029208 s]

4 connections:

[connection 1 ops, 3.289038 s]
[dispatch 670 ops, 2.679317 s]
[extents 1 ops, 0.010870 s]
[write 383 ops, 2.172633 s, 333.70 MiB, 153.59 MiB/s]
[zero 286 ops, 0.346506 s, 1.29 GiB, 3.72 GiB/s]

[connection 1 ops, 3.303300 s]
[dispatch 632 ops, 2.711896 s]
[zero 273 ops, 0.380406 s, 1.12 GiB, 2.93 GiB/s]
[extents 1 ops, 0.000485 s]
[write 358 ops, 2.182803 s, 310.67 MiB, 142.33 MiB/s]

[connection 1 ops, 3.318177 s]
[dispatch 669 ops, 2.759531 s]
[extents 1 ops, 0.064217 s]
[write 354 ops, 2.067320 s, 336.70 MiB, 162.87 MiB/s]
[zero 313 ops, 0.470069 s, 1.20 GiB, 2.55 GiB/s]
[flush 1 ops, 0.002421 s]

[connection 1 ops, 3.280020 s]
[dispatch 662 ops, 2.685547 s]
[zero 304 ops, 0.431782 s, 1.13 GiB, 2.62 GiB/s]
[extents 1 ops, 0.000424 s]
[write 356 ops, 2.101127 s, 317.17 MiB, 150.95 MiB/s]
[flush 1 ops, 0.000127 s]

Results are not very stable, but the trend is clear. We can use this
to optimize the virt-v2v.

Signed-off-by: Nir Soffer <nsoffer@redhat.com>
---
 plugins/python/examples/imageio.py | 167 +++++++++++++++++++++++++++++
 1 file changed, 167 insertions(+)
 create mode 100644 plugins/python/examples/imageio.py

diff --git a/plugins/python/examples/imageio.py b/plugins/python/examples/imageio.py
new file mode 100644
index 00000000..e77fd2f4
--- /dev/null
+++ b/plugins/python/examples/imageio.py
@@ -0,0 +1,167 @@
+# Example Python plugin.
+#
+# This example can be freely used for any purpose.
+#
+# Upload and download images to oVirt with nbdkit and qemu-img.
+#
+# Install ovirt-imageio-client
+#
+#   dnf copr enable nsoffer/ovirt-imageio-preview
+#   dnf install ovirt-imageio-client
+#
+# To upload or download images, you need to start an image transfer. The
+# easiest way is using oVirt image_transfer.py example:
+#
+#  /usr/share/doc/python3-ovirt-enigne-sdk4/eamples/image_transfer.py \
+#      --engine-url https://my.engine \
+#      --username admin@internal \
+#      --password-file password \
+#      --cafile my.engine.pem \
+#      upload disk-uuid
+#
+# This will print the trasnfer URL for this image transfer.
+#
+# Run this example from the build directory:
+#
+#   ./nbdkit -t4 -f -v -U /tmp/nbd.sock -t4 python \
+#       ./plugins/python/examples/imageio.py \
+#       transfer_url=https://server:54322/images/ticket-id \
+#       connections=4 \
+#       secure=no
+#
+# Note that number of nbdkit threads and imageio connections should match.
+#
+# To upload an image run:
+#
+#   qemu-img convert -f qcow2 -O raw disk.img nbd:///?socket=tmp/nbd.sock
+#
+# Downloading image is not efficient with this version, since we don't report
+# extents yet.
+#
+# The -f -v arguments are optional.  They cause the server to stay in
+# the foreground and print debugging, which is useful when testing.
+
+import queue
+import threading
+from contextlib import contextmanager
+
+from ovirt_imageio.client import ImageioClient
+
+import nbdkit
+
+# Using version 2 supporting the buffer protocol for better performance.
+API_VERSION = 2
+
+# Plugin configuration, can be set using key=value in the command line.
+params = {
+    "secure": True,
+    "ca_file": "",
+    "connections": 1,
+    "transfer_url": None,
+}
+
+
+def config(key, value):
+    """
+    Parse the url parameter which contains the transfer URL that we want to
+    serve.
+    """
+    if key == "transfer_url":
+        params["transfer_url"] = value
+    elif key == "connections":
+        params["connections"] = int(value)
+    elif key == "ca_file":
+        params["ca_file"] = value
+    elif key == "secure":
+        params["secure"] = boolify(key, value)
+    else:
+        raise RuntimeError("unknown parameter: {!r}".format(key))
+
+
+def boolify(key, value):
+    v = value.lower()
+    if v in ("yes", "true", "1"):
+        return True
+    if v in ("no", "false", 0):
+        return False
+    raise RuntimeError("Invalid boolean value for {}: {!r}".format(key, value))
+
+
+def config_complete():
+    """
+    Called when configuration completed.
+    """
+    if params["transfer_url"] is None:
+        raise RuntimeError("'transfer_url' parameter is required")
+
+
+def thread_model():
+    """
+    Using parallel model to speed up transfer with multiple connections to
+    imageio server.
+    """
+    return nbdkit.THREAD_MODEL_PARALLEL
+
+
+def open(readonly):
+    """
+    Called once when plugin is loaded. We created a pool of connected clients
+    that will be used for requests later.
+    """
+    pool = queue.Queue()
+    for i in range(params["connections"]):
+        client = ImageioClient(
+            params["transfer_url"],
+            cafile=params["ca_file"],
+            secure=params["secure"])
+        pool.put(client)
+    return { "pool": pool }
+
+
+def close(h):
+    """
+    Called when plugin is closed. Close and remove all clients from the pool.
+    """
+    pool = h["pool"]
+    while not pool.empty():
+        client = pool.get()
+        client.close()
+
+
+@contextmanager
+def client(h):
+    """
+    Context manager fetching an imageio client from the pool. Blocks until a
+    client is available.
+    """
+    pool = h["pool"]
+    client = pool.get()
+    try:
+        yield client
+    finally:
+        pool.put(client)
+
+
+def get_size(h):
+    with client(h) as c:
+        return c.size()
+
+
+def pread(h, buf, offset, flags):
+    with client(h) as c:
+        c.read(offset, buf)
+
+
+def pwrite(h, buf, offset, flags):
+    with client(h) as c:
+        c.write(offset, buf)
+
+
+def zero(h, count, offset, flags):
+    with client(h) as c:
+        c.zero(offset, count)
+
+
+def flush(h, flags):
+    with client(h) as c:
+        c.flush()
-- 
2.25.4

    

Nir Soffer

Nir Soffer

Richard W.M. Jones

Eric Blake

Nir Soffer

tags

participants (4)