couchbase 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19

data/ext/couchbase/platform/uuid.h

@@ -1,56 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2017 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 <array>
-#include <cstdint>
-#include <string>
-
-namespace couchbase::uuid
-{
-
-using uuid_t = std::array<uint8_t, 16>;
-
-/**
- * Get a random uuid (version 4 of the uuids)
- */
-void
-random(uuid_t& uuid);
-
-/**
- * Generate a new random uuid and return it
- */
-uuid_t
-random();
-
-/**
- * Convert a textual version of a UUID to a uuid type
- * @throw std::invalid_argument if the textual uuid is not
- *        formatted correctly
- */
-uuid_t
-from_string(std::string_view str);
-
-/**
- * Print a textual version of the UUID in the form:
- *
- *     00000000-0000-0000-0000-000000000000
- */
-std::string
-to_string(const couchbase::uuid::uuid_t& uuid);
-
-} // namespace couchbase::uuid

data/ext/couchbase/protocol/client_opcode.hxx

@@ -1,264 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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 <io/mcbp_message.hxx>
-
-namespace couchbase::protocol
-{
-enum class client_opcode : uint8_t {
-    get = 0x00,
-    upsert = 0x01,
-    insert = 0x02,
-    replace = 0x03,
-    remove = 0x04,
-    increment = 0x05,
-    decrement = 0x06,
-    touch = 0x1c,
-    get_and_touch = 0x1d,
-    hello = 0x1f,
-    sasl_list_mechs = 0x20,
-    sasl_auth = 0x21,
-    sasl_step = 0x22,
-    select_bucket = 0x89,
-    observe = 0x92,
-    get_and_lock = 0x94,
-    unlock = 0x95,
-    get_collections_manifest = 0xba,
-    get_collection_id = 0xbb,
-    subdoc_multi_lookup = 0xd0,
-    subdoc_multi_mutation = 0xd1,
-    get_cluster_config = 0xb5,
-    get_error_map = 0xfe,
-    invalid = 0xff,
-};
-
-/**
- * subdocument opcodes are listed separately, because we are not going to implement/support single-op messages
- */
-enum class subdoc_opcode : uint8_t {
-    get_doc = 0x00,
-    set_doc = 0x01,
-    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,
-};
-
-constexpr inline bool
-is_valid_client_opcode(uint8_t code)
-{
-    switch (static_cast<client_opcode>(code)) {
-        case client_opcode::get:
-        case client_opcode::upsert:
-        case client_opcode::insert:
-        case client_opcode::replace:
-        case client_opcode::remove:
-        case client_opcode::hello:
-        case client_opcode::sasl_list_mechs:
-        case client_opcode::sasl_auth:
-        case client_opcode::sasl_step:
-        case client_opcode::select_bucket:
-        case client_opcode::subdoc_multi_lookup:
-        case client_opcode::subdoc_multi_mutation:
-        case client_opcode::get_cluster_config:
-        case client_opcode::get_error_map:
-        case client_opcode::invalid:
-        case client_opcode::get_collections_manifest:
-        case client_opcode::touch:
-        case client_opcode::observe:
-        case client_opcode::get_and_lock:
-        case client_opcode::unlock:
-        case client_opcode::get_and_touch:
-        case client_opcode::increment:
-        case client_opcode::decrement:
-        case client_opcode::get_collection_id:
-            return true;
-    }
-    return false;
-}
-
-constexpr inline bool
-is_valid_subdoc_opcode(uint8_t code)
-{
-    switch (static_cast<subdoc_opcode>(code)) {
-        case subdoc_opcode::get:
-        case subdoc_opcode::exists:
-        case subdoc_opcode::dict_add:
-        case subdoc_opcode::dict_upsert:
-        case subdoc_opcode::remove:
-        case subdoc_opcode::replace:
-        case subdoc_opcode::array_push_last:
-        case subdoc_opcode::array_push_first:
-        case subdoc_opcode::array_insert:
-        case subdoc_opcode::array_add_unique:
-        case subdoc_opcode::counter:
-        case subdoc_opcode::get_count:
-        case subdoc_opcode::get_doc:
-        case subdoc_opcode::set_doc:
-            return true;
-    }
-    return false;
-}
-} // namespace couchbase::protocol
-
-template<>
-struct fmt::formatter<couchbase::protocol::client_opcode> : formatter<string_view> {
-    template<typename FormatContext>
-    auto format(couchbase::protocol::client_opcode opcode, FormatContext& ctx)
-    {
-        string_view name = "unknown";
-        switch (opcode) {
-            case couchbase::protocol::client_opcode::get:
-                name = "get (0x00)";
-                break;
-            case couchbase::protocol::client_opcode::upsert:
-                name = "upsert (0x01)";
-                break;
-            case couchbase::protocol::client_opcode::insert:
-                name = "insert (0x02)";
-                break;
-            case couchbase::protocol::client_opcode::replace:
-                name = "replace (0x03)";
-                break;
-            case couchbase::protocol::client_opcode::remove:
-                name = "remove (0x04)";
-                break;
-            case couchbase::protocol::client_opcode::hello:
-                name = "hello (0x1f)";
-                break;
-            case couchbase::protocol::client_opcode::sasl_list_mechs:
-                name = "sasl_list_mechs (0x20)";
-                break;
-            case couchbase::protocol::client_opcode::sasl_auth:
-                name = "sasl_auth (0x21)";
-                break;
-            case couchbase::protocol::client_opcode::sasl_step:
-                name = "sasl_step (0x22)";
-                break;
-            case couchbase::protocol::client_opcode::select_bucket:
-                name = "select_bucket (0x89)";
-                break;
-            case couchbase::protocol::client_opcode::subdoc_multi_lookup:
-                name = "subdoc_multi_lookup (0xd0)";
-                break;
-            case couchbase::protocol::client_opcode::subdoc_multi_mutation:
-                name = "subdoc_multi_mutation (0xd1)";
-                break;
-            case couchbase::protocol::client_opcode::get_cluster_config:
-                name = "get_cluster_config (0xb5)";
-                break;
-            case couchbase::protocol::client_opcode::get_error_map:
-                name = "get_error_map (0xfe)";
-                break;
-            case couchbase::protocol::client_opcode::invalid:
-                name = "invalid (0xff)";
-                break;
-            case couchbase::protocol::client_opcode::get_collections_manifest:
-                name = "get_collections_manifest (0xba)";
-                break;
-            case couchbase::protocol::client_opcode::touch:
-                name = "touch (0x1c)";
-                break;
-            case couchbase::protocol::client_opcode::observe:
-                name = "observe (0x92)";
-                break;
-            case couchbase::protocol::client_opcode::get_and_lock:
-                name = "get_and_lock (0x94)";
-                break;
-            case couchbase::protocol::client_opcode::unlock:
-                name = "unlock (0x95)";
-                break;
-            case couchbase::protocol::client_opcode::get_and_touch:
-                name = "get_and_touch (0x1d)";
-                break;
-            case couchbase::protocol::client_opcode::increment:
-                name = "increment (0x05)";
-                break;
-            case couchbase::protocol::client_opcode::decrement:
-                name = "decrement (0x06)";
-                break;
-            case couchbase::protocol::client_opcode::get_collection_id:
-                name = "get_collection_uid (0xbb)";
-                break;
-        }
-        return formatter<string_view>::format(name, ctx);
-    }
-};
-
-template<>
-struct fmt::formatter<couchbase::protocol::subdoc_opcode> : formatter<string_view> {
-    template<typename FormatContext>
-    auto format(couchbase::protocol::subdoc_opcode opcode, FormatContext& ctx)
-    {
-        string_view name = "unknown";
-        switch (opcode) {
-            case couchbase::protocol::subdoc_opcode::get:
-                name = "get (0xc5)";
-                break;
-            case couchbase::protocol::subdoc_opcode::exists:
-                name = "exists (0xc6)";
-                break;
-            case couchbase::protocol::subdoc_opcode::dict_add:
-                name = "dict_add (0xc7)";
-                break;
-            case couchbase::protocol::subdoc_opcode::dict_upsert:
-                name = "dict_upsert (0xc8)";
-                break;
-            case couchbase::protocol::subdoc_opcode::remove:
-                name = "remove (0xc9)";
-                break;
-            case couchbase::protocol::subdoc_opcode::replace:
-                name = "replace (0xca)";
-                break;
-            case couchbase::protocol::subdoc_opcode::array_push_last:
-                name = "array_push_last (0xcb)";
-                break;
-            case couchbase::protocol::subdoc_opcode::array_push_first:
-                name = "array_push_first (0xcc)";
-                break;
-            case couchbase::protocol::subdoc_opcode::array_insert:
-                name = "array_insert (0xcd)";
-                break;
-            case couchbase::protocol::subdoc_opcode::array_add_unique:
-                name = "array_add_unique (0xce)";
-                break;
-            case couchbase::protocol::subdoc_opcode::counter:
-                name = "counter (0xcf)";
-                break;
-            case couchbase::protocol::subdoc_opcode::get_count:
-                name = "get_count (0xd2)";
-                break;
-            case couchbase::protocol::subdoc_opcode::get_doc:
-                name = "get_doc (0x00)";
-                break;
-            case couchbase::protocol::subdoc_opcode::set_doc:
-                name = "set_doc (0x01)";
-                break;
-        }
-        return formatter<string_view>::format(name, ctx);
-    }
-};

