mt-libcouchbase 1.4.0

data/ext/libcouchbase/include/libcouchbase/ixmgmt.h

@@ -0,0 +1,263 @@
+/* -*- 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.
+ */
+
+#ifndef LCB_IXMGMT_H
+#define LCB_IXMGMT_H
+
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/n1ql.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @volatile
+ *
+ * Structure representing a single index definition
+ */
+typedef struct {
+    /**
+     * Raw JSON returned from server.
+     * Can be used to decode fields in future versions not present within the
+     * library.
+     *
+     * This field can also be used as an input field to populate the other
+     * fields in this structure. This means that if you have a raw JSON
+     * representation of an index, you need only set this field (and
+     * `nrawjson`). The library will internally parse the raw JSON and
+     * populate the internal equivalents of the fields in this structure.
+     *
+     * Note that when using this field as an input for creating indexes, you
+     * should still set the @ref flags field if you wish to set flags (e.g. in
+     * order to create a deferred-build index).
+     */
+    const char *rawjson;
+    size_t nrawjson;
+
+    /** Name of the index. For raw JSON, use the `name` propery */
+    const char *name;
+    size_t nname;
+
+    /**
+     * Keyspace or "bucket" of the index. For raw JSON, use the
+     * `keyspace_id` property
+     */
+    const char *keyspace;
+    size_t nkeyspace;
+
+    /** 'namespace'. Currently unused */
+    const char *nspace;
+    size_t nnspace;
+
+    /** Output parameter only. State of index */
+    const char *state;
+    size_t nstate;
+
+    /** Actual index text. For raw JSON use the `index_key` property.
+     * The value for this field is a properly-encoded JSON array of fields
+     * to index. e.g.
+     *
+     * @code{c}
+     * spec.fields = "[\"`name`\", \"`email`\", \"`ctime`\"]"
+     * @endcode
+     */
+    const char *fields;
+    size_t nfields;
+
+    /**Indexing condition. If set, only field values matching this condition
+     * will be indexed */
+    const char *cond;
+    size_t ncond;
+
+    /**
+     * Modifiers for the index itself. This might be
+     * LCB_N1XSPEC_F_PRIMARY if the index is primary. For raw JSON,
+     * use `"is_primary":true`
+     *
+     * For creation the LCB_N1XSPEC_F_DEFER option is also accepted to
+     * indicate that the building of this index should be deferred.
+     */
+    unsigned flags;
+
+    /**
+     * Type of this index, Can be LCB_N1XSPEC_T_DEFAULT for the default
+     * server type, or an explicit LCB_N1XSPEC_T_GSI or LCB_N1XSPEC_T_VIEW.
+     * When using JSON, specify `"using":"gsi"`
+     */
+    unsigned ixtype;
+} lcb_N1XSPEC;
+
+/** Input/Output flag. The index is the primary index for the bucket */
+#define LCB_N1XSPEC_F_PRIMARY (1 << 16)
+
+/**
+ * Input flag for creation. Defer the index building until later. This may
+ * be used to accelerate the building of multiple indexes, so that the index
+ * builder can construct all indexes by scanning items only once
+ */
+#define LCB_N1XSPEC_F_DEFER (1 << 17)
+
+/**
+ * Input for index type. It's best to just leave this value to 0 (DEFAULT)
+ * unless you know what you're doing.
+ */
+#define LCB_N1XSPEC_T_DEFAULT 0
+#define LCB_N1XSPEC_T_GSI 1
+#define LCB_N1XSPEC_T_VIEW 2
+
+struct lcb_RESPN1XMGMT_st;
+
+/**
+ * Callback for index management operations
+ * @param instance
+ * @param cbtype - set to LCB_CALLBACK_N1XMGMT
+ * @param resp the response structure
+ */
+typedef void (*lcb_N1XMGMTCALLBACK)(lcb_t instance,
+        int cbtype, const struct lcb_RESPN1XMGMT_st *resp);
+
+/**
+ * @volatile
+ * Command for index management operations
+ */
+typedef struct {
+    /**
+     * The index to operate on. This can either be a full definition
+     * (when creating an index)
+     * or a partial definition (when listing or building
+     * indexes)
+     */
+    lcb_N1XSPEC spec;
+
+    /**
+     * Callback to be invoked when operation is complete.
+     */
+    lcb_N1XMGMTCALLBACK callback;
+} lcb_CMDN1XMGMT;
+
+/**
+ * @volatile
+ *
+ * Response structure for index management operations
+ */
+typedef struct lcb_RESPN1XMGMT_st {
+    LCB_RESP_BASE
+
+    /**
+     * A list of pointers to specs. This isn't a simple array of specs because
+     * the spec structure internally is backed by additional internal data.
+     */
+    const lcb_N1XSPEC *const *specs;
+    /** Number of specs */
+    size_t nspecs;
+
+    /** Inner N1QL response. Examine on error */
+    const lcb_RESPN1QL *inner;
+} lcb_RESPN1XMGMT;
+
+/**
+ * @volatile
+ *
+ * Retrieve a list of all indexes in the cluster. If lcb_CMDN1XMGMT::spec
+ * contains entries then the search will be limited to the appropriate criteria.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1x_list(lcb_t instance, const void *cookie, const lcb_CMDN1XMGMT *cmd);
+
+/**
+ * @volatile
+ *
+ * Create an index. The index can either be a primary or secondary index, and
+ * it may be created immediately or it may be deferred.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1x_create(lcb_t instance, const void *cookie, const lcb_CMDN1XMGMT *cmd);
+
+/**
+ * @volatile
+ * Remove an index.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1x_drop(lcb_t instance, const void *cookie, const lcb_CMDN1XMGMT *cmd);
+
+/**
+ * @volatile
+ *
+ * Build defered indexes. This may be used with the @ref LCB_N1XSPEC_F_DEFER
+ * option (see lcb_n1x_create()) to initiate the background creation of
+ * indexes.
+ *
+ * lcb_n1x_watchbuild may be used to wait on the status of those indexes.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1x_startbuild(lcb_t instance, const void *cookie, const lcb_CMDN1XMGMT *cmd);
+
+/**
+ * @volatile
+ *
+ * Structure used for polling index building statuses
+ */
+typedef struct {
+    /**
+     * Input specs. This should be the specs received from lcb_n1x_startbuild()'s
+     * callback. If you are building from scratch, only the lcb_N1XSPEC::rawjson
+     * and lcb_INDEXSPEC::nrawjson need to be populated
+     */
+    const lcb_N1XSPEC * const *specs;
+    /** Number of specs */
+    size_t nspec;
+
+    /**
+     * Maximum amount of time to wait (microseconds).
+     * If not specified, the default is 30 seconds (30 * 100000)
+     */
+    lcb_U32 timeout;
+
+    /**
+     * How often to check status (microseconds).
+     * Default is 500 milliseconds (500000)
+     */
+    lcb_U32 interval;
+
+    /**
+     * Callback to invoke once the indexes have been built or the timeout
+     * has been reached.
+     *
+     * The callback is only invoked once.
+     */
+    lcb_N1XMGMTCALLBACK callback;
+} lcb_CMDN1XWATCH;
+
+/**
+ * @volatile
+ * Poll indexes being built. This allows you to wait until the specified indexes
+ * which are being built (using lcb_n1x_startbuild()) have been fully
+ * created.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1x_watchbuild(lcb_t instance, const void *cookie, const lcb_CMDN1XWATCH *cmd);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* LCB_IXMGMT_H */

