couchbase 4.0.0 → 4.1.0

package/tools/gen-bindings-json.py

@@ -0,0 +1,360 @@
+import os
+import json
+import re
+import subprocess
+from unittest import TestCase
+import clang.cindex
+
+# configurable part
+
+llvmLibPath = "/usr/local/Cellar/llvm/13.0.1_1/lib/"
+
+cxxClientRoot = "../deps/couchbase-cxx-client"
+
+fileList = [
+    "couchbase/management/analytics_dataset.hxx",
+    "couchbase/management/analytics_index.hxx",
+    "couchbase/management/analytics_link_azure_blob_external.hxx",
+    "couchbase/management/analytics_link_couchbase_remote.hxx",
+    "couchbase/management/analytics_link_s3_external.hxx",
+    "couchbase/management/bucket_settings.hxx",
+    "couchbase/management/design_document.hxx",
+    "couchbase/management/eventing_function.hxx",
+    "couchbase/management/eventing_status.hxx",
+    "couchbase/management/rbac.hxx",
+    "couchbase/management/search_index.hxx",
+    "couchbase/management/query_index.hxx",
+    "couchbase/io/retry_reason.hxx",
+    "couchbase/topology/collections_manifest.hxx",
+    "couchbase/protocol/client_opcode.hxx",
+    "couchbase/protocol/cmd_lookup_in.hxx",
+    "couchbase/protocol/cmd_mutate_in.hxx",
+    "couchbase/protocol/durability_level.hxx",
+    "couchbase/protocol/status.hxx",
+    "couchbase/cas.hxx",
+    "couchbase/errors.hxx",
+    "couchbase/analytics_scan_consistency.hxx",
+    "couchbase/design_document_namespace.hxx",
+    "couchbase/diagnostics.hxx",
+    "couchbase/document_id.hxx",
+    "couchbase/json_string.hxx",
+    "couchbase/mutation_token.hxx",
+    "couchbase/query_profile_mode.hxx",
+    "couchbase/query_scan_consistency.hxx",
+    "couchbase/search_highlight_style.hxx",
+    "couchbase/search_scan_consistency.hxx",
+    "couchbase/service_type.hxx",
+    "couchbase/view_scan_consistency.hxx",
+    "couchbase/view_sort_order.hxx",
+    "couchbase/operations/*",
+    "couchbase/operations/management/*",
+]
+
+typeList = [
+    "couchbase::management::analytics::dataset",
+    "couchbase::management::analytics::index",
+    "couchbase::management::analytics::azure_blob_external_link",
+    "couchbase::management::analytics::couchbase_link_encryption_level",
+    "couchbase::management::analytics::couchbase_link_encryption_settings",
+    "couchbase::management::analytics::couchbase_remote_link",
+    "couchbase::management::analytics::s3_external_link",
+    "couchbase::management::cluster::bucket_settings",
+    "couchbase::management::cluster::bucket_type",
+    "couchbase::management::cluster::bucket_compression",
+    "couchbase::management::cluster::bucket_eviction_policy",
+    "couchbase::management::cluster::bucket_conflict_resolution",
+    "couchbase::management::cluster::bucket_storage_backend",
+    "couchbase::management::views::design_document",
+    "couchbase::management::eventing::function",
+    "couchbase::management::eventing::status",
+    "couchbase::management::rbac::role",
+    "couchbase::management::rbac::role_and_description",
+    "couchbase::management::rbac::origin",
+    "couchbase::management::rbac::role_and_origins",
+    "couchbase::management::rbac::user",
+    "couchbase::management::rbac::auth_domain",
+    "couchbase::management::rbac::user_and_metadata",
+    "couchbase::management::rbac::group",
+    "couchbase::management::search::index",
+    "couchbase::management::query::index",
+    "couchbase::io::retry_reason",
+    "couchbase::topology::collections_manifest",
+    "couchbase::protocol::status",
+    "couchbase::protocol::subdoc_opcode",
+    "couchbase::protocol::lookup_in_request_body::lookup_in_specs",
+    "couchbase::protocol::mutate_in_request_body::mutate_in_specs",
+    "couchbase::protocol::mutate_in_request_body::store_semantics_type",
+    "couchbase::protocol::durability_level",
+    "couchbase::error::common_errc",
+    "couchbase::error::key_value_errc",
+    "couchbase::error::query_errc",
+    "couchbase::error::analytics_errc",
+    "couchbase::error::search_errc",
+    "couchbase::error::view_errc",
+    "couchbase::error::management_errc",
+    "couchbase::error::field_level_encryption_errc",
+    "couchbase::error::network_errc",
+    "couchbase::analytics_scan_consistency",
+    "couchbase::cas",
+    "couchbase::design_document_namespace",
+    "couchbase::diag::cluster_state",
+    "couchbase::diag::endpoint_state",
+    "couchbase::diag::endpoint_diag_info",
+    "couchbase::diag::diagnostics_result",
+    "couchbase::diag::ping_state",
+    "couchbase::diag::endpoint_ping_info",
+    "couchbase::diag::ping_result",
+    "couchbase::document_id",
+    "couchbase::json_string",
+    "couchbase::mutation_token",
+    "couchbase::query_profile_mode",
+    "couchbase::query_scan_consistency",
+    "couchbase::search_highlight_style",
+    "couchbase::search_scan_consistency",
+    "couchbase::service_type",
+    "couchbase::view_scan_consistency",
+    "couchbase::view_sort_order",
+    "couchbase::operations::*",
+    "couchbase::operations::management::*",
+]
+
+# end of configurable part
+
+clang.cindex.Config.set_library_path(llvmLibPath)
+
+
+def list_headers_in_dir(path):
+    # enumerates a folder but keeps the full pathing for the files returned
+    # and removes certain files we don't want (like non-hxx, _json.hxx or _fmt.hxx)
+
+    # list all the files in the folder
+    files = os.listdir(path)
+    # only include .hxx files
+    files = list(filter(lambda x: x.endswith('.hxx'), files))
+    # add the folder path back on
+    files = list(map(lambda x: path + x, files))
+    return files
+
+
+# parse through the list of files specified and expand wildcards
+fullFileList = []
+for filePath in fileList:
+    if "*" in filePath:
+        # wildcard path
+        basePath = filePath[:-1]
+        if "*" in basePath:
+            # if there is still a wildcard, we have an issue...
+            raise NotImplementedError(
+                "wildcard only supported at end of file path")
+        files = list_headers_in_dir(os.path.join(cxxClientRoot, basePath))
+        fullFileList = fullFileList + files
+    else:
+        # normal path
+        fullFileList.append(os.path.join(cxxClientRoot, filePath))
+
+# exclude _json.hxx files
+fullFileList = list(
+    filter(lambda x: not x.endswith('_json.hxx'), fullFileList))
+# exclude _fmt.hxx files
+fullFileList = list(
+    filter(lambda x: not x.endswith('_fmt.hxx'), fullFileList))
+
+
+# generate a list of regexps from the type list (for handling wildcards)
+typeListRe = list(map(lambda x: x.replace("*", "(.*)") + "(.*)", typeList))
+
+
+def is_included_type(name):
+    for x in typeListRe:
+        if re.fullmatch(x, name):
+            return True
+    return False
+
+
+opTypes = []
+opEnums = []
+
+
+def parse_type(type):
+    typeStr = type.get_canonical().spelling
+    return parse_type_str(typeStr)
+
+
+def parse_type_str(typeStr):
+    if typeStr == "std::string":
+        return {"name": "std::string"}
+    if typeStr == "std::chrono::duration<long long>":
+        return {"name": "std::chrono::seconds"}
+    if typeStr == "std::chrono::duration<long long, std::ratio<1, 1000>>":
+        return {"name": "std::chrono::milliseconds"}
+    if typeStr == "std::chrono::duration<long long, std::ratio<1, 1000000>>":
+        return {"name": "std::chrono::microseconds"}
+    if typeStr == "std::chrono::duration<long long, std::ratio<1, 1000000000>>":
+        return {"name": "std::chrono::nanoseconds"}
+    if typeStr == "std::error_code":
+        return {"name": "std::error_code"}
+    if typeStr == "std::monostate":
+        return {"name": "std::monostate"}
+    if typeStr == "unsigned long":
+        return {"name": "std::size_t"}
+    if typeStr == "char":
+        return {"name": "std::int8_t"}
+    if typeStr == "unsigned char":
+        return {"name": "std::uint8_t"}
+    if typeStr == "short":
+        return {"name": "std::int16_t"}
+    if typeStr == "unsigned short":
+        return {"name": "std::uint16_t"}
+    if typeStr == "int":
+        return {"name": "std::int32_t"}
+    if typeStr == "unsigned int":
+        return {"name": "std::uint32_t"}
+    if typeStr == "long long":
+        return {"name": "std::int64_t"}
+    if typeStr == "unsigned long long":
+        return {"name": "std::uint64_t"}
+    if typeStr == "bool":
+        return {"name": "std::bool"}
+    if typeStr == "float":
+        return {"name": "std::float"}
+    if typeStr == "double":
+        return {"name": "std::double"}
+
+    tplParts = typeStr.split("<", 1)
+    if len(tplParts) > 1:
+        tplClassName = tplParts[0]
+        tplParams = tplParts[1][:-1]
+        if tplClassName == "std::function":
+            return {
+                "name": "std::function"
+            }
+        if tplClassName == "std::optional":
+            return {
+                "name": "std::optional",
+                "of": parse_type_str(tplParams)
+            }
+        if tplClassName == "std::vector":
+            return {
+                "name": "std::vector",
+                "of": parse_type_str(tplParams)
+            }
+        if tplClassName == "std::set":
+            return {
+                "name": "std::set",
+                "of": parse_type_str(tplParams)
+            }
+        if tplClassName == "std::variant":
+            variantParts = tplParams.split(", ")
+            variantTypes = []
+            for variantPart in variantParts:
+                variantTypes.append(parse_type_str(variantPart))
+            return {
+                "name": "std::variant",
+                "of": variantTypes
+            }
+        if tplClassName == "std::array":
+            variantParts = tplParams.split(", ")
+            if len(variantParts) != 2:
+                print("FAILED TO PARSE ARRAY TYPES: " + typeStr)
+                return {"name": "unknown", "str": typeStr}
+            return {
+                "name": "std::array",
+                "of": parse_type_str(variantParts[0]),
+                "size": int(variantParts[1])
+            }
+        if tplClassName == "std::map":
+            variantParts = tplParams.split(", ")
+            if len(variantParts) != 2:
+                print("FAILED TO PARSE MAP TYPES: " + typeStr)
+                return {"name": "unknown", "str": typeStr}
+            return {
+                "name": "std::map",
+                "of": parse_type_str(variantParts[0]),
+                "to": parse_type_str(variantParts[1])
+            }
+
+    if not typeStr.startswith("couchbase::"):
+        print("FAILED TO PARSE STRING TYPE: " + typeStr)
+        return {"name": "unknown", "str": typeStr}
+
+    return {"name": typeStr}
+
+
+def traverse(node, namespace, main_file):
+    # only scan the elements of the file we parsed
+    if node.location.file != None and node.location.file.name != main_file:
+        return
+
+    if node.kind == clang.cindex.CursorKind.STRUCT_DECL:
+        fullStructName = "::".join([*namespace, node.displayname])
+        if is_included_type(fullStructName):
+            structFields = []
+
+            for child in node.get_children():
+                if child.kind == clang.cindex.CursorKind.FIELD_DECL:
+                    structFields.append({
+                        "name": child.displayname,
+                        "type": parse_type(child.type),
+                    })
+
+            opTypes.append({
+                "name": fullStructName,
+                "fields": structFields,
+            })
+    if node.kind == clang.cindex.CursorKind.ENUM_DECL:
+        fullEnumName = "::".join([*namespace, node.displayname])
+        if is_included_type(fullEnumName):
+            enumValues = []
+
+            for child in node.get_children():
+                if child.kind == clang.cindex.CursorKind.ENUM_CONSTANT_DECL:
+                    enumValues.append({
+                        "name": child.displayname,
+                        "value": child.enum_value,
+                    })
+            opEnums.append({
+                "name": fullEnumName,
+                "type": parse_type(node.enum_type),
+                "values": enumValues,
+            })
+
+    if node.kind == clang.cindex.CursorKind.NAMESPACE:
+        namespace = [*namespace, node.displayname]
+    if node.kind == clang.cindex.CursorKind.CLASS_DECL:
+        namespace = [*namespace, node.displayname]
+    if node.kind == clang.cindex.CursorKind.STRUCT_DECL:
+        namespace = [*namespace, node.displayname]
+
+    for child in node.get_children():
+        traverse(child, namespace, main_file)
+
+
+for headerPath in fullFileList:
+    print("processing " + headerPath)
+    index = clang.cindex.Index.create()
+    args = [
+        '-std=c++17',
+        "-I" + cxxClientRoot + "/",
+        "-I" + cxxClientRoot + "/third_party/fmt/include",
+        "-I" + cxxClientRoot + "/third_party/gsl/include",
+        "-I" + cxxClientRoot + "/third_party/json/include",
+        "-I" + "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/13.0.0/include"
+    ]
+    translation_unit = index.parse(headerPath, args=args)
+
+    # output clang compiler diagnostics information (for debugging)
+    if 1:
+        for diagnostic in translation_unit.diagnostics:
+            diagnosticMsg = diagnostic.format()
+            print(diagnostic)
+
+    traverse(translation_unit.cursor, [], headerPath)
+
+jsonData = json.dumps({
+    'op_structs': opTypes,
+    'op_enums': opEnums
+})
+
+f = open("bindings.json", "w")
+f.write(jsonData)
+f.close()

