libcouchbase 0.0.7 → 0.0.8

data/ext/libcouchbase/src/nodeinfo.cc

@@ -70,7 +70,7 @@ lcb_get_node(lcb_t instance, lcb_GETNODETYPE type, unsigned ix)
 
     if (type & LCB_NODE_HTCONFIG) {
         if (type & LCB_NODE_CONNECTED) {
-            const lcb_host_t *host = lcb_confmon_get_rest_host(instance->confmon);
+            const lcb_host_t *host = lcb::clconfig::http_get_host(instance->confmon);
             if (host) {
                 return mk_scratch_host(instance, host);
             } else {
@@ -101,20 +101,16 @@ lcb_get_node(lcb_t instance, lcb_GETNODETYPE type, unsigned ix)
             return ensure_scratch(instance).append(hp).c_str();
         }
     } else if (type & (LCB_NODE_DATA|LCB_NODE_VIEWS)) {
-        const mc_SERVER *server;
         ix %= LCBT_NSERVERS(instance);
-        server = LCBT_GET_SERVER(instance, ix);
+        const lcb::Server *server = instance->get_server(ix);
 
-        if ((type & LCB_NODE_CONNECTED) && server->connctx == NULL) {
-            return return_badhost(type);
-        }
-        if (server->curhost == NULL) {
+        if ((type & LCB_NODE_CONNECTED) && !server->is_connected()) {
             return return_badhost(type);
         }
 
         /* otherwise, return the actual host:port of the server */
         if (type & LCB_NODE_DATA) {
-            return mk_scratch_host(instance, server->curhost);
+            return mk_scratch_host(instance, &server->get_host());
         } else {
             return lcbvb_get_hostport(vbc, ix, LCBVB_SVCTYPE_VIEWS, mode);
         }

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

@@ -15,11 +15,10 @@
  */
 
 #include "internal.h"
-#include "simplestring.h"
 #include <http/http.h>
 
 static void
-flush_cb(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+flush_cb(lcb_t instance, int, const lcb_RESPBASE *rb)
 {
     const lcb_RESPHTTP *resp = (const lcb_RESPHTTP *)rb;
     lcb_RESPCBFLUSH fresp = { 0 };
@@ -35,37 +34,30 @@ flush_cb(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
     if (callback) {
         callback(instance, LCB_CALLBACK_CBFLUSH, (lcb_RESPBASE*)&fresp);
     }
-    (void)cbtype;
 }
 
 LIBCOUCHBASE_API
 lcb_error_t
-lcb_cbflush3(lcb_t instance, const void *cookie, const lcb_CMDBASE *cmd)
+lcb_cbflush3(lcb_t instance, const void *cookie, const lcb_CMDBASE *)
 {
     lcb_http_request_t htr;
     lcb_CMDHTTP htcmd = { 0 };
-    lcb_string urlpath;
     lcb_error_t rc;
 
-    (void)cmd;
-
-    lcb_string_init(&urlpath);
-    lcb_string_appendz(&urlpath, "/pools/default/buckets/");
-    lcb_string_appendz(&urlpath, LCBT_SETTING(instance, bucket));
-    lcb_string_appendz(&urlpath, "/controller/doFlush");
-
+    std::string urlpath("/pools/default/buckets/");
+    urlpath.append(LCBT_SETTING(instance, bucket));
+    urlpath.append("/controller/doFlush");
 
     htcmd.type = LCB_HTTP_TYPE_MANAGEMENT;
     htcmd.method = LCB_HTTP_METHOD_POST;
     htcmd.reqhandle = &htr;
-    LCB_CMD_SET_KEY(&htcmd, urlpath.base, urlpath.nused);
+    LCB_CMD_SET_KEY(&htcmd, urlpath.c_str(), urlpath.size());
 
     rc = lcb_http3(instance, cookie, &htcmd);
-    lcb_string_release(&urlpath);
 
     if (rc != LCB_SUCCESS) {
         return rc;
     }
-    lcb_htreq_setcb(htr, flush_cb);
+    htr->set_callback(flush_cb);
     return LCB_SUCCESS;
 }

data/ext/libcouchbase/src/operations/{durability-cas.c → durability-cas.cc}

@@ -16,16 +16,50 @@
  */
 
 #define LCBDUR_PRIV_SYMS
+
 #include <libcouchbase/couchbase.h>
 #include <libcouchbase/api3.h>
 #include "internal.h"
 #include "durability_internal.h"
 
-#define DSET_HT(dset) (dset)->impldata
+using namespace lcb::durability;
+
+namespace {
+struct CasDurset : public Durset {
+    CasDurset(lcb_t instance_, const lcb_durability_opts_t *options)
+        : Durset(instance_, options), ht(NULL) {
+    }
+
+    virtual ~CasDurset();
+
+    void update(lcb_error_t err, const lcb_RESPOBSERVE *resp);
+    Item& find(const char *s, size_t n) {
+        if (entries.size() == 1) {
+            return entries.back();
+        } else {
+            return *reinterpret_cast<Item*>(genhash_find(ht, s, n));
+        }
+    }
+
+    // Override
+    lcb_error_t prepare_schedule();
+    lcb_error_t poll_impl();
+
+    genhash_t *ht;
+};
+}
+
+
+Durset*
+Durset::createCasDurset(lcb_t instance, const lcb_durability_opts_t *options) {
+    return new CasDurset(instance, options);
+}
+
+
 
 /* Called when the criteria is to ensure the key exists somewhow */
 static int
-check_positive_durability(lcb_DURITEM *ent, const lcb_RESPOBSERVE *res)
+check_positive_durability(Item& ent, const lcb_RESPOBSERVE *res)
 {
     switch (res->status) {
     case LCB_OBSERVE_NOT_FOUND:
@@ -33,131 +67,122 @@ check_positive_durability(lcb_DURITEM *ent, const lcb_RESPOBSERVE *res)
         /* If we get NOT_FOUND from the master, this means the key
          * simply does not exists (and we don't have to continue polling) */
         if (res->ismaster) {
-            RESFLD(ent, rc) = LCB_KEY_ENOENT;
-            lcbdur_ent_finish(ent);
+            ent.finish(LCB_KEY_ENOENT);
         }
-        return 0;
+        return Item::NO_CHANGES;
 
     case LCB_OBSERVE_PERSISTED:
-        return LCBDUR_UPDATE_PERSISTED | LCBDUR_UPDATE_REPLICATED;
+        return Item::UPDATE_PERSISTED | Item::UPDATE_REPLICATED;
 
     case LCB_OBSERVE_FOUND:
-        return LCBDUR_UPDATE_REPLICATED;
+        return Item::UPDATE_REPLICATED;
 
     default:
-        RESFLD(ent, rc) = LCB_EINTERNAL;
-        lcbdur_ent_finish(ent);
-        return 0;
+        ent.finish(LCB_EINTERNAL);
+        return Item::NO_CHANGES;
     }
 }
 
 /* Called when the criteria is to ensure that the key is deleted somehow */
 static int
-check_negative_durability(lcb_DURITEM *ent, const lcb_RESPOBSERVE *res)
+check_negative_durability(Item& ent, const lcb_RESPOBSERVE *res)
 {
     switch (res->status) {
     case LCB_OBSERVE_PERSISTED:
     case LCB_OBSERVE_FOUND:
         /* Still there! */
-        return 0;
+        return Item::NO_CHANGES;
 
     case LCB_OBSERVE_LOGICALLY_DELETED:
         /* removed from cache, but not actually deleted from disk */
-        return LCBDUR_UPDATE_REPLICATED;
+        return Item::UPDATE_REPLICATED;
 
     case LCB_OBSERVE_NOT_FOUND:
         /* No knowledge of key. */
-        return LCBDUR_UPDATE_PERSISTED | LCBDUR_UPDATE_REPLICATED;
+        return Item::UPDATE_PERSISTED | Item::UPDATE_REPLICATED;
 
     default:
-        RESFLD(ent, rc) = LCB_EINTERNAL;
-        lcbdur_ent_finish(ent);
-        return 0;
+        ent.finish(LCB_EINTERNAL);
+        return Item::NO_CHANGES;
     }
 }
 
+void lcbdur_cas_update(lcb_t, void *dset, lcb_error_t err,
+                       const lcb_RESPOBSERVE *resp)
+{
+    reinterpret_cast<CasDurset*>(dset)->update(err, resp);
+}
+
 /* Observe callback. Called internally by observe.c */
 void
-lcbdur_cas_update(lcb_t instance,
-    lcb_DURSET *dset, lcb_error_t err, const lcb_RESPOBSERVE *resp)
+CasDurset::update(lcb_error_t err, const lcb_RESPOBSERVE *resp)
 {
-    lcb_DURITEM *ent;
-    int flags;
-
     if (resp->key == NULL) {
         /* Last observe response for requests. Start polling after interval */
-        lcbdur_reqs_done(dset);
+        on_poll_done();
         return;
     }
 
-    if (DSET_COUNT(dset) == 1) {
-        ent = DSET_ENTRIES(dset);
-    } else {
-        ent = genhash_find(DSET_HT(dset), resp->key, resp->nkey);
-    }
+    Item& ent = find(reinterpret_cast<const char *>(resp->key), resp->nkey);
 
-    if (ent->done) {
+    if (ent.done) {
         /* ignore subsequent errors */
         return;
     }
 
     if (err != LCB_SUCCESS) {
-        RESFLD(ent, rc) = err;
+        ent.res().rc = err;
         return;
     }
 
-    RESFLD(ent, nresponses)++;
+    ent.res().nresponses++;
     if (resp->cas && resp->ismaster) {
-        RESFLD(ent, cas) = resp->cas;
+        ent.res().cas = resp->cas;
 
-        if (ent->reqcas && ent->reqcas != resp->cas) {
-            RESFLD(ent, rc) = LCB_KEY_EEXISTS;
-            lcbdur_ent_finish(ent);
+        if (ent.reqcas && ent.reqcas != resp->cas) {
+            ent.finish(LCB_KEY_EEXISTS);
             return;
         }
     }
 
-    if (DSET_OPTFLD(ent->parent, check_delete)) {
+    int flags;
+    if (opts.check_delete) {
         flags = check_negative_durability(ent, resp);
     } else {
         flags = check_positive_durability(ent, resp);
     }
 
-    lcbdur_update_item(ent, flags, resp->ttp);
-    (void)instance;
+    ent.update(flags, resp->ttp);
 }
 
-static lcb_error_t
-cas_poll(lcb_DURSET *dset)
+lcb_error_t
+CasDurset::poll_impl()
 {
     lcb_MULTICMD_CTX *mctx;
-    size_t ii;
     lcb_error_t err;
-    lcb_t instance = dset->instance;
 
-    mctx = lcb_observe_ctx_dur_new(dset->instance);
+    mctx = lcb_observe_ctx_dur_new(instance);
     if (!mctx) {
         return LCB_CLIENT_ENOMEM;
     }
 
-    for (ii = 0; ii < DSET_COUNT(dset); ii++) {
+    for (size_t ii = 0; ii < entries.size(); ii++) {
         lcb_CMDOBSERVE cmd = { 0 };
-        lcb_U16 servers[4];
-        size_t nservers = 0;
+        uint16_t servers[4];
 
-        struct lcb_DURITEM_st *ent = DSET_ENTRIES(dset) + ii;
-        if (ent->done) {
+        Item& ent = entries[ii];
+        if (ent.done) {
             continue;
         }
 
-        lcbdur_prepare_item(ent, servers, &nservers);
+        size_t nservers = ent.prepare(servers);
         if (nservers == 0) {
-            RESFLD(ent, rc) = LCB_NO_MATCHING_SERVER;
+            ent.res().rc = LCB_NO_MATCHING_SERVER;
             continue;
         }
 
-        LCB_KREQ_SIMPLE(&cmd.key, RESFLD(ent, key), RESFLD(ent, nkey));
-        LCB_CMD__SETVBID(&cmd, ent->vbid);
+        LCB_KREQ_SIMPLE(&cmd.key, ent.res().key, ent.res().nkey);
+        LCB_CMD__SETVBID(&cmd, ent.vbid);
         cmd.servers_ = servers;
         cmd.nservers_ = nservers;
 
@@ -169,38 +194,36 @@ cas_poll(lcb_DURSET *dset)
     }
 
     lcb_sched_enter(instance);
-    err = mctx->done(mctx, dset);
+    err = mctx->done(mctx, this);
     mctx = NULL;
 
     if (err == LCB_SUCCESS) {
         lcb_sched_leave(instance);
-        dset->waiting = 1;
+        waiting = 1;
     } else {
         lcb_sched_fail(instance);
     }
     return err;
 }
 
-static lcb_error_t
-cas_schedule(lcb_DURSET *dset)
+lcb_error_t
+CasDurset::prepare_schedule()
 {
-    size_t ii;
-
-    if (DSET_COUNT(dset) < 2) {
+    Durset::prepare_schedule();
+    if (entries.size() < 2) {
         return LCB_SUCCESS;
     }
 
-    DSET_HT(dset) = lcb_hashtable_nc_new(DSET_COUNT(dset));
-    if (!DSET_HT(dset)) {
+    ht = lcb_hashtable_nc_new(entries.size());
+    if (!ht) {
         return LCB_CLIENT_ENOMEM;
     }
 
-    for (ii = 0; ii < DSET_COUNT(dset); ++ii) {
+    for (size_t ii = 0; ii < entries.size(); ++ii) {
         int mt;
-        lcb_DURITEM *ent = DSET_ENTRIES(dset) + ii;
+        Item &ent = entries[ii];
 
-        mt = genhash_update(DSET_HT(dset),
-            RESFLD(ent, key), RESFLD(ent, nkey), ent, 0);
+        mt = genhash_update(ht, ent.res().key, ent.res().nkey, &ent, 0);
         if (mt != NEW) {
             return LCB_DUPLICATE_COMMANDS;
         }
@@ -208,17 +231,10 @@ cas_schedule(lcb_DURSET *dset)
     return LCB_SUCCESS;
 }
 
-static void
-cas_clean(lcb_DURSET *dset)
+CasDurset::~CasDurset()
 {
-    if (DSET_HT(dset)) {
-        genhash_free(DSET_HT(dset));
+    if (ht) {
+        genhash_free(ht);
+        ht = NULL;
     }
 }
-
-lcbdur_PROCS lcbdur_cas_procs = {
-        cas_poll,
-        NULL, /* ent_add */
-        cas_schedule,
-        cas_clean
-};

data/ext/libcouchbase/src/operations/{durability-seqno.c → durability-seqno.cc}

@@ -20,32 +20,51 @@
 #include <libcouchbase/api3.h>
 #include "durability_internal.h"
 
+using namespace lcb::durability;
+
+namespace {
+class SeqnoDurset : public Durset {
+public:
+    SeqnoDurset(lcb_t instance_, const lcb_durability_opts_t *options)
+        : Durset(instance_, options) {
+    }
+
+    // Override
+    lcb_error_t poll_impl();
+
+    // Override
+    lcb_error_t after_add(Item& item, const lcb_CMDENDURE *cmd);
+
+    void update(const lcb_RESPOBSEQNO *resp);
+};
+}
+
+Durset *
+Durset::createSeqnoDurset(lcb_t instance, const lcb_durability_opts_t *options) {
+    return new SeqnoDurset(instance, options);
+}
+
 #define ENT_SEQNO(ent) (ent)->reqseqno
 
 static void
-seqno_callback(lcb_t instance, int ign, const lcb_RESPBASE *rb)
+seqno_callback(lcb_t, int, const lcb_RESPBASE *rb)
 {
     const lcb_RESPOBSEQNO *resp = (const lcb_RESPOBSEQNO*)rb;
-    char *pp = resp->cookie;
-    lcb_DURITEM *ent;
     int flags = 0;
-    lcb_U64 seqno_mem, seqno_disk;
+    Item *ent = static_cast<Item*>(reinterpret_cast<CallbackCookie*>(resp->cookie));
 
-    pp -= offsetof(lcb_DURITEM, callback);
-    ent = (lcb_DURITEM *)pp;
     /* Now, process the response */
-
     if (resp->rc != LCB_SUCCESS) {
-        RESFLD(ent, rc) = resp->rc;
+        ent->res().rc = resp->rc;
         goto GT_TALLY;
     }
 
+    lcb_U64 seqno_mem, seqno_disk;
     if (resp->old_uuid) {
         /* Failover! */
         seqno_mem = seqno_disk = resp->old_seqno;
         if (seqno_mem < ENT_SEQNO(ent)) {
-            RESFLD(ent, rc) = LCB_MUTATION_LOST;
-            lcbdur_ent_finish(ent);
+            ent->finish(LCB_MUTATION_LOST);
             goto GT_TALLY;
         }
     } else {
@@ -57,57 +76,52 @@ seqno_callback(lcb_t instance, int ign, const lcb_RESPBASE *rb)
         goto GT_TALLY;
     }
 
-    flags = LCBDUR_UPDATE_REPLICATED;
+    flags = Item::UPDATE_REPLICATED;
     if (seqno_disk >= ENT_SEQNO(ent)) {
-        flags |= LCBDUR_UPDATE_PERSISTED;
+        flags |= Item::UPDATE_PERSISTED;
     }
 
-    lcbdur_update_item(ent, flags, resp->server_index);
+    ent->update(flags, resp->server_index);
 
     GT_TALLY:
     if (!--ent->parent->waiting) {
         /* avoid ssertion (wait==0)! */
         ent->parent->waiting = 1;
-        lcbdur_reqs_done(ent->parent);
+        ent->parent->on_poll_done();
     }
-
-    (void)ign; (void)instance;
 }
 
-static lcb_error_t
-seqno_poll(lcb_DURSET *dset)
+lcb_error_t
+SeqnoDurset::poll_impl()
 {
     lcb_error_t ret_err = LCB_EINTERNAL; /* This should never be returned */
-    size_t ii;
-    int has_ops = 0;
-    lcb_t instance = dset->instance;
+    bool has_ops = false;
 
     lcb_sched_enter(instance);
-    for (ii = 0; ii < DSET_COUNT(dset); ii++) {
-        lcb_DURITEM *ent = DSET_ENTRIES(dset) + ii;
-        size_t jj, nservers = 0;
+    for (size_t ii = 0; ii < entries.size(); ii++) {
+        Item& ent = entries[ii];
         lcb_U16 servers[4];
         lcb_CMDOBSEQNO cmd = { 0 };
 
-        if (ent->done) {
+        if (ent.done) {
             continue;
         }
 
-        cmd.uuid = ent->uuid;
-        cmd.vbid = ent->vbid;
+        cmd.uuid = ent.uuid;
+        cmd.vbid = ent.vbid;
         cmd.cmdflags = LCB_CMD_F_INTERNAL_CALLBACK;
-        ent->callback = seqno_callback;
+        ent.callback = seqno_callback;
 
-        lcbdur_prepare_item(ent, servers, &nservers);
-        for (jj = 0; jj < nservers; jj++) {
+        size_t nservers = ent.prepare(servers);
+        for (size_t jj = 0; jj < nservers; jj++) {
             lcb_error_t err;
             cmd.server_index = servers[jj];
-            err = lcb_observe_seqno3(instance, &ent->callback, &cmd);
+            err = lcb_observe_seqno3(instance, &ent.callback, &cmd);
             if (err == LCB_SUCCESS) {
-                dset->waiting++;
-                has_ops = 1;
+                waiting++;
+                has_ops = true;
             } else {
-                RESFLD(ent, rc) = ret_err = err;
+                ent.res().rc = ret_err = err;
             }
         }
     }
@@ -119,8 +133,8 @@ seqno_poll(lcb_DURSET *dset)
     }
 }
 
-static lcb_error_t
-seqno_ent_add(lcb_DURSET *dset, lcb_DURITEM *item, const lcb_CMDENDURE *cmd)
+lcb_error_t
+SeqnoDurset::after_add(Item &item, const lcb_CMDENDURE *cmd)
 {
     const lcb_MUTATION_TOKEN *stok = NULL;
 
@@ -129,29 +143,21 @@ seqno_ent_add(lcb_DURSET *dset, lcb_DURITEM *item, const lcb_CMDENDURE *cmd)
     }
 
     if (stok == NULL) {
-        lcb_t instance = dset->instance;
         if (!instance->dcpinfo) {
             return LCB_DURABILITY_NO_MUTATION_TOKENS;
         }
-        if (item->vbid >= LCBT_VBCONFIG(instance)->nvb) {
+        if (item.vbid >= LCBT_VBCONFIG(instance)->nvb) {
             return LCB_EINVAL;
         }
-        stok = instance->dcpinfo + item->vbid;
+        stok = instance->dcpinfo + item.vbid;
         if (LCB_MUTATION_TOKEN_ID(stok) == 0) {
             return LCB_DURABILITY_NO_MUTATION_TOKENS;
         }
     }
 
     /* Set the fields */
-    memset(item->sinfo, 0, sizeof(item->sinfo[0]) * 4);
-    item->uuid = LCB_MUTATION_TOKEN_ID(stok);
-    ENT_SEQNO(item) = LCB_MUTATION_TOKEN_SEQ(stok);
+    memset(item.sinfo, 0, sizeof(item.sinfo[0]) * 4);
+    item.uuid = LCB_MUTATION_TOKEN_ID(stok);
+    ENT_SEQNO(&item) = LCB_MUTATION_TOKEN_SEQ(stok);
     return LCB_SUCCESS;
 }
-
-lcbdur_PROCS lcbdur_seqno_procs = {
-        seqno_poll,
-        seqno_ent_add,
-        NULL, /*schedule*/
-        NULL /*clean*/
-};