couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/management/bucket_settings.hxx

@@ -1,134 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 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/protocol/durability_level.hxx>
-
-#include <map>
-#include <optional>
-#include <string>
-#include <vector>
-
-namespace couchbase::management::cluster
-{
-enum class bucket_type { unknown, couchbase, memcached, ephemeral };
-enum class bucket_compression { unknown, off, active, passive };
-enum class bucket_eviction_policy {
-    unknown,
-
-    /**
-     * During ejection, everything (including key, metadata, and value) will be ejected.
-     *
-     * Full Ejection reduces the memory overhead requirement, at the cost of performance.
-     *
-     * This value is only valid for buckets of type COUCHBASE.
-     */
-    full,
-
-    /**
-     * During ejection, only the value will be ejected (key and metadata will remain in memory).
-     *
-     * Value Ejection needs more system memory, but provides better performance than Full Ejection.
-     *
-     * This value is only valid for buckets of type COUCHBASE.
-     */
-    value_only,
-
-    /**
-     * Couchbase Server keeps all data until explicitly deleted, but will reject
-     * any new data if you reach the quota (dedicated memory) you set for your bucket.
-     *
-     * This value is only valid for buckets of type EPHEMERAL.
-     */
-    no_eviction,
-
-    /**
-     * When the memory quota is reached, Couchbase Server ejects data that has not been used recently.
-     *
-     * This value is only valid for buckets of type EPHEMERAL.
-     */
-    not_recently_used,
-};
-enum class bucket_conflict_resolution {
-    unknown,
-    /**
-     * Use timestamp conflict resolution.
-     *
-     * Timestamp-based conflict resolution (often referred to as Last Write Wins, or LWW) uses the document
-     * timestamp (stored in the CAS) to resolve conflicts. The timestamps associated with the most recent
-     * updates of source and target documents are compared. The document whose update has the more recent
-     * timestamp prevails.
-     */
-    timestamp,
-
-    /**
-     * Use sequence number conflict resolution
-     *
-     * Conflicts can be resolved by referring to documents' sequence numbers. Sequence numbers are maintained
-     * per document, and are incremented on every document-update. The sequence numbers of source and
-     * target documents are compared; and the document with the higher sequence number prevails.
-     */
-    sequence_number,
-
-    /**
-     * VOLATILE: This API is subject to change at any time.
-     *
-     * In Couchbase Server 7.1, this feature is only available in "developer-preview" mode. See the UI XDCR settings.
-     */
-    custom,
-};
-enum class bucket_storage_backend { unknown, couchstore, magma };
-
-struct bucket_settings {
-    struct node {
-        std::string hostname;
-        std::string status;
-        std::string version;
-        std::vector<std::string> services;
-        std::map<std::string, std::uint16_t> ports;
-    };
-
-    std::string name;
-    std::string uuid;
-    cluster::bucket_type bucket_type{ cluster::bucket_type::unknown };
-    std::uint64_t ram_quota_mb{ 100 };
-    std::uint32_t max_expiry{ 0 };
-    bucket_compression compression_mode{ bucket_compression::unknown };
-    std::optional<protocol::durability_level> minimum_durability_level{};
-    std::uint32_t num_replicas{ 1 };
-    bool replica_indexes{ false };
-    bool flush_enabled{ false };
-    bucket_eviction_policy eviction_policy{ bucket_eviction_policy::unknown };
-    bucket_conflict_resolution conflict_resolution_type{ bucket_conflict_resolution::unknown };
-
-    /**
-     * UNCOMMITTED: This API may change in the future
-     */
-    bucket_storage_backend storage_backend{ bucket_storage_backend::unknown };
-
-    /**
-     * UNCOMMITTED: read-only attribute
-     */
-    std::vector<std::string> capabilities{};
-
-    /**
-     * UNCOMMITTED: read-only attribute
-     */
-    std::vector<node> nodes{};
-};
-} // namespace couchbase::management::cluster

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/management/bucket_settings_json.hxx

