couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/platform/random.cc

@@ -1,120 +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.
- */
-
-#include <couchbase/platform/random.h>
-
-#include <cerrno>
-#include <chrono>
-#include <memory>
-#include <mutex>
-#include <system_error>
-
-#ifdef WIN32
-// We need to include windows.h _before_ wincrypt.h
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-
-#include <wincrypt.h>
-#else
-#include <fcntl.h>
-#include <unistd.h>
-#endif
-
-namespace couchbase
-{
-class RandomGeneratorProvider
-{
-  public:
-    RandomGeneratorProvider()
-    {
-#ifdef WIN32
-        if (!CryptAcquireContext(&handle, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
-            throw std::system_error(int(GetLastError()),
-                                    std::system_category(),
-                                    "RandomGeneratorProvider::Failed to "
-                                    "initialize random generator");
-        }
-#else
-        if ((handle = open("/dev/urandom", O_RDONLY)) == -1) {
-            throw std::system_error(errno,
-                                    std::system_category(),
-                                    "RandomGeneratorProvider::Failed to "
-                                    "initialize random generator");
-        }
-#endif
-    }
-
-    virtual ~RandomGeneratorProvider()
-    {
-#ifdef WIN32
-        CryptReleaseContext(handle, 0);
-#else
-        close(handle);
-#endif
-    }
-
-    bool getBytes(void* dest, size_t size)
-    {
-        std::lock_guard<std::mutex> lock(mutex);
-#ifdef WIN32
-        return CryptGenRandom(handle, (DWORD)size, static_cast<BYTE*>(dest));
-#else
-        return size_t(read(handle, dest, size)) == size;
-#endif
-    }
-
-  protected:
-#ifdef WIN32
-    HCRYPTPROV handle{};
-#else
-    int handle = -1;
-#endif
-    std::mutex mutex;
-};
-
-std::mutex shared_provider_lock;
-std::unique_ptr<RandomGeneratorProvider> shared_provider;
-
-RandomGenerator::RandomGenerator()
-{
-    if (!shared_provider) {
-        // This might be the first one, lets lock and create
-        std::lock_guard<std::mutex> guard(shared_provider_lock);
-        if (!shared_provider) {
-            shared_provider = std::make_unique<RandomGeneratorProvider>();
-        }
-    }
-}
-
-uint64_t
-RandomGenerator::next()
-{
-    uint64_t ret;
-    if (getBytes(&ret, sizeof(ret))) {
-        return ret;
-    }
-
-    return static_cast<uint64_t>(std::chrono::steady_clock::now().time_since_epoch().count());
-}
-
-bool
-RandomGenerator::getBytes(void* dest, size_t size)
-{
-    return shared_provider->getBytes(dest, size);
-}
-
-} // namespace couchbase

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/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

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/platform/string_hex.cc

@@ -1,101 +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 <couchbase/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');
-    }
-    if ('A' <= c && c <= 'F') {
-        return static_cast<uint8_t>(c + 10 - 'A');
-    }
-    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;
-}

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/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 <cstdint>
-#include <string_view>
-
-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

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/platform/terminate_handler.cc

