On 09/03/22 00:14, Eric Blake wrote: > The next patch will add some APIs that expose long-term statistics > counters. A counter is always accessible (no need to return -1; if > the handle is new the count is still 0, and even after the handle is > in DEAD the counter is still useful). But it is also long-running; > the existing RUInt might only be 32 bits, while it is easy to prove > some counters (bytes transmitted, for example) will need 64-bits. So > time to plumb in a new return type. > > Using signed int64 in OCaml bindings is okay (actually sending 2^63 > bytes of data to overflow the counter takes a LOOONG time, so we don't > worry if we can't get to 2^64). Should be OK for counters (the first use of the new data type in the generator), could be a problem for other purposes. See e.g. commit 0e714a6e06e6 ("ocaml: map C's uint32_t to OCaml's int64", 2022-01-17); mishandling the sign bit there caused infinite loops there. This is not an argument against the patch / new return data type in general, just a remark that in the future, once we try to use Uint64 for other things (not just byte / chunk counters), we could be surprised. Perhaps add a comment somewhere near the RUint64 data constructor in "generator/OCaml.ml"? ... Well, at the same time, we already silently map UInt64 (not RUInt64) to "int64", so there's already prior art for this. OK, feel free to ignore this remark.

> @@ -3368,10 +3369,12 @@ let () = > failwithf "%s: if may_set_error is false, permitted_states must be empty (any permitted state)" > name > > - (* may_set_error = true is incompatible with RUInt, REnum, and RFlags > + (* may_set_error = true is incompatible with RUInt*, REnum, and RFlags > * because these calls cannot return an error indication. > *) > | name, { ret = RUInt; may_set_error = true } > + | name, { ret = RUIntPtr; may_set_error = true } Silent fix for a different omission?

> +++ b/generator/C.ml > @@ -730,24 +732,25 @@ let > pr " nbd_internal_printable_string (ret);\n" > | RBool | RErr | RFd | RInt > | RInt64 | RCookie | RSizeT > - | RUInt | RUIntPtr | REnum _ | RFlags _ -> () > + | RUInt | RUIntPtr | RUInt64 | REnum _ | RFlags _ -> () > ); > pr " debug (h, \"leave: ret=\" "; > (match ret with > | RBool | RErr | RFd | RInt | REnum _ -> pr "\"%%d\", ret" > - | RInt64 | RCookie -> pr "\"%%\" PRIi64 \"\", ret" > + | RInt64 | RCookie -> pr "\"%%\" PRIi64, ret" another silent fix for an earlier problem? > | RSizeT -> pr "\"%%zd\", ret" > | RStaticString | RString -> > pr "\"%%s\", ret_printable ? ret_printable : \"\"" > | RUInt | RFlags _ -> pr "\"%%u\", ret" > | RUIntPtr -> pr "\"%%\" PRIuPTR, ret" > + | RUInt64 -> pr "\"%%\" PRIu64, ret"

> ); > pr ");\n"; > (match ret with > | RStaticString | RString -> pr " free (ret_printable);\n" > | RBool | RErr | RFd | RInt > | RInt64 | RCookie | RSizeT > - | RUInt | REnum _ | RFlags _ | RUIntPtr -> () > + | RUInt | RUIntPtr | RUInt64 | REnum _ | RFlags _ -> () looks like there were multiple RUintPtr omissions, those could go into a unified (but from this, separate) patch.

> ); > pr " }\n"; > pr " }\n" > @@ -904,6 +907,8 @@ let > pr "This call returns a bitmask.\n"; > | RUIntPtr -> > pr "This call returns a C<uintptr_t>.\n"; > + | RUInt64 -> > + pr "This call returns a counter.\n"; Hmmm. On one hand, I like that here we do tie the new type to counters. On the other hand, the explanation doesn't match the generic name "RUint64". Not sure what to suggest :/

> +++ b/generator/Python.ml > @@ -525,7 +525,7 @@ let > | RErr -> > pr " py_ret = Py_None;\n"; > pr " Py_INCREF (py_ret);\n" > - | RFd | RInt | REnum _ | RFlags _ | RSizeT | RUInt | RUIntPtr -> > + | RFd | RInt | REnum _ | RFlags _ | RSizeT | RUInt | RUIntPtr | RUInt64 -> > pr " py_ret = PyLong_FromLong (ret);\n" > | RInt64 | RCookie -> > pr " py_ret = PyLong_FromLongLong (ret);\n" > This does not look right; I think RUInt64 belongs with RInt64 and RCookie (so that we invoke PyLong_FromLongLong()).

