libcouchbase 0.3.3 → 1.0.0

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

@@ -19,8 +19,8 @@
 #define LCBIO_MANAGER_H
 #include "connect.h"
 #include "settings.h"
-#include "contrib/genhash/genhash.h"
 #include "list.h"
+#include "ioutils.h"
 #include <stdio.h>
 
 
@@ -42,114 +42,151 @@
  */
 
 #ifdef __cplusplus
-extern "C" {
-#endif
+#include <map>
 
-/** Cancellable pool request */
-struct lcbio_MGRREQ;
+namespace lcb {
+namespace io {
 
 /** @brief Socket Pool */
-typedef struct lcbio_MGR {
-    genhash_t* ht;
-    lcb_settings *settings;
-    lcbio_pTABLE io;
+class Pool;
 
-    /**
-     * Maximum number of microseconds for a connection to idle inside the pool
-     * before being closed
-     */
-    uint32_t tmoidle;
-    unsigned maxtotal;
-    unsigned maxidle; /**< Maximum number of idle connections, per host */
-    unsigned refcount;
-} lcbio_MGR;
+/** @brief Pooled connection */
+struct PoolConnInfo;
 
-/**
- * Create a socket pool controlled by the given settings and IO structure.
- * This function will increment the refcount on both the settings and table
- * objects.
- */
-LCB_INTERNAL_API
-lcbio_MGR*
-lcbio_mgr_create(lcb_settings *settings, lcbio_pTABLE io);
+/** @brief Cancellable pool request */
+struct PoolRequest;
 
-/**
- * Destroy the socket pool. Note that internally this just decrements the
- * reference count. The object is only destroyed when its count hits zero.
- */
-LCB_INTERNAL_API
-void
-lcbio_mgr_destroy(lcbio_MGR *);
+struct PoolHost;
+}
+}
 
-/**
- * Request a connection from the socket pool. The semantics and prototype
- * of this function are by design similar to lcbio_connect() as they do the
- * same things.
- *
- * @param mgr
- * @param dest the host to connect to
- * @param timeout amount of time to wait for a connection to be estblished
- * @param handler a callback to invoke when the result is ready
- * @param arg an argument passed to the callback
- * @return a request handle which may be cancelled
- * @see lcbio_connect()
- */
-LCB_INTERNAL_API
-struct lcbio_MGRREQ *
-lcbio_mgr_get(lcbio_MGR *mgr, lcb_host_t *dest, uint32_t timeout,
-              lcbio_CONNDONE_cb handler, void *arg);
+typedef lcb::io::Pool lcbio_MGR;
+extern "C" {
 
-/**
- * Cancel a pending request. The callback for the request must have not already
- * been invoked (if it has, use sockpool_put)
- * @param req the request to cancel
- */
-LCB_INTERNAL_API
-void
-lcbio_mgr_cancel(struct lcbio_MGRREQ *req);
+#else
+/* C only */
+typedef struct lcbio_MGR_CDUMMY lcbio_MGR;
+#endif
 
-/**
- * Release a socket back into the pool. This means the socket is no longer
- * used and shall be available for reuse for another request. To verify these
- * constraints, the socket's reference count must be one. Once the socket
- * has been released its reference count should not be modified.
- */
-LCB_INTERNAL_API
-void lcbio_mgr_put(lcbio_SOCKET *sock);
+#ifdef __cplusplus
+}
 
-/**
- * Mark a slot as available but discard the current connection. This should be
- * done if the connection itself is "dirty", i.e. has a protocol error on it
- * or is otherwise not suitable for reuse
- */
-LCB_INTERNAL_API
-void lcbio_mgr_discard(lcbio_SOCKET *sock);
+namespace lcb {
+namespace io {
+class Pool {
+public:
+    /**
+     * Create a socket pool controlled by the given settings and IO structure.
+     * This function will increment the refcount on both the settings and table
+     * objects.
+     */
+    Pool(lcb_settings*, lcbio_pTABLE);
 
-/**
- * Like lcbio_mgr_discard() except the source connection is left untouched. It
- * is removed from the pool instead.
- *
- * Because the lcbio_MGR object itself has internal limits and thresholds on how
- * many leased and/or open connections it can contain, when a connection receives
- * an error it must either be discarded back to the pool (in which case the
- * connection is cleaned up and is freed) or it must be detached (in which case
- * the connection object itself still remains valid, but the pool does not know
- * about it, and all its counters are restored, as with lcbio_mgr_discard()).
- *
- * lcbio_mgr_discard() itself is now implemented as the equivalent to:
- *  `lcbio_mgr_detach(mgr, conn)`;
- */
-LCB_INTERNAL_API
-void lcbio_mgr_detach(lcbio_SOCKET *sock);
+    /**
+     * Destroy the socket pool. Note that internally this just decrements the
+     * reference count. The object is only destroyed when its count hits zero.
+     */
+    void shutdown();
 
-/**
- * Dumps the connection manager state to stderr
- */
-LCB_INTERNAL_API
-void lcbio_mgr_dump(lcbio_MGR *mgr, FILE *out);
+    /**
+     * Request a connection from the socket pool. The semantics and prototype
+     * of this function are by design similar to lcbio_connect() as they do the
+     * same things.
+     *
+     * @param dest the host to connect to
+     * @param timeout amount of time to wait for a connection to be estblished
+     * @param handler a callback to invoke when the result is ready
+     * @param arg an argument passed to the callback
+     * @return a request handle which may be cancelled
+     * @see lcbio_connect()
+     */
+    ConnectionRequest* get(const lcb_host_t&, uint32_t, lcbio_CONNDONE_cb, void *);
 
-#ifdef __cplusplus
-}
+    /**
+     * Release a socket back into the pool. This means the socket is no longer
+     * used and shall be available for reuse for another request. To verify these
+     * constraints, the socket's reference count must be one. Once the socket
+     * has been released its reference count should not be modified.
+     */
+    static void put(lcbio_SOCKET *sock);
+
+    /**
+     * Mark a slot as available but discard the current connection. This should be
+     * done if the connection itself is "dirty", i.e. has a protocol error on it
+     * or is otherwise not suitable for reuse
+     */
+    static void discard(lcbio_SOCKET *sock);
+
+    /**
+     * Like lcbio_mgr_discard() except the source connection is left untouched. It
+     * is removed from the pool instead.
+     *
+     * Because the lcbio_MGR object itself has internal limits and thresholds on how
+     * many leased and/or open connections it can contain, when a connection receives
+     * an error it must either be discarded back to the pool (in which case the
+     * connection is cleaned up and is freed) or it must be detached (in which case
+     * the connection object itself still remains valid, but the pool does not know
+     * about it, and all its counters are restored, as with lcbio_mgr_discard()).
+     *
+     * lcbio_mgr_discard() itself is now implemented as the equivalent to:
+     *  `lcbio_mgr_detach(mgr, conn)`;
+     */
+    static void detach(lcbio_SOCKET *sock);
+
+    static bool is_from_pool(const lcbio_SOCKET *sock);
+
+    /**
+     * Dumps the connection manager state to stderr
+     */
+    void dump(FILE *) const;
+
+    inline void ref();
+    inline void unref();
+
+    struct Options {
+        Options() : maxtotal(0), maxidle(0), tmoidle(0) {
+        }
+
+        /** Maximum *total* number of connections opened by the pool. If this
+         * number is exceeded, the pool will black hole future requests until
+         * a new slot becomes available.
+         */
+        unsigned maxtotal;
+
+        /**
+         * Maximum number of idle connections to keep around
+         */
+        unsigned maxidle;
+
+        /**
+         * The amount of time the pool should wait before closing idle
+         * connections. In microseconds
+         */
+        uint32_t tmoidle;
+    };
+
+    void set_options(const Options& opts) {
+        options = opts;
+    }
+
+    Options& get_options() {
+        return options;
+    }
+
+private:
+    friend struct PoolRequest;
+    friend struct PoolConnInfo;
+    friend struct PoolHost;
+
+    typedef std::map<std::string, PoolHost*> HostMap;
+    HostMap ht;
+    lcb_settings *settings;
+    lcbio_pTABLE io;
+    Options options;
+    unsigned refcount;
+};
+} // namespace io
+} // namespace lcb
 #endif
 /**@}*/
 

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