@@ -1,125 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2016 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/platform/terminate_handler.h>
-
-#include <couchbase/logger/logger.hxx>
-#include <couchbase/meta/version.hxx>
-#include <couchbase/platform/backtrace.h>
-
-#include <cstdlib>
-#include <exception>
-
-namespace couchbase::platform
-{
-static bool should_include_backtrace = true;
-static std::terminate_handler default_terminate_handler = nullptr;
-
-// Logs details on the handled exception. Attempts to log to
-// `terminate_logger` if non-null; otherwise prints to stderr.
-static void
-log_handled_exception()
-{
-#ifdef WIN32
-    // Windows doesn't like us re-throwing the exception in the handler (and
-    // seems to result in immediate process termination). As such skip logging
-    // the exception here.
-    return;
-#else
-    // Attempt to get the exception's what() message.
-    try {
-        static int tried_throw = 0;
-        // try once to re-throw currently active exception (so we can print
-        // its what() message).
-        if (tried_throw++ == 0) {
-            throw;
-        }
-    } catch (const std::exception& e) {
-        LOG_CRITICAL("Caught unhandled std::exception-derived exception. what(): {}", e.what());
-    } catch (...) {
-        LOG_CRITICAL_RAW("Caught unknown/unhandled exception.");
-    }
-#endif
-}
-
-// Log the symbolified backtrace to this point.
-static void
-log_backtrace()
-{
-    static const char format_str[] = "Call stack:\n%s";
-
-    char buffer[8192];
-    if (print_backtrace_to_buffer("    ", buffer, sizeof(buffer))) {
-        LOG_CRITICAL("Call stack:\n{}", buffer);
-    } else {
-        // Exceeded buffer space - print directly to stderr FD (requires no
-        // buffering, but has the disadvantage that we don't get it in the log).
-        fprintf(stderr, format_str, "");
-        print_backtrace_to_file(stderr);
-        fflush(stderr);
-        LOG_CRITICAL_RAW("Call stack exceeds 8k, rendered to STDERR");
-    }
-}
-
-// Replacement terminate_handler which prints the exception's what() and a
-// backtrace of the current stack before chaining to the default handler.
-static void
-backtrace_terminate_handler()
-{
-    static bool meta_reported = false;
-    if (!meta_reported) {
-        LOG_CRITICAL(R"(*** Fatal error encountered during exception handling ({}) ***)", meta::sdk_build_info_short());
-        meta_reported = true;
-    }
-    log_handled_exception();
-
-    if (should_include_backtrace) {
-        log_backtrace();
-    }
-
-    // Chain to the default handler if available (as it may be able to print
-    // other useful information on why we were told to terminate).
-    if (default_terminate_handler != nullptr && default_terminate_handler != backtrace_terminate_handler) {
-        default_terminate_handler();
-    }
-
-#if !defined(HAVE_BREAKPAD)
-    // Shut down the logger (and flush everything). If breakpad is installed
-    // then we'll let it do it.
-    logger::shutdown();
-#endif
-
-    std::abort();
-}
-
-void
-install_backtrace_terminate_handler()
-{
-    if (default_terminate_handler != nullptr) {
-        // restore the previously saved one before (re)installing ours.
-        std::set_terminate(default_terminate_handler);
-    }
-    default_terminate_handler = std::set_terminate(backtrace_terminate_handler);
-}
-
-void
-set_terminate_handler_print_backtrace(bool print)
-{
-    should_include_backtrace = print;
-}
-
-} // namespace couchbase::platform

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/platform/terminate_handler.h

@@ -1,36 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2016 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
-
-namespace couchbase::platform
-{
-/**
- * Interposes our own C++ terminate handler to print backtrace upon failures.
- * Chains to the default handler (if exists) after printing the backtrace,
- * then calls std::abort().
- */
-void
-install_backtrace_terminate_handler();
-
-/**
- * Control if our C++ terminate handler should include a backtrace or not.
- */
-void
-set_terminate_handler_print_backtrace(bool print);
-
-} // namespace couchbase::platform

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/platform/uuid.cc

@@ -1,98 +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 <couchbase/platform/uuid.h>
-
-#include <couchbase/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();
-}

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/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

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/CMakeLists.txt

@@ -1,43 +0,0 @@
-add_library(
-  couchbase_protocol OBJECT
-  client_request.cxx
-  client_response.cxx
-  cmd_append.cxx
-  cmd_cluster_map_change_notification.cxx
-  cmd_decrement.cxx
-  cmd_exists.cxx
-  cmd_get.cxx
-  cmd_get_and_lock.cxx
-  cmd_get_and_touch.cxx
-  cmd_get_cluster_config.cxx
-  cmd_get_collection_id.cxx
-  cmd_get_collections_manifest.cxx
-  cmd_get_error_map.cxx
-  cmd_get_meta.cxx
-  cmd_hello.cxx
-  cmd_increment.cxx
-  cmd_insert.cxx
-  cmd_lookup_in.cxx
-  cmd_mutate_in.cxx
-  cmd_noop.cxx
-  cmd_prepend.cxx
-  cmd_remove.cxx
-  cmd_replace.cxx
-  cmd_sasl_auth.cxx
-  cmd_sasl_list_mechs.cxx
-  cmd_sasl_step.cxx
-  cmd_select_bucket.cxx
-  cmd_touch.cxx
-  cmd_unlock.cxx
-  cmd_upsert.cxx
-  frame_info_utils.cxx
-  status.cxx)
-set_target_properties(couchbase_protocol PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(
-  couchbase_protocol
-  PRIVATE project_options
-          project_warnings
-          snappy
-          fmt::fmt
-          spdlog::spdlog)
-target_include_directories(couchbase_protocol PRIVATE ${PROJECT_SOURCE_DIR})