couchbase 3.0.0.beta.1 → 3.0.0

data/ext/couchbase/platform/backtrace.c

@@ -0,0 +1,189 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2015 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 <inttypes.h>
+#include <platform/backtrace.h>
+#include <strings.h>
+
+#if defined(WIN32) && defined(HAVE_BACKTRACE_SUPPORT)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <Dbghelp.h>
+#endif
+
+#if defined(HAVE_BACKTRACE) && defined(HAVE_DLADDR)
+#define HAVE_BACKTRACE_SUPPORT 1
+#include <execinfo.h> // for backtrace()
+#include <dlfcn.h>    // for dladdr()
+#include <stddef.h>   // for ptrdiff_t
+#endif
+
+// Maximum number of frames that will be printed.
+#define MAX_FRAMES 50
+
+#if defined(HAVE_BACKTRACE_SUPPORT)
+/**
+ * Populates buf with a description of the given address in the program.
+ **/
+static void
+describe_address(char* msg, size_t len, void* addr)
+{
+#if defined(WIN32)
+
+    // Get module information
+    IMAGEHLP_MODULE64 module_info;
+    module_info.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
+    SymGetModuleInfo64(GetCurrentProcess(), (DWORD64)addr, &module_info);
+
+    // Get symbol information.
+    DWORD64 displacement = 0;
+    char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR)];
+    PSYMBOL_INFO sym_info = (PSYMBOL_INFO)buffer;
+    sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
+    sym_info->MaxNameLen = MAX_SYM_NAME;
+
+    if (SymFromAddr(GetCurrentProcess(), (DWORD64)addr, &displacement, sym_info)) {
+        snprintf(msg, len, "%s(%s+%lld) [0x%p]", module_info.ImageName ? module_info.ImageName : "", sym_info->Name, displacement, addr);
+    } else {
+        // No symbol found.
+        snprintf(msg, len, "[0x%p]", addr);
+    }
+#else // !WIN32
+    Dl_info info;
+    int status = dladdr(addr, &info);
+
+    if (status != 0) {
+        ptrdiff_t image_offset = (char*)addr - (char*)info.dli_fbase;
+        if (info.dli_fname != NULL && info.dli_fname[0] != '\0') {
+            // Found a nearest symbol - print it.
+            if (info.dli_saddr == 0) {
+                // No function offset calculation possible.
+                snprintf(msg,
+                         len,
+                         "%s(%s) [%p+0x%" PRIx64 "]",
+                         info.dli_fname,
+                         info.dli_sname ? info.dli_sname : "",
+                         info.dli_fbase,
+                         (uint64_t)image_offset);
+            } else {
+                char sign;
+                ptrdiff_t offset;
+                if (addr >= info.dli_saddr) {
+                    sign = '+';
+                    offset = (char*)addr - (char*)info.dli_saddr;
+                } else {
+                    sign = '-';
+                    offset = (char*)info.dli_saddr - (char*)addr;
+                }
+                snprintf(msg,
+                         len,
+                         "%s(%s%c%#tx) [%p+0x%" PRIx64 "]",
+                         info.dli_fname,
+                         info.dli_sname ? info.dli_sname : "",
+                         sign,
+                         offset,
+                         info.dli_fbase,
+                         (uint64_t)image_offset);
+            }
+        } else {
+            // No function found; just print library name and offset.
+            snprintf(msg, len, "%s [%p+0x%" PRIx64 "]", info.dli_fname, info.dli_fbase, (uint64_t)image_offset);
+        }
+    } else {
+        // dladdr failed.
+        snprintf(msg, len, "[%p]", addr);
+    }
+#endif // WIN32
+}
+
+void
+print_backtrace(write_cb_t write_cb, void* context)
+{
+    void* frames[MAX_FRAMES];
+#if defined(WIN32)
+    int active_frames = CaptureStackBackTrace(0, MAX_FRAMES, frames, NULL);
+    SymInitialize(GetCurrentProcess(), NULL, TRUE);
+#else
+    int active_frames = backtrace(frames, MAX_FRAMES);
+#endif
+
+    // Note we start from 1 to skip our own frame.
+    for (int ii = 1; ii < active_frames; ii++) {
+        // Fixed-sized buffer; possible that description will be cropped.
+        char msg[300];
+        describe_address(msg, sizeof(msg), frames[ii]);
+        write_cb(context, msg);
+    }
+    if (active_frames == MAX_FRAMES) {
+        write_cb(context, "<frame limit reached, possible truncation>");
+    }
+}
+
+#else // if defined(HAVE_BACKTRACE_SUPPORT)
+
+void
+print_backtrace(write_cb_t write_cb, void* context)
+{
+    write_cb(context, "<backtrace not supported on this platform>");
+}
+
+#endif // defined(HAVE_BACKTRACE_SUPPORT)
+
+static void
+print_to_file_cb(void* ctx, const char* frame)
+{
+    fprintf(ctx, "\t%s\n", frame);
+}
+
+void
+print_backtrace_to_file(FILE* stream)
+{
+    print_backtrace(print_to_file_cb, stream);
+}
+
+struct context {
+    const char* indent;
+    char* buffer;
+    size_t size;
+    size_t offset;
+    bool error;
+};
+
+static void
+memory_cb(void* ctx, const char* frame)
+{
+    struct context* c = ctx;
+
+    if (!c->error) {
+
+        int length = snprintf(c->buffer + c->offset, c->size - c->offset, "%s%s\n", c->indent, frame);
+
+        if ((length < 0) || (length >= (c->size - c->offset))) {
+            c->error = true;
+        } else {
+            c->offset += length;
+        }
+    }
+}
+
+bool
+print_backtrace_to_buffer(const char* indent, char* buffer, size_t size)
+{
+    struct context c = { .indent = indent, .buffer = buffer, .size = size, .offset = 0, .error = false };
+    print_backtrace(memory_cb, &c);
+    return !c.error;
+}