@@ -24,9 +24,9 @@ lcbio_protoctx_add(lcbio_SOCKET *sock, lcbio_PROTOCTX *ctx)
 }
 
 lcbio_PROTOCTX *
-lcbio_protoctx_get(lcbio_SOCKET *sock, lcbio_PROTOID id)
+lcbio_protoctx_get(const lcbio_SOCKET *sock, lcbio_PROTOID id)
 {
-    lcb_list_t *ll;
+    const lcb_list_t *ll;
     LCB_LIST_FOR(ll, &sock->protos) {
         lcbio_PROTOCTX *cur = LCB_LIST_ITEM(ll, lcbio_PROTOCTX, ll);
         if (cur->id == id) {

data/ext/libcouchbase/src/lcbio/timer-cxx.h

@@ -0,0 +1,87 @@
+/*
+ *     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.
+ */
+
+#ifndef LCBIO_TIMER_CXX
+#define LCBIO_TIMER_CXX
+
+#include <lcbio/timer-ng.h>
+#include <cstdlib>
+
+namespace lcb {
+namespace io {
+
+class SimpleTimer {
+public:
+    typedef void (Callback)(void*);
+    SimpleTimer(lcbio_pTABLE iot, void *data, Callback cb)
+        : inner(lcbio_timer_new(iot, data, cb)) {
+    }
+    ~SimpleTimer() {
+        release();
+    }
+    void release() {
+        if (inner != NULL) {
+            lcbio_timer_destroy(inner);
+            inner = NULL;
+        }
+    }
+    void signal() {
+        lcbio_async_signal(inner);
+    }
+    void cancel() {
+        lcbio_timer_disarm(inner);
+    }
+    bool is_armed() const {
+        return lcbio_timer_armed(inner);
+    }
+    void rearm(uint32_t usec) {
+        lcbio_timer_rearm(inner, usec);
+    }
+    void arm_if_disarmed(uint32_t usec) {
+        if (!is_armed()) {
+            rearm(usec);
+        }
+    }
+    void dump(FILE *fp) const {
+        lcbio_timer_dump(inner, fp);
+    }
+private:
+    lcbio_pTIMER inner;
+    SimpleTimer(const SimpleTimer&);
+};
+
+template <typename T, void (T::*M)(void)>
+class Timer : public SimpleTimer {
+public:
+    Timer(lcbio_pTABLE iot, T* ptr)
+        : SimpleTimer(iot, ptr, cb) {
+    }
+
+    ~Timer() {
+        release();
+    }
+
+private:
+    static void cb(void *arg) {
+        T *obj = reinterpret_cast<T*>(arg);
+        (obj->*M)();
+    }
+    Timer(const Timer&);
+};
+
+}
+}
+#endif

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

@@ -543,6 +543,15 @@ int
 mcreq_pipeline_init(mc_PIPELINE *pipeline)
 {
     nb_SETTINGS settings;
+
+    /* Initialize all members to 0 */
+    memset(&pipeline->requests, 0, sizeof pipeline->requests);
+    pipeline->parent = NULL;
+    pipeline->flush_start = NULL;
+    pipeline->index = 0;
+    memset(&pipeline->ctxqueued, 0, sizeof pipeline->ctxqueued);
+    pipeline->buf_done_callback = NULL;
+
     netbuf_default_settings(&settings);
 
     /** Initialize datapool */
@@ -550,7 +559,7 @@ mcreq_pipeline_init(mc_PIPELINE *pipeline)
 
     /** Initialize request pool */
     settings.data_basealloc = sizeof(mc_PACKET) * 32;
-    netbuf_init(&pipeline->reqpool, &settings);
+    netbuf_init(&pipeline->reqpool, &settings);;
     return 0;
 }
 
@@ -911,7 +920,7 @@ mcreq_dump_packet(const mc_PACKET *packet, FILE *fp, mcreq_payload_dump_fn dumpf
                 fprintf(fp, "%sValue is user allocated\n", indent);
             }
             fprintf(fp, "%sValue: %p, %u bytes\n", indent,
-                SPAN_BUFFER(&packet->u_value.single), packet->u_value.single.size);
+                (void *)SPAN_BUFFER(&packet->u_value.single), packet->u_value.single.size);
         }
     }
 

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

