couchbase 3.2.0 → 3.2.4

package/src/opbuilder.h

@@ -3,6 +3,7 @@
 #define OPBUILDER_H
 
 #include "connection.h"
+#include "instance.h"
 #include "lcbx.h"
 #include "tracespan.h"
 #include "tracing.h"
@@ -17,15 +18,14 @@ using namespace v8;
 class OpCookie : public Nan::AsyncResource
 {
 public:
-    OpCookie(Connection *impl, const Nan::Callback &callback,
+    OpCookie(Instance *inst, const Nan::Callback &callback,
              const Nan::Persistent<Object> &transcoder, TraceSpan span,
              WrappedRequestSpan *parentSpan)
         : Nan::AsyncResource("couchbase::op")
-        , _impl(impl)
+        , _inst(inst)
         , _parentSpan(parentSpan)
         , _traceSpan(span)
     {
-        _implRef.Reset(_impl->persistent());
         _callback.Reset(callback.GetFunction());
         _transcoder.Reset(transcoder);
     }
@@ -35,7 +35,6 @@ public:
         // We do not end the trace here, as the callback is responsible for
         // ending the trace at the appropriate point in time.
 
-        _implRef.Reset();
         _callback.Reset();
         _transcoder.Reset();
 
@@ -47,7 +46,7 @@ public:
 
     TraceSpan startDecodeTrace()
     {
-        return TraceSpan::beginDecodeTrace(_impl, _traceSpan);
+        return TraceSpan::beginDecodeTrace(_inst, _traceSpan);
     }
 
     void endTrace()
@@ -65,10 +64,9 @@ public:
         return _callback.Call(argc, argv, asyncContext()).ToLocalChecked();
     }
 
-    Connection *_impl;
+    Instance *_inst;
     Nan::Callback _callback;
     Nan::Persistent<Object> _transcoder;
-    Nan::Persistent<Object> _implRef;
     WrappedRequestSpan *_parentSpan;
     TraceSpan _traceSpan;
 };
@@ -314,9 +312,9 @@ class OpBuilder : public CmdBuilder<CmdType>
 {
 public:
     template <typename... Ts>
-    OpBuilder(Connection *impl, Ts... args)
+    OpBuilder(Instance *inst, Ts... args)
         : CmdBuilder<CmdType>(_valueParser, args...)
-        , _impl(impl)
+        , _inst(inst)
         , _parentSpan(nullptr)
     {
     }
@@ -334,7 +332,7 @@ public:
 
     TraceSpan startEncodeTrace()
     {
-        return TraceSpan::beginEncodeTrace(_impl, _traceSpan);
+        return TraceSpan::beginEncodeTrace(_inst, _traceSpan);
     }
 
     bool parseParentSpan(Local<Value> parentSpan)
@@ -346,7 +344,7 @@ public:
 
         if (!parentSpan.IsEmpty() && parentSpan->IsObject()) {
             _parentSpan =
-                new WrappedRequestSpan(_impl, parentSpan.As<Object>());
+                new WrappedRequestSpan(_inst, parentSpan.As<Object>());
         }
 
         return true;
@@ -451,7 +449,7 @@ public:
         }
 
         TraceSpan span =
-            TraceSpan::beginOpTrace(_impl, service, opName, parentSpan);
+            TraceSpan::beginOpTrace(_inst, service, opName, parentSpan);
         _traceSpan = span;
     }
 
@@ -472,13 +470,13 @@ public:
         }
 
         OpCookie *cookie =
-            new OpCookie(this->_impl, this->_callback, this->_transcoder,
+            new OpCookie(this->_inst, this->_callback, this->_transcoder,
                          this->_traceSpan, this->_parentSpan);
 
         // ownership of the parent span wrapper transfers to the opcookie
         _parentSpan = nullptr;
 
-        lcb_STATUS err = ExecFn(this->_impl->lcbHandle(), cookie, this->cmd());
+        lcb_STATUS err = ExecFn(this->_inst->lcbHandle(), cookie, this->cmd());
         if (err != LCB_SUCCESS) {
             // If the result was unsuccessful, we need to destroy the cookie
             // since we won't see it in any callbacks.
@@ -489,7 +487,7 @@ public:
     }
 
 protected:
-    Connection *_impl;
+    Instance *_inst;
     ValueParser _valueParser;
     std::vector<Nan::Utf8String *> _strings;
     Nan::Callback _callback;

package/src/respreader.cpp

@@ -0,0 +1 @@
+#include "respreader.h"

package/src/respreader.h

@@ -2,7 +2,9 @@
 #ifndef RESPREADER_H
 #define RESPREADER_H
 
-#include "connection.h"
+#include "error.h"
+#include "instance.h"
+#include "mutationtoken.h"
 #include "opbuilder.h"
 
 namespace couchnode
@@ -102,9 +104,9 @@ public:
         }
     }
 
-    Connection *connection() const
+    Instance *instance() const
     {
-        return Connection::fromInstance(_instance);
+        return Instance::fromLcbInst(_instance);
     }
 
     OpCookie *cookie() const
