libcouchbase 1.3.0 → 1.3.2

data/ext/libcouchbase/src/dns-srv.cc

@@ -88,7 +88,7 @@ lcb::dnssrv_query(const char* name, lcb::Hostlist& hostlist)
 }
 #endif /* HAVE_RES_SEARCH */
 
-#else
+#elif defined(_MSC_VER)
 #include <windns.h>
 #define CAN_SRV_LOOKUP
 /* Implement via DnsQuery() */

data/ext/libcouchbase/src/handler.cc

@@ -679,7 +679,6 @@ H_observe(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse *response
             rd->procs->handler(pipeline, request, resp.rc, &resp);
         }
     }
-    TRACE_OBSERVE_END(root, request, response);
 }
 
 static void

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

@@ -79,6 +79,7 @@ struct Request {
         return reqtype == LCB_HTTP_TYPE_N1QL ||
                 reqtype == LCB_HTTP_TYPE_VIEW ||
                 reqtype == LCB_HTTP_TYPE_FTS ||
+                reqtype == LCB_HTTP_TYPE_PING ||
                 reqtype == LCB_HTTP_TYPE_CBAS;
     }
 

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

@@ -412,8 +412,7 @@ Request::get_api_node(lcb_error_t &rc)
     }
 
     const lcbvb_SVCTYPE svc = httype2svctype(reqtype);
-    const lcbvb_SVCMODE mode = LCBT_SETTING(instance, sslopts) ?
-            LCBVB_SVCMODE_SSL : LCBVB_SVCMODE_PLAIN;
+    const lcbvb_SVCMODE mode = LCBT_SETTING_SVCMODE(instance);
 
     lcbvb_CONFIG *vbc = LCBT_VBCONFIG(instance);
 

data/ext/libcouchbase/src/instance.cc

@@ -451,7 +451,10 @@ lcb_error_t lcb_create(lcb_t *instance,
         goto GT_DONE;
     }
 
