From: Simon Marchi <simon.marchi@efficios.com>
Date: Tue, 12 Dec 2023 04:27:56 +0000 (+0000)
Subject: src.ctf.fs: use C++ value wrappers in queries
X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=commitdiff_plain;h=c02af77939cd46b58bb79fa51688991d38f36a30

src.ctf.fs: use C++ value wrappers in queries

 - Pass the query parameters as a bt2::ConstMapValue
 - Return the query result as a bt2::Value::Shared
 - Communicate errors via exceptions
 - Use std::string instead of GString to build the metadata text

Change-Id: If75da1efc1accb5c42dd98d830ab9abf2ffff932
Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/8165
Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/12271
Tested-by: jenkins <jenkins@lttng.org>
---

diff --git a/src/plugins/ctf/fs-src/fs.cpp b/src/plugins/ctf/fs-src/fs.cpp
index 968c451d..39abdd6c 100644
--- a/src/plugins/ctf/fs-src/fs.cpp
+++ b/src/plugins/ctf/fs-src/fs.cpp
@@ -2255,24 +2255,26 @@ bt_component_class_query_method_status ctf_fs_query(bt_self_component_class_sour
                                                     const bt_value **result)
 {
     try {
-        bt_component_class_query_method_status status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
         bt2c::Logger logger {bt2::SelfComponentClass {comp_class_src},
                              bt2::PrivateQueryExecutor {priv_query_exec},
                              "PLUGIN/SRC.CTF.FS/QUERY"};
+        bt2::ConstMapValue paramsObj(params);
+        bt2::Value::Shared resultObj;
 
         if (strcmp(object, "metadata-info") == 0) {
-            status = metadata_info_query(params, logger, result);
+            resultObj = metadata_info_query(paramsObj, logger);
         } else if (strcmp(object, "babeltrace.trace-infos") == 0) {
-            status = trace_infos_query(params, logger, result);
+            resultObj = trace_infos_query(paramsObj, logger);
         } else if (!strcmp(object, "babeltrace.support-info")) {
-            status = support_info_query(params, logger, result);
+            resultObj = support_info_query(paramsObj, logger);
         } else {
             BT_CPPLOGE_SPEC(logger, "Unknown query object `{}`", object);
-            status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_UNKNOWN_OBJECT;
-            goto end;
+            return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_UNKNOWN_OBJECT;
         }
-end:
-        return status;
+
+        *result = resultObj.release().libObjPtr();
+
+        return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
     } catch (const std::bad_alloc&) {
         return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
     } catch (const bt2::Error&) {
diff --git a/src/plugins/ctf/fs-src/query.cpp b/src/plugins/ctf/fs-src/query.cpp
index 6625ec7d..ce4619ef 100644
--- a/src/plugins/ctf/fs-src/query.cpp
+++ b/src/plugins/ctf/fs-src/query.cpp
@@ -12,6 +12,7 @@
 
 #include <babeltrace2/babeltrace.h>
 
+#include "cpp-common/bt2/exc.hpp"
 #include "cpp-common/bt2c/libc-up.hpp"
 
 #include "../common/src/metadata/tsdl/decoder.hpp"
@@ -27,169 +28,84 @@ struct range
     bool set = false;
 };
 
-bt_component_class_query_method_status metadata_info_query(const bt_value *params,
-                                                           const bt2c::Logger& logger,
-                                                           const bt_value **user_result)
+bt2::Value::Shared metadata_info_query(const bt2::ConstMapValue params, const bt2c::Logger& logger)
 {
-    bt_component_class_query_method_status status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
-    bt_value *result = NULL;
-    const bt_value *path_value = NULL;
-    bt2c::FileUP metadata_fp;
-    int ret;
-    int bo;
-    const char *path;
-    bool is_packetized;
-    ctf_metadata_decoder_up decoder;
-    ctf_metadata_decoder_config decoder_cfg {logger};
-    enum ctf_metadata_decoder_status decoder_status;
-    GString *g_metadata_text = NULL;
-    const char *plaintext;
-
-    result = bt_value_map_create();
-    if (!result) {
-        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
-        goto error;
-    }
-
-    BT_ASSERT(params);
-
-    if (!bt_value_is_map(params)) {
-        BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "Query parameters is not a map value object.");
-        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
-        goto error;
+    const auto pathValue = params["path"];
+    if (!pathValue) {
+        BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error,
+                                               "Mandatory `path` parameter missing");
     }
 
-    path_value = bt_value_map_borrow_entry_value_const(params, "path");
-    if (!path_value) {
-        BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "Mandatory `path` parameter missing");
-        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
-        goto error;
+    if (!pathValue->isString()) {
+        BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error,
+                                               "`path` parameter is required to be a string value");
     }
 