I was trying to write a test that determined whether a failure was due to a short-circuit test on the client side or an actual failure returned by the server. Such a test is a lot easier if we can watch status counters increase according to how much traffic goes over the wire. We may add more stats later (for example, how many bytes were written by nbd_[aio_]pread, or even how many times we had to grab the lock as part of an nbd_* command); or even to reset the counters for determining the protocol overhead around a particular set of I/O options, but this is a fun start. In this patch, update an example to serve as a compile time test of the new API; the next patch will add a runtime test of some simple uses while also checking the language bindings. --- docs/libnbd.pod | 20 ++++++++ generator/API.ml | 78 +++++++++++++++++++++++++++++- lib/handle.c | 28 +++++++++++ examples/strict-structured-reads.c | 13 ++++- 4 files changed, 135 insertions(+), 4 deletions(-) diff --git a/docs/libnbd.pod b/docs/libnbd.pod index 7a01179a..d256cd65 100644 --- a/docs/libnbd.pod +++ b/docs/libnbd.pod @@ -940,6 +940,26 @@ should return C<1> on all control paths, even when handling errors (note that with automatic retirement, assigning into C<error> is pointless as there is no later API to see that value). +=head1 STATISTICS COUNTERS + +Libnbd tracks several statistics counters, useful for tracking how +much traffic was sent over the connection. The counters track the +number of bytes sent and received, as well as the number of protocol +chunks (a group of bytes delineated by a magic number). + + printf ("bytes: sent=%" PRIu64 " received=%" PRIu64, + nbd_stats_bytes_sent (nbd), nbd_stats_bytes_received (nbd)); + printf ("chunks: sent=%" PRIu64 " received=%" PRIu64, + nbd_stats_chunks_sent (nbd), nbd_stats_chunks_received (nbd));

+Note that if a command fails early at the client without needing to +consult the server, the counters will not be incremented; conversely, +the chunk counts can increase by more than one for a single API call +(for example, L<nbd_opt_go(3)> defaults to sending a two-option +sequence of C<NBD_OPT_SET_META_CONTEXT> and C<NBD_OPT_GO>, and the +server in turn replies with multiple C<NBD_REP_INFO> before concluding +with C<NBD_REP_ACK>).

