couchbase 3.0.0.alpha.5-x86_64-linux → 3.5.1-x86_64-linux

data/ext/couchbase/platform/random.h

@@ -1,39 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2014 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 <cstddef>
-#include <cstdint>
-
-namespace couchbase
-{
-class RandomGeneratorProvider;
-
-/**
- * The RandomGenerator use windows crypto framework on windows and
- * /dev/urandom on the other platforms in order to get random data.
- */
-class RandomGenerator
-{
-  public:
-    RandomGenerator();
-
-    uint64_t next();
-
-    bool getBytes(void* dest, size_t size);
-};
-} // namespace couchbase

data/ext/couchbase/platform/string_hex.cc

@@ -1,99 +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.
- */
-
-#include <platform/string_hex.h>
-
-#include <cinttypes>
-#include <iomanip>
-#include <sstream>
-#include <stdexcept>
-#include <string>
-
-static inline uint8_t
-from_hex_digit(char c)
-{
-    if ('0' <= c && c <= '9') {
-        return static_cast<uint8_t>(c - '0');
-    } else if ('A' <= c && c <= 'F') {
-        return static_cast<uint8_t>(c + 10 - 'A');
-    } else if ('a' <= c && c <= 'f') {
-        return static_cast<uint8_t>(c + 10 - 'a');
-    }
-    throw std::invalid_argument("couchbase::from_hex_digit: character was not in hexadecimal range");
-}
-
-uint64_t
-couchbase::from_hex(std::string_view buffer)
-{
-    uint64_t ret = 0;
-    if (buffer.size() > 16) {
-        throw std::overflow_error("couchbase::from_hex: input string too long: " + std::to_string(buffer.size()));
-    }
-
-    for (char digit : buffer) {
-        ret = (ret << 4) | from_hex_digit(digit);
-    }
-
-    return ret;
-}
-
-std::string
-couchbase::to_hex(uint8_t val)
-{
-    char buf[32];
-    snprintf(buf, sizeof(buf), "0x%02" PRIx8, val);
-    return std::string{ buf };
-}
-
-std::string
-couchbase::to_hex(uint16_t val)
-{
-    char buf[32];
-    snprintf(buf, sizeof(buf), "0x%04" PRIx16, val);
-    return std::string{ buf };
-}
-
-std::string
-couchbase::to_hex(uint32_t val)
-{
-    char buf[32];
-    snprintf(buf, sizeof(buf), "0x%08" PRIx32, val);
-    return std::string{ buf };
-}
-
-std::string
-couchbase::to_hex(uint64_t val)
-{
-    char buf[32];
-    snprintf(buf, sizeof(buf), "0x%016" PRIx64, val);
-    return std::string{ buf };
-}
-
-std::string
-couchbase::to_hex(std::string_view buffer)
-{
-    if (buffer.empty()) {
-        return "";
-    }
-    std::stringstream ss;
-    for (const auto& c : buffer) {
-        ss << "0x" << std::hex << std::setfill('0') << std::setw(2) << uint32_t(c) << " ";
-    }
-    auto ret = ss.str();
-    ret.resize(ret.size() - 1);
-    return ret;
-}

data/ext/couchbase/platform/string_hex.h

@@ -1,50 +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 <string_view>
-#include <cstdint>
-
-namespace couchbase
-{
-/**
- * Get the value for a string of hex characters
- *
- * @param buffer the input buffer
- * @return the value of the string
- * @throws std::invalid_argument for an invalid character in the string
- *         std::overflow_error if the input string won't fit in uint64_t
- */
-uint64_t
-from_hex(std::string_view buffer);
-
-std::string
-to_hex(std::uint8_t val);
-
-std::string
-to_hex(std::uint16_t val);
-
-std::string
-to_hex(std::uint32_t val);
-
-std::string
-to_hex(std::uint64_t val);
-
-std::string
-to_hex(std::string_view buffer);
-
-} // namespace couchbase

data/ext/couchbase/platform/uuid.cc