-    if (!bt_value_is_string(path_value)) {
-        BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "`path` parameter is required to be a string value");
-        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
-        goto error;
+    const auto path = pathValue->asString().value();
+    bt2c::FileUP metadataFp {ctf_fs_metadata_open_file(path, logger)};
+    if (!metadataFp) {
+        BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error,
+                                               "Cannot open trace metadata: path=\"{}\".", path);
     }
 
-    path = bt_value_string_get(path_value);
-
-    BT_ASSERT(path);
-    metadata_fp.reset(ctf_fs_metadata_open_file(path, logger));
-    if (!metadata_fp) {
-        BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "Cannot open trace metadata: path=\"{}\".", path);
-        goto error;
-    }
+    bool is_packetized;
+    int bo;
+    int ret = ctf_metadata_decoder_is_packetized(metadataFp.get(), &is_packetized, &bo, logger);
 
-    ret = ctf_metadata_decoder_is_packetized(metadata_fp.get(), &is_packetized, &bo, logger);
     if (ret) {
-        BT_CPPLOGE_APPEND_CAUSE_SPEC(
-            logger, "Cannot check whether or not the metadata stream is packetized: path=\"{}\".",
-            path);
-        goto error;
+        BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(
+            logger, bt2::Error,
+            "Cannot check whether or not the metadata stream is packetized: path=\"{}\".", path);
     }
 
+    ctf_metadata_decoder_config decoder_cfg {logger};
     decoder_cfg.keep_plain_text = true;
-    decoder = ctf_metadata_decoder_create(&decoder_cfg);
+    ctf_metadata_decoder_up decoder = ctf_metadata_decoder_create(&decoder_cfg);
     if (!decoder) {
-        BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "Cannot create metadata decoder: path=\"{}\".", path);
-        goto error;
+        BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(
+            logger, bt2::Error, "Cannot create metadata decoder: path=\"{}}\".", path);
     }
 
-    rewind(metadata_fp.get());
-    decoder_status = ctf_metadata_decoder_append_content(decoder.get(), metadata_fp.get());
+    rewind(metadataFp.get());
+    ctf_metadata_decoder_status decoder_status =
+        ctf_metadata_decoder_append_content(decoder.get(), metadataFp.get());
     if (decoder_status) {
-        BT_CPPLOGE_APPEND_CAUSE_SPEC(
-            logger, "Cannot update metadata decoder's content: path=\"{}\".", path);
-        goto error;
+        BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(
+            logger, bt2::Error, "Cannot update metadata decoder's content: path=\"{}\".", path);
     }
 
-    plaintext = ctf_metadata_decoder_get_text(decoder.get());
-    g_metadata_text = g_string_new(NULL);
-
-    if (!g_metadata_text) {
-        goto error;
-    }
-
-    if (strncmp(plaintext, METADATA_TEXT_SIG, sizeof(METADATA_TEXT_SIG) - 1) != 0) {
-        g_string_assign(g_metadata_text, METADATA_TEXT_SIG);
-        g_string_append(g_metadata_text, " */\n\n");
-    }
+    const char *plain_text = ctf_metadata_decoder_get_text(decoder.get());
+    std::string metadata_text;
 
