libcouchbase 0.2.0 → 0.3.1

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

@@ -23,16 +23,7 @@
 #include "settings.h"
 #include "hostlist.h"
 #ifdef __cplusplus
-namespace lcb {
-namespace io {
-struct Connstart;
-}
-}
-typedef lcb::io::Connstart* lcbio_pCONNSTART;
 extern "C" {
-#else
-struct lcbio_CONNSTART;
-typedef struct lcbio_CONNSTART* lcbio_pCONNSTART;
 #endif
 
 /**
@@ -48,9 +39,11 @@ typedef struct lcbio_CONNSTART* lcbio_pCONNSTART;
  * @{
  */
 
+struct lcbio_CONNSTART;
 struct lcbio_MGRREQ;
 
 /** @brief Pending connection request */
+typedef struct lcbio_CONNSTART *lcbio_pCONNSTART;
 typedef struct lcbio_MGRREQ *lcbio_pMGRREQ;
 typedef struct lcbio_TABLE *lcbio_pTABLE;
 typedef struct lcbio_TIMER *lcbio_pTIMER, *lcbio_pASYNC;

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

@@ -148,7 +148,7 @@ lcbio_ctx_close_ex(lcbio_CTX *ctx, lcbio_CTXCLOSE_cb cb, void *arg,
     }
 
     oldrc = ctx->sock->refcount;
-    lcb_log(LOGARGS(ctx, DEBUG), CTX_LOGFMT "Destroying context. Pending Writes=%d, Entered=%s, Socket Refcount=%d", CTX_LOGID(ctx), (int)ctx->npending, (int)ctx->entered ? "true": "false", oldrc);
+    lcb_log(LOGARGS(ctx, DEBUG), CTX_LOGFMT "Destroying. PND=%d,ENT=%d,SORC=%d", CTX_LOGID(ctx), (int)ctx->npending, (int)ctx->entered, oldrc);
 
     if (cb) {
         int reusable =

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

@@ -37,6 +37,22 @@
 extern "C" {
 #endif
 
+typedef struct lcbio_TABLE {
+    lcb_io_opt_t p;
+    lcb_iomodel_t model;
+    lcb_timer_procs timer;
+    lcb_loop_procs loop;
+
+    union {
+        struct {
+            lcb_ev_procs ev;
+            lcb_bsd_procs io;
+        } v0;
+        lcb_completion_procs completion;
+    } u_io;
+    unsigned refcount;
+    void (*dtor)(void *);
+} lcbio_TABLE;
 
 /** Whether the underlying model is event-based */
 #define IOT_IS_EVENT(iot) ((iot)->model == LCB_IOMODEL_EVENT)
@@ -62,67 +78,6 @@ extern "C" {
 /** First argument to IO Table */
 #define IOT_ARG(iot) (iot)->p
 
-typedef struct lcbio_TABLE {
-    lcb_io_opt_t p;
-    lcb_iomodel_t model;
-    lcb_timer_procs timer;
-    lcb_loop_procs loop;
-
-    union {
-        struct {
-            lcb_ev_procs ev;
-            lcb_bsd_procs io;
-        } v0;
-        lcb_completion_procs completion;
-    } u_io;
-    unsigned refcount;
-    void (*dtor)(void *);
-
-#ifdef __cplusplus
-    bool is_E() const { return IOT_IS_EVENT(this); }
-    bool is_C() const { return !is_E(); }
-    int get_errno() const { return IOT_ERRNO(this); }
-
-    void run_loop() { IOT_START(this); }
-    void stop_loop() { IOT_STOP(this); }
-
-    int E_connect(lcb_socket_t sock, const sockaddr* saddr, unsigned addrlen) {
-       return IOT_V0IO(this).connect0(p, sock, saddr, addrlen);
-    }
-
-    void E_close(lcb_socket_t sock) {
-        IOT_V0IO(this).close(p, sock);
-    }
-
-    void *E_event_create() {
-        return IOT_V0EV(this).create(p);
-    }
-
-    void E_event_watch(lcb_socket_t fd, void *event, short mask, void *arg,
-                       lcb_ioE_callback cb) {
-        IOT_V0EV(this).watch(p, fd, event, mask, arg, cb);
-    }
-
-     void E_event_destroy(void *event) {
-         IOT_V0EV(this).destroy(p, event);
-     }
-
-    void E_event_cancel(lcb_socket_t fd, void *event) {
-        IOT_V0EV(this).cancel(p, fd, event);
-    }
-
-    void C_close(lcb_sockdata_t *sd) {
-        IOT_V1(this).close(p, sd);
-    }
-
-    int C_connect(lcb_sockdata_t *sd, const sockaddr *addr, unsigned addrlen,
-                  lcb_io_connect_cb callback) {
-        return IOT_V1(this).connect(p, sd, addr, addrlen, callback);
-    }
-#endif
-
-} lcbio_TABLE;
-
 #ifdef __cplusplus
 }
 #endif

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

@@ -142,7 +142,7 @@ typedef struct {
     #define LCBIO_CONNREQ_POOLED 2
     #define LCBIO_CONNREQ_GENERIC 3
     union {
-        lcbio_pCONNSTART cs; /**< from lcbio_connect() */
+        struct lcbio_CONNSTART *cs; /**< from lcbio_connect() */
         struct lcbio_MGRREQ *preq; /**< from lcbio_mgr_get() */
         void *p_generic; /**< Generic pointer. Destroyed via the dtor field */
     } u;

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

@@ -314,11 +314,11 @@ start_new_connection(mgr_HOST *he, uint32_t tmo)
 
     err = lcb_host_parsez(&tmphost, he->key, 80);
     if (err != LCB_SUCCESS) {
-        lcb_log(LOGARGS(he->parent, ERROR), HE_LOGFMT "Could not parse host! Will supply dummy host (I=%p)", HE_LOGID(he), (void*)info);
+        lcb_log(LOGARGS(he->parent, ERROR), HE_LOGFMT "Could not parse host! Will supply dummy host", HE_LOGID(he));
         strcpy(tmphost.host, "BADHOST");
         strcpy(tmphost.port, "BADPORT");
     }
-    lcb_log(LOGARGS(he->parent, TRACE), HE_LOGFMT "New pool entry: I=%p", HE_LOGID(he), (void*)info);
+    lcb_log(LOGARGS(he->parent, DEBUG), HE_LOGFMT "Starting connection on I=%p", HE_LOGID(he), (void*)info);
 
     info->cs = lcbio_connect(he->parent->io, he->parent->settings, &tmphost,
                              tmo, on_connected, info);

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

@@ -179,17 +179,10 @@ typedef struct {
  * packets, or when the packet itself is generated internally rather than
  * on behalf of an API request.
  */
-typedef struct mc_REQDATAEX {
+typedef struct {
     const void *cookie; /**< User data */
     hrtime_t start; /**< Start time */
-    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_REQDATAPROCS *procs; /**< Common routines for the packet */
 } mc_REQDATAEX;
 
 /**

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

@@ -29,8 +29,6 @@
 #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)
@@ -99,7 +97,7 @@ void
 lcb_sched_flush(lcb_t instance)
 {
     for (size_t ii = 0; ii < LCBT_NSERVERS(instance); ii++) {
-        Server *server = instance->get_server(ii);
+        Server *server = LCBT_GET_SERVER(instance, ii);
 
         if (!server->has_pending()) {
             continue;
@@ -122,8 +120,8 @@ Server::handle_nmv(MemcachedResponse& resinfo, mc_PACKET *oldpkt)
     protocol_binary_request_header hdr;
     lcb_error_t err = LCB_ERROR;
     lcb_U16 vbid;
-    lcb::clconfig::Provider *cccp =
-            instance->confmon->get_provider(lcb::clconfig::CLCONFIG_CCCP);
+    clconfig_provider *cccp = lcb_confmon_get_provider(instance->confmon,
+        LCB_CLCONFIG_CCCP);
 
     mcreq_read_hdr(oldpkt, &hdr);
     vbid = ntohs(hdr.request.vbucket);
@@ -134,12 +132,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::clconfig::cccp_update(cccp, curhost->host, s.c_str());
+        err = lcb_cccp_update(cccp, curhost->host, s.c_str());
     }
 
     if (err != LCB_SUCCESS) {
         int bs_options;
-        if (instance->cur_configinfo->get_origin() == lcb::clconfig::CLCONFIG_CCCP) {
+        if (instance->cur_configinfo->origin == LCB_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
@@ -148,11 +146,11 @@ Server::handle_nmv(MemcachedResponse& resinfo, mc_PACKET *oldpkt)
              *
              * For this reason, we don't use if (cccp->enabled) {...}
              */
-            bs_options = BS_REFRESH_THROTTLE;
+            bs_options = LCB_BS_REFRESH_THROTTLE;
         } else {
-            bs_options = BS_REFRESH_ALWAYS;
+            bs_options = LCB_BS_REFRESH_ALWAYS;
         }
-        instance->bootstrap(bs_options);
+        lcb_bootstrap_common(instance, bs_options);
     }
 
     if (!lcb_should_retry(settings, oldpkt, LCB_NOT_MY_VBUCKET)) {
@@ -166,107 +164,6 @@ 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:
-        return true;
-    default:
-        if (rc >= 0xc0 && rc <= 0xcc) {
-            // other subdoc?
-            return true;
-        } else {
-            return false;
-        }
-        break;
-    }
-}
-
-/**
- * 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.
- */
-bool Server::handle_unknown_error(const MemcachedResponse& mcresp,
-                                  lcb_error_t& newerr) {
-
-    if (!settings->errmap->isLoaded() || !settings->use_errmap) {
-        // If there's no error map, just return false
-        return false;
-    }
-
-    // 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 true;
-    } 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;
-    }
-
-    if (err.hasAttribute(errmap::CONN_STATE_INVALIDATED)) {
-        if (newerr != LCB_SUCCESS) {
-            newerr = LCB_ERROR;
-        }
-        lcbio_ctx_senderr(connctx, newerr);
-        return true;
-    }
-
-    return false;
-
-}
-
 /* 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
@@ -322,19 +219,12 @@ Server::try_read(lcbio_CTX *ctx, rdb_IOROPE *ior)
     }
 
     if (!request) {
-        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(WARN), LOGFMT "Found stale packet (OP=0x%x, RC=0x%x, SEQ=%u)", LOGID_T(), mcresp.opcode(), mcresp.status(), mcresp.opaque());
         rdb_consumed(ior, pktsize);
         return PKT_READ_COMPLETE;
     }
 
-    lcb_error_t err_override = LCB_SUCCESS;
-    ReadState rdstate = PKT_READ_COMPLETE;
-
-    /* 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) {
+    if (mcresp.status() == PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET) {
         /* consume the header */
         DO_ASSIGN_PAYLOAD()
         if (!handle_nmv(mcresp, request)) {
@@ -342,19 +232,13 @@ Server::try_read(lcbio_CTX *ctx, rdb_IOROPE *ior)
         }
         DO_SWALLOW_PAYLOAD()
         goto GT_DONE;
-    } else if (handle_unknown_error(mcresp, err_override)) {
-        DO_ASSIGN_PAYLOAD()
-        mcreq_dispatch_response(this, request, &mcresp, err_override);
-        DO_SWALLOW_PAYLOAD()
-        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, err_override);
+        mcreq_dispatch_response(this, request, &mcresp, LCB_SUCCESS);
         DO_SWALLOW_PAYLOAD()
 
     } else {
@@ -381,7 +265,7 @@ Server::try_read(lcbio_CTX *ctx, rdb_IOROPE *ior)
     if (is_last) {
         mcreq_packet_handled(this, request);
     }
-    return rdstate;
+    return PKT_READ_COMPLETE;
 }
 
 static void
