libcouchbase 0.0.7 → 0.0.8

data/ext/libcouchbase/src/operations/durability_internal.h

@@ -18,12 +18,52 @@
 #ifndef LCB_DURABILITY_INTERNAL_H
 #define LCB_DURABILITY_INTERNAL_H
 
-#include "simplestring.h"
-#include "ssobuf.h"
 #ifdef __cplusplus
+#include "mctx-helper.h"
+
 extern "C" {
 #endif
 
+/**
+ * @name internal durability functions
+ * These functions are used internally beyond the durability module.
+ * @{
+ */
+
+/**
+ * Called from the OBSERVE codebase to update an item's status for CAS-based
+ * observe
+ */
+void lcbdur_cas_update(lcb_t, void *dset, lcb_error_t, const lcb_RESPOBSERVE *);
+
+/**
+ * Called from the OBSERVE codebase to update an item's status for seqno-based
+ * observe
+ */
+void lcbdur_update_seqno(lcb_t, void *dset, const lcb_RESPOBSEQNO*);
+
+/** Indicate that this durability command context is for an original storage op */
+void lcbdurctx_set_durstore(lcb_MULTICMD_CTX *ctx, int enabled);
+
+void lcbdur_destroy(void *dset);
+
+/** Called from durability-cas to request an OBSERVE with a special callback */
+lcb_MULTICMD_CTX *lcb_observe_ctx_dur_new(lcb_t instance);
+
+/**@}
+ *
+ * The rest of this file is internal to the various durability operations and
+ * is not accessed by the rest of the codebase
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef LCBDUR_PRIV_SYMS
+namespace lcb {
+namespace durability {
+
 /**
  * Here is the internal API for the durability functions.
  *
@@ -42,158 +82,206 @@ extern "C" {
  * persisted to or replicated to. This is tied to a given mc_SERVER
  * instance.
  */
-typedef struct {
-    const mc_SERVER *server; /**< Server pointer (for comparison only) */
+struct ServerInfo {
+    const lcb::Server *server; /**< Server pointer (for comparison only) */
     lcb_U16 persisted; /**< Exists on server */
     lcb_U16 exists; /**< Persisted to server */
-} lcbdur_SERVINFO;
+
+    ServerInfo() : server(NULL), persisted(0), exists(0) {
+    }
+
+    void clear() {
+        server = NULL;
+        persisted = 0;
+        exists = 0;
+    }
+};
+
+struct Durset;
+
+// For use in conjunction with MCREQ_F_PRIVCALLBACK
+struct CallbackCookie {
+    lcb_RESPCALLBACK callback;
+};
 
 /**Information a single entry in a durability set. Each entry contains a single
  * key */
-typedef struct lcb_DURITEM_st {
+struct Item : public CallbackCookie {
+    /**
+     * Returns true if the entry is complete, false otherwise. This only assumes
+     * successful entries.
+     */
+    bool is_all_done() const;
+
+    /**
+     * Determine if this item has been satisfied on a specific server. This
+     * function is used to determine if a probe should be sent to the server.
+     *
+     * If there are no items "tied" to the server (because they have all been
+     * completed) then we employ a bandwidth saving optimization by not sending
+     * additional probes to it.
+     *
+     * @param info Server to check against
+     * @param is_master If this server is the master for the item's vbucket
+     *
+     * @return true if the item is both persisted and replicated on the server,
+     *         OR if the item has been replicated, but replication is not
+     *         required for the item.
+     */
+    bool is_server_done(const ServerInfo& info, bool is_master) const;
+
+    /**
+     * Updates the state of the given entry and synchronizes it with the
+     * current server list.
+     *
+     * Specifically this function will return a list of
+     * servers which still need to be contacted, and will increment internal
+     * counters on behalf of those (still active) servers which the item has
+     * already been replicated to (and persisted to, if requested).
+     *
+     * This will invalidate any cached information of the cluster configuration
+     * in respect to this item has changed -- this includes things like servers
+     * moving indices or being recreated entirely.
+     *
+     * This function should be called during poll().
+     * @param[out] ixarray An array of server indices which should be queried
+     * @return the number of effective entries in the array.
+     */
+    size_t prepare(uint16_t ixarray[4]);
+
+    enum UpdateFlags {
+        NO_CHANGES = 0x00,
+        UPDATE_PERSISTED = 0x01,
+        UPDATE_REPLICATED = 0x02
+    };
+
+    /**
+     * Update an item's status.
+     * @param flags OR'd set of UPDATE_PERSISTED and UPDATE_REPLICATED
+     * @param ix The server index
+     */
+    void update(int flags, int srvix);
+
+    /**
+     * Set the logical state of the entry to done, and invoke the callback.
+     * It is safe to call this multiple times
+     */
+    void finish();
+
+    void finish(lcb_error_t err) {
+        result.rc = err;
+        finish();
+    }
+
+    lcb_RESPENDURE& res() { return result; }
+    const lcb_RESPENDURE& res() const { return result; }
+    ServerInfo* get_server_info(int index);
+
     lcb_U64 reqcas; /**< Last known CAS for the user */
     lcb_U64 reqseqno; /**< Last known seqno for the user */
     lcb_U64 uuid;
     lcb_RESPENDURE result; /**< Result to be passed to user */
-    struct lcb_DURSET_st *parent;
-    lcb_RESPCALLBACK callback; /**< For F_INTERNAL_CALLBACK */
+    Durset *parent;
     lcb_U16 vbid; /**< vBucket ID (computed via hashkey) */
     lcb_U8 done; /**< Whether we have a conclusive result for this entry */
 
     /** Array of servers which have satisfied constraints */
-    lcbdur_SERVINFO sinfo[4];
-} lcb_DURITEM;
-
-struct lcbdur_PROCS_st;
-
-enum {
-    LCBDUR_STATE_OBSPOLL = 0,
-    LCBDUR_STATE_INIT,
-    LCBDUR_STATE_TIMEOUT,
-    LCBDUR_STATE_IGNORE
+    ServerInfo sinfo[4];
 };
 
 /**
  * A collection encompassing one or more entries which are to be checked for
  * persistence
  */
-typedef struct lcb_DURSET_st {
-    lcb_MULTICMD_CTX mctx; /**< Base class returned to user for scheduling */
-    lcb_DURABILITYOPTSv0 opts; /**< Sanitized user options */
-    LCB_SSOBUF_DECLARE(lcb_DURITEM) entries_;
-    unsigned nremaining; /**< Number of entries remaining to poll for */
-    int waiting; /**< Set if currently awaiting an observe callback */
-    unsigned refcnt; /**< Reference count */
-    unsigned next_state; /**< Internal state */
-    lcb_error_t lasterr;
-    int is_durstore; /** Whether the callback should be DURSTORE */
-    lcb_string kvbufs; /**< Backing storage for key buffers */
-    const void *cookie; /**< User cookie */
-    hrtime_t ns_timeout; /**< Timestamp of next timeout */
-    void *timer;
-    lcb_t instance;
-    void *impldata;
-} lcb_DURSET;
-
-typedef struct lcbdur_PROCS_st {
-    lcb_error_t (*poll)(lcb_DURSET *dset);
-    lcb_error_t (*ent_add)(lcb_DURSET*,lcb_DURITEM*,const lcb_CMDENDURE*);
-    lcb_error_t (*schedule)(lcb_DURSET*);
-    void (*clean)(lcb_DURSET*);
-} lcbdur_PROCS;
-
-void
-lcbdur_cas_update(lcb_t instance, lcb_DURSET *dset, lcb_error_t err,
-    const lcb_RESPOBSERVE *resp);
-void
-lcbdur_update_seqno(lcb_t instance, lcb_DURSET *dset,
-    const lcb_RESPOBSEQNO *resp);
-
-/** Indicate that this durability command context is for an original storage op */
-void
-lcbdurctx_set_durstore(lcb_MULTICMD_CTX *ctx, int enabled);
+struct Durset : public MultiCmdContext {
+    /**
+     * Call this when the polling method (poll_impl()) has completed. This will
+     * trigger a new poll after the interval.
+     */
+    void on_poll_done();
 
-lcb_MULTICMD_CTX *
-lcb_observe_ctx_dur_new(lcb_t instance);
+    void incref() { refcnt++; }
 
-#ifdef LCBDUR_PRIV_SYMS
+    /**
+     * Decrement the refcount for the 'dset'. When it hits zero then the dset is
+     * freed
+     */
+    void decref() { if (!--refcnt) { delete this; } }
 
-extern lcbdur_PROCS lcbdur_cas_procs;
-extern lcbdur_PROCS lcbdur_seqno_procs;
+    enum State {
+        STATE_OBSPOLL,
+        STATE_INIT,
+        STATE_TIMEOUT,
+        STATE_IGNORE
+    };
 
-#define RESFLD(e, f) (e)->result.f
-#define ENT_CAS(e) (e)->request.options.cas
-#define DSET_OPTFLD(ds, opt) (ds)->opts.opt
-#define DSET_COUNT(ds) (ds)->entries_.count
-#define DSET_ENTRIES(ds) LCB_SSOBUF_ARRAY(&(ds)->entries_, lcb_DURITEM)
-#define DSET_PROCS(ds) ((ds)->opts.pollopts == LCB_DURABILITY_MODE_CAS \
-    ? (&lcbdur_cas_procs) : (&lcbdur_seqno_procs))
-#define ENT_NUMINFO(ent) 4
+    /**
+     * Schedules us to be notified with the given state within a particular amount
+     * of time. This is used both for the timeout and for the interval
+     */
+    void switch_state(State state);
 
-/**
- * Returns true if the entry is complete, false otherwise. This only assumes
- * successful entries.
- */
-int lcbdur_ent_check_done(lcb_DURITEM *ent);
+    /**
+     * Called from mctx_schedule(). This allows implementations to do any
+     * additional bookeeping, having guaranteed that all items are now
+     * added.
+     */
+    virtual lcb_error_t prepare_schedule() {
+        return LCB_SUCCESS;
+    }
 
-/**
- * Set the logical state of the entry to done, and invoke the callback.
- * It is safe to call this multiple times
- */
-void lcbdur_ent_finish(lcb_DURITEM *ent);
+    /**
+     * Called from mctx_add. Called to register any item-specific data (i.e.
+     * to associate item data with internal structures)
+     * @param itm the newly added item
+     * @param the original command, for more context
+     */
+    virtual lcb_error_t after_add(Item&, const lcb_CMDENDURE*) {
+        return LCB_SUCCESS;
+    }
 
-/**
- * Called when the last (primitive) OBSERVE response is received for the entry.
- */
-void lcbdur_reqs_done(lcb_DURSET *dset);
+    /**
+     * Called to actually check for persistence/replication. This must be
+     * implemented.
+     */
+    virtual lcb_error_t poll_impl() = 0;
 
-/**
- * Updates the state of the given entry and synchronizes it with the
- * current server list.
- *
- * Specifically this function will return a list of
- * servers which still need to be contacted, and will increment internal
- * counters on behalf of those (still active) servers which the item has
- * already been replicated to (and persisted to, if requested).
- *
- * This will invalidate any cached information of the cluster configuration
- * in respect to this item has changed -- this includes things like servers
- * moving indices or being recreated entirely.
- *
- * This function should be called during poll().
- * @param item The item to update
- * @param[out] ixarray An array of server indices which should be queried
- * @param[out] nitems the number of effective entries in the array.
- */
-void
-lcbdur_prepare_item(lcb_DURITEM *item, lcb_U16 *ixarray, size_t *nitems);
+    virtual ~Durset();
+    Durset(lcb_t instance, const lcb_durability_opts_t* options);
 
-#define LCBDUR_UPDATE_PERSISTED 1
-#define LCBDUR_UPDATE_REPLICATED 2
-/**
- * Update an item's status.
- * @param item The item to update
- * @param flags OR'd set of UPDATE_PERSISTED and UPDATE_REPLICATED
- * @param ix The server index
- */
-void
-lcbdur_update_item(lcb_DURITEM *item, int flags, int ix);
+    // Implementation for MULTICMD_CTX
+    lcb_error_t MCTX_done(const void *cookie);
+    lcb_error_t MCTX_addcmd(const lcb_CMDBASE *cmd);
+    void MCTX_fail();
 
-lcbdur_SERVINFO *
-lcbdur_ent_getinfo(lcb_DURITEM *item, int srvix);
+    /**
+     * This function calls poll_impl(). The implementation should then call
+     * on_poll_done() once the polling is finished
+     */
+    inline void poll();
 
-/**
- * Schedules us to be notified with the given state within a particular amount
- * of time. This is used both for the timeout and for the interval
- */
-void lcbdur_switch_state(lcb_DURSET *dset, unsigned int state);
-#define lcbdur_ref(dset) (dset)->refcnt++;
-void lcbdur_unref(lcb_DURSET *dset);
+    /** Called after timeouts and intervals. */
+    inline void tick();
 
-#endif /* PRIV_SYMS */
+    static Durset* createCasDurset(lcb_t, const lcb_durability_opts_t*);
+    static Durset* createSeqnoDurset(lcb_t, const lcb_durability_opts_t*);
 
-#ifdef __cplusplus
-}
-#endif
+    lcb_DURABILITYOPTSv0 opts; /**< Sanitized user options */
+    std::vector<Item> entries;
+    unsigned nremaining; /**< Number of entries remaining to poll for */
+    int waiting; /**< Set if currently awaiting an observe callback */
+    unsigned refcnt; /**< Reference count */
+    State next_state; /**< Internal state */
+    lcb_error_t lasterr;
+    bool is_durstore; /** Whether the callback should be DURSTORE */
+    std::string kvbufs; /**< Backing storage for key buffers */
+    const void *cookie; /**< User cookie */
+    hrtime_t ns_timeout; /**< Timestamp of next timeout */
+    void *timer;
+    lcb_t instance;
+};
 
