vbucket.h

Go to the documentation of this file.

/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2014-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_VBUCKET_H
#define LCB_VBUCKET_H
#include <libcouchbase/visibility.h>
#include <libcouchbase/sysdefs.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef enum {
    LCBVB_SVCTYPE_DATA = 0,  
    LCBVB_SVCTYPE_VIEWS,     
    LCBVB_SVCTYPE_MGMT,      
    LCBVB_SVCTYPE_IXQUERY,   
    LCBVB_SVCTYPE_IXADMIN,   
    LCBVB_SVCTYPE_QUERY,     
    LCBVB_SVCTYPE_SEARCH,    
    LCBVB_SVCTYPE_ANALYTICS, 
    LCBVB_SVCTYPE_EVENTING,  
/* for backward compatiblity */
#define LCBVB_SVCTYPE_CBAS LCBVB_SVCTYPE_ANALYTICS
    LCBVB_SVCTYPE__MAX
} lcbvb_SVCTYPE;

typedef enum {
    LCBVB_SVCMODE_PLAIN = 0, 
    LCBVB_SVCMODE_SSL,       
    LCBVB_SVCMODE__MAX
} lcbvb_SVCMODE;

typedef struct {
    lcb_U16 data;      
    lcb_U16 mgmt;      
    lcb_U16 views;     
    lcb_U16 ixquery;   
    lcb_U16 ixadmin;   
    lcb_U16 n1ql;      
    lcb_U16 fts;       
    lcb_U16 cbas;      
    lcb_U16 eventing;  
    char *views_base_; 
    char *query_base_; 
    char *fts_base_;
    char *cbas_base_;
    char *eventing_base_;
    char *hoststrs[LCBVB_SVCTYPE__MAX];
} lcbvb_SERVICES;

typedef struct {
    lcbvb_SERVICES svc;         
    lcbvb_SERVICES svc_ssl;     
    char *authority;            
    char *hostname;             
    char *viewpath;             
    char *querypath;            
    char *ftspath;              
    char *cbaspath;             
    char *eventingpath;         
    unsigned nvbs;              
    char *alt_hostname;         
    lcbvb_SERVICES alt_svc;     
    lcbvb_SERVICES alt_svc_ssl; 
} lcbvb_SERVER;

typedef struct {
    int servers[4];
} lcbvb_VBUCKET;

typedef struct {
    lcb_U32 index;
    lcb_U32 point;
} lcbvb_CONTINUUM;

typedef enum {
    LCBVB_DIST_VBUCKET = 0, 
    LCBVB_DIST_KETAMA = 1,  
    LCBVB_DIST_UNKNOWN = 2  
} lcbvb_DISTMODE;

typedef enum {
    LCBVB_CAP_XATTR = 1 << 0,
    LCBVB_CAP_CBHELLO = 1 << 1,
    LCBVB_CAP_CCCP = 1 << 2,
    LCBVB_CAP_COUCHAPI = 1 << 3,
    LCBVB_CAP_DCP = 1 << 4,
    LCBVB_CAP_NODES_EXT = 1 << 5,
    LCBVB_CAP_TOUCH = 1 << 6,
    LCBVB_CAP_XDCR_CHECKPOINTING = 1 << 7,
    LCBVB_CAP_COLLECTIONS = 1 << 8,
    LCBVB_CAP_DURABLE_WRITE = 1 << 9,
    LCBVB_CAP_TOMBSTONED_USER_XATTRS = 1 << 10
} lcbvb_BUCKET_CAPABILITIES;

typedef enum {
    LCBVB_CCAP_N1QL_ENHANCED_PREPARED_STATEMENTS = 1 << 0,
} lcbvb_CLUSTER_CAPABILITIES;

typedef struct lcbvb_CONFIG_st {
    lcbvb_DISTMODE dtype;       
    unsigned nvb;               
    unsigned ndatasrv;          
    unsigned nsrv;              
    unsigned nrepl;             
    unsigned ncontinuum;        /* number of continuum points */
    unsigned is3x;              /* whether server 3.0 config semantics are in place */
    int64_t revepoch;           /* revision Epoch from the config (-1 if not present) */
    int64_t revid;              /* revision ID from the config (-1 if not present) */
    char *buuid;                /* bucket UUID */
    char *bname;                /* bucket name */
    size_t bname_len;           /* bucket name */
    const char *errstr;         /* last error */
    lcbvb_SERVER *servers;      /* nodes */
    lcbvb_VBUCKET *vbuckets;    /* vbucket map */
    lcbvb_VBUCKET *ffvbuckets;  /* fast-forward map */
    lcbvb_CONTINUUM *continuum; /* ketama continuums */
    int *randbuf;               /* Used for random server selection */
    uint64_t caps;              
    uint64_t ccaps;             
} lcbvb_CONFIG;

