couchbase 3.2.0 → 3.2.4

package/deps/lcb/tests/iotests/testutil.cc

@@ -316,6 +316,10 @@ static std::uint64_t get_manifest_id(lcb_INSTANCE *instance)
     lcb_cmdgetmanifest_destroy(cmd);
     lcb_wait(instance, LCB_WAIT_DEFAULT);
 
+    if (result.rc == LCB_ERR_TIMEOUT) {
+        return 0;
+    }
+
     Json::Value payload;
     EXPECT_EQ(LCB_SUCCESS, result.rc);
     EXPECT_FALSE(result.value.empty());
@@ -461,3 +465,167 @@ std::string unique_name(const std::string &prefix)
     ss << prefix << lcb_next_rand32();
     return ss.str();
 }
+
+void TestSpan::SetAttribute(std::string key, uint64_t value)
+{
+    int_tags[std::move(key)] = value;
+}
+
+void TestSpan::SetAttribute(std::string key, std::string value)
+{
+    str_tags[std::move(key)] = std::move(value);
+}
+
+void TestSpan::End()
+{
+    finished = true;
+}
+
+TestSpan::TestSpan(std::string span_name)
+{
+    name = std::move(span_name);
+}
+
+std::shared_ptr<TestSpan> TestTracer::StartSpan(std::string name)
+{
+    auto t_span = std::make_shared<TestSpan>(name);
+    spans.push_back(t_span);
+    return t_span;
+}
+
+void TestTracer::reset()
+{
+    spans.clear();
+}
+
+static void *start_span(lcbtrace_TRACER *tracer, const char *name, void *parent)
+{
+    auto test_tracer = static_cast<TestTracer *>(tracer->cookie);
+    if (!test_tracer->enabled()) {
+        return nullptr;
+    }
+    auto test_span = test_tracer->StartSpan(std::string(name));
+    return test_span.get();
+}
+
+static void end_span(void *span)
+{
+    if (span == nullptr) {
+        return;
+    }
+    static_cast<TestSpan *>(span)->End();
+}
+
+static void add_tag_string(void *span, const char *name, const char *value, size_t value_len)
+{
+    if (span == nullptr) {
+        return;
+    }
+    std::string val;
+    val.append(value, value_len);
+    static_cast<TestSpan *>(span)->SetAttribute(std::string(name), val);
+}
+
+static void add_tag_uint64(void *span, const char *name, uint64_t value)
+{
+    if (span == nullptr) {
+        return;
+    }
+    static_cast<TestSpan *>(span)->SetAttribute(name, value);
+}
+
+void TestTracer::create_lcb_tracer()
+{
+    lcbtracer_ = lcbtrace_new(nullptr, LCBTRACE_F_EXTERNAL);
+    lcbtracer_->version = 1;
+    lcbtracer_->v.v1.start_span = start_span;
+    lcbtracer_->v.v1.end_span = end_span;
+    lcbtracer_->v.v1.add_tag_string = add_tag_string;
+    lcbtracer_->v.v1.add_tag_uint64 = add_tag_uint64;
+    lcbtracer_->cookie = static_cast<void *>(this);
+}
+
+void TestTracer::destroy_lcb_tracer()
+{
+    if (lcbtracer_ != nullptr) {
+        lcbtrace_destroy(lcbtracer_);
+        delete lcbtracer_;
+        lcbtracer_ = nullptr;
+    }
+}
+
+TestTracer::~TestTracer()
+{
+    destroy_lcb_tracer();
+}
+
+TestMeter::TestMeter() = default;
+
+void TestMeter::reset()
+{
+    recorders.clear();
+}
+
+void TestValueRecorder::RecordValue(uint64_t value)
+{
+    values.push_back(value);
+}
+
+std::shared_ptr<TestValueRecorder> TestMeter::ValueRecorder(std::string name,
+                                                            std::unordered_map<std::string, std::string> tags)
+{
+    auto key = name + ":" + tags["db.couchbase.service"];
+    auto op = tags["db.operation"];
+    if (!op.empty()) {
+        key = key + ":" + op;
+    }
+    std::shared_ptr<TestValueRecorder> test_recorder;
+    if (recorders.find(key) == recorders.end()) {
+        test_recorder = std::make_shared<TestValueRecorder>();
+        recorders[key] = test_recorder;
+    } else {
+        test_recorder = recorders[key];
+    }
+    return test_recorder;
+}
+
+static void record_callback(const lcbmetrics_VALUERECORDER *recorder, uint64_t value)
+{
+    void *test_recorder;
+    lcbmetrics_valuerecorder_cookie(recorder, &test_recorder);
+    static_cast<TestValueRecorder *>(test_recorder)->RecordValue(value);
+}
+
+static const lcbmetrics_VALUERECORDER *new_recorder(const lcbmetrics_METER *meter, const char *name,
+                                                    const lcbmetrics_TAG *tags, size_t ntags)
+{
+    std::unordered_map<std::string, std::string> recorder_tags;
+    for (int i = 0; i < ntags; i++) {
+        recorder_tags[tags[i].key] = tags[i].value;
+    }
+
+    void *test_meter_;
+    lcbmetrics_meter_cookie(meter, &test_meter_);
+    auto test_meter = static_cast<TestMeter *>(test_meter_);
+    auto test_value_recorder = test_meter->ValueRecorder(std::string(name), recorder_tags);
+
+    lcbmetrics_VALUERECORDER *recorder;
+    lcbmetrics_valuerecorder_create(&recorder, test_value_recorder.get());
+    lcbmetrics_valuerecorder_record_value_callback(recorder, record_callback);
+
+    return recorder;
+}
+
+void TestMeter::create_lcb_meter()
+{
+    lcbmetrics_meter_create(&lcbmeter_, static_cast<void *>(this));
+    lcbmetrics_meter_value_recorder_callback(lcbmeter_, new_recorder);
+}
+
+void TestMeter::destroy_lcb_meter()
+{
+    if (lcbmeter_ != nullptr) {
+        lcbmetrics_meter_destroy(lcbmeter_);
+        lcbmeter_ = nullptr;
+    }
+}

