时间:2021-07-01 10:21:17 帮助过:24人阅读
Redis的sentinel模式使用了Hiredis代码,Hiredis是redis数据库一个轻量级的C语言客户端库。它实现的向Redis发送命令的API函数redisCommand,使用方法类于printf。因此只要熟悉redis命令,就可以很容易的使用该函数将redis命令字符串,转换成统一请求协议式之
Redis的sentinel模式使用了Hiredis代码,Hiredis是redis数据库一个轻量级的C语言客户端库。它实现的向Redis发送命令的API函数redisCommand,使用方法类似于printf。因此只要熟悉redis命令,就可以很容易的使用该函数将redis命令字符串,转换成统一请求协议格式之后,发送给Redis服务器。
Hiredis库包含三类API:同步操作API、异步操作API和回复解析API。本文主要介绍同步操作API和回复解析API,下一篇介绍异步操作API。
一:同步操作API
所谓的同步操作,就是以阻塞的方式向Redis服务器建链,发送命令,接收命令回复。使用同步操作API,主要涉及以下三个API函数:
redisContext *redisConnect(const char *ip, int port); void *redisCommand(redisContext *c, const char *format, ...); void freeReplyObject(void *reply);
1:TCP建链
redisConnect函数创建一个上下文结构redisContext,并向Redis服务器发起TCP建链。该函数是同步建链API,因此该函数返回后,要么TCP已经建链成功了,要么建链期间发生了错误,可以通过检查redisContext结构的err和errstr属性得到错误类型和错误类型。
redisConnect的代码较简单,如下:
redisContext *redisConnect(const char *ip, int port) { redisContext *c; c = redisContextInit(); if (c == NULL) return NULL; c->flags |= REDIS_BLOCK; redisContextConnectTcp(c,ip,port,NULL); return c; }
redisContext上下文结构用于保存所有与Redis服务器连接的状态。比如socket描述符,输出缓存,回复解析器等。该结构的定义如下:
typedef struct redisContext { int err; /* Error flags, 0 when there is no error */ char errstr[128]; /* String representation of error when applicable */ int fd; int flags; char *obuf; /* Write buffer */ redisReader *reader; /* Protocol reader */ } redisContext;
属性err为非0时,表示与Redis服务器的连接发生了错误,属性errstr就包含一个描述该错误的字符串。因此,每次与Redis进行交互之后,就需要检查该属性判断是否发生了错误,一旦有错误发生,则立即终止与Redis的链接。
属性fd就是与Redis服务器链接的socket描述符;flags表示客户端标志位,表示客户端当前的状态;
obuf就是输出缓存,当用户调用redisCommand向Redis发送命令时,命令字符串首先就是追加到该输出缓存中;
reader是一个回复解析器,后续在“回复解析API”中会详细介绍。
2:发送命令,接收回复
用户可以调用redisCommand函数向Redis服务器发送命令,该函数返回Redis的回复信息。该函数的原型如下:
void *redisCommand(redisContext *c, const char *format, ...)
该函数类似于printf,支持不定参数,使用起来很方便,比如:
reply = redisCommand(context, "SET foo bar");
redisCommand函数返回NULL表示发生了错误,可以通过检查redisContext结构中的err得到错误类型;如果执行成功,则返回值是一个指向redisReply结构的指针,其中包含了Redis的回复信息。
可以在格式字符串中使用”%s”,表示在命令中插入一个字符串,此时使用strlen判断字符串的长度:
reply = redisCommand(context, "SET foo %s", value);
如果需要在命令中传递二进制安全的字符串,可以使用”%b”,此时需要一个size_t类型的参数表示该字符串的长度:
reply = redisCommand(context, "SET foo %b", value, (size_t) valuelen);
redisCommand主要是通过redisvCommand实现的,而redisvCommand主要是通过redisvAppendCommand和__redisBlockForReply两个函数实现。它们的代码如下:
void *redisvCommand(redisContext *c, const char *format, va_list ap) { if (redisvAppendCommand(c,format,ap) != REDIS_OK) return NULL; return __redisBlockForReply(c); } void *redisCommand(redisContext *c, const char *format, ...) { va_list ap; void *reply = NULL; va_start(ap,format); reply = redisvCommand(c,format,ap); va_end(ap); return reply; }
redisvAppendCommand函数作用是解析用户的输入,并将用户输入的命令字符串转换成Redis统一请求协议的格式,存储到上下文结构redisContext中的输出缓存obuf中,它的代码如下:
int redisvAppendCommand(redisContext *c, const char *format, va_list ap) { char *cmd; int len; len = redisvFormatCommand(&cmd,format,ap); if (len == -1) { __redisSetError(c,REDIS_ERR_OOM,"Out of memory"); return REDIS_ERR; } if (__redisAppendCommand(c,cmd,len) != REDIS_OK) { free(cmd); return REDIS_ERR; } free(cmd); return REDIS_OK; } int __redisAppendCommand(redisContext *c, const char *cmd, size_t len) { sds newbuf; newbuf = sdscatlen(c->obuf,cmd,len); if (newbuf == NULL) { __redisSetError(c,REDIS_ERR_OOM,"Out of memory"); return REDIS_ERR; } c->obuf = newbuf; return REDIS_OK; }
redisvAppendCommand首先调用redisvFormatCommand函数,用于解析用户输入的命令字符串,并将字符串转换成协议格式之后,保存在cmd中。然后调用__redisAppendCommand函数,将cmd追加到输出缓存c->obuf中。代码较简单,不在赘述。
在redisvCommand函数中,调用redisvAppendCommand之后,接下来就是调用__redisBlockForReply函数,将输出缓存中的内容发送给Redis服务器,并读取Redis的回复,并解析之。
__redisBlockForReply函数主要是通过redisGetReply实现的,它们的代码如下:
static void *__redisBlockForReply(redisContext *c) { void *reply; if (c->flags & REDIS_BLOCK) { if (redisGetReply(c,&reply) != REDIS_OK) return NULL; return reply; } return NULL; } int redisGetReply(redisContext *c, void **reply) { int wdone = 0; void *aux = NULL; /* Try to read pending replies */ if (redisGetReplyFromReader(c,&aux) == REDIS_ERR) return REDIS_ERR; /* For the blocking context, flush output buffer and read reply */ if (aux == NULL && c->flags & REDIS_BLOCK) { /* Write until done */ do { if (redisBufferWrite(c,&wdone) == REDIS_ERR) return REDIS_ERR; } while (!wdone); /* Read until there is a reply */ do { if (redisBufferRead(c) == REDIS_ERR) return REDIS_ERR; if (redisGetReplyFromReader(c,&aux) == REDIS_ERR) return REDIS_ERR; } while (aux == NULL); } /* Set reply object */ if (reply != NULL) *reply = aux; return REDIS_OK; }
在redisGetReply中,首先是循环调用redisBufferWrite,将输出缓存c->obuf中的所有内容发送给Redis。然后循环调用redisBufferRead,读取Redis的回复,并调用函数redisGetReplyFromReader对回复信息进行解析。
redisBufferRead函数的代码如下:
int redisBufferRead(redisContext *c) { char buf[1024*16]; int nread; /* Return early when the context has seen an error. */ if (c->err) return REDIS_ERR; nread = read(c->fd,buf,sizeof(buf)); if (nread == -1) { if ((errno == EAGAIN && !(c->flags & REDIS_BLOCK)) || (errno == EINTR)) { /* Try again later */ } else { __redisSetError(c,REDIS_ERR_IO,NULL); return REDIS_ERR; } } else if (nread == 0) { __redisSetError(c,REDIS_ERR_EOF,"Server closed the connection"); return REDIS_ERR; } else { if (redisReaderFeed(c->reader,buf,nread) != REDIS_OK) { __redisSetError(c,c->reader->err,c->reader->errstr); return REDIS_ERR; } } return REDIS_OK; }
该函数主要是从socket中读取数据到buf中,然后通过函数redisReaderFeed,将buf内容追加到解析器的输入缓存中。redisReaderFeed函数属于回复解析API函数。
二:回复解析API
回复解析API的函数主要有下面几个:
redisReader *redisReaderCreate(void); void redisReaderFree(redisReader *reader); int redisReaderFeed(redisReader *reader, const char *buf, size_t len); int redisReaderGetReply(redisReader *reader, void **reply);
1:输入缓存
解析器结构redisReader,是回复解析API最主要的数据结构。它的部分定义如下:
/* State for the protocol parser */ typedef struct redisReader { int err; /* Error flags, 0 when there is no error */ char errstr[128]; /* String representation of error when applicable */ char *buf; /* Read buffer */ size_t pos; /* Buffer cursor */ size_t len; /* Buffer length */ size_t maxbuf; /* Max length of unused buffer */ ... } redisReader;
其中的err和errstr属性与redisContext结构中的err和errstr属性作用一样,都是用于保存错误类型和错误信息的;
buf属性就是输入缓存,redisReaderFeed函数将读取到的Redis回复信息都存储到该缓存中,该缓存根据回复信息可以动态扩容。len表示当前缓存的容量;pos表示缓存当前的读取索引,每次读取输入缓存时,都是从reader->buf + reader->pos处开始读取,读取数据之后,会增加pos的值;
maxbuf属性表示输入缓存所允许的最大闲置空间。为了节省内存空间,当buf为空,并且当前buf的闲置空间大于reader->maxbuf时,就会释放r->buf,重新为其申请空间。该属性的默认值为16K。如果置为0,表示无此限制。
redisReaderFeed就是将从socket读取的Redis回复信息,追加到输入缓存的函数。其代码如下:
int redisReaderFeed(redisReader *r, const char *buf, size_t len) { sds newbuf; /* Return early when this reader is in an erroneous state. */ if (r->err) return REDIS_ERR; /* Copy the provided buffer. */ if (buf != NULL && len >= 1) { /* Destroy internal buffer when it is empty and is quite large. */ if (r->len == 0 && r->maxbuf != 0 && sdsavail(r->buf) > r->maxbuf) { sdsfree(r->buf); r->buf = sdsempty(); r->pos = 0; /* r->buf should not be NULL since we just free'd a larger one. */ assert(r->buf != NULL); } newbuf = sdscatlen(r->buf,buf,len); if (newbuf == NULL) { __redisReaderSetErrorOOM(r); return REDIS_ERR; } r->buf = newbuf; r->len = sdslen(r->buf); } return REDIS_OK; }
2:解析
在redisGetReply函数中,将Redis的回复信息追加到解析器输入缓存之后,接下来就会调用函数redisGetReplyFromReader对解析器的输入缓存中的消息进行解析,解析的内容以redisReply结构进行组织。
如果回复信息是嵌套的话,则形成一颗以redisReply结构为节点的多叉树;如果回复信息只是基本信息的话,则该树仅仅包含一个根节点。redisCommand函数就是返回一个指向redisReply结构树根节点的指针。redisReply结构树的宽度没有限制,但是深度的最大值为7,也就是仅允许最多7层嵌套。
首先看一下redisReply结构的定义如下:
/* This is the reply object returned by redisCommand() */ typedef struct redisReply { int type; long long integer; int len; char *str; size_t elements; struct redisReply **element; } redisReply;
该结构中的type成员表示Redis回复信息的类型,可以有下面几种类型:
REDIS_REPLY_STATUS:状态回复,状态信息以'+'开头。str属性保存Redis回复的状态信息字符串,该字符串的长度保存在len属性中。
REDIS_REPLY_ERROR:错误回复,错误信息以'-'开头。str属性保存Redis回复的错误信息字符串,该字符串的长度保存在len属性中。
REDIS_REPLY_INTEGER:整数回复,整数信息以':'开头。integer 属性保存Redis回复的整数值。
REDIS_REPLY_STRING:单行字符串回复,这种信息以'$'开头。str属性保存Redis回复的字符串信息,该字符串的长度保存在len属性中。
REDIS_REPLY_NIL:Redis回复”nil”。
以上的类型可以称为基本类型。
REDIS_REPLY_ARRAY:数组回复,也就是嵌套回复,数组信息以'*'开头,后接数组元素个数。数组中的元素可以是以上所有基本类型,也可以是REDIS_REPLY_ARRAY类型,也就是数组嵌套数组。
数组元素的个数保存在elements属性中,数组元素也以redisReply结构表示,指向数组元素的指针保存在element指针数组中,也就是说,指针数组element中保存了所有孩子节点的指针。
经过回复解析API函数redisReaderGetReply的解析之后,最终形成的redisReply结构树,非叶子节点只能是REDIS_REPLY_ARRAY类型,叶子节点的类型只能是基本类型。
处理数组信息的代码较复杂,以一个例子说明。假设Redis的回复信息是:"*3\r\n*3\r\n:11\r\n:12\r\n:13\r\n*3\r\n:21\r\n:22\r\n:23\r\n:31\r\n"。
分析该字符串,第一个字符为”*”,表明这是一条数组回复,后面的3表示数组元素的个数,因此,最终形成的树,根节点有3个孩子节点。
接下来就是根节点各个孩子节点的信息。第一个孩子节点首字符还是”*”,说明该孩子节点又是一个数组信息,它也有3个孩子。接下来就是3个孩子信息,也就是3个整数:11,12和13。
接下来是根节点第二个孩子节点的信息。首字符还是”*”,说明该孩子节点也是一个数组,它也有3个孩子,分别是整数:21,22和23。
接下来是根节点最后一个孩子的信息,首字符是”:”,说明该孩子节点是一个整数,整数值为31。
根据以上的分析,最终形成的树如下图:
上图中,非叶子节点都是REDIS_REPLY_ARRAY类型的redisReply结构,叶子节点是REDIS_REPLY_INTEGER类型的redisReply结构。
回复解析API函数redisReaderGetReply的作用,就是解析回复信息,最终形成一颗这样的redisReply结构树。
在回复解析API的代码中,使用redisReadTask任务结构解析回复信息,构建每个redisReply结构节点,填充到树中合适的位置。
redisReadTask结构包含解析器结构redisReader中,redisReader结构剩下的定义如下:
typedef struct redisReader { ... redisReadTask rstack[9]; int ridx; /* Index of current read task */ void *reply; /* Temporary reply pointer */ redisReplyObjectFunctions *fn; void *privdata; } redisReader;
在redisReader结构中,redisReadTask结构数组rstack大小为9。rstack[0]用于处理redisReply结构树中的根节点;rstack[1]表示处理redisReply结构树中的第一层子节点,以此类推。
ridx属性表示当前正在处理第几层子节点;fn属性是一个redisReplyObjectFunctions结构体,该结构中包含了用于生成各种类型redisReply结构的函数;
reply属性指向redisReply结构树中的根节点
构建每个redisReply结构节点的redisReadTask结构定义如下:
typedef struct redisReadTask { int type; int elements; /* number of elements in multibulk container */ int idx; /* index in parent (array) object */ void *obj; /* holds user-generated value for a read task */ struct redisReadTask *parent; /* parent task */ void *privdata; /* user-settable arbitrary field */ } redisReadTask;
type表示该redisReadTask结构当前处理的信息类型,与其当前构建的redisReply结构节点中的type一致;
elements表示当前构建的REDIS_REPLY_ARRAY类型的redisReply结构节点中,包含的子节点数目。也就是redisReply结构节点中,数组element中的元素个数;idx表示当前构建的redisReply结构节点,在其父节点element数组中的索引;obj就是指向当前正在构建的REDIS_REPLY_ARRAY 类型的redisReply结构节点,parent表示正在处理当前节点的父节点的redisReadTask结构。
回复解析API函数redisReaderGetReply的代码如下:
int redisReaderGetReply(redisReader *r, void **reply) { /* Default target pointer to NULL. */ if (reply != NULL) *reply = NULL; /* Return early when this reader is in an erroneous state. */ if (r->err) return REDIS_ERR; /* When the buffer is empty, there will never be a reply. */ if (r->len == 0) return REDIS_OK; /* Set first item to process when the stack is empty. */ if (r->ridx == -1) { r->rstack[0].type = -1; r->rstack[0].elements = -1; r->rstack[0].idx = -1; r->rstack[0].obj = NULL; r->rstack[0].parent = NULL; r->rstack[0].privdata = r->privdata; r->ridx = 0; } /* Process items in reply. */ while (r->ridx >= 0) if (processItem(r) != REDIS_OK) break; /* Return ASAP when an error occurred. */ if (r->err) return REDIS_ERR; /* Discard part of the buffer when we've consumed at least 1k, to avoid * doing unnecessary calls to memmove() in sds.c. */ if (r->pos >= 1024) { sdsrange(r->buf,r->pos,-1); r->pos = 0; r->len = sdslen(r->buf); } /* Emit a reply when there is one. */ if (r->ridx == -1) { if (reply != NULL) *reply = r->reply; r->reply = NULL; } return REDIS_OK; }
首先,将r->ridx置为0,然后初始化r->rstack[0],表示接下来开始构建根节点。
接下来的语句,就是循环调用processItem函数,直到r->ridx再次等于-1。循环调用processItem函数的过程,就是以深度优先的顺序构建redisReply结构树的过程。
processItem函数的代码如下:
static int processItem(redisReader *r) { redisReadTask *cur = &(r->rstack[r->ridx]); char *p; /* check if we need to read type */ if (cur->type < 0) { if ((p = readBytes(r,1)) != NULL) { switch (p[0]) { case '-': cur->type = REDIS_REPLY_ERROR; break; case '+': cur->type = REDIS_REPLY_STATUS; break; case ':': cur->type = REDIS_REPLY_INTEGER; break; case '$': cur->type = REDIS_REPLY_STRING; break; case '*': cur->type = REDIS_REPLY_ARRAY; break; default: __redisReaderSetErrorProtocolByte(r,*p); return REDIS_ERR; } } else { /* could not consume 1 byte */ return REDIS_ERR; } } /* process typed item */ switch(cur->type) { case REDIS_REPLY_ERROR: case REDIS_REPLY_STATUS: case REDIS_REPLY_INTEGER: return processLineItem(r); case REDIS_REPLY_STRING: return processBulkItem(r); case REDIS_REPLY_ARRAY: return processMultiBulkItem(r); default: assert(NULL); return REDIS_ERR; /* Avoid warning. */ } }
首先得到构建当前节点的redisReadTask结构cur,然后从输入缓存中读取首个字符,以判断接下来的回复信息的类型,赋值到cur->type中。
得到类型信息之后,就调用不同的函数处理不同的类型。首先看一下处理数组类型的函数processMultiBulkItem的实现:
static int processMultiBulkItem(redisReader *r) { redisReadTask *cur = &(r->rstack[r->ridx]); void *obj; char *p; long elements; int root = 0; /* Set error for nested multi bulks with depth > 7 */ if (r->ridx == 8) { __redisReaderSetError(r,REDIS_ERR_PROTOCOL, "No support for nested multi bulk replies with depth > 7"); return REDIS_ERR; } if ((p = readLine(r,NULL)) != NULL) { elements = readLongLong(p); root = (r->ridx == 0); if (elements == -1) { if (r->fn && r->fn->createNil) obj = r->fn->createNil(cur); else obj = (void*)REDIS_REPLY_NIL; if (obj == NULL) { __redisReaderSetErrorOOM(r); return REDIS_ERR; } moveToNextTask(r); } else { if (r->fn && r->fn->createArray) obj = r->fn->createArray(cur,elements); else obj = (void*)REDIS_REPLY_ARRAY; if (obj == NULL) { __redisReaderSetErrorOOM(r); return REDIS_ERR; } /* Modify task stack when there are more than 0 elements. */ if (elements > 0) { cur->elements = elements; cur->obj = obj; r->ridx++; r->rstack[r->ridx].type = -1; r->rstack[r->ridx].elements = -1; r->rstack[r->ridx].idx = 0; r->rstack[r->ridx].obj = NULL; r->rstack[r->ridx].parent = cur; r->rstack[r->ridx].privdata = r->privdata; } else { moveToNextTask(r); } } /* Set reply if this is the root object. */ if (root) r->reply = obj; return REDIS_OK; } return REDIS_ERR; }
首先得到构建当前节点的redisReadTask结构cur,然后调用readLine函数,从输入缓存中读取一行信息(”\r\n”之前的内容),并解析出当前节点中包含的元素个数elements。
如果elements不是-1,说明正确解析到了数组元素个数,接下来调用r->fn->createArray创建一个数组类型的redisReply结构节点。然后将创建的redisReply结构信息记录到cur中:将元素个数记录到cur->elements中,将创建的redisReply记录到cur->obj中:
cur->elements = elements; cur->obj = obj;
数组类型的redisReply结构节点创建完成后,接下来就是开始构建其各个子节点。首先就是将r->ridx加1,并初始化r->rstack[r->ridx]结构,注意这里置r->rstack[r->ridx].idx为0.表示接下来首先构建第一个子节点。
下面是创建数组类型redisReply结构的函数createArrayObject的代码:
static void *createArrayObject(const redisReadTask *task, int elements) { redisReply *r, *parent; r = createReplyObject(REDIS_REPLY_ARRAY); if (r == NULL) return NULL; if (elements > 0) { r->element = calloc(elements,sizeof(redisReply*)); if (r->element == NULL) { freeReplyObject(r); return NULL; } } r->elements = elements; if (task->parent) { parent = task->parent->obj; assert(parent->type == REDIS_REPLY_ARRAY); parent->element[task->idx] = r; } return r; }
该函数中,重点是要理解下面的代码:
if (task->parent) { parent = task->parent->obj; assert(parent->type == REDIS_REPLY_ARRAY); parent->element[task->idx] = r; }
这段代码的作用,就是将指向新创建的redisReply结构节点的指针r,存放到其父节点的element数组中,存放索引就是task->idx。
如果task->parent不为NULL,说明当前新建的redisReply结构节点具有父节点,根据当前task得到该父节点redisReply结构parent。然后将当前节点放到存储到父节点的element数组中的task-idx索引处。
接下来是moveToNextTask函数的实现,该函数的主要作用,实际上是变更属性r->ridx和cur->idx。说白了,就是为下一个要创建的节点,找到合适的位置。代码如下:
static void moveToNextTask(redisReader *r) { redisReadTask *cur, *prv; while (r->ridx >= 0) { /* Return a.s.a.p. when the stack is now empty. */ if (r->ridx == 0) { r->ridx--; return; } cur = &(r->rstack[r->ridx]); prv = &(r->rstack[r->ridx-1]); assert(prv->type == REDIS_REPLY_ARRAY); if (cur->idx == prv->elements-1) { r->ridx--; } else { /* Reset the type because the next item can be anything */ assert(cur->idx < prv->elements); cur->type = -1; cur->elements = -1; cur->idx++; return; } } }
在while循环中,首先得到处理当前节点的redisReadTask结构cur,然后是正处理该节点父节点的redisReadTask结构prv。
cur->idx记录了当前处理的节点,其在父节点中的element数组中的索引,也就是当前节点是父节点的第几个孩子。
prv->elements表示当前节点的父节点,共有几个孩子。
因此,如果cur->idx小于prv->elements的话,则接下来,cur结构要开始构建当前节点的下一个兄弟节点了,因此将cur->idx加1。
如果cur->idx等于prv->elements的话,说明当前节点,已经是其父节点最后一个孩子节点了。接下来,就开始构建当前节点的叔叔结点了(父节点的兄弟节点),因此r->ridx--,表示回溯。上移一层,将父结点变成当前节点,然后接着判断新的cur点在其父节点中是否是最后一个孩子,若是,则接着回溯,否则开始构建其兄弟节点。
如果当前节点已经是根节点了(r->ridx == 0),因为根节点没有兄弟节点,因此将r->ridx置为-1后,直接返回。
构建好一颗redisReply结构树之后,如果需要释放它,可以通过API函数freeReplyObject实现,代码如下:
void freeReplyObject(void *reply) { redisReply *r = reply; size_t j; switch(r->type) { case REDIS_REPLY_INTEGER: break; /* Nothing to free */ case REDIS_REPLY_ARRAY: if (r->element != NULL) { for (j = 0; j < r->elements; j++) if (r->element[j] != NULL) freeReplyObject(r->element[j]); free(r->element); } break; case REDIS_REPLY_ERROR: case REDIS_REPLY_STATUS: case REDIS_REPLY_STRING: if (r->str != NULL) free(r->str); break; } free(r); }
标准的深度优先顺序进行释放。不再赘述。
以上就是回复解析API的主要工作流程。构建redisReply结构树和redisReadTask结构的作用比较晦涩,但是却是一个很好的构建多叉树的例子。学习代码时,脑子中跟着代码逐步建立这颗树就好理解了。
参考:
http://blog.csdn.net/it_small_farmer/article/details/41726293