#define LCBVB_BUCKET_NAME(cfg) (cfg)->bname
#define LCBVB_NSERVERS(cfg) (cfg)->nsrv
#define LCBVB_NDATASERVERS(cfg) (cfg)->ndatasrv
#define LCBVB_NREPLICAS(cfg) (cfg)->nrepl
#define LCBVB_DISTTYPE(cfg) (cfg)->dtype
#define LCBVB_CAPS(cfg) (cfg)->caps
#define LCBVB_CCAPS(cfg) (cfg)->ccaps
#define LCBVB_GET_SERVER(conf, ix) ((conf)->servers + ix)

LIBCOUCHBASE_API
lcbvb_CONFIG *lcbvb_create(void);

LIBCOUCHBASE_API
lcbvb_CONFIG *lcbvb_parse_json(const char *data);

LIBCOUCHBASE_API
int lcbvb_load_json(lcbvb_CONFIG *vbc, const char *data);

LIBCOUCHBASE_API
int lcbvb_load_json_ex(lcbvb_CONFIG *vbc, const char *data, const char *source, char **network);

LIBCOUCHBASE_API
char *lcbvb_save_json(lcbvb_CONFIG *vbc);

LIBCOUCHBASE_API
const char *lcbvb_get_error(const lcbvb_CONFIG *vbc);

LIBCOUCHBASE_API
void lcbvb_replace_host(lcbvb_CONFIG *cfg, const char *hostname);

LIBCOUCHBASE_API
void lcbvb_destroy(lcbvb_CONFIG *conf);

LIBCOUCHBASE_API
int lcbvb_vbmaster(lcbvb_CONFIG *cfg, int vbid);

LIBCOUCHBASE_API
int lcbvb_vbreplica(lcbvb_CONFIG *cfg, int vbid, unsigned ix);

#define lcbvb_vbserver(cfg, vbid, ix) ((ix == 0) ? lcbvb_vbmaster(cfg, vbid) : lcbvb_vbreplica(cfg, vbid, ix - 1))

#define lcbvb_nmv_remap(cfg, vbid, bad) lcbvb_nmv_remap_ex(cfg, vbid, bad, 0)

int lcbvb_nmv_remap_ex(lcbvb_CONFIG *cfg, int vbid, int bad, int use_heuristics);

LIBCOUCHBASE_API
int lcbvb_map_key(lcbvb_CONFIG *cfg, const void *key, lcb_SIZE n, int *vbid, int *srvix);

LIBCOUCHBASE_API
int lcbvb_k2vb(lcbvb_CONFIG *cfg, const void *key, lcb_SIZE n);

LIBCOUCHBASE_API
int lcbvb_has_vbucket(lcbvb_CONFIG *vbc, int vbid, int ix);

LIBCOUCHBASE_API
unsigned lcbvb_get_nservers(const lcbvb_CONFIG *cfg);

LIBCOUCHBASE_API
unsigned lcbvb_get_nreplicas(const lcbvb_CONFIG *cfg);

LIBCOUCHBASE_API
unsigned lcbvb_get_nvbuckets(const lcbvb_CONFIG *cfg);

LIBCOUCHBASE_API
lcbvb_DISTMODE lcbvb_get_distmode(const lcbvb_CONFIG *cfg);

LIBCOUCHBASE_API
int lcbvb_get_revision(const lcbvb_CONFIG *cfg);

LIBCOUCHBASE_API
unsigned lcbvb_get_port(lcbvb_CONFIG *cfg, unsigned ix, lcbvb_SVCTYPE type, lcbvb_SVCMODE mode);

LIBCOUCHBASE_API
const char *lcbvb_get_hostport(lcbvb_CONFIG *cfg, unsigned ix, lcbvb_SVCTYPE type, lcbvb_SVCMODE mode);

LIBCOUCHBASE_API
const char *lcbvb_get_hostname(const lcbvb_CONFIG *cfg, unsigned ix);

LIBCOUCHBASE_API
const char *lcbvb_get_resturl(lcbvb_CONFIG *cfg, unsigned ix, lcbvb_SVCTYPE type, lcbvb_SVCMODE mode);

LIBCOUCHBASE_API
int lcbvb_get_randhost(const lcbvb_CONFIG *cfg, lcbvb_SVCTYPE type, lcbvb_SVCMODE mode);

LIBCOUCHBASE_API
int lcbvb_get_randhost_ex(const lcbvb_CONFIG *cfg, lcbvb_SVCTYPE type, lcbvb_SVCMODE mode, int *used);

typedef struct {
    char **servers_added;
    char **servers_removed;
    int n_vb_changes;
    int sequence_changed;
    int n_repl_changed;
} lcbvb_CONFIGDIFF, VBUCKET_CONFIG_DIFF;