@@ -179,10 +179,17 @@ typedef struct {
  * packets, or when the packet itself is generated internally rather than
  * on behalf of an API request.
  */
-typedef struct {
+typedef struct mc_REQDATAEX {
     const void *cookie; /**< User data */
     hrtime_t start; /**< Start time */
-    mc_REQDATAPROCS *procs; /**< Common routines for the packet */
+    const mc_REQDATAPROCS *procs; /**< Common routines for the packet */
+
+    #ifdef __cplusplus
+    mc_REQDATAEX(const void *cookie_,
+                const mc_REQDATAPROCS &procs_, hrtime_t start_)
+        : cookie(cookie_), start(start_), procs(&procs_) {
+    }
+    #endif
 } mc_REQDATAEX;
 
 /**

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

@@ -29,6 +29,8 @@
 #define LOGARGS_T(lvl) LOGARGS(this, lvl)
 
 #define LOGFMT "<%s:%s> (SRV=%p,IX=%d) "
+#define PKTFMT "OP=0x%x, RC=0x%x, SEQ=%u"
+#define PKTARGS(pkt) (pkt).opcode(), (pkt).status(), (pkt).opaque()
 
 #define LOGID(server) get_ctx_host(server->connctx), get_ctx_port(server->connctx), (void*)server, server->index
 #define LOGID_T() LOGID(this)
@@ -97,7 +99,7 @@ void
 lcb_sched_flush(lcb_t instance)
 {
     for (size_t ii = 0; ii < LCBT_NSERVERS(instance); ii++) {
-        Server *server = LCBT_GET_SERVER(instance, ii);
+        Server *server = instance->get_server(ii);
 
         if (!server->has_pending()) {
             continue;
@@ -120,8 +122,8 @@ Server::handle_nmv(MemcachedResponse& resinfo, mc_PACKET *oldpkt)
     protocol_binary_request_header hdr;
     lcb_error_t err = LCB_ERROR;
     lcb_U16 vbid;
-    clconfig_provider *cccp = lcb_confmon_get_provider(instance->confmon,
-        LCB_CLCONFIG_CCCP);
+    lcb::clconfig::Provider *cccp =
+            instance->confmon->get_provider(lcb::clconfig::CLCONFIG_CCCP);
 
     mcreq_read_hdr(oldpkt, &hdr);
     vbid = ntohs(hdr.request.vbucket);
@@ -132,12 +134,12 @@ Server::handle_nmv(MemcachedResponse& resinfo, mc_PACKET *oldpkt)
 
     if (resinfo.bodylen() && cccp->enabled) {
         std::string s(resinfo.body<const char*>(), resinfo.vallen());
-        err = lcb_cccp_update(cccp, curhost->host, s.c_str());
+        err = lcb::clconfig::cccp_update(cccp, curhost->host, s.c_str());
     }
 
     if (err != LCB_SUCCESS) {
         int bs_options;
-        if (instance->cur_configinfo->origin == LCB_CLCONFIG_CCCP) {
+        if (instance->cur_configinfo->get_origin() == lcb::clconfig::CLCONFIG_CCCP) {
             /**
              * XXX: Not enough to see if cccp was enabled, since cccp might
              * be requested by a user, but would still not actually be active
@@ -146,11 +148,11 @@ Server::handle_nmv(MemcachedResponse& resinfo, mc_PACKET *oldpkt)
              *
              * For this reason, we don't use if (cccp->enabled) {...}
              */
-            bs_options = LCB_BS_REFRESH_THROTTLE;
+            bs_options = BS_REFRESH_THROTTLE;
         } else {
-            bs_options = LCB_BS_REFRESH_ALWAYS;
+            bs_options = BS_REFRESH_ALWAYS;
         }
-        lcb_bootstrap_common(instance, bs_options);
+        instance->bootstrap(bs_options);
     }
 
     if (!lcb_should_retry(settings, oldpkt, LCB_NOT_MY_VBUCKET)) {
@@ -164,6 +166,124 @@ Server::handle_nmv(MemcachedResponse& resinfo, mc_PACKET *oldpkt)
     return true;
 }
 