@@ -1,123 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 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/management/bucket_settings.hxx>
-
-#include <tao/json/forward.hpp>
-
-namespace tao::json
-{
-template<>
-struct traits<couchbase::management::cluster::bucket_settings> {
-    template<template<typename...> class Traits>
-    static couchbase::management::cluster::bucket_settings as(const tao::json::basic_value<Traits>& v)
-    {
-        couchbase::management::cluster::bucket_settings result;
-        result.name = v.at("name").get_string();
-        result.uuid = v.at("uuid").get_string();
-        const static std::uint64_t megabyte = 1024LLU * 1024LLU;
-        result.ram_quota_mb = v.at("quota").at("rawRAM").get_unsigned() / megabyte;
-        result.num_replicas = v.at("replicaNumber").template as<std::uint32_t>();
-
-        if (auto* max_ttl = v.find("maxTTL"); max_ttl != nullptr) {
-            result.max_expiry = max_ttl->template as<std::uint32_t>();
-        }
-
-        if (auto& str = v.at("bucketType").get_string(); str == "couchbase" || str == "membase") {
-            result.bucket_type = couchbase::management::cluster::bucket_type::couchbase;
-        } else if (str == "ephemeral") {
-            result.bucket_type = couchbase::management::cluster::bucket_type::ephemeral;
-        } else if (str == "memcached") {
-            result.bucket_type = couchbase::management::cluster::bucket_type::memcached;
-        }
-
-        if (auto* compression_mode = v.find("compressionMode"); compression_mode != nullptr && compression_mode->is_string()) {
-            if (auto& str = compression_mode->get_string(); str == "active") {
-                result.compression_mode = couchbase::management::cluster::bucket_compression::active;
-            } else if (str == "passive") {
-                result.compression_mode = couchbase::management::cluster::bucket_compression::passive;
-            } else if (str == "off") {
-                result.compression_mode = couchbase::management::cluster::bucket_compression::off;
-            }
-        }
-
-        if (auto& str = v.at("evictionPolicy").get_string(); str == "valueOnly") {
-            result.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::value_only;
-        } else if (str == "fullEviction") {
-            result.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::full;
-        } else if (str == "noEviction") {
-            result.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::no_eviction;
-        } else if (str == "nruEviction") {
-            result.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::not_recently_used;
-        }
-
-        if (auto* storage_backend = v.find("storageBackend"); storage_backend != nullptr && storage_backend->is_string()) {
-            if (const auto& str = storage_backend->get_string(); str == "couchstore") {
-                result.storage_backend = couchbase::management::cluster::bucket_storage_backend::couchstore;
-            } else if (str == "magma") {
-                result.storage_backend = couchbase::management::cluster::bucket_storage_backend::magma;
-            }
-        }
-
-        if (auto* min_level = v.find("durabilityMinLevel"); min_level != nullptr) {
-            if (auto& str = min_level->get_string(); str == "none") {
-                result.minimum_durability_level = couchbase::protocol::durability_level::none;
-            } else if (str == "majority") {
-                result.minimum_durability_level = couchbase::protocol::durability_level::majority;
-            } else if (str == "majorityAndPersistActive") {
-                result.minimum_durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-            } else if (str == "persistToMajority") {
-                result.minimum_durability_level = couchbase::protocol::durability_level::persist_to_majority;
-            }
-        }
-
-        if (auto& str = v.at("conflictResolutionType").get_string(); str == "lww") {
-            result.conflict_resolution_type = couchbase::management::cluster::bucket_conflict_resolution::timestamp;
-        } else if (str == "seqno") {
-            result.conflict_resolution_type = couchbase::management::cluster::bucket_conflict_resolution::sequence_number;
-        } else if (str == "custom") {
-            result.conflict_resolution_type = couchbase::management::cluster::bucket_conflict_resolution::custom;
-        }
-
-        result.flush_enabled = v.at("controllers").find("flush") != nullptr;
-        if (const auto replica_index = v.find("replicaIndex")) {
-            result.replica_indexes = replica_index->get_boolean();
-        }
-        if (const auto caps = v.find("bucketCapabilities"); caps != nullptr) {
-            for (auto& cap : caps->get_array()) {
-                result.capabilities.emplace_back(cap.get_string());
-            }
-        }
-        for (auto& n : v.at("nodes").get_array()) {
-            couchbase::management::cluster::bucket_settings::node node;
-            node.status = n.at("status").get_string();
-            node.hostname = n.at("hostname").get_string();
-            node.version = n.at("version").get_string();
-            for (auto& s : n.at("services").get_array()) {
-                node.services.emplace_back(s.get_string());
-            }
-            for (auto& p : n.at("ports").get_object()) {
-                node.ports.emplace(p.first, p.second.template as<std::uint16_t>());
-            }
-            result.nodes.emplace_back(node);
-        }
-        return result;
-    }
-};
-} // namespace tao::json

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/management/design_document.hxx

