Add C++ builder pattern

mooncake-store/include/client.h

@@ -364,4 +364,34 @@ class Client {
     UUID client_id_;
 };
 
+/**
+ * @brief Fluent builder for configuring a mooncake::Client instance.
+ *
+ * Provides readable, type-safe setters with sensible defaults so callers can
+ * specify only the options they need while reusing existing Client::Create
+ * logic under the hood.
+ */
+class MooncakeStoreBuilder {
+   public:
+    MooncakeStoreBuilder& WithLocalHostname(std::string local_hostname);
+    MooncakeStoreBuilder& WithMetadataConnectionString(
+        std::string metadata_connstring);
+    MooncakeStoreBuilder& WithProtocol(std::string protocol);
+    MooncakeStoreBuilder& WithTransferEngineArgs(std::string engine_args);
+    MooncakeStoreBuilder& WithMasterEndpoint(std::string master_server_entry);
+    MooncakeStoreBuilder& WithExistingTransferEngine(
+        std::shared_ptr<TransferEngine> transfer_engine);
+
+    [[nodiscard]] tl::expected<std::shared_ptr<Client>, std::string> Build()
+        const;
+
+   private:
+    std::optional<std::string> local_hostname_;
+    std::optional<std::string> metadata_connstring_;
+    std::string protocol_ = "tcp";
+    std::optional<std::string> device_names_;
+    std::string master_server_entry_ = kDefaultMasterAddress;
+    std::shared_ptr<TransferEngine> transfer_engine_ = nullptr;
+};
+
 }  // namespace mooncake

mooncake-store/include/pybind_client.h

