couchbase.h

Go to the documentation of this file.

/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2010-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 LIBCOUCHBASE_COUCHBASE_H
#define LIBCOUCHBASE_COUCHBASE_H 1

#define LCB_CONFIG_MCD_PORT 11210
#define LCB_CONFIG_MCD_SSL_PORT 11207
#define LCB_CONFIG_HTTP_PORT 8091
#define LCB_CONFIG_HTTP_SSL_PORT 18091
#define LCB_CONFIG_MCCOMPAT_PORT 11211

struct lcb_st;

typedef struct lcb_st *lcb_t;
struct lcb_http_request_st;
typedef struct lcb_http_request_st *lcb_http_request_t;

#include <stddef.h>
#include <time.h>
#include <stdarg.h>
#include <stdio.h>
#include <libcouchbase/sysdefs.h>
#include <libcouchbase/assert.h>
#include <libcouchbase/visibility.h>
#include <libcouchbase/error.h>
#include <libcouchbase/iops.h>
#include <libcouchbase/http.h>
#include <libcouchbase/configuration.h>
#include <libcouchbase/kvbuf.h>
#include <libcouchbase/auth.h>
#include <libcouchbase/tracing.h>
#include <libcouchbase/_cxxwrap.h>
#include <libcouchbase/cntl.h>

#ifdef __cplusplus
extern "C"{
#endif

typedef lcb_U8 lcb_datatype_t;
typedef lcb_U32 lcb_USECS;


/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** INITIALIZATION                                                           **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/

typedef enum {
    LCB_TYPE_BUCKET = 0x00, 
    LCB_TYPE_CLUSTER = 0x01 
} lcb_type_t;

typedef enum {
    LCB_BTYPE_UNSPEC = 0x00,    
    LCB_BTYPE_COUCHBASE = 0x01, 
    LCB_BTYPE_EPHEMERAL = 0x02, 
    LCB_BTYPE_MEMCACHED = 0x03  
} lcb_BTYPE;


#ifndef __LCB_DOXYGEN__
/* These are definitions for some of the older fields of the `lcb_create_st`
 * structure. They are here for backwards compatibility and should not be
 * used by new code */
typedef enum { LCB_CONFIG_TRANSPORT_LIST_END = 0, LCB_CONFIG_TRANSPORT_HTTP = 1, LCB_CONFIG_TRANSPORT_CCCP, LCB_CONFIG_TRANSPORT_MAX } lcb_config_transport_t;
#define LCB_CREATE_V0_FIELDS const char *host; const char *user; const char *passwd; const char *bucket; struct lcb_io_opt_st *io;
#define LCB_CREATE_V1_FIELDS LCB_CREATE_V0_FIELDS lcb_type_t type;
#define LCB_CREATE_V2_FIELDS LCB_CREATE_V1_FIELDS const char *mchosts; const lcb_config_transport_t* transports;
struct lcb_create_st0 { LCB_CREATE_V0_FIELDS };
struct lcb_create_st1 { LCB_CREATE_V1_FIELDS };
struct lcb_create_st2 { LCB_CREATE_V2_FIELDS };
#endif

struct lcb_create_st3 {
    const char *connstr; 
    const char *username;

    const char *passwd;

    void *_pad_bucket; 
    struct lcb_io_opt_st *io; 
    lcb_type_t type;
};

struct lcb_create_st4 {
    const char *connstr; 
    const char *username;

    const char *passwd;

    lcb_logprocs *logger; 
    struct lcb_io_opt_st *io; 
    lcb_type_t type;
};

struct lcb_create_st {
    int version;

    union lcb_CRST_u {
        struct lcb_create_st0 v0;
        struct lcb_create_st1 v1;
        struct lcb_create_st2 v2;
        struct lcb_create_st3 v3; 
        struct lcb_create_st4 v4;
    } v;
    LCB_DEPR_CTORS_CRST
};

LIBCOUCHBASE_API
lcb_error_t lcb_create(lcb_t *instance, const struct lcb_create_st *options);

LIBCOUCHBASE_API
lcb_error_t lcb_connect(lcb_t instance);

typedef void (*lcb_bootstrap_callback)(lcb_t instance, lcb_error_t err);

LIBCOUCHBASE_API
lcb_bootstrap_callback
lcb_set_bootstrap_callback(lcb_t instance, lcb_bootstrap_callback callback);

LIBCOUCHBASE_API
lcb_error_t
lcb_get_bootstrap_status(lcb_t instance);

LIBCOUCHBASE_API
void
lcb_set_auth(lcb_t instance, lcb_AUTHENTICATOR *auth);
#define LCB_CMD_BASE \
 \
    lcb_U32 cmdflags; \
    \
 \
    lcb_U32 exptime; \
    \
 \
    lcb_U64 cas; \
    \
 \
    lcb_KEYBUF key; \
    \
 \
    lcb_KEYBUF _hashkey

typedef struct lcb_CMDBASE {
    LCB_CMD_BASE;
} lcb_CMDBASE;

#define LCB_CMD_F_INTERNAL_CALLBACK (1 << 0)

#define LCB_CMD_F_MULTIAUTH (1<<1)

#define LCB_CMD_SET_KEY(cmd, keybuf, keylen) \
        LCB_KREQ_SIMPLE(&(cmd)->key, keybuf, keylen)

#define LCB_CMD__SETVBID(cmd, vbid) do { \
        (cmd)->_hashkey.type = LCB_KV_VBID; \
        (cmd)->_hashkey.contig.nbytes = vbid; \
} while (0);