-    settings->logger = lcb_init_console_logger();
+    settings->logger = spec.logger();
+    if (settings->logger == NULL) {
+        settings->logger = lcb_init_console_logger();
+    }
     settings->iid = lcb_next_rand32();
     if (spec.loglevel()) {
         lcb_U32 val = spec.loglevel();
@@ -615,9 +618,25 @@ void lcb_destroy(lcb_t instance)
     DESTROY(lcb_vbguess_destroy, vbguess);
     DESTROY(lcb_n1qlcache_destroy, n1ql_cache);
 
+    if (instance->cmdq.pipelines) {
+        unsigned ii;
+        for (ii = 0; ii < instance->cmdq.npipelines; ii++) {
+            lcb::Server *server = static_cast<lcb::Server*>(instance->cmdq.pipelines[ii]);
+            if (server) {
+                server->instance = NULL;
+            }
+        }
+    }
     mcreq_queue_cleanup(&instance->cmdq);
     lcb_aspend_cleanup(po);
 
+#ifdef LCB_TRACING
+    if (instance->settings && instance->settings->tracer) {
+        lcbtrace_destroy(instance->settings->tracer);
+        instance->settings->tracer = NULL;
+    }
+#endif
+
     if (instance->iotable && instance->iotable->refcount > 1 &&
             instance->settings && instance->settings->syncdtor) {
         /* create an async object */
@@ -676,7 +695,7 @@ lcb_st::find_server(const lcb_host_t& host) const
     unsigned ii;
     for (ii = 0; ii < cmdq.npipelines; ii++) {
         lcb::Server *server = static_cast<lcb::Server*>(cmdq.pipelines[ii]);
-        if (lcb_host_equals(&server->get_host(), &host)) {
+        if (server && lcb_host_equals(&server->get_host(), &host)) {
             return server;
         }
     }

data/ext/libcouchbase/src/internal.h

@@ -196,6 +196,7 @@ struct lcb_st {
 #define LCBT_NREPLICAS(instance) LCBVB_NREPLICAS(LCBT_VBCONFIG(instance))
 #define LCBT_GET_SERVER(instance, ix) (instance)->cmdq.pipelines[ix]
 #define LCBT_SETTING(instance, name) (instance)->settings->name
+#define LCBT_SETTING_SVCMODE(instance) (((instance)->settings->sslopts & LCB_SSL_ENABLED) ? LCBVB_SVCMODE_SSL : LCBVB_SVCMODE_PLAIN)
 
 void lcb_initialize_packet_handlers(lcb_t instance);
 

data/ext/libcouchbase/src/lcbio/ctx.c

@@ -31,11 +31,11 @@
     } \
 } while (0)
 
-#include "rw-inl.h"
-#include "ctx-log-inl.h"
 
 #define LOGARGS(c, lvl) (c)->sock->settings, "ioctx", LCB_LOG_##lvl, __FILE__, __LINE__
 
+#include "rw-inl.h"
+
 typedef enum {
     ES_ACTIVE = 0,
     ES_DETACHED
@@ -385,6 +385,18 @@ Cr_handler(lcb_sockdata_t *sd, lcb_ssize_t nr, void *arg)
             rdb_rdend(&ctx->ior, nr);
             total = rdb_get_nused(&ctx->ior);
             if (total >= ctx->rdwant) {
+#ifdef LCB_DUMP_PACKETS
+                {
+                    char *b64 = NULL;
+                    lcb_SIZE nb64 = 0;
+                    char *buf = calloc(total, sizeof(char));
+                    rdb_copyread(&ctx->ior, buf, total);
+                    lcb_base64_encode2(buf, total, &b64, &nb64);
+                    lcb_log(LOGARGS(ctx, TRACE), CTX_LOGFMT "pkt,rcv: size=%d, %.*s", CTX_LOGID(ctx), (int)nb64, (int)nb64, b64);
+                    free(b64);
+                    free(buf);
+                }
+#endif
                 invoke_read_cb(ctx, total);
             }
             CTX_INCR_METRIC(ctx, bytes_received, total);
@@ -421,7 +433,7 @@ C_schedule(lcbio_CTX *ctx)
 
     if (ctx->output && ctx->output->rb.nbytes) {
         /** Schedule a write */
-        lcb_IOV iov[2];
+        lcb_IOV iov[2] = {0};
         unsigned niov;
 
         ringbuffer_get_iov(&ctx->output->rb, RINGBUFFER_READ, iov);
@@ -433,6 +445,15 @@ C_schedule(lcbio_CTX *ctx)
         } else {
             ctx->output = NULL;
             ctx->npending++;
+#ifdef LCB_DUMP_PACKETS
+            {
+                char *b64 = NULL;
+                int nb64 = 0;
+                lcb_base64_encode_iov((lcb_IOV *)iov, niov, iov[0].iov_len + iov[1].iov_len, &b64, &nb64);
+                lcb_log(LOGARGS(ctx, TRACE), CTX_LOGFMT "pkt,snd: size=%d, %.*s", CTX_LOGID(ctx), nb64, nb64, b64);
+                free(b64);
+            }
+#endif
         }
     }
 

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

@@ -109,7 +109,7 @@ lcb_error_t
 lcbio_mklcberr(lcbio_OSERR in, const lcb_settings *settings)
 {
     if (settings->detailed_neterr == 0) {
-        lcb_log(settings, "lcbio", LCB_LOG_INFO, __FILE__, __LINE__, "Translating errno=%d, lcb=0x%x to NETWORK_ERROR",
+        lcb_log(settings, "lcbio", LCB_LOG_WARN, __FILE__, __LINE__, "Translating errno=%d, lcb=0x%x to NETWORK_ERROR",
             in, ioerr2lcberr(in, settings));
         return LCB_NETWORK_ERROR;
     }

data/ext/libcouchbase/src/lcbio/rw-inl.h

@@ -20,6 +20,9 @@
  */
 #include <errno.h>
 #include <limits.h> /* For IOV_MAX */
+#include "ctx-log-inl.h"
+#include "strcodecs/strcodecs.h"
+
 #ifndef INLINE
 #ifdef _MSC_VER
 #define INLINE __inline
@@ -57,6 +60,15 @@ lcbio_E_rdb_slurp(lcbio_CTX *ctx, rdb_IOROPE *ior)
         GT_READ:
         rv = IOT_V0IO(iot).recvv(IOT_ARG(iot), CTX_FD(ctx), iov, niov);
         if (rv > 0) {
+#ifdef LCB_DUMP_PACKETS
+            {
+                char *b64 = NULL;
+                int nb64 = 0;
+                lcb_base64_encode_iov((lcb_IOV *)iov, niov, rv, &b64, &nb64);
+                lcb_log(LOGARGS(ctx, TRACE), CTX_LOGFMT "pkt,rcv: size=%d, %.*s", CTX_LOGID(ctx), nb64, nb64, b64);
+                free(b64);
+            }
+#endif
             rdb_rdend(ior, rv);
             if (rdsize && (total_nr += rv) >= rdsize) {
                 return LCBIO_PENDING;
@@ -83,7 +95,7 @@ lcbio_E_rdb_slurp(lcbio_CTX *ctx, rdb_IOROPE *ior)
 static INLINE lcbio_IOSTATUS
 lcbio_E_rb_write(lcbio_CTX *ctx, ringbuffer_t *buf)
 {
-    lcb_IOV iov[2];
+    lcb_IOV iov[2] = {0};
     lcb_ssize_t nw;
     lcbio_TABLE *iot = ctx->io;
     while (buf->nbytes) {
@@ -108,6 +120,15 @@ lcbio_E_rb_write(lcbio_CTX *ctx, ringbuffer_t *buf)
             }
         }
         if (nw) {
+#ifdef LCB_DUMP_PACKETS
+            {
+                char *b64 = NULL;
+                int nb64 = 0;
+                lcb_base64_encode_iov((lcb_IOV *)iov, niov, nw, &b64, &nb64);
+                lcb_log(LOGARGS(ctx, TRACE), CTX_LOGFMT "pkt,snd: size=%d, %.*s", CTX_LOGID(ctx), nb64, nb64, b64);
+                free(b64);
+            }
+#endif
             ringbuffer_consumed(buf, nw);
             CTX_INCR_METRIC(ctx, bytes_sent, nw);
         }

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

@@ -66,7 +66,9 @@ lcbio_pSSLCTX lcbio_ssl_new__fallback(const char *, const char *, const char *,
 #ifndef LCB_NO_SSL
 /**
  * Create a new SSL context to be used to establish SSL policy.
+ * @param tsfile Path to trusted store file
  * @param cafile Optional path to CA file
+ * @param keyfile Path to private key file
  * @param noverify To not attempt to verify server's certificate
  * @param errp a pointer to contain the error code if initialization failed
  * @param settings settings structure, used for logging.

data/ext/libcouchbase/src/mc/compress.cc

@@ -54,18 +54,25 @@ class FragBufSource : public snappy::Source
 
     virtual void Skip(size_t n)
     {
-        lcb_IOV &v = buf->iov[idx];
-        if (ptr == static_cast< const char * >(v.iov_base) && n == v.iov_len) {
-            ptr = static_cast< const char * >(buf->iov[++idx].iov_base);
-        } else {
-            ptr += n;
-            if (static_cast< size_t >(ptr - static_cast< const char * >(v.iov_base)) == v.iov_len) {
-                ptr = static_cast< const char * >(buf->iov[++idx].iov_base);
+        do {
+            size_t spanleft = buf->iov[idx].iov_len - (ptr - static_cast< const char * >(buf->iov[idx].iov_base));
+            if (n < spanleft) {
+                ptr += n;
+                left -= n;
+                break;
             }
-        }
-        left -= n;
-        if (left == 0) {
+            if (idx + 1 >= buf->niov) {
+                left = 0;
+                ptr = NULL;
+                break;
+            }
+            left -= spanleft;
+            n -= spanleft;
+            ptr = static_cast< const char * >(buf->iov[++idx].iov_base);
+        } while (n > 0);
+        if (left == 0 || idx >= buf->niov) {
             ptr = NULL;
+            left = 0;
         }
     }
 
@@ -125,7 +132,7 @@ int mcreq_compress_value(mc_PIPELINE *pl, mc_PACKET *pkt, const lcb_VALBUF *vbuf
     compsize = sink.CurrentDestination() - SPAN_BUFFER(outspan);
     delete source;
 
-    if (compsize == 0 || compsize / origsize > settings->compress_min_ratio) {
+    if (compsize == 0 || (((float)compsize / origsize) > settings->compress_min_ratio)) {
         netbuf_mblock_release(&pl->nbmgr, outspan);
         *should_compress = 0;
         mcreq_reserve_value(pl, pkt, vbuf);

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

@@ -640,6 +640,8 @@ mcreq_queue_cleanup(mc_CMDQUEUE *queue)
     }
     free(queue->scheds);
     free(queue->pipelines);
+    queue->pipelines = NULL;
+    queue->npipelines = 0;
     queue->scheds = NULL;
 }
 

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

@@ -699,7 +699,7 @@ mcreq_get_bodysize(const mc_PACKET *packet);
 
 /**
  * @brief get the total packet size (header+body)
- * @param pkt the packet
+ * @param packet the packet
  * @return the total size
  */
 uint32_t

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

@@ -46,7 +46,7 @@ static void
 on_flush_ready(lcbio_CTX *ctx)
 {
     Server *server = Server::get(ctx);
-    nb_IOV iov[MCREQ_MAXIOV];
+    nb_IOV iov[MCREQ_MAXIOV] = {};
     int ready;
 
     do {
@@ -56,6 +56,15 @@ on_flush_ready(lcbio_CTX *ctx)
         if (!nb) {
             return;
         }
+#ifdef LCB_DUMP_PACKETS
+        {
+            char *b64 = NULL;
+            int nb64 = 0;
+            lcb_base64_encode_iov((lcb_IOV *)iov, niov, nb, &b64, &nb64);
+            lcb_log(LOGARGS(server, TRACE), LOGFMT "pkt,snd,fill: size=%d, %.*s", LOGID(server), nb64, nb64, b64);
+            free(b64);
+        }
+#endif
         ready = lcbio_ctx_put_ex(ctx, (lcb_IOV *)iov, niov, nb);
     } while (ready);
     lcbio_ctx_wwant(ctx);
@@ -70,6 +79,9 @@ on_flush_done(lcbio_CTX *ctx, unsigned expected, unsigned actual)
         now = gethrtime();
     }
 
+#ifdef LCB_DUMP_PACKETS
+    lcb_log(LOGARGS(server, TRACE), LOGFMT "pkt,snd,flush: expected=%u, actual=%u", LOGID(server), expected, actual);
+#endif
     mcreq_flush_done_ex(server, actual, expected, now);
     server->check_closed();
 }
@@ -197,6 +209,14 @@ static bool is_fastpath_error(uint16_t rc) {
     case PROTOCOL_BINARY_RESPONSE_SUBDOC_DELTA_ERANGE:
     case PROTOCOL_BINARY_RESPONSE_SUBDOC_INVALID_COMBO:
     case PROTOCOL_BINARY_RESPONSE_SUBDOC_MULTI_PATH_FAILURE:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_SUCCESS_DELETED:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_XATTR_INVALID_FLAG_COMBO:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_XATTR_INVALID_KEY_COMBO:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_XATTR_UNKNOWN_MACRO:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_XATTR_UNKNOWN_VATTR:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_XATTR_CANT_MODIFY_VATTR:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_MULTI_PATH_FAILURE_DELETED:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_INVALID_XATTR_ORDER:
     case PROTOCOL_BINARY_RESPONSE_EACCESS:
         return true;
     default:
@@ -357,7 +377,7 @@ Server::try_read(lcbio_CTX *ctx, rdb_IOROPE *ior)
 
     if (!request) {
         MC_INCR_METRIC(this, packets_ownerless, 1);
-        lcb_log(LOGARGS_T(WARN), LOGFMT "Server sent us reply for a timed-out command. (OP=0x%x, RC=0x%x, SEQ=%u)", LOGID_T(), mcresp.opcode(), mcresp.status(), mcresp.opaque());
+        lcb_log(LOGARGS_T(DEBUG), LOGFMT "Server sent us reply for a timed-out command. (OP=0x%x, RC=0x%x, SEQ=%u)", LOGID_T(), mcresp.opcode(), mcresp.status(), mcresp.opaque());
         rdb_consumed(ior, pktsize);
         return PKT_READ_COMPLETE;
     }
@@ -475,6 +495,100 @@ fail_callback(mc_PIPELINE *pipeline, mc_PACKET *pkt, lcb_error_t err, void *) {
     static_cast<Server*>(pipeline)->purge_single(pkt, err);
 }
 
+static const char *opcode_name(uint8_t code)
+{
+    switch (code) {
+        case PROTOCOL_BINARY_CMD_GET:
+            return "get";
+        case PROTOCOL_BINARY_CMD_SET:
+            return "set";
+        case PROTOCOL_BINARY_CMD_ADD:
+            return "add";
+        case PROTOCOL_BINARY_CMD_REPLACE:
+            return "replace";
+        case PROTOCOL_BINARY_CMD_DELETE:
+            return "delete";
+        case PROTOCOL_BINARY_CMD_INCREMENT:
+            return "incr";
+        case PROTOCOL_BINARY_CMD_DECREMENT:
+            return "decr";
+        case PROTOCOL_BINARY_CMD_FLUSH:
+            return "flush";
+        case PROTOCOL_BINARY_CMD_GETQ:
+            return "getq";
+        case PROTOCOL_BINARY_CMD_NOOP:
+            return "noop";
+        case PROTOCOL_BINARY_CMD_VERSION:
+            return "version";
+        case PROTOCOL_BINARY_CMD_APPEND:
+            return "append";
+        case PROTOCOL_BINARY_CMD_PREPEND:
+            return "prepend";
+        case PROTOCOL_BINARY_CMD_STAT:
+            return "stat";
+        case PROTOCOL_BINARY_CMD_VERBOSITY:
+            return "verbosity";
+        case PROTOCOL_BINARY_CMD_TOUCH:
+            return "touch";
+        case PROTOCOL_BINARY_CMD_GAT:
+            return "gat";
+        case PROTOCOL_BINARY_CMD_HELLO:
+            return "hello";
+        case PROTOCOL_BINARY_CMD_SASL_LIST_MECHS:
+            return "sasl_list_mechs";
+        case PROTOCOL_BINARY_CMD_SASL_AUTH:
+            return "sasl_auth";
+        case PROTOCOL_BINARY_CMD_SASL_STEP:
+            return "sasl_step";
+        case PROTOCOL_BINARY_CMD_GET_REPLICA:
+            return "get_replica";
+        case PROTOCOL_BINARY_CMD_SELECT_BUCKET:
+            return "select_bucket";
+        case PROTOCOL_BINARY_CMD_OBSERVE_SEQNO:
+            return "observe_seqno";
+        case PROTOCOL_BINARY_CMD_OBSERVE:
+            return "observe";
+        case PROTOCOL_BINARY_CMD_GET_LOCKED:
+            return "get_locked";
+        case PROTOCOL_BINARY_CMD_UNLOCK_KEY:
+            return "unlock_key";
+        case PROTOCOL_BINARY_CMD_GET_CLUSTER_CONFIG:
+            return "get_cluster_config";
+        case PROTOCOL_BINARY_CMD_SUBDOC_GET:
+            return "subdoc_get";
+        case PROTOCOL_BINARY_CMD_SUBDOC_EXISTS:
+            return "subdoc_exists";
+        case PROTOCOL_BINARY_CMD_SUBDOC_DICT_ADD:
+            return "subdoc_dict_add";
+        case PROTOCOL_BINARY_CMD_SUBDOC_DICT_UPSERT:
+            return "subdoc_dict_upsert";
+        case PROTOCOL_BINARY_CMD_SUBDOC_DELETE:
+            return "subdoc_delete";
+        case PROTOCOL_BINARY_CMD_SUBDOC_REPLACE:
+            return "subdoc_replace";
+        case PROTOCOL_BINARY_CMD_SUBDOC_ARRAY_PUSH_LAST:
+            return "subdoc_array_push_last";
+        case PROTOCOL_BINARY_CMD_SUBDOC_ARRAY_PUSH_FIRST:
+            return "subdoc_array_push_first";
+        case PROTOCOL_BINARY_CMD_SUBDOC_ARRAY_INSERT:
+            return "subdoc_array_insert";
+        case PROTOCOL_BINARY_CMD_SUBDOC_ARRAY_ADD_UNIQUE:
+            return "subdoc_array_add_unique";
+        case PROTOCOL_BINARY_CMD_SUBDOC_COUNTER:
+            return "subdoc_counter";
+        case PROTOCOL_BINARY_CMD_SUBDOC_MULTI_LOOKUP:
+            return "subdoc_multi_lookup";
+        case PROTOCOL_BINARY_CMD_SUBDOC_MULTI_MUTATION:
+            return "subdoc_multi_mutation";
+        case PROTOCOL_BINARY_CMD_SUBDOC_GET_COUNT:
+            return "subdoc_get_count";
+        case PROTOCOL_BINARY_CMD_GET_ERROR_MAP:
+            return "get_error_map";
+        default:
+            return "unknown";
+    }
+}
+
 void Server::purge_single(mc_PACKET *pkt, lcb_error_t err) {
     if (maybe_retry_packet(pkt, err)) {
         return;
@@ -502,7 +616,39 @@ void Server::purge_single(mc_PACKET *pkt, lcb_error_t err) {
 #ifdef LCB_TRACING
     lcbtrace_span_set_orphaned(MCREQ_PKT_RDATA(pkt)->span, true);
 #endif
-    lcb_log(LOGARGS_T(WARN), LOGFMT "Failing command (pkt=%p, opaque=%lu, opcode=0x%x) with error %s", LOGID_T(), (void*)pkt, (unsigned long)pkt->opaque, hdr.request.opcode, lcb_strerror_short(err));
+    if (err == LCB_ETIMEDOUT && settings->use_tracing) {
+        Json::Value info;
+
+        char opid[30] = {};
+        snprintf(opid, sizeof(opid), "kv:%s", opcode_name(hdr.request.opcode));
+        info["s"] = opid;
+        info["b"] = settings->bucket;
+        info["t"] = settings->operation_timeout;
+
+        const lcb_host_t &remote = get_host();
+        std::string rhost;
+        if (remote.ipv6) {
+            rhost.append("[").append(remote.host).append("]:").append(remote.port);
+        } else {
+            rhost.append(remote.host).append(":").append(remote.port);
+        }
+        info["r"] = rhost.c_str();
+
+        if (connctx) {
+            char local_id[54] = {};
+            snprintf(local_id, sizeof(local_id), "%016" PRIx64 "/%016" PRIx64 "/%x",
+                     (lcb_U64)settings->iid, connctx->sock->id, (int)pkt->opaque);
+            info["i"] = local_id;
+            info["l"] = lcbio__inet_ntop(&connctx->sock->info->sa_local).c_str();
+        }
+        std::string msg(Json::FastWriter().write(info));
+        if (msg.size() > 1) {
+            lcb_log(LOGARGS(instance, WARN), "Failing command with error %s: %.*s",
+                    lcb_strerror_short(err), (int)(msg.size() - 1), msg.c_str());
+        }
+    } else {
+        lcb_log(LOGARGS_T(WARN), LOGFMT "Failing command (pkt=%p, opaque=%lu, opcode=0x%x) with error %s", LOGID_T(), (void*)pkt, (unsigned long)pkt->opaque, hdr.request.opcode, lcb_strerror_short(err));
+    }
     int rv = mcreq_dispatch_response(this, pkt, &resp, err);
     lcb_assert(rv == 0);
 }
@@ -579,7 +725,7 @@ void Server::io_timeout()
                         Server::REFRESH_ONFAILED);
     if (npurged) {
         MC_INCR_METRIC(this, packets_timeout, npurged);
-        lcb_log(LOGARGS_T(ERR), LOGFMT "Server timed out. Some commands have failed", LOGID_T());
+        lcb_log(LOGARGS_T(DEBUG), LOGFMT "Server timed out. Some commands have failed", LOGID_T());
     }
 
     uint32_t next_us = next_timeout();
@@ -706,8 +852,7 @@ Server::Server(lcb_t instance_, int ix)
 
     const char *datahost = lcbvb_get_hostport(
         LCBT_VBCONFIG(instance), ix,
-        LCBVB_SVCTYPE_DATA, settings->sslopts & LCB_SSL_ENABLED ?
-                LCBVB_SVCMODE_SSL : LCBVB_SVCMODE_PLAIN);
+        LCBVB_SVCTYPE_DATA, LCBT_SETTING_SVCMODE(instance));
     if (datahost) {
         lcb_host_parsez(curhost, datahost, LCB_CONFIG_MCD_PORT);
     }
@@ -731,6 +876,18 @@ Server::~Server() {
         return;
     }
 
+    if (this->instance) {
+        unsigned ii;
+        mc_CMDQUEUE *cmdq = &this->instance->cmdq;
+        for (ii = 0; ii < cmdq->npipelines; ii++) {
+            lcb::Server *server = static_cast<lcb::Server*>(cmdq->pipelines[ii]);
+            if (server == this) {
+                cmdq->pipelines[ii] = NULL;
+                break;
+            }
+        }
+    }
+    this->instance = NULL;
     mcreq_pipeline_cleanup(this);
 
     if (io_timer) {