-    g_string_append(g_metadata_text, plaintext);
-    ret = bt_value_map_insert_string_entry(result, "text", g_metadata_text->str);
-    if (ret) {
-        BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "Cannot insert metadata text into query result.");
-        goto error;
-    }
-
-    ret = bt_value_map_insert_bool_entry(result, "is-packetized", is_packetized);
-    if (ret) {
-        BT_CPPLOGE_APPEND_CAUSE_SPEC(
-            logger, "Cannot insert \"is-packetized\" attribute into query result.");
-        goto error;
+    if (strncmp(plain_text, METADATA_TEXT_SIG, sizeof(METADATA_TEXT_SIG) - 1) != 0) {
+        metadata_text = METADATA_TEXT_SIG;
+        metadata_text += " */\n\n";
     }
 
-    goto end;
+    metadata_text += plain_text;
 
-error:
-    BT_VALUE_PUT_REF_AND_RESET(result);
-    result = NULL;
+    const auto result = bt2::MapValue::create();
+    result->insert("text", metadata_text);
+    result->insert("is-packetized", is_packetized);
 
-    if (status >= 0) {
-        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
-    }
-
-end:
-    if (g_metadata_text) {
-        g_string_free(g_metadata_text, TRUE);
-    }
-
-    *user_result = result;
-    return status;
+    return result;
 }
 
-static int add_range(bt_value *info, struct range *range, const char *range_name)
+static void add_range(const bt2::MapValue info, struct range *range, const char *range_name)
 {
-    int ret = 0;
-    bt_value_map_insert_entry_status status;
-    bt_value *range_map;
-
     if (!range->set) {
         /* Not an error. */
-        goto end;
-    }
-
-    status = bt_value_map_insert_empty_map_entry(info, range_name, &range_map);
-    if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
-        ret = -1;
-        goto end;
-    }
-
-    status = bt_value_map_insert_signed_integer_entry(range_map, "begin", range->begin_ns);
-    if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
-        ret = -1;
-        goto end;
+        return;
     }
 
-    status = bt_value_map_insert_signed_integer_entry(range_map, "end", range->end_ns);
-    if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
-        ret = -1;
-        goto end;
-    }
-
-end:
-    return ret;
+    const auto rangeMap = info.insertEmptyMap(range_name);
+    rangeMap.insert("begin", range->begin_ns);
+    rangeMap.insert("end", range->end_ns);
 }
 
-static int populate_stream_info(struct ctf_fs_ds_file_group *group, bt_value *group_info,
-                                struct range *stream_range)
+static void populate_stream_info(struct ctf_fs_ds_file_group *group, const bt2::MapValue groupInfo,
+                                 struct range *stream_range, const bt2c::Logger& logger)
 {
-    int ret = 0;
-    bt_value_map_insert_entry_status insert_status;
-    struct ctf_fs_ds_index_entry *first_ds_index_entry, *last_ds_index_entry;
-    bt2c::GCharUP port_name;
-
     /*
      * Since each `struct ctf_fs_ds_file_group` has a sorted array of
      * `struct ctf_fs_ds_index_entry`, we can compute the stream range from
@@ -201,11 +117,11 @@ static int populate_stream_info(struct ctf_fs_ds_file_group *group, bt_value *gr
     BT_ASSERT(group->index->entries->len > 0);
 
     /* First entry. */
-    first_ds_index_entry =
+    ctf_fs_ds_index_entry *first_ds_index_entry =
         (struct ctf_fs_ds_index_entry *) g_ptr_array_index(group->index->entries, 0);
 
     /* Last entry. */
-    last_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
+    ctf_fs_ds_index_entry *last_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
         group->index->entries, group->index->entries->len - 1);
 
     stream_range->begin_ns = first_ds_index_entry->timestamp_begin_ns;