#define LCB_RESP_BASE \
 \
    void *cookie; \
    const void *key;  \
    lcb_SIZE nkey;  \
    lcb_CAS cas;  \
    lcb_error_t rc;  \
    lcb_U16 version;  \
 \
    lcb_U16 rflags;


typedef struct {
    LCB_RESP_BASE
} lcb_RESPBASE;


#define LCB_RESP_SERVER_FIELDS \
 \
    const char *server;

typedef struct {
    LCB_RESP_BASE
    LCB_RESP_SERVER_FIELDS
} lcb_RESPSERVERBASE;

typedef struct lcb_MUTATION_TOKEN {
    lcb_U64 uuid_; 
    lcb_U64 seqno_; 
    lcb_U16 vbid_; 
} lcb_MUTATION_TOKEN;

typedef enum {
    LCB_RESP_F_FINAL = 0x01,

    LCB_RESP_F_CLIENTGEN = 0x02,

    LCB_RESP_F_NMVGEN = 0x04,

    LCB_RESP_F_EXTDATA = 0x08,

    LCB_RESP_F_SDSINGLE = 0x10,

    LCB_RESP_F_ERRINFO = 0x20
} lcb_RESPFLAGS;

typedef enum {
    LCB_CALLBACK_DEFAULT = 0, 
    LCB_CALLBACK_GET, 
    LCB_CALLBACK_STORE, 
    LCB_CALLBACK_COUNTER, 
    LCB_CALLBACK_TOUCH, 
    LCB_CALLBACK_REMOVE, 
    LCB_CALLBACK_UNLOCK, 
    LCB_CALLBACK_STATS, 
    LCB_CALLBACK_VERSIONS, 
    LCB_CALLBACK_VERBOSITY, 
    LCB_CALLBACK_FLUSH, 
    LCB_CALLBACK_OBSERVE, 
    LCB_CALLBACK_GETREPLICA, 
    LCB_CALLBACK_ENDURE, 
    LCB_CALLBACK_HTTP, 
    LCB_CALLBACK_CBFLUSH, 
    LCB_CALLBACK_OBSEQNO, 
    LCB_CALLBACK_STOREDUR, 
    LCB_CALLBACK_SDLOOKUP,
    LCB_CALLBACK_SDMUTATE,
    LCB_CALLBACK_NOOP, 
    LCB_CALLBACK_PING, 
    LCB_CALLBACK_DIAG, 
    LCB_CALLBACK__MAX /* Number of callbacks */
} lcb_CALLBACKTYPE;

/* The following callback types cannot be set using lcb_install_callback3(),
 * however, their value is passed along as the second argument of their
 * respective callbacks. This allows you to still use the same callback,
 * differentiating their meaning by the type. */

#define LCB_CALLBACK_VIEWQUERY -1

