couchbase 3.5.3 → 3.5.4

data/ext/couchbase/core/columnar/agent.hxx

@@ -20,6 +20,7 @@
 #include "agent_config.hxx"
 #include "core/free_form_http_request.hxx"
 #include "core/pending_operation.hxx"
+#include "database_management_options.hxx"
 #include "error.hxx"
 #include "query_options.hxx"
 
@@ -45,11 +46,25 @@ public:
 
   auto free_form_http_request(const http_request& request,
                               free_form_http_request_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error_union>;
+
+  auto free_form_http_request_buffered(const http_request& request,
+                                       buffered_free_form_http_request_callback&& callback)
     -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>;
 
   auto execute_query(const query_options& options, query_callback&& callback)
     -> tl::expected<std::shared_ptr<pending_operation>, error>;
 
+  auto database_fetch_all(const fetch_all_databases_options& options,
+                          fetch_all_databases_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>;
+
+  auto database_drop(const drop_database_options& options, drop_database_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>;
+
+  auto database_create(const create_database_options& options, create_database_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>;
+
 private:
   std::shared_ptr<agent_impl> impl_;
 };

data/ext/couchbase/core/columnar/agent_config.cxx

@@ -38,10 +38,11 @@ auto
 timeout_config::to_string() const -> std::string
 {
   return fmt::format(
-    R"(#<timeout_config:{} connect_timeout={}, dispatch_timeout={}, query_timeout={}>)",
+    R"(#<timeout_config:{} connect_timeout={}, dispatch_timeout={}, query_timeout={}, management_timeout={}>)",
     static_cast<const void*>(this),
     connect_timeout,
     dispatch_timeout,
-    query_timeout);
+    query_timeout,
+    management_timeout);
 }
 } // namespace couchbase::core::columnar

data/ext/couchbase/core/columnar/agent_config.hxx

@@ -35,6 +35,7 @@ struct timeout_config {
   static constexpr std::chrono::milliseconds default_connect_timeout{ 10'000 };
   static constexpr std::chrono::milliseconds default_dispatch_timeout{ 30'000 };
   static constexpr std::chrono::milliseconds default_query_timeout{ 600'000 };
+  static constexpr std::chrono::milliseconds default_management_timeout{ 30'000 };
 
   // TODO(DC): Use connect_timeout and dispatch_timeout once the agent provides an entry point for
   // opening the cluster
@@ -42,6 +43,7 @@ struct timeout_config {
   std::chrono::milliseconds dispatch_timeout{ default_dispatch_timeout }; // Not currently used
 
   std::chrono::milliseconds query_timeout{ default_query_timeout };
+  std::chrono::milliseconds management_timeout{ default_management_timeout };
 
   [[nodiscard]] auto to_string() const -> std::string;
 };

data/ext/couchbase/core/columnar/database_management_options.hxx

@@ -0,0 +1,56 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. Couchbase, Inc.
+ *
+ *   Licensed 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.
+ */
+
+#pragma once
+
+#include <chrono>
+#include <optional>
+#include <vector>
+
+#include "core/utils/movable_function.hxx"
+#include "error.hxx"
+
+namespace couchbase::core::columnar
+{
+struct fetch_all_databases_options {
+  std::optional<std::chrono::milliseconds> timeout{};
+};
+
+struct drop_database_options {
+  std::string name;
+
+  bool ignore_if_not_exists{};
+  std::optional<std::chrono::milliseconds> timeout{};
+};
+
+struct create_database_options {
+  std::string name;
+
+  bool ignore_if_exists{};
+  std::optional<std::chrono::milliseconds> timeout{};
+};
+
+struct database_metadata {
+  std::string name;
+  bool is_system_database;
+};
+
+using fetch_all_databases_callback =
+  utils::movable_function<void(std::vector<database_metadata>, error)>;
+using drop_database_callback = utils::movable_function<void(error)>;
+using create_database_callback = utils::movable_function<void(error)>;
+} // namespace couchbase::core::columnar

data/ext/couchbase/core/columnar/error.hxx

@@ -46,7 +46,7 @@ struct error {
   tao::json::value ctx = tao::json::empty_object;
   std::shared_ptr<error> cause{};
 
-  operator bool() const;
-  auto message_with_ctx() const -> std::string;
+  explicit operator bool() const;
+  [[nodiscard]] auto message_with_ctx() const -> std::string;
 };
 } // namespace couchbase::core::columnar

data/ext/couchbase/core/columnar/error_codes.cxx

@@ -27,7 +27,7 @@ namespace couchbase::core::columnar
 struct columnar_error_category : std::error_category {
   [[nodiscard]] auto name() const noexcept -> const char* override
   {
-    return "couchbase.core.columnar";
+    return "couchbase.core.columnar.errc";
   }
 
   [[nodiscard]] auto message(int ev) const noexcept -> std::string override
@@ -42,17 +42,48 @@ struct columnar_error_category : std::error_category {
       case errc::query_error:
         return "query_error";
     }
-    return "FIXME: unknown error code (recompile with newer library): couchbase.core.columnar." +
+    return "FIXME: unknown error code (recompile with newer library): "
+           "couchbase.core.columnar.errc." +
            std::to_string(ev);
   }
 };
 
-const inline static columnar_error_category category_instance;
+const inline static columnar_error_category columnar_category_instance;
 
 auto
 columnar_category() noexcept -> const std::error_category&
 {
-  return category_instance;
+  return columnar_category_instance;
+}
+
+struct columnar_client_error_category : std::error_category {
+  [[nodiscard]] auto name() const noexcept -> const char* override
+  {
+    return "couchbase.core.columnar.client_errc";
+  }
+
+  [[nodiscard]] auto message(int ev) const noexcept -> std::string override
+  {
+    switch (static_cast<client_errc>(ev)) {
+      case client_errc::canceled:
+        return "canceled";
+      case client_errc::cluster_closed:
+        return "cluster_closed";
+      case client_errc::invalid_argument:
+        return "invalid_argument";
+    }
+    return "FIXME: unknown error code (recompile with newer library): "
+           "couchbase.core.columnar.client_errc" +
+           std::to_string(ev);
+  }
+};
+
+const inline static columnar_client_error_category columnar_client_category_instance;
+
+auto
+columnar_client_category() noexcept -> const std::error_category&
+{
+  return columnar_client_category_instance;
 }
 
 auto
@@ -62,7 +93,15 @@ maybe_convert_error_code(std::error_code e) -> std::error_code
       e == couchbase::errc::common::ambiguous_timeout) {
     return errc::timeout;
   }
+  if (e == couchbase::errc::common::request_canceled) {
+    return client_errc::canceled;
+  }
+  if (e == couchbase::errc::network::cluster_closed) {
+    return client_errc::cluster_closed;
+  }
+  if (e == couchbase::errc::common::invalid_argument) {
+    return client_errc::invalid_argument;
+  }
   return e;
 }
-
 } // namespace couchbase::core::columnar

data/ext/couchbase/core/columnar/error_codes.hxx

@@ -25,6 +25,10 @@ namespace couchbase::core::columnar
 auto
 columnar_category() noexcept -> const std::error_category&;
 
+/**
+ * Error codes used when the error is the result of an unsuccessful client-server interaction.
+ * Wrapper SDKs should expose them as an error that extends ColumnarError.
+ */
 enum class errc : std::uint8_t {
   generic = 1,
   invalid_credential = 2,
@@ -38,6 +42,26 @@ make_error_code(errc e) noexcept -> std::error_code
   return { static_cast<int>(e), columnar_category() };
 }
 
+auto
+columnar_client_category() noexcept -> const std::error_category&;
+
+/**
+ * Error codes used for client-side errors.
+ * Wrapper SDKs should expose them using platform-idiomatic error types that do _not_ extend
+ * ColumnarError.
+ */
+enum class client_errc : std::uint8_t {
+  canceled = 1,
+  invalid_argument = 2,
+  cluster_closed = 3,
+};
+
+inline auto
+make_error_code(client_errc e) noexcept -> std::error_code
+{
+  return { static_cast<int>(e), columnar_client_category() };
+}
+
 auto
 maybe_convert_error_code(std::error_code e) -> std::error_code;
 } // namespace couchbase::core::columnar
