utils.h

Go to the documentation of this file.

/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2011-2020 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_UTILS_H
#define LCB_UTILS_H

#ifdef __cplusplus
extern "C" {
#endif

#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

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

#define LCB_CMD_BASE                                                                                                   \
                                                                                   \
    lcb_U32 cmdflags;                                                                                                  \
                                                                                                                       \
                                                                 \
    lcb_U32 exptime;                                                                                                   \
                                                                                                                       \
                                                                      \
    lcb_U64 cas;                                                                                                       \
                                                                                                                       \
                                                                                              \
    lcb_U32 cid;                                                                                                       \
    const char *scope;                                                                                                 \
    size_t nscope;                                                                                                     \
    const char *collection;                                                                                            \
    size_t ncollection;                                                                                                \
                                    \
    lcb_KEYBUF key;                                                                                                    \
                                                                                                                       \
                         \
    lcb_U32 timeout;                                                                                                   \
                                                                                         \
    lcbtrace_SPAN *pspan

typedef struct {
    LCB_CMD_BASE;
} lcb_CMDCBFLUSH;

typedef struct {
    lcb_STATUS rc;
    void *cookie;
    lcb_U16 rflags;
} lcb_RESPCBFLUSH;

LIBCOUCHBASE_API
lcb_STATUS lcb_cbflush3(lcb_INSTANCE *instance, void *cookie, const lcb_CMDCBFLUSH *cmd);

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_STATUS lcb_enable_timings(lcb_INSTANCE *instance);

LIBCOUCHBASE_API
lcb_STATUS lcb_disable_timings(lcb_INSTANCE *instance);

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

LIBCOUCHBASE_API
lcb_STATUS lcb_get_timings(lcb_INSTANCE *instance, const void *cookie, lcb_timings_callback callback);
typedef enum {
    LCB_DUMP_VBCONFIG = 0x01,
    LCB_DUMP_PKTINFO = 0x02,
    LCB_DUMP_BUFINFO = 0x04,
    LCB_DUMP_METRICS = 0x08,
    LCB_DUMP_ALL = 0xff
} lcb_DUMPFLAGS;

LIBCOUCHBASE_API
void lcb_dump(lcb_INSTANCE *instance, FILE *fp, lcb_U32 flags);

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);

/*
 * @addtogroup lcb-collection-api
 * @{
 */

typedef struct lcb_RESPGETMANIFEST_ lcb_RESPGETMANIFEST;

LIBCOUCHBASE_API lcb_STATUS lcb_respgetmanifest_status(const lcb_RESPGETMANIFEST *resp);
LIBCOUCHBASE_API lcb_STATUS lcb_respgetmanifest_cookie(const lcb_RESPGETMANIFEST *resp, void **cookie);
LIBCOUCHBASE_API lcb_STATUS lcb_respgetmanifest_value(const lcb_RESPGETMANIFEST *resp, const char **json,
                                                      size_t *json_len);

typedef struct lcb_CMDGETMANIFEST_ lcb_CMDGETMANIFEST;

LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetmanifest_create(lcb_CMDGETMANIFEST **cmd);
LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetmanifest_destroy(lcb_CMDGETMANIFEST *cmd);
LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetmanifest_timeout(lcb_CMDGETMANIFEST *cmd, uint32_t timeout);
LIBCOUCHBASE_API lcb_STATUS lcb_getmanifest(lcb_INSTANCE *instance, void *cookie, const lcb_CMDGETMANIFEST *cmd);

typedef struct lcb_RESPGETCID_ lcb_RESPGETCID;

LIBCOUCHBASE_API lcb_STATUS lcb_respgetcid_status(const lcb_RESPGETCID *resp);
LIBCOUCHBASE_API lcb_STATUS lcb_respgetcid_cookie(const lcb_RESPGETCID *resp, void **cookie);
LIBCOUCHBASE_API lcb_STATUS lcb_respgetcid_manifest_id(const lcb_RESPGETCID *resp, uint64_t *id);
LIBCOUCHBASE_API lcb_STATUS lcb_respgetcid_collection_id(const lcb_RESPGETCID *resp, uint32_t *id);
LIBCOUCHBASE_API lcb_STATUS lcb_respgetcid_scoped_collection(const lcb_RESPGETCID *resp, const char **name,
                                                             size_t *name_len);

typedef struct lcb_CMDGETCID_ lcb_CMDGETCID;

LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetcid_create(lcb_CMDGETCID **cmd);
LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetcid_destroy(lcb_CMDGETCID *cmd);
LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetcid_scope(lcb_CMDGETCID *cmd, const char *scope, size_t scope_len);
LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetcid_collection(lcb_CMDGETCID *cmd, const char *collection, size_t collection_len);
LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetcid_timeout(lcb_CMDGETCID *cmd, uint32_t timeout);

LIBCOUCHBASE_API lcb_STATUS lcb_getcid(lcb_INSTANCE *instance, void *cookie, const lcb_CMDGETCID *cmd);
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_INSTANCE *instance, lcb_GETNODETYPE type, unsigned index);

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

LIBCOUCHBASE_API
lcb_S32 lcb_get_num_replicas(lcb_INSTANCE *instance);

LIBCOUCHBASE_API
lcb_S32 lcb_get_num_nodes(lcb_INSTANCE *instance);

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

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_INSTANCE *instance);

LCB_INTERNAL_API
void lcb_stop_loop(lcb_INSTANCE *instance);

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

#ifdef __cplusplus
}
#endif
#endif /* LCB_UTILS_H */