libcouchbase 1.0.4 → 1.1.0

data/ext/libcouchbase/src/http/http-priv.h

@@ -78,7 +78,8 @@ struct Request {
     bool is_data_request() const {
         return reqtype == LCB_HTTP_TYPE_N1QL ||
                 reqtype == LCB_HTTP_TYPE_VIEW ||
-                reqtype == LCB_HTTP_TYPE_FTS;
+                reqtype == LCB_HTTP_TYPE_FTS ||
+                reqtype == LCB_HTTP_TYPE_CBAS;
     }
 
     /**
@@ -310,6 +311,8 @@ struct Request {
 
     /** overrides default timeout if nonzero */
     const uint32_t user_timeout;
+
+    hrtime_t start; /**< Start time */
 };
 
 } // namespace: http

data/ext/libcouchbase/src/http/http.cc

@@ -368,6 +368,8 @@ httype2svctype(unsigned httype)
         return LCBVB_SVCTYPE_N1QL;
     case LCB_HTTP_TYPE_FTS:
         return LCBVB_SVCTYPE_FTS;
+    case LCB_HTTP_TYPE_CBAS:
+        return LCBVB_SVCTYPE_CBAS;
     default:
         return LCBVB_SVCTYPE__MAX;
     }
@@ -548,6 +550,7 @@ Request::create(lcb_t instance,
         *rc = LCB_CLIENT_ENOMEM;
         return NULL;
     }