+/**
+ * Determine if this is an error code that we can pass to the user, or can
+ * otherwise handle "innately"
+ */
+static bool is_fastpath_error(uint16_t rc) {
+    switch (rc) {
+    case PROTOCOL_BINARY_RESPONSE_SUCCESS:
+    case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT:
+    case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS:
+    case PROTOCOL_BINARY_RESPONSE_E2BIG:
+    case PROTOCOL_BINARY_RESPONSE_NOT_STORED:
+    case PROTOCOL_BINARY_RESPONSE_DELTA_BADVAL:
+    case PROTOCOL_BINARY_RESPONSE_ERANGE:
+    case PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED:
+    case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND:
+    case PROTOCOL_BINARY_RESPONSE_ETMPFAIL:
+    case PROTOCOL_BINARY_RESPONSE_ENOMEM:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_ENOENT:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_EEXISTS:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_MISMATCH:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_EINVAL:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_E2BIG:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_VALUE_CANTINSERT:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_VALUE_ETOODEEP:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_DOC_NOTJSON:
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_NUM_ERANGE:
+    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_EACCESS:
+        return true;
+    default:
+        if (rc >= 0xc0 && rc <= 0xcc) {
+            // other subdoc?
+            return true;
+        } else {
+            return false;
+        }
+        break;
+    }
+}
+
+#define ERRMAP_HANDLE_CONTINUE 0
+#define ERRMAP_HANDLE_DISCONN 1
+#define ERRMAP_HANDLE_RETRY 2
+
+/**
+ * Handle an unknown memcached error
+ *
+ * @param mcresp Response which contains the unknown error
+ * @param[out] newerr more user-friendly based on error map attributes
+ *
+ * @return true if this function handled the error specially (by disconnecting)
+ * or false if normal handling should continue.
+ */
+int Server::handle_unknown_error(const mc_PACKET *request,
+                                 const MemcachedResponse& mcresp,
+                                 lcb_error_t& newerr) {
+
+    if (!settings->errmap->isLoaded() || !settings->use_errmap) {
+        // If there's no error map, just return false
+        return ERRMAP_HANDLE_CONTINUE;
+    }
+
+    // Look up the error map definition for this error
+    const errmap::Error& err = settings->errmap->getError(mcresp.status());
+
+    if (!err.isValid() || err.hasAttribute(errmap::SPECIAL_HANDLING)) {
+        lcb_log(LOGARGS_T(ERR), LOGFMT "Received error not in error map or requires special handling! " PKTFMT, LOGID_T(), PKTARGS(mcresp));
+        lcbio_ctx_senderr(connctx, LCB_PROTOCOL_ERROR);
+        return ERRMAP_HANDLE_DISCONN;
+    } else {
+        lcb_log(LOGARGS_T(WARN), LOGFMT "Received server error %s (0x%x) on packet: " PKTFMT, LOGID_T(), err.shortname.c_str(), err.code, PKTARGS(mcresp));
+    }
+
+    if (err.hasAttribute(errmap::FETCH_CONFIG)) {
+        instance->bootstrap(BS_REFRESH_THROTTLE);
+    }
+
+    if (err.hasAttribute(errmap::TEMPORARY)) {
+        newerr = LCB_GENERIC_TMPERR;
+    }
+
+    if (err.hasAttribute(errmap::CONSTRAINT_FAILURE)) {
+        newerr = LCB_GENERIC_CONSTRAINT_ERR;
+    }
+
+    if (err.hasAttribute(errmap::AUTH)) {
+        newerr = LCB_AUTH_ERROR;
+    }
+
+    if (err.hasAttribute(errmap::SUBDOC) && newerr == LCB_SUCCESS) {
+        newerr = LCB_GENERIC_SUBDOCERR;
+    }
+
+    int rv = 0;
+
+    if (err.hasAttribute(errmap::AUTO_RETRY)) {
+        errmap::RetrySpec *spec = err.getRetrySpec();
+
+        mc_PACKET *newpkt = mcreq_renew_packet(request);
+        newpkt->flags &= ~MCREQ_STATE_FLAGS;
+        instance->retryq->add((mc_EXPACKET *)newpkt, newerr ? newerr : LCB_ERROR, spec);
+        rv |= ERRMAP_HANDLE_RETRY;
+    }
+
+    if (err.hasAttribute(errmap::CONN_STATE_INVALIDATED)) {
+        if (newerr != LCB_SUCCESS) {
+            newerr = LCB_ERROR;
+        }
+        lcbio_ctx_senderr(connctx, newerr);
+        rv |= ERRMAP_HANDLE_DISCONN;
+    }
+
+    return rv;
+
+}
+
 /* This function is called within a loop to process a single packet.
  *
  * If a full packet is available, it will process the packet and return
@@ -219,12 +339,20 @@ Server::try_read(lcbio_CTX *ctx, rdb_IOROPE *ior)
     }
 
     if (!request) {
-        lcb_log(LOGARGS_T(WARN), LOGFMT "Found stale packet (OP=0x%x, RC=0x%x, SEQ=%u)", LOGID_T(), mcresp.opcode(), mcresp.status(), mcresp.opaque());
+        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());
         rdb_consumed(ior, pktsize);
         return PKT_READ_COMPLETE;
     }
 
-    if (mcresp.status() == PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET) {
+    lcb_error_t err_override = LCB_SUCCESS;
+    ReadState rdstate = PKT_READ_COMPLETE;
+    int unknown_err_rv;
+
+    /* Check if the status code is one which must be handled carefully by the
+     * client */
+    if (is_fastpath_error(mcresp.status())) {
+        // Nothing here!
+    } else if (mcresp.status() == PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET) {
         /* consume the header */
         DO_ASSIGN_PAYLOAD()
         if (!handle_nmv(mcresp, request)) {
@@ -232,13 +360,25 @@ Server::try_read(lcbio_CTX *ctx, rdb_IOROPE *ior)
         }
         DO_SWALLOW_PAYLOAD()
         goto GT_DONE;
+    } else if ((unknown_err_rv =
+                handle_unknown_error(request, mcresp, err_override)) !=
+                        ERRMAP_HANDLE_CONTINUE) {
+        DO_ASSIGN_PAYLOAD()
+        if (!(unknown_err_rv & ERRMAP_HANDLE_RETRY)) {
+            mcreq_dispatch_response(this, request, &mcresp, err_override);
+        }
+        DO_SWALLOW_PAYLOAD()
+        if (unknown_err_rv & ERRMAP_HANDLE_DISCONN) {
+            rdstate = PKT_READ_ABORT;
+        }
+        goto GT_DONE;
     }
 
     /* Figure out if the request is 'ufwd' or not */
     if (!(request->flags & MCREQ_F_UFWD)) {
         DO_ASSIGN_PAYLOAD();
         mcresp.bufh = rdb_get_first_segment(ior);
-        mcreq_dispatch_response(this, request, &mcresp, LCB_SUCCESS);
+        mcreq_dispatch_response(this, request, &mcresp, err_override);
         DO_SWALLOW_PAYLOAD()
 
     } else {
@@ -265,7 +405,7 @@ Server::try_read(lcbio_CTX *ctx, rdb_IOROPE *ior)
     if (is_last) {
         mcreq_packet_handled(this, request);
     }
-    return PKT_READ_COMPLETE;
+    return rdstate;
 }
 
 static void