@@ -456,7 +340,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 %s", LOGID_T(), (void*)pkt, (unsigned long)pkt->opaque, hdr.request.opcode, lcb_strerror_short(err));
+    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);
     int rv = mcreq_dispatch_response(this, pkt, &resp, err);
     lcb_assert(rv == 0);
 }
@@ -481,7 +365,8 @@ Server::purge(lcb_error_t error, hrtime_t thresh, hrtime_t *next,
     }
 
     if (affected || policy == REFRESH_ALWAYS) {
-        instance->bootstrap(BS_REFRESH_THROTTLE|BS_REFRESH_INCRERR);
+        lcb_bootstrap_common(instance,
+            LCB_BS_REFRESH_THROTTLE|LCB_BS_REFRESH_INCRERR);
     }
     return affected;
 }
@@ -535,7 +420,7 @@ void Server::io_timeout()
     }
 
     uint32_t next_us = next_timeout();
-    lcb_log(LOGARGS_T(TRACE), LOGFMT "Scheduling next timeout for %u ms. This is not an error", LOGID_T(), next_us / 1000);
+    lcb_log(LOGARGS_T(DEBUG), LOGFMT "Scheduling next timeout for %u ms", LOGID_T(), next_us / 1000);
     lcbio_timer_rearm(io_timer, next_us);
     lcb_maybe_breakout(instance);
 }
