feat: add http interface to get a specified config

include/dsn/utility/flags.h

@@ -118,4 +118,7 @@ extern bool has_tag(const std::string &name, const flag_tag &tag);
 
 // list all the flags
 extern std::string list_all_flags();
+
+// get the json string of a specified flag
+extern error_with<std::string> get_flag_str(const std::string &flag_name);
 } // namespace dsn

src/http/builtin_http_calls.cpp

@@ -78,6 +78,10 @@ namespace dsn {
             [](const http_request &req, http_response &resp) { update_config(req, resp); })
         .with_help("Updates the value of a config");
 
+    register_http_call("config")
+        .with_callback([](const http_request &req, http_response &resp) { get_config(req, resp); })
+        .with_help("get the details of a specified config");
+
     register_http_call("configs")
         .with_callback(
             [](const http_request &req, http_response &resp) { list_all_configs(req, resp); })

src/http/builtin_http_calls.h

@@ -36,4 +36,5 @@ extern void update_config(const http_request &req, http_response &resp);
 
 extern void list_all_configs(const http_request &req, http_response &resp);
 
+extern void get_config(const http_request &req, http_response &resp);
 } // namespace dsn

src/http/config_http_service.cpp

@@ -48,4 +48,25 @@ void list_all_configs(const http_request &req, http_response &resp)
     resp.body = list_all_flags();
     resp.status_code = http_status_code::ok;
 }
+
+void get_config(const http_request &req, http_response &resp)
+{
+    std::string config_name;
+    for (const auto &p : req.query_args) {
+        if ("name" == p.first) {
+            config_name = p.second;
+        } else {
+            resp.status_code = http_status_code::bad_request;
+            return;
+        }
+    }
+
+    auto res = get_flag_str(config_name);
+    if (res.is_ok()) {
+        resp.body = res.get_value();
+    } else {
+        resp.body = res.get_error().description();
+    }
+    resp.status_code = http_status_code::ok;
+}
 } // namespace dsn

src/utils/flags.cpp

@@ -215,6 +215,16 @@ class flag_registry : public utils::singleton<flag_registry>
         return it->second.has_tag(tag);
     }
 
+    error_with<std::string> get_flag_str(const std::string &name) const
+    {
+        const auto iter = _flags.find(name);
+        if (iter == _flags.end()) {
+            return error_s::make(ERR_OBJECT_NOT_FOUND, fmt::format("{} is not found", name));
+        }
+
+        return iter->second.to_json();
+    }
+
     std::string list_all_flags() const
     {
         utils::table_printer tp;
@@ -272,6 +282,11 @@ flag_tagger::flag_tagger(const char *name, const flag_tag &tag)
     return flag_registry::instance().has_tag(name, tag);
 }
 
+/*extern*/ error_with<std::string> get_flag_str(const std::string &flag_name)
+{
+    return flag_registry::instance().get_flag_str(flag_name);
+}
+
 /*extern*/ std::string list_all_flags() { return flag_registry::instance().list_all_flags(); }
 
 } // namespace dsn

src/utils/test/flag_test.cpp

@@ -120,5 +120,89 @@ TEST(flag_test, tag_flag)
     res = has_tag("no_flag", flag_tag::FT_MUTABLE);
     ASSERT_FALSE(res);
 }