@@ -307,7 +447,8 @@ Server::maybe_retry_packet(mc_PACKET *pkt, lcb_error_t err)
 
     mc_PACKET *newpkt = mcreq_renew_packet(pkt);
     newpkt->flags &= ~MCREQ_STATE_FLAGS;
-    instance->retryq->add((mc_EXPACKET *)newpkt, err);
+    // TODO: Load the 4th argument from the error map
+    instance->retryq->add((mc_EXPACKET *)newpkt, err, NULL);
     return true;
 }
 
@@ -340,7 +481,7 @@ void Server::purge_single(mc_PACKET *pkt, lcb_error_t err) {
                            hdr.request.opaque,
                            PROTOCOL_BINARY_RESPONSE_EINVAL);
 
-    lcb_log(LOGARGS_T(WARN), LOGFMT "Failing command (pkt=%p, opaque=%lu, opcode=0x%x) with error 0x%x", LOGID_T(), (void*)pkt, (unsigned long)pkt->opaque, hdr.request.opcode, err);
+    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);
 }
@@ -365,8 +506,7 @@ Server::purge(lcb_error_t error, hrtime_t thresh, hrtime_t *next,
     }
 
     if (affected || policy == REFRESH_ALWAYS) {
-        lcb_bootstrap_common(instance,
-            LCB_BS_REFRESH_THROTTLE|LCB_BS_REFRESH_INCRERR);
+        instance->bootstrap(BS_REFRESH_THROTTLE|BS_REFRESH_INCRERR);
     }
     return affected;
 }