package/deps/couchbase-cxx-client/couchbase/operations/document_observe.hxx

@@ -1,61 +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/error_context/key_value.hxx>
-#include <couchbase/io/mcbp_context.hxx>
-#include <couchbase/io/retry_context.hxx>
-#include <couchbase/protocol/client_request.hxx>
-#include <couchbase/timeout_defaults.hxx>
-#include <couchbase/protocol/cmd_exists.hxx>
-
-namespace couchbase::operations
-{
-
-struct exists_response {
-    enum class observe_status { invalid, found, not_found, persisted, logically_deleted };
-
-    error_context::key_value ctx;
-    std::uint16_t partition_id{};
-    protocol::cas cas{};
-    observe_status status{ observe_status::invalid };
-
-    [[nodiscard]] constexpr bool exists() const
-    {
-        return status == couchbase::operations::exists_response::observe_status::found ||
-               status == couchbase::operations::exists_response::observe_status::persisted;
-    }
-};
-
-struct exists_request {
-    using response_type = exists_response;
-    using encoded_request_type = protocol::client_request<protocol::exists_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::exists_response_body>;
-
-    document_id id;
-    std::uint16_t partition{};
-    std::uint32_t opaque{};
-    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
-    io::retry_context<io::retry_strategy::best_effort> retries{ false };
-
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context) const;
-
-    [[nodiscard]] exists_response make_response(error_context::key_value&& ctx, const encoded_response_type& encoded) const;
-};
-
-} // namespace couchbase::operations

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