+
+DSN_DEFINE_int32("flag_test", get_flag_int32, 5, "test get_flag_int32");
+DSN_TAG_VARIABLE(get_flag_int32, FT_MUTABLE);
+DSN_DEFINE_uint32("flag_test", get_flag_uint32, 5, "test get_flag_uint32");
+DSN_TAG_VARIABLE(get_flag_uint32, FT_MUTABLE);
+DSN_DEFINE_int64("flag_test", get_flag_int64, 5, "test get_flag_int64");
+DSN_TAG_VARIABLE(get_flag_int64, FT_MUTABLE);
+DSN_DEFINE_uint64("flag_test", get_flag_uint64, 5, "test get_flag_uint64");
+DSN_TAG_VARIABLE(get_flag_uint64, FT_MUTABLE);
+DSN_DEFINE_double("flag_test", get_flag_double, 5.12, "test get_flag_double");
+DSN_TAG_VARIABLE(get_flag_double, FT_MUTABLE);
+DSN_DEFINE_bool("flag_test", get_flag_bool, true, "test get_flag_bool");
+DSN_TAG_VARIABLE(get_flag_bool, FT_MUTABLE);
+DSN_DEFINE_string("flag_test", get_flag_string, "flag_string", "test get_flag_string");
+DSN_TAG_VARIABLE(get_flag_string, FT_MUTABLE);
+
+TEST(flag_test, get_config)
+{
+    auto res = get_flag_str("get_flag_not_exist");
+    ASSERT_EQ(res.get_error().code(), ERR_OBJECT_NOT_FOUND);
+
+    std::string test_app = "get_flag_int32";
+    res = get_flag_str(test_app);
+    ASSERT_TRUE(res.is_ok());
+    ASSERT_EQ(
+        res.get_value(),
+        R"({"name":")" + test_app +
+            R"(","section":"flag_test","type":"FV_INT32","tags":"flag_tag::FT_MUTABLE","description":"test get_flag_int32","value":")" +
+            std::to_string(FLAGS_get_flag_int32) + R"("})" + "\n");
+
+    test_app = "get_flag_uint32";
+    res = get_flag_str(test_app);
+    ASSERT_TRUE(res.is_ok());
+    ASSERT_EQ(
+        res.get_value(),
+        R"({"name":")" + test_app +
+            R"(","section":"flag_test","type":"FV_UINT32","tags":"flag_tag::FT_MUTABLE","description":"test get_flag_uint32","value":")" +
+            std::to_string(FLAGS_get_flag_uint32) + R"("})" + "\n");
+
+    test_app = "get_flag_int64";
+    res = get_flag_str(test_app);
+    ASSERT_TRUE(res.is_ok());
+    ASSERT_EQ(
+        res.get_value(),
+        R"({"name":")" + test_app +
+            R"(","section":"flag_test","type":"FV_INT64","tags":"flag_tag::FT_MUTABLE","description":"test get_flag_int64","value":")" +
+            std::to_string(FLAGS_get_flag_int64) + R"("})" + "\n");
+
+    test_app = "get_flag_uint64";
+    res = get_flag_str(test_app);
+    ASSERT_TRUE(res.is_ok());
+    ASSERT_EQ(
+        res.get_value(),
+        R"({"name":")" + test_app +
+            R"(","section":"flag_test","type":"FV_UINT64","tags":"flag_tag::FT_MUTABLE","description":"test get_flag_uint64","value":")" +
+            std::to_string(FLAGS_get_flag_uint64) + R"("})" + "\n");
+
+    test_app = "get_flag_double";
+    res = get_flag_str(test_app);
+    ASSERT_TRUE(res.is_ok());
+    ASSERT_EQ(
+        res.get_value(),
+        R"({"name":")" + test_app +
+            R"(","section":"flag_test","type":"FV_DOUBLE","tags":"flag_tag::FT_MUTABLE","description":"test get_flag_double","value":"5.12"})" +
+            "\n");
+
+    test_app = "get_flag_bool";
+    res = get_flag_str(test_app);
+    ASSERT_TRUE(res.is_ok());
+    ASSERT_EQ(
+        res.get_value(),
+        R"({"name":")" + test_app +
+            R"(","section":"flag_test","type":"FV_BOOL","tags":"flag_tag::FT_MUTABLE","description":"test get_flag_bool","value":"true"})"
+            "\n");
+
+    test_app = "get_flag_string";
+    res = get_flag_str(test_app);
+    ASSERT_TRUE(res.is_ok());
+    ASSERT_EQ(
+        res.get_value(),
+        R"({"name":")" + test_app +
+            R"(","section":"flag_test","type":"FV_STRING","tags":"flag_tag::FT_MUTABLE","description":"test get_flag_string","value":")" +
+            FLAGS_get_flag_string + R"("})" + "\n");
+}
 } // namespace utils
 } // namespace dsn