@@ -219,195 +135,112 @@ static int populate_stream_info(struct ctf_fs_ds_file_group *group, bt_value *gr
     stream_range->set =
         stream_range->begin_ns != UINT64_C(-1) && stream_range->end_ns != UINT64_C(-1);
 
-    ret = add_range(group_info, stream_range, "range-ns");
-    if (ret) {
-        goto end;
-    }
+    add_range(groupInfo, stream_range, "range-ns");
 
-    port_name = ctf_fs_make_port_name(group);
-    if (!port_name) {
-        ret = -1;
-        goto end;
+    bt2c::GCharUP portName = ctf_fs_make_port_name(group);
+    if (!portName) {
+        BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error, "Failed to make port name");
     }
 
-    insert_status = bt_value_map_insert_string_entry(group_info, "port-name", port_name.get());
-    if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
-        ret = -1;
-        goto end;
-    }
-
-end:
-    return ret;
+    groupInfo.insert("port-name", portName.get());
 }
 
-static int populate_trace_info(const struct ctf_fs_trace *trace, bt_value *trace_info,
-                               const bt2c::Logger& logger)
+static void populate_trace_info(const struct ctf_fs_trace *trace, const bt2::MapValue traceInfo,
+                                const bt2c::Logger& logger)
 {
-    int ret = 0;
-    size_t group_idx;
-    bt_value_map_insert_entry_status insert_status;
-    bt_value_array_append_element_status append_status;
-    bt_value *file_groups = NULL;
-
     BT_ASSERT(trace->ds_file_groups);
     /* Add trace range info only if it contains streams. */
     if (trace->ds_file_groups->len == 0) {
-        ret = -1;
-        BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "Trace has no streams: trace-path={}",
-                                     trace->path->str);
-        goto end;
+        BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(
+            logger, bt2::Error, "Trace has no streams: trace-path={}", trace->path->str);
     }
 
-    insert_status = bt_value_map_insert_empty_array_entry(trace_info, "stream-infos", &file_groups);
-    if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
-        ret = -1;
-        goto end;
-    }
+    const auto fileGroups = traceInfo.insertEmptyArray("stream-infos");
 
     /* Find range of all stream groups, and of the trace. */
-    for (group_idx = 0; group_idx < trace->ds_file_groups->len; group_idx++) {
-        bt_value *group_info;
+    for (size_t group_idx = 0; group_idx < trace->ds_file_groups->len; group_idx++) {
         range group_range;
         ctf_fs_ds_file_group *group =
             (ctf_fs_ds_file_group *) g_ptr_array_index(trace->ds_file_groups, group_idx);
 
-        append_status = bt_value_array_append_empty_map_element(file_groups, &group_info);
-        if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
-            ret = -1;
-            goto end;
-        }
-
-        ret = populate_stream_info(group, group_info, &group_range);
-        if (ret) {
-            goto end;
-        }
+        const auto groupInfo = fileGroups.appendEmptyMap();
+        populate_stream_info(group, groupInfo, &group_range, logger);
     }
-
-end:
-    return ret;
 }
 
-bt_component_class_query_method_status
-trace_infos_query(const bt_value *params, const bt2c::Logger& logger, const bt_value **user_result)
+bt2::Value::Shared trace_infos_query(const bt2::ConstMapValue params, const bt2c::Logger& logger)
 {
-    ctf_fs_component::UP ctf_fs;
-    bt_component_class_query_method_status status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
-    bt_value *result = NULL;
-    const bt_value *inputs_value = NULL;
-    const bt_value *trace_name_value;
-    int ret = 0;
-    bt_value *trace_info = NULL;
-    bt_value_array_append_element_status append_status;
-
-    BT_ASSERT(params);
-
-    if (!bt_value_is_map(params)) {
-        BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "Query parameters is not a map value object.");
-        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
-        goto error;
-    }
-
-    ctf_fs = ctf_fs_component_create(logger);
+    ctf_fs_component::UP ctf_fs = ctf_fs_component_create(logger);
     if (!ctf_fs) {
-        goto error;
-    }
-
-    if (!read_src_fs_parameters(params, &inputs_value, &trace_name_value, ctf_fs.get())) {
-        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
-        goto error;
+        BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error,
+                                               "Cannot create ctf_fs_component");
     }
 
