libcouchbase 0.0.1

data/ext/libcouchbase/src/hashset.c

@@ -0,0 +1,164 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2012 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "internal.h"
+
+static const unsigned int prime_1 = 73;
+static const unsigned int prime_2 = 5009;
+
+hashset_t hashset_create()
+{
+    hashset_t set = calloc(1, sizeof(struct hashset_st));
+
+    if (set == NULL) {
+        return NULL;
+    }
+    set->nbits = 3;
+    set->capacity = (lcb_size_t)(1 << set->nbits);
+    set->mask = set->capacity - 1;
+    set->items = calloc(set->capacity, sizeof(lcb_size_t));
+    if (set->items == NULL) {
+        hashset_destroy(set);
+        return NULL;
+    }
+    set->nitems = 0;
+    return set;
+}
+
+lcb_size_t hashset_num_items(hashset_t set)
+{
+    return set->nitems;
+}
+
+void hashset_destroy(hashset_t set)
+{
+    if (set) {
+        free(set->items);
+    }
+    free(set);
+}
+
+static int hashset_add_member(hashset_t set, void *item)
+{
+    lcb_size_t value = (lcb_size_t)item;
+    lcb_size_t ii;
+
+    if (value == 0 || value == 1) {
+        return -1;
+    }
+
+    ii = set->mask & (prime_1 * value);
+
+    while (set->items[ii] != 0 && set->items[ii] != 1) {
+        if (set->items[ii] == value) {
+            return 0;
+        } else {
+            /* search free slot */
+            ii = set->mask & (ii + prime_2);
+        }
+    }
+    set->nitems++;
+    set->items[ii] = value;
+    return 1;
+}
+
+static void maybe_rehash(hashset_t set)
+{
+    lcb_size_t *old_items;
+    lcb_size_t old_capacity, ii;
+
+
+    if ((float)set->nitems >= (lcb_size_t)((double)set->capacity * 0.85)) {
+        old_items = set->items;
+        old_capacity = set->capacity;
+        set->nbits++;
+        set->capacity = (lcb_size_t)(1 << set->nbits);
+        set->mask = set->capacity - 1;
+        set->items = calloc(set->capacity, sizeof(lcb_size_t));
+        set->nitems = 0;
+        lcb_assert(set->items);
+        for (ii = 0; ii < old_capacity; ii++) {
+            hashset_add_member(set, (void *)old_items[ii]);
+        }
+        free(old_items);
+    }
+}
+
+int hashset_add(hashset_t set, void *item)
+{
+    int rv = hashset_add_member(set, item);
+    maybe_rehash(set);
+    return rv;
+}
+
+int hashset_remove(hashset_t set, void *item)
+{
+    lcb_size_t value = (lcb_size_t)item;
+    lcb_size_t ii = set->mask & (prime_1 * value);
+
+    while (set->items[ii] != 0) {
+        if (set->items[ii] == value) {
+            set->items[ii] = 1;
+            set->nitems--;
+            return 1;
+        } else {
+            ii = set->mask & (ii + prime_2);
+        }
+    }
+    return 0;
+}
+
+int hashset_is_member(hashset_t set, void *item)
+{
+    lcb_size_t value = (lcb_size_t)item;
+    lcb_size_t ii = set->mask & (prime_1 * value);
+
+    while (set->items[ii] != 0) {
+        if (set->items[ii] == value) {
+            return 1;
+        } else {
+            ii = set->mask & (ii + prime_2);
+        }
+    }
+    return 0;
+}
+
+void **hashset_get_items(hashset_t set, void **itemlist)
+{
+    lcb_size_t ii, oix;
+
+    if (!set->nitems) {
+        return NULL;
+    }
+
+    if (!itemlist) {
+        itemlist = malloc(set->nitems * sizeof(void *));
+        if (!itemlist) {
+            return NULL;
+        }
+    }
+
+    for (ii = 0, oix = 0; ii < set->capacity; ii++) {
+
+        if (set->items[ii] > 1) {
+            itemlist[oix] = (void *)set->items[ii];
+            oix++;
+        }
+    }
+
+    return itemlist;
+}

data/ext/libcouchbase/src/hashset.h

@@ -0,0 +1,86 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2012 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#ifndef LIBCOUCHBASE_HASHSET_H
+#define LIBCOUCHBASE_HASHSET_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    struct hashset_st {
+        lcb_size_t nbits;
+        lcb_size_t mask;
+
+        lcb_size_t capacity;
+        lcb_size_t *items;
+        lcb_size_t nitems;
+    };
+
+    typedef struct hashset_st *hashset_t;
+
+    /* create hashset instance */
+    hashset_t hashset_create(void);
+
+    /* destroy hashset instance */
+    void hashset_destroy(hashset_t set);
+
+    lcb_size_t hashset_num_items(hashset_t set);
+
+    /**
+     * Makes a list of items inside the hashset.
+     * @param set the hashset
+     * @param itemlist an allocated array large enough to hold the number
+     * of items in the hashset (use hashset_num_items). If this is NULL
+     * then a list is allocated for you
+     *
+     * @return the item list. If the @itemlist param argument was
+     * not-null, then this is the same list; if it was NULL then this
+     * is an allocated list which should be released using @itemlist
+     * free(). It will return NULL if the hashset is empty or memory
+     * allocation for @itemlist was failed.
+     */
+    void **hashset_get_items(hashset_t set, void **itemlist);
+
+
+    /* add item into the hashset.
+     *
+     * @note 0 and 1 is special values, meaning nil and deleted items. the
+     *       function will return -1 indicating error.
+     *
+     * returns zero if the item already in the set and non-zero otherwise
+     */
+    int hashset_add(hashset_t set, void *item);
+
+    /* remove item from the hashset
+     *
+     * returns non-zero if the item was removed and zero if the item wasn't
+     * exist
+     */
+    int hashset_remove(hashset_t set, void *item);
+
+    /* check if existence of the item
+     *
+     * returns non-zero if the item exists and zero otherwise
+     */
+    int hashset_is_member(hashset_t set, void *item);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/libcouchbase/src/hashtable.c

@@ -0,0 +1,75 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2013 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "internal.h"
+#include "contrib/genhash/genhash.h"
+
+/**
+ * Structures for common hash table operations
+ */
+
+static int hasheq(const void *a, lcb_size_t n_a, const void *b, lcb_size_t n_b)
+{
+    if (n_a != n_b) {
+        return 0;
+    }
+
+    return memcmp(a, b, n_a) == 0;
+}
+/**
+ * Structure for a no-copy hash table
+ */
+static struct lcb_hash_ops hashops_nocopy = {
+    genhash_string_hash, /* hashfunc */
+    hasheq, /* hasheq */
+    NULL, /* dupKey */
+    NULL, /* dupValue */
+    NULL, /* freeKey */
+    NULL, /* freeValue */
+};
+
+genhash_t *lcb_hashtable_nc_new(lcb_size_t est)
+{
+    return genhash_init(est, hashops_nocopy);
+}
+
+
+static int u32_hash(const void *p, lcb_size_t n)
+{
+    (void)p;
+    return n;
+}
+
+static int u32_eq(const void *a, lcb_size_t n_a, const void *b, lcb_size_t n_b)
+{
+    (void)a; (void)b;
+    return n_a == n_b;
+}
+
+static struct lcb_hash_ops hashops_u32 = {
+        u32_hash,
+        u32_eq,
+        NULL,
+        NULL,
+        NULL,
+        NULL
+};
+
+genhash_t *lcb_hashtable_szt_new(lcb_size_t est)
+{
+    return genhash_init(est, hashops_u32);
+}

data/ext/libcouchbase/src/hdr_timings.c

@@ -0,0 +1,92 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2016 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+/* High dynamic range timings, using HdrHistogram
+ * (http://hdrhistogram.github.io/HdrHistogram/), specifically the
+ * C implementation (https://github.com/HdrHistogram/HdrHistogram_c)
+ *
+ * hdr_timings.c is a rrop-in replacment for timings.c - you only want one of
+ * the two files.
+ */
+
+#include "internal.h"
+
+#include "hdr_histogram.h"
+
+struct lcb_histogram_st {
+    struct hdr_histogram* hdr_histogram;
+};
+
+LCB_INTERNAL_API
+lcb_HISTOGRAM *
+lcb_histogram_create(void)
+{
+    lcb_HISTOGRAM* histo = calloc(1, sizeof(struct lcb_histogram_st));
+
+    if (histo != NULL) {
+        hdr_init(/* minimum - 1 ns*/ 1,
+                 /* maximum - 30 s*/ 30e9,
+                 /* s   ignificant figures */3,
+                 &histo->hdr_histogram);
+    }
+
+    return histo;
+}
+
+LCB_INTERNAL_API
+void
+lcb_histogram_destroy(lcb_HISTOGRAM *hg)
+{
+    free(hg->hdr_histogram);
+    free(hg);
+}
+
+LCB_INTERNAL_API
+void
+lcb_histogram_read(const lcb_HISTOGRAM *hg,
+    const void *cookie, lcb_HISTOGRAM_CALLBACK callback)
+{
+    struct hdr_iter iter;
+    hdr_iter_recorded_init(&iter, hg->hdr_histogram);
+
+    while (hdr_iter_next(&iter)) {
+        callback(cookie, LCB_TIMEUNIT_NSEC,
+                 iter.value_iterated_from, iter.value_iterated_to,
+                 iter.count,
+                 hdr_max(hg->hdr_histogram));
+
+    }
+}
+
+LCB_INTERNAL_API
+lcb_error_t lcb_histogram_print(lcb_HISTOGRAM* hg, FILE* stream) {
+    hdr_percentiles_print(
+        hg->hdr_histogram,
+        stream,
+        5,  // Granularity of printed values
+        1.0,  // Multiplier for results
+        CLASSIC);  // Format CLASSIC/CSV supported.
+
+    return LCB_SUCCESS;
+}
+
+LCB_INTERNAL_API
+void
+lcb_histogram_record(lcb_HISTOGRAM *hg, lcb_U64 delta)
+{
+    hdr_record_value(hg->hdr_histogram, delta);
+}

data/ext/libcouchbase/src/hostlist.cc

