couchbase 4.2.9 → 4.2.10

package/deps/couchbase-cxx-client/couchbase/endpoint_diagnostics.hxx

@@ -0,0 +1,206 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-Present 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 <couchbase/service_type.hxx>
+
+#include <chrono>
+#include <optional>
+#include <string>
+#include <utility>
+
+namespace couchbase
+{
+enum class endpoint_state {
+    /**
+     * The endpoint is connected and ready.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    connected,
+
+    /**
+     * The endpoint is disconnected but trying to connect right now.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    connecting,
+
+    /**
+     * The endpoint is disconnected (not reachable) and not trying to connect.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    disconnected,
+
+    /**
+     * The endpoint is currently disconnecting.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    disconnecting,
+};
+
+class endpoint_diagnostics
+{
+  public:
+    endpoint_diagnostics() = default;
+
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    endpoint_diagnostics(service_type type,
+                         std::string id,
+                         std::optional<std::chrono::microseconds> last_activity,
+                         std::string local,
+                         std::string remote,
+                         std::optional<std::string> endpoint_namespace,
+                         endpoint_state state,
+                         std::optional<std::string> details)
+      : type_{ type }
+      , id_{ std::move(id) }
+      , last_activity_{ last_activity }
+      , local_{ std::move(local) }
+      , remote_{ std::move(remote) }
+      , namespace_{ std::move(endpoint_namespace) }
+      , state_{ state }
+      , details_{ std::move(details) }
+    {
+    }
+
+    /**
+     * Returns the service type for this endpoint.
+     *
+     * @return the service type.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto type() const -> service_type
+    {
+        return type_;
+    }
+
+    /**
+     *
+     * Returns the ID for this endpoint.
+     *
+     * @return the endpoint ID.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto id() const -> std::string
+    {
+        return id_;
+    }
+
+    /**
+     * Returns the time since the last activity, if there has been one.
+     *
+     * @return the duration since the last activity.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto last_activity() const -> std::optional<std::chrono::microseconds>
+    {
+        return last_activity_;
+    }
+
+    /**
+     * Returns the local socket address for this endpoint.
+     *
+     * @return the local socket address.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto local() const -> std::string
+    {
+        return local_;
+    }
+
+    /**
+     * Returns the remote socket address for this endpoint.
+     *
+     * @return the remote socket address.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto remote() const -> std::string
+    {
+        return remote_;
+    }
+
+    /**
+     * Returns the namespace of this endpoint (likely the bucket name if present).
+     *
+     * @return the namespace.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto endpoint_namespace() const -> std::optional<std::string>
+    {
+        return namespace_;
+    }
+
+    /**
+     * Returns the current state of the endpoint.
+     *
+     * @return the endpoint state.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto state() const -> endpoint_state
+    {
+        return state_;
+    }
+
+    /**
+     * Returns any additional details about the endpoint, if available.
+     *
+     * @return endpoint details.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto details() const -> std::optional<std::string>
+    {
+        return details_;
+    }
+
+  private:
+    service_type type_{};
+    std::string id_{};
+    std::optional<std::chrono::microseconds> last_activity_{};
+    std::string local_{};
+    std::string remote_{};
+    std::optional<std::string> namespace_{};
+    endpoint_state state_{};
+    std::optional<std::string> details_{};
+};
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/endpoint_ping_report.hxx

@@ -0,0 +1,205 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-present 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 <cstdint>
+#include <map>
+#include <optional>
+#include <string>
+
+#include <couchbase/codec/tao_json_serializer.hxx>
+#include <couchbase/endpoint_ping_report.hxx>
+#include <couchbase/service_type.hxx>
+
+namespace couchbase
+{
+enum class ping_state {
+    /**
+     * Indicates that the ping operation was successful.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    ok,
+
+    /**
+     * Indicates that the ping operation timed out.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    timeout,
+
+    /**
+     * Indicates that the ping operation failed.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    error,
+};
+
+class endpoint_ping_report
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    endpoint_ping_report() = default;
+
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    endpoint_ping_report(service_type type,
+                         std::string id,
+                         std::string local,
+                         std::string remote,
+                         ping_state state,
+                         std::optional<std::string> error,
+                         std::optional<std::string> endpoint_namespace,
+                         std::chrono::microseconds latency)
+      : type_{ type }
+      , id_{ std::move(id) }
+      , local_{ std::move(local) }
+      , remote_{ std::move(remote) }
+      , state_{ state }
+      , error_{ std::move(error) }
+      , namespace_{ std::move(endpoint_namespace) }
+      , latency_{ latency }
+    {
+    }
+
+    /**
+     * Returns the service type for this endpoint.
+     *
+     * @return the service type.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto type() const -> service_type
+    {
+        return type_;
+    }
+
+    /**
+     * Returns the ID for this endpoint.
+     *
+     * @return the endpoint ID.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto id() const -> std::string
+    {
+        return id_;
+    }
+
+    /**
+     * Returns the local socket address for this endpoint.
+     *
+     * @return the local socket address.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto local() const -> std::string
+    {
+        return local_;
+    }
+
+    /**
+     * Returns the remote socket address for this endpoint.
+     *
+     * @return the remote socket address.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto remote() const -> std::string
+    {
+        return remote_;
+    }
+
+    /**
+     * Returns the state of this ping when assembling the report.
+     *
+     * @return the ping state.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto state() const -> ping_state
+    {
+        return state_;
+    }
+
+    /**
+     * Returns the reason this ping did not succeed, if applicable.
+     *
+     * @return error description.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto error() const -> std::optional<std::string>
+    {
+        return error_;
+    }
+
+    /**
+     * Returns the namespace of this endpoint (likely the bucket name if present).
+     *
+     * @return the namespace.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto endpoint_namespace() const -> std::optional<std::string>
+    {
+        return namespace_;
+    }
+
+    /**
+     * Returns the latency of this ping.
+     *
+     * @return the latency in microseconds.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto latency() const -> std::chrono::microseconds
+    {
+        return latency_;
+    }
+
+  private:
+    service_type type_;
+    std::string id_;
+    std::string local_;
+    std::string remote_;
+    ping_state state_;
+    std::optional<std::string> error_{};
+    std::optional<std::string> namespace_{};
+    std::chrono::microseconds latency_;
+};
+
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/get_options.hxx

@@ -46,8 +46,6 @@ struct get_options : public common_options<get_options> {
         const std::vector<std::string> projections;
     };
 
-    static constexpr std::size_t maximum_number_of_projections{ 16U };
-
     /**
      * Validates options and returns them as an immutable value.
      *
@@ -60,10 +58,7 @@ struct get_options : public common_options<get_options> {
      */
     [[nodiscard]] auto build() const -> built
     {
-        if (projections_.size() + (with_expiry_ ? 2 : 1) < maximum_number_of_projections) {
-            return { build_common_options(), with_expiry_, projections_ };
-        }
-        return { build_common_options(), with_expiry_, {} };
+        return { build_common_options(), with_expiry_, projections_ };
     }
 
     /**

package/deps/couchbase-cxx-client/couchbase/management/collection_spec.hxx

@@ -22,7 +22,7 @@ namespace couchbase::management::bucket
 struct collection_spec {
     std::string name;
     std::string scope_name;
-    std::uint32_t max_expiry{};
+    std::int32_t max_expiry{};
     std::optional<bool> history{};
 };
 

package/deps/couchbase-cxx-client/couchbase/ping_options.hxx

@@ -0,0 +1,93 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-Present 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 <couchbase/common_options.hxx>
+#include <couchbase/ping_result.hxx>
+#include <couchbase/service_type.hxx>
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+
+namespace couchbase
+{
+struct ping_options : public common_options<ping_options> {
+    /**
+     * Sets a custom report ID that will be used in the report. If no report ID is provided, the client will generate a
+     * unique one.
+     *
+     * @param report_id the report ID that should be used.
+     * @return reference to this object, for use in chaining.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto report_id(std::string report_id) -> ping_options&
+    {
+        report_id_ = std::move(report_id);
+        return self();
+    }
+
+    /**
+     * Customizes the set of services to ping.
+     *
+     * @param service_types the services to ping.
+     * @return reference to this object, for use in chaining.
+     */
+    auto service_types(std::set<service_type> service_types) -> ping_options&
+    {
+        service_types_ = std::move(service_types);
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<ping_options>::built {
+        std::optional<std::string> report_id;
+        std::set<service_type> service_types;
+    };
+
+    /**
+     * Validates the options and returns them as an immutable value.
+     *
+     * @return consistent options as an immutable value
+     *
+     * @exception std::system_error with code errc::common::invalid_argument if the options are not valid
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options(), report_id_, service_types_ };
+    }
+
+  private:
+    std::optional<std::string> report_id_{};
+    std::set<service_type> service_types_{};
+};
+
+using ping_handler = std::function<void(ping_result)>;
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/ping_result.hxx

@@ -0,0 +1,118 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-present 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 <couchbase/codec/tao_json_serializer.hxx>
+#include <couchbase/endpoint_ping_report.hxx>
+#include <couchbase/service_type.hxx>
+
+#include <cstdint>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace couchbase
+{
+class ping_result
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    ping_result() = default;
+
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    ping_result(std::string id, std::uint16_t version, std::string sdk, std::map<service_type, std::vector<endpoint_ping_report>> endpoints)
+      : id_{ std::move(id) }
+      , version_{ version }
+      , sdk_{ std::move(sdk) }
+      , endpoints_{ std::move(endpoints) }
+    {
+    }
+
+    /**
+     * Returns the ID of this report.
+     *
+     * @return the report ID.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto id() const -> std::string
+    {
+        return id_;
+    }
+
+    /**
+     * Returns the version of this report (useful when exporting to JSON).
+     *
+     * @return the report version.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto version() const -> std::uint16_t
+    {
+        return version_;
+    }
+
+    /**
+     * Returns the identifier of this SDK (useful when exporting to JSON).
+     *
+     * @return the SDK identifier.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto sdk() const -> std::string
+    {
+        return sdk_;
+    }
+
+    /**
+     * Returns the ping reports for each individual endpoint, organised by service type.
+     *
+     * @return the service type to ping reports map.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto endpoints() const -> std::map<service_type, std::vector<endpoint_ping_report>>
+    {
+        return endpoints_;
+    }
+
+    /**
+     * Exports the ping report as JSON.
+     *
+     * @return the JSON report.
+     */
+    [[nodiscard]] auto as_json() const -> codec::tao_json_serializer::document_type;
+
+  private:
+    std::string id_{};
+    std::uint16_t version_{};
+    std::string sdk_{};
+    std::map<service_type, std::vector<endpoint_ping_report>> endpoints_{};
+};
+} // namespace couchbase