@@ -580,7 +465,7 @@ Server::handle_connected(lcbio_SOCKET *sock, lcb_error_t err, lcbio_OSERR syserr
     LCBIO_CONNREQ_CLEAR(&connreq);
 
     if (err != LCB_SUCCESS) {
-        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);
+        lcb_log(LOGARGS_T(ERR), LOGFMT "Got error for connection! (OS=%d)", LOGID_T(), syserr);
         if (!maybe_reconnect_on_fake_timeout(err)) {
             socket_failed(err);
         }
@@ -609,9 +494,10 @@ 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";
-    flush_start = (mcreq_flushstart_fn)mcserver_flush;
+    mc_PIPELINE::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();
 }
@@ -622,7 +508,7 @@ Server::connect()
     lcbio_pMGRREQ mr = lcbio_mgr_get(instance->memd_sockpool, curhost,
         default_timeout(), on_connected, this);
     LCBIO_CONNREQ_MKPOOLED(&connreq, mr);
-    flush_start = flush_noop;
+    mc_PIPELINE::flush_start = flush_noop;
     state = Server::S_CLEAN;
 }
 
@@ -634,7 +520,7 @@ buf_done_cb(mc_PIPELINE *pl, const void *cookie, void *, void *)
 }
 
 Server::Server(lcb_t instance_, int ix)