#define LCB_CALLBACK_N1QL -2

#define LCB_CALLBACK_IXMGMT -3

typedef void (*lcb_RESPCALLBACK)
        (lcb_t instance, int cbtype, const lcb_RESPBASE* resp);

LIBCOUCHBASE_API
lcb_RESPCALLBACK
lcb_install_callback3(lcb_t instance, int cbtype, lcb_RESPCALLBACK cb);

LIBCOUCHBASE_API
lcb_RESPCALLBACK
lcb_get_callback3(lcb_t instance, int cbtype);

LIBCOUCHBASE_API
const char *
lcb_strcbtype(int cbtype);

#define LCB_CMDGET_F_CLEAREXP (1<<16)

typedef struct {
    LCB_CMD_BASE;
    int lock;
} lcb_CMDGET;

typedef struct {
    LCB_RESP_BASE
    const void *value; 
    lcb_SIZE nvalue; 
    void* bufh;
    lcb_datatype_t datatype; 
    lcb_U32 itmflags; 
} lcb_RESPGET;

LIBCOUCHBASE_API
lcb_error_t
lcb_get3(lcb_t instance, const void *cookie, const lcb_CMDGET *cmd);
typedef enum {
    LCB_REPLICA_FIRST = 0x00,

    LCB_REPLICA_ALL = 0x01,

    LCB_REPLICA_SELECT = 0x02
} lcb_replica_t;

typedef struct {
    LCB_CMD_BASE;
    lcb_replica_t strategy;

    int index;
} lcb_CMDGETREPLICA;

LIBCOUCHBASE_API
lcb_error_t
lcb_rget3(lcb_t instance, const void *cookie, const lcb_CMDGETREPLICA *cmd);
typedef enum {
    LCB_ADD = 0x01,

    LCB_REPLACE = 0x02,

    LCB_SET = 0x03,

    LCB_UPSERT = 0x00,

    LCB_APPEND = 0x04,

    LCB_PREPEND = 0x05
} lcb_storage_t;

typedef struct {
    LCB_CMD_BASE;

    lcb_VALBUF value;

    lcb_U32 flags;

    lcb_datatype_t datatype;

    lcb_storage_t operation;
} lcb_CMDSTORE;

typedef struct {
    LCB_RESP_BASE

    lcb_storage_t op;
} lcb_RESPSTORE;

#define LCB_CMD_SET_VALUE(scmd, valbuf, vallen) do { \
    (scmd)->value.vtype = LCB_KV_COPY; \
    (scmd)->value.u_buf.contig.bytes = valbuf; \
    (scmd)->value.u_buf.contig.nbytes = vallen; \
} while (0);

#define LCB_CMD_SET_VALUEIOV(scmd, iovs, niovs) do { \
    (scmd)->value.vtype = LCB_KV_IOVCOPY; \
    (scmd)->value.u_buf.multi.iov = iovs; \
    (scmd)->value.u_buf.multi.niov = niovs; \
} while (0);

LIBCOUCHBASE_API
lcb_error_t
lcb_store3(lcb_t instance, const void *cookie, const lcb_CMDSTORE *cmd);
typedef lcb_CMDBASE lcb_CMDREMOVE;

typedef lcb_RESPBASE lcb_RESPREMOVE;

LIBCOUCHBASE_API
lcb_error_t
lcb_remove3(lcb_t instance, const void *cookie, const lcb_CMDREMOVE * cmd);
typedef struct lcb_MULTICMD_CTX_st {
    lcb_error_t (*addcmd)(struct lcb_MULTICMD_CTX_st *ctx, const lcb_CMDBASE *cmd);

    lcb_error_t (*done)(struct lcb_MULTICMD_CTX_st *ctx, const void *cookie);

    void (*fail)(struct lcb_MULTICMD_CTX_st *ctx);

#ifdef LCB_TRACING

    void (*setspan)(struct lcb_MULTICMD_CTX_st *ctx, lcbtrace_SPAN *span);
#endif
} lcb_MULTICMD_CTX;
typedef enum {
    LCB_DURABILITY_MODE_DEFAULT = 0,

    LCB_DURABILITY_MODE_CAS,

    LCB_DURABILITY_MODE_SEQNO
} lcb_DURMODE;

