libcouchbase 1.0.4 → 1.1.0

data/ext/libcouchbase/contrib/cbsasl/src/hash.c

@@ -277,31 +277,31 @@ uint32_t cbsasl_hash(
             a += k[0] + (((uint32_t)k[1]) << 16);
             break;
         case 11:
-            c += ((uint32_t)k8[10]) << 16; /* @fallthrough */
+            c += ((uint32_t)k8[10]) << 16; /* fall through */
         case 10:
-            c += k[4];                     /* @fallthrough@ */
+            c += k[4];                     /* fall through */
             b += k[2] + (((uint32_t)k[3]) << 16);
             a += k[0] + (((uint32_t)k[1]) << 16);
             break;
         case 9 :
-            c += k8[8];                    /* @fallthrough */
+            c += k8[8];                    /* fall through */
         case 8 :
             b += k[2] + (((uint32_t)k[3]) << 16);
             a += k[0] + (((uint32_t)k[1]) << 16);
             break;
         case 7 :
-            b += ((uint32_t)k8[6]) << 16;  /* @fallthrough */
+            b += ((uint32_t)k8[6]) << 16;  /* fall through */
         case 6 :
             b += k[2];
             a += k[0] + (((uint32_t)k[1]) << 16);
             break;
         case 5 :
-            b += k8[4];                    /* @fallthrough */
+            b += k8[4];                    /* fall through */
         case 4 :
             a += k[0] + (((uint32_t)k[1]) << 16);
             break;
         case 3 :
-            a += ((uint32_t)k8[2]) << 16;  /* @fallthrough */
+            a += ((uint32_t)k8[2]) << 16;  /* fall through */
         case 2 :
             a += k[0];
             break;
@@ -337,27 +337,27 @@ uint32_t cbsasl_hash(
         /*-------------------------------- last block: affect all 32 bits of (c) */
         switch (length) {                /* all the case statements fall through */
         case 12:
-            c += ((uint32_t)k[11]) << 24;
+            c += ((uint32_t)k[11]) << 24;   /* fall through */
         case 11:
-            c += ((uint32_t)k[10]) << 16;
+            c += ((uint32_t)k[10]) << 16;   /* fall through */
         case 10:
-            c += ((uint32_t)k[9]) << 8;
+            c += ((uint32_t)k[9]) << 8;     /* fall through */
         case 9 :
-            c += k[8];
+            c += k[8];                      /* fall through */
         case 8 :
-            b += ((uint32_t)k[7]) << 24;
+            b += ((uint32_t)k[7]) << 24;    /* fall through */
         case 7 :
-            b += ((uint32_t)k[6]) << 16;
+            b += ((uint32_t)k[6]) << 16;    /* fall through */
         case 6 :
-            b += ((uint32_t)k[5]) << 8;
+            b += ((uint32_t)k[5]) << 8;     /* fall through */
         case 5 :
-            b += k[4];
+            b += k[4];                      /* fall through */
         case 4 :
-            a += ((uint32_t)k[3]) << 24;
+            a += ((uint32_t)k[3]) << 24;    /* fall through */
         case 3 :
-            a += ((uint32_t)k[2]) << 16;
+            a += ((uint32_t)k[2]) << 16;    /* fall through */
         case 2 :
-            a += ((uint32_t)k[1]) << 8;
+            a += ((uint32_t)k[1]) << 8;     /* fall through */
         case 1 :
             a += k[0];
             break;

data/ext/libcouchbase/contrib/cliopts/cliopts.c

@@ -103,6 +103,66 @@ cliopts_list_clear(cliopts_list *l)
     l->nalloc = 0;
 }
 
+static void
+add_pair_list_value(const char *src, size_t nsrc, cliopts_pair_list *l)
+{
+    char *key = NULL, *val = NULL;
+    char *sep = memchr(src, '=', nsrc);
+    if (sep == NULL) {
+        key = malloc(nsrc + 1);
+        memcpy(key, src, nsrc);
+        key[nsrc] = '\0';
+        val = malloc(1);
+        val[0] = '\0';
+    } else {
+        char *pp = sep;
+        size_t nkey = sep - src;
+        size_t nval = nsrc - nkey - 1;
+        for (; pp > src; pp--, nkey--) {
+            if (*pp != ' ' && *pp != '\t' && *pp != '\0') {
+                break;
+            }
+        }
+        key = malloc(nkey + 1);
+        memcpy(key, src, nkey);
+        key[nkey] = '\0';
+        val = malloc(nval + 1);
+        memcpy(val, sep + 1, nval);
+        val[nval] = '\0';
+    }
+
+    if (!l->nalloc) {
+        l->nalloc = 2;
+        l->keys = malloc(l->nalloc * sizeof(*l->keys));
+        l->values = malloc(l->nalloc * sizeof(*l->values));
+    } else {
+        l->nalloc *= 1.5;
+        l->keys = realloc(l->keys, sizeof(*l->keys) * l->nalloc);
+        l->values = realloc(l->values, sizeof(*l->values) * l->nalloc);
+    }
+
+    l->keys[l->nvalues] = key;
+    l->values[l->nvalues] = val;
+    l->nvalues++;
+}
+
+CLIOPTS_API
+void
+cliopts_pair_list_clear(cliopts_pair_list *l)
+{
+    size_t ii;
+    for (ii = 0; ii < l->nvalues; ii++) {
+        free(l->keys[ii]);
+        free(l->values[ii]);
+    }
+    free(l->keys);
+    free(l->values);
+    l->keys = NULL;
+    l->values = NULL;
+    l->nvalues = 0;
+    l->nalloc = 0;
+}
+
 /**
  * Various extraction/conversion functions for numerics
  */
@@ -230,6 +290,7 @@ parse_value(struct cliopts_priv *ctx,
         char *vp = malloc(vlen+1);
         vp[vlen] = 0;
         strcpy(vp, value);
+        free(*(char**)entry->dest);
         *(char**)entry->dest = vp;
         return WANT_OPTION;
     }
@@ -238,6 +299,10 @@ parse_value(struct cliopts_priv *ctx,
         add_list_value(value, vlen, (cliopts_list *)entry->dest);
         return WANT_OPTION;
     }
+    if (entry->ktype == CLIOPTS_ARGT_PAIR_LIST) {
+        add_pair_list_value(value, vlen, (cliopts_pair_list *)entry->dest);
+        return WANT_OPTION;
+    }
 
     if (entry->ktype == CLIOPTS_ARGT_FLOAT) {
         exfn = extract_float;
@@ -596,6 +661,17 @@ print_help(struct cliopts_priv *ctx, struct cliopts_extra_settings *settings)
                 }
                 break;
             }
+            case CLIOPTS_ARGT_PAIR_LIST: {
+                size_t ii;
+                cliopts_pair_list *l = (cliopts_pair_list *)cur->dest;
+                for (ii = 0; ii < l->nvalues; ii++) {
+                    fprintf(stderr, "'%s=%s'", l->keys[ii], l->values[ii]);
+                    if (ii != l->nvalues-1) {
+                        fprintf(stderr, ", ");
+                    }
+                }
+                break;
+            }
             case CLIOPTS_ARGT_FLOAT:
                 fprintf(stderr, "%0.2f", *(float*)cur->dest);
                 break;

data/ext/libcouchbase/contrib/cliopts/cliopts.h

@@ -47,7 +47,13 @@ typedef enum {
      * string. You can use this option type to build -Doption=value style
      * options which can be processed later on.
      */
-    CLIOPTS_ARGT_LIST
+    CLIOPTS_ARGT_LIST,
+
+    /**
+     * Destination should be cliopts_pair_list. Argument type is assumed to be a
+     * string with '=' separator in form of KEY=VALUE.
+     */
+    CLIOPTS_ARGT_PAIR_LIST
 } cliopts_argtype_t;
 
 typedef struct {
@@ -134,6 +140,19 @@ typedef struct {
     size_t nalloc;
 } cliopts_list;
 
+typedef struct {
+    /** Array of string pointers. Allocated via standard malloc functions */
+    char **keys;
+    /** Number of valid entries */
+    size_t nkeys;
+    /** Array of string pointers. Allocated via standard malloc functions */
+    char **values;
+    /** Number of valid entries */
+    size_t nvalues;
+    /** Number of entries allocated */
+    size_t nalloc;
+} cliopts_pair_list;
+
 /**
  * Clear a list of its contents
  * @param l The list
@@ -142,6 +161,14 @@ CLIOPTS_API
 void
 cliopts_list_clear(cliopts_list *l);
 
+/**
+ * Clear a pair list of its contents
+ * @param l The pair list
+ */
+CLIOPTS_API
+void
+cliopts_pair_list_clear(cliopts_pair_list *l);
+
 /**
  * Parse options.
  *
@@ -265,9 +292,9 @@ public:
     TOption(TOption& other) {
         *(cliopts_entry*)this = *(cliopts_entry*) &other;
         innerVal = other.innerVal;
-        dest = &innerVal;
         other.dest = NULL;
         doCopy(other);
+        dest = &innerVal;
     }
 
     ~TOption() {
@@ -292,6 +319,7 @@ public:
      * @return the option object, for method chaining.
      */
     inline Ttype& setDefault(const T& val) {
+        freeInnerVal();
         innerVal = val;
         return *this;
     }
@@ -349,16 +377,7 @@ protected:
     /** Called from within copy constructor */
     inline void doCopy(TOption&) {}
 
-    inline void freeInnerVal() {
-        switch (ktype) {
-            case CLIOPTS_ARGT_LIST:
-                cliopts_list_clear((cliopts_list *)&innerVal);
-                break;
-            default:
-                /* nothing to do */
-                break;
-        }
-    }
+    inline void freeInnerVal() {}
 
     /** Create the default value for the option */
     static inline Taccum createDefault() { return Taccum(); }
@@ -374,6 +393,11 @@ typedef TOption<std::vector<std::string>,
         cliopts_list,
         std::vector<std::string> > ListOption;
 
+typedef TOption<std::vector<std::pair<std::string, std::string> >,
+        CLIOPTS_ARGT_PAIR_LIST,
+        cliopts_pair_list,
+        std::vector<std::pair<std::string, std::string> > > PairListOption;
+
 typedef TOption<bool,
         CLIOPTS_ARGT_NONE,
         int> BoolOption;
@@ -408,18 +432,24 @@ template<> inline std::string& StringOption::const_result() {
 template<> inline std::string StringOption::result() {
     return const_result();
 }
+template<> inline void StringOption::freeInnerVal() {
+    free((void *)innerVal);
+    innerVal = NULL;
+}
 template<> inline StringOption& StringOption::setDefault(const std::string& s) {
     priv = s;
-    innerVal = priv.c_str();
+    freeInnerVal();
+    innerVal = strdup(priv.c_str());
     return *this;
 }
 template<> inline void StringOption::doCopy(StringOption& other) {
     priv = other.priv;
     if (other.innerVal == other.priv.c_str()) {
-        innerVal = priv.c_str();
+        freeInnerVal();
+        innerVal = strdup(priv.c_str());
     }
 }
-template<> inline const char* StringOption::createDefault() { return ""; }
+template<> inline const char* StringOption::createDefault() { return NULL; }
 
 // LIST ROUTINES
 template<> inline std::vector<std::string>& ListOption::const_result() {
@@ -433,6 +463,27 @@ template<> inline std::vector<std::string>& ListOption::const_result() {
 template<> inline std::vector<std::string> ListOption::result() {
     return const_result();
 }
+template<> inline void ListOption::freeInnerVal() { cliopts_list_clear(&innerVal); }
+
+struct PairListDtor {
+    static void call(void *arg) {
+        cliopts_pair_list_clear((cliopts_pair_list *)arg);
+    }
+};
+
+// PAIR LIST ROUTINES
+template<> inline std::vector<std::pair<std::string, std::string> >& PairListOption::const_result() {
+    if (priv.empty()) {
+        for (size_t ii = 0; ii < innerVal.nvalues; ii++) {
+            priv.push_back(std::make_pair(innerVal.keys[ii], innerVal.values[ii]));
+        }
+    }
+    return priv;
+}
+template<> inline std::vector<std::pair<std::string, std::string> > PairListOption::result() {
+    return const_result();
+}
+template<> inline void PairListOption::freeInnerVal() { cliopts_pair_list_clear(&innerVal); }
 
 // BOOL ROUTINES
 template<> inline BoolOption& BoolOption::setDefault(const bool& b) {

data/ext/libcouchbase/contrib/genhash/genhash.c

@@ -149,7 +149,6 @@ static struct genhash_entry_t *genhash_find_entry(genhash_t *h,
     n = h->ops.hashfunc(k, klen) % h->size;
     lcb_assert(n < h->size);
 
-    p = h->buckets[n];
     for (p = h->buckets[n]; p && !h->ops.hasheq(k, klen, p->key, p->nkey); p = p->next);
     return p;
 }
@@ -181,7 +180,7 @@ enum update_type genhash_update(genhash_t *h, const void *k, lcb_size_t klen,
         rv = MODIFICATION;
     } else {
         if (-1 == genhash_store(h, k, klen, v, vlen)) {
-            rv = ALLOC_FAILURE;
+            return ALLOC_FAILURE;
         }
         rv = NEW;
     }

data/ext/libcouchbase/contrib/lcb-jsoncpp/lcb-jsoncpp.cpp

@@ -1275,7 +1275,8 @@ bool OurReader::readToken(Token& token) {
     token.type_ = tokenString;
     ok = readStringSingleQuote();
     break;
-    } // else continue
+    }
+    /* falls through */
   case '/':
     token.type_ = tokenComment;
     ok = readComment();
@@ -2351,12 +2352,12 @@ RuntimeError::RuntimeError(std::string const& msg)
 LogicError::LogicError(std::string const& msg)
   : Exception(msg)
 {}
-void throwRuntimeError(std::string const& msg)
+void throwRuntimeError(std::string const& )
 {
     assert(false);
 //  throw RuntimeError(msg);
 }
-void throwLogicError(std::string const& msg)
+void throwLogicError(std::string const&)
 {
     assert(false);
 //  throw LogicError(msg);

data/ext/libcouchbase/example/instancepool/main.cc

@@ -70,7 +70,7 @@ pthr_func(void *arg) {
 }
 
 #define NUM_WORKERS 20
-int main(void) {
+int main(int argc, char *argv[]) {
     lcb_create_st options;
     pthread_t workers[NUM_WORKERS];
     Pool *pool;
@@ -79,7 +79,17 @@ int main(void) {
     // set up the options to represent your cluster (hostname etc)
     memset(&options, 0, sizeof options);
     options.version = 3;
-    options.v.v3.connstr = "couchbase://localhost/default";
+    options.v.v3.connstr = "couchbase://localhost";
+    if (argc > 1) {
+        options.v.v3.connstr = argv[1];
+    }
+    if (argc > 2) {
+        options.v.v3.passwd = argv[2];
+    }
+    if (argc > 3) {
+        options.v.v3.username = argv[3];
+    }
+
     pool = new MyPool(options, 5);
 
     err = pool->connect();

data/ext/libcouchbase/example/libeventdirect/main.c

@@ -15,6 +15,13 @@
  *   limitations under the License.
  */
 
+/**
+ * gcc -levent -lcouchbase main.c
+ *
+ * # perform STORE and 20 iterations of GET commands with interval 3 seconds
+ * ./a.out couchbase://localhost password Administrator 20 3
+ */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -22,17 +29,29 @@
 #include <libcouchbase/api3.h>
 #include <event2/event.h>
 
-static void
-bootstrap_callback(lcb_t instance, lcb_error_t err)
+const char key[] = "foo";
+lcb_SIZE nkey = sizeof(key);
+
+const char val[] = "{\"answer\":42}";
+lcb_SIZE nval = sizeof(val);
+
+int nreq = 1;
+int nresp = 1;
+int interval = 0;
+struct event *timer = NULL;
+
+static void bootstrap_callback(lcb_t instance, lcb_error_t err)
 {
-    lcb_CMDSTORE cmd = { 0 };
+    lcb_CMDSTORE cmd = {0};
     if (err != LCB_SUCCESS) {
         fprintf(stderr, "ERROR: %s\n", lcb_strerror(instance, err));
         exit(EXIT_FAILURE);
     }
+    printf("successfully bootstrapped\n");
+    fflush(stdout);
     /* Since we've got our configuration, let's go ahead and store a value */
-    LCB_CMD_SET_KEY(&cmd, "foo", 3);
-    LCB_CMD_SET_VALUE(&cmd, "bar", 3);
+    LCB_CMD_SET_KEY(&cmd, key, nkey);
+    LCB_CMD_SET_VALUE(&cmd, val, nval);
     cmd.operation = LCB_SET;
     err = lcb_store3(instance, NULL, &cmd);
     if (err != LCB_SUCCESS) {
@@ -49,32 +68,68 @@ static void get_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
         exit(EXIT_FAILURE);
     }
 
-    fprintf(stdout, "I stored and retrieved the key 'foo'. Value: %.*s. Terminate program\n", (int)rg->nvalue, rg->value);
-    event_base_loopbreak((void *)lcb_get_cookie(instance));
+    printf("%d. retrieved the key 'foo', value: %.*s\n", nresp, (int)rg->nvalue, rg->value);
+    fflush(stdout);
+    nresp--;
+    if (nresp == 0) {
+        printf("stopping the loop\n");
+        event_base_loopbreak((void *)lcb_get_cookie(instance));
+    }
     (void)cbtype;
 }
 
-static void store_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+static void schedule_timer();
+
+static void timer_callback(int fd, short event, void *arg)
 {
+    lcb_t instance = arg;
     lcb_error_t rc;
-    lcb_CMDGET gcmd =  { 0 };
+    lcb_CMDGET gcmd = {0};
 
-    if (rb->rc != LCB_SUCCESS) {
-        fprintf(stderr, "Failed to store key: %s\n", lcb_strerror(instance, rb->rc));
-        exit(EXIT_FAILURE);
-    }
-
-    LCB_CMD_SET_KEY(&gcmd, rb->key, rb->nkey);
+    LCB_CMD_SET_KEY(&gcmd, key, nkey);
     rc = lcb_get3(instance, NULL, &gcmd);
     if (rc != LCB_SUCCESS) {
         fprintf(stderr, "Failed to schedule get request: %s\n", lcb_strerror(NULL, rc));
         exit(EXIT_FAILURE);
     }
+    (void)fd;
+    (void)event;
+    schedule_timer();
+}
+
+static void schedule_timer()
+{
+    struct timeval tv;
+
+    if (!nreq) {
+        return;
+    }
+    tv.tv_sec = interval;
+    tv.tv_usec = 0;
+    evtimer_add(timer, &tv);
+    nreq--;
+}
+
+static void store_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+{
+    if (rb->rc != LCB_SUCCESS) {
+        fprintf(stderr, "Failed to store key: %s\n", lcb_strerror(instance, rb->rc));
+        exit(EXIT_FAILURE);
+    }
+    printf("stored key 'foo'\n");
+    fflush(stdout);
+    {
+        struct event_base *evbase = (struct event_base *)lcb_get_cookie(instance);
+
+        printf("try to get value %d times with %dsec interval\n", nreq, interval);
+        timer = evtimer_new(evbase, timer_callback, instance);
+        schedule_timer();
+    }
+
     (void)cbtype;
 }
 
-static lcb_io_opt_t
-create_libevent_io_ops(struct event_base *evbase)
+static lcb_io_opt_t create_libevent_io_ops(struct event_base *evbase)
 {
     struct lcb_create_io_ops_st ciops;
     lcb_io_opt_t ioops;
@@ -93,8 +148,7 @@ create_libevent_io_ops(struct event_base *evbase)
     return ioops;
 }
 
-static lcb_t
-create_libcouchbase_handle(lcb_io_opt_t ioops)
+static lcb_t create_libcouchbase_handle(lcb_io_opt_t ioops, int argc, char **argv)
 {
     lcb_t instance;
     lcb_error_t error;
@@ -103,8 +157,17 @@ create_libcouchbase_handle(lcb_io_opt_t ioops)
     memset(&copts, 0, sizeof(copts));
 
     /* If NULL, will default to localhost */
-    copts.v.v0.host = getenv("LCB_EVENT_SERVER");
-    copts.v.v0.io = ioops;
+    copts.version = 3;
+    if (argc > 1) {
+        copts.v.v3.connstr = argv[1];
+    }
+    if (argc > 2) {
+        copts.v.v3.passwd = argv[2];
+    }
+    if (argc > 3) {
+        copts.v.v3.username = argv[3];
+    }
+    copts.v.v3.io = ioops;
     error = lcb_create(&instance, &copts);
 
     if (error != LCB_SUCCESS) {
@@ -128,12 +191,18 @@ create_libcouchbase_handle(lcb_io_opt_t ioops)
 
 /* This example shows how we can hook ourself into an external event loop.
  * You may find more information in the blogpost: http://goo.gl/fCTrX */
-int main(void)
+int main(int argc, char **argv)
 {
     struct event_base *evbase = event_base_new();
     lcb_io_opt_t ioops = create_libevent_io_ops(evbase);
-    lcb_t instance = create_libcouchbase_handle(ioops);
+    lcb_t instance = create_libcouchbase_handle(ioops, argc, argv);
 
+    if (argc > 4) {
+        nreq = nresp = atoi(argv[4]);
+    }
+    if (argc > 5) {
+        interval = atoi(argv[4]);
+    }
     /*Store the event base as the user cookie in our instance so that
      * we may terminate the program when we're done */
     lcb_set_cookie(instance, evbase);
@@ -142,7 +211,12 @@ int main(void)
     event_base_loop(evbase, 0);
 
     /* Cleanup */
-    event_base_free(evbase);
     lcb_destroy(instance);
-    exit(EXIT_SUCCESS);
+    if (timer) {
+        evtimer_del(timer);
+    }
+    lcb_destroy_io_ops(ioops);
+    event_base_free(evbase);
+
+    return EXIT_SUCCESS;
 }