+    req->start = gethrtime();
 
     *rc = req->setup_inputs(cmd);
     if (*rc != LCB_SUCCESS) {

data/ext/libcouchbase/src/instance.cc

@@ -129,7 +129,7 @@ lcb_st::process_dns_srv(Connspec& spec)
 
     const Spechost& host = spec.hosts().front();
     lcb_error_t rc = LCB_ERROR;
-    Hostlist* hl = dnssrv_getbslist(host.hostname.c_str(), host.isSSL(), rc);
+    Hostlist* hl = dnssrv_getbslist(host.hostname.c_str(), spec.sslopts() & LCB_SSL_ENABLED, rc);
 
     if (hl == NULL) {
         lcb_log(LOGARGS(this, INFO), "DNS SRV lookup failed: %s. Ignore this if not relying on DNS SRV records", lcb_strerror(this, rc));

data/ext/libcouchbase/src/internal.h

@@ -132,6 +132,7 @@ struct lcb_st {
     lcb_MUTATION_TOKEN *dcpinfo; /**< Mapping of known vbucket to {uuid,seqno} info */
     lcbio_pTIMER dtor_timer; /**< Asynchronous destruction timer */
     int type; /**< Type of connection */
+    lcb_BTYPE btype; /**< Type of the bucket */
 
     #ifdef __cplusplus
     lcb_settings* getSettings() { return settings; }

data/ext/libcouchbase/src/lcbio/connect.cc

@@ -302,7 +302,6 @@ E_conncb(lcb_socket_t, short events, void *arg)
         goto GT_NEXTSOCK;
 
     } else {
-        rv = 0;
         ai = cs->ai;
 
         GT_CONNECT:
@@ -434,8 +433,8 @@ lcbio_connect(lcbio_TABLE *iot, lcb_settings *settings, const lcb_host_t *dest,
 
 Connstart::Connstart(lcbio_TABLE* iot_, lcb_settings* settings_,
                     const lcb_host_t *dest, uint32_t timeout,
-                    lcbio_CONNDONE_cb handler, void *arg)
-    : user_handler(handler), user_arg(arg), sock(NULL), syserr(0),
+                    lcbio_CONNDONE_cb handler_, void *arg)
+    : user_handler(handler_), user_arg(arg), sock(NULL), syserr(0),
       event(NULL), ev_active(false), in_uhandler(false),
       ai_root(NULL), ai(NULL), state(CS_PENDING), last_error(LCB_SUCCESS),
       timer(iot_, this) {

data/ext/libcouchbase/src/lcbio/manager.cc

@@ -289,8 +289,8 @@ void PoolConnInfo::on_connected(lcbio_SOCKET *sock_, lcb_error_t err) {
 
     if (err != LCB_SUCCESS) {
         /** If the connection failed, fail out all remaining requests */
-        lcb_list_t *cur, *next;
-        LCB_LIST_SAFE_FOR(cur, next, (lcb_list_t *)&parent->requests) {
+        lcb_list_t *cur, *nxt;
+        LCB_LIST_SAFE_FOR(cur, nxt, (lcb_list_t *)&parent->requests) {
             PoolRequest *req = PoolRequest::from_llnode(cur);
             lcb_clist_delete(&parent->requests, req);
             req->sock = NULL;

data/ext/libcouchbase/src/lcbio/ssl.h

@@ -26,6 +26,16 @@ extern "C" {
  * @file
  * @brief SSL Socket Routines
  */
+#ifndef LCB_NO_SSL
+#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x10100000L
+// OpenSSL 1.1 has changed behavior of BIO_get_mem_ptr behavior, so we cannot
+// apply reduce-memory-copy optimization, and fallback to BIO_write
+// Reference: https://github.com/openssl/openssl/commit/9fe9d0461ea
+#define LCB_CAN_OPTIMIZE_SSL_BIO 1
+#else
+#define LCB_CAN_OPTIMIZE_SSL_BIO 0
+#endif
+#endif
 
 /**
  * @ingroup lcbio

data/ext/libcouchbase/src/mc/mcreq.c

@@ -362,6 +362,8 @@ mcreq_renew_packet(const mc_PACKET *src)
                 assert(vdata == inflated);
 
                 if (rv != 0) {
+                    /* TODO: log error details when snappy will be enabled */
+                    free(edst);
                     return NULL;
                 }
                 nvdata = n_inflated;
@@ -461,6 +463,9 @@ mcreq_basic_packet(
     if (!queue->config) {
         return LCB_CLIENT_ETMPFAIL;
     }
+    if (!cmd) {
+        return LCB_EINVAL;
+    }
 
     mcreq_map_key(queue, &cmd->key, &cmd->_hashkey,
         sizeof(*req) + extlen, &vb, &srvix);
@@ -476,6 +481,9 @@ mcreq_basic_packet(
     }
 
     *packet = mcreq_allocate_packet(*pipeline);
+    if (*packet == NULL) {
+        return LCB_CLIENT_ENOMEM;
+    }
 
     mcreq_reserve_key(*pipeline, *packet, sizeof(*req) + extlen, &cmd->key);
 

data/ext/libcouchbase/src/mcserver/mcserver.cc

@@ -261,6 +261,19 @@ int Server::handle_unknown_error(const mc_PACKET *request,
         newerr = LCB_GENERIC_SUBDOCERR;
     }
 
+    /* TODO: remove masking LOCKED in 3.0 release */
+    if (err.hasAttribute(errmap::ITEM_LOCKED)) {
+        switch (mcresp.opcode()) {
+        case PROTOCOL_BINARY_CMD_SET:
+        case PROTOCOL_BINARY_CMD_REPLACE:
+        case PROTOCOL_BINARY_CMD_DELETE:
+            newerr = LCB_KEY_EEXISTS;
+            break;
+        default:
+            newerr = LCB_ETMPFAIL;
+        }
+    }
+
     int rv = 0;
 
     if (err.hasAttribute(errmap::AUTO_RETRY)) {
@@ -385,7 +398,7 @@ Server::try_read(lcbio_CTX *ctx, rdb_IOROPE *ior)
         /* figure out how many buffers we want to use as an upper limit for the
          * IOV arrays. Currently we'll keep it simple and ensure the entire
          * response is contiguous. */
-        lcb_PKTFWDRESP resp = { 0 };
+        lcb_PKTFWDRESP resp = { 0 }; /* TODO: next ABI version should include is_last flag */
         rdb_ROPESEG *segs;
         nb_IOV iov;
 

data/ext/libcouchbase/src/n1ql/ixmgmt.cc

@@ -407,9 +407,6 @@ do_index_list(lcb_t instance, const void *cookie, const lcb_CMDN1XMGMT *cmd,
     if (spec.ixtype) {
         const char *s_ixtype = ixtype_2_str(spec.ixtype);
         if (s_ixtype == NULL) {
-            if (ctx != NULL) {
-                delete ctx;
-            }
             return LCB_EINVAL;
         }
         ss.append(" using=\"").append(s_ixtype).append("\" AND");

data/ext/libcouchbase/src/n1ql/n1ql.cc

@@ -155,9 +155,6 @@ typedef struct lcb_N1QLREQ : lcb::jsparse::Parser::Actions {
     // How many rows were received. Used to avoid parsing the meta
     size_t nrows;
 
-    // Host for CBAS/Analytics query
-    std::string cbashost;
-
     /** The PREPARE query itself */
     struct lcb_N1QLREQ *prepare_req;
 
@@ -171,6 +168,9 @@ typedef struct lcb_N1QLREQ : lcb::jsparse::Parser::Actions {
     /** Whether we're retrying this */
     bool was_retried;
 
+    /** Is this query to Analytics (CBAS) service */
+    bool is_cbas;
+
     lcb_N1QLCACHE& cache() { return *instance->n1ql_cache; }
 
     /**
@@ -208,6 +208,11 @@ typedef struct lcb_N1QLREQ : lcb::jsparse::Parser::Actions {
      */
     inline bool maybe_retry();
 
+    /**
+     * Returns true if payload matches retry conditions.
+     */
+    inline bool has_retriable_error(const Json::Value& root);
+
     /**
      * Did the application request this query to use prepared statements
      * @return true if using prepared statements
@@ -230,10 +235,6 @@ typedef struct lcb_N1QLREQ : lcb::jsparse::Parser::Actions {
      */
     inline void fail_prepared(const lcb_RESPN1QL *orig, lcb_error_t err);
 
-    bool is_cbas() const {
-        return !cbashost.empty();
-    }
-
     inline lcb_N1QLREQ(lcb_t obj, const void *user_cookie, const lcb_CMDN1QL *cmd);
     inline ~lcb_N1QLREQ();
 
@@ -298,8 +299,8 @@ static const char *wtf_magic_strings[] = {
         NULL
 };
 
-static bool
-has_retriable_error(const Json::Value& root)
+bool
+N1QLREQ::has_retriable_error(const Json::Value& root)
 {
     if (!root.isObject()) {
         return false;
@@ -316,9 +317,11 @@ has_retriable_error(const Json::Value& root)
         }
         const Json::Value& jmsg = cur["msg"];
         const Json::Value& jcode = cur["code"];
+        unsigned code = 0;
         if (jcode.isNumeric()) {
-            unsigned code = jcode.asUInt();
+            code = jcode.asUInt();
             if (code == 4050 || code == 4070) {
+                lcb_log(LOGARGS(this, TRACE), LOGFMT "Will retry request. code: %d", LOGID(this), code);
                 return true;
             }
         }
@@ -326,6 +329,7 @@ has_retriable_error(const Json::Value& root)
             const char *jmstr = jmsg.asCString();
             for (const char **curs = wtf_magic_strings; *curs; curs++) {
                 if (!strstr(jmstr, *curs)) {
+                    lcb_log(LOGARGS(this, TRACE), LOGFMT "Will retry request. code: %d, msg: %s", LOGID(this), code, jmstr);
                     return true;
                 }
             }
@@ -458,8 +462,6 @@ chunk_callback(lcb_t instance, int ign, const lcb_RESPBASE *rb)
     req->parser->feed(static_cast<const char*>(rh->body), rh->nbody);
 }
 
-#define QUERY_PATH "/query/service"
-
 void
 N1QLREQ::fail_prepared(const lcb_RESPN1QL *orig, lcb_error_t err)
 {
@@ -523,9 +525,8 @@ N1QLREQ::issue_htreq(const std::string& body)
     htcmd.content_type = "application/json";
     htcmd.method = LCB_HTTP_METHOD_POST;
 
-    if (is_cbas()) {
-        htcmd.type = LCB_HTTP_TYPE_RAW;
-        htcmd.host = cbashost.c_str();
+    if (is_cbas) {
+        htcmd.type = LCB_HTTP_TYPE_CBAS;
     } else {
         htcmd.type = LCB_HTTP_TYPE_N1QL;
     }
@@ -607,7 +608,7 @@ lcb_N1QLREQ::lcb_N1QLREQ(lcb_t obj,
       parser(new lcb::jsparse::Parser(lcb::jsparse::Parser::MODE_N1QL, this)),
       cookie(user_cookie), callback(cmd->callback), instance(obj),
       lasterr(LCB_SUCCESS), flags(cmd->cmdflags), timeout(0),
-      nrows(0), prepare_req(NULL), was_retried(false)
+      nrows(0), prepare_req(NULL), was_retried(false), is_cbas(false)
 {
     if (cmd->handle) {
         *cmd->handle = this;
@@ -621,19 +622,11 @@ lcb_N1QLREQ::lcb_N1QLREQ(lcb_t obj,
     }
 
     if (flags & LCB_CMDN1QL_F_CBASQUERY) {
-        if (!cmd->host) {
-            lasterr = LCB_EINVAL;
-            return;
-        }
-        cbashost.assign(cmd->host);
-        if (cbashost.empty()) {
-            lasterr = LCB_EINVAL;
-            return;
-        }
-        if (flags & LCB_CMDN1QL_F_PREPCACHE) {
-            lasterr = LCB_OPTIONS_CONFLICT;
-            return;
-        }
+        is_cbas = true;
+    }
+    if (is_cbas && (flags & LCB_CMDN1QL_F_PREPCACHE)) {
+        lasterr = LCB_OPTIONS_CONFLICT;
+        return;
     }
 
     const Json::Value& j_statement = json_const()["statement"];

data/ext/libcouchbase/src/n1ql/params.cc

@@ -1,3 +1,20 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2015-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 <libcouchbase/couchbase.h>
 #include <libcouchbase/n1ql.h>
 #include <libcouchbase/vbucket.h>
@@ -84,6 +101,34 @@ lcb_n1p_posparam(lcb_N1QLPARAMS *params, const char *value, size_t nvalue)
     return LCB_SUCCESS;
 }
 
+lcb_error_t
+lcb_n1p_readonly(lcb_N1QLPARAMS *params, int readonly)
+{
+    params->root["readonly"] = readonly ? true : false;
+    return LCB_SUCCESS;
+}
+
+lcb_error_t
+lcb_n1p_scancap(lcb_N1QLPARAMS *params, int scancap)
+{
+    params->root["scan_cap"] = Json::valueToString(scancap);
+    return LCB_SUCCESS;
+}
+
+lcb_error_t
+lcb_n1p_pipelinecap(lcb_N1QLPARAMS *params, int pipelinecap)
+{
+    params->root["pipeline_cap"] = Json::valueToString(pipelinecap);
+    return LCB_SUCCESS;
+}
+
+lcb_error_t
+lcb_n1p_pipelinebatch(lcb_N1QLPARAMS *params, int pipelinebatch)
+{
+    params->root["pipeline_batch"] = Json::valueToString(pipelinebatch);
+    return LCB_SUCCESS;
+}
+
 static void
 encode_mutation_token(Json::Value& sparse, const lcb_MUTATION_TOKEN *sv)
 {
@@ -92,7 +137,7 @@ encode_mutation_token(Json::Value& sparse, const lcb_MUTATION_TOKEN *sv)
     Json::Value& cur_sv = sparse[buf];
 
     cur_sv[0] = static_cast<Json::UInt64>(sv->seqno_);
-    sprintf(buf, "%llu", sv->uuid_);
+    sprintf(buf, "%llu", (unsigned long long)sv->uuid_);
     cur_sv[1] = buf;
 }
 

data/ext/libcouchbase/src/newconfig.cc

@@ -103,12 +103,12 @@ lcb_vbguess_remap(lcb_t instance, int vbid, int bad)
 
     } else {
         lcb_GUESSVB *guesses = instance->vbguess;
-        lcb_GUESSVB *guess = guesses + vbid;
-        int newix = lcbvb_nmv_remap_ex(LCBT_VBCONFIG(instance), vbid, bad, 1);
         if (!guesses) {
-            guesses = instance->vbguess = reinterpret_cast<lcb_GUESSVB*>(calloc(
-                LCBT_VBCONFIG(instance)->nvb, sizeof *guesses));
+            guesses = instance->vbguess =
+                reinterpret_cast< lcb_GUESSVB * >(calloc(LCBT_VBCONFIG(instance)->nvb, sizeof(lcb_GUESSVB)));
         }
+        lcb_GUESSVB *guess = guesses + vbid;
+        int newix = lcbvb_nmv_remap_ex(LCBT_VBCONFIG(instance), vbid, bad, 1);
         if (newix > -1 && newix != bad) {
             guess->newix = newix;
             guess->oldix = bad;

data/ext/libcouchbase/src/operations/durability-seqno.cc

@@ -113,6 +113,10 @@ SeqnoDurset::poll_impl()
         ent.callback = seqno_callback;
 
         size_t nservers = ent.prepare(servers);
+        if (nservers == 0) {
+            ret_err = LCB_DURABILITY_ETOOMANY;
+            continue;
+        }
         for (size_t jj = 0; jj < nservers; jj++) {
             lcb_error_t err;
             cmd.server_index = servers[jj];

data/ext/libcouchbase/src/operations/durability.cc

@@ -284,6 +284,9 @@ lcb_error_t
 lcb_durability_validate(lcb_t instance,
     lcb_U16 *persist_to, lcb_U16 *replicate_to, int options)
 {
+    if (!LCBT_VBCONFIG(instance)) {
+        return LCB_CLIENT_ENOCONF;
+    }
     int replica_max = std::min(
         LCBT_NREPLICAS(instance),
         LCBT_NDATASERVERS(instance)-1);

data/ext/libcouchbase/src/operations/ping.cc

@@ -0,0 +1,315 @@
+/* -*- 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 "internal.h"
+#include <libcouchbase/n1ql.h>
+#include "http/http.h"
+#include "auth-priv.h"
+
+static void refcnt_dtor_ping(mc_PACKET *);
+static void handle_ping(mc_PIPELINE *, mc_PACKET *, lcb_error_t, const void *);
+
+static mc_REQDATAPROCS ping_procs = {
+    handle_ping,
+    refcnt_dtor_ping
+};
+
+struct PingCookie : mc_REQDATAEX {
+    int remaining;
+    int options;
+    std::list<lcb_PINGSVC> responses;
+
+    PingCookie(const void *cookie_, int _options)
+        : mc_REQDATAEX(cookie_, ping_procs, gethrtime()),
+        remaining(0), options(_options) {
+    }
+
+    ~PingCookie() {
+        for (std::list<lcb_PINGSVC>::iterator it = responses.begin(); it != responses.end(); it++) {
+            if (it->server) {
+                free(it->server);
+                it->server = NULL;
+            }
+        }
+    }
+
+    bool needMetrics() {
+        return (options & LCB_PINGOPT_F_NOMETRICS) == 0;
+    }
+
+    bool needJSON() {
+        return options & LCB_PINGOPT_F_JSON;
+    }
+
+    bool needDetails() {
+        return options & LCB_PINGOPT_F_JSONDETAILS;
+    }
+
+    bool needPretty() {
+        return options & LCB_PINGOPT_F_JSONPRETTY;
+    }
+};
+
+static void
+refcnt_dtor_ping(mc_PACKET *pkt)
+{
+    PingCookie *ck = static_cast<PingCookie *>(pkt->u_rdata.exdata);
+    if (!--ck->remaining) {
+        delete ck;
+    }
+}
+
+static std::string latency_to_string(lcb_U64 latency)
+{
+    std::stringstream ss;
+    ss.precision(3);
+    ss.setf(std::ios::fixed);
+    if (latency < 1000) {
+        ss << latency << "ns";
+    } else if (latency < LCB_US2NS(1000)) {
+        ss << (latency / (double)LCB_US2NS(1)) << "us";
+    } else if (latency < LCB_MS2NS(1000)) {
+        ss << (latency / (double)LCB_MS2NS(1)) << "ms";
+    } else {
+        ss << (latency / (double)LCB_S2NS(1)) << "s";
+    }
+    return ss.str();
+}
+
+static const char* svc_to_string(lcb_PINGSVCTYPE type)
+{
+    switch (type) {
+    case LCB_PINGSVC_KV:
+        return "kv";
+    case LCB_PINGSVC_VIEWS:
+        return "views";
+    case LCB_PINGSVC_N1QL:
+        return "n1ql";
+    case LCB_PINGSVC_FTS:
+        return "fts";
+    default:
+        return "unknown";
+    }
+}
+
+static void
+build_ping_json(lcb_RESPPING &ping, Json::Value &root, bool details)
+{
+    Json::Value services;
+    for (size_t ii = 0; ii < ping.nservices; ii++) {
+        lcb_PINGSVC &svc = ping.services[ii];
+        Json::Value service;
+        service["server"] = svc.server;
+        service["latency"] = latency_to_string(svc.latency);
+        service["status"] = svc.status;
+        if (details) {
+            service["details"] = lcb_strerror(NULL, svc.status);
+        }
+        services[svc_to_string(svc.type)].append(service);
+    }
+    root["services"] = services;
+}
+
+static void
+invoke_ping_callback(lcb_t instance, PingCookie *ck)
+{
+    lcb_RESPPING ping;
+    std::string json;
+    size_t idx = 0;
+    memset(&ping, 0, sizeof(ping));
+    if (ck->needMetrics()) {
+        ping.nservices = ck->responses.size();
+        ping.services = new lcb_PINGSVC[ping.nservices];
+        for(std::list<lcb_PINGSVC>::const_iterator it = ck->responses.begin(); it != ck->responses.end(); ++it){
+            ping.services[idx++] = *it;
+        }
+        if (ck->needJSON()) {
+            Json::Value root;
+            build_ping_json(ping, root, ck->needDetails());
+            Json::Writer *w;
+            if (ck->needPretty()) {
+                w = new Json::StyledWriter();
+            } else {
+                w = new Json::FastWriter();
+            }
+            json = w->write(root);
+            delete w;
+            ping.njson = json.size();
+            ping.json = json.c_str();
+        }
+    }
+    lcb_RESPCALLBACK callback;
+    callback = lcb_find_callback(instance, LCB_CALLBACK_PING);
+    ping.cookie = const_cast<void*>(ck->cookie);
+    callback(instance, LCB_CALLBACK_PING, (lcb_RESPBASE *)&ping);
+    if (ping.services != NULL) {
+        delete []ping.services;
+    }
+    delete ck;
+}
+
+static void
+handle_ping(mc_PIPELINE *pipeline, mc_PACKET *req, lcb_error_t err, const void *)
+{
+    lcb::Server *server = static_cast<lcb::Server*>(pipeline);
+    PingCookie *ck = (PingCookie *)req->u_rdata.exdata;
+
+    if (ck->needMetrics()) {
+        std::string hh(server->get_host().host);
+        hh.append(":");
+        hh.append(server->get_host().port);
+
+        lcb_PINGSVC svc;
+        svc.type = LCB_PINGSVC_KV;
+        svc.server = strdup(hh.c_str());
+        svc.latency = gethrtime() - MCREQ_PKT_RDATA(req)->start;
+        svc.status = err;
+        ck->responses.push_back(svc);
+    }
+
+    if (--ck->remaining) {
+        return;
+    }
+    invoke_ping_callback(server->get_instance(), ck);
+}
+
+static void handle_http(lcb_t instance, lcb_PINGSVCTYPE type, const lcb_RESPHTTP *resp)
+{
+    if ((resp->rflags & LCB_RESP_F_FINAL) == 0) {
+        return;
+    }
+    PingCookie *ck = (PingCookie *)resp->cookie;
+    lcb::http::Request *htreq = reinterpret_cast<lcb::http::Request*>(resp->_htreq);
+
+    if (ck->needMetrics()) {
+        lcb_PINGSVC svc;
+        svc.type = type;
+        svc.server = strdup((htreq->host + ":" + htreq->port).c_str());
+        svc.latency = gethrtime() - htreq->start;
+        svc.status = resp->rc;
+        ck->responses.push_back(svc);
+    }
+    if (--ck->remaining) {
+        return;
+    }
+    invoke_ping_callback(instance, ck);
+}
+
+static void handle_n1ql(lcb_t instance, int, const lcb_RESPBASE *resp)
+{
+    handle_http(instance, LCB_PINGSVC_N1QL, (const lcb_RESPHTTP *)resp);
+}
+
+static void handle_views(lcb_t instance, int, const lcb_RESPBASE *resp)
+{
+    handle_http(instance, LCB_PINGSVC_VIEWS, (const lcb_RESPHTTP *)resp);
+}
+
+static void handle_fts(lcb_t instance, int, const lcb_RESPBASE *resp)
+{
+    handle_http(instance, LCB_PINGSVC_FTS, (const lcb_RESPHTTP *)resp);
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_ping3(lcb_t instance, const void *cookie, const lcb_CMDPING *cmd)
+{
+    mc_CMDQUEUE *cq = &instance->cmdq;
+    unsigned ii;
+
+    if (!cq->config) {
+        return LCB_CLIENT_ETMPFAIL;
+    }
+
+    PingCookie *ckwrap = new PingCookie(cookie, cmd->options);
+
+    if (cmd->services & LCB_PINGSVC_F_KV) {
+        for (ii = 0; ii < cq->npipelines; ii++) {
+            mc_PIPELINE *pl = cq->pipelines[ii];
+            mc_PACKET *pkt = mcreq_allocate_packet(pl);
+            protocol_binary_request_header hdr;
+            memset(&hdr, 0, sizeof(hdr));
+
+            if (!pkt) {
+                return LCB_CLIENT_ENOMEM;
+            }
+
+            pkt->u_rdata.exdata = ckwrap;
+            pkt->flags |= MCREQ_F_REQEXT;
+
+            hdr.request.magic = PROTOCOL_BINARY_REQ;
+            hdr.request.opaque = pkt->opaque;
+            hdr.request.opcode = PROTOCOL_BINARY_CMD_NOOP;
+
+            mcreq_reserve_header(pl, pkt, MCREQ_PKT_BASESIZE);
+            memcpy(SPAN_BUFFER(&pkt->kh_span), hdr.bytes, sizeof(hdr.bytes));
+            mcreq_sched_add(pl, pkt);
+            ckwrap->remaining++;
+        }
+    }
+
+    lcbvb_CONFIG *cfg = LCBT_VBCONFIG(instance);
+    const lcbvb_SVCMODE mode = LCBT_SETTING(instance, sslopts) ?
+            LCBVB_SVCMODE_SSL : LCBVB_SVCMODE_PLAIN;
+    for (int idx = 0; idx < (int)LCBVB_NSERVERS(cfg); idx++) {
+#define PING_HTTP(SVC, QUERY, TMO, CB)                                  \
+        do {                                                            \
+            lcb_error_t rc;                                             \
+            struct lcb_http_request_st *htreq;                          \
+            lcb_CMDHTTP htcmd = {0};                                    \
+            htcmd.host = lcbvb_get_resturl(cfg, idx, SVC, mode);        \
+            if (htcmd.host == NULL) {                                   \
+                continue;                                               \
+            }                                                           \
+            htcmd.body = QUERY;                                         \
+            htcmd.nbody = strlen(htcmd.body);                           \
+            htcmd.content_type = "application/json";                    \
+            htcmd.method = LCB_HTTP_METHOD_POST;                        \
+            htcmd.type = LCB_HTTP_TYPE_RAW;                             \
+            htcmd.reqhandle = &htreq;                                   \
+            const lcb::Authenticator& auth = *instance->settings->auth; \
+            htcmd.username = auth.username_for(LCBT_SETTING(instance, bucket)).c_str(); \
+            htcmd.password = auth.password_for(LCBT_SETTING(instance, bucket)).c_str(); \
+            htcmd.cmdflags = LCB_CMDHTTP_F_CASTMO;                      \
+            htcmd.cas = LCBT_SETTING(instance, TMO);                    \
+            rc = lcb_http3(instance, ckwrap, &htcmd);                   \
+            if (rc == LCB_SUCCESS) {                                    \
+                htreq->set_callback(CB);                                \
+            }                                                           \
+            ckwrap->remaining++;                                        \
+        } while (0);
+
+        if (cmd->services & LCB_PINGSVC_F_N1QL) {
+            PING_HTTP(LCBVB_SVCTYPE_N1QL, "{\"statement\":\"select 1\"}",
+                      n1ql_timeout, handle_n1ql);
+        }
+        if (cmd->services & LCB_PINGSVC_F_VIEWS) {
+            PING_HTTP(LCBVB_SVCTYPE_VIEWS, "", views_timeout, handle_views);
+        }
+        if (cmd->services & LCB_PINGSVC_F_FTS) {
+            PING_HTTP(LCBVB_SVCTYPE_FTS, "", n1ql_timeout, handle_fts);
+        }
+#undef PING_HTTP
+    }
+
+    if (ckwrap->remaining == 0) {
+        delete ckwrap;
+        return LCB_NO_MATCHING_SERVER;
+    }
+    MAYBE_SCHEDLEAVE(instance);
+    return LCB_SUCCESS;
+}