@@ -384,7 +386,7 @@ public:
             return Nan::Null();
         }
 
-        return MutationToken::create(value, connection()->bucketName());
+        return MutationToken::create(value, instance()->bucketName());
     }
 
     template <lcb_STATUS (*ValFn)(const RespType *, const char **, size_t *)>

package/src/tracespan.h

@@ -45,10 +45,10 @@ public:
         return TraceSpan(span);
     }
 
-    static TraceSpan beginOpTrace(Connection *impl, lcbtrace_SERVICE service,
+    static TraceSpan beginOpTrace(Instance *inst, lcbtrace_SERVICE service,
                                   const char *opName, TraceSpan parent)
     {
-        lcbtrace_TRACER *tracer = lcb_get_tracer(impl->lcbHandle());
+        lcbtrace_TRACER *tracer = lcb_get_tracer(inst->lcbHandle());
         if (!tracer) {
             return TraceSpan();
         }
@@ -64,19 +64,19 @@ public:
         lcbtrace_SPAN *span = lcbtrace_span_start(tracer, opName, 0, refPtr);
         lcbtrace_span_set_is_outer(span, 1);
         lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_COMPONENT,
-                                  impl->clientString());
+                                  inst->clientString());
         lcbtrace_span_set_service(span, service);
 
         return TraceSpan(span);
     }
 
-    static TraceSpan beginEncodeTrace(Connection *impl, TraceSpan opSpan)
+    static TraceSpan beginEncodeTrace(Instance *inst, TraceSpan opSpan)
     {
         if (!opSpan) {
             return TraceSpan();
         }
 
-        lcbtrace_TRACER *tracer = lcb_get_tracer(impl->lcbHandle());
+        lcbtrace_TRACER *tracer = lcb_get_tracer(inst->lcbHandle());
         if (!tracer) {
             return TraceSpan();
         }
@@ -87,18 +87,18 @@ public:
         lcbtrace_SPAN *span = lcbtrace_span_start(
             tracer, LCBTRACE_OP_REQUEST_ENCODING, LCBTRACE_NOW, &ref);
         lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_COMPONENT,
-                                  impl->clientString());
+                                  inst->clientString());
 
         return TraceSpan(span);
     }
 
-    static TraceSpan beginDecodeTrace(Connection *impl, TraceSpan opSpan)
+    static TraceSpan beginDecodeTrace(Instance *inst, TraceSpan opSpan)
     {
         if (!opSpan) {
             return NULL;
         }
 
-        lcbtrace_TRACER *tracer = lcb_get_tracer(impl->lcbHandle());
+        lcbtrace_TRACER *tracer = lcb_get_tracer(inst->lcbHandle());
         if (!tracer) {
             return NULL;
         }
@@ -109,7 +109,7 @@ public:
         lcbtrace_SPAN *span = lcbtrace_span_start(
             tracer, LCBTRACE_OP_RESPONSE_DECODING, LCBTRACE_NOW, &ref);
         lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_COMPONENT,
-                                  impl->clientString());
+                                  inst->clientString());
 
         return TraceSpan(span);
     }