typedef struct {
    lcb_U32 timeout;

    lcb_U32 interval;

    lcb_U16 persist_to;

    lcb_U16 replicate_to;

    lcb_U8 check_delete;

    lcb_U8 cap_max;

    lcb_U8 pollopts;
} lcb_DURABILITYOPTSv0;

typedef struct lcb_durability_opts_st {
    int version;
    union {
        lcb_DURABILITYOPTSv0 v0;
    } v;
} lcb_durability_opts_t;

#define LCB_CMDENDURE_F_MUTATION_TOKEN (1 << 16)

typedef struct {
    LCB_CMD_BASE;
    const lcb_MUTATION_TOKEN *mutation_token;
} lcb_CMDENDURE;

typedef struct {
    LCB_RESP_BASE
    lcb_U16 nresponses;

    lcb_U8 exists_master;

    lcb_U8 persisted_master;

    lcb_U8 npersisted;

    lcb_U8 nreplicated;
} lcb_RESPENDURE;

LIBCOUCHBASE_API
lcb_MULTICMD_CTX *
lcb_endure3_ctxnew(lcb_t instance,
    const lcb_durability_opts_t *options, lcb_error_t *err);

typedef struct {
    LCB_CMD_BASE;
    lcb_VALBUF value; 
    lcb_U32 flags; 
    lcb_datatype_t datatype; 
    lcb_storage_t operation; 
    char persist_to;

    char replicate_to;
} lcb_CMDSTOREDUR;

typedef struct {
    LCB_RESP_BASE
    const lcb_RESPENDURE *dur_resp;

    int store_ok;
} lcb_RESPSTOREDUR;

LIBCOUCHBASE_API
lcb_error_t
lcb_storedur3(lcb_t instance, const void *cookie, const lcb_CMDSTOREDUR *cmd);

#define LCB_DURABILITY_VALIDATE_CAPMAX (1 << 1)

LIBCOUCHBASE_API
lcb_error_t
lcb_durability_validate(lcb_t instance,
    lcb_U16 *persist_to, lcb_U16 *replicate_to, int options);
#define LCB_CMDOBSERVE_F_MASTER_ONLY (1 << 16)

typedef struct {
    LCB_CMD_BASE;
    const lcb_U16* servers_;
    size_t nservers_;
} lcb_CMDOBSERVE;

typedef enum {
    LCB_OBSERVE_FOUND = 0x00,
    LCB_OBSERVE_PERSISTED = 0x01,
    LCB_OBSERVE_NOT_FOUND = 0x80,
    LCB_OBSERVE_LOGICALLY_DELETED = 0x81,

    LCB_OBSERVE_MAX = 0x82
} lcb_observe_t;

typedef struct {
    LCB_RESP_BASE
    lcb_U8 status; 
    lcb_U8 ismaster; 
    lcb_U32 ttp; 
    lcb_U32 ttr; 
} lcb_RESPOBSERVE;

LIBCOUCHBASE_API
lcb_MULTICMD_CTX *
lcb_observe3_ctxnew(lcb_t instance);

typedef struct {
    LCB_CMD_BASE;
    lcb_U16 server_index;
    lcb_U16 vbid; 
    lcb_U64 uuid; 
} lcb_CMDOBSEQNO;

typedef struct {
    LCB_RESP_BASE
    lcb_U16 vbid; 
    lcb_U16 server_index; 
    lcb_U64 cur_uuid; 
    lcb_U64 persisted_seqno; 
    lcb_U64 mem_seqno; 
    lcb_U64 old_uuid;

    lcb_U64 old_seqno;
} lcb_RESPOBSEQNO;

LIBCOUCHBASE_API
lcb_error_t
lcb_observe_seqno3(lcb_t instance, const void *cookie, const lcb_CMDOBSEQNO *cmd);

#define LCB_MUTATION_TOKEN_ID(p) ((p)->uuid_)

#define LCB_MUTATION_TOKEN_SEQ(p) ((p)->seqno_)

#define LCB_MUTATION_TOKEN_VB(p) ((p)->vbid_)

