As promised in the previous patch, also test the new
nbd_opt_set_meta_context() API in Python, OCaml, and Golang.
The fact that Go slams all unit tests into the same namespace is
somewhat annoying; it required munging test 240 now that 250 wants to
use similar global variables.
---
python/t/250-opt-set-meta.py | 126 ++++++++++++
ocaml/tests/Makefile.am | 5 +-
ocaml/tests/test_250_opt_set_meta.ml | 150 ++++++++++++++
tests/opt-set-meta.c | 1 +
golang/Makefile.am | 3 +-
golang/libnbd_240_opt_list_meta_test.go | 54 +++---
golang/libnbd_250_opt_set_meta_test.go | 248 ++++++++++++++++++++++++
7 files changed, 558 insertions(+), 29 deletions(-)
create mode 100644 python/t/250-opt-set-meta.py
create mode 100644 ocaml/tests/test_250_opt_set_meta.ml
create mode 100644 golang/libnbd_250_opt_set_meta_test.go
diff --git a/python/t/250-opt-set-meta.py b/python/t/250-opt-set-meta.py
new file mode 100644
index 0000000..eb27998
--- /dev/null
+++ b/python/t/250-opt-set-meta.py
@@ -0,0 +1,126 @@
+# 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
+
+
+count = 0
+seen = False
+
+
+def f(user_data, name):
+ global count
+ global seen
+ assert user_data == 42
+ count = count + 1
+ if name == nbd.CONTEXT_BASE_ALLOCATION:
+ seen = True
+
+
+def must_fail(f, *args, **kwds):
+ try:
+ f(*args, **kwds)
+ assert False
+ except nbd.Error:
+ pass
+
+
+# First process, with structured replies. Get into negotiating state.
+h = nbd.NBD()
+h.set_opt_mode(True)
+h.connect_command(["nbdkit", "-s", "--exit-with-parent", "-v",
+ "memory", "size=1M"])
+
+# No contexts negotiated yet; can_meta should be error if any requested */
+assert h.get_structured_replies_negotiated() is True
+assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is False
+h.add_meta_context(nbd.CONTEXT_BASE_ALLOCATION)
+must_fail(h.can_meta_context, nbd.CONTEXT_BASE_ALLOCATION)
+
+# FIXME: Once nbd_opt_structured_reply exists, check that set before
+# SR fails server-side, then enable SR for rest of process.
+
+# nbdkit does not match wildcard for SET, even though it does for LIST
+count = 0
+seen = False
+h.clear_meta_contexts()
+h.add_meta_context("base:")
+r = h.opt_set_meta_context(lambda *args: f(42, *args))
+assert r == count
+assert r == 0
+assert not seen
+assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is False
+
+# Negotiating with no contexts is not an error, but selects nothing
+count = 0
+seen = False
+h.clear_meta_contexts()
+r = h.opt_set_meta_context(lambda *args: f(42, *args))
+assert r == 0
+assert r == count
+assert not seen
+assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is False
+
+# Request 2 with expectation of 1; with set_request_meta_context off
+count = 0
+seen = False
+h.add_meta_context("x-nosuch:context")
+h.add_meta_context(nbd.CONTEXT_BASE_ALLOCATION)
+h.set_request_meta_context(False)
+r = h.opt_set_meta_context(lambda *args: f(42, *args))
+assert r == 1
+assert count == 1
+assert seen
+assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is True
+
+# Transition to transmission phase; our last set should remain active
+h.clear_meta_contexts()
+h.add_meta_context("x-nosuch:context")
+h.opt_go()
+assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is True
+
+# Now too late to set; but should not lose earlier state
+count = 0
+seen = False
+must_fail(h.opt_set_meta_context, lambda *args: f(42, *args))
+assert count == 0
+assert not seen
+assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is True
+
+h.shutdown()
+
+# Second process, this time without structured replies server-side.
+h = nbd.NBD()
+h.set_opt_mode(True)
+h.add_meta_context(nbd.CONTEXT_BASE_ALLOCATION)
+h.connect_command(["nbdkit", "-s", "--exit-with-parent", "-v",
+ "memory", "size=1M", "--no-sr"])
+assert h.get_structured_replies_negotiated() is False
+
+# Expect server-side failure here
+count = 0
+seen = False
+must_fail(h.opt_set_meta_context, lambda *args: f(42, *args))
+assert count == 0
+assert not seen
+must_fail(h.can_meta_context, nbd.CONTEXT_BASE_ALLOCATION)
+
+# Even though can_meta fails after failed SET, it returns 0 after go
+h.opt_go()
+assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is False
+
+h.shutdown()
diff --git a/ocaml/tests/Makefile.am b/ocaml/tests/Makefile.am
index 24f626d..f8ce810 100644
--- a/ocaml/tests/Makefile.am
+++ b/ocaml/tests/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
@@ -31,6 +31,7 @@ EXTRA_DIST = \
test_220_opt_list.ml \
test_230_opt_info.ml \
test_240_opt_list_meta.ml \
+ test_250_opt_set_meta.ml \
test_300_get_size.ml \
test_400_pread.ml \
test_405_pread_structured.ml \
@@ -59,6 +60,7 @@ tests_bc = \
test_220_opt_list.bc \
test_230_opt_info.bc \
test_240_opt_list_meta.bc \
+ test_250_opt_set_meta.bc \
test_300_get_size.bc \
test_400_pread.bc \
test_405_pread_structured.bc \
@@ -84,6 +86,7 @@ tests_opt = \
test_220_opt_list.opt \
test_230_opt_info.opt \
test_240_opt_list_meta.opt \
+ test_250_opt_set_meta.opt \
test_300_get_size.opt \
test_400_pread.opt \
test_405_pread_structured.opt \
diff --git a/ocaml/tests/test_250_opt_set_meta.ml
b/ocaml/tests/test_250_opt_set_meta.ml
new file mode 100644
index 0000000..d74e9e0
--- /dev/null
+++ b/ocaml/tests/test_250_opt_set_meta.ml
@@ -0,0 +1,150 @@
+(* 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 count = ref 0
+let seen = ref false
+let f user_data name =
+ assert (user_data = 42);
+ count := !count + 1;
+ if name = NBD.context_base_allocation then
+ seen := true;
+ 0
+
+let () =
+ let nbd = NBD.create () in
+ NBD.set_opt_mode nbd true;
+ NBD.connect_command nbd
+ ["nbdkit"; "-s"; "--exit-with-parent"; "-v";
+ "memory"; "size=1M"];
+
+ (* No contexts negotiated yet; can_meta should be error if any requested *)
+ let sr = NBD.get_structured_replies_negotiated nbd in
+ assert sr;
+ let m = NBD.can_meta_context nbd NBD.context_base_allocation in
+ assert (not m);
+ NBD.add_meta_context nbd NBD.context_base_allocation;
+ (try
+ let _ = NBD.can_meta_context nbd NBD.context_base_allocation in
+ assert false
+ with
+ NBD.Error (errstr, errno) -> ()
+ );
+
+ (* FIXME: Once nbd_opt_structured_reply exists, check that set before
+ * SR fails server-side, then enable SR for rest of process.
+ *)
+
+ (* nbdkit does not match wildcard for SET, even though it does for LIST *)
+ count := 0;
+ seen := false;
+ NBD.clear_meta_contexts nbd;
+ NBD.add_meta_context nbd "base:";
+ let r = NBD.opt_set_meta_context nbd (f 42) in
+ assert (r = !count);
+ assert (r = 0);
+ assert (not !seen);
+ let m = NBD.can_meta_context nbd NBD.context_base_allocation in
+ assert (not m);
+
+ (* Negotiating with no contexts is not an error, but selects nothing *)
+ count := 0;
+ seen := false;
+ NBD.clear_meta_contexts nbd;
+ let r = NBD.opt_set_meta_context nbd (f 42) in
+ assert (r = 0);
+ assert (r = !count);
+ assert (not !seen);
+ let m = NBD.can_meta_context nbd NBD.context_base_allocation in
+ assert (not m);
+
+ (* Request 2 with expectation of 1; with set_request_meta_context off *)
+ count := 0;
+ seen := false;
+ NBD.add_meta_context nbd "x-nosuch:context";
+ NBD.add_meta_context nbd NBD.context_base_allocation;
+ NBD.set_request_meta_context nbd false;
+ let r = NBD.opt_set_meta_context nbd (f 42) in
+ assert (r = 1);
+ assert (r = !count);
+ assert !seen;
+ let m = NBD.can_meta_context nbd NBD.context_base_allocation in
+ assert m;
+
+ (* Transition to transmission phase; our last set should remain active *)
+ NBD.clear_meta_contexts nbd;
+ NBD.add_meta_context nbd "x-nosuch:context";
+ NBD.opt_go nbd;
+ let m = NBD.can_meta_context nbd NBD.context_base_allocation in
+ assert m;
+
+ (* Now too late to set; but should not lose earlier state *)
+ count := 0;
+ seen := false;
+ (try
+ let _ = NBD.opt_set_meta_context nbd (f 42) in
+ assert false
+ with
+ NBD.Error (errstr, errno) -> ()
+ );
+ assert (0 = !count);
+ assert (not !seen);
+ let s = NBD.get_size nbd in
+ assert (s = 1048576_L);
+ let m = NBD.can_meta_context nbd NBD.context_base_allocation in
+ assert m;
+
+ NBD.shutdown nbd;
+
+ (* Second process, this time without structured replies server-side. *)
+ let nbd = NBD.create () in
+ NBD.set_opt_mode nbd true;
+ NBD.add_meta_context nbd NBD.context_base_allocation;
+ NBD.connect_command nbd
+ ["nbdkit"; "-s"; "--exit-with-parent"; "-v";
+ "memory"; "size=1M"; "--no-sr"];
+ let sr = NBD.get_structured_replies_negotiated nbd in
+ assert (not sr);
+
+ (* Expect server-side failure here *)
+ count := 0;
+ seen := false;
+ NBD.add_meta_context nbd "base:";
+ (try
+ let _ = NBD.opt_set_meta_context nbd (f 42) in
+ assert false
+ with
+ NBD.Error (errstr, errno) -> ()
+ );
+ assert (0 = !count);
+ assert (not !seen);
+ (try
+ let _ = NBD.can_meta_context nbd NBD.context_base_allocation in
+ assert false
+ with
+ NBD.Error (errstr, errno) -> ()
+ );
+
+ (* Even though can_meta fails after failed SET, it returns 0 after go *)
+ NBD.opt_go nbd;
+ let m = NBD.can_meta_context nbd NBD.context_base_allocation in
+ assert (not m);
+
+ NBD.shutdown nbd
+
+let () = Gc.compact ()
diff --git a/tests/opt-set-meta.c b/tests/opt-set-meta.c
index 01c9604..bd00276 100644
--- a/tests/opt-set-meta.c
+++ b/tests/opt-set-meta.c
@@ -17,6 +17,7 @@
*/
/* Test behavior of nbd_opt_set_meta_context. */
+/* See also unit test 250 in the various language ports. */
#include <config.h>
diff --git a/golang/Makefile.am b/golang/Makefile.am
index f170cbc..f6e6f91 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
@@ -35,6 +35,7 @@ source_files = \
libnbd_220_opt_list_test.go \
libnbd_230_opt_info_test.go \
libnbd_240_opt_list_meta_test.go \
+ libnbd_250_opt_set_meta_test.go \
libnbd_300_get_size_test.go \
libnbd_400_pread_test.go \
libnbd_405_pread_structured_test.go \
diff --git a/golang/libnbd_240_opt_list_meta_test.go
b/golang/libnbd_240_opt_list_meta_test.go
index 47df787..4af1008 100644
--- a/golang/libnbd_240_opt_list_meta_test.go
+++ b/golang/libnbd_240_opt_list_meta_test.go
@@ -22,16 +22,16 @@ import (
"testing"
)
-var count uint
-var seen bool
+var list_count uint
+var list_seen bool
func listmetaf(user_data int, name string) int {
if user_data != 42 {
panic("expected user_data == 42")
}
- count++
+ list_count++
if (name == context_base_allocation) {
- seen = true
+ list_seen = true
}
return 0
}
@@ -57,22 +57,22 @@ func Test240OptListMeta(t *testing.T) {
}
/* First pass: empty query should give at least "base:allocation". */
- count = 0
- seen = false
+ list_count = 0
+ list_seen = false
r, err := h.OptListMetaContext(func(name string) int {
return listmetaf(42, name)
})
if err != nil {
t.Fatalf("could not request opt_list_meta_context: %s", err)
}
- if r != count || r < 1 || !seen {
- t.Fatalf("unexpected count after opt_list_meta_context")
+ if r != list_count || r < 1 || !list_seen {
+ t.Fatalf("unexpected list_count after opt_list_meta_context")
}
- max := count
+ max := list_count
/* Second pass: bogus query has no response. */
- count = 0
- seen = false
+ list_count = 0
+ list_seen = false
err = h.AddMetaContext("x-nosuch:")
if err != nil {
t.Fatalf("could not request add_meta_context: %s", err)
@@ -83,13 +83,13 @@ func Test240OptListMeta(t *testing.T) {
if err != nil {
t.Fatalf("could not request opt_list_meta_context: %s", err)
}
- if r != 0 || r != count || seen {
- t.Fatalf("unexpected count after opt_list_meta_context")
+ if r != 0 || r != list_count || list_seen {
+ t.Fatalf("unexpected list_count after opt_list_meta_context")
}
/* Third pass: specific query should have one match. */
- count = 0
- seen = false
+ list_count = 0
+ list_seen = false
err = h.AddMetaContext(context_base_allocation)
if err != nil {
t.Fatalf("could not request add_meta_context: %s", err)
@@ -114,15 +114,15 @@ func Test240OptListMeta(t *testing.T) {
if err != nil {
t.Fatalf("could not request opt_list_meta_context: %s", err)
}
- if r != 1 || r != count || !seen {
- t.Fatalf("unexpected count after opt_list_meta_context")
+ if r != 1 || r != list_count || !list_seen {
+ t.Fatalf("unexpected list_count after opt_list_meta_context")
}
/* Fourth pass: opt_list_meta_context is stateless, so it should
* not wipe status learned during opt_info
*/
- count = 0
- seen = false
+ list_count = 0
+ list_seen = false
_, err = h.GetSize()
if err == nil {
t.Fatalf("expected error")
@@ -147,7 +147,7 @@ func Test240OptListMeta(t *testing.T) {
t.Fatalf("can_meta_context failed unexpectedly: %s", err)
}
if !meta {
- t.Fatalf("unexpected count after can_meta_context")
+ t.Fatalf("unexpected list_count after can_meta_context")
}
err = h.ClearMetaContexts()
if err != nil {
@@ -163,8 +163,8 @@ func Test240OptListMeta(t *testing.T) {
if err != nil {
t.Fatalf("could not request opt_list_meta_context: %s", err)
}
- if r != 0 || r != count || seen {
- t.Fatalf("unexpected count after opt_list_meta_context")
+ if r != 0 || r != list_count || list_seen {
+ t.Fatalf("unexpected list_count after opt_list_meta_context")
}
size, err = h.GetSize()
if err != nil {
@@ -178,13 +178,13 @@ func Test240OptListMeta(t *testing.T) {
t.Fatalf("can_meta_context failed unexpectedly: %s", err)
}
if !meta {
- t.Fatalf("unexpected count after can_meta_context")
+ t.Fatalf("unexpected list_count after can_meta_context")
}
err = h.ClearMetaContexts()
/* Final pass: "base:" query should get at least "base:allocation" */
- count = 0
- seen = false
+ list_count = 0
+ list_seen = false
err = h.AddMetaContext("base:")
if err != nil {
t.Fatalf("could not request add_meta_context: %s", err)
@@ -195,8 +195,8 @@ func Test240OptListMeta(t *testing.T) {
if err != nil {
t.Fatalf("could not request opt_list_meta_context: %s", err)
}
- if r < 1 || r > max || r != count || !seen {
- t.Fatalf("unexpected count after opt_list_meta_context")
+ if r < 1 || r > max || r != list_count || !list_seen {
+ t.Fatalf("unexpected list_count after opt_list_meta_context")
}
err = h.OptAbort()
diff --git a/golang/libnbd_250_opt_set_meta_test.go
b/golang/libnbd_250_opt_set_meta_test.go
new file mode 100644
index 0000000..c29b7f4
--- /dev/null
+++ b/golang/libnbd_250_opt_set_meta_test.go
@@ -0,0 +1,248 @@
+/* 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"
+)
+
+var set_count uint
+var set_seen bool
+
+func setmetaf(user_data int, name string) int {
+ if user_data != 42 {
+ panic("expected user_data == 42")
+ }
+ set_count++
+ if (name == context_base_allocation) {
+ set_seen = true
+ }
+ return 0
+}
+
+func Test250OptSetMeta(t *testing.T) {
+ h, err := Create()
+ if err != nil {
+ t.Fatalf("could not create handle: %s", err)
+ }
+ defer h.Close()
+
+ err = h.SetOptMode(true)
+ if err != nil {
+ t.Fatalf("could not set opt mode: %s", err)
+ }
+
+ err = h.ConnectCommand([]string{
+ "nbdkit", "-s", "--exit-with-parent", "-v",
+ "memory", "size=1M",
+ })
+ if err != nil {
+ t.Fatalf("could not connect: %s", err)
+ }
+
+ /* No contexts negotiated yet; CanMeta should be error if any
requested */
+ sr, err := h.GetStructuredRepliesNegotiated()
+ if err != nil {
+ t.Fatalf("could not check structured replies negotiated: %s",
err)
+ }
+ if !sr {
+ t.Fatalf("unexpected structured replies state")
+ }
+ meta, err := h.CanMetaContext(context_base_allocation)
+ if err != nil {
+ t.Fatalf("could not check can meta context: %s", err)
+ }
+ if meta {
+ t.Fatalf("unexpected can meta context state")
+ }
+ err = h.AddMetaContext(context_base_allocation)
+ if err != nil {
+ t.Fatalf("could not request add_meta_context: %s", err)
+ }
+ _, err = h.CanMetaContext(context_base_allocation)
+ if err == nil {
+ t.Fatalf("expected error")
+ }
+
+ /* FIXME: Once OptStructuredReply exists, check that set before
+ * SR fails server-side, then enable SR for rest of process.
+ */
+
+ /* nbdkit does not match wildcard for SET, even though it does for LIST
*/
+ set_count = 0
+ set_seen = false
+ err = h.ClearMetaContexts()
+ if err != nil {
+ t.Fatalf("could not request clear_meta_contexts: %s", err)
+ }
+ err = h.AddMetaContext("base:")
+ if err != nil {
+ t.Fatalf("could not request add_meta_context: %s", err)
+ }
+ r, err := h.OptSetMetaContext(func(name string) int {
+ return setmetaf(42, name)
+ })
+ if err != nil {
+ t.Fatalf("could not request opt_set_meta_context: %s", err)
+ }
+ if r != set_count || r != 0 || set_seen {
+ t.Fatalf("unexpected set_count after opt_set_meta_context")
+ }
+
+ /* Request 2 with expectation of 1; with SetRequestMetaContext off */
+ set_count = 0
+ set_seen = false
+ err = h.AddMetaContext("x-nosuch:context")
+ if err != nil {
+ t.Fatalf("could not request add_meta_context: %s", err)
+ }
+ err = h.AddMetaContext(context_base_allocation)
+ if err != nil {
+ t.Fatalf("could not request add_meta_context: %s", err)
+ }
+ err = h.SetRequestMetaContext(false)
+ if err != nil {
+ t.Fatalf("could not set_request_meta_context: %s", err)
+ }
+ r, err = h.OptSetMetaContext(func(name string) int {
+ return setmetaf(42, name)
+ })
+ if err != nil {
+ t.Fatalf("could not request opt_set_meta_context: %s", err)
+ }
+ if r != 1 || r != set_count || !set_seen {
+ t.Fatalf("unexpected set_count after opt_set_meta_context")
+ }
+ meta, err = h.CanMetaContext(context_base_allocation)
+ if err != nil {
+ t.Fatalf("could not check can meta context: %s", err)
+ }
+ if !meta {
+ t.Fatalf("unexpected can meta context state")
+ }
+
+ /* Transition to transmission phase; our last set should remain active
*/
+ err = h.ClearMetaContexts()
+ if err != nil {
+ t.Fatalf("could not request clear_meta_contexts: %s", err)
+ }
+ err = h.AddMetaContext("x-nosuch:context")
+ if err != nil {
+ t.Fatalf("could not request add_meta_context: %s", err)
+ }
+ err = h.OptGo()
+ if err != nil {
+ t.Fatalf("could not request opt_go: %s", err)
+ }
+ meta, err = h.CanMetaContext(context_base_allocation)
+ if err != nil {
+ t.Fatalf("could not check can meta context: %s", err)
+ }
+ if !meta {
+ t.Fatalf("unexpected can meta context state")
+ }
+
+ /* Now too late to set; but should not lose earlier state */
+ set_count = 0
+ set_seen = false
+ _, err = h.OptSetMetaContext(func(name string) int {
+ return setmetaf(42, name)
+ })
+ if err == nil {
+ t.Fatalf("expected error")
+ }
+ if set_count != 0 || set_seen {
+ t.Fatalf("unexpected set_count after opt_set_meta_context")
+ }
+ meta, err = h.CanMetaContext(context_base_allocation)
+ if err != nil {
+ t.Fatalf("could not check can meta context: %s", err)
+ }
+ if !meta {
+ t.Fatalf("unexpected can meta context state")
+ }
+
+ err = h.Shutdown(nil)
+ if err != nil {
+ t.Fatalf("could not request shutdown: %s", err)
+ }
+
+ /* Second process, this time without structured replies server-side. */
+ h, err = Create()
+ if err != nil {
+ t.Fatalf("could not create handle: %s", err)
+ }
+ defer h.Close()
+
+ err = h.SetOptMode(true)
+ if err != nil {
+ t.Fatalf("could not set opt mode: %s", err)
+ }
+
+ err = h.AddMetaContext(context_base_allocation)
+ if err != nil {
+ t.Fatalf("could not request add_meta_context: %s", err)
+ }
+
+ err = h.ConnectCommand([]string{
+ "nbdkit", "-s", "--exit-with-parent", "-v",
+ "memory", "size=1M", "--no-sr",
+ })
+ if err != nil {
+ t.Fatalf("could not connect: %s", err)
+ }
+
+ sr, err = h.GetStructuredRepliesNegotiated()
+ if err != nil {
+ t.Fatalf("could not check structured replies negotiated: %s",
err)
+ }
+ if sr {
+ t.Fatalf("unexpected structured replies state")
+ }
+
+ /* Expect server-side failure here */
+ set_count = 0
+ set_seen = false
+ _, err = h.OptSetMetaContext(func(name string) int {
+ return setmetaf(42, name)
+ })
+ if err == nil {
+ t.Fatalf("expected error")
+ }
+ if set_count != 0 || set_seen {
+ t.Fatalf("unexpected set_count after opt_set_meta_context")
+ }
+ _, err = h.CanMetaContext(context_base_allocation)
+ if err == nil {
+ t.Fatalf("expected error")
+ }
+
+ /* Even though CanMeta fails after failed SET, it returns 0 after go */
+ err = h.OptGo()
+ if err != nil {
+ t.Fatalf("could not request opt_go: %s", err)
+ }
+ meta, err = h.CanMetaContext(context_base_allocation)
+ if err != nil {
+ t.Fatalf("could not check can meta context: %s", err)
+ }
+ if meta {
+ t.Fatalf("unexpected can meta context state")
+ }
+}
--
2.37.2
_______________________________________________
Libguestfs mailing list
Libguestfs@redhat.com
https://listman.redhat.com/mailman/listinfo/libguestfs