@@ -126,11 +126,11 @@ private:
 class WrappedRequestSpan
 {
 public:
-    WrappedRequestSpan(Connection *conn, Local<Object> val)
+    WrappedRequestSpan(Instance *inst, Local<Object> val)
         : _reqSpan(val, true)
         , _span(nullptr)
     {
-        lcbtrace_TRACER *tracer = lcb_get_tracer(conn->lcbHandle());
+        lcbtrace_TRACER *tracer = lcb_get_tracer(inst->lcbHandle());
         if (!tracer) {
             _span = nullptr;
             return;

package/src/tracing.cpp

@@ -59,9 +59,11 @@ static void lcbSpanAddTagUint64(lcbxtrace_SPAN *procs, const char *name,
 }
 
 RequestTracer::RequestTracer(Local<Object> impl)
+    : _enabled(true)
 {
     _lcbTracer = lcbtrace_new(nullptr, LCBTRACE_F_EXTERNAL);
     _lcbTracer->version = 1;
+    _lcbTracer->destructor = nullptr;
     _lcbTracer->v.v1.start_span = lcbTracerStartSpan;
     _lcbTracer->v.v1.end_span = lcbSpanEnd;
     _lcbTracer->v.v1.destroy_span = lcbSpanDestroy;
@@ -89,9 +91,18 @@ lcbtrace_TRACER *RequestTracer::lcbProcs() const
     return _lcbTracer;
 }
 
+void RequestTracer::disconnect()
+{
+    _enabled = false;
+}
+
 lcbxtrace_SPAN *RequestTracer::requestSpan(const char *name,
                                            const lcbxtrace_SPAN *parent)
 {
+    if (!_enabled) {
+        return nullptr;
+    }
+
     Nan::HandleScope scope;
     Local<Object> impl = Nan::New(_impl);
     Local<Function> requestSpanImpl = Nan::New(_requestSpanImpl);

package/src/tracing.h

@@ -23,7 +23,10 @@ public:
 
     lcbxtrace_SPAN *requestSpan(const char *name, const lcbxtrace_SPAN *parent);
 
+    void disconnect();
+
 protected:
+    bool _enabled;
     lcbtrace_TRACER *_lcbTracer;
     Nan::Persistent<Object> _impl;
     Nan::Persistent<Function> _requestSpanImpl;

package/src/valueparser.h

@@ -88,6 +88,11 @@ public:
         return true;
     }
 
+    static bool isSet(Local<Value> val)
+    {
+        return !val.IsEmpty() && !val->IsUndefined() && !val->IsNull();
+    }
+
     template <typename T>
     static bool parseUint(T *out, Local<Value> value)
     {

package/deps/lcb/example/observe/durability.c

@@ -1,110 +0,0 @@
-/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2017-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.
- */
-
-/*
- * BUILD:
- *   cc -o durability durability.c -lcouchbase
- *
- * RUN:
- *   ./durability [ CONNSTRING [ PASSWORD [ USERNAME ] ] ]
- *
- *   # use default durability check method
- *   ./durability couchbase://localhost
- *
- *   # force durability check method based on sequence numbers
- *   ./durability couchbase://localhost?fetch_mutation_tokens=true&dur_mutation_tokens=true
- */
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <assert.h>
-#include <libcouchbase/couchbase.h>
-
-#define fail(msg)                                                                                                      \
-    fprintf(stderr, "%s\n", msg);                                                                                      \
-    exit(EXIT_FAILURE)
-
-#define fail2(msg, err)                                                                                                \
-    fprintf(stderr, "%s\n", msg);                                                                                      \
-    fprintf(stderr, "Error was 0x%x (%s)\n", err, lcb_strerror_short(err));                                            \
-    exit(EXIT_FAILURE)
-
-static void store_callback(lcb_INSTANCE *instance, int cbtype, const lcb_RESPSTORE *resp)
-{
-    lcb_STATUS rc = lcb_respstore_status(resp);
-    int store_ok, exists_master, persisted_master;
-    uint16_t num_responses, num_replicated, num_persisted;
-
-    lcb_respstore_observe_stored(resp, &store_ok);
-    lcb_respstore_observe_master_exists(resp, &exists_master);
-    lcb_respstore_observe_master_persisted(resp, &persisted_master);
-    lcb_respstore_observe_num_responses(resp, &num_responses);
-    lcb_respstore_observe_num_replicated(resp, &num_replicated);
-    lcb_respstore_observe_num_persisted(resp, &num_persisted);
-
-    fprintf(stderr, "Got status of operation: 0x%02x, %s\n", rc, lcb_strerror_short(rc));
-    fprintf(stderr, "Stored: %s\n", store_ok ? "true" : "false");
-    fprintf(stderr, "Number of roundtrips: %d\n", (int)num_responses);
-    fprintf(stderr, "In memory on master: %s\n", exists_master ? "true" : "false");
-    fprintf(stderr, "Persisted on master: %s\n", persisted_master ? "true" : "false");
-    fprintf(stderr, "Nodes have value replicated: %d\n", (int)num_replicated);
-    fprintf(stderr, "Nodes have value persisted (including master): %d\n", (int)num_persisted);
-}
-
-int main(int argc, char *argv[])
-{
-    lcb_INSTANCE *instance;
-    lcb_STATUS err;
-    lcb_CMDSTORE *cmd;
-    lcb_CREATEOPTS *options = NULL;
-    const char *key = "foo";
-    const char *value = "{\"val\":42}";
-
-    lcb_createopts_create(&options, LCB_TYPE_BUCKET);
-    if (argc > 1) {
-        lcb_createopts_connstr(options, argv[1], strlen(argv[1]));
-    }
-    if (argc > 3) {
-        lcb_createopts_credentials(options, argv[3], strlen(argv[3]), argv[2], strlen(argv[2]));
-    }
-
-    if ((err = lcb_create(&instance, options)) != LCB_SUCCESS) {
-        fail2("cannot create connection instance", err);
-    }
-    lcb_createopts_destroy(options);
-    if ((err = lcb_connect(instance)) != LCB_SUCCESS) {
-        fail2("Couldn't schedule connection", err);
-    }
-    lcb_wait(instance, LCB_WAIT_DEFAULT);
-    if ((err = lcb_get_bootstrap_status(instance)) != LCB_SUCCESS) {
-        fail2("Couldn't get initial cluster configuration", err);
-    }
-    lcb_install_callback(instance, LCB_CALLBACK_STORE, (lcb_RESPCALLBACK)store_callback);
-
-    lcb_cmdstore_create(&cmd, LCB_STORE_UPSERT);
-    lcb_cmdstore_key(cmd, key, strlen(key));
-    lcb_cmdstore_value(cmd, value, strlen(value));
-    /* replicate and persist on all nodes */
-    lcb_cmdstore_durability_observe(cmd, -1, -1);
-    lcb_store(instance, NULL, cmd);
-    lcb_cmdstore_destroy(cmd);
-
-    lcb_wait(instance, LCB_WAIT_DEFAULT);
-
-    lcb_destroy(instance);
-    return EXIT_SUCCESS;
-}