#define LCB_MUTATION_TOKEN_ISVALID(p) \
    (p && !((p)->uuid_ == 0 && (p)->seqno_ == 0 && (p)->vbid_ == 0))

LIBCOUCHBASE_API
const lcb_MUTATION_TOKEN *
lcb_resp_get_mutation_token(int cbtype, const lcb_RESPBASE *rb);

LIBCOUCHBASE_API
const lcb_MUTATION_TOKEN *
lcb_get_mutation_token(lcb_t instance, const lcb_KEYBUF *kb, lcb_error_t *errp);

typedef struct {
    LCB_CMD_BASE;
    lcb_int64_t delta;
    lcb_U64 initial;
    int create;
} lcb_CMDCOUNTER;

typedef struct {
    LCB_RESP_BASE
    lcb_U64 value;
} lcb_RESPCOUNTER;

LIBCOUCHBASE_API
lcb_error_t
lcb_counter3(lcb_t instance, const void *cookie, const lcb_CMDCOUNTER *cmd);
typedef lcb_CMDBASE lcb_CMDUNLOCK;

typedef lcb_RESPBASE lcb_RESPUNLOCK;

LIBCOUCHBASE_API
lcb_error_t
lcb_unlock3(lcb_t instance, const void *cookie, const lcb_CMDUNLOCK *cmd);
typedef lcb_CMDBASE lcb_CMDTOUCH;

typedef lcb_RESPBASE lcb_RESPTOUCH;

LIBCOUCHBASE_API
lcb_error_t
lcb_touch3(lcb_t instance, const void *cookie, const lcb_CMDTOUCH *cmd);
typedef lcb_CMDBASE lcb_CMDSTATS;

#define LCB_CMDSTATS_F_KV (1 << 16)

typedef struct {
    LCB_RESP_BASE
    LCB_RESP_SERVER_FIELDS
    const char *value; 
    lcb_SIZE nvalue; 
} lcb_RESPSTATS;

LIBCOUCHBASE_API
lcb_error_t
lcb_stats3(lcb_t instance, const void *cookie, const lcb_CMDSTATS * cmd);
typedef struct {
    LCB_RESP_BASE
    LCB_RESP_SERVER_FIELDS
    const char *mcversion; 
    lcb_SIZE nversion; 
} lcb_RESPMCVERSION;

LIBCOUCHBASE_API
lcb_error_t
lcb_server_versions3(lcb_t instance, const void *cookie, const lcb_CMDBASE * cmd);

typedef enum {
    LCB_VERBOSITY_DETAIL = 0x00,
    LCB_VERBOSITY_DEBUG = 0x01,
    LCB_VERBOSITY_INFO = 0x02,
    LCB_VERBOSITY_WARNING = 0x03
} lcb_verbosity_level_t;

typedef struct {
    /* unused */
    LCB_CMD_BASE;
    const char *server;
    lcb_verbosity_level_t level;
} lcb_CMDVERBOSITY;
typedef lcb_RESPSERVERBASE lcb_RESPVERBOSITY;
LIBCOUCHBASE_API
lcb_error_t
lcb_server_verbosity3(lcb_t instance, const void *cookie, const lcb_CMDVERBOSITY *cmd);
typedef lcb_CMDBASE lcb_CMDCBFLUSH;
typedef lcb_RESPBASE lcb_RESPCBFLUSH;

LIBCOUCHBASE_API
lcb_error_t
lcb_cbflush3(lcb_t instance, const void *cookie, const lcb_CMDCBFLUSH *cmd);


typedef lcb_CMDBASE lcb_CMDFLUSH;
typedef lcb_RESPSERVERBASE lcb_RESPFLUSH;
LIBCOUCHBASE_API
lcb_error_t
lcb_flush3(lcb_t instance, const void *cookie, const lcb_CMDFLUSH *cmd);
typedef lcb_CMDBASE lcb_CMDNOOP;
typedef lcb_RESPSERVERBASE lcb_RESPNOOP;

LIBCOUCHBASE_API
lcb_error_t
lcb_noop3(lcb_t instance, const void *cookie, const lcb_CMDNOOP *cmd);
#define LCB_PINGSVC_F_KV 0x01