@@ -45,3 +69,7 @@ maybe_convert_error_code(std::error_code e) -> std::error_code;
 template<>
 struct std::is_error_code_enum<couchbase::core::columnar::errc> : std::true_type {
 };
+
+template<>
+struct std::is_error_code_enum<couchbase::core::columnar::client_errc> : std::true_type {
+};

data/ext/couchbase/core/columnar/management_component.cxx

@@ -0,0 +1,300 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. Couchbase, Inc.
+ *
+ *   Licensed 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 "management_component.hxx"
+
+#include "core/http_component.hxx"
+#include "core/logger/logger.hxx"
+#include "core/platform/uuid.h"
+#include "core/utils/json.hxx"
+#include "core/utils/movable_function.hxx"
+#include "error.hxx"
+#include "error_codes.hxx"
+
+#include <chrono>
+#include <optional>
+#include <string>
+
+#include <gsl/narrow>
+#include <tao/json/value.hpp>
+#include <tl/expected.hpp>
+
+namespace couchbase::core::columnar
+{
+struct query_based_management_request {
+  std::string statement;
+  std::optional<std::chrono::milliseconds> timeout{};
+  std::string client_context_id{ uuid::to_string(uuid::random()) };
+};
+
+class pending_management_operation
+  : public std::enable_shared_from_this<pending_management_operation>
+  , public pending_operation
+{
+public:
+  pending_management_operation(http_request req, http_component& http)
+    : req_{ std::move(req) }
+    , http_{ http }
+  {
+  }
+
+  auto parse_management_error(const std::uint32_t& http_status,
+                              const tao::json::value& body) -> error
+  {
+    const auto* errors_json = body.find("errors");
+    if (errors_json == nullptr) {
+      return {};
+    }
+    if (!errors_json->is_array()) {
+      return { errc::generic, "Could not parse errors from server response - expected JSON array" };
+    }
+    if (errors_json->get_array().empty()) {
+      return {};
+    }
+
+    CB_LOG_DEBUG("MANAGEMENT OPERATION ERROR (client_context_id={}, http_status={}): {}.",
+                 req_.client_context_id,
+                 http_status,
+                 utils::json::generate(errors_json));
+
+    error err{ errc::generic };
+    err.ctx["http_status"] = std::to_string(http_status);
+    err.ctx["errors"] = std::vector<tao::json::value>{};
+
+    if (http_status == 401) {
+      err.ec = errc::invalid_credential;
+    }
+
+    for (auto error_json : errors_json->get_array()) {
+      auto* msg = error_json.find("msg");
+      if (msg == nullptr) {
+        return { errc::generic,
+                 "Could not parse error from server response - could not find 'msg' field" };
+      }
+      if (!msg->is_string()) {
+        return { errc::generic,
+                 "Could not parse error from server response - 'msg' field was not string" };
+      }
+
+      auto* c = error_json.find("code");
+      if (c == nullptr) {
+        return { errc::generic,
+                 "Could not parse error from server response - could not find 'code' field" };
+      }
+      if (!(c->is_unsigned() || c->is_signed())) {
+        return { errc::generic,
+                 "Could not parse error from server response - 'code' field was not an integer" };
+      }
+
+      std::int32_t code = c->is_signed() ? gsl::narrow_cast<std::int32_t>(c->get_signed())
+                                         : gsl::narrow_cast<std::int32_t>(c->get_unsigned());
+
+      tao::json::value error = {
+        { "code", code },
+        { "msg", msg->get_string() },
+      };
+      err.ctx["errors"].get_array().emplace_back(std::move(error));
+
+      switch (code) {
+        case 20000:
+          err.ec = errc::invalid_credential;
+          break;
+        case 21002:
+          err.ec = errc::timeout;
+          break;
+        default:
+          break;
+      }
+    }
+
+    return err;
+  }
+
+  auto execute(core::utils::movable_function<void(std::vector<tao::json::value>, error)>&& callback)
+    -> error
+  {
+    auto op = http_.do_http_request_buffered(
+      req_,
+      [self = shared_from_this(), cb = std::move(callback)](buffered_http_response resp, auto ec) {
+        if (ec) {
+          return cb(
+            {}, { maybe_convert_error_code(ec), "Failed to execute management HTTP operation" });
+        }
+        auto body_json = utils::json::parse(std::string_view{ resp.body() });
+        auto err = self->parse_management_error(resp.status_code(), body_json);
+        if (err) {
+          return cb({}, err);
+        }
+        const auto* results_json = body_json.find("results");
+        if (results_json == nullptr) {
+          return cb({}, {});
+        }
+        if (!results_json->is_array()) {
+          return cb({},
+                    { errc::generic,
+                      "Could not parse results from server response - expected JSON array" });
+        }
+        cb(results_json->get_array(), {});
+      });
+
+    if (op.has_value()) {
+      http_op_ = std::move(op.value());
+      return {};
+    }
+    return error{ maybe_convert_error_code(op.error()),
+                  "Failed do dispatch management HTTP operation" };
+  }
+
+  void cancel() override
+  {
+    if (http_op_) {
+      http_op_->cancel();
+    }
+  }
+
+private:
+  http_request req_;
+  http_component& http_;
+  std::shared_ptr<pending_operation> http_op_{};
+};
+
+class management_component_impl
+{
+public:
+  management_component_impl(http_component http, std::chrono::milliseconds default_timeout)
+    : http_{ std::move(http) }
+    , default_timeout_{ default_timeout }
+  {
+  }
+
+  auto database_fetch_all(const fetch_all_databases_options& options,
+                          fetch_all_databases_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>
+  {
+    query_based_management_request req{
+      "SELECT d.* FROM `System`.`Metadata`.`Database` AS d",
+      options.timeout,
+    };
+    return execute(std::move(req), [cb = std::move(callback)](const auto& raw_res, auto err) {
+      if (err) {
+        cb({}, std::move(err));
+        return;
+      }
+      std::vector<database_metadata> res{};
+      res.reserve(raw_res.size());
+      for (tao::json::value raw_metadata : raw_res) {
+        res.emplace_back(database_metadata{
+          raw_metadata["DatabaseName"].get_string(),
+          raw_metadata["SystemDatabase"].get_boolean(),
+        });
+      }
+      cb(std::move(res), {});
+    });
+  }
+
+  auto database_create(const create_database_options& options, create_database_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>
+  {
+    query_based_management_request req{
+      fmt::format("CREATE DATABASE `{}`", options.name),
+      options.timeout,
+    };
+    if (options.ignore_if_exists) {
+      req.statement += " IF NOT EXISTS";
+    }
+    return execute(std::move(req), [cb = std::move(callback)](const auto& /*raw_res*/, auto err) {
+      cb(std::move(err));
+    });
+  }
+
+  auto database_drop(const drop_database_options& options, drop_database_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>
+  {
+    query_based_management_request req{
+      fmt::format("DROP DATABASE `{}`", options.name),
+      options.timeout,
+    };
+    if (options.ignore_if_not_exists) {
+      req.statement += " IF EXISTS";
+    }
+    return execute(std::move(req), [cb = std::move(callback)](const auto& /*raw_res*/, auto err) {
+      cb(std::move(err));
+    });
+  }
+
+private:
+  auto execute(query_based_management_request req,
+               core::utils::movable_function<void(std::vector<tao::json::value>, error)>&& callback)
+    -> tl::expected<std::shared_ptr<pending_management_operation>, error>
+  {
+    const std::chrono::milliseconds timeout = req.timeout.value_or(default_timeout_);
+    const std::chrono::milliseconds server_timeout = timeout + std::chrono::seconds(5);
+
+    const tao::json::value body{
+      { "statement", std::move(req.statement) },
+      { "client_context_id", req.client_context_id },
+      { "timeout", fmt::format("{}ms", server_timeout.count()) },
+    };
+
+    http_request http_req{ service_type::analytics, "POST", {}, "/api/v1/request" };
+    http_req.body = utils::json::generate(body);
+    http_req.headers["content-type"] = "application/json";
+    http_req.client_context_id = std::move(req.client_context_id);
+    http_req.timeout = timeout;
+
+    auto op = std::make_shared<pending_management_operation>(std::move(http_req), http_);
+    auto err = op->execute(std::move(callback));
+    if (err) {
+      return tl::unexpected{ err };
+    }
+    return op;
+  }
+
+  http_component http_;
+  std::chrono::milliseconds default_timeout_;
+};
+
+management_component::management_component(http_component http,
+                                           std::chrono::milliseconds default_timeout)
+  : impl_{ std::make_shared<management_component_impl>(std::move(http), default_timeout) }
+{
+}
+
+auto
+management_component::database_fetch_all(const fetch_all_databases_options& options,
+                                         fetch_all_databases_callback&& callback)
+  -> tl::expected<std::shared_ptr<pending_operation>, error>
+{
+  return impl_->database_fetch_all(options, std::move(callback));
+}
+
+auto
+management_component::database_create(const create_database_options& options,
+                                      create_database_callback&& callback)
+  -> tl::expected<std::shared_ptr<pending_operation>, error>
+{
+  return impl_->database_create(options, std::move(callback));
+}
+
+auto
+management_component::database_drop(const drop_database_options& options,
+                                    drop_database_callback&& callback)
+  -> tl::expected<std::shared_ptr<pending_operation>, error>
+{
+  return impl_->database_drop(options, std::move(callback));
+}
+} // namespace couchbase::core::columnar

data/ext/couchbase/core/columnar/management_component.hxx

@@ -0,0 +1,56 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. Couchbase, Inc.
+ *
+ *   Licensed 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.
+ */
+
+#pragma once
+
+#include "core/pending_operation.hxx"
+#include "database_management_options.hxx"
+#include "error.hxx"
+
+#include <chrono>
+#include <memory>
+
+#include <tl/expected.hpp>
+
+namespace couchbase::core
+{
+class http_component;
+
+namespace columnar
+{
+class management_component_impl;
+
+class management_component
+{
+public:
+  management_component(http_component http, std::chrono::milliseconds default_timeout);
+
+  auto database_fetch_all(const fetch_all_databases_options& options,
+                          fetch_all_databases_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>;
+
+  auto database_drop(const drop_database_options& options, drop_database_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>;
+
+  auto database_create(const create_database_options& options, create_database_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>;
+
+private:
+  std::shared_ptr<management_component_impl> impl_;
+};
+} // namespace columnar
+} // namespace couchbase::core