@@ -420,7 +560,7 @@ void Server::io_timeout()
     }
 
     uint32_t next_us = next_timeout();
-    lcb_log(LOGARGS_T(DEBUG), LOGFMT "Scheduling next timeout for %u ms", LOGID_T(), next_us / 1000);
+    lcb_log(LOGARGS_T(TRACE), LOGFMT "Scheduling next timeout for %u ms. This is not an error", LOGID_T(), next_us / 1000);
     lcbio_timer_rearm(io_timer, next_us);
     lcb_maybe_breakout(instance);
 }
@@ -462,10 +602,10 @@ static void mcserver_flush(Server *s) { s->flush(); }
 void
 Server::handle_connected(lcbio_SOCKET *sock, lcb_error_t err, lcbio_OSERR syserr)
 {
-    LCBIO_CONNREQ_CLEAR(&connreq);
+    connreq = NULL;
 
     if (err != LCB_SUCCESS) {
-        lcb_log(LOGARGS_T(ERR), LOGFMT "Got error for connection! (OS=%d)", LOGID_T(), syserr);
+        lcb_log(LOGARGS_T(ERR), LOGFMT "Connection attempt failed. Received %s from libcouchbase, received %d from operating system", LOGID_T(), lcb_strerror_short(err), syserr);
         if (!maybe_reconnect_on_fake_timeout(err)) {
             socket_failed(err);
         }
@@ -478,9 +618,8 @@ Server::handle_connected(lcbio_SOCKET *sock, lcb_error_t err, lcbio_OSERR syserr
     SessionInfo* sessinfo = SessionInfo::get(sock);
     if (sessinfo == NULL) {
         lcb_log(LOGARGS_T(TRACE), "<%s:%s> (SRV=%p) Session not yet negotiated. Negotiating", curhost->host, curhost->port, (void*)this);
-        SessionRequest *sreq = SessionRequest::start(
+        connreq = SessionRequest::start(
             sock, settings, default_timeout(), on_connected, this);
-        LCBIO_CONNREQ_MKGENERIC(&connreq, sreq, lcb::sessreq_cancel);
         return;
     } else {
         compsupport = sessinfo->has_feature(PROTOCOL_BINARY_FEATURE_DATATYPE);
@@ -494,10 +633,9 @@ Server::handle_connected(lcbio_SOCKET *sock, lcb_error_t err, lcbio_OSERR syserr
     procs.cb_flush_ready = on_flush_ready;
     connctx = lcbio_ctx_new(sock, this, &procs);
     connctx->subsys = "memcached";
-    mc_PIPELINE::flush_start = (mcreq_flushstart_fn)mcserver_flush;
+    flush_start = (mcreq_flushstart_fn)mcserver_flush;
 
     uint32_t tmo = next_timeout();
-    lcb_log(LOGARGS_T(DEBUG), LOGFMT "Setting initial timeout=%ums", LOGID_T(), tmo/1000);
     lcbio_timer_rearm(io_timer, tmo);
     flush();
 }
@@ -505,10 +643,9 @@ Server::handle_connected(lcbio_SOCKET *sock, lcb_error_t err, lcbio_OSERR syserr
 void
 Server::connect()
 {
-    lcbio_pMGRREQ mr = lcbio_mgr_get(instance->memd_sockpool, curhost,
+    connreq = instance->memd_sockpool->get(*curhost,
         default_timeout(), on_connected, this);
-    LCBIO_CONNREQ_MKPOOLED(&connreq, mr);
-    mc_PIPELINE::flush_start = flush_noop;
+    flush_start = flush_noop;
     state = Server::S_CLEAN;
 }
 
@@ -520,7 +657,7 @@ buf_done_cb(mc_PIPELINE *pl, const void *cookie, void *, void *)
 }
 
 Server::Server(lcb_t instance_, int ix)
-    : state(S_CLEAN),
+    : mc_PIPELINE(), state(S_CLEAN),
       io_timer(lcbio_timer_new(instance_->iotable, this, timeout_server)),
       instance(instance_),
       settings(lcb_settings_ref2(instance_->settings)),
@@ -529,11 +666,10 @@ Server::Server(lcb_t instance_, int ix)
       connctx(NULL),
       curhost(new lcb_host_t())
 {
-    std::memset(static_cast<mc_PIPELINE*>(this), 0, sizeof(mc_PIPELINE));
     mcreq_pipeline_init(this);
-    mc_PIPELINE::flush_start = (mcreq_flushstart_fn)server_connect;
-    mc_PIPELINE::buf_done_callback = buf_done_cb;
-    mc_PIPELINE::index = ix;
+    flush_start = (mcreq_flushstart_fn)server_connect;
+    buf_done_callback = buf_done_cb;
+    index = ix;
 
     std::memset(&connreq, 0, sizeof connreq);
     std::memset(curhost, 0, sizeof *curhost);
@@ -550,7 +686,7 @@ Server::Server(lcb_t instance_, int ix)
 Server::Server()
     : state(S_TEMPORARY),
       io_timer(NULL), instance(NULL), settings(NULL), compsupport(0),
-      mutation_tokens(0), connctx(NULL), curhost(NULL)
+      mutation_tokens(0), connctx(NULL), connreq(NULL), curhost(NULL)
 {
 }
 
@@ -573,14 +709,14 @@ static void
 close_cb(lcbio_SOCKET *sock, int, void *)
 {
     lcbio_ref(sock);
-    lcbio_mgr_discard(sock);
+    lcb::io::Pool::discard(sock);
 }
 
 static void
 on_error(lcbio_CTX *ctx, lcb_error_t err)
 {
     Server *server = Server::get(ctx);
-    lcb_log(LOGARGS(server, WARN), LOGFMT "Got socket error 0x%x", LOGID(server), err);
+    lcb_log(LOGARGS(server, WARN), LOGFMT "Got socket error %s", LOGID(server), lcb_strerror_short(err));
     if (server->check_closed()) {
         return;
     }
@@ -622,7 +758,7 @@ Server::start_errored_ctx(State next_state)
 
     state = next_state;
     /* Cancel any pending connection attempt? */
-    lcbio_connreq_cancel(&connreq);
+    lcb::io::ConnectionRequest::cancel(&connreq);
 
     /* If the server is being destroyed, silence the timer */
     if (next_state == Server::S_CLOSED && io_timer != NULL) {
@@ -636,13 +772,15 @@ Server::start_errored_ctx(State next_state)
             return;
         } else {
             /* Not closed but don't have a current context */
-            mc_PIPELINE::flush_start = (mcreq_flushstart_fn)server_connect;
             if (has_pending()) {
                 if (!lcbio_timer_armed(io_timer)) {
                     /* TODO: Maybe throttle reconnection attempts? */
                     lcbio_timer_rearm(io_timer, default_timeout());
                 }
                 connect();
+            } else {
+                // Connect once someone actually wants a connection.
+                flush_start = (mcreq_flushstart_fn)server_connect;
             }
         }
 
@@ -656,7 +794,7 @@ Server::start_errored_ctx(State next_state)
             /* Close the socket not to leak resources */
             lcbio_shutdown(lcbio_ctx_sock(ctx));
             if (next_state == Server::S_ERRDRAIN) {
-                mc_PIPELINE::flush_start = (mcreq_flushstart_fn)flush_errdrain;
+                flush_start = (mcreq_flushstart_fn)flush_errdrain;
             }
         } else {
             finalize_errored_ctx();
@@ -701,7 +839,6 @@ Server::finalize_errored_ctx()
         /* Otherwise, cycle the state back to CLEAN and reinit
          * the connection */
         state = Server::S_CLEAN;
-        mc_PIPELINE::flush_start = (mcreq_flushstart_fn)server_connect;
         connect();
     }
 }
@@ -723,8 +860,3 @@ Server::check_closed()
     finalize_errored_ctx();
     return 1;
 }
-
-int
-mcserver_supports_compression(mc_SERVER *server) {
-    return server->compsupport;
-}