data/ext/couchbase/protocol/client_request.hxx

@@ -1,160 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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
-
-#ifndef WIN32
-#include <arpa/inet.h>
-#endif
-
-#include <snappy.h>
-
-#include <gsl/gsl_util>
-#include <protocol/client_opcode.hxx>
-#include <protocol/magic.hxx>
-#include <protocol/client_response.hxx>
-
-namespace couchbase::protocol
-{
-template<typename Body>
-class client_request
-{
-  public:
-    using body_type = Body;
-    using response_body_type = typename Body::response_body_type;
-    using response_type = client_response<response_body_type>;
-
-  private:
-    magic magic_{ magic::client_request };
-
-    client_opcode opcode_{ Body::opcode };
-    std::uint16_t partition_{ 0 };
-    std::uint32_t opaque_{ 0 };
-    std::uint64_t cas_{ 0 };
-    Body body_;
-    std::vector<std::uint8_t> payload_;
-
-  public:
-    client_opcode opcode()
-    {
-        return opcode_;
-    }
-
-    void opaque(std::uint32_t val)
-    {
-        opaque_ = val;
-    }
-
-    void cas(std::uint64_t val)
-    {
-        cas_ = val;
-    }
-
-    std::uint32_t opaque()
-    {
-        return opaque_;
-    }
-
-    void opcode(client_opcode val)
-    {
-        opcode_ = val;
-    }
-
-    void partition(std::uint16_t val)
-    {
-        partition_ = val;
-    }
-
-    Body& body()
-    {
-        return body_;
-    }
-
-    std::vector<std::uint8_t>& data(bool try_to_compress = false)
-    {
-        switch (opcode_) {
-            case protocol::client_opcode::insert:
-            case protocol::client_opcode::upsert:
-            case protocol::client_opcode::replace:
-                write_payload(try_to_compress);
-                break;
-            default:
-                write_payload(false);
-                break;
-        }
-        return payload_;
-    }
-
-  private:
-    void write_payload(bool try_to_compress)
-    {
-        payload_.resize(header_size + body_.size(), 0);
-        payload_[0] = static_cast<uint8_t>(magic_);
-        payload_[1] = static_cast<uint8_t>(opcode_);
-
-        auto framing_extras = body_.framing_extras();
-
-        uint16_t key_size = gsl::narrow_cast<uint16_t>(body_.key().size());
-        if (framing_extras.size() == 0) {
-            key_size = htons(key_size);
-            memcpy(payload_.data() + 2, &key_size, sizeof(key_size));
-        } else {
-            magic_ = protocol::magic::alt_client_request;
-            payload_[0] = static_cast<uint8_t>(magic_);
-            payload_[2] = gsl::narrow_cast<std::uint8_t>(framing_extras.size());
-            payload_[3] = gsl::narrow_cast<std::uint8_t>(key_size);
-        }
-
-        uint8_t ext_size = gsl::narrow_cast<uint8_t>(body_.extras().size());
-        memcpy(payload_.data() + 4, &ext_size, sizeof(ext_size));
-
-        uint16_t vbucket = ntohs(gsl::narrow_cast<uint16_t>(partition_));
-        memcpy(payload_.data() + 6, &vbucket, sizeof(vbucket));
-
-        uint32_t body_size = htonl(gsl::narrow_cast<uint32_t>(body_.size()));
-        memcpy(payload_.data() + 8, &body_size, sizeof(body_size));
-
-        memcpy(payload_.data() + 12, &opaque_, sizeof(opaque_));
-        memcpy(payload_.data() + 16, &cas_, sizeof(cas_));
-
-        auto body_itr = payload_.begin() + header_size;
-        if (framing_extras.size() > 0) {
-            body_itr = std::copy(framing_extras.begin(), framing_extras.end(), body_itr);
-        }
-        body_itr = std::copy(body_.extras().begin(), body_.extras().end(), body_itr);
-        body_itr = std::copy(body_.key().begin(), body_.key().end(), body_itr);
-
-        static const std::size_t min_size_to_compress = 32;
-        static const double min_ratio = 0.83;
-        if (try_to_compress && body_.value().size() > min_size_to_compress) {
-            std::string compressed;
-            std::size_t compressed_size =
-              snappy::Compress(reinterpret_cast<const char*>(body_.value().data()), body_.value().size(), &compressed);
-            if (gsl::narrow_cast<double>(compressed_size) / gsl::narrow_cast<double>(body().value().size()) < min_ratio) {
-                std::copy(compressed.begin(), compressed.end(), body_itr);
-                payload_[5] |= static_cast<uint8_t>(protocol::datatype::snappy);
-                size_t new_body_size = body_.size() - (body_.value().size() - compressed_size);
-                body_size = htonl(gsl::narrow_cast<uint32_t>(new_body_size));
-                memcpy(payload_.data() + 8, &body_size, sizeof(body_size));
-                payload_.resize(header_size + new_body_size);
-                return;
-            }
-        }
-        std::copy(body_.value().begin(), body_.value().end(), body_itr);
-    }
-};
-} // namespace couchbase::protocol