#define LCB_PINGSVC_F_N1QL 0x02

#define LCB_PINGSVC_F_VIEWS 0x04

#define LCB_PINGSVC_F_FTS 0x08

#define LCB_PINGSVC_F_ANALYTICS 0x10

#define LCB_PINGOPT_F_NOMETRICS 0x01

#define LCB_PINGOPT_F_JSON 0x02

#define LCB_PINGOPT_F_JSONDETAILS 0x04

#define LCB_PINGOPT_F_JSONPRETTY 0x08

typedef struct {
    LCB_CMD_BASE;
    int services; 
    int options; 
    const char *id; 
} lcb_CMDPING;

typedef enum {
    LCB_PINGSVC_KV = 0,
    LCB_PINGSVC_VIEWS,
    LCB_PINGSVC_N1QL,
    LCB_PINGSVC_FTS,
    LCB_PINGSVC__MAX
} lcb_PINGSVCTYPE;

typedef enum {
    LCB_PINGSTATUS_OK = 0,
    LCB_PINGSTATUS_TIMEOUT,
    LCB_PINGSTATUS_ERROR,
    LCB_PINGSTATUS__MAX
} lcb_PINGSTATUS;

typedef struct {
    lcb_PINGSVCTYPE type; 
    /* TODO: rename to "remote" */
    const char *server; 
    lcb_U64 latency; 
    lcb_error_t rc; 
    const char *local; 
    const char *id; 
    const char *scope; 
    lcb_PINGSTATUS status; 
} lcb_PINGSVC;

typedef struct {
    LCB_RESP_BASE
    LCB_RESP_SERVER_FIELDS
    lcb_SIZE nservices; 
    lcb_PINGSVC *services; 
    lcb_SIZE njson; 
    const char *json; 
} lcb_RESPPING;

LIBCOUCHBASE_API
lcb_error_t
lcb_ping3(lcb_t instance, const void *cookie, const lcb_CMDPING *cmd);

typedef struct {
    LCB_CMD_BASE;
    int options;  
    const char *id; 
} lcb_CMDDIAG;

typedef struct {
    LCB_RESP_BASE
    lcb_SIZE njson;   
    const char *json; 
} lcb_RESPDIAG;

LIBCOUCHBASE_API
lcb_error_t lcb_diag(lcb_t instance, const void *cookie, const lcb_CMDDIAG *cmd);
typedef enum {
    LCB_HTTP_TYPE_VIEW = 0,

    LCB_HTTP_TYPE_MANAGEMENT = 1,

    LCB_HTTP_TYPE_RAW = 2,

    LCB_HTTP_TYPE_N1QL = 3,

    LCB_HTTP_TYPE_FTS = 4,

    LCB_HTTP_TYPE_CBAS = 5,

    LCB_HTTP_TYPE_PING = 6,

    LCB_HTTP_TYPE_MAX
} lcb_http_type_t;

typedef enum {
    LCB_HTTP_METHOD_GET = 0,
    LCB_HTTP_METHOD_POST = 1,
    LCB_HTTP_METHOD_PUT = 2,
    LCB_HTTP_METHOD_DELETE = 3,
    LCB_HTTP_METHOD_MAX = 4
} lcb_http_method_t;

#define LCB_CMDHTTP_F_STREAM (1 << 16)

#define LCB_CMDHTTP_F_CASTMO (1 << 17)

#define LCB_CMDHTTP_F_NOUPASS (1 << 18)

typedef struct {
    LCB_CMD_BASE;
    lcb_http_type_t type;
    lcb_http_method_t method; 
    const char *body;

    lcb_SIZE nbody;

    lcb_http_request_t *reqhandle;

    const char *content_type;

    const char *username;

    const char *password;

    const char *host;
} lcb_CMDHTTP;

typedef struct {
    LCB_RESP_BASE
    short htstatus;

    const char * const * headers;

    const void *body;
    lcb_SIZE nbody;
    lcb_http_request_t _htreq;
} lcb_RESPHTTP;

LIBCOUCHBASE_API
lcb_error_t
lcb_http3(lcb_t instance, const void *cookie, const lcb_CMDHTTP *cmd);

