mt-libcouchbase 1.4.0

data/ext/libcouchbase/src/callbacks.c

@@ -0,0 +1,380 @@
+/* -*- 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 "internal.h"
+
+#define DEFINE_DUMMY_CALLBACK(name, resptype) \
+    static void name(lcb_t i, const void *c, lcb_error_t e, const resptype *r) \
+    { (void)i;(void)e;(void)c;(void)r; }
+
+static void dummy_error_callback(lcb_t instance,lcb_error_t error, const char *errinfo) {
+    lcb_breakout(instance);
+    (void)error;
+    (void)errinfo;
+}
+
+static void dummy_store_callback(lcb_t instance, const void *cookie,
+    lcb_storage_t operation, lcb_error_t error, const lcb_store_resp_t *resp) {
+    (void)instance; (void)cookie; (void)operation; (void)error; (void)resp;
+}
+
+
+static void dummy_http_callback(lcb_http_request_t request, lcb_t instance,
+    const void *cookie, lcb_error_t error, const lcb_http_resp_t *resp) {
+    (void)request;(void)instance;(void)cookie;(void)error; (void)resp;
+}
+
+static void dummy_configuration_callback(lcb_t instance, lcb_configuration_t val) {
+    (void)instance; (void)val;
+}
+
+static void dummy_bootstrap_callback(lcb_t instance, lcb_error_t err) {
+    (void)instance; (void)err;
+}
+
+static void dummy_pktfwd_callback(lcb_t instance, const void *cookie,
+    lcb_error_t err, lcb_PKTFWDRESP *resp) {
+    (void)instance;(void)cookie;(void)err;(void)resp;
+}
+static void dummy_pktflushed_callback(lcb_t instance, const void *cookie) {
+    (void)instance;(void)cookie;
+}
+
+DEFINE_DUMMY_CALLBACK(dummy_stat_callback, lcb_server_stat_resp_t)
+DEFINE_DUMMY_CALLBACK(dummy_version_callback, lcb_server_version_resp_t)
+DEFINE_DUMMY_CALLBACK(dummy_verbosity_callback, lcb_verbosity_resp_t)
+DEFINE_DUMMY_CALLBACK(dummy_get_callback, lcb_get_resp_t)
+DEFINE_DUMMY_CALLBACK(dummy_arithmetic_callback, lcb_arithmetic_resp_t)
+DEFINE_DUMMY_CALLBACK(dummy_remove_callback, lcb_remove_resp_t)
+DEFINE_DUMMY_CALLBACK(dummy_touch_callback, lcb_touch_resp_t)
+DEFINE_DUMMY_CALLBACK(dummy_flush_callback, lcb_flush_resp_t)
+DEFINE_DUMMY_CALLBACK(dummy_unlock_callback, lcb_unlock_resp_t)
+DEFINE_DUMMY_CALLBACK(dummy_observe_callback, lcb_observe_resp_t)
+DEFINE_DUMMY_CALLBACK(dummy_durability_callback, lcb_durability_resp_t)
+
+typedef union {
+    lcb_RESPBASE base;
+    lcb_RESPGET get;
+    lcb_RESPSTORE store;
+    lcb_RESPUNLOCK unlock;
+    lcb_RESPCOUNTER arith;
+    lcb_RESPREMOVE del;
+    lcb_RESPENDURE endure;
+    lcb_RESPUNLOCK unl;
+    lcb_RESPFLUSH flush;
+    lcb_RESPSTATS stats;
+    lcb_RESPMCVERSION mcversion;
+    lcb_RESPVERBOSITY verbosity;
+    lcb_RESPOBSERVE observe;
+    lcb_RESPHTTP http;
+} uRESP;
+
+static void
+compat_default_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *r3base)
+{
+    const uRESP *r3 = (uRESP *)r3base;
+    const void *cookie = r3base->cookie;
+    lcb_error_t err = r3base->rc;
+
+    #define FILL_KVC(dst) \
+        (dst)->v.v0.key = r3base->key; \
+        (dst)->v.v0.nkey = r3base->nkey; \
+        (dst)->v.v0.cas = r3base->cas;
+
+    switch (cbtype) {
+    case LCB_CALLBACK_GET:
+    case LCB_CALLBACK_GETREPLICA: {
+        lcb_get_resp_t r2 = { 0 };
+        FILL_KVC(&r2)
+        r2.v.v0.bytes = r3->get.value;
+        r2.v.v0.nbytes = r3->get.nvalue;
+        r2.v.v0.flags = r3->get.itmflags;
+        r2.v.v0.datatype = r3->get.datatype;
+        instance->callbacks.get(instance, cookie, err, &r2);
+        break;
+    }
+    case LCB_CALLBACK_STORE: {
+        lcb_store_resp_t r2 = { 0 };
+        FILL_KVC(&r2)
+        r2.v.v0.mutation_token = lcb_resp_get_mutation_token(cbtype, r3base);
+        instance->callbacks.store(instance, cookie, r3->store.op, err, &r2);
+        break;
+    }
+    case LCB_CALLBACK_COUNTER: {
+        lcb_arithmetic_resp_t r2 = { 0 };
+        FILL_KVC(&r2);
+        r2.v.v0.value = r3->arith.value;
+        r2.v.v0.mutation_token = lcb_resp_get_mutation_token(cbtype, r3base);
+        instance->callbacks.arithmetic(instance, cookie, err, &r2);
+        break;
+    }
+    case LCB_CALLBACK_REMOVE: {
+        lcb_remove_resp_t r2 = { 0 };
+        FILL_KVC(&r2)
+        r2.v.v0.mutation_token = lcb_resp_get_mutation_token(cbtype, r3base);
+        instance->callbacks.remove(instance, cookie, err, &r2);
+        break;
+    }
+    case LCB_CALLBACK_TOUCH: {
+        lcb_touch_resp_t r2 = { 0 };
+        FILL_KVC(&r2)
+        instance->callbacks.touch(instance, cookie, err, &r2);
+        break;
+    }
+    case LCB_CALLBACK_UNLOCK: {
+        lcb_unlock_resp_t r2 = { 0 };
+        r2.v.v0.key = r3->unl.key;
+        r2.v.v0.nkey = r3->unl.nkey;
+        instance->callbacks.unlock(instance, cookie, err, &r2);
+        break;
+    }
+    case LCB_CALLBACK_FLUSH: {
+        lcb_flush_resp_t r2 = { 0 };
+        r2.v.v0.server_endpoint = r3->flush.server;
+        instance->callbacks.flush(instance, cookie, err, &r2);
+        break;
+    }
+    case LCB_CALLBACK_VERSIONS: {
+        lcb_server_version_resp_t r2 = { 0 };
+        r2.v.v0.server_endpoint = r3->mcversion.server;
+        r2.v.v0.vstring = r3->mcversion.mcversion;
+        r2.v.v0.nvstring = r3->mcversion.nversion;
+        instance->callbacks.version(instance, cookie, err, &r2);
+        break;
+    }
+    case LCB_CALLBACK_VERBOSITY: {
+        lcb_verbosity_resp_t r2 = { 0 };
+        r2.v.v0.server_endpoint = r3->verbosity.server;
+        instance->callbacks.verbosity(instance, cookie, err, &r2);
+        break;
+    }
+    case LCB_CALLBACK_STATS: {
+        lcb_server_stat_resp_t r2 = { 0 };
+        r2.v.v0.key = r3->stats.key;
+        r2.v.v0.nkey = r3->stats.nkey;
+        r2.v.v0.bytes = r3->stats.value;
+        r2.v.v0.nbytes = r3->stats.nvalue;
+        r2.v.v0.server_endpoint = r3->stats.server;
+        instance->callbacks.stat(instance, cookie, err, &r2);
+        break;
+    }
+    case LCB_CALLBACK_OBSERVE: {
+        lcb_observe_resp_t r2 = { 0 };
+        FILL_KVC(&r2);
+        r2.v.v0.status = r3->observe.status;
+        r2.v.v0.from_master = r3->observe.ismaster;
+        r2.v.v0.ttp = r3->observe.ttp;
+        r2.v.v0.ttr = r3->observe.ttr;
+        instance->callbacks.observe(instance, cookie, err, &r2);
+        break;
+    }
+    case LCB_CALLBACK_ENDURE: {
+        lcb_durability_resp_t r2 = { 0 };
+        FILL_KVC(&r2);
+        r2.v.v0.err = r3->endure.rc;
+        r2.v.v0.exists_master = r3->endure.exists_master;
+        r2.v.v0.persisted_master = r3->endure.persisted_master;
+        r2.v.v0.npersisted = r3->endure.npersisted;
+        r2.v.v0.nreplicated = r3->endure.nreplicated;
+        r2.v.v0.nresponses = r3->endure.nresponses;
+        if (err == LCB_SUCCESS) {
+            err = r3->endure.rc;
+        }
+        instance->callbacks.durability(instance, cookie, err, &r2);
+        break;
+    }
+    case LCB_CALLBACK_HTTP: {
+        lcb_http_res_callback target;
+        lcb_http_resp_t r2 = { 0 };
+        r2.v.v0.path = r3->http.key;
+        r2.v.v0.npath = r3->http.nkey;
+        r2.v.v0.bytes = r3->http.body;
+        r2.v.v0.nbytes = r3->http.nbody;
+        r2.v.v0.status = r3->http.htstatus;
+        r2.v.v0.headers = r3->http.headers;
+        if (!(r3base->rflags & LCB_RESP_F_FINAL)) {
+            target = instance->callbacks.http_data;
+        } else {
+            target = instance->callbacks.http_complete;
+        }
+        target(r3->http._htreq, instance, cookie, err, &r2);
+        break;
+    }
+
+    default:
+        break;
+    }
+}
+
+void lcb_initialize_packet_handlers(lcb_t instance)
+{
+    instance->callbacks.get = dummy_get_callback;
+    instance->callbacks.store = dummy_store_callback;
+    instance->callbacks.arithmetic = dummy_arithmetic_callback;
+    instance->callbacks.remove = dummy_remove_callback;
+    instance->callbacks.touch = dummy_touch_callback;
+    instance->callbacks.error = dummy_error_callback;
+    instance->callbacks.stat = dummy_stat_callback;
+    instance->callbacks.version = dummy_version_callback;
+    instance->callbacks.http_complete = dummy_http_callback;
+    instance->callbacks.http_data = dummy_http_callback;
+    instance->callbacks.flush = dummy_flush_callback;
+    instance->callbacks.unlock = dummy_unlock_callback;
+    instance->callbacks.configuration = dummy_configuration_callback;
+    instance->callbacks.observe = dummy_observe_callback;
+    instance->callbacks.verbosity = dummy_verbosity_callback;
+    instance->callbacks.durability = dummy_durability_callback;
+    instance->callbacks.errmap = lcb_errmap_default;
+    instance->callbacks.bootstrap = dummy_bootstrap_callback;
+    instance->callbacks.pktflushed = dummy_pktflushed_callback;
+    instance->callbacks.pktfwd = dummy_pktfwd_callback;
+    instance->callbacks.v3callbacks[LCB_CALLBACK_DEFAULT] = compat_default_callback;
+}
+
+#define CALLBACK_ACCESSOR(name, cbtype, field) \
+LIBCOUCHBASE_API \
+cbtype name(lcb_t instance, cbtype cb) { \
+    cbtype ret = instance->callbacks.field; \
+    if (cb != NULL) { \
+        instance->callbacks.field = cb; \
+    } \
+    return ret; \
+}
+
+LIBCOUCHBASE_API
+lcb_destroy_callback
+lcb_set_destroy_callback(lcb_t instance, lcb_destroy_callback cb)
+{
+    lcb_destroy_callback ret = LCBT_SETTING(instance, dtorcb);
+    if (cb) {
+        LCBT_SETTING(instance, dtorcb) = cb;
+    }
+    return ret;
+}
+
+CALLBACK_ACCESSOR(lcb_set_get_callback, lcb_get_callback, get)
+CALLBACK_ACCESSOR(lcb_set_store_callback, lcb_store_callback, store)
+CALLBACK_ACCESSOR(lcb_set_arithmetic_callback, lcb_arithmetic_callback, arithmetic)
+CALLBACK_ACCESSOR(lcb_set_observe_callback, lcb_observe_callback, observe)
+CALLBACK_ACCESSOR(lcb_set_remove_callback, lcb_remove_callback, remove)
+CALLBACK_ACCESSOR(lcb_set_touch_callback, lcb_touch_callback, touch)
+CALLBACK_ACCESSOR(lcb_set_stat_callback, lcb_stat_callback, stat)
+CALLBACK_ACCESSOR(lcb_set_version_callback, lcb_version_callback, version)
+CALLBACK_ACCESSOR(lcb_set_error_callback, lcb_error_callback, error)
+CALLBACK_ACCESSOR(lcb_set_flush_callback, lcb_flush_callback, flush)
+CALLBACK_ACCESSOR(lcb_set_http_complete_callback, lcb_http_complete_callback, http_complete)
+CALLBACK_ACCESSOR(lcb_set_http_data_callback, lcb_http_data_callback, http_data)
+CALLBACK_ACCESSOR(lcb_set_unlock_callback, lcb_unlock_callback, unlock)
+CALLBACK_ACCESSOR(lcb_set_configuration_callback, lcb_configuration_callback, configuration)
+CALLBACK_ACCESSOR(lcb_set_verbosity_callback, lcb_verbosity_callback, verbosity)
+CALLBACK_ACCESSOR(lcb_set_durability_callback, lcb_durability_callback, durability)
+CALLBACK_ACCESSOR(lcb_set_errmap_callback, lcb_errmap_callback, errmap)
+CALLBACK_ACCESSOR(lcb_set_bootstrap_callback, lcb_bootstrap_callback, bootstrap)
+CALLBACK_ACCESSOR(lcb_set_pktfwd_callback, lcb_pktfwd_callback, pktfwd)
+CALLBACK_ACCESSOR(lcb_set_pktflushed_callback, lcb_pktflushed_callback, pktflushed)
+
+LIBCOUCHBASE_API
+lcb_RESPCALLBACK
+lcb_install_callback3(lcb_t instance, int cbtype, lcb_RESPCALLBACK cb)
+{
+    lcb_RESPCALLBACK ret;
+    if (cbtype >= LCB_CALLBACK__MAX) {
+        return NULL;
+    }
+
+    ret = instance->callbacks.v3callbacks[cbtype];
+    instance->callbacks.v3callbacks[cbtype] = cb;
+    return ret;
+}
+
+LIBCOUCHBASE_API
+lcb_RESPCALLBACK
+lcb_get_callback3(lcb_t instance, int cbtype)
+{
+    if (cbtype >= LCB_CALLBACK__MAX) {
+        return NULL;
+    }
+    return instance->callbacks.v3callbacks[cbtype];
+}
+
+LIBCOUCHBASE_API
+const char *
+lcb_strcbtype(int cbtype)
+{
+    switch (cbtype) {
+    case LCB_CALLBACK_GET:
+        return "GET";
+    case LCB_CALLBACK_STORE:
+        return "STORE";
+    case LCB_CALLBACK_COUNTER:
+        return "COUNTER";
+    case LCB_CALLBACK_TOUCH:
+        return "TOUCH";
+    case LCB_CALLBACK_REMOVE:
+        return "REMOVE";
+    case LCB_CALLBACK_UNLOCK:
+        return "UNLOCK";
+    case LCB_CALLBACK_STATS:
+        return "STATS";
+    case LCB_CALLBACK_VERSIONS:
+        return "VERSIONS";
+    case LCB_CALLBACK_VERBOSITY:
+        return "VERBOSITY";
+    case LCB_CALLBACK_FLUSH:
+        return "FLUSH";
+    case LCB_CALLBACK_OBSERVE:
+        return "OBSERVE";
+    case LCB_CALLBACK_GETREPLICA:
+        return "GETREPLICA";
+    case LCB_CALLBACK_ENDURE:
+        return "ENDURE";
+    case LCB_CALLBACK_HTTP:
+        return "HTTP";
+    case LCB_CALLBACK_CBFLUSH:
+        return "CBFLUSH";
+    case LCB_CALLBACK_OBSEQNO:
+        return "OBSEQNO";
+    case LCB_CALLBACK_STOREDUR:
+        return "STOREDUR";
+    case LCB_CALLBACK_SDMUTATE:
+        return "SDMUTATE";
+    case LCB_CALLBACK_SDLOOKUP:
+        return "SDLOOKUP";
+    case LCB_CALLBACK_NOOP:
+        return "NOOP";
+    default:
+        return "UNKNOWN";
+    }
+}
+
+static void
+nocb_fallback(lcb_t instance, int type, const lcb_RESPBASE *response)
+{
+    (void)instance; (void)type; (void)response;
+}
+lcb_RESPCALLBACK
+lcb_find_callback(lcb_t instance, lcb_CALLBACKTYPE cbtype)
+{
+    lcb_RESPCALLBACK ret = instance->callbacks.v3callbacks[cbtype];
+    if (!ret) {
+        ret = instance->callbacks.v3callbacks[LCB_CALLBACK_DEFAULT];
+        if (!ret) {
+            ret = nocb_fallback;
+        }
+    }
+    return ret;
+}

data/ext/libcouchbase/src/cbft.cc

@@ -0,0 +1,253 @@
+/*
+ *     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 <libcouchbase/couchbase.h>
+#include <libcouchbase/cbft.h>
+#include <jsparse/parser.h>
+#include "internal.h"
+#include "http/http.h"
+#include "logging.h"
+#include "contrib/lcb-jsoncpp/lcb-jsoncpp.h"
+#include <string>
+
+#define LOGFMT "(FTR=%p) "
+#define LOGID(req) static_cast<const void*>(req)
+#define LOGARGS(req, lvl) req->instance->settings, "n1ql", LCB_LOG_##lvl, __FILE__, __LINE__
+
+struct lcb_FTSREQ : lcb::jsparse::Parser::Actions {
+    const lcb_RESPHTTP *cur_htresp;
+    lcb_http_request_t htreq;
+    lcb::jsparse::Parser *parser;
+    const void *cookie;
+    lcb_FTSCALLBACK callback;
+    lcb_t instance;
+    size_t nrows;
+    lcb_error_t lasterr;
+#ifdef LCB_TRACING
+    lcbtrace_SPAN *span;
+#endif
+
+    void invoke_row(lcb_RESPFTS *resp);
+    void invoke_last();
+
+    lcb_FTSREQ(lcb_t, const void *, const lcb_CMDFTS *);
+    ~lcb_FTSREQ();
+    void JSPARSE_on_row(const lcb::jsparse::Row& datum) {
+        lcb_RESPFTS resp = { 0 };
+        resp.row = static_cast<const char*>(datum.row.iov_base);
+        resp.nrow = datum.row.iov_len;
+        nrows++;
+        invoke_row(&resp);
+    }
+    void JSPARSE_on_error(const std::string&) {
+        lasterr = LCB_PROTOCOL_ERROR;
+    }
+    void JSPARSE_on_complete(const std::string&) {
+        // Nothing
+    }
+};
+
+static void
+chunk_callback(lcb_t, int, const lcb_RESPBASE *rb)
+{
+    const lcb_RESPHTTP *rh = (const lcb_RESPHTTP *)rb;
+    lcb_FTSREQ *req = static_cast<lcb_FTSREQ*>(rh->cookie);
+
+    req->cur_htresp = rh;
+    if (rh->rc != LCB_SUCCESS || rh->htstatus != 200) {
+        if (req->lasterr == LCB_SUCCESS || rh->htstatus != 200) {
+            req->lasterr = rh->rc ? rh->rc : LCB_HTTP_ERROR;
+        }
+    }
+
+    if (rh->rflags & LCB_RESP_F_FINAL) {
+        req->invoke_last();
+        delete req;
+
+    } else if (req->callback == NULL) {
+        /* Cancelled. Similar to the block above, except the http request
+         * should remain alive (so we can cancel it later on) */
+        delete req;
+    } else {
+        req->parser->feed(static_cast<const char*>(rh->body), rh->nbody);
+    }
+}
+
+void
+lcb_FTSREQ::invoke_row(lcb_RESPFTS *resp)
+{
+    resp->cookie = const_cast<void*>(cookie);
+    resp->htresp = cur_htresp;
+
+    if (callback) {
+        callback(instance, -4, resp);
+    }
+}
+
+void
+lcb_FTSREQ::invoke_last()
+{
+    lcb_RESPFTS resp = { 0 };
+    resp.rflags |= LCB_RESP_F_FINAL;
+    resp.rc = lasterr;
+
+    if (parser) {
+        lcb_IOV meta;
+        parser->get_postmortem(meta);
+        resp.row = static_cast<const char*>(meta.iov_base);
+        resp.nrow = meta.iov_len;
+    }
+    invoke_row(&resp);
+    callback = NULL;
+}
+
+lcb_FTSREQ::lcb_FTSREQ(lcb_t instance_, const void *cookie_, const lcb_CMDFTS *cmd)
+: lcb::jsparse::Parser::Actions(),
+  cur_htresp(NULL), htreq(NULL),
+  parser(new lcb::jsparse::Parser(lcb::jsparse::Parser::MODE_FTS, this)),
+  cookie(cookie_), callback(cmd->callback), instance(instance_), nrows(0),
+  lasterr(LCB_SUCCESS)
+#ifdef LCB_TRACING
+    , span(NULL)
+#endif
+{
+    lcb_CMDHTTP htcmd = { 0 };
+    htcmd.type = LCB_HTTP_TYPE_FTS;
+    htcmd.method = LCB_HTTP_METHOD_POST;
+    htcmd.reqhandle = &htreq;
+    htcmd.content_type = "application/json";
+    htcmd.cmdflags |= LCB_CMDHTTP_F_STREAM;
+    if (!callback) {
+        lasterr = LCB_EINVAL;
+        return;
+    }
+
+    Json::Value root;
+    Json::Reader rr;
+    if (!rr.parse(cmd->query, cmd->query + cmd->nquery, root)) {
+        lasterr = LCB_EINVAL;
+        return;
+    }
+
+    const Json::Value& constRoot = root;
+    const Json::Value& j_ixname = constRoot["indexName"];
+    if (!j_ixname.isString()) {
+        lasterr = LCB_EINVAL;
+        return;
+    }
+
+    std::string url;
+    url.append("api/index/").append(j_ixname.asCString()).append("/query");
+    LCB_CMD_SET_KEY(&htcmd, url.c_str(), url.size());
+
+    // Making a copy here to ensure that we don't accidentally create a new
+    // 'ctl' field.
+    const Json::Value& ctl = constRoot["value"];
+    if (ctl.isObject()) {
+        const Json::Value& tmo = ctl["timeout"];
+        if (tmo.isNumeric()) {
+            htcmd.cmdflags |= LCB_CMDHTTP_F_CASTMO;
+            htcmd.cas = tmo.asLargestUInt();
+        }
+    } else {
+        root["ctl"]["timeout"] = LCBT_SETTING(instance, n1ql_timeout) / 1000;
+    }
+
+    std::string qbody(Json::FastWriter().write(root));
+    htcmd.body = qbody.c_str();
+    htcmd.nbody = qbody.size();
+
+    lasterr = lcb_http3(instance, this, &htcmd);
+    if (lasterr == LCB_SUCCESS) {
+        htreq->set_callback(chunk_callback);
+        if (cmd->handle) {
+            *cmd->handle = reinterpret_cast<lcb_FTSREQ*>(this);
+        }
+#ifdef LCB_TRACING
+        if (instance->settings->tracer) {
+            char id[20] = {0};
+            snprintf(id, sizeof(id), "%p", (void *)this);
+            span = lcbtrace_span_start(instance->settings->tracer, LCBTRACE_OP_DISPATCH_TO_SERVER, LCBTRACE_NOW, NULL);
+            lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_OPERATION_ID, id);
+            lcbtrace_span_add_system_tags(span, instance->settings, LCBTRACE_TAG_SERVICE_SEARCH);
+        }
+#endif
+    }
+}
+
+lcb_FTSREQ::~lcb_FTSREQ()
+{
+    if (htreq != NULL) {
+        lcb_cancel_http_request(instance, htreq);
+        htreq = NULL;
+    }
+#ifdef LCB_TRACING
+    if (span) {
+        if (htreq) {
+            lcbio_CTX *ctx = htreq->ioctx;
+            if (ctx) {
+                std::string remote;
+                if (htreq->ipv6) {
+                    remote = "[" + std::string(htreq->host) + "]:" + std::string(htreq->port);
+                } else {
+                    remote = std::string(htreq->host) + ":" + std::string(htreq->port);
+                }
+                lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_PEER_ADDRESS, remote.c_str());
+                lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_LOCAL_ADDRESS,
+                                          lcbio__inet_ntop(&ctx->sock->info->sa_local).c_str());
+            }
+        }
+        lcbtrace_span_finish(span, LCBTRACE_NOW);
+        span = NULL;
+    }
+#endif
+    if (parser) {
+        delete parser;
+        parser = NULL;
+    }
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_fts_query(lcb_t instance, const void *cookie, const lcb_CMDFTS *cmd)
+{
+    lcb_FTSREQ *req = new lcb_FTSREQ(instance, cookie, cmd);
+    if (req->lasterr) {
+        lcb_error_t rc = req->lasterr;
+        delete req;
+        return rc;
+    }
+    return LCB_SUCCESS;
+}
+
+LIBCOUCHBASE_API
+void
+lcb_fts_cancel(lcb_t, lcb_FTSHANDLE handle)
+{
+    handle->callback = NULL;
+}
+
+#ifdef LCB_TRACING
+
+LIBCOUCHBASE_API
+void lcb_fts_set_parent_span(lcb_t, lcb_FTSHANDLE handle, lcbtrace_SPAN *span)
+{
+    if (handle) {
+        lcbtrace_span_set_parent(handle->span, span);
+    }
+}
+
+#endif