couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/impl/subdoc/mutate_in_specs.cxx

@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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.
+ */
+
+#include "command_bundle.hxx"
+
+#include <couchbase/mutate_in_specs.hxx>
+
+namespace couchbase
+{
+auto
+mutate_in_specs::specs() const -> const std::vector<core::impl::subdoc::command>&
+{
+    static std::vector<core::impl::subdoc::command> empty{};
+    if (specs_ == nullptr) {
+        return empty;
+    }
+    return specs_->specs();
+}
+
+auto
+mutate_in_specs::bundle() -> core::impl::subdoc::command_bundle&
+{
+    if (specs_ == nullptr) {
+        specs_ = std::make_shared<core::impl::subdoc::command_bundle>();
+    }
+    return *specs_;
+}
+} // namespace couchbase

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/impl/subdoc/opcode.hxx

@@ -0,0 +1,47 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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 <cinttypes>
+#include <string>
+
+namespace couchbase::core::impl::subdoc
+{
+/**
+ * @since 1.0.0
+ * @internal
+ */
+enum class opcode : std::uint8_t {
+    get_doc = 0x00,
+    set_doc = 0x01,
+    remove_doc = 0x04,
+    get = 0xc5,
+    exists = 0xc6,
+    dict_add = 0xc7,
+    dict_upsert = 0xc8,
+    remove = 0xc9,
+    replace = 0xca,
+    array_push_last = 0xcb,
+    array_push_first = 0xcc,
+    array_insert = 0xcd,
+    array_add_unique = 0xce,
+    counter = 0xcf,
+    get_count = 0xd2,
+    replace_body_with_xattr = 0xd3,
+};
+} // namespace couchbase::core::impl::subdoc

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/impl/subdoc/path_flags.hxx