LIBCOUCHBASE_API
void
lcb_cancel_http_request(lcb_t instance, lcb_http_request_t request);
LIBCOUCHBASE_API
void lcb_set_cookie(lcb_t instance, const void *cookie);

LIBCOUCHBASE_API
const void *lcb_get_cookie(lcb_t instance);
LIBCOUCHBASE_API
lcb_error_t lcb_wait(lcb_t instance);

LIBCOUCHBASE_API
lcb_error_t lcb_tick_nowait(lcb_t instance);

typedef enum {
    LCB_WAIT_DEFAULT = 0x00,

    LCB_WAIT_NOCHECK = 0x01
} lcb_WAITFLAGS;

LIBCOUCHBASE_API
void lcb_wait3(lcb_t instance, lcb_WAITFLAGS flags);

LIBCOUCHBASE_API
void lcb_breakout(lcb_t instance);

LIBCOUCHBASE_API
int lcb_is_waiting(lcb_t instance);
LIBCOUCHBASE_API
void
lcb_refresh_config(lcb_t instance);

LIBCOUCHBASE_API
void lcb_sched_enter(lcb_t instance);

LIBCOUCHBASE_API
void lcb_sched_leave(lcb_t instance);


LIBCOUCHBASE_API
void lcb_sched_fail(lcb_t instance);

LIBCOUCHBASE_API
void lcb_sched_flush(lcb_t instance);

LIBCOUCHBASE_API
void lcb_destroy(lcb_t instance);

typedef void (*lcb_destroy_callback)(const void *cookie);

LIBCOUCHBASE_API
lcb_destroy_callback
lcb_set_destroy_callback(lcb_t, lcb_destroy_callback);
LIBCOUCHBASE_API
void lcb_destroy_async(lcb_t instance, const void *arg);
#define LCB_DATATYPE_JSON 0x01

typedef enum { LCB_VALUE_RAW = 0x00, LCB_VALUE_F_JSON = 0x01, LCB_VALUE_F_SNAPPYCOMP = 0x02 } lcb_VALUEFLAGS;


typedef enum {
    LCB_NODE_HTCONFIG = 0x01,
    LCB_NODE_DATA = 0x02,
    LCB_NODE_VIEWS = 0x04,
    LCB_NODE_CONNECTED = 0x08,

    LCB_NODE_NEVERNULL = 0x10,

    LCB_NODE_HTCONFIG_CONNECTED = 0x09,

    LCB_NODE_HTCONFIG_ANY = 0x11
} lcb_GETNODETYPE;

#define LCB_GETNODE_UNAVAILABLE "invalid_host:0"

LIBCOUCHBASE_API
const char *
lcb_get_node(lcb_t instance, lcb_GETNODETYPE type, unsigned index);

LIBCOUCHBASE_API
const char *
lcb_get_keynode(lcb_t instance, const void *key, size_t nkey);

LIBCOUCHBASE_API
lcb_S32 lcb_get_num_replicas(lcb_t instance);

LIBCOUCHBASE_API
lcb_S32 lcb_get_num_nodes(lcb_t instance);


LIBCOUCHBASE_API
const char *const *lcb_get_server_list(lcb_t instance);

LIBCOUCHBASE_API
void
lcb_dump(lcb_t instance, FILE *fp, lcb_U32 flags);
LIBCOUCHBASE_API
lcb_error_t lcb_cntl(lcb_t instance, int mode, int cmd, void *arg);

LIBCOUCHBASE_API
lcb_error_t
lcb_cntl_string(lcb_t instance, const char *key, const char *value);

LIBCOUCHBASE_API
lcb_error_t lcb_cntl_setu32(lcb_t instance, int cmd, lcb_U32 arg);

LIBCOUCHBASE_API
lcb_U32 lcb_cntl_getu32(lcb_t instance, int cmd);

LIBCOUCHBASE_API
int
lcb_cntl_exists(int ctl); /* settings */

enum lcb_timeunit_t {
    LCB_TIMEUNIT_NSEC = 0, 
    LCB_TIMEUNIT_USEC = 1, 
    LCB_TIMEUNIT_MSEC = 2, 
    LCB_TIMEUNIT_SEC = 3 
};
typedef enum lcb_timeunit_t lcb_timeunit_t;