-    : mc_PIPELINE(), state(S_CLEAN),
+    : state(S_CLEAN),
       io_timer(lcbio_timer_new(instance_->iotable, this, timeout_server)),
       instance(instance_),
       settings(lcb_settings_ref2(instance_->settings)),
@@ -643,10 +529,11 @@ 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);
-    flush_start = (mcreq_flushstart_fn)server_connect;
-    buf_done_callback = buf_done_cb;
-    index = ix;
+    mc_PIPELINE::flush_start = (mcreq_flushstart_fn)server_connect;
+    mc_PIPELINE::buf_done_callback = buf_done_cb;
+    mc_PIPELINE::index = ix;
 
     std::memset(&connreq, 0, sizeof connreq);
     std::memset(curhost, 0, sizeof *curhost);
@@ -693,7 +580,7 @@ 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 %s", LOGID(server), lcb_strerror_short(err));
+    lcb_log(LOGARGS(server, WARN), LOGFMT "Got socket error 0x%x", LOGID(server), err);
     if (server->check_closed()) {
         return;
     }
@@ -749,15 +636,13 @@ 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;
             }
         }
 
@@ -771,7 +656,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) {
-                flush_start = (mcreq_flushstart_fn)flush_errdrain;
+                mc_PIPELINE::flush_start = (mcreq_flushstart_fn)flush_errdrain;
             }
         } else {
             finalize_errored_ctx();
@@ -816,6 +701,7 @@ 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();
     }
 }
@@ -837,3 +723,8 @@ Server::check_closed()
     finalize_errored_ctx();
     return 1;
 }
+
+int
+mcserver_supports_compression(mc_SERVER *server) {
+    return server->compsupport;
+}