@@ -82,14 +82,14 @@ class PyClient {
     // Factory to create shared instances and auto-register to ResourceTracker
     static std::shared_ptr<PyClient> create();
 
-    int setup(const std::string &local_hostname,
-              const std::string &metadata_server,
-              size_t global_segment_size = 1024 * 1024 * 16,
-              size_t local_buffer_size = 1024 * 1024 * 16,
-              const std::string &protocol = "tcp",
-              const std::string &rdma_devices = "",
-              const std::string &master_server_addr = "127.0.0.1:50051",
-              const std::shared_ptr<TransferEngine> &transfer_engine = nullptr);
+    [[deprecated("Use MooncakeStoreBuilder instead")]] int setup(
+        const std::string &local_hostname, const std::string &metadata_server,
+        size_t global_segment_size = 1024 * 1024 * 16,
+        size_t local_buffer_size = 1024 * 1024 * 16,
+        const std::string &protocol = "tcp",
+        const std::string &rdma_devices = "",
+        const std::string &master_server_addr = "127.0.0.1:50051",
+        const std::shared_ptr<TransferEngine> &transfer_engine = nullptr);
 
     int initAll(const std::string &protocol, const std::string &device_name,
                 size_t mount_segment_size = 1024 * 1024 * 16);  // Default 16MB

mooncake-store/src/client.cpp

@@ -7,6 +7,7 @@
 #include <chrono>
 #include <cstdint>
 #include <cstdlib>
+#include <string_view>
 #include <optional>
 #include <ranges>
 #include <thread>
@@ -406,6 +407,80 @@ std::optional<std::shared_ptr<Client>> Client::Create(
     return client;
 }
 
+MooncakeStoreBuilder& MooncakeStoreBuilder::WithLocalHostname(
+    std::string local_hostname) {
+    local_hostname_ = std::move(local_hostname);
+    return *this;
+}
+
+MooncakeStoreBuilder& MooncakeStoreBuilder::WithMetadataConnectionString(
+    std::string metadata_connstring) {
+    metadata_connstring_ = std::move(metadata_connstring);
+    return *this;
+}
+
+MooncakeStoreBuilder& MooncakeStoreBuilder::WithProtocol(std::string protocol) {
+    protocol_ = std::move(protocol);
+    return *this;
+}
+
+MooncakeStoreBuilder& MooncakeStoreBuilder::WithTransferEngineArgs(
+    std::string engine_args) {
+    // Can add some other engine arguments
+    device_names_ = std::move(engine_args);
+    return *this;
+}
+
+MooncakeStoreBuilder& MooncakeStoreBuilder::WithMasterEndpoint(
+    std::string master_server_entry) {
+    master_server_entry_ = std::move(master_server_entry);
+    return *this;
+}
+
+MooncakeStoreBuilder& MooncakeStoreBuilder::WithExistingTransferEngine(
+    std::shared_ptr<TransferEngine> transfer_engine) {
+    transfer_engine_ = std::move(transfer_engine);
+    return *this;
+}
+
+tl::expected<std::shared_ptr<Client>, std::string> MooncakeStoreBuilder::Build()
+    const {
+    std::vector<std::string_view> missing;
+    if (!local_hostname_) {
+        missing.emplace_back("local_hostname");
+    }
+    if (!metadata_connstring_) {
+        missing.emplace_back("metadata_connstring");
+    }
+
+    if (!missing.empty()) {
+        std::string joined;
+        joined.reserve(missing.size() * 16);
+        for (size_t i = 0; i < missing.size(); ++i) {
+            if (i != 0) {
+                joined.append(", ");
+            }
+            joined.append(missing[0]);
+            for (size_t i = 1; i < missing.size(); ++i) {
+                joined.append(", ");
+                joined.append(missing[i]);
+            }
+        }
+        auto error_msg =
+            "MooncakeStoreBuilder missing required fields: " + joined;
+        LOG(ERROR) << error_msg;
+        return tl::make_unexpected(std::move(error_msg));
+    }
+    auto client =
+        Client::Create(*local_hostname_, *metadata_connstring_, protocol_,
+                       device_names_, master_server_entry_, transfer_engine_);
+    if (!client) {
+        std::string error_msg = "Client creation failed";
+        return tl::make_unexpected(std::move(error_msg));
+    }
+    return *client;
+}
+
 tl::expected<void, ErrorCode> Client::Get(const std::string& object_key,
                                           std::vector<Slice>& slices) {
     auto query_result = Query(object_key);

mooncake-store/src/pybind_client.cpp

@@ -178,9 +178,27 @@ tl::expected<void, ErrorCode> PyClient::setup_internal(
         (rdma_devices.empty() ? std::nullopt
                               : std::make_optional(rdma_devices));
 
-    auto client_opt = mooncake::Client::Create(
-        this->local_hostname, metadata_server, protocol, device_name,
-        master_server_addr, transfer_engine);
+    MooncakeStoreBuilder builder;
+    builder.WithLocalHostname(this->local_hostname)
+        .WithMetadataConnectionString(metadata_server)
+        .WithProtocol(protocol)
+        .WithMasterEndpoint(master_server_addr);
+
+    if (device_name) {
+        builder.WithTransferEngineArgs(*device_name);
+    }
+    if (transfer_engine) {
+        builder.WithExistingTransferEngine(transfer_engine);
+    }
+
+    auto client_opt = MooncakeStoreBuilder()
+                          .WithLocalHostname(this->local_hostname)
+                          .WithMetadataConnectionString(metadata_server)
+                          .WithProtocol(protocol)
+                          .WithMasterEndpoint(master_server_addr)
+                          .WithTransferEngineArgs(device_name.value_or(""))
+                          .WithExistingTransferEngine(transfer_engine)
+                          .Build();
     if (!client_opt) {
         LOG(ERROR) << "Failed to create client";
         return tl::unexpected(ErrorCode::INVALID_PARAMS);

mooncake-store/tests/CMakeLists.txt

@@ -32,6 +32,7 @@ add_store_test(serializer_test serializer_test.cpp)
 add_store_test(non_ha_reconnect_test non_ha_reconnect_test.cpp)
 add_store_test(storage_backend_test storage_backend_test.cpp)
 add_store_test(mutex_test mutex_test.cpp)
+add_store_test(builder_test builder_test.cpp)
 add_subdirectory(e2e)
 
 add_executable(high_availability_test high_availability_test.cpp)

mooncake-store/tests/builder_test.cpp

@@ -0,0 +1,70 @@
+#include <glog/logging.h>
+#include <gtest/gtest.h>
+
+#include "client.h"
+
+namespace mooncake::test {
+
+class MooncakeStoreBuilderTest : public ::testing::Test {
+   protected:
+    void SetUp() override {
+        google::InitGoogleLogging("MooncakeStoreBuilderTest");
+        FLAGS_logtostderr = true;
+    }
+
+    void TearDown() override { google::ShutdownGoogleLogging(); }
+};
+
+TEST_F(MooncakeStoreBuilderTest, MissingAllRequiredFields) {
+    MooncakeStoreBuilder builder;
+
+    auto result = builder.Build();
+
+    ASSERT_FALSE(result.has_value());
+    const std::string& error = result.error();
+    EXPECT_NE(error.find("local_hostname"), std::string::npos);
+    EXPECT_NE(error.find("metadata_connstring"), std::string::npos);
+}
+
+TEST_F(MooncakeStoreBuilderTest, MissingLocalHostnameOnly) {
+    MooncakeStoreBuilder builder;
+    builder.WithMetadataConnectionString("metastore:1234");
+
+    auto result = builder.Build();
+
+    ASSERT_FALSE(result.has_value());
+    const std::string& error = result.error();
+    EXPECT_NE(error.find("local_hostname"), std::string::npos);
+    EXPECT_EQ(error.find("metadata_connstring"), std::string::npos);
+}
+
+TEST_F(MooncakeStoreBuilderTest, MissingMetadataConnectionStringOnly) {
+    MooncakeStoreBuilder builder;
+    builder.WithLocalHostname("localhost:1234");
+
+    auto result = builder.Build();
+
+    ASSERT_FALSE(result.has_value());
+    const std::string& error = result.error();
+    EXPECT_NE(error.find("metadata_connstring"), std::string::npos);
+    EXPECT_EQ(error.find("local_hostname"), std::string::npos);
+}
+
+TEST_F(MooncakeStoreBuilderTest, ProvidedAllRequiredFields) {
+    MooncakeStoreBuilder builder;
+    builder.WithLocalHostname("localhost:1234");
+    builder.WithMetadataConnectionString("metadata:5678");
+
+    auto result = builder.Build();
+
+    if (result.has_value()) {
+        SUCCEED();
+    } else {
+        const std::string& error = result.error();
+        EXPECT_EQ(error.find("missing required fields"), std::string::npos);
+        EXPECT_EQ(error.find("local_hostname"), std::string::npos);
+        EXPECT_EQ(error.find("metadata_connstring"), std::string::npos);
+    }
+}
+
+}  // namespace mooncake::test