libcouchbase 0.3.3 → 1.0.0

data/ext/libcouchbase/src/handler.cc

@@ -21,6 +21,8 @@
 #include "mc/compress.h"
 #include "trace.h"
 
+#define LOGARGS(obj, lvl) (obj)->settings, "handler", LCB_LOG_##lvl, __FILE__, __LINE__
+
 using lcb::MemcachedResponse;
 
 template <typename T>
@@ -28,12 +30,60 @@ class ResponsePack {
 public:
     T resp;
     lcb_MUTATION_TOKEN mt;
+    const char *value;
+    lcb_SIZE nvalue;
+    char *err_ref;
+    char *err_ctx;
+
+    ~ResponsePack() {
+        free(err_ref);
+        free(err_ctx);
+    }
 
     static const lcb_MUTATION_TOKEN*
     get_mt(const lcb_RESPBASE *rb) {
         const ResponsePack *rp = reinterpret_cast<const ResponsePack*>(rb);
         return &rp->mt;
     }
+
+    static const char*
+    get_err_ctx(const lcb_RESPBASE *rb) {
+        const ResponsePack *rp = reinterpret_cast<const ResponsePack*>(rb);
+        if (rp->resp.rflags & LCB_RESP_F_ERRINFO) {
+            if (rp->err_ctx) {
+                return rp->err_ctx;
+            } else {
+                parse_enhanced_error(rp);
+                return rp->err_ctx;
+            }
+        }
+        return NULL;
+    }
+
+    static const char*
+    get_err_ref(const lcb_RESPBASE *rb) {
+        const ResponsePack *rp = reinterpret_cast<const ResponsePack*>(rb);
+        if (rp->resp.rflags & LCB_RESP_F_ERRINFO) {
+            if (rp->err_ref) {
+                return rp->err_ref;
+            } else {
+                parse_enhanced_error(rp);
+                return rp->err_ref;
+            }
+        }
+        return NULL;
+    }
+
+ private:
+
+    static void
+    parse_enhanced_error(const ResponsePack *rp) {
+        ResponsePack *mrp = const_cast<ResponsePack *>(rp);
+        lcb_error_t rc = MemcachedResponse::parse_enhanced_error(mrp->value, mrp->nvalue, &mrp->err_ref, &mrp->err_ctx);
+        if (rc != LCB_SUCCESS) {
+            mrp->resp.rflags &= ~LCB_RESP_F_ERRINFO;
+        }
+    }
 };
 
 LIBCOUCHBASE_API
@@ -53,7 +103,7 @@ lcb_errmap_default(lcb_t instance, lcb_uint16_t in)
     case PROTOCOL_BINARY_RESPONSE_EINTERNAL:
     default:
         if (instance) {
-            lcb_log(instance->settings, "handler", LCB_LOG_ERROR, __FILE__, __LINE__, "Got unhandled memcached error 0x%X", in);
+            lcb_log(LOGARGS(instance, ERROR), "Got unhandled memcached error 0x%X", in);
         } else {
             fprintf(stderr, "COUCHBASE: Unhandled memcached status=0x%x\n", in);
         }
@@ -113,6 +163,8 @@ map_error(lcb_t instance, int in)
         return LCB_UNKNOWN_COMMAND;
     case PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED:
         return LCB_NOT_SUPPORTED;
+    case PROTOCOL_BINARY_RESPONSE_EACCESS:
+        return LCB_NOT_AUTHORIZED;
     default:
         if (instance != NULL) {
             return instance->callbacks.errmap(instance, in);
@@ -174,6 +226,18 @@ void make_error(lcb_t instance, T* resp,
     }
 }
 