data/ext/libcouchbase/include/libcouchbase/kvbuf.h

@@ -0,0 +1,137 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014 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_KVBUF_H
+#define LCB_KVBUF_H
+
+/**
+ * @file
+ *
+ * Low level structures used by commands for buffers.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** @brief Flags indicating the storage policy for a buffer */
+typedef enum {
+    LCB_KV_COPY = 0, /**< The buffer should be copied */
+    LCB_KV_CONTIG, /**< The buffer is contiguous and should not be copied */
+    LCB_KV_IOV, /**< The buffer is not contiguous and should not be copied */
+
+    /**For use within the hashkey field, indicates that the _length_
+     * of the hashkey is the vBucket ID, rather than an actual hashkey */
+    LCB_KV_VBID,
+
+    /**
+     * The buffers are not contiguous (multi-part buffers) but should be
+     * copied. This avoids having to make the buffers contiguous before
+     * passing it into the library (only to have the library copy it again) */
+    LCB_KV_IOVCOPY,
+
+    /**
+     * For use within the hashkey field, indicates that the _pointer to bytes_
+     * of the hashkey is the tracing span, rather than an actual hashkey */
+    LCB_KV_TRACESPAN
+} lcb_KVBUFTYPE;
+
+#define LCB_KV_HEADER_AND_KEY LCB_KV_CONTIG
+
+/**
+ * @brief simple buf/length structure for a contiguous series of bytes
+ */
+typedef struct lcb_CONTIGBUF {
+    const void *bytes;
+    /** Number of total bytes */
+    lcb_size_t nbytes;
+} lcb_CONTIGBUF;
+
+/** @brief Common request header for all keys */
+typedef struct lcb_KEYBUF {
+    /**
+     * The type of key to provide. This can currently be LCB_KV_COPY (Default)
+     * to copy the key into the pipeline buffers, or LCB_KV_HEADER_AND_KEY
+     * to provide a buffer with the header storage and the key.
+     *
+     * TODO:
+     * Currently only LCB_KV_COPY should be used. LCB_KV_HEADER_AND_KEY is used
+     * internally but may be exposed later on
+     */
+    lcb_KVBUFTYPE type;
+    lcb_CONTIGBUF contig;
+} lcb_KEYBUF;
+
+/**@private*/
+#define LCB_KEYBUF_IS_EMPTY(k) (k)->contig.nbytes == 0
+
+/**
+ * @brief Initialize a contiguous request backed by a buffer which should be
+ * copied
+ * @param req the key request to initialize
+ * @param k the key to copy
+ * @param nk the size of the key
+ */
+#define LCB_KREQ_SIMPLE(req, k, nk) do { \
+    (req)->type = LCB_KV_COPY; \
+    (req)->contig.bytes = k; \
+    (req)->contig.nbytes = nk; \
+} while (0);
+
+/**
+ * Structure for an IOV buffer to be supplied as a buffer. This is currently
+ * only used for value buffers
+ */
+typedef struct lcb_FRAGBUF {
+    /** An IOV array */
+    lcb_IOV *iov;
+
+    /** Number of elements in iov array */
+    unsigned int niov;
+
+    /**
+     * Total length of the items. This should be set, if known, to prevent the
+     * library from manually traversing the iov array to calculate the length.
+     */
+    unsigned int total_length;
+} lcb_FRAGBUF;
+
+/** @brief Structure representing a value to be stored */
+typedef struct lcb_VALBUF {
+    /**
+     * Value request type. This may be one of:
+     * - LCB_KV_COPY: Copy over the value into LCB's own buffers
+     *   Use the 'contig' field to supply the information.
+     *
+     * - LCB_KV_CONTIG: The buffer is a contiguous chunk of value data.
+     *   Use the 'contig' field to supply the information.
+     *
+     * - LCB_KV_IOV: The buffer is a series of IOV elements. Use the 'multi'
+     *   field to supply the information.
+     */
+    lcb_KVBUFTYPE vtype;
+    union {
+        lcb_CONTIGBUF contig;
+        lcb_FRAGBUF multi;
+    } u_buf;
+} lcb_VALBUF;
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/libcouchbase/include/libcouchbase/metrics.h