@@ -0,0 +1,77 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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 "command.hxx"
+
+#include <cinttypes>
+#include <cstddef>
+#include <string>
+
+namespace couchbase::core::impl::subdoc
+{
+/**
+ * Should non-existent intermediate paths be created
+ */
+constexpr std::byte path_flag_create_parents{ 0b0000'0001U };
+
+/**
+ * If set, the path refers to an Extended Attribute (XATTR).
+ * If clear, the path refers to a path inside the document body.
+ */
+constexpr std::byte path_flag_xattr{ 0b0000'0100U };
+
+/**
+ * Expand macro values inside extended attributes. The request is
+ * invalid if this flag is set without `path_flag_create_parents` being set.
+ */
+constexpr std::byte path_flag_expand_macros{ 0b0001'0000U };
+
+constexpr std::byte
+build_mutate_in_path_flags(bool xattr, bool create_path, bool expand_macro)
+{
+    std::byte flags{ 0 };
+    if (xattr) {
+        flags |= path_flag_xattr;
+    }
+    if (create_path) {
+        flags |= path_flag_create_parents;
+    }
+    if (expand_macro) {
+        flags |= path_flag_expand_macros;
+    }
+    return flags;
+}
+
+constexpr std::byte
+build_lookup_in_path_flags(bool xattr)
+{
+    std::byte flags{ 0U };
+    if (xattr) {
+        flags |= path_flag_xattr;
+    }
+    return flags;
+}
+
+constexpr bool
+has_xattr_path_flag(std::byte flags)
+{
+    return (flags & path_flag_xattr) == path_flag_xattr;
+}
+
+} // namespace couchbase::core::impl::subdoc

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/impl/subdoc/remove.cxx

@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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.
+ */
+
+#include "command_bundle.hxx"
+#include "opcode.hxx"
+#include "path_flags.hxx"
+
+#include <couchbase/subdoc/remove.hxx>
+
+namespace couchbase
+{
+void
+subdoc::remove::encode(core::impl::subdoc::command_bundle& bundle) const
+{
+    bundle.emplace_back({
+      path_.empty() ? core::impl::subdoc::opcode::remove_doc : core::impl::subdoc::opcode::remove,
+      path_,
+      {},
+      core::impl::subdoc::build_mutate_in_path_flags(xattr_, false, false),
+    });
+}
+} // namespace couchbase

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/impl/subdoc/replace.cxx

@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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.
+ */
+
+#include "command_bundle.hxx"
+#include "opcode.hxx"
+#include "path_flags.hxx"
+
+#include <couchbase/subdoc/replace.hxx>
+
+namespace couchbase
+{
+void
+subdoc::replace::encode(core::impl::subdoc::command_bundle& bundle) const
+{
+    bundle.emplace_back({
+      path_.empty() ? core::impl::subdoc::opcode::set_doc : core::impl::subdoc::opcode::replace,
+      path_,
+      value_,
+      core::impl::subdoc::build_mutate_in_path_flags(xattr_, false, expand_macro_),
+    });
+}
+} // namespace couchbase

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/impl/subdoc/upsert.cxx

@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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.
+ */
+
+#include "command_bundle.hxx"
+#include "opcode.hxx"
+#include "path_flags.hxx"
+
+#include <couchbase/subdoc/upsert.hxx>
+
+namespace couchbase
+{
+void
+subdoc::upsert::encode(core::impl::subdoc::command_bundle& bundle) const
+{
+    bundle.emplace_back({
+      core::impl::subdoc::opcode::dict_upsert,
+      path_,
+      value_,
+      core::impl::subdoc::build_mutate_in_path_flags(xattr_, create_path_, expand_macro_),
+    });
+}
+} // namespace couchbase

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/impl/touch.cxx

@@ -0,0 +1,48 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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.
+ */
+
+#include "core/cluster.hxx"
+#include "core/error_context/key_value.hxx"
+#include "core/operations/document_touch.hxx"
+
+#include <couchbase/touch_options.hxx>
+
+namespace couchbase::core::impl
+{
+void
+initiate_touch_operation(std::shared_ptr<couchbase::core::cluster> core,
+                         std::string bucket_name,
+                         std::string scope_name,
+                         std::string collection_name,
+                         std::string document_key,
+                         std::uint32_t expiry,
+                         touch_options::built options,
+                         touch_handler&& handler)
+{
+    core->execute(
+      operations::touch_request{
+        document_id{ std::move(bucket_name), std::move(scope_name), std::move(collection_name), std::move(document_key) },
+        {},
+        {},
+        expiry,
+        options.timeout,
+      },
+      [handler = std::move(handler)](operations::touch_response&& resp) mutable {
+          return handler(std::move(resp.ctx), result{ resp.cas });
+      });
+}
+} // namespace couchbase::core::impl

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/impl/upsert.cxx

@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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.
+ */
+
+#include "core/cluster.hxx"
+#include "core/error_context/key_value.hxx"
+#include "core/impl/observe_poll.hxx"
+#include "core/impl/observe_seqno.hxx"
+#include "core/operations/document_upsert.hxx"
+
+#include <couchbase/upsert_options.hxx>
+
+#include <utility>
+
+namespace couchbase::core::impl
+{
+
+void
+initiate_upsert_operation(std::shared_ptr<couchbase::core::cluster> core,
+                          std::string bucket_name,
+                          std::string scope_name,
+                          std::string collection_name,
+                          std::string document_key,
+                          codec::encoded_value encoded,
+                          upsert_options::built options,
+                          upsert_handler&& handler)
+{
+    auto value = std::move(encoded);
+    auto id = document_id{
+        std::move(bucket_name),
+        std::move(scope_name),
+        std::move(collection_name),
+        std::move(document_key),
+    };
+    if (options.persist_to == persist_to::none && options.replicate_to == replicate_to::none) {
+        return core->execute(
+          operations::upsert_request{
+            std::move(id),
+            std::move(value.data),
+            {},
+            {},
+            value.flags,
+            options.expiry,
+            options.durability_level,
+            options.timeout,
+            {},
+            options.preserve_expiry,
+          },
+          [handler = std::move(handler)](operations::upsert_response&& resp) mutable {
+              return handler(std::move(resp.ctx), mutation_result{ resp.cas, std::move(resp.token) });
+          });
+    }
+
+    operations::upsert_request request{
+        id, std::move(value.data), {}, {}, value.flags, options.expiry, durability_level::none, options.timeout, {}, options.preserve_expiry
+    };
+    return core->execute(
+      std::move(request), [core, id = std::move(id), options, handler = std::move(handler)](operations::upsert_response&& resp) mutable {
+          if (resp.ctx.ec()) {
+              return handler(std::move(resp.ctx), mutation_result{ resp.cas, std::move(resp.token) });
+          }
+
+          initiate_observe_poll(core,
+                                std::move(id),
+                                resp.token,
+                                options.timeout,
+                                options.persist_to,
+                                options.replicate_to,
+                                [resp = std::move(resp), handler = std::move(handler)](std::error_code ec) mutable {
+                                    if (ec) {
+                                        resp.ctx.override_ec(ec);
+                                        return handler(std::move(resp.ctx), mutation_result{});
+                                    }
+                                    return handler(std::move(resp.ctx), mutation_result{ resp.cas, std::move(resp.token) });
+                                });
+      });
+}
+} // namespace couchbase::core::impl

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/impl/view_error_category.cxx

@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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.
+ */
+
+#include <couchbase/error_codes.hxx>
+
+#include <string>
+
+namespace couchbase::core::impl
+{
+
+struct view_error_category : std::error_category {
+    [[nodiscard]] const char* name() const noexcept override
+    {
+        return "couchbase.view";
+    }
+
+    [[nodiscard]] std::string message(int ev) const noexcept override
+    {
+        switch (static_cast<errc::view>(ev)) {
+            case errc::view::view_not_found:
+                return "view_not_found (501)";
+            case errc::view::design_document_not_found:
+                return "design_document_not_found (502)";
+        }
+        return "FIXME: unknown error code (recompile with newer library): couchbase.view." + std::to_string(ev);
+    }
+};
+const inline static view_error_category category_instance;
+
+const std::error_category&
+view_category() noexcept
+{
+    return category_instance;
+}
+
+} // namespace couchbase::core::impl

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/impl/with_legacy_durability.hxx

@@ -0,0 +1,65 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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 "observe_poll.hxx"
+
+#include <couchbase/persist_to.hxx>
+#include <couchbase/replicate_to.hxx>
+
+#include <memory>
+
+namespace couchbase::core::impl
+{
+template<typename mutation_request>
+struct with_legacy_durability : public mutation_request {
+    couchbase::persist_to persist_to{ couchbase::persist_to::none };
+    couchbase::replicate_to replicate_to{ couchbase::replicate_to::none };
+
+    template<typename Core, typename Handler>
+    void execute(Core core, Handler handler)
+    {
+        using mutation_response = typename mutation_request::response_type;
+        core->template execute<mutation_request>(*this,
+                                                 [core,
+                                                  id = mutation_request::id,
+                                                  timeout = mutation_request::timeout,
+                                                  persist_to = persist_to,
+                                                  replicate_to = replicate_to,
+                                                  handler = std::forward<Handler>(handler)](mutation_response&& resp) mutable {
+                                                     if (resp.ctx.ec()) {
+                                                         return handler(std::move(resp));
+                                                     }
+
+                                                     initiate_observe_poll(
+                                                       core,
+                                                       id,
+                                                       resp.token,
+                                                       timeout,
+                                                       persist_to,
+                                                       replicate_to,
+                                                       [resp = std::move(resp), handler = std::move(handler)](std::error_code ec) mutable {
+                                                           if (ec) {
+                                                               resp.ctx.override_ec(ec);
+                                                           }
+                                                           return handler(std::move(resp));
+                                                       });
+                                                 });
+    }
+};
+} // namespace couchbase::core::impl

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/io/CMakeLists.txt

@@ -0,0 +1,12 @@
+add_library(couchbase_io STATIC mcbp_message.cxx mcbp_parser.cxx http_parser.cxx)
+set_target_properties(couchbase_io PROPERTIES POSITION_INDEPENDENT_CODE ON)
+add_dependencies(couchbase_io http_parser)
+target_link_libraries(
+  couchbase_io
+  PRIVATE project_options
+          project_warnings
+          snappy
+          http_parser
+          fmt::fmt
+          spdlog::spdlog)
+target_include_directories(couchbase_io PRIVATE ../.. ../../third_party/http_parser)