package/deps/lcb/tests/iotests/testutil.h

@@ -20,12 +20,19 @@
 #include <libcouchbase/couchbase.h>
 #include <libcouchbase/vbucket.h>
 #include <string>
+#include <memory>
+#include <unordered_map>
 
 #define ASSERT_STATUS_EQ(expected, actual)                                                                             \
     lcb_STATUS GTEST_CONCAT_TOKEN_(actual_code__, __LINE__) = (actual);                                                \
     ASSERT_EQ(expected, GTEST_CONCAT_TOKEN_(actual_code__, __LINE__))                                                  \
         << lcb_strerror_short(expected) << " != " << lcb_strerror_short(GTEST_CONCAT_TOKEN_(actual_code__, __LINE__))
 
+#define EXPECT_STATUS_EQ(expected, actual)                                                                             \
+    lcb_STATUS GTEST_CONCAT_TOKEN_(actual_code__, __LINE__) = (actual);                                                \
+    EXPECT_EQ(expected, GTEST_CONCAT_TOKEN_(actual_code__, __LINE__))                                                  \
+        << lcb_strerror_short(expected) << " != " << lcb_strerror_short(GTEST_CONCAT_TOKEN_(actual_code__, __LINE__))
+
 struct Item {
     void assign(const lcb_RESPGET *resp)
     {
@@ -207,4 +214,113 @@ void drop_scope(lcb_INSTANCE *instance, const std::string &scope, bool wait = tr
 void drop_collection(lcb_INSTANCE *instance, const std::string &scope, const std::string &collection, bool wait = true);
 
 std::string unique_name(const std::string &);
+
+class TestSpan
+{
+  public:
+    explicit TestSpan(std::string name);
+    void SetAttribute(std::string key, std::string value);
+    void SetAttribute(std::string key, uint64_t value);
+    void End();
+
+    std::unordered_map<std::string, std::string> str_tags{};
+    std::unordered_map<std::string, uint64_t> int_tags{};
+    bool finished{false};
+    std::string name{};
+
+    TestSpan *parent{nullptr};
+};
+
+class TestTracer
+{
+  public:
+    TestTracer() = default;
+    ~TestTracer();
+    std::shared_ptr<TestSpan> StartSpan(std::string name);
+
+    std::vector<std::shared_ptr<TestSpan>> spans{};
+
+    void reset();
+
+    bool set_enabled(bool new_value)
+    {
+        bool old_value = enabled_;
+        enabled_ = new_value;
+
+        reset();
+        destroy_lcb_tracer();
+        if (new_value) {
+            create_lcb_tracer();
+        }
+        return old_value;
+    }
+
+    bool enabled() const
+    {
+        return enabled_;
+    }
+
+    lcbtrace_TRACER *lcb_tracer()
+    {
+        return lcbtracer_;
+    }
+
+  private:
+    void create_lcb_tracer();
+    void destroy_lcb_tracer();
+
+    lcbtrace_TRACER *lcbtracer_{nullptr};
+    bool enabled_{false};
+};
+
+class TestValueRecorder
+{
+  public:
+    TestValueRecorder() = default;
+    void RecordValue(uint64_t value);
+
+    std::vector<uint64_t> values{};
+};
+
+class TestMeter
+{
+  public:
+    TestMeter();
+    void reset();
+    std::shared_ptr<TestValueRecorder> ValueRecorder(std::string name,
+                                                     std::unordered_map<std::string, std::string> tags);
+
+    std::unordered_map<std::string, std::shared_ptr<TestValueRecorder>> recorders{};
+
+    bool set_enabled(bool new_value)
+    {
+        bool old_value = enabled_;
+        enabled_ = new_value;
+
+        reset();
+        destroy_lcb_meter();
+        if (new_value) {
+            create_lcb_meter();
+        }
+        return old_value;
+    }
+
+    bool enabled() const
+    {
+        return enabled_;
+    }
+
+    lcbmetrics_METER *lcb_meter()
+    {
+        return lcbmeter_;
+    }
+
+  private:
+    void create_lcb_meter();
+    void destroy_lcb_meter();
+
+    lcbmetrics_METER *lcbmeter_{nullptr};
+    bool enabled_{false};
+};
+
 #endif

package/deps/lcb/tests/mocksupport/procutil.c

@@ -20,8 +20,6 @@
 #include <stdio.h>
 
 #ifndef _WIN32
-#define _XOPEN_SOURCE
-#include <stdlib.h>
 #include <string.h>
 #include <wordexp.h>
 #include <fcntl.h>  /* O_* */
@@ -51,6 +49,7 @@ static char **clisplit(const char *s)
         ret[ii] = strdup(p.we_wordv[ii]);
     }
     ret[ii] = NULL;
+    wordfree(&p);
     return ret;
 }
 
@@ -59,39 +58,44 @@ static int spawn_process_impl(child_process_t *proc)
     int rv;
     char **argv;
 
-    proc->pid = fork();
-    if (proc->pid < 0) {
+    argv = clisplit(proc->name);
+    if (argv == NULL) {
+        fprintf(stderr, "Couldn't split arguments: %s\n", proc->name);
         return -1;
     }
-    if (proc->pid > 0) {
-        return 0;
-    }
-
-    /** In Child */
-    argv = clisplit(proc->name);
-    if (!argv) {
-        fprintf(stderr, "Couldn't split arguments\n");
-        exit(EXIT_FAILURE);
+    proc->pid = vfork();
+    if (proc->pid < 0) {
+        for (int i = 0; argv[i] != NULL; ++i) {
+            free(argv[i]);
+        }
+        free(argv);
+        return -1;
     }
-    if (proc->redirect) {
-        int fd = open(proc->redirect, O_RDWR | O_CREAT | O_APPEND, 0644);
-        if (fd < 0) {
-            perror(proc->redirect);
-            exit(EXIT_FAILURE);
+    if (proc->pid == 0) {
+        /** In Child */
+        if (proc->redirect) {
+            int fd = open(proc->redirect, O_RDWR | O_CREAT | O_APPEND, 0644);
+            if (fd < 0) {
+                perror(proc->redirect);
+                exit(EXIT_FAILURE);
+            }
+            if (dup2(fd, fileno(stderr)) < 0 || dup2(fd, fileno(stdout)) < 0) {
+                perror("dup2");
+                exit(EXIT_FAILURE);
+            }
+            setvbuf(stderr, NULL, _IOLBF, 0);
         }
-        if (dup2(fd, fileno(stderr)) < 0 || dup2(fd, fileno(stdout)) < 0) {
-            perror("dup2");
-            exit(EXIT_FAILURE);
+        rv = execvp(argv[0], argv);
+        if (rv < 0) {
+            perror(argv[0]);
+            return -1;
         }
-        setvbuf(stderr, NULL, _IOLBF, 0);
     }
-    rv = execvp(argv[0], argv);
-    if (rv < 0) {
-        perror(argv[0]);
-        exit(EXIT_FAILURE);
+    for (int i = 0; argv[i] != NULL; ++i) {
+        free(argv[i]);
     }
-    abort();
-    return 0; /* make things happy */
+    free(argv);
+    return 0;
 }
 
 void kill_process(child_process_t *process, int force)

package/deps/lcb/tests/mocksupport/server.c

@@ -296,7 +296,6 @@ static int start_mock_server(struct test_server_info *info, char **cmdline)
 
     start_mock_process(info, argv);
     negotiate_mock_connection(info);
-    sleep(1); /* give it a bit time to initialize itself */
     return 1;
 }
 

package/deps/lcb/tests/mocksupport/timeout.c

@@ -17,12 +17,12 @@
 #include "config.h"
 #include <stdio.h>
 /*
- * The current test suite should not take more than 5 minutes to run.
+ * The current test suite should not take more than 8 minutes to run.
  * If you're testing on a really slow system you may set the
  * environment variable LCB_MAX_TEST_DURATION to the maximum number of
  * seconds you'd like the tests to take.
  */
-const int max_duration = 300;
+const int max_duration = 480;
 
 #ifdef _WIN32
 static HANDLE hTimer;

package/deps/lcb/tools/cbc.cc

@@ -1273,6 +1273,13 @@ void VersionHandler::run()
 #endif
         printf("  SSL Headers: %s\n", OPENSSL_VERSION_TEXT);
 #endif
+        printf("  HAVE_PKCS5_PBKDF2_HMAC: "
+#ifdef HAVE_PKCS5_PBKDF2_HMAC
+               "yes"
+#else
+               "no"
+#endif
+               "\n");
     } else {
         printf("  SSL: NOT SUPPORTED\n");
     }