-#endif
+} // namespace durability
+} // namespace lcb
+#endif // __cplusplus
+#endif // LCB_DURABILITY_INTERNAL_H

data/ext/libcouchbase/src/operations/{get.c → get.cc}

@@ -181,28 +181,31 @@ lcb_unlock(lcb_t instance, const void *cookie, lcb_size_t num,
     }
 }
 
-typedef struct {
-    mc_REQDATAEX base;
+struct RGetCookie : mc_REQDATAEX {
+    RGetCookie(const void *cookie, lcb_t instance, lcb_replica_t, int vb);
+    void decref() {
+        if (!--remaining) {
+            delete this;
+        }
+    }
+
     unsigned r_cur;
     unsigned r_max;
     int remaining;
     int vbucket;
     lcb_replica_t strategy;
     lcb_t instance;
-} rget_cookie;
+};
 
 static void rget_dtor(mc_PACKET *pkt) {
-    rget_cookie *rck = (rget_cookie *)pkt->u_rdata.exdata;
-    if (! --rck->remaining) {
-        free(rck);
-    }
+    static_cast<RGetCookie*>(pkt->u_rdata.exdata)->decref();
 }
 
 static void
-rget_callback(mc_PIPELINE *pl, mc_PACKET *pkt, lcb_error_t err, const void *arg)
+rget_callback(mc_PIPELINE *, mc_PACKET *pkt, lcb_error_t err, const void *arg)
 {
-    rget_cookie *rck = (rget_cookie *)pkt->u_rdata.exdata;
-    lcb_RESPGET *resp = (void *)arg;
+    RGetCookie *rck = static_cast<RGetCookie*>(pkt->u_rdata.exdata);
+    lcb_RESPGET *resp = reinterpret_cast<lcb_RESPGET*>(const_cast<void*>(arg));
     lcb_RESPCALLBACK callback;
     lcb_t instance = rck->instance;
 
@@ -247,11 +250,7 @@ rget_callback(mc_PIPELINE *pl, mc_PACKET *pkt, lcb_error_t err, const void *arg)
             rck->remaining = 2;
         }
     }
