feat: Implement NoopAuthManager and integrate AuthManager into RestCatalog

Author: shuxu.li

src/iceberg/catalog/rest/auth/auth_managers.cc

@@ -33,7 +33,6 @@ namespace {
 using AuthManagerRegistry =
     std::unordered_map<std::string, AuthManagerFactory, StringHash, StringEqual>;
 
-/// \brief Known authentication types that are defined in the Iceberg spec.
 const std::unordered_set<std::string, StringHash, StringEqual>& KnownAuthTypes() {
   static const std::unordered_set<std::string, StringHash, StringEqual> kAuthTypes = {
       AuthProperties::kAuthTypeNone,
@@ -65,6 +64,12 @@ std::string InferAuthType(
 /// \brief Authentication manager that performs no authentication.
 class NoopAuthManager : public AuthManager {
  public:
+  static Result<std::unique_ptr<AuthManager>> Make(
+      [[maybe_unused]] std::string_view name,
+      [[maybe_unused]] const std::unordered_map<std::string, std::string>& properties) {
+    return std::make_unique<NoopAuthManager>();
+  }
+
   Result<std::shared_ptr<AuthSession>> CatalogSession(
       [[maybe_unused]] HttpClient& client,
       [[maybe_unused]] const std::unordered_map<std::string, std::string>& properties)
@@ -73,18 +78,22 @@ class NoopAuthManager : public AuthManager {
   }
 };
 
+template <typename T>
+AuthManagerFactory MakeAuthFactory() {
+  return []([[maybe_unused]] std::string_view name,
+            [[maybe_unused]] const std::unordered_map<std::string, std::string>& props)
+             -> Result<std::unique_ptr<AuthManager>> { return T::Make(name, props); };
+}
+
+AuthManagerRegistry CreateDefaultRegistry() {
+  return {
+      {AuthProperties::kAuthTypeNone, MakeAuthFactory<NoopAuthManager>()},
+  };
+}
+
 // Get the global registry of auth manager factories.
 AuthManagerRegistry& GetRegistry() {
-  static AuthManagerRegistry registry = [] {
-    AuthManagerRegistry r;
-    r[AuthProperties::kAuthTypeNone] =
-        []([[maybe_unused]] std::string_view name,
-           [[maybe_unused]] const std::unordered_map<std::string, std::string>& props)
-        -> Result<std::unique_ptr<AuthManager>> {
-      return std::make_unique<NoopAuthManager>();
-    };
-    return r;
-  }();
+  static AuthManagerRegistry registry = CreateDefaultRegistry();
   return registry;
 }
 

src/iceberg/catalog/rest/http_client.cc

@@ -22,6 +22,7 @@
 #include <cpr/cpr.h>
 #include <nlohmann/json.hpp>
 
+#include "iceberg/catalog/rest/auth/auth_session.h"
 #include "iceberg/catalog/rest/constant.h"
 #include "iceberg/catalog/rest/error_handlers.h"
 #include "iceberg/catalog/rest/json_serde_internal.h"
@@ -146,11 +147,21 @@ HttpClient::HttpClient(std::unordered_map<std::string, std::string> default_head
 
 HttpClient::~HttpClient() = default;
 
+void HttpClient::SetAuthSession(auth::AuthSession* session) { session_ = session; }
+
+Result<std::unordered_map<std::string, std::string>> HttpClient::AuthHeaders() {
+  std::unordered_map<std::string, std::string> headers;
+  if (session_) {
+    ICEBERG_RETURN_UNEXPECTED(session_->Authenticate(headers));
+  }
+  return headers;
+}
+
 Result<HttpResponse> HttpClient::Get(
     const std::string& path, const std::unordered_map<std::string, std::string>& params,
-    const std::unordered_map<std::string, std::string>& headers,
     const ErrorHandler& error_handler) {
-  auto final_headers = MergeHeaders(default_headers_, headers);
+  ICEBERG_ASSIGN_OR_RAISE(auto auth_headers, AuthHeaders());
+  auto final_headers = MergeHeaders(default_headers_, auth_headers);
   cpr::Response response =
       cpr::Get(cpr::Url{path}, GetParameters(params), final_headers, *connection_pool_);
 
@@ -160,11 +171,10 @@ Result<HttpResponse> HttpClient::Get(
   return http_response;
 }
 
-Result<HttpResponse> HttpClient::Post(
-    const std::string& path, const std::string& body,
-    const std::unordered_map<std::string, std::string>& headers,
-    const ErrorHandler& error_handler) {
-  auto final_headers = MergeHeaders(default_headers_, headers);
+Result<HttpResponse> HttpClient::Post(const std::string& path, const std::string& body,
+                                      const ErrorHandler& error_handler) {
+  ICEBERG_ASSIGN_OR_RAISE(auto auth_headers, AuthHeaders());
+  auto final_headers = MergeHeaders(default_headers_, auth_headers);
   cpr::Response response =
       cpr::Post(cpr::Url{path}, cpr::Body{body}, final_headers, *connection_pool_);
 
@@ -177,9 +187,9 @@ Result<HttpResponse> HttpClient::Post(
 Result<HttpResponse> HttpClient::PostForm(
     const std::string& path,
     const std::unordered_map<std::string, std::string>& form_data,
-    const std::unordered_map<std::string, std::string>& headers,
     const ErrorHandler& error_handler) {
-  auto final_headers = MergeHeaders(default_headers_, headers);
+  ICEBERG_ASSIGN_OR_RAISE(auto auth_headers, AuthHeaders());
+  auto final_headers = MergeHeaders(default_headers_, auth_headers);
   final_headers.insert_or_assign(kHeaderContentType, kMimeTypeFormUrlEncoded);
   std::vector<cpr::Pair> pair_list;
   pair_list.reserve(form_data.size());
@@ -196,10 +206,10 @@ Result<HttpResponse> HttpClient::PostForm(
   return http_response;
 }
 
-Result<HttpResponse> HttpClient::Head(
-    const std::string& path, const std::unordered_map<std::string, std::string>& headers,
-    const ErrorHandler& error_handler) {
-  auto final_headers = MergeHeaders(default_headers_, headers);
+Result<HttpResponse> HttpClient::Head(const std::string& path,
+                                      const ErrorHandler& error_handler) {
+  ICEBERG_ASSIGN_OR_RAISE(auto auth_headers, AuthHeaders());
+  auto final_headers = MergeHeaders(default_headers_, auth_headers);
   cpr::Response response = cpr::Head(cpr::Url{path}, final_headers, *connection_pool_);
 
   ICEBERG_RETURN_UNEXPECTED(HandleFailureResponse(response, error_handler));
@@ -210,9 +220,9 @@ Result<HttpResponse> HttpClient::Head(
 
 Result<HttpResponse> HttpClient::Delete(
     const std::string& path, const std::unordered_map<std::string, std::string>& params,
-    const std::unordered_map<std::string, std::string>& headers,
     const ErrorHandler& error_handler) {
-  auto final_headers = MergeHeaders(default_headers_, headers);
+  ICEBERG_ASSIGN_OR_RAISE(auto auth_headers, AuthHeaders());
+  auto final_headers = MergeHeaders(default_headers_, auth_headers);
   cpr::Response response = cpr::Delete(cpr::Url{path}, GetParameters(params),
                                        final_headers, *connection_pool_);
 

src/iceberg/catalog/rest/http_client.h

@@ -78,38 +78,39 @@ class ICEBERG_REST_EXPORT HttpClient {
   HttpClient(HttpClient&&) = delete;
   HttpClient& operator=(HttpClient&&) = delete;
 
+  /// \brief Set the authentication session
+  void SetAuthSession(auth::AuthSession* session);
+
   /// \brief Sends a GET request.
   Result<HttpResponse> Get(const std::string& path,
                            const std::unordered_map<std::string, std::string>& params,
-                           const std::unordered_map<std::string, std::string>& headers,
                            const ErrorHandler& error_handler);
 
   /// \brief Sends a POST request.
   Result<HttpResponse> Post(const std::string& path, const std::string& body,
-                            const std::unordered_map<std::string, std::string>& headers,
                             const ErrorHandler& error_handler);
 
   /// \brief Sends a POST request with form data.
   Result<HttpResponse> PostForm(
       const std::string& path,
       const std::unordered_map<std::string, std::string>& form_data,
-      const std::unordered_map<std::string, std::string>& headers,
       const ErrorHandler& error_handler);
 
   /// \brief Sends a HEAD request.
-  Result<HttpResponse> Head(const std::string& path,
-                            const std::unordered_map<std::string, std::string>& headers,
-                            const ErrorHandler& error_handler);
+  Result<HttpResponse> Head(const std::string& path, const ErrorHandler& error_handler);
 
   /// \brief Sends a DELETE request.
   Result<HttpResponse> Delete(const std::string& path,
                               const std::unordered_map<std::string, std::string>& params,
-                              const std::unordered_map<std::string, std::string>& headers,
                               const ErrorHandler& error_handler);
 
  private:
+  /// \brief Get authentication headers.
+  Result<std::unordered_map<std::string, std::string>> AuthHeaders();
+
   std::unordered_map<std::string, std::string> default_headers_;
   std::unique_ptr<cpr::ConnectionPool> connection_pool_;
+  auth::AuthSession* session_ = nullptr;
 };
 
 }  // namespace iceberg::rest