-    if (ctf_fs_component_create_ctf_fs_trace(ctf_fs.get(), inputs_value, trace_name_value, NULL)) {
-        goto error;
-    }
-
-    result = bt_value_array_create();
-    if (!result) {
-        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
-        goto error;
-    }
+    const bt_value *inputs_value = NULL;
+    const bt_value *trace_name_value;
 
-    append_status = bt_value_array_append_empty_map_element(result, &trace_info);
-    if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
-        BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "Failed to create trace info map.");
-        goto error;
+    if (!read_src_fs_parameters(params.libObjPtr(), &inputs_value, &trace_name_value,
+                                ctf_fs.get())) {
+        BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error, "Failed to read parameters");
     }
 
-    ret = populate_trace_info(ctf_fs->trace, trace_info, logger);
-    if (ret) {
-        goto error;
+    if (ctf_fs_component_create_ctf_fs_trace(ctf_fs.get(), inputs_value, trace_name_value, NULL)) {
+        BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error, "Failed to create trace");
     }
 
-    goto end;
-
-error:
-    BT_VALUE_PUT_REF_AND_RESET(result);
-
-    if (status >= 0) {
-        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
-    }
+    const auto result = bt2::ArrayValue::create();
+    const auto traceInfo = result->appendEmptyMap();
+    populate_trace_info(ctf_fs->trace, traceInfo, logger);
 
-end:
-    *user_result = result;
-    return status;
+    return result;
 }
 
