Redis源碼剖析和注釋（二十）--- 網路連接庫剖析(client的建立/釋放、命令接收/回複、Redis通訊協定分析等)

Redis 網路連接庫剖析 1. Redis網路連接庫介紹

Redis網路連接庫對應的檔案是networking.c。這個檔案主要負責 用戶端的建立與釋放 命令接收與命令回複 Redis通訊協定分析 CLIENT 命令的實現

我們接下來就這幾塊內容分別列出源碼，進行剖析。 2. 用戶端的建立與釋放

redis 網路連結庫的源碼詳細注釋 2.1用戶端的建立

Redis 伺服器是一個同時與多個用戶端建立串連的程式。當用戶端串連上伺服器時，伺服器會建立一個server.h/client結構來儲存用戶端的狀態資訊。所以在用戶端建立時，就會初始化這樣一個結構，用戶端的建立源碼如下：

client *createClient(int fd) {    client *c = zmalloc(sizeof(client));    //分配空間    // 如果fd為-1，表示建立的是一個無網路連接的偽用戶端，用於執行lua指令碼的時候。    // 如果fd不等於-1，表示建立一個有網路連接的用戶端    if (fd != -1) {        // 設定fd為非阻塞模式        anetNonBlock(NULL,fd);        // 禁止使用 Nagle 演算法，client向核心遞交的每個資料包都會立即發送給server出去，TCP_NODELAY        anetEnableTcpNoDelay(NULL,fd);        // 如果開啟了tcpkeepalive，則設定 SO_KEEPALIVE        if (server.tcpkeepalive)            // 設定tcp串連的keep alive選項            anetKeepAlive(NULL,fd,server.tcpkeepalive);        // 建立一個檔案事件狀態el，且監聽讀事件，開始接受命令的輸入        if (aeCreateFileEvent(server.el,fd,AE_READABLE,            readQueryFromClient, c) == AE_ERR)        {            close(fd);            zfree(c);            return NULL;        }    }    // 預設選0號資料庫    selectDb(c,0);    // 設定client的ID    c->id = server.next_client_id++;    // client的通訊端    c->fd = fd;    // client的名字    c->name = NULL;    // 回複固定(靜態)緩衝區的位移量    c->bufpos = 0;    // 輸入緩衝區    c->querybuf = sdsempty();    // 輸入緩衝區的峰值    c->querybuf_peak = 0;    // 請求協議類型，內聯或者多條命令，初始化為0    c->reqtype = 0;    // 參數個數    c->argc = 0;    // 參數列表    c->argv = NULL;    // 當前執行的命令和最近一次執行的命令    c->cmd = c->lastcmd = NULL;    // 查詢緩衝區剩餘未讀取命令的數量    c->multibulklen = 0;    // 讀入參數的長度    c->bulklen = -1;    // 已發的位元組數    c->sentlen = 0;    // client的狀態    c->flags = 0;    // 設定建立client的時間和最後一次互動的時間    c->ctime = c->lastinteraction = server.unixtime;    // 認證狀態    c->authenticated = 0;    // replication複製的狀態，初始為無    c->replstate = REPL_STATE_NONE;    // 設定從節點的寫處理器為ack，是否在slave向master發送ack    c->repl_put_online_on_ack = 0;    // replication複製的位移量    c->reploff = 0;    // 通過ack命令接收到的位移量    c->repl_ack_off = 0;    // 通過ack命令接收到的位移量所用的時間    c->repl_ack_time = 0;    // 從節點的連接埠號碼    c->slave_listening_port = 0;    // 從節點IP地址    c->slave_ip[0] = '\0';    // 從節點的功能    c->slave_capa = SLAVE_CAPA_NONE;    // 回複鏈表    c->reply = listCreate();    // 回複鏈表的位元組數    c->reply_bytes = 0;    // 回複緩衝區的記憶體大小軟式節流    c->obuf_soft_limit_reached_time = 0;    // 回複鏈表的釋放和複製方法    listSetFreeMethod(c->reply,decrRefCountVoid);    listSetDupMethod(c->reply,dupClientReplyValue);    // 阻塞類型    c->btype = BLOCKED_NONE;    // 阻塞超過時間    c->bpop.timeout = 0;    // 造成阻塞的鍵字典    c->bpop.keys = dictCreate(&setDictType,NULL);    // 儲存解除阻塞的鍵，用於儲存PUSH入元素的鍵，也就是dstkey    c->bpop.target = NULL;    // 阻塞狀態    c->bpop.numreplicas = 0;    // 要達到的複製位移量    c->bpop.reploffset = 0;    // 全域的複製位移量    c->woff = 0;    // 監控的鍵    c->watched_keys = listCreate();    // 訂閱頻道    c->pubsub_channels = dictCreate(&setDictType,NULL);    // 訂閱模式    c->pubsub_patterns = listCreate();    // 被緩衝的peerid，peerid就是 ip:port    c->peerid = NULL;    // 訂閱發布模式的釋放和比較方法    listSetFreeMethod(c->pubsub_patterns,decrRefCountVoid);    listSetMatchMethod(c->pubsub_patterns,listMatchObjects);    // 將真正的client放在伺服器的用戶端鏈表中    if (fd != -1) listAddNodeTail(server.clients,c);    // 初始化client的事物狀態    initClientMultiState(c);    return c;}

根據傳入的檔案描述符fd，可以建立用於不同情景下的client。這個fd就是伺服器接收用戶端connect後所返回的檔案描述符。 fd == -1。表示建立一個無網路連接的用戶端。主要用於執行 lua 指令碼時。 fd != -1。表示接收到一個正常的用戶端串連，則會建立一個有網路連接的用戶端，也就是建立一個檔案事件，來監聽這個fd是否可讀，當用戶端發送資料，則事件被觸發。建立用戶端時，還會禁用Nagle演算法。

Nagle演算法能自動連接許多的小緩衝器訊息，這一過程（稱為nagling）通過減少必鬚髮送包的個數來增加網路軟體系統的效率。但是伺服器和用戶端的對即使通訊性有很高的要求，因此禁止使用 Nagle 演算法，用戶端向核心遞交的每個資料包都會立即發送給伺服器。

建立用戶端的過程，會將server.h/client結構的所有成員初始化，接下裡會介紹部分重點的成員。 int id：伺服器對於每一個串連進來的都會建立一個ID，用戶端的ID從1開始。每次重啟伺服器會重新整理。 int fd：當前用戶端狀態描述符。分為無網路連接的用戶端和有網路連接的用戶端。 int flags：用戶端狀態的標誌。Redis 3.2.8 中在server.h中定義了23種狀態。 robj *name：預設建立的用戶端是沒有名字的，可以通過CLIENT SETNAME命令設定名字。後面會介紹該命令的實現。 int reqtype：請求協議的類型。因為Redis伺服器支援Telnet的串連，因此Telnet命令請求協議類型是PROTO_REQ_INLINE，而redis-cli命令請求的協議類型是PROTO_REQ_MULTIBULK。

用於儲存伺服器接受用戶端命令的成員： sds querybuf：儲存用戶端發來命令請求的輸入緩衝區。以Redis通訊協定的方式儲存。 size_t querybuf_peak：儲存輸入緩衝區的峰值。 int argc：命令參數個數。 robj *argv：命令參數列表。

用於儲存伺服器給用戶端回複的成員： char buf[16*1024]：儲存執行完命令所得命令回複資訊的靜態緩衝區，它的大小是固定的，所以主要儲存的是一些比較短的回複。分配client結構空間時，就會分配一個16K的大小。 int bufpos：記錄靜態緩衝區的位移量，也就是buf數組已經使用的位元組數。 list *reply：儲存命令回複的鏈表。因為靜態緩衝區大小固定，主要儲存固定長度的命令回複，當處理一些返回大量回複的命令，則會將命令回複以鏈表的形式串連起來。 unsigned long long reply_bytes：儲存回複鏈表的位元組數。 size_t sentlen：已發送回複的位元組數。 2.2 用戶端的釋放

用戶端的釋放freeClient()函數主要就是釋放各種資料結構和清空一些緩衝區等等操作，這裡就不列出源碼。但是我們關注一下非同步釋放用戶端。源碼如下：

// 非同步釋放clientvoid freeClientAsync(client *c) {    // 如果是已經即將關閉或者是lua指令碼的偽client，則直接返回    if (c->flags & CLIENT_CLOSE_ASAP || c->flags & CLIENT_LUA) return;    c->flags |= CLIENT_CLOSE_ASAP;    // 將client加入到即將關閉的client鏈表中    listAddNodeTail(server.clients_to_close,c);}

server.clients_to_close：是伺服器儲存所有待關閉的client鏈表。

設定非同步釋放用戶端的目的主要是：防止底層函數正在向用戶端的輸出緩衝區寫資料的時候，關閉用戶端，這樣是不安全的。Redis會安排用戶端在serverCron()函數的安全時間釋放它。

當然也可以取消非同步釋放，那麼就會調用freeClient()函數立即釋放。源碼如下：

// 取消設定非同步釋放的clientvoid freeClientsInAsyncFreeQueue(void) {    // 遍曆所有即將關閉的client    while (listLength(server.clients_to_close)) {        listNode *ln = listFirst(server.clients_to_close);        client *c = listNodeValue(ln);        // 取消立即關閉的標誌        c->flags &= ~CLIENT_CLOSE_ASAP;        freeClient(c);        // 從即將關閉的client鏈表中刪除        listDelNode(server.clients_to_close,ln);    }}

3. 命令接收與命令回複

redis 網路連結庫的源碼詳細注釋 3.1 命令接收

當用戶端串連上Redis伺服器後，伺服器會得到一個檔案描述符fd，而且伺服器會監聽該檔案描述符的讀事件，這些在createClient()函數中，我們有分析。那麼當用戶端發送了命令，觸發了AE_READABLE事件，那麼就會調用回呼函數readQueryFromClient()來從檔案描述符fd中讀發來的命令，並儲存在輸入緩衝區中querybuf。而這個回呼函數就是我們在Redis 事件處理實現一文中所提到的指向回呼函數的指標rfileProc和wfileProc。那麼，我們先來分析sendReplyToClient()函數。

// 讀取client的輸入緩衝區的內容void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {    client *c = (client*) privdata;    int nread, readlen;    size_t qblen;    UNUSED(el);    UNUSED(mask);    // 讀入的長度，預設16MB    readlen = PROTO_IOBUF_LEN;    /* If this is a multi bulk request, and we are processing a bulk reply     * that is large enough, try to maximize the probability that the query     * buffer contains exactly the SDS string representing the object, even     * at the risk of requiring more read(2) calls. This way the function     * processMultiBulkBuffer() can avoid copying buffers to create the     * Redis Object representing the argument. */    // 如果是多條請求，根據請求的大小，設定讀入的長度readlen    if (c->reqtype == PROTO_REQ_MULTIBULK && c->multibulklen && c->bulklen != -1        && c->bulklen >= PROTO_MBULK_BIG_ARG)    {        int remaining = (unsigned)(c->bulklen+2)-sdslen(c->querybuf);        if (remaining < readlen) readlen = remaining;    }    // 輸入緩衝區的長度    qblen = sdslen(c->querybuf);    // 更新緩衝區的峰值    if (c->querybuf_peak < qblen) c->querybuf_peak = qblen;    // 擴充緩衝區的大小    c->querybuf = sdsMakeRoomFor(c->querybuf, readlen);    // 將client發來的命令，讀入到輸入緩衝區中    nread = read(fd, c->querybuf+qblen, readlen);    // 讀操作出錯    if (nread == -1) {        if (errno == EAGAIN) {            return;        } else {            serverLog(LL_VERBOSE, "Reading from client: %s",strerror(errno));            freeClient(c);            return;        }    // 讀操作完成    } else if (nread == 0) {        serverLog(LL_VERBOSE, "Client closed connection");        freeClient(c);        return;    }    // 更新輸入緩衝區的已用大小和未用大小。    sdsIncrLen(c->querybuf,nread);    // 設定最後一次伺服器和client互動的時間    c->lastinteraction = server.unixtime;    // 如果是主節點，則更新複製操作的位移量    if (c->flags & CLIENT_MASTER) c->reploff += nread;    // 更新從網路輸入的位元組數    server.stat_net_input_bytes += nread;    // 如果輸入緩衝區長度超過伺服器設定的最大緩衝區長度    if (sdslen(c->querybuf) > server.client_max_querybuf_len) {        // 將client資訊轉換為sds        sds ci = catClientInfoString(sdsempty(),c), bytes = sdsempty();        // 輸入緩衝區儲存在bytes中        bytes = sdscatrepr(bytes,c->querybuf,64);        // 列印到日誌        serverLog(LL_WARNING,"Closing client that reached max query buffer length: %s (qbuf initial bytes: %s)", ci, bytes);        // 釋放空間        sdsfree(ci);        sdsfree(bytes);        freeClient(c);        return;    }    // 處理client輸入的命令內容    processInputBuffer(c);}

實際上，這個readQueryFromClient()函數是read函數的封裝，從檔案描述符fd中讀出資料到輸入緩衝區querybuf中，並更新輸入緩衝區的峰值querybuf_peak，而且會檢查讀的長度，如果大於了server.client_max_querybuf_len則會退出，而這個閥值在伺服器初始化為PROTO_MAX_QUERYBUF_LEN (1024*1024*1024)也就是1G大小。

回憶之前的各種命令實現，都是通過client的argv和argc這兩個成員來處理的。因此，伺服器還需要將輸入緩衝區querybuf中的資料，處理成參數列表的對象，也就是上面的processInputBuffer()函數。源碼如下：

// 處理client輸入的命令內容void processInputBuffer(client *c) {    server.current_client = c;    /* Keep processing while there is something in the input buffer */    // 一直讀輸入緩衝區的內容    while(sdslen(c->querybuf)) {        /* Return if clients are paused. */        // 如果處於暫停狀態，直接返回        if (!(c->flags & CLIENT_SLAVE) && clientsArePaused()) break;        /* Immediately abort if the client is in the middle of something. */        // 如果client處於被阻塞狀態，直接返回        if (c->flags & CLIENT_BLOCKED) break;        // 如果client處於關閉狀態，則直接返回        if (c->flags & (CLIENT_CLOSE_AFTER_REPLY|CLIENT_CLOSE_ASAP)) break;        /* Determine request type when unknown. */        // 如果是未知的請求類型，則判定請求類型        if (!c->reqtype) {            // 如果是"*"開頭，則是多條請求，是client發來的            if (c->querybuf[0] == '*') {                c->reqtype = PROTO_REQ_MULTIBULK;            // 否則就是內聯請求，是Telnet發來的            } else {                c->reqtype = PROTO_REQ_INLINE;            }        }        // 如果是內聯請求        if (c->reqtype == PROTO_REQ_INLINE) {            // 處理Telnet發來的內聯命令，並建立成對象，儲存在client的參數列表中            if (processInlineBuffer(c) != C_OK) break;        // 如果是多條請求        } else if (c->reqtype == PROTO_REQ_MULTIBULK) {            // 將client的querybuf中的協議內容轉換為client的參數列表中的對象            if (processMultibulkBuffer(c) != C_OK) break;        } else {            serverPanic("Unknown request type");        }        /* Multibulk processing could see a <= 0 length. */        // 如果參數為0，則重設client        if (c->argc == 0) {            resetClient(c);        } else {            /* Only reset the client when the command was executed. */            // 執行命令成功後重設client            if (processCommand(c) == C_OK)                resetClient(c);            /* freeMemoryIfNeeded may flush slave output buffers. This may result             * into a slave, that may be the active client, to be freed. */            if (server.current_client == NULL) break;        }    }    // 執行成功，則將用於崩潰報告的client設定為NULL    server.current_client = NULL;}

這個processInputBuffer()函數只要根據reqtype來判斷和佈建要求的類型，之前提過，因為Redis伺服器支援Telnet的串連，因此Telnet命令請求協議類型是PROTO_REQ_INLINE，進而調用processInlineBuffer()函數處理，而redis-cli命令請求的協議類型是PROTO_REQ_MULTIBULK，進而調用processMultibulkBuffer()函數來處理。我們只要看processMultibulkBuffer()函數，是如果將Redis協議的命令，處理成參數列表的對象的。源碼如下：

// 將client的querybuf中的協議內容轉換為client的參數列表中的對象int processMultibulkBuffer(client *c) {    char *newline = NULL;    int pos = 0, ok;    long long ll;    // 參數列表中命令數量為0    if (c->multibulklen == 0) {        /* The client should have been reset */        serverAssertWithInfo(c,NULL,c->argc == 0);        /* Multi bulk length cannot be read without a \r\n */        // 查詢第一個分行符號        newline = strchr(c->querybuf,'\r');        // 沒有找到\r\n，表示不符合協議，返回錯誤        if (newline == NULL) {            if (sdslen(c->querybuf) > PROTO_INLINE_MAX_SIZE) {                addReplyError(c,"Protocol error: too big mbulk count string");                setProtocolError(c,0);            }            return C_ERR;        }        /* Buffer should also contain \n */        // 檢查格式        if (newline-(c->querybuf) > ((signed)sdslen(c->querybuf)-2))            return C_ERR;        /* We know for sure there is a whole line since newline != NULL,         * so go ahead and find out the multi bulk length. */        // 保證第一個字元為'*'        serverAssertWithInfo(c,NULL,c->querybuf[0] == '*');        // 將'*'之後的數字轉換為整數。*3\r\n        ok = string2ll(c->querybuf+1,newline-(c->querybuf+1),&ll);        if (!ok || ll > 1024*1024) {            addReplyError(c,"Protocol error: invalid multibulk length");            setProtocolError(c,pos);            return C_ERR;        }        // 指向"*3\r\n"的"\r\n"之後的位置        pos = (newline-c->querybuf)+2;        // 空白命令，則將之前的刪除，保留未閱讀的部分        if (ll <= 0) {            sdsrange(c->querybuf,pos,-1);            return C_OK;        }        // 參數數量        c->multibulklen = ll;        /* Setup argv array on client structure */        // 分配client參數列表的空間        if (c->argv) zfree(c->argv);        c->argv = zmalloc(sizeof(robj*)*c->multibulklen);    }    serverAssertWithInfo(c,NULL,c->multibulklen > 0);    // 讀入multibulklen個參數，並建立對象儲存在參數列表中    while(c->multibulklen) {        /* Read bulk length if unknown */        // 讀入參數的長度        if (c->bulklen == -1) {            // 找到分行符號，確保"\r\n"存在            newline = strchr(c->querybuf+pos,'\r');            if (newline == NULL) {                if (sdslen(c->querybuf) > PROTO_INLINE_MAX_SIZE) {                    addReplyError(c,                        "Protocol error: too big bulk count string");                    setProtocolError(c,0);                    return C_ERR;                }                break;            }            /* Buffer should also contain \n */            // 檢查格式            if (newline-(c->querybuf) > ((signed)sdslen(c->querybuf)-2))                break;            // $3\r\nSET\r\n...，確保是'$'字元，保證格式            if (c->querybuf[pos] != '$') {                addReplyErrorFormat(c,                    "Protocol error: expected '$', got '%c'",                    c->querybuf[pos]);                setProtocolError(c,pos);                return C_ERR;            }            // 將命令長度儲存到ll。            ok = string2ll(c->querybuf+pos+1,newline-(c->querybuf+pos+1),&ll);            if (!ok || ll < 0 || ll > 512*1024*1024) {                addReplyError(c,"Protocol error: invalid bulk length");                setProtocolError(c,pos);                return C_ERR;            }            // 定位第一個參數的位置，也就是SET的S            pos += newline-(c->querybuf+pos)+2;            // 參數太長，進行最佳化            if (ll >= PROTO_MBULK_BIG_ARG) {                size_t qblen;                /* If we are going to read a large object from network                 * try to make it likely that it will start at c->querybuf                 * boundary so that we can optimize object creation                 * avoiding a large copy of data. */                // 如果我們要從網路中讀取一個大的對象，嘗試使它可能從c-> querybuf邊界開始，以便我們可以最佳化對象建立，避免大量的資料副本                // 儲存未讀取的部分                sdsrange(c->querybuf,pos,-1);                // 重設位移量                pos = 0;                // 擷取querybuf中已使用的長度                qblen = sdslen(c->querybuf);                /* Hint the sds library about the amount of bytes this string is                 * going to contain. */                // 擴充querybuf的大小                if (qblen < (size_t)ll+2)                    c->querybuf = sdsMakeRoomFor(c->querybuf,ll+2-qblen);            }            // 儲存參數的長度            c->bulklen = ll;        }        /* Read bulk argument */        // 因為唯讀了multibulklen位元組的資料，讀到的資料不夠，則直接跳出迴圈，執行processInputBuffer()函數迴圈讀取        if (sdslen(c->querybuf)-pos < (unsigned)(c->bulklen+2)) {            /* Not enough data (+2 == trailing \r\n) */            break;        // 為參數建立了對象        } else {            /* Optimization: if the buffer contains JUST our bulk element             * instead of creating a new object by *copying* the sds we             * just use the current sds string. */            // 如果讀入的長度大於32k            if (pos == 0 &&                c->bulklen >= PROTO_MBULK_BIG_ARG &&                (signed) sdslen(c->querybuf) == c->bulklen+2)            {                c->argv[c->argc++] = createObject(OBJ_STRING,c->querybuf);                // 跳過換行                sdsIncrLen(c->querybuf,-2); /* remove CRLF */                /* Assume that if we saw a fat argument we'll see another one                 * likely... */                // 設定一個新長度                c->querybuf = sdsnewlen(NULL,c->bulklen+2);                sdsclear(c->querybuf);                pos = 0;            // 建立對象儲存在client的參數列表中            } else {                c->argv[c->argc++] =                    createStringObject(c->querybuf+pos,c->bulklen);                pos += c->bulklen+2;            }            // 清空命令內容的長度            c->bulklen = -1;            // 未讀取命令參數的數量，讀取一個，該值減1            c->multibulklen--;        }    }    /* Trim to pos */    // 刪除已經讀取的，保留未讀取的    if (pos) sdsrange(c->querybuf,pos,-1);    /* We're done when c->multibulk == 0 */    // 命令的參數全部被讀取完    if (c->multibulklen == 0) return C_OK;    /* Still not read to process the command */    return C_ERR;}

我們結合一個多條批量回複進行分析。一個多條批量回複以 *<argc>\r\n 為首碼，後跟多條不同的批量回複，其中 argc 為這些批量回複的數量。那麼SET nmykey nmyvalue命令轉換為Redis協議內容如下：

"*3\r\n$3\r\nSET\r\n$5\r\nmykey\r\n$7\r\nmyvalue\r\n"

當進入processMultibulkBuffer()函數之後，如果是第一次執行該函數，那麼argv中未讀取的命令數量為0，也就是說參數列表為空白，那麼會執行if (c->multibulklen == 0)的代碼，這裡的代碼會解析*3\r\n，將3儲存到multibulklen中，表示後面的參數個數，然後根據參數個數，為argv分配空間。

接著，執行multibulklen次while迴圈，每次讀一個參數，例如$3\r\nSET\r\n，也是先讀出參數長度，儲存在bulklen中，然後將參數SET儲存構建成對象儲存到參數列表中。每次讀一個參數，multibulklen就會減1，當等於0時，就表示命令的參數全部讀取到參數列表完畢。

於是命令接收的整個過程完成。 3.2 命令回複

命令回複的函數，也是事件處理常式的回呼函數之一。當伺服器的client的回複緩衝區有資料，那麼就會調用aeCreateFileEvent(