LIBCOUCHBASE_API
lcb_error_t lcb_enable_timings(lcb_t instance);


LIBCOUCHBASE_API
lcb_error_t lcb_disable_timings(lcb_t instance);

typedef void (*lcb_timings_callback)(lcb_t instance,
                                     const void *cookie,
                                     lcb_timeunit_t timeunit,
                                     lcb_U32 min,
                                     lcb_U32 max,
                                     lcb_U32 total,
                                     lcb_U32 maxtotal);

LIBCOUCHBASE_API
lcb_error_t lcb_get_timings(lcb_t instance,
                            const void *cookie,
                            lcb_timings_callback callback);
#if !defined(LCB_VERSION_STRING) || defined(__LCB_DOXYGEN__)

#define LCB_VERSION_STRING "unknown"
#endif

#if !defined(LCB_VERSION) || defined(__LCB_DOXYGEN__)

#define LCB_VERSION 0x000000
#endif

#if !defined(LCB_VERSION_CHANGESET) || defined(__LCB_DOXYGEN__)

#define LCB_VERSION_CHANGESET "0xdeadbeef"
#endif

LIBCOUCHBASE_API
const char *lcb_get_version(lcb_U32 *version);

LIBCOUCHBASE_API LCB_EXTERN_VAR
const lcb_U32 lcb_version_g;

#define LCB_SUPPORTS_SSL 1

#define LCB_SUPPORTS_SNAPPY 2

#define LCB_SUPPORTS_TRACING 3

LIBCOUCHBASE_API
int
lcb_supports_feature(int n);

LIBCOUCHBASE_API
void *lcb_mem_alloc(lcb_SIZE size);

LIBCOUCHBASE_API
void lcb_mem_free(void *ptr);

LCB_INTERNAL_API
void lcb_run_loop(lcb_t instance);

LCB_INTERNAL_API
void lcb_stop_loop(lcb_t instance);

/* This returns the library's idea of time */
LCB_INTERNAL_API
lcb_U64 lcb_nstime(void);

typedef enum {
    LCB_DUMP_VBCONFIG =  0x01,
    LCB_DUMP_PKTINFO = 0x02,
    LCB_DUMP_BUFINFO = 0x04,
    LCB_DUMP_METRICS = 0x08,
    LCB_DUMP_ALL = 0xff
} lcb_DUMPFLAGS;

struct lcb_histogram_st;
typedef struct lcb_histogram_st lcb_HISTOGRAM;

LIBCOUCHBASE_API
lcb_HISTOGRAM *
lcb_histogram_create(void);

LIBCOUCHBASE_API
void
lcb_histogram_destroy(lcb_HISTOGRAM *hg);

LIBCOUCHBASE_API
void
lcb_histogram_record(lcb_HISTOGRAM *hg, lcb_U64 duration);

typedef void (*lcb_HISTOGRAM_CALLBACK)
        (const void *cookie, lcb_timeunit_t timeunit, lcb_U32 min, lcb_U32 max,
                lcb_U32 total, lcb_U32 maxtotal);

LIBCOUCHBASE_API
void
lcb_histogram_read(const lcb_HISTOGRAM *hg, const void *cookie,
    lcb_HISTOGRAM_CALLBACK cb);

LIBCOUCHBASE_API
void lcb_histogram_print(lcb_HISTOGRAM* hg, FILE* stream);

LIBCOUCHBASE_API
const char *
lcb_resp_get_error_context(int cbtype, const lcb_RESPBASE *rb);

LIBCOUCHBASE_API
const char *
lcb_resp_get_error_ref(int cbtype, const lcb_RESPBASE *rb);

LIBCOUCHBASE_API
int lcb_is_redacting_logs(lcb_t instance);

/* Post-include some other headers */
#ifdef __cplusplus
}
#endif /* __cplusplus */
#include <libcouchbase/subdoc.h>
#include <libcouchbase/deprecated.h>
#include <libcouchbase/api-legacy.h>
#endif /* LIBCOUCHBASE_COUCHBASE_H */