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& UsingProtocol(std::string protocol);
+    MooncakeStoreBuilder& WithRdmaDeviceNames(std::string device_names);
+    MooncakeStoreBuilder& WithMasterServerEntry(
+        std::string master_server_entry);
+    MooncakeStoreBuilder& WithExistingTransferEngine(
+        std::shared_ptr<TransferEngine> transfer_engine);
+
+    [[nodiscard]] std::optional<std::shared_ptr<Client>> Build();
+
+   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,6 +82,7 @@ class PyClient {
     // Factory to create shared instances and auto-register to ResourceTracker
     static std::shared_ptr<PyClient> create();
 
+    [[deprecated("Use MooncakeStoreBuilder instead")]]
     int setup(const std::string &local_hostname,
               const std::string &metadata_server,
               size_t global_segment_size = 1024 * 1024 * 16,

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,74 @@ 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::UsingProtocol(
+    std::string protocol) {
+    protocol_ = std::move(protocol);
+    return *this;
+}
+
+MooncakeStoreBuilder& MooncakeStoreBuilder::WithRdmaDeviceNames(
+    std::string device_names) {
+    if (device_names.empty()) {
+        device_names_.reset();
+    } else {
+        device_names_ = std::move(device_names);
+    }
+    return *this;
+}
+
+MooncakeStoreBuilder& MooncakeStoreBuilder::WithMasterServerEntry(
+    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;
+}
+
+std::optional<std::shared_ptr<Client>> MooncakeStoreBuilder::Build() {
+    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[i]);
+        }
+        LOG(ERROR) << "MooncakeStoreBuilder missing required fields: "
+                   << joined;
+        return std::nullopt;
+    }
+
+    return Client::Create(*local_hostname_, *metadata_connstring_, protocol_,
+                          device_names_, master_server_entry_,
+                          transfer_engine_);
+}
+
 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,20 @@ 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)
+        .UsingProtocol(protocol)
+        .WithMasterServerEntry(master_server_addr);
+
+    if (device_name) {
+        builder.WithRdmaDeviceNames(*device_name);
+    }
+    if (transfer_engine) {
+        builder.WithExistingTransferEngine(transfer_engine);
+    }
+
+    auto client_opt = builder.Build();
     if (!client_opt) {
         LOG(ERROR) << "Failed to create client";
         return tl::unexpected(ErrorCode::INVALID_PARAMS);