typedef enum {
    LCBVB_NO_CHANGES = 0,              
    LCBVB_SERVERS_MODIFIED = 1u << 0u, 
    LCBVB_MAP_MODIFIED = 1u << 1u,     
    LCBVB_REPLICAS_MODIFIED = 1u << 2u 
} lcbvb_CHANGETYPE,
    VBUCKET_CHANGE_STATUS;

LIBCOUCHBASE_API
lcbvb_CONFIGDIFF *lcbvb_compare(lcbvb_CONFIG *from, lcbvb_CONFIG *to);

LIBCOUCHBASE_API
void lcbvb_free_diff(lcbvb_CONFIGDIFF *diff);

LIBCOUCHBASE_API
lcbvb_CHANGETYPE lcbvb_get_changetype(lcbvb_CONFIGDIFF *diff);

LIBCOUCHBASE_API
int lcbvb_genconfig_ex(lcbvb_CONFIG *vb, const char *name, const char *uuid, const lcbvb_SERVER *servers,
                       unsigned nservers, unsigned nreplica, unsigned nvbuckets);

LIBCOUCHBASE_API
int lcbvb_genconfig(lcbvb_CONFIG *vb, unsigned nservers, unsigned nreplica, unsigned nvbuckets);

LIBCOUCHBASE_API
void lcbvb_genffmap(lcbvb_CONFIG *vb);

LIBCOUCHBASE_API
void lcbvb_make_ketama(lcbvb_CONFIG *vb);

LIBCOUCHBASE_API
const char *lcbvb_get_capibase(lcbvb_CONFIG *cfg, unsigned ix, lcbvb_SVCMODE mode);
/*the rest of these symbols are deprecated and should not be touched by
 * doxygen */

typedef enum { LIBVBUCKET_SOURCE_FILE, LIBVBUCKET_SOURCE_MEMORY } vbucket_source_t;

typedef lcbvb_CONFIG *VBUCKET_CONFIG_HANDLE;
typedef lcbvb_DISTMODE VBUCKET_DISTRIBUTION_TYPE;
#define VBUCKET_DISTRIBUTION_VBUCKET LCBVB_DIST_VBUCKET
#define VBUCKET_DISTRIBUTION_KETAMA LCBVB_DIST_KETAMA
#define VBUCKET_NO_CHANGES LCBVB_NO_CHANGES
#define VBUCKET_SERVERS_MODIFIED LCBVB_SERVERS_MODIFIED
#define VBUCKET_MAP_MODIFIED LCVBVB_MAP_MODIFIED

LIBCOUCHBASE_API int vbucket_config_parse(lcbvb_CONFIG *, vbucket_source_t, const char *);
LIBCOUCHBASE_API const char *vbucket_get_error_message(lcbvb_CONFIG *);
LIBCOUCHBASE_API lcbvb_CONFIG *vbucket_config_create(void);
LIBCOUCHBASE_API void vbucket_config_destroy(lcbvb_CONFIG *);
LIBCOUCHBASE_API int vbucket_config_get_num_replicas(lcbvb_CONFIG *);
LIBCOUCHBASE_API int vbucket_config_get_num_vbuckets(lcbvb_CONFIG *);
LIBCOUCHBASE_API int vbucket_config_get_num_servers(lcbvb_CONFIG *);
LIBCOUCHBASE_API const char *vbucket_config_get_server(lcbvb_CONFIG *, int);
LIBCOUCHBASE_API const char *vbucket_config_get_couch_api_base(lcbvb_CONFIG *, int);
LIBCOUCHBASE_API const char *vbucket_config_get_rest_api_server(lcbvb_CONFIG *, int);
LIBCOUCHBASE_API lcbvb_DISTMODE vbucket_config_get_distribution_type(lcbvb_CONFIG *);
LIBCOUCHBASE_API int vbucket_map(lcbvb_CONFIG *, const void *, lcb_SIZE, int *, int *);
LIBCOUCHBASE_API int vbucket_get_vbucket_by_key(lcbvb_CONFIG *, const void *, lcb_SIZE);
LIBCOUCHBASE_API int vbucket_get_master(lcbvb_CONFIG *, int);
LIBCOUCHBASE_API int vbucket_get_replica(lcbvb_CONFIG *, int, int);
LIBCOUCHBASE_API lcbvb_CONFIGDIFF *vbucket_compare(lcbvb_CONFIG *, lcbvb_CONFIG *);
LIBCOUCHBASE_API void vbucket_free_diff(lcbvb_CONFIGDIFF *);
LIBCOUCHBASE_API int vbucket_config_get_revision(lcbvb_CONFIG *);
LIBCOUCHBASE_API lcbvb_CHANGETYPE vbucket_what_changed(lcbvb_CONFIGDIFF *diff);
LIBCOUCHBASE_API int vbucket_config_generate(lcbvb_CONFIG *vb, unsigned, unsigned, unsigned);

#ifdef __cplusplus
}
#endif
#endif