data/ext/couchbase/platform/backtrace.h

@@ -0,0 +1,54 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2015 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 <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#include <stdbool.h>
+#endif
+
+typedef void (*write_cb_t)(void* ctx, const char* frame);
+
+/**
+ * Prints a backtrace from the current thread. For each frame, the
+ * `write_cb` function is called with `context` and a string describing
+ * the frame.
+ */
+void
+print_backtrace(write_cb_t write_cb, void* context);
+
+/**
+ * Convenience function - prints a backtrace to the specified FILE.
+ */
+void
+print_backtrace_to_file(FILE* stream);
+
+/**
+ * print a backtrace to a buffer
+ *
+ * @param indent the indent used for each entry in the callstack
+ * @param buffer the buffer to populate with the backtrace
+ * @param size the size of the input buffer
+ */
+bool
+print_backtrace_to_buffer(const char* indent, char* buffer, size_t size);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

data/ext/couchbase/platform/terminate_handler.cc

@@ -0,0 +1,122 @@
+/* -*- 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 <platform/terminate_handler.h>
+
+#include <cstdlib>
+#include <exception>
+
+#include <spdlog/spdlog.h>
+#include <platform/backtrace.h>
+
+#include <version.hxx>
+
+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;
+#endif
+    // 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) {
+        spdlog::critical("Caught unhandled std::exception-derived exception. what(): {}", e.what());
+    } catch (...) {
+        spdlog::critical("Caught unknown/unhandled exception.");
+    }
+}
+
+// Log the symbolified backtrace to this point.
+static void
+log_backtrace()
+{
+    static const char format_str[] = "Call stack:\n%s";
+
+    char buffer[4096];
+    if (print_backtrace_to_buffer("    ", buffer, sizeof(buffer))) {
+        spdlog::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);
+        spdlog::critical("Call stack exceeds 4k");
+    }
+}
+
+// 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()
+{
+    spdlog::critical("*** Fatal error encountered during exception handling (rev=\"" BACKEND_GIT_REVISION "\", compiler=\"" BACKEND_CXX_COMPILER
+                     "\", system=\"" BACKEND_SYSTEM "\", date=\"" BACKEND_BUILD_TIMESTAMP "\")***");
+    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();
+    }
+
+#if !defined(HAVE_BREAKPAD)
+    // Shut down the logger (and flush everything). If breakpad is installed
+    // then we'll let it do it.
+    spdlog::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

data/ext/couchbase/platform/terminate_handler.h

@@ -0,0 +1,36 @@
+/* -*- 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

data/ext/couchbase/protocol/cmd_get_cluster_config.hxx

@@ -47,6 +47,11 @@ struct deduplicate_keys : Consumer {
 };
 } // namespace
 
+template<typename Iterator>
+configuration parse_config(Iterator begin, Iterator end) {
+    return tao::json::from_string<deduplicate_keys>(std::string(begin, end)).as<configuration>();
+}
+
 class get_cluster_config_response_body
 {
   public:
@@ -72,7 +77,7 @@ class get_cluster_config_response_body
         Expects(header[1] == static_cast<uint8_t>(opcode));
         if (status == protocol::status::success) {
             std::vector<uint8_t>::difference_type offset = framing_extras_size + key_size + extras_size;
-            config_ = tao::json::from_string<deduplicate_keys>(std::string(body.begin() + offset, body.end())).as<configuration>();
+            config_ = parse_config(body.begin() + offset, body.end());
             return true;
         }
         return false;

data/ext/couchbase/protocol/status.hxx

@@ -45,7 +45,7 @@ enum class status : uint16_t {
     not_supported = 0x83,
     internal = 0x84,
     busy = 0x85,
-    temp_failure = 0x86,
+    temporary_failure = 0x86,
     xattr_invalid = 0x87,
     unknown_collection = 0x88,
     no_collections_manifest = 0x89,
@@ -108,7 +108,7 @@ is_valid_status(uint16_t code)
         case status::not_supported:
         case status::internal:
         case status::busy:
-        case status::temp_failure:
+        case status::temporary_failure:
         case status::xattr_invalid:
         case status::unknown_collection:
         case status::no_collections_manifest:
@@ -146,6 +146,16 @@ is_valid_status(uint16_t code)
     }
     return false;
 }
+
+[[nodiscard]] std::string
+status_to_string(uint16_t code)
+{
+    if (is_valid_status(code)) {
+        return fmt::format("{} ({})", code, static_cast<status>(code));
+    }
+    return fmt::format("{} (unknown)", code);
+}
+
 } // namespace protocol
 } // namespace couchbase
 
@@ -225,8 +235,8 @@ struct fmt::formatter<couchbase::protocol::status> : formatter<string_view> {
             case couchbase::protocol::status::busy:
                 name = "busy";
                 break;
-            case couchbase::protocol::status::temp_failure:
-                name = "temp_failure";
+            case couchbase::protocol::status::temporary_failure:
+                name = "temporary_failure";
                 break;
             case couchbase::protocol::status::xattr_invalid:
                 name = "xattr_invalid";