@@ -1,96 +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.
- */
-#include <platform/uuid.h>
-#include <platform/string_hex.h>
-
-#include <iomanip>
-#include <random>
-#include <sstream>
-
-void
-couchbase::uuid::random(couchbase::uuid::uuid_t& uuid)
-{
-    std::random_device rd;
-    std::mt19937 gen(rd());
-    std::uniform_int_distribution<uint64_t> dis;
-
-    // The uuid is 16 bytes, which is the same as two 64 bit integers
-    auto* ptr = reinterpret_cast<uint64_t*>(uuid.data());
-    ptr[0] = dis(gen);
-    ptr[1] = dis(gen);
-
-    // Make sure that it looks like a version 4
-    uuid[6] &= 0x0f;
-    uuid[6] |= 0x40;
-}
-
-couchbase::uuid::uuid_t
-couchbase::uuid::random()
-{
-    uuid_t ret;
-    random(ret);
-    return ret;
-}
-
-couchbase::uuid::uuid_t
-couchbase::uuid::from_string(std::string_view str)
-{
-    uuid_t ret;
-    if (str.size() != 36) {
-        throw std::invalid_argument("couchbase::uuid::from_string: string was wrong size got: " + std::to_string(str.size()) +
-                                    " (expected: 36)");
-    }
-
-    size_t jj = 0;
-    for (size_t ii = 0; ii < 36; ii += 2) {
-        switch (ii) {
-            case 8:
-            case 13:
-            case 18:
-            case 23:
-                if (str[ii] != '-') {
-                    throw std::invalid_argument("couchbase::uuid::from_string: hyphen not found where "
-                                                "expected");
-                }
-                ++ii; // fall-through
-            default:
-                ret[jj++] = uint8_t(couchbase::from_hex({ str.data() + ii, 2 }));
-        }
-    }
-    return ret;
-}
-
-std::string
-couchbase::uuid::to_string(const couchbase::uuid::uuid_t& uuid)
-{
-    std::stringstream ss;
-    ss << std::hex << std::setfill('0');
-    int ii = 0;
-    for (const auto& c : uuid) {
-        ss << std::setw(2) << uint32_t(c);
-        switch (++ii) {
-            case 4:
-            case 6:
-            case 8:
-            case 10:
-                ss << '-';
-            default:;
-        }
-    }
-
-    return ss.str();
-}

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";
-                break;
-            case couchbase::protocol::client_opcode::upsert:
-                name = "upsert";
-                break;
-            case couchbase::protocol::client_opcode::insert:
-                name = "insert";
-                break;
-            case couchbase::protocol::client_opcode::replace:
-                name = "replace";
-                break;
-            case couchbase::protocol::client_opcode::remove:
-                name = "remove";
-                break;
-            case couchbase::protocol::client_opcode::hello:
-                name = "hello";
-                break;
-            case couchbase::protocol::client_opcode::sasl_list_mechs:
-                name = "sasl_list_mechs";
-                break;
-            case couchbase::protocol::client_opcode::sasl_auth:
-                name = "sasl_auth";
-                break;
-            case couchbase::protocol::client_opcode::sasl_step:
-                name = "sasl_step";
-                break;
-            case couchbase::protocol::client_opcode::select_bucket:
-                name = "select_bucket";
-                break;
-            case couchbase::protocol::client_opcode::subdoc_multi_lookup:
-                name = "subdoc_multi_lookup";
-                break;
-            case couchbase::protocol::client_opcode::subdoc_multi_mutation:
-                name = "subdoc_multi_mutation";
-                break;
-            case couchbase::protocol::client_opcode::get_cluster_config:
-                name = "get_cluster_config";
-                break;
-            case couchbase::protocol::client_opcode::get_error_map:
-                name = "get_error_map";
-                break;
-            case couchbase::protocol::client_opcode::invalid:
-                name = "invalid";
-                break;
-            case couchbase::protocol::client_opcode::get_collections_manifest:
-                name = "get_collections_manifest";
-                break;
-            case couchbase::protocol::client_opcode::touch:
-                name = "touch";
-                break;
-            case couchbase::protocol::client_opcode::observe:
-                name = "observe";
-                break;
-            case couchbase::protocol::client_opcode::get_and_lock:
-                name = "get_and_lock";
-                break;
-            case couchbase::protocol::client_opcode::unlock:
-                name = "unlock";
-                break;
-            case couchbase::protocol::client_opcode::get_and_touch:
-                name = "get_and_touch";
-                break;
-            case couchbase::protocol::client_opcode::increment:
-                name = "increment";
-                break;
-            case couchbase::protocol::client_opcode::decrement:
-                name = "decrement";
-                break;
-            case couchbase::protocol::client_opcode::get_collection_id:
-                name = "get_collection_uid";
-                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";
-                break;
-            case couchbase::protocol::subdoc_opcode::exists:
-                name = "exists";
-                break;
-            case couchbase::protocol::subdoc_opcode::dict_add:
-                name = "dict_add";
-                break;
-            case couchbase::protocol::subdoc_opcode::dict_upsert:
-                name = "dict_upsert";
-                break;
-            case couchbase::protocol::subdoc_opcode::remove:
-                name = "remove";
-                break;
-            case couchbase::protocol::subdoc_opcode::replace:
-                name = "replace";
-                break;
-            case couchbase::protocol::subdoc_opcode::array_push_last:
-                name = "array_push_last";
-                break;
-            case couchbase::protocol::subdoc_opcode::array_push_first:
-                name = "array_push_first";
-                break;
-            case couchbase::protocol::subdoc_opcode::array_insert:
-                name = "array_insert";
-                break;
-            case couchbase::protocol::subdoc_opcode::array_add_unique:
-                name = "array_add_unique";
-                break;
-            case couchbase::protocol::subdoc_opcode::counter:
-                name = "counter";
-                break;
-            case couchbase::protocol::subdoc_opcode::get_count:
-                name = "get_count";
-                break;
-            case couchbase::protocol::subdoc_opcode::get_doc:
-                name = "get_doc";
-                break;
-            case couchbase::protocol::subdoc_opcode::set_doc:
-                name = "set_doc";
-                break;
-        }
-        return formatter<string_view>::format(name, ctx);
-    }
-};