@@ -1,128 +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>
-
-namespace couchbase::operations::management
-{
-struct bucket_settings {
-    enum class bucket_type { unknown, couchbase, memcached, ephemeral };
-    enum class compression_mode { unknown, off, active, passive };
-    enum class 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 conflict_resolution_type {
-        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 storage_backend_type { unknown, couchstore, magma };
-    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;
-    bucket_type bucket_type{ bucket_type::unknown };
-    std::uint64_t ram_quota_mb{ 100 };
-    std::uint32_t max_expiry{ 0 };
-    compression_mode compression_mode{ compression_mode::unknown };
-    std::optional<protocol::durability_level> minimum_durability_level{};
-    std::uint32_t num_replicas{ 1 };
-    bool replica_indexes{ false };
-    bool flush_enabled{ false };
-    eviction_policy eviction_policy{ eviction_policy::unknown };
-    conflict_resolution_type conflict_resolution_type{ conflict_resolution_type::unknown };
-
-    /**
-     * UNCOMMITTED: This API may change in the future
-     */
-    storage_backend_type storage_backend{ storage_backend_type::unknown };
-
-    /**
-     * UNCOMMITTED: read-only attribute
-     */
-    std::vector<std::string> capabilities{};
-
-    /**
-     * UNCOMMITTED: read-only attribute
-     */
-    std::vector<node> nodes{};
-};
-} // namespace couchbase::operations::management

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_observe.hxx

@@ -1,61 +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/error_context/key_value.hxx>
-#include <couchbase/io/mcbp_context.hxx>
-#include <couchbase/io/retry_context.hxx>
-#include <couchbase/protocol/client_request.hxx>
-#include <couchbase/timeout_defaults.hxx>
-#include <couchbase/protocol/cmd_exists.hxx>
-
-namespace couchbase::operations
-{
-
-struct exists_response {
-    enum class observe_status { invalid, found, not_found, persisted, logically_deleted };
-
-    error_context::key_value ctx;
-    std::uint16_t partition_id{};
-    protocol::cas cas{};
-    observe_status status{ observe_status::invalid };
-
-    [[nodiscard]] constexpr bool exists() const
-    {
-        return status == couchbase::operations::exists_response::observe_status::found ||
-               status == couchbase::operations::exists_response::observe_status::persisted;
-    }
-};
-
-struct exists_request {
-    using response_type = exists_response;
-    using encoded_request_type = protocol::client_request<protocol::exists_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::exists_response_body>;
-
-    document_id id;
-    std::uint16_t partition{};
-    std::uint32_t opaque{};
-    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
-    io::retry_context<io::retry_strategy::best_effort> retries{ false };
-
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context) const;
-
-    [[nodiscard]] exists_response make_response(error_context::key_value&& ctx, const encoded_response_type& encoded) const;
-};
-
-} // namespace couchbase::operations