=head1 SIGNALS Libnbd does not install signal handlers. It attempts to disable diff --git a/generator/API.ml b/generator/API.ml index e4e2ea0a..dbfde284 100644 --- a/generator/API.ml +++ b/generator/API.ml @@ -307,6 +307,70 @@ "clear_debug_callback", { callback was associated this does nothing."; }; + "stats_bytes_sent", { + default_call with + args = []; ret = RUInt64; + may_set_error = false; + shortdesc = "statistics of bytes sent over socket so far"; + longdesc = "\ +Return the number of bytes that the client has sent to the server."; + see_also = [Link "stats_chunks_sent"; + Link "stats_bytes_received"; Link "stats_chunks_received"]; + }; + + "stats_chunks_sent", { + default_call with + args = []; ret = RUInt64; + may_set_error = false; + shortdesc = "statistics of chunks sent over socket so far"; + longdesc = "\ +Return the number of chunks that the client has sent to the +server, where a chunk is a group of bytes delineated by a magic +number that cannot be further subdivided without breaking the +protocol. + +This number increments when a request is sent to the server; +it is unchanged for an API that fails during initial client-side +sanity checking (see L<nbd_set_strict_mode(3)>), and can +increment by more than one for APIs that wrap multiple +underlying requests (such as L<nbd_opt_go(3)>).";

+ see_also = [Link "stats_bytes_sent"; + Link "stats_bytes_received"; Link "stats_chunks_received"; + Link "set_strict_mode"]; + }; + + "stats_bytes_received", { + default_call with + args = []; ret = RUInt64; + may_set_error = false; + shortdesc = "statistics of bytes received over socket so far"; + longdesc = "\ +Return the number of bytes that the client has received from the server."; + see_also = [Link "stats_chunks_received"; + Link "stats_bytes_sent"; Link "stats_chunks_sent"]; + }; + + "stats_chunks_received", { + default_call with + args = []; ret = RUInt64; + may_set_error = false; + shortdesc = "statistics of chunks received over socket so far"; + longdesc = "\ +Return the number of chunks that the client has received from the +server, where a chunk is a group of bytes delineated by a magic +number that cannot be further subdivided without breaking the +protocol. + +This number increments when a reply is received from the server; +it is unchanged for an API that fails during initial client-side +sanity checking (see L<nbd_set_strict_mode(3)>), and can +increment by more than one when the server utilizes structured +replies (see L<nbd_get_structured_replies_negotiated(3)>).";

+ see_also = [Link "stats_bytes_received"; + Link "stats_bytes_sent"; Link "stats_chunks_sent"; + Link "get_structured_replies_negotiated"]; + }; + "set_handle_name", { default_call with args = [ String "handle_name" ]; ret = RErr; @@ -945,8 +1009,14 @@ "set_strict_mode", { such, when attempting to relax only one specific bit while keeping remaining checks at the client side, it is wiser to first call L<nbd_get_strict_mode(3)> and modify that value, rather than -blindly setting a constant value."; - see_also = [Link "get_strict_mode"; Link "set_handshake_flags"]; +blindly setting a constant value. + +When commands are not being attempted in parallel, it is possible +to observe whether a given command was filtered at the client +or triggered a server response by whether the statistics +counters increase (such as L<nbd_stats_bytes_sent(3)>).";

+ see_also = [Link "get_strict_mode"; Link "set_handshake_flags"; + Link "stats_bytes_sent"; Link "stats_bytes_received"]; }; "get_strict_mode", { @@ -3274,6 +3344,10 @@ let first_version = (* Added in 1.15.x development cycle, will be stable and supported in 1.16. *) "poll2", (1, 16); "supports_vsock", (1, 16); + "stats_bytes_sent", (1, 16); + "stats_chunks_sent", (1, 16); + "stats_bytes_received", (1, 16); + "stats_chunks_received", (1, 16); (* These calls are proposed for a future version of libnbd, but * have not been added to any released version so far. diff --git a/lib/handle.c b/lib/handle.c index 7fcdc8cd..d4426260 100644 --- a/lib/handle.c +++ b/lib/handle.c @@ -548,3 +548,31 @@ nbd_unlocked_set_uri_allow_local_file (struct nbd_handle *h, bool allow) h->uri_allow_local_file = allow; return 0; } + +/* NB: may_set_error = false. */ +uint64_t +nbd_unlocked_stats_bytes_sent (struct nbd_handle *h) +{ + return h->bytes_sent; +} + +/* NB: may_set_error = false. */ +uint64_t +nbd_unlocked_stats_chunks_sent (struct nbd_handle *h) +{ + return h->chunks_sent; +} + +/* NB: may_set_error = false. */ +uint64_t +nbd_unlocked_stats_bytes_received (struct nbd_handle *h) +{ + return h->bytes_received; +} + +/* NB: may_set_error = false. */ +uint64_t +nbd_unlocked_stats_chunks_received (struct nbd_handle *h) +{ + return h->chunks_received; +} diff --git a/examples/strict-structured-reads.c b/examples/strict-structured-reads.c index 6ea17006..b56a4825 100644 --- a/examples/strict-structured-reads.c +++ b/examples/strict-structured-reads.c @@ -4,6 +4,10 @@ * qemu-nbd -f $format -k $sock -r image * ./strict-structured-reads $sock * + * With nbdkit (but less useful until nbdkit learns to send holes): + * + * nbdkit -U- sparse-random 1G --run './strict-structured-reads "$unixsocket"' + *

* This will perform read randomly over the image and check that all * structured replies comply with the NBD spec (chunks may be out of * order or interleaved, but no read succeeds unless chunks cover the @@ -257,8 +261,11 @@ main (int argc, char *argv[]) exit (EXIT_FAILURE); } - nbd_close (nbd); - + printf ("traffic:\n"); + printf (" bytes sent: %10" PRIu64 "\n", nbd_stats_bytes_sent (nbd)); + printf (" bytes received: %10" PRIu64 "\n", nbd_stats_bytes_received (nbd)); + printf (" chunks sent: %10" PRIu64 "\n", nbd_stats_chunks_sent (nbd)); + printf (" chunks received: %10" PRIu64 "\n", nbd_stats_chunks_received (nbd)); printf ("totals:\n"); printf (" data chunks: %10d\n", total_data_chunks); printf (" data bytes: %10" PRId64 "\n", total_data_bytes); @@ -270,5 +277,7 @@ main (int argc, char *argv[]) printf (" bytes read: %10" PRId64 "\n", total_bytes); printf (" compliant: %10d\n", total_success); + nbd_close (nbd); + exit (EXIT_SUCCESS); } --

On 09/03/22 18:30, Richard W.M. Jones wrote: > On Fri, Sep 02, 2022 at 05:14:24PM -0500, Eric Blake wrote: >> I was trying to write a test that determined whether a failure was due >> to a short-circuit test on the client side or an actual failure >> returned by the server. Such a test is a lot easier if we can watch >> status counters increase according to how much traffic goes over the >> wire. We may add more stats later (for example, how many bytes were >> written by nbd_[aio_]pread, or even how many times we had to grab the >> lock as part of an nbd_* command); or even to reset the counters for >> determining the protocol overhead around a particular set of I/O >> options, but this is a fun start. >> >> In this patch, update an example to serve as a compile time test of >> the new API; the next patch will add a runtime test of some simple >> uses while also checking the language bindings. >> --- >> docs/libnbd.pod | 20 ++++++++ >> generator/API.ml | 78 +++++++++++++++++++++++++++++- >> lib/handle.c | 28 +++++++++++ >> examples/strict-structured-reads.c | 13 ++++- >> 4 files changed, 135 insertions(+), 4 deletions(-) >> >> diff --git a/docs/libnbd.pod b/docs/libnbd.pod >> index 7a01179a..d256cd65 100644 >> --- a/docs/libnbd.pod >> +++ b/docs/libnbd.pod >> @@ -940,6 +940,26 @@ should return C<1> on all control paths, even when handling errors >> (note that with automatic retirement, assigning into C<error> is >> pointless as there is no later API to see that value). >> >> +=head1 STATISTICS COUNTERS >> + >> +Libnbd tracks several statistics counters, useful for tracking how >> +much traffic was sent over the connection. The counters track the >> +number of bytes sent and received, as well as the number of protocol >> +chunks (a group of bytes delineated by a magic number). >> + >> + printf ("bytes: sent=%" PRIu64 " received=%" PRIu64, >> + nbd_stats_bytes_sent (nbd), nbd_stats_bytes_received (nbd)); >> + printf ("chunks: sent=%" PRIu64 " received=%" PRIu64, >> + nbd_stats_chunks_sent (nbd), nbd_stats_chunks_received (nbd)); > > You probably also want to note that if TLS is enabled these don't > relate closely to either bytes or packets sent. > >> +Note that if a command fails early at the client without needing to >> +consult the server, the counters will not be incremented; conversely, >> +the chunk counts can increase by more than one for a single API call >> +(for example, L<nbd_opt_go(3)> defaults to sending a two-option >> +sequence of C<NBD_OPT_SET_META_CONTEXT> and C<NBD_OPT_GO>, and the >> +server in turn replies with multiple C<NBD_REP_INFO> before concluding >> +with C<NBD_REP_ACK>). > > The trouble is that by writing this down, we need to keep supporting > this. If you don't write it down, but it's implicit in our tests then > we can change the API later if it turns out to be hard to support. So > my preference would be to simply delete this paragraph and similar > below ... We ought to be able to document the (originally) intended purpose of a feature such that it does not come with "support strings attached". Commit messages are good, code comments are good too, yes, but what about explicit documentation? E.g. "p2v-hacking.pod" is a great thing. Anyway I don't insist; I just thought (without realizing the "support strings attached") that exactly those paragraphs were the nicest touch ;)