-bt_component_class_query_method_status
-support_info_query(const bt_value *params, const bt2c::Logger& logger, const bt_value **user_result)
+bt2::Value::Shared support_info_query(const bt2::ConstMapValue params, const bt2c::Logger& logger)
 {
-    const bt_value *input_type_value;
-    const char *input_type;
-    bt_component_class_query_method_status status;
-    bt_value_map_insert_entry_status insert_entry_status;
-    double weight = 0;
-    bt2c::GCharUP metadata_path;
-    bt_value *result = NULL;
-    ctf_metadata_decoder_up metadata_decoder;
-    FILE *metadata_file = NULL;
-    char uuid_str[BT_UUID_STR_LEN + 1];
-    bool has_uuid = false;
-    const bt_value *input_value;
-    const char *input;
-
-    input_type_value = bt_value_map_borrow_entry_value_const(params, "type");
-    BT_ASSERT(input_type_value);
-    BT_ASSERT(bt_value_get_type(input_type_value) == BT_VALUE_TYPE_STRING);
-    input_type = bt_value_string_get(input_type_value);
+    const auto typeValue = params["type"];
+    BT_ASSERT(typeValue);
+    BT_ASSERT(typeValue->isString());
+    const auto type = typeValue->asString().value();
 
-    if (strcmp(input_type, "directory") != 0) {
-        goto create_result;
+    if (strcmp(type, "directory") != 0) {
+        const auto result = bt2::MapValue::create();
+        result->insert("weight", 0.0f);
+        return result;
     }
 
-    input_value = bt_value_map_borrow_entry_value_const(params, "input");
-    BT_ASSERT(input_value);
-    BT_ASSERT(bt_value_get_type(input_value) == BT_VALUE_TYPE_STRING);
-    input = bt_value_string_get(input_value);
+    const auto inputValue = params["input"];
+    BT_ASSERT(inputValue);
+    BT_ASSERT(inputValue->isString());
+    const auto input = inputValue->asString().value();
 
-    metadata_path.reset(g_build_filename(input, CTF_FS_METADATA_FILENAME, NULL));
-    if (!metadata_path) {
-        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
-        goto end;
+    bt2c::GCharUP metadataPath {g_build_filename(input, CTF_FS_METADATA_FILENAME, NULL)};
+    if (!metadataPath) {
+        BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error, "Failed to read parameters");
     }
 
-    metadata_file = g_fopen(metadata_path.get(), "rb");
-    if (metadata_file) {
+    double weight = 0;
+    char uuid_str[BT_UUID_STR_LEN + 1];
+    bool has_uuid = false;
+    bt2c::FileUP metadataFile {g_fopen(metadataPath.get(), "rb")};
+    if (metadataFile) {
         enum ctf_metadata_decoder_status decoder_status;
         bt_uuid_t uuid;
 
         ctf_metadata_decoder_config metadata_decoder_config {logger};
 
-        metadata_decoder = ctf_metadata_decoder_create(&metadata_decoder_config);
+        ctf_metadata_decoder_up metadata_decoder =
+            ctf_metadata_decoder_create(&metadata_decoder_config);
         if (!metadata_decoder) {
-            status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
-            goto end;
+            BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error,
+                                                   "Failed to create metadata decoder");
         }
 
-        decoder_status = ctf_metadata_decoder_append_content(metadata_decoder.get(), metadata_file);
+        decoder_status =
+            ctf_metadata_decoder_append_content(metadata_decoder.get(), metadataFile.get());
         if (decoder_status != CTF_METADATA_DECODER_STATUS_OK) {
-            BT_CPPLOGW_SPEC(logger, "cannot append metadata content: metadata-decoder-status={}",
-                            decoder_status);
-            status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
-            goto end;
+            BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(
+                logger, bt2::Error, "Failed to append metadata content: metadata-decoder-status={}",
+                decoder_status);
         }
 
         /*
@@ -423,36 +256,15 @@ support_info_query(const bt_value *params, const bt2c::Logger& logger, const bt_
         }
     }
 
-create_result:
-    result = bt_value_map_create();
-    if (!result) {
-        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
-        goto end;
-    }
-
-    insert_entry_status = bt_value_map_insert_real_entry(result, "weight", weight);
-    if (insert_entry_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
-        status = (bt_component_class_query_method_status) insert_entry_status;
-        goto end;
-    }
+    const auto result = bt2::MapValue::create();
+    result->insert("weight", weight);
 
     /* We are not supposed to have weight == 0 and a UUID. */
     BT_ASSERT(weight > 0 || !has_uuid);
 
     if (weight > 0 && has_uuid) {
-        insert_entry_status = bt_value_map_insert_string_entry(result, "group", uuid_str);
-        if (insert_entry_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
-            status = (bt_component_class_query_method_status) insert_entry_status;
-            goto end;
-        }
+        result->insert("group", uuid_str);
     }
 
-    *user_result = result;
-    result = NULL;
-    status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
-
-end:
-    bt_value_put_ref(result);
-
-    return status;
+    return result;
 }
diff --git a/src/plugins/ctf/fs-src/query.hpp b/src/plugins/ctf/fs-src/query.hpp
index 1745c751..2c7aca09 100644
--- a/src/plugins/ctf/fs-src/query.hpp
+++ b/src/plugins/ctf/fs-src/query.hpp
@@ -9,7 +9,7 @@
 #ifndef BABELTRACE_PLUGIN_CTF_FS_QUERY_H
 #define BABELTRACE_PLUGIN_CTF_FS_QUERY_H
 
-#include <babeltrace2/babeltrace.h>
+#include "cpp-common/bt2/value.hpp"
 
 namespace bt2c {
 
@@ -17,13 +17,10 @@ class Logger;
 
 } /* namespace bt2c */
 
-bt_component_class_query_method_status
-metadata_info_query(const bt_value *params, const bt2c::Logger& logger, const bt_value **result);
+bt2::Value::Shared metadata_info_query(bt2::ConstMapValue params, const bt2c::Logger& logger);
 
-bt_component_class_query_method_status
-trace_infos_query(const bt_value *params, const bt2c::Logger& logger, const bt_value **result);
+bt2::Value::Shared trace_infos_query(bt2::ConstMapValue params, const bt2c::Logger& logger);
 
-bt_component_class_query_method_status
-support_info_query(const bt_value *params, const bt2c::Logger& logger, const bt_value **result);
+bt2::Value::Shared support_info_query(bt2::ConstMapValue params, const bt2c::Logger& logger);
 
 #endif /* BABELTRACE_PLUGIN_CTF_FS_QUERY_H */