@@ -1,41 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 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 <map>
-#include <optional>
-#include <string>
-
-#include <couchbase/design_document_namespace.hxx>
-
-namespace couchbase::management::views
-{
-struct design_document {
-    struct view {
-        std::string name;
-        std::optional<std::string> map{};
-        std::optional<std::string> reduce{};
-    };
-
-    std::string rev;
-    std::string name;
-    design_document_namespace ns;
-    std::map<std::string, view> views;
-};
-
-} // namespace couchbase::management::views

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/management/eventing_function.hxx

@@ -1,188 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 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/management/eventing_status.hxx>
-#include <couchbase/query_scan_consistency.hxx>
-
-#include <chrono>
-#include <optional>
-#include <string>
-#include <variant>
-#include <vector>
-
-namespace couchbase::management::eventing
-{
-
-struct function_keyspace {
-    std::string bucket;
-    std::optional<std::string> scope{};
-    std::optional<std::string> collection{};
-};
-
-enum class function_dcp_boundary {
-    everything,
-    from_now,
-};
-
-enum class function_language_compatibility {
-    version_6_0_0,
-    version_6_5_0,
-    version_6_6_2,
-};
-
-enum class function_log_level {
-    info,
-    error,
-    warning,
-    debug,
-    trace,
-};
-
-struct function_settings {
-    /** number of threads each worker utilizes */
-    std::optional<std::int64_t> cpp_worker_count{};
-    /** indicates where to start dcp stream from */
-    std::optional<function_dcp_boundary> dcp_stream_boundary{};
-    /** free form text for user to describe the handler. no functional role */
-    std::optional<std::string> description{};
-    /** indicates if the function is deployed */
-    std::optional<function_deployment_status> deployment_status{};
-    /** indicates if the function is running */
-    std::optional<function_processing_status> processing_status{};
-    /** level of detail in system logging */
-    std::optional<function_log_level> log_level{};
-    /** eventing language version this handler assumes in terms of syntax and behavior */
-    std::optional<function_language_compatibility> language_compatibility{};
-    /** maximum time the handler can run before it is forcefully terminated */
-    std::optional<std::chrono::seconds> execution_timeout{};
-    /** maximum number of libcouchbase connections that may be opened and pooled */
-    std::optional<std::int64_t> lcb_inst_capacity{};
-    /** number of retries of retriable libcouchbase failures. 0 keeps trying till execution_timeout */
-    std::optional<std::int64_t> lcb_retry_count{};
-    /** maximum time the lcb command is waited until completion before we terminate the request */
-    std::optional<std::chrono::seconds> lcb_timeout{};
-    /** consistency level used by n1ql statements in the handler */
-    std::optional<couchbase::query_scan_consistency> query_consistency{};
-    /** number of timer shards. defaults to number of vbuckets */
-    std::optional<std::int64_t> num_timer_partitions{};
-    /** batch size for messages from producer to consumer */
-    std::optional<std::int64_t> sock_batch_size{};
-    /** duration to log stats from this handler */
-    std::optional<std::chrono::milliseconds> tick_duration{};
-    /** size limit of timer context object */
-    std::optional<std::int64_t> timer_context_size{};
-    /** key prefix for all data stored in metadata by this handler */
-    std::optional<std::string> user_prefix{};
-    /** maximum size in bytes the bucket cache can grow to */
-    std::optional<std::int64_t> bucket_cache_size{};
-    /** time in milliseconds after which a cached bucket object is considered stale */
-    std::optional<std::chrono::milliseconds> bucket_cache_age{};
-    /** maximum allowable curl call response in 'MegaBytes'. Setting the value to 0 lifts the upper limit off. This parameters affects v8
-     * engine stability since it defines the maximum amount of heap space acquired by a curl call */
-    std::optional<std::int64_t> curl_max_allowed_resp_size{};
-    /** automatically prepare all n1ql statements in the handler */
-    std::optional<bool> query_prepare_all{};
-    /** number of worker processes handler utilizes on each eventing node */
-    std::optional<std::int64_t> worker_count{};
-    /** code to automatically prepend to top of handler code */
-    std::vector<std::string> handler_headers{};
-    /** code to automatically append to bottom of handler code */
-    std::vector<std::string> handler_footers{};
-    /** enable rotating this handlers log() message files */
-    std::optional<bool> enable_app_log_rotation{};
-    /** directory to write content of log() message files */
-    std::optional<std::string> app_log_dir{};
-    /** rotate logs when file grows to this size in bytes approximately */
-    std::optional<std::int64_t> app_log_max_size{};
-    /** number of log() message files to retain when rotating */
-    std::optional<std::int64_t> app_log_max_files{};
-    /** number of seconds before writing a progress checkpoint */
-    std::optional<std::chrono::seconds> checkpoint_interval{};
-};
-
-enum class function_bucket_access {
-    read_only,
-    read_write,
-};
-
-struct function_bucket_binding {
-    /** symbolic name used in code to refer to this binding */
-    std::string alias;
-    /** name of the bucket with optional scope and collection */
-    function_keyspace name;
-    /** bucket access level (read or read+write) */
-    function_bucket_access access{ function_bucket_access::read_write };
-};
-
-struct function_url_no_auth {
-};
-
-struct function_url_auth_basic {
-    std::string username;
-    std::string password{};
-};
-
-struct function_url_auth_digest {
-    std::string username;
-    std::string password{};
-};
-
-struct function_url_auth_bearer {
-    std::string key{};
-};
-
-struct function_url_binding {
-    std::string alias;
-    std::string hostname;
-    bool allow_cookies{ false };
-    bool validate_ssl_certificate{ true };
-    std::variant<function_url_no_auth, function_url_auth_basic, function_url_auth_digest, function_url_auth_bearer> auth{
-        function_url_no_auth{}
-    };
-};
-
-struct function_constant_binding {
-    /** alias name of the constant binding */
-    std::string alias;
-    /** literal value bound to the alias name */
-    std::string literal;
-};
-
-struct function {
-    std::string name;
-    /** handler source code */
-    std::string code;
-    /** keyspace to store eventing checkpoints and timers */
-    eventing::function_keyspace metadata_keyspace{};
-    /** keyspace to listen to for document mutations */
-    eventing::function_keyspace source_keyspace{};
-    /** authoring tool. use 'external' if authored or edited outside eventing UI */
-    std::optional<std::string> version{};
-    /** enforces stricter validation for all settings and configuration fields */
-    std::optional<bool> enforce_schema{};
-    /** unique id of the the handler. generated by server */
-    std::optional<std::int64_t> handler_uuid{};
-    /** unique id of the deployment of the handler. generated by server */
-    std::optional<std::string> function_instance_id{};
-    std::vector<function_bucket_binding> bucket_bindings{};
-    std::vector<function_url_binding> url_bindings{};
-    std::vector<function_constant_binding> constant_bindings{};
-    function_settings settings{};
-};
-} // namespace couchbase::management::eventing