So either way: Acked-by: Laszlo Ersek <lersek(a)redhat.com&gt; Laszlo > >> =head1 SIGNALS >> >> Libnbd does not install signal handlers. It attempts to disable >> diff --git a/generator/API.ml b/generator/API.ml >> index e4e2ea0a..dbfde284 100644 >> --- a/generator/API.ml >> +++ b/generator/API.ml >> @@ -307,6 +307,70 @@ "clear_debug_callback", { >> callback was associated this does nothing."; >> }; >> >> + "stats_bytes_sent", { >> + default_call with >> + args = []; ret = RUInt64; >> + may_set_error = false; >> + shortdesc = "statistics of bytes sent over socket so far"; >> + longdesc = "\ >> +Return the number of bytes that the client has sent to the server."; >> + see_also = [Link "stats_chunks_sent"; >> + Link "stats_bytes_received"; Link "stats_chunks_received"]; >> + }; >> + >> + "stats_chunks_sent", { >> + default_call with >> + args = []; ret = RUInt64; >> + may_set_error = false; >> + shortdesc = "statistics of chunks sent over socket so far"; >> + longdesc = "\ >> +Return the number of chunks that the client has sent to the >> +server, where a chunk is a group of bytes delineated by a magic >> +number that cannot be further subdivided without breaking the >> +protocol. >> + >> +This number increments when a request is sent to the server; >> +it is unchanged for an API that fails during initial client-side >> +sanity checking (see L<nbd_set_strict_mode(3)>), and can >> +increment by more than one for APIs that wrap multiple >> +underlying requests (such as L<nbd_opt_go(3)>)."; > > ^ This one. > >> + see_also = [Link "stats_bytes_sent"; >> + Link "stats_bytes_received"; Link "stats_chunks_received"; >> + Link "set_strict_mode"]; >> + }; >> + >> + "stats_bytes_received", { >> + default_call with >> + args = []; ret = RUInt64; >> + may_set_error = false; >> + shortdesc = "statistics of bytes received over socket so far"; >> + longdesc = "\ >> +Return the number of bytes that the client has received from the server."; >> + see_also = [Link "stats_chunks_received"; >> + Link "stats_bytes_sent"; Link "stats_chunks_sent"]; >> + }; >> + >> + "stats_chunks_received", { >> + default_call with >> + args = []; ret = RUInt64; >> + may_set_error = false; >> + shortdesc = "statistics of chunks received over socket so far"; >> + longdesc = "\ >> +Return the number of chunks that the client has received from the >> +server, where a chunk is a group of bytes delineated by a magic >> +number that cannot be further subdivided without breaking the >> +protocol. >> + >> +This number increments when a reply is received from the server; >> +it is unchanged for an API that fails during initial client-side >> +sanity checking (see L<nbd_set_strict_mode(3)>), and can >> +increment by more than one when the server utilizes structured >> +replies (see L<nbd_get_structured_replies_negotiated(3)>)."; > > ^ This one. > >> + see_also = [Link "stats_bytes_received"; >> + Link "stats_bytes_sent"; Link "stats_chunks_sent"; >> + Link "get_structured_replies_negotiated"]; >> + }; >> + >> "set_handle_name", { >> default_call with >> args = [ String "handle_name" ]; ret = RErr; >> @@ -945,8 +1009,14 @@ "set_strict_mode", { >> such, when attempting to relax only one specific bit while keeping >> remaining checks at the client side, it is wiser to first call >> L<nbd_get_strict_mode(3)> and modify that value, rather than >> -blindly setting a constant value."; >> - see_also = [Link "get_strict_mode"; Link "set_handshake_flags"]; >> +blindly setting a constant value. >> + >> +When commands are not being attempted in parallel, it is possible >> +to observe whether a given command was filtered at the client >> +or triggered a server response by whether the statistics >> +counters increase (such as L<nbd_stats_bytes_sent(3)>)."; > > ^ This one. > >> + see_also = [Link "get_strict_mode"; Link "set_handshake_flags"; >> + Link "stats_bytes_sent"; Link "stats_bytes_received"]; >> }; >> >> "get_strict_mode", { >> @@ -3274,6 +3344,10 @@ let first_version = >> (* Added in 1.15.x development cycle, will be stable and supported in 1.16. *) >> "poll2", (1, 16); >> "supports_vsock", (1, 16); >> + "stats_bytes_sent", (1, 16); >> + "stats_chunks_sent", (1, 16); >> + "stats_bytes_received", (1, 16); >> + "stats_chunks_received", (1, 16); >> >> (* These calls are proposed for a future version of libnbd, but >> * have not been added to any released version so far. >> diff --git a/lib/handle.c b/lib/handle.c >> index 7fcdc8cd..d4426260 100644 >> --- a/lib/handle.c >> +++ b/lib/handle.c >> @@ -548,3 +548,31 @@ nbd_unlocked_set_uri_allow_local_file (struct nbd_handle *h, bool allow) >> h->uri_allow_local_file = allow; >> return 0; >> } >> + >> +/* NB: may_set_error = false. */ >> +uint64_t >> +nbd_unlocked_stats_bytes_sent (struct nbd_handle *h) >> +{ >> + return h->bytes_sent; >> +} >> + >> +/* NB: may_set_error = false. */ >> +uint64_t >> +nbd_unlocked_stats_chunks_sent (struct nbd_handle *h) >> +{ >> + return h->chunks_sent; >> +} >> + >> +/* NB: may_set_error = false. */ >> +uint64_t >> +nbd_unlocked_stats_bytes_received (struct nbd_handle *h) >> +{ >> + return h->bytes_received; >> +} >> + >> +/* NB: may_set_error = false. */ >> +uint64_t >> +nbd_unlocked_stats_chunks_received (struct nbd_handle *h) >> +{ >> + return h->chunks_received; >> +} >> diff --git a/examples/strict-structured-reads.c b/examples/strict-structured-reads.c >> index 6ea17006..b56a4825 100644 >> --- a/examples/strict-structured-reads.c >> +++ b/examples/strict-structured-reads.c >> @@ -4,6 +4,10 @@ >> * qemu-nbd -f $format -k $sock -r image >> * ./strict-structured-reads $sock >> * >> + * With nbdkit (but less useful until nbdkit learns to send holes): >> + * >> + * nbdkit -U- sparse-random 1G --run './strict-structured-reads "$unixsocket"' >> + * > > Is this hunk meant to be included? > >> * This will perform read randomly over the image and check that all >> * structured replies comply with the NBD spec (chunks may be out of >> * order or interleaved, but no read succeeds unless chunks cover the >> @@ -257,8 +261,11 @@ main (int argc, char *argv[]) >> exit (EXIT_FAILURE); >> } >> >> - nbd_close (nbd); >> - >> + printf ("traffic:\n"); >> + printf (" bytes sent: %10" PRIu64 "\n", nbd_stats_bytes_sent (nbd)); >> + printf (" bytes received: %10" PRIu64 "\n", nbd_stats_bytes_received (nbd)); >> + printf (" chunks sent: %10" PRIu64 "\n", nbd_stats_chunks_sent (nbd)); >> + printf (" chunks received: %10" PRIu64 "\n", nbd_stats_chunks_received (nbd)); >> printf ("totals:\n"); >> printf (" data chunks: %10d\n", total_data_chunks); >> printf (" data bytes: %10" PRId64 "\n", total_data_bytes); >> @@ -270,5 +277,7 @@ main (int argc, char *argv[]) >> printf (" bytes read: %10" PRId64 "\n", total_bytes); >> printf (" compliant: %10d\n", total_success); >> >> + nbd_close (nbd); >> + >> exit (EXIT_SUCCESS); >> } >> -- > > Rich. >

This proves that the stat counters increment as desired, as well as proving that our RUInt32 generator type works.

This commit is also a showcase of whether I can do 64-bit math in various languages (C's terseness in 'a == b + (c > d)' is annoying to replicate in languages that don't like playing fast and loose with types). :)