@@ -0,0 +1,79 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2017 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_METRICS_H
+#define LCB_METRICS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct lcb_METRICS_st;
+
+typedef struct lcb_IOMETRICS_st {
+    const char *hostport;
+    lcb_SIZE io_close;
+    lcb_SIZE io_error;
+    lcb_SIZE bytes_sent;
+    lcb_SIZE bytes_received;
+} lcb_IOMETRICS;
+
+typedef struct lcb_SERVERMETRICS_st {
+    /** IO Metrics for the underlying socket */
+    lcb_IOMETRICS iometrics;
+
+    /** Number of packets sent on this server */
+    lcb_SIZE packets_sent;
+
+    /** Number of packets read on this server */
+    lcb_SIZE packets_read;
+
+    /** Total number of packets placed in send queue */
+    lcb_SIZE packets_queued;
+
+    /** Total number of bytes placed in send queue */
+    lcb_SIZE bytes_queued;
+
+    /**
+     * Number of packets which failed on this server (i.e. as a result
+     * of a timeout/network error or similar)
+     */
+    lcb_SIZE packets_errored;
+
+    /** Number of packets which timed out. Subset of packets_errored */
+    lcb_SIZE packets_timeout;
+
+    /** Number of packets received which were timed out or otherwise cancelled */
+    lcb_SIZE packets_ownerless;
+
+    /** Number of NOT_MY_VBUCKET replies received */
+    lcb_SIZE packets_nmv;
+} lcb_SERVERMETRICS;
+
+typedef struct lcb_METRICS_st {
+    lcb_SIZE nservers;
+    const lcb_SERVERMETRICS **servers;
+
+    /** Number of times a packet entered the retry queue */
+    lcb_SIZE packets_retried;
+} lcb_METRICS;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif