mt-libcouchbase 1.4.0

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,293 @@
+/* -*- 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 <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;
+    bool ipv6 = false;
+
+    /** 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 ( (delim = strstr(host_s, "://"))) {
+        host_s = delim + 3;
+    }
+
+    if ((delim = strstr(host_s, "/"))) {
+        *delim = '\0';
+    }
+
+    port_s = strstr(host_s, ":");
+    if (port_s != NULL && strstr(port_s + 1, ":") != NULL) {
+        ipv6 = true;
+        // treat as IPv6 address
+        if (host_s[0] == '[') {
+            host_s++;
+            char *hostend = strstr(host_s, "]");
+            if (hostend == NULL) {
+                return LCB_INVALID_HOST_FORMAT;
+            }
+            port_s = hostend + 1;
+            if (*port_s != ':' || (size_t)(port_s - host_s) >= strlen(host_s)) {
+                port_s = NULL;
+            }
+            *hostend = '\0';
+        } else {
+            port_s = NULL;
+        }
+    }
+    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;
+        case ':':
+        case '[':
+        case ']':
+            if (ipv6) {
+                break;
+            }
+        /* fallthrough */
+        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);
+    }
+    host->ipv6 = ipv6;
+
+    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 = {"", "", 0};
+    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 = {"", "", 0};
+        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;
+        if (host.ipv6) {
+            ss.append("[").append(host.host).append("]");
+        } else {
+            ss.append(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;
+}

data/ext/libcouchbase/src/hostlist.h

@@ -0,0 +1,160 @@
+/* -*- 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.
+ */
+
+#ifndef LCB_HOSTLIST_H
+#define LCB_HOSTLIST_H
+
+#include "config.h"
+#include <libcouchbase/couchbase.h>
+
+/**
+ * Structure representing a host. This contains the string representation
+ * of a host and a port.
+ */
+typedef struct lcb_host_st {
+    char host[NI_MAXHOST + 1];
+    char port[NI_MAXSERV + 1];
+    int ipv6;
+} lcb_host_t;
+
+#define LCB_HOST_FMT LCB_LOG_SPEC("%s%s%s:%s")
+#define LCB_HOST_ARG(__settings, __host)                                \
+    ((__settings && __settings->log_redaction) ? LCB_LOG_SD_OTAG : ""), \
+        ((__host)->ipv6 ? "[" : ""), (__host)->host, ((__host)->ipv6 ? "]" : ""), (__host)->port, \
+        ((__settings && __settings->log_redaction) ? LCB_LOG_SD_CTAG : "") \
+
+/**
+ * Structure representing a list of hosts. This has an internal iteration
+ * index which is used to cycle between 'good' and 'bad' hosts.
+ */
+#ifndef __cplusplus
+struct hostlist_st;
+typedef struct hostlist_st *hostlist_t;
+#else
+#include <vector>
+
+namespace lcb {
+struct Hostlist {
+    Hostlist() : ix(0) {}
+    ~Hostlist();
+
+    /**
+     * 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_]; }
+
+    std::vector<lcb_host_t> hosts;
+    std::vector<const char *> hoststrs;
+};
+}
+typedef lcb::Hostlist* hostlist_t;
+
+struct hostlist_st : lcb::Hostlist {
+    hostlist_st() : Hostlist() {
+    }
+};
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/**
+ * Parses a string into a hostlist
+ * @param host the target host to populate
+ * @param spec a string to parse. This may either be an IP/host or an
+ * IP:Port pair.
+ * @param speclen the length of the string. If this is -1 then it is assumed
+ * to be NUL-terminated and strlen will be used
+ * @param deflport If a port is not found in the spec, then this port will
+ * be used
+ *
+ * @return LCB_EINVAL if the host format is invalid
+ */
+lcb_error_t
+lcb_host_parse(lcb_host_t *host, const char *spec, int speclen, int deflport);
+
+/** Wrapper around lcb_host_parse() which accepts a NUL-terminated string
+ * @param host the host to populate
+ * @param spec a NUL-terminated string to parse
+ * @param deflport the default port to use if the `spec` does not contain a port
+ * @see lcb_host_parse()
+ */
+#define lcb_host_parsez(host, spec, deflport) lcb_host_parse(host, spec, -1, deflport)
+
+/**
+ * Compares two hosts for equality.
+ * @param a host to compare
+ * @param b other host to compare
+ * @return true if equal, false if different.
+ */
+int lcb_host_equals(const lcb_host_t *a, const lcb_host_t *b);
+
+#ifdef __cplusplus
+}
+#endif
+#endif