--- python/t/620-stats.py | 77 +++++++++++++++ ocaml/tests/Makefile.am | 1 + ocaml/tests/test_620_stats.ml | 77 +++++++++++++++ golang/Makefile.am | 3 +- golang/libnbd_620_stats.go | 181 ++++++++++++++++++++++++++++++++++ 5 files changed, 338 insertions(+), 1 deletion(-) create mode 100644 python/t/620-stats.py create mode 100644 ocaml/tests/test_620_stats.ml create mode 100644 golang/libnbd_620_stats.go diff --git a/python/t/620-stats.py b/python/t/620-stats.py new file mode 100644 index 00000000..62f8443f --- /dev/null +++ b/python/t/620-stats.py @@ -0,0 +1,77 @@ +# libnbd Python bindings +# Copyright (C) 2010-2022 Red Hat Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +import nbd + +h = nbd.NBD() + +# Pre-connection, stats start out at 0 +bs0 = h.stats_bytes_sent() +cs0 = h.stats_chunks_sent() +br0 = h.stats_bytes_received() +cr0 = h.stats_chunks_received() + +assert bs0 == 0 +assert cs0 == 0 +assert br0 == 0 +assert cr0 == 0 + +# Connection performs handshaking, which increments stats. +# The number of bytes/chunks here may grow over time as more features get +# automatically negotiated, so merely check that they are non-zero. +h.connect_command(["nbdkit", "-s", "--exit-with-parent", "null"]) + +bs1 = h.stats_bytes_sent() +cs1 = h.stats_chunks_sent() +br1 = h.stats_bytes_received() +cr1 = h.stats_chunks_received() + +assert cs1 > 0 +assert bs1 > cs1 +assert cr1 > 0 +assert br1 > cr1 + +# A flush command should be one chunk out, one chunk back (even if +# structured replies are in use) +h.flush() + +bs2 = h.stats_bytes_sent() +cs2 = h.stats_chunks_sent() +br2 = h.stats_bytes_received() +cr2 = h.stats_chunks_received() + +assert bs2 == bs1 + 28 +assert cs2 == cs1 + 1 +assert br2 == br1 + 16 # assumes nbdkit uses simple reply +assert cr2 == cr1 + 1 + +# Stats are still readable after the connection closes; we don't know if +# the server sent reply bytes to our NBD_CMD_DISC, so don't insist on it. +h.shutdown() + +bs3 = h.stats_bytes_sent() +cs3 = h.stats_chunks_sent() +br3 = h.stats_bytes_received() +cr3 = h.stats_chunks_received() + +assert bs3 > bs2 +assert cs3 == cs2 + 1 +assert br3 >= br2 +assert cr3 == cr2 + (br3 > br2) + +# Try to trigger garbage collection of h +h = None diff --git a/ocaml/tests/Makefile.am b/ocaml/tests/Makefile.am index 22cefb4d..c4751ad3 100644 --- a/ocaml/tests/Makefile.am +++ b/ocaml/tests/Makefile.am @@ -42,6 +42,7 @@ ML_TESTS = \ test_590_aio_copy.ml \ test_600_debug_callback.ml \ test_610_exception.ml \ + test_620_stats.ml \ $(NULL) EXTRA_DIST = $(ML_TESTS) diff --git a/ocaml/tests/test_620_stats.ml b/ocaml/tests/test_620_stats.ml new file mode 100644 index 00000000..648096fd --- /dev/null +++ b/ocaml/tests/test_620_stats.ml @@ -0,0 +1,77 @@ +(* hey emacs, this is OCaml code: -*- tuareg -*- *) +(* libnbd OCaml test case + * Copyright (C) 2013-2022 Red Hat Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + *) + +let () = + let nbd = NBD.create () in + + (* Pre-connection, stats start out at 0 *) + let bs0 = NBD.stats_bytes_sent nbd in + let cs0 = NBD.stats_chunks_sent nbd in + let br0 = NBD.stats_bytes_received nbd in + let cr0 = NBD.stats_chunks_received nbd in + assert (bs0 = 0L); + assert (cs0 = 0L); + assert (br0 = 0L); + assert (cr0 = 0L); + + (* Connection performs handshaking, which increments stats. + * The number of bytes/chunks here may grow over time as more features get + * automatically negotiated, so merely check that they are non-zero. + *) + NBD.connect_command nbd ["nbdkit"; "-s"; "--exit-with-parent"; "null"]; + + let bs1 = NBD.stats_bytes_sent nbd in + let cs1 = NBD.stats_chunks_sent nbd in + let br1 = NBD.stats_bytes_received nbd in + let cr1 = NBD.stats_chunks_received nbd in + assert (cs1 > 0L); + assert (bs1 > cs1); + assert (cr1 > 0L); + assert (br1 > cr1); + + (* A flush command should be one chunk out, one chunk back (even if + * structured replies are in use) + *) + NBD.flush nbd; + + let bs2 = NBD.stats_bytes_sent nbd in + let cs2 = NBD.stats_chunks_sent nbd in + let br2 = NBD.stats_bytes_received nbd in + let cr2 = NBD.stats_chunks_received nbd in + assert (bs2 = (Int64.add bs1 28L)); + assert (cs2 = (Int64.succ cs1)); + assert (br2 = (Int64.add br1 16L)); (* assumes nbdkit uses simple reply *) + assert (cr2 = (Int64.succ cr1)); + + (* Stats are still readable after the connection closes; we don't know if + * the server sent reply bytes to our NBD_CMD_DISC, so don't insist on it. + *) + NBD.shutdown nbd; + + let bs3 = NBD.stats_bytes_sent nbd in + let cs3 = NBD.stats_chunks_sent nbd in + let br3 = NBD.stats_bytes_received nbd in + let cr3 = NBD.stats_chunks_received nbd in + let fudge = if cr2 = cr3 then 0L else 1L in + assert (bs3 > bs2); + assert (cs3 = (Int64.succ cs2)); + assert (br3 >= br2); + assert (cr3 = (Int64.add cr2 fudge)) + +let () = Gc.compact () diff --git a/golang/Makefile.am b/golang/Makefile.am index f170cbc4..765382d4 100644 --- a/golang/Makefile.am +++ b/golang/Makefile.am @@ -1,5 +1,5 @@ # nbd client library in userspace -# Copyright (C) 2013-2020 Red Hat Inc. +# Copyright (C) 2013-2022 Red Hat Inc. # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -45,6 +45,7 @@ source_files = \ libnbd_590_aio_copy_test.go \ libnbd_600_debug_callback_test.go \ libnbd_610_error_test.go \ + libnbd_620_stats.go \ $(NULL) generator_built = \ diff --git a/golang/libnbd_620_stats.go b/golang/libnbd_620_stats.go new file mode 100644 index 00000000..8d566198 --- /dev/null +++ b/golang/libnbd_620_stats.go @@ -0,0 +1,181 @@ +/* libnbd golang tests + * Copyright (C) 2013-2022 Red Hat Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package libnbd + +import "testing" + +func Test620Stats(t *testing.T) { + h, err := Create() + if err != nil { + t.Fatalf("could not create handle: %s", err) + } + defer h.Close() + + /* Pre-connection, stats start out at 0 */ + bs0, err := h.StatsBytesSent() + if err != nil { + t.Fatalf("%s", err) + } + cs0, err := h.StatsChunksSent() + if err != nil { + t.Fatalf("%s", err) + } + br0, err := h.StatsBytesReceived() + if err != nil { + t.Fatalf("%s", err) + } + cr0, err := h.StatsChunksReceived() + if err != nil { + t.Fatalf("%s", err) + } + + if bs0 != 0 { + t.Fatalf("unexpected value for bs0") + } + if cs0 != 0 { + t.Fatalf("unexpected value for cs0") + } + if br0 != 0 { + t.Fatalf("unexpected value for br0") + } + if cr0 != 0 { + t.Fatalf("unexpected value for cr0") + } + + /* Connection performs handshaking, which increments stats. + * The number of bytes/chunks here may grow over time as more features + * get automatically negotiated, so merely check that they are non-zero. + */ + err = h.ConnectCommand([]string{ + "nbdkit", "-s", "--exit-with-parent", "null", + }) + if err != nil { + t.Fatalf("%s", err) + } + + bs1, err := h.StatsBytesSent() + if err != nil { + t.Fatalf("%s", err) + } + cs1, err := h.StatsChunksSent() + if err != nil { + t.Fatalf("%s", err) + } + br1, err := h.StatsBytesReceived() + if err != nil { + t.Fatalf("%s", err) + } + cr1, err := h.StatsChunksReceived() + if err != nil { + t.Fatalf("%s", err) + } + + if cs1 == 0 { + t.Fatalf("unexpected value for cs1") + } + if bs1 <= cs1 { + t.Fatalf("unexpected value for bs1") + } + if cr1 == 0 { + t.Fatalf("unexpected value for cr1") + } + if br1 <= cr1 { + t.Fatalf("unexpected value for br1") + } + + /* A flush command should be one chunk out, one chunk back (even if + * structured replies are in use) + */ + err = h.Flush(nil) + if err != nil { + t.Fatalf("%s", err) + } + + bs2, err := h.StatsBytesSent() + if err != nil { + t.Fatalf("%s", err) + } + cs2, err := h.StatsChunksSent() + if err != nil { + t.Fatalf("%s", err) + } + br2, err := h.StatsBytesReceived() + if err != nil { + t.Fatalf("%s", err) + } + cr2, err := h.StatsChunksReceived() + if err != nil { + t.Fatalf("%s", err) + } + + if bs2 != bs1 + 28 { + t.Fatalf("unexpected value for bs2") + } + if cs2 != cs1 + 1 { + t.Fatalf("unexpected value for cs2") + } + if br2 != br1 + 16 { /* assumes nbdkit uses simple reply */ + t.Fatalf("unexpected value for br2") + } + if cr2 != cr1 + 1 { + t.Fatalf("unexpected value for cr2") + } + + /* Stats are still readable after the connection closes; we don't know if + * the server sent reply bytes to our NBD_CMD_DISC, so don't insist on it. + */ + err = h.Shutdown(nil) + if err != nil { + t.Fatalf("%s", err) + } + + bs3, err := h.StatsBytesSent() + if err != nil { + t.Fatalf("%s", err) + } + cs3, err := h.StatsChunksSent() + if err != nil { + t.Fatalf("%s", err) + } + br3, err := h.StatsBytesReceived() + if err != nil { + t.Fatalf("%s", err) + } + cr3, err := h.StatsChunksReceived() + if err != nil { + t.Fatalf("%s", err) + } + slop := uint64(1) + if br2 == br3 { + slop = uint64(0) + } + + if bs3 <= bs2 { + t.Fatalf("unexpected value for bs3") + } + if cs3 != cs2 + 1 { + t.Fatalf("unexpected value for cs3") + } + if br3 < br2 { + t.Fatalf("unexpected value for br3") + } + if cr3 != cr2 + slop { + t.Fatalf("unexpected value for cr3") + } +}