-
-    if (!--rck->remaining) {
-        free(rck);
-    }
-    (void)pl;
+    rck->decref();
 }
 
 static mc_REQDATAPROCS rget_procs = {
@@ -259,6 +258,13 @@ static mc_REQDATAPROCS rget_procs = {
         rget_dtor
 };
 
+RGetCookie::RGetCookie(const void *cookie_, lcb_t instance_,
+    lcb_replica_t strategy_, int vbucket_)
+    : mc_REQDATAEX(cookie_, rget_procs, gethrtime()),
+      r_cur(0), r_max(LCBT_NREPLICAS(instance_)), remaining(0),
+      vbucket(vbucket_), strategy(strategy_), instance(instance_) {
+}
+
 LIBCOUCHBASE_API
 lcb_error_t
 lcb_rget3(lcb_t instance, const void *cookie, const lcb_CMDGETREPLICA *cmd)
@@ -271,7 +277,6 @@ lcb_rget3(lcb_t instance, const void *cookie, const lcb_CMDGETREPLICA *cmd)
     int vbid, ixtmp;
     protocol_binary_request_header req;
     unsigned r0, r1 = 0;
-    rget_cookie *rck = NULL;
 
     if (LCB_KEYBUF_IS_EMPTY(&cmd->key)) {
         return LCB_EMPTY_KEY;
@@ -323,15 +328,7 @@ lcb_rget3(lcb_t instance, const void *cookie, const lcb_CMDGETREPLICA *cmd)
     }
 
     /* Initialize the cookie */
-    rck = calloc(1, sizeof(*rck));
-    rck->base.cookie = cookie;
-    rck->base.start = gethrtime();
-    rck->base.procs = &rget_procs;
-    rck->strategy = cmd->strategy;
-    rck->r_cur = r0;
-    rck->r_max = LCBT_NREPLICAS(instance);
-    rck->instance = instance;
-    rck->vbucket = vbid;
+    RGetCookie *rck = new RGetCookie(cookie, instance, cmd->strategy, vbid);
 
     /* Initialize the packet */
     req.request.magic = PROTOCOL_BINARY_REQ;
@@ -343,6 +340,7 @@ lcb_rget3(lcb_t instance, const void *cookie, const lcb_CMDGETREPLICA *cmd)
     req.request.keylen = htons((lcb_uint16_t)cmd->key.contig.nbytes);
     req.request.bodylen = htonl((lcb_uint32_t)cmd->key.contig.nbytes);
 
+    rck->r_cur = r0;
     do {
         int curix;
         mc_PIPELINE *pl;
@@ -359,7 +357,7 @@ lcb_rget3(lcb_t instance, const void *cookie, const lcb_CMDGETREPLICA *cmd)
             return LCB_CLIENT_ENOMEM;
         }
 
-        pkt->u_rdata.exdata = &rck->base;
+        pkt->u_rdata.exdata = rck;
         pkt->flags |= MCREQ_F_REQEXT;
 
         mcreq_reserve_key(pl, pkt, sizeof(req.bytes), &cmd->key);