fix ci

Author: HeartLinked

src/iceberg/catalog/rest/CMakeLists.txt

@@ -18,9 +18,11 @@
 set(ICEBERG_REST_SOURCES
     rest_catalog.cc
     catalog_properties.cc
+    error_handlers.cc
     http_client.cc
     json_internal.cc
-    resource_paths.cc)
+    resource_paths.cc
+    rest_util.cc)
 
 set(ICEBERG_REST_STATIC_BUILD_INTERFACE_LIBS)
 set(ICEBERG_REST_SHARED_BUILD_INTERFACE_LIBS)

src/iceberg/catalog/rest/catalog_properties.cc

@@ -19,20 +19,24 @@
 
 #include "iceberg/catalog/rest/catalog_properties.h"
 
+#include <string_view>
+
 namespace iceberg::rest {
 
-std::unique_ptr<RestCatalogConfig> RestCatalogConfig::default_properties() {
-  return std::make_unique<RestCatalogConfig>();
+std::unique_ptr<RestCatalogProperties> RestCatalogProperties::default_properties() {
+  return std::unique_ptr<RestCatalogProperties>(new RestCatalogProperties());
 }
 
-std::unique_ptr<RestCatalogConfig> RestCatalogConfig::FromMap(
+std::unique_ptr<RestCatalogProperties> RestCatalogProperties::FromMap(
     const std::unordered_map<std::string, std::string>& properties) {
-  auto rest_catalog_config = std::make_unique<RestCatalogConfig>();
+  auto rest_catalog_config =
+      std::unique_ptr<RestCatalogProperties>(new RestCatalogProperties());
   rest_catalog_config->configs_ = properties;
   return rest_catalog_config;
 }
 
-std::unordered_map<std::string, std::string> RestCatalogConfig::ExtractHeaders() const {
+std::unordered_map<std::string, std::string> RestCatalogProperties::ExtractHeaders()
+    const {
   std::unordered_map<std::string, std::string> headers;
   constexpr std::string_view prefix = "header.";
   for (const auto& [key, value] : configs_) {
@@ -47,4 +51,12 @@ std::unordered_map<std::string, std::string> RestCatalogConfig::ExtractHeaders()
   return headers;
 }
 
+Result<std::string_view> RestCatalogProperties::Uri() const {
+  auto it = configs_.find(kUri.key());
+  if (it == configs_.end() || it->second.empty()) {
+    return InvalidArgument("Rest catalog configuration property 'uri' is required.");
+  }
+  return it->second;
+}
+
 }  // namespace iceberg::rest

src/iceberg/catalog/rest/catalog_properties.h

@@ -21,24 +21,23 @@
 
 #include <memory>
 #include <string>
-#include <string_view>
 #include <unordered_map>
 
-#include <cpr/cprtypes.h>
-
 #include "iceberg/catalog/rest/iceberg_rest_export.h"
+#include "iceberg/result.h"
 #include "iceberg/util/config.h"
 
 /// \file iceberg/catalog/rest/catalog_properties.h
-/// \brief RestCatalogConfig implementation for Iceberg REST API.
+/// \brief RestCatalogProperties implementation for Iceberg REST API.
 
 namespace iceberg::rest {
 
 /// \brief Configuration class for a REST Catalog.
-class ICEBERG_REST_EXPORT RestCatalogConfig : public ConfigBase<RestCatalogConfig> {
+class ICEBERG_REST_EXPORT RestCatalogProperties
+    : public ConfigBase<RestCatalogProperties> {
  public:
   template <typename T>
-  using Entry = const ConfigBase<RestCatalogConfig>::Entry<T>;
+  using Entry = const ConfigBase<RestCatalogProperties>::Entry<T>;
 
   /// \brief The URI of the REST catalog server.
   inline static Entry<std::string> kUri{"uri", ""};
@@ -49,18 +48,28 @@ class ICEBERG_REST_EXPORT RestCatalogConfig : public ConfigBase<RestCatalogConfi
   /// \brief The warehouse path.
   inline static Entry<std::string> kWarehouse{"warehouse", ""};
 
-  /// \brief Create a default RestCatalogConfig instance.
-  static std::unique_ptr<RestCatalogConfig> default_properties();
+  /// \brief The optional prefix for REST API paths.
+  inline static Entry<std::string> kPrefix{"prefix", ""};
+
+  /// \brief Create a default RestCatalogProperties instance.
+  static std::unique_ptr<RestCatalogProperties> default_properties();
 
-  /// \brief Create a RestCatalogConfig instance from a map of key-value pairs.
-  static std::unique_ptr<RestCatalogConfig> FromMap(
+  /// \brief Create a RestCatalogProperties instance from a map of key-value pairs.
+  static std::unique_ptr<RestCatalogProperties> FromMap(
       const std::unordered_map<std::string, std::string>& properties);
 
   /// \brief Returns HTTP headers to be added to every request.
   ///
   /// This includes any key prefixed with "header." in the properties.
   /// \return A map of headers with the prefix removed from the keys.
   std::unordered_map<std::string, std::string> ExtractHeaders() const;
+
+  /// \brief Get the URI of the REST catalog server.
+  /// \return The URI if configured, or an error if not set or empty.
+  Result<std::string_view> Uri() const;
+
+ private:
+  RestCatalogProperties() = default;
 };
 
 }  // namespace iceberg::rest

src/iceberg/catalog/rest/constant.h

@@ -34,6 +34,7 @@ inline const std::string kHeaderXClientVersion = "X-Client-Version";
 inline const std::string kHeaderUserAgent = "User-Agent";
 
 inline const std::string kMimeTypeApplicationJson = "application/json";
+inline const std::string kMimeTypeFormUrlEncoded = "application/x-www-form-urlencoded";
 inline const std::string kUserAgentPrefix = "iceberg-cpp/";
 inline const std::string kUserAgent = "iceberg-cpp/" ICEBERG_VERSION_STRING;
 

src/iceberg/catalog/rest/error_handlers.cc

@@ -0,0 +1,184 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "iceberg/catalog/rest/error_handlers.h"
+
+#include <string_view>
+
+namespace iceberg::rest {
+
+namespace {
+
+constexpr std::string_view kIllegalArgumentException = "IllegalArgumentException";
+constexpr std::string_view kNoSuchNamespaceException = "NoSuchNamespaceException";
+constexpr std::string_view kNamespaceNotEmptyException = "NamespaceNotEmptyException";
+
+}  // namespace
+
+const std::shared_ptr<DefaultErrorHandler>& DefaultErrorHandler::Instance() {
+  static const std::shared_ptr<DefaultErrorHandler> instance{new DefaultErrorHandler()};
+  return instance;
+}
+
+Status DefaultErrorHandler::Accept(const ErrorModel& error) const {
+  switch (error.code) {
+    case 400:
+      if (error.type == kIllegalArgumentException) {
+        return InvalidArgument(error.message);
+      }
+      return BadRequest("Malformed request: {}", error.message);
+    case 401:
+      return NotAuthorized("Not authorized: {}", error.message);
+    case 403:
+      return Forbidden("Forbidden: {}", error.message);
+    case 405:
+    case 406:
+      break;
+    case 500:
+      return InternalServerError("Server error: {}: {}", error.type, error.message);
+    case 501:
+      return NotSupported(error.message);
+    case 503:
+      return ServiceUnavailable("Service unavailable: {}", error.message);
+  }
+
+  return RestError("Unable to process: {}", error.message);
+}
+
+const std::shared_ptr<NamespaceErrorHandler>& NamespaceErrorHandler::Instance() {
+  static const std::shared_ptr<NamespaceErrorHandler> instance{
+      new NamespaceErrorHandler()};
+  return instance;
+}
+
+Status NamespaceErrorHandler::Accept(const ErrorModel& error) const {
+  switch (error.code) {
+    case 400:
+      if (error.type == kNamespaceNotEmptyException) {
+        return NamespaceNotEmpty(error.message);
+      }
+      return BadRequest("Malformed request: {}", error.message);
+    case 404:
+      return NoSuchNamespace(error.message);
+    case 409:
+      return AlreadyExists(error.message);
+    case 422:
+      return RestError("Unable to process: {}", error.message);
+  }
+
+  return DefaultErrorHandler::Accept(error);
+}
+
+const std::shared_ptr<DropNamespaceErrorHandler>& DropNamespaceErrorHandler::Instance() {
+  static const std::shared_ptr<DropNamespaceErrorHandler> instance{
+      new DropNamespaceErrorHandler()};
+  return instance;
+}
+
+Status DropNamespaceErrorHandler::Accept(const ErrorModel& error) const {
+  if (error.code == 409) {
+    return NamespaceNotEmpty(error.message);
+  }
+
+  return NamespaceErrorHandler::Accept(error);
+}
+
+const std::shared_ptr<TableErrorHandler>& TableErrorHandler::Instance() {
+  static const std::shared_ptr<TableErrorHandler> instance{new TableErrorHandler()};
+  return instance;
+}
+
+Status TableErrorHandler::Accept(const ErrorModel& error) const {
+  switch (error.code) {
+    case 404:
+      if (error.type == kNoSuchNamespaceException) {
+        return NoSuchNamespace(error.message);
+      }
+      return NoSuchTable(error.message);
+    case 409:
+      return AlreadyExists(error.message);
+  }
+
+  return DefaultErrorHandler::Accept(error);
+}
+
+const std::shared_ptr<ViewErrorHandler>& ViewErrorHandler::Instance() {
+  static const std::shared_ptr<ViewErrorHandler> instance{new ViewErrorHandler()};
+  return instance;
+}
+
+Status ViewErrorHandler::Accept(const ErrorModel& error) const {
+  switch (error.code) {
+    case 404:
+      if (error.type == kNoSuchNamespaceException) {
+        return NoSuchNamespace(error.message);
+      }
+      return NoSuchView(error.message);
+    case 409:
+      return AlreadyExists(error.message);
+  }
+
+  return DefaultErrorHandler::Accept(error);
+}
+
+const std::shared_ptr<TableCommitErrorHandler>& TableCommitErrorHandler::Instance() {
+  static const std::shared_ptr<TableCommitErrorHandler> instance{
+      new TableCommitErrorHandler()};
+  return instance;
+}
+
+Status TableCommitErrorHandler::Accept(const ErrorModel& error) const {
+  switch (error.code) {
+    case 404:
+      return NoSuchTable(error.message);
+    case 409:
+      return CommitFailed("Commit failed: {}", error.message);
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      return CommitStateUnknown("Service failed: {}: {}", error.code, error.message);
+  }
+
+  return DefaultErrorHandler::Accept(error);
+}
+
+const std::shared_ptr<ViewCommitErrorHandler>& ViewCommitErrorHandler::Instance() {
+  static const std::shared_ptr<ViewCommitErrorHandler> instance{
+      new ViewCommitErrorHandler()};
+  return instance;
+}
+
+Status ViewCommitErrorHandler::Accept(const ErrorModel& error) const {
+  switch (error.code) {
+    case 404:
+      return NoSuchView(error.message);
+    case 409:
+      return CommitFailed("Commit failed: {}", error.message);
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      return CommitStateUnknown("Service failed: {}: {}", error.code, error.message);
+  }
+
+  return DefaultErrorHandler::Accept(error);
+}
+
+}  // namespace iceberg::rest