libcoubase源码解析

libcouchbase是couchbase的客户端库，有很多的语言版本，现在看的是c语言2.0.6版本。

libcouchbase支持时间循环使用libevent或者libev，并且在默认情况下，优先选择libevent，如果不存在libevent，再使用libev，这样的逻辑选择在函数栈

#0  create_v1 (io=0x7fffffffd5d8, options=0x7fffffffd500) at src/iofactory.c:218

#1  0x00002aaaaaacd34c in create_v0 (options=0x7fffffffd520, io=0x7fffffffd5d8) at src/iofactory.c:202

#2  lcb_create_io_ops (io=0x7fffffffd5d8, io_opts=<optimized out>) at src/iofactory.c:172

#3  0x00002aaaaaac7a9e in lcb_create (instance=0x2aaaace8b220, options=<optimized out>) at src/instance.c:311

中能够提现出来。

作为一个异步的网络程序，需要下面三个关键部件：

1 读写事件循环，更新接口

2 读写缓冲

3 读写事件回掉回掉

对应libcouchbase，为：

1 lcb_io_run_event_loop，这是个事件循环接口，因为选择的libev或者libevent不同而具体实现不同。lcb_io_update_event，这是事件更新接口，用于开始或者结束事件监测。

2 ringbuffer，作为读写的缓冲层，在可读事件发生后，会从socket上读数据到buffer中，当可写事件发生后，会从socket上写数据到buffer中

3 lcb_server_event_handler，在读写事件发生后，调用具体的读写函数：do_send_data和do_read_data

真正进行写操作的栈如下：

#0  0x0000003267c0ed20 in sendmsg () from /lib64/libpthread.so.0

#1  0x00002aee4385128c in lcb_io_sendv (iops=0x2aee435dc540, sock=<optimized out>, iov=<optimized out>, niov=<optimized out>) at plugins/io/libev/plugin-libev.c:113

#2  0x00002aee411f0f6a in do_send_data (c=<optimized out>) at src/event.c:318

#3  lcb_server_event_handler (sock=<optimized out>, which=4, arg=0x2aee437b6108) at src/event.c:377

#4  0x00002aee423d23cd in ev_invoke_pending (loop=0x2aee435d7200) at ev.c:2994

#5  0x00002aee423d32bf in ev_run (loop=0x2aee435d7200, flags=0) at ev.c:3394

#6  0x00002aee43850de6 in lcb_io_run_event_loop (iops=<optimized out>) at plugins/io/libev/plugin-libev.c:337

#7  0x00002aee411fcce3 in lcb_wait (instance=0x2aee437ab800) at src/wait.c:67

作为客户端需要一个结构体描述对端的server，如下：

 /**
* The structure representing each couchbase server
*/
struct lcb_server_st {
/** The server index in the list */
int index;
/** Non-zero for node is using for configuration */
int is_config_node;
/** The name of the server */
char *hostname;
/** The servers port */
char *port;
/** The server endpoint as hostname:port */
char *authority;
/** The Couchbase Views API endpoint base */
char *couch_api_base;
/** The REST API server as hostname:port */
char *rest_api_server;
/** The socket to the server */
lcb_socket_t sock;
/** The address information for this server (the one to release) */
struct addrinfo *root_ai;
/** The address information for this server (the one we're trying) */
struct addrinfo *curr_ai;

/** The output buffer for this server */
ringbuffer_t output;
/** The sent buffer for this server so that we can resend the
* command to another server if the bucket is moved... */
ringbuffer_t cmd_log;
ringbuffer_t output_cookies;
/**
* The pending buffer where we write data until we're in a
* connected state;
*/
ringbuffer_t pending;
ringbuffer_t pending_cookies;

/** The input buffer for this server */
ringbuffer_t input;

/** The set of the pointers to HTTP requests to couchbase (Views and
* Management API) */
hashset_t http_requests;

/** The SASL object used for this server */
sasl_conn_t *sasl_conn;
/** The event item representing _this_ object */
void *event;
/** The timer bound to the socket to implement timeouts */
void *timer;
/** Is this server in a connected state (done with sasl auth) */
int connected;
/* Pointer back to the instance */
lcb_t instance;
};

其中ringbuffer_t 用来做缓存。

其中lcb_t实际是一个指针。指向的结构体如下：

struct lcb_st {
/**
* the type of the connection:
* * LCB_TYPE_BUCKET
* NULL for bucket means "default" bucket
* * LCB_TYPE_CLUSTER
* the bucket argument ignored and all data commands will
* return LCB_EBADHANDLE
*/
lcb_type_t type;
/** The couchbase host */
char host[NI_MAXHOST + 1];
/** The port of the couchbase server */
char port[NI_MAXSERV + 1];

/** The URL request to send to the server */
char *http_uri;
lcb_size_t n_http_uri_sent;

/** The event item representing _this_ object */
void *event;

/** The current vbucket config handle */
VBUCKET_CONFIG_HANDLE vbucket_config;

struct {
char *header;
buffer_t input;
lcb_size_t chunk_size;
buffer_t chunk;
} vbucket_stream;

struct lcb_io_opt_st *io;

/** The number of weird things happened with config node
* This counter reflects event on memcached port (default 11210),
* but used to make decisions about healthiness of the
* configuration port (default 8091).
*/
lcb_size_t weird_things;
lcb_size_t weird_things_threshold;

/* The current synchronous mode */
lcb_syncmode_t syncmode;

lcb_socket_t sock;
struct addrinfo *ai;
struct addrinfo *curr_ai;

/** The number of couchbase server in the configuration */
lcb_size_t nservers;
/** The array of the couchbase servers */
lcb_server_t *servers;

/** if non-zero, backup_nodes entries should be freed before
freeing the pointer itself */
int should_free_backup_nodes;
/** The array of last known nodes as hostname:port */
char **backup_nodes;
/** The current connect index */
int backup_idx;

/** The type of the key distribution */
VBUCKET_DISTRIBUTION_TYPE dist_type;
/** The number of replicas */
lcb_uint16_t nreplicas;
/** The number of vbuckets */
lcb_uint16_t nvbuckets;
/** A map from the vbucket to the server hosting the vbucket */
lcb_vbucket_t *vb_server_map;

vbucket_state_listener_t vbucket_state_listener;

/* credentials needed to operate cluster via REST API */
char *username;
char *password;

struct {
const char *name;
union {
sasl_secret_t secret;
char buffer[256];
} password;
sasl_callback_t callbacks[4];
} sasl;

/** The set of the timers */
hashset_t timers;
/** The set of the pointers to HTTP requests to Cluster */
hashset_t http_requests;

struct lcb_callback_st callbacks;
struct lcb_histogram_st *histogram;

lcb_uint32_t seqno;
int wait;
int connected;
/** Is IPv6 enabled */
lcb_ipv6_t ipv6;
const void *cookie;

lcb_error_t last_error;

struct {
hrtime_t next;
void *event;
lcb_uint32_t usec;
} timeout;

struct {
lcb_compat_t type;
union {
struct {
time_t mtime;
char *cachefile;
int updating;
int needs_update;
} cached;
} value;
} compat;

#ifdef LCB_DEBUG
lcb_debug_st debug;
#endif
};
所以和io相关的操作是这样调用的：

server->instance->io->v.v0.update_event

couchbase client是通过长链接的方式和server链接的，这样每一个client只需要在创建的时候进行一次事件循环初始化，后续的事件更新都是在回调中进行的。