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(a)redhat.com&gt; --- 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