+template <typename T>
+void handle_error_info(const MemcachedResponse* mc_resp, ResponsePack<T>* rp)
+{
+    if (mc_resp->status() != PROTOCOL_BINARY_RESPONSE_SUCCESS
+        && mc_resp->datatype() & PROTOCOL_BINARY_DATATYPE_JSON
+        && mc_resp->vallen() > 0) {
+        rp->resp.rflags |= LCB_RESP_F_ERRINFO;
+        rp->value = mc_resp->value();
+        rp->nvalue = mc_resp->vallen();
+    }
+}
+
 template <typename T>
 void init_resp(lcb_t instance, const MemcachedResponse* mc_resp,
                const mc_PACKET *req, lcb_error_t immerr, T *resp) {
@@ -289,10 +353,12 @@ static void
 H_get(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse* response,
       lcb_error_t immerr)
 {
-    lcb_RESPGET resp = { 0 };
+    ResponsePack<lcb_RESPGET> w = {{ 0 }};
+    lcb_RESPGET& resp = w.resp;
 
     lcb_t o = get_instance(pipeline);
     init_resp(o, response, request, immerr, &resp);
+    handle_error_info(response, &w);
     resp.rflags |= LCB_RESP_F_FINAL;
 
     if (resp.rc == LCB_SUCCESS) {
@@ -317,12 +383,14 @@ static void
 H_getreplica(mc_PIPELINE *pipeline, mc_PACKET *request,
              MemcachedResponse *response, lcb_error_t immerr)
 {
-    lcb_RESPGET resp = { 0 };
+    ResponsePack<lcb_RESPGET> w = {{ 0 }};
+    lcb_RESPGET& resp = w.resp;
     lcb_t instance = get_instance(pipeline);
     void *freeptr = NULL;
     mc_REQDATAEX *rd = request->u_rdata.exdata;
 
     init_resp(instance, response, request, immerr, &resp);
+    handle_error_info(response, &w);
 
     if (resp.rc == LCB_SUCCESS) {
         const protocol_binary_response_get *get =
@@ -511,6 +579,7 @@ H_delete(mc_PIPELINE *pipeline, mc_PACKET *packet, MemcachedResponse *response,
     ResponsePack<lcb_RESPREMOVE> w = { { 0 } };
     w.resp.rflags |= LCB_RESP_F_EXTDATA | LCB_RESP_F_FINAL;
     init_resp(root, response, packet, immerr, &w.resp);
+    handle_error_info(response, &w);
     handle_mutation_token(root, response, packet, &w.mt);
     TRACE_REMOVE_END(response, &w.resp);
     invoke_callback(packet, root, &w.resp, LCB_CALLBACK_REMOVE);
@@ -628,6 +697,7 @@ H_store(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse *response,
     ResponsePack<lcb_RESPSTORE> w = { { 0 } };
     uint8_t opcode;
     init_resp(root, response, request, immerr, &w.resp);
+    handle_error_info(response, &w);
     if (!immerr) {
         opcode = response->opcode();
     } else {
@@ -669,6 +739,8 @@ H_arithmetic(mc_PIPELINE *pipeline, mc_PACKET *request,
         w.resp.value = lcb_ntohll(w.resp.value);
         w.resp.rflags |= LCB_RESP_F_EXTDATA;
         handle_mutation_token(root, response, request, &w.mt);
+    } else {
+        handle_error_info(response, &w);
     }
     w.resp.rflags |= LCB_RESP_F_FINAL;
     w.resp.cas = response->cas();
@@ -741,8 +813,10 @@ H_touch(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse *response,
         lcb_error_t immerr)
 {
     lcb_t root = get_instance(pipeline);
-    lcb_RESPTOUCH resp = { 0 };
+    ResponsePack<lcb_RESPTOUCH> w = {{ 0 }};
+    lcb_RESPTOUCH& resp = w.resp;
     init_resp(root, response, request, immerr, &resp);
+    handle_error_info(response, &w);
     resp.rflags |= LCB_RESP_F_FINAL;
     TRACE_TOUCH_END(response, &resp);
     invoke_callback(request, root, &resp, LCB_CALLBACK_TOUCH);
@@ -764,8 +838,10 @@ H_unlock(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse *response,
          lcb_error_t immerr)
 {
     lcb_t root = get_instance(pipeline);
-    lcb_RESPUNLOCK resp = { 0 };
+    ResponsePack<lcb_RESPUNLOCK> w = {{ 0 }};
+    lcb_RESPUNLOCK& resp = w.resp;
     init_resp(root, response, request, immerr, &resp);
+    handle_error_info(response, &w);
     resp.rflags |= LCB_RESP_F_FINAL;
     TRACE_UNLOCK_END(response, &resp);
     invoke_callback(request, root, &resp, LCB_CALLBACK_UNLOCK);
@@ -822,8 +898,6 @@ mcreq_dispatch_response(
     break;
 
     switch (res->opcode()) {
-    case PROTOCOL_BINARY_CMD_GETQ:
-    case PROTOCOL_BINARY_CMD_GATQ:
     case PROTOCOL_BINARY_CMD_GET:
     case PROTOCOL_BINARY_CMD_GAT:
     case PROTOCOL_BINARY_CMD_GET_LOCKED:
@@ -934,3 +1008,40 @@ lcb_resp_get_mutation_token(int cbtype, const lcb_RESPBASE *rb)
     }
     return ss;
 }
+
+#define ERRINFO_CALLBACKS(X)                    \
+    X(GET)                                      \
+    X(STORE)                                    \
+    X(COUNTER)                                  \
+    X(TOUCH)                                    \
+    X(REMOVE)                                   \
+    X(UNLOCK)                                   \
+
+
+LIBCOUCHBASE_API
+const char *
+lcb_resp_get_error_context(int cbtype, const lcb_RESPBASE *rb)
+{
+    if ((rb->rflags & LCB_RESP_F_ERRINFO) == 0) {
+        return NULL;
+    }
+
+#define X(NAME) if (cbtype == LCB_CALLBACK_##NAME) { return ResponsePack<lcb_RESP##NAME>::get_err_ctx(rb); }
+    ERRINFO_CALLBACKS(X);
+#undef X
+    return NULL;
+}
+
+LIBCOUCHBASE_API
+const char *
+lcb_resp_get_error_ref(int cbtype, const lcb_RESPBASE *rb)
+{
+    if ((rb->rflags & LCB_RESP_F_ERRINFO) == 0) {
+        return NULL;
+    }
+
+#define X(NAME) if (cbtype == LCB_CALLBACK_##NAME) { return ResponsePack<lcb_RESP##NAME>::get_err_ref(rb); }
+    ERRINFO_CALLBACKS(X);
+#undef X
+    return NULL;
+}

data/ext/libcouchbase/src/hostlist.cc

@@ -16,7 +16,6 @@
  */
 
 #include "hostlist.h"
-#include "simplestring.h"
 #include <stdio.h>
 #include <ctype.h>
 #include <limits.h>
@@ -264,38 +263,3 @@ Hostlist::assign(const Hostlist& src)
     }
     return *this;
 }
-
-extern "C" {
-Hostlist* hostlist_create(void) { return new Hostlist(); }
-void hostlist_destroy(hostlist_t l) { delete l; }
-void hostlist_clear(hostlist_t l) { l->clear(); }
-void hostlist_reset_strlist(hostlist_t l) { l->reset_strlist(); }
-lcb_error_t hostlist_add_host(hostlist_t l, const lcb_host_t *h) { l->add(*h); return LCB_SUCCESS; }
-lcb_host_t *hostlist_shift_next(hostlist_t hl, int wrap) { return hl->next(wrap); }
-int hostlist_finished(hostlist_t l) { return l->ix == l->hosts.size(); }
-size_t hostlist_size(hostlist_t l) { return l->size(); }
-void hostlist_randomize(hostlist_t l) { l->randomize(); }
-
-lcb_error_t
-hostlist_add_string(hostlist_t hl, const char *spec, int len, int deflport) {
-    return hl->add(spec, len, deflport);
-}
-
-void
-hostlist_assign(hostlist_t dst, const hostlist_t src) {
-    dst->assign(*src);
-}
-
-const lcb_host_t*
-hostlist_get(const hostlist_t h, size_t ix) { return &h->hosts[ix]; }
-
-const char * const *
-hostlist_strents(const hostlist_t h) {
-    h->ensure_strlist();
-    if (h->hoststrs.size()) {
-        return &h->hoststrs[0];
-    } else {
-        return NULL;
-    }
-}
-}

data/ext/libcouchbase/src/hostlist.h

@@ -45,21 +45,59 @@ struct Hostlist {
     Hostlist() : ix(0) {}
     ~Hostlist();
 
-    void add(const lcb_host_t&);
+    /**
+     * Adds a string to the hostlist. See lcb_host_parse for details.
+     * Note that if the host already exists (see 'lcb_host_equals') it will
+     * not be added
+     * @param s the string to parse
+     * @param len the length of the string
+     * @param deflport If `s` does not contain an explicit port, use this
+     *        port instead.
+     * @return LCB_EINVAL if the host string is not valid
+     */
     lcb_error_t add(const char *s, long len, int deflport);
     lcb_error_t add(const char *s, int deflport) { return add(s, -1, deflport); }
+    void add(const lcb_host_t&);
+
     bool exists(const lcb_host_t&) const;
     bool exists(const char *hostport) const;
+
+    /**
+     * Return the next host in the list.
+     * @param wrap If the internal iterator has reached its limit, this
+     * indicates whether it should be reset, or if it should return NULL
+     * @return a new host if available, or NULL if the list is empty or the
+     * iterator is finished.
+     */
     lcb_host_t *next(bool wrap);
     bool finished() const;
 
     size_t size() const { return hosts.size(); }
     bool empty() const { return hosts.empty(); }
     Hostlist& assign(const Hostlist& other);
+
+    /** Clears the hostlist */
     void clear() { hosts.clear(); reset_strlist(); ix = 0; }
+
+    /** Randomize the hostlist by shuffling the order. */
     void randomize();
+
+    /**
+     * String list handling functions. These are used to return the hostlist via
+     * the API where we return a char*[] terminated by a NULL pointer.
+     */
+
+    /** Ensure that the string list contains at least one entry */
     void ensure_strlist();
+
+    /** Frees the current list of strings */
     void reset_strlist();
+
+    const char * const *get_strlist() {
+        ensure_strlist();
+        return &hoststrs[0];
+    }
+
     unsigned int ix;
     const lcb_host_t& operator[](size_t ix_) const { return hosts[ix_]; }
 
@@ -68,28 +106,16 @@ struct Hostlist {
 };
 }
 typedef lcb::Hostlist* hostlist_t;
-#define hostlist_st lcb::Hostlist
+
+struct hostlist_st : lcb::Hostlist {
+    hostlist_st() : Hostlist() {
+    }
+};
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-
-/**
- * Creates a new hostlist. Returns NULL on allocation failure
- */
-hostlist_t hostlist_create(void);
-
-/**
- * Frees resources associated with the hostlist
- */
-void hostlist_destroy(hostlist_t hostlist);
-
-/**
- * Clears the hostlist
- */
-void hostlist_clear(hostlist_t hostlist);
-
 /**
  * Parses a string into a hostlist
  * @param host the target host to populate
@@ -121,50 +147,6 @@ lcb_host_parse(lcb_host_t *host, const char *spec, int speclen, int deflport);
  */
 int lcb_host_equals(const lcb_host_t *a, const lcb_host_t *b);
 
-/**
- * Adds a string to the hostlist. See lcb_host_parse for details.
- * Note that if the host already exists (see 'lcb_host_equals') it will
- * not be added
- * @return LCB_EINVAL if the host string is not value, LCB_CLIENT_ENOMEM on
- * allocation failure.
- */
-lcb_error_t hostlist_add_string(hostlist_t hostlist,
-                                const char *spec,
-                                int speclen,
-                                int deflport);
-
-#define hostlist_add_stringz(hostlist, spec, deflport) \
-    hostlist_add_string(hostlist, spec, -1, deflport)
-
-lcb_error_t hostlist_add_host(hostlist_t hostlist, const lcb_host_t *host);
-
-/**
- * Return the next host in the list.
- * @param hostlist the hostlist to use
- * @param rollover If the internal iterator has reached its limit, this
- * indicates whether it should be reset, or if it should return NULL
- * @return a new host if available, or NULL if the list is empty or the
- * iterator is finished.
- */
-lcb_host_t *hostlist_shift_next(hostlist_t hostlist, int rollover);
-
-/**
- * Randomize the hostlist
- */
-void hostlist_randomize(hostlist_t hostlist);
-
-/**
- * String list handling functions. These are used to return the hostlist via
- * the API where we return a char*[] terminated by a NULL pointer.
- */
-void hostlist_reset_strlist(hostlist_t hostlist);
-
-/** Whether the internal iterator has finished. */
-int hostlist_finished(hostlist_t);
-size_t hostlist_size(const hostlist_t hl);
-void hostlist_assign(hostlist_t dst, const hostlist_t src);
-const lcb_host_t *hostlist_get(const hostlist_t, size_t);
-const char * const *hostlist_strents(const hostlist_t hl);
 #ifdef __cplusplus
 }
 #endif

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

@@ -21,6 +21,7 @@
 #include <libcouchbase/couchbase.h>
 #include <lcbio/lcbio.h>
 #include <lcbio/timer-ng.h>
+#include <lcbio/timer-cxx.h>
 #include <lcbht/lcbht.h>
 #include "contrib/http_parser/http_parser.h"
 #include "http.h"
@@ -41,100 +42,34 @@ struct Header {
 };
 
 struct Request {
-    enum State {
-        /**
-         * The request is still ongoing. Callbacks are still active.
-         * Note that this essentially means the absence of any flags :)
-         */
-        ONGOING = 0,
-
-        /**
-         * This flag is set when the on_complete callback has been invoked. This
-         * is used as a marker to prevent us from calling that callback more than
-         * once per request
-         */
-        CBINVOKED = 1 << 0,
-
-        /**
-         * This flag is set by lcb_http_request_finish, and indicates that the
-         * request is no longer active per se. This means that while the request
-         * may still be valid in memory, it is simply waiting for any pending I/O
-         * operations to close, so the reference count can hit zero.
-         */
-        FINISHED = 1 << 1,
-
-        /**
-         * Internal flag used to indicate that finish() should not not attempt
-         * to modify any instance-level globals. This is currently used
-         * from within lcb_destroy()
-         */
-        NOLCB = 1 << 2
-    };
-
-    lcb_t instance; /**< Library handle */
-    std::string url; /**<Base URL: http://host:port/path?query*/
-    std::string host; /**< Host, derived from URL */
-    std::string port; /**< Port, derived from URL */
-
-    std::string pending_redirect; /**< New redirected URL */
-    bool has_pending_redirect() const { return !pending_redirect.empty(); }
-    const std::vector<char> body; /**< Input body (for POST/PUT) */
-
-    /** Request buffer (excluding body). Reassembled from inputs */
-    std::vector<char> preamble;
-
-    struct http_parser_url url_info; /**< Parser info for the URL */
-    const lcb_http_method_t method; /**< Request method constant */
-    const bool chunked; /**< Whether to invoke callback for each data chunk */
-    bool paused; /**< See pause() and resume() */
-    const void * const command_cookie; /** User context for callback */
-    size_t refcount; /** Initialized to 1. See incref() and decref() */
-    int redircount; /** Times this request was redirected */
-
     /**
-     * Whether this request has delivered data to the user. This is relevant
-     * in cases where a retry is requested. If any data has been passed at
-     * all, we cannot retry the request.
+     * Initializes the request. This simply copies the relevant fields from the
+     * body and initializes instance members to their default values. The static
+     * ::create() method should be used instead to construct a new object
      */
-    bool passed_data;
+    inline Request(lcb_t instance, const void *cookie, const lcb_CMDHTTP* cmd);
 
-    /** Sparse map indicating which nodes the request was already sent to */
-    std::vector<int> used_nodes;
+    /** Creates a new request object and verifies the input (setup_inputs()) */
+    static Request * create(lcb_t instance, const void *cookie,
+        const lcb_CMDHTTP *cmd, lcb_error_t *rc);
 
-    /**
-     * Last revision ID of vBucket config. If the current revision does not
-     * match this number, the ::used_nodes field is cleared
-     */
-    int last_vbcrev;
+    /** Pause IO on this request */
+    void pause();
 
-    const lcb_http_type_t reqtype; /**< HTTP API type */
-    int status; /**< OR'd flags of ::State */
-    std::vector<Header> request_headers; /**< List of request headers */
+    /** Resume previously paused IO */
+    void resume();
+
+    /** Cancel and finish this request, suppressing callbacks */
+    void cancel();
 
     /**
-     * Response headers for callback (array of char*). Buffers are mapped to
-     * ::response_headers
+     * Start all operations required to make this request. This should be
+     * called once all inputs have been completed. If successful, I/O operations
+     * will begin (this function calls start_io())
      */
-    std::vector<const char*> response_headers_clist;
-
-    /** Backing buffers for response headers */
-    std::vector<Header> response_headers;
-
-    /** Callback to invoke */
-    lcb_RESPCALLBACK callback;
-
-    // IO variables
-    lcbio_pTABLE io;
-    lcbio_pCTX ioctx;
-    lcbio_pTIMER timer;
-    lcbio_CONNREQ creq;
-
-    /** HTTP Protocol parser */
-    lcbht_pPARSER parser;
-
-    /** overrides default timeout if nonzero */
-    const uint32_t user_timeout;
+    lcb_error_t submit();
 
+    bool has_pending_redirect() const { return !pending_redirect.empty(); }
     /**
      * @return The effective timeout. This is either the user timeout or the
      * default timeout for the API type
@@ -152,13 +87,6 @@ struct Request {
      */
     bool is_ongoing() const { return status == ONGOING; }
 
-    /**
-     * Initializes the request. This simply copies the relevant fields from the
-     * body and initializes instance members to their default values. The static
-     * ::create() method should be used instead to construct a new object
-     */
-    inline Request(lcb_t instance, const void *cookie, const lcb_CMDHTTP* cmd);
-
     /**
      * Sets up inputs from the command. This should really be in the
      * constructor, however we also need a return value. The ::create()
@@ -180,10 +108,6 @@ struct Request {
     const char *get_api_node(lcb_error_t &rc);
     const char *get_api_node() { lcb_error_t dummy; return get_api_node(dummy); }
 
-    /** Creates a new request object and verifies the input (setup_inputs()) */
-    static Request * create(lcb_t instance, const void *cookie,
-        const lcb_CMDHTTP *cmd, lcb_error_t *rc);
-
     /**
      * Sets the URL for the field
      * @param base The URL base (i.e. http://foo.com)
@@ -220,13 +144,6 @@ struct Request {
     inline void add_to_preamble(const std::string&);
     inline void add_to_preamble(const Header&);
 
-    /**
-     * Start all operations required to make this request. This should be
-     * called once all inputs have been completed. If successful, I/O operations
-     * will begin (this function calls start_io())
-     */
-    lcb_error_t submit();
-
     /**
      * Starts the IO on the current request. This really belongs in submit(),
      * but submit() handles building the request while start_io() sets up
@@ -241,7 +158,7 @@ struct Request {
 
     // Helper functions for parsing response data from network
     inline int handle_parse_chunked(const char *buf, unsigned nbuf);
-    inline void assign_response_headers(const lcbht_RESPONSE*);
+    inline void assign_response_headers(const lcb::htparse::Response&);
 
     /**
      * Called when a redirect has happened. pending_redirect must not be empty.
@@ -273,14 +190,15 @@ struct Request {
      **/
     void finish_or_retry(lcb_error_t rc);
 
-    /** Pause IO on this request */
-    void pause();
-
-    /** Resume previously paused IO */
-    void resume();
-
-    /** Cancel and finish this request, suppressing callbacks */
-    void cancel();
+    /**
+     * Change the callback for this request. This is used to indicate that
+     * a custom internal callback is used, rather than the one installed via
+     * lcb_install_callback3
+     * @param callback_ The internal callback to invoke
+     */
+    void set_callback(lcb_RESPCALLBACK callback_) {
+        callback = callback_;
+    }
 
     /**
      * Let the request finish its normal course, suppressing any callbacks.
@@ -297,6 +215,101 @@ struct Request {
 
     /** Increment refcount */
     void incref() { refcount++; }
+
+    lcb_t instance; /**< Library handle */
+    std::string url; /**<Base URL: http://host:port/path?query*/
+    std::string host; /**< Host, derived from URL */
+    std::string port; /**< Port, derived from URL */
+
+    std::string pending_redirect; /**< New redirected URL */
+
+    const std::vector<char> body; /**< Input body (for POST/PUT) */
+
+    /** Request buffer (excluding body). Reassembled from inputs */
+    std::vector<char> preamble;
+
+    struct http_parser_url url_info; /**< Parser info for the URL */
+    const lcb_http_method_t method; /**< Request method constant */
+    const bool chunked; /**< Whether to invoke callback for each data chunk */
+    bool paused; /**< See pause() and resume() */
+    const void * const command_cookie; /** User context for callback */
+    size_t refcount; /** Initialized to 1. See incref() and decref() */
+    int redircount; /** Times this request was redirected */
+
+    /**
+     * Whether this request has delivered data to the user. This is relevant
+     * in cases where a retry is requested. If any data has been passed at
+     * all, we cannot retry the request.
+     */
+    bool passed_data;
+
+    /** Sparse map indicating which nodes the request was already sent to */
+    std::vector<int> used_nodes;
+
+    /**
+     * Last revision ID of vBucket config. If the current revision does not
+     * match this number, the ::used_nodes field is cleared
+     */
+    int last_vbcrev;
+
+    const lcb_http_type_t reqtype; /**< HTTP API type */
+
+
+    enum State {
+        /**
+         * The request is still ongoing. Callbacks are still active.
+         * Note that this essentially means the absence of any flags :)
+         */
+        ONGOING = 0,
+
+        /**
+         * This flag is set when the on_complete callback has been invoked. This
+         * is used as a marker to prevent us from calling that callback more than
+         * once per request
+         */
+        CBINVOKED = 1 << 0,
+
+        /**
+         * This flag is set by lcb_http_request_finish, and indicates that the
+         * request is no longer active per se. This means that while the request
+         * may still be valid in memory, it is simply waiting for any pending I/O
+         * operations to close, so the reference count can hit zero.
+         */
+        FINISHED = 1 << 1,
+
+        /**
+         * Internal flag used to indicate that finish() should not not attempt
+         * to modify any instance-level globals. This is currently used
+         * from within lcb_destroy()
+         */
+        NOLCB = 1 << 2
+    };
+    int status; /**< OR'd flags of ::State */
+    std::vector<Header> request_headers; /**< List of request headers */
+
+    /**
+     * Response headers for callback (array of char*). Buffers are mapped to
+     * ::response_headers
+     */
+    std::vector<const char*> response_headers_clist;
+
+    /** Backing buffers for response headers */
+    std::vector<lcb::htparse::MimeHeader> response_headers;
+
+    /** Callback to invoke */
+    lcb_RESPCALLBACK callback;
+
+    // IO variables
+    lcbio_pTABLE io;
+    lcbio_pCTX ioctx;
+    lcbio_pTIMER timer;
+    lcb::io::ConnectionRequest *creq;
+
+    /** HTTP Protocol parser */
+    lcb::htparse::Parser* parser;
+
+    /** overrides default timeout if nonzero */
+    const uint32_t user_timeout;
 };
 
 } // namespace: http