@@ -0,0 +1,301 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2013 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "hostlist.h"
+#include "simplestring.h"
+#include <stdio.h>
+#include <ctype.h>
+#include <limits.h>
+#include <algorithm>
+#include <string>
+
+using namespace lcb;
+
+
+Hostlist::~Hostlist()
+{
+    reset_strlist();
+}
+
+void
+Hostlist::reset_strlist()
+{
+    for (size_t ii = 0; ii < hoststrs.size(); ++ii) {
+        if (hoststrs[ii] != NULL) {
+            delete[] hoststrs[ii];
+        }
+    }
+    hoststrs.clear();
+}
+
+lcb_error_t
+lcb_host_parse(lcb_host_t *host, const char *spec, int speclen, int deflport)
+{
+    std::vector<char> zspec;
+    char *host_s;
+    char *port_s;
+    char *delim;
+
+    /** Parse the host properly */
+    if (speclen < 0) {
+        speclen = strlen(spec);
+    } else if (speclen == 0) {
+        return LCB_INVALID_HOST_FORMAT;
+    }
+
+    if (deflport < 1) {
+        return LCB_INVALID_HOST_FORMAT;
+    }
+
+    zspec.assign(spec, spec + speclen);
+    zspec.push_back('\0');
+    host_s = &zspec[0];
+
+    if (*host_s == ':') {
+        return LCB_INVALID_HOST_FORMAT;
+    }
+
+    if ( (delim = strstr(host_s, "://"))) {
+        host_s = delim + 3;
+    }
+
+    if ((delim = strstr(host_s, "/"))) {
+        *delim = '\0';
+    }
+
+    port_s = strstr(host_s, ":");
+    if (port_s != NULL) {
+        char *endp;
+        long ll;
+
+        *port_s = '\0';
+        port_s++;
+
+        if (! *port_s) {
+            return LCB_INVALID_HOST_FORMAT;
+        }
+
+        ll = strtol(port_s, &endp, 10);
+        if (ll == LONG_MIN || ll == LONG_MAX) {
+            return LCB_INVALID_HOST_FORMAT;
+        }
+
+        if (*endp) {
+            return LCB_INVALID_HOST_FORMAT;
+        }
+
+    } else {
+        port_s = const_cast<char*>("");
+    }
+
+
+    if (strlen(host_s) > sizeof(host->host)-1 ||
+            strlen(port_s) > sizeof(host->port)-1 ||
+            *host_s == '\0') {
+        return LCB_INVALID_HOST_FORMAT;
+    }
+
+    size_t ii, hostlen = strlen(host_s);
+    for (ii = 0; ii < hostlen; ii++) {
+        if (isalnum(host_s[ii])) {
+            continue;
+        }
+        switch (host_s[ii]) {
+        case '.':
+        case '-':
+        case '_':
+            break;
+        default:
+            return LCB_INVALID_HOST_FORMAT;
+        }
+    }
+
+    strcpy(host->host, host_s);
+    if (*port_s) {
+        strcpy(host->port, port_s);
+    } else {
+        sprintf(host->port, "%d", deflport);
+    }
+
+    return LCB_SUCCESS;
+}
+
+int lcb_host_equals(const lcb_host_t *a, const lcb_host_t *b)
+{
+    return strcmp(a->host, b->host) == 0 && strcmp(a->port, b->port) == 0;
+}
+
+bool
+Hostlist::exists(const lcb_host_t& host) const
+{
+    for (size_t ii = 0; ii < hosts.size(); ++ii) {
+        if (lcb_host_equals(&host, &hosts[ii])) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool
+Hostlist::exists(const char *s) const
+{
+    lcb_host_t tmp;
+    if (lcb_host_parse(&tmp, s, -1, 1) != LCB_SUCCESS) {
+        return false;
+    }
+    return exists(tmp);
+}
+
+void
+Hostlist::add(const lcb_host_t& host)
+{
+    if (exists(host)) {
+        return;
+    }
+    hosts.push_back(host);
+    reset_strlist();
+}
+
+lcb_error_t
+Hostlist::add(const char *hostport, long len, int deflport)
+{
+    lcb_error_t err = LCB_SUCCESS;
+
+    if (len < 0) {
+        len = strlen(hostport);
+    }
+
+    std::string ss(hostport, len);
+    if (ss.empty()) {
+        return LCB_SUCCESS;
+    }
+    if (ss[ss.length()-1] != ';') {
+        ss += ';';
+    }
+
+    const char *curstart = ss.c_str();
+    const char *delim;
+    while ( (delim = strstr(curstart, ";"))) {
+        lcb_host_t curhost;
+        size_t curlen;
+
+        if (delim == curstart) {
+            curstart++;
+            continue;
+        }
+
+        /** { 'f', 'o', 'o', ';' } */
+        curlen = delim - curstart;
+
+        err = lcb_host_parse(&curhost, curstart, curlen, deflport);
+        if (err != LCB_SUCCESS) {
+            return err;
+        }
+        add(curhost);
+        curstart = delim + 1;
+    }
+    return LCB_SUCCESS;
+}
+
+lcb_host_t *
+Hostlist::next(bool wrap)
+{
+    lcb_host_t *ret;
+    if (empty()) {
+        return NULL;
+    }
+    if (ix == size()) {
+        if (wrap) {
+            ix = 0;
+        } else {
+            return NULL;
+        }
+    }
+
+    ret = &hosts[ix];
+    ix++;
+    return ret;
+}
+
+void
+Hostlist::randomize()
+{
+    std::random_shuffle(hosts.begin(), hosts.end());
+    reset_strlist();
+}
+
+void Hostlist::ensure_strlist() {
+    if (hoststrs.size()) {
+        return;
+    }
+    for (size_t ii = 0; ii < hosts.size(); ii++) {
+        const lcb_host_t& host = hosts[ii];
+        std::string ss(host.host);
+        ss.append(":").append(host.port);
+        char *newstr = new char[ss.size() + 1];
+        newstr[ss.size()] = '\0';
+        memcpy(newstr, ss.c_str(), ss.size());
+        hoststrs.push_back(newstr);
+    }
+    hoststrs.push_back(NULL);
+}
+
+Hostlist&
+Hostlist::assign(const Hostlist& src)
+{
+    clear();
+    reset_strlist();
+    for (size_t ii = 0; ii < src.size(); ++ii) {
+        add(src.hosts[ii]);
+    }
+    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;
+    }
+}
+}