Memcache源码阅读（3）---处理用户输入

最新推荐文章于 2021-01-19 10:52:17 发布

Honkee

最新推荐文章于 2021-01-19 10:52:17 发布

阅读量527

点赞数

分类专栏： C++语言计算机网络编程文章标签： memcached 源码

本文链接：https://blog.csdn.net/Honkee_/article/details/53708227

版权

计算机同时被 3 个专栏收录

20 篇文章 0 订阅

订阅专栏

C++语言

19 篇文章 0 订阅

订阅专栏

网络编程

10 篇文章 0 订阅

订阅专栏

我看的源码版本是1.2.4

从main函数开始，看看作者怎么初始化,然后再看作者怎么监听连接，怎么接受用户的输入，怎么处理用户的输入。

主程序

main函数里的一些操作

自定义中断处理函数
从命令行中获取用户打开memcached的指令值
设置core文件
初始化资源，统计资源，分配内存
屏蔽SIGPIPE信号，因为SIGPIPE的默认处理是中断程序，客户端断开连接后，memcached再往客户端写数据就会触发该信号，此时memcached应该要继续运行的，所以要屏蔽该信号。
监听用户的连接，作者用到libevent的事件驱动模型，一个主线程负责监听连接，将接受到的连接交给工作线程去处理。

主程序监听套接字的设置

//创建一个套接字
l_socket = server_socket(settings.port, 0);

//对监听套接字设置事件处理，这里主要是为套接字l_socket设置事件处理函数
//将l_socket设置为conn_listening状态，一直在这个状态中运行。
//后面就会看到关于状态机的处理代码。
listen_conn = conn_new(l_socket, conn_listening,
                                 EV_READ | EV_PERSIST, 1, false, main_base);
//程序会一直在这里等待,有时间到来就会调用注册的时间处理函数                                                                 
event_base_loop(main_base, 0);

主线程创建一个套接字，然后对这个套接字设置一个状态，为conn_listening，这个套接字一直都处理conn_listening状态，它一直负责接收用户的连接。主线程收到客户的连接，就会将这个连接交给工作线程处理，然后主线程继续回到监听状态，等待下一个连接。

细节描述

//为sfd添加事件处理函数。memcached使用libevent这个库来进行事件处理。
conn *conn_new(const int sfd, const int init_state, const int event_flags,
                const int read_buffer_size, const bool is_udp, struct event_base *base) {
    conn *c = conn_from_freelist();
    ...
    一些对conn的初始化
    ...
    //设置事件处理,时间处理函数为event_handler
    event_set(&c->event, sfd, event_flags, event_handler, (void *)c);
    event_base_set(base, &c->event);
    c->ev_flags = event_flags;
    event_add(&c->event, 0)
    return c;
}

//事件处理就是交给drive_machine，他的参数是一个连接，每个连接都有一个状态，与它接收到的数据，每个工作线程可以根据它现在的状态和收据做对应的操作。
void event_handler(const int fd, const short which, void *arg) {
    conn *c;
    c = (conn *)arg;
    drive_machine(c);
}

//所有的连接的事件处理函数都是它，它会根据连接的状态和数据来作对应的处理
static void drive_machine(conn *c) {
    while (!stop) {
        switch(c->state) {
            case conn_listening:
                    //监听进程一直都在执行这里的代码
                    //接收连接，然后分发给工作线程，注意，交给工作线程时设置初始状态为conn_read
                    sfd = accept(c->sfd, &addr, &addrlen)) 
                    dispatch_conn_new(sfd, conn_read, EV_READ | EV_PERSIST,
                                     DATA_BUFFER_SIZE, false);
                    break;
            case conn_read:
                //接收命令行传过来的参数，就是第二篇文章讲的第一行命令，
                //如set a 0 0 4
                //try_read_command判断接收的消息有没有一个可以操作的命令，
                //如果可以操作，就会跳到对应的状态，否则继续在这个状态，继续接收数据。
                //这里接收数据是通过try_read_network这个函数来接收数据的。
                if (try_read_command(c) != 0) {
                    continue;
                }
                //这里是用来接收用户传来的信息
                if ((c->udp ? try_read_udp(c) : try_read_network(c)) != 0) {
                    continue;
                }
                stop = true;
                break;

            case conn_nread:
                //接收用户的数据块
                //如set a 0 0 4后的 1234
                if (c->rlbytes == 0) {
                    complete_nread(c);
                    break;
                 }
                 res = read(c->sfd, c->ritem, c->rlbytes);
                 if (res > 0) {
                    break;
                }
                if (res == 0) { /* end of stream */
                    conn_set_state(c, conn_closing);
                    break;
                }
                if (res == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
                    stop = true;
                    break;
                }
                /* otherwise we have a real error, on which we close the connection */
                conn_set_state(c, conn_closing);
                break;
            //这些后面再讲
            case conn_swallow:
            case conn_write:
            case conn_mwrite:
            case conn_closing:
        }
    }

    return;
}

//因为一个客户端与memcached是一个tcp长连接，这个长连接一般会保持到用户主动退出或者网络断开，
//还有这个套接字是异步套接字，我觉得理解这个概念很重要，用户输入完一个命令之后可以从这个while循环中返回。
//因为是异步套接字，所以这个函数在用户不需要断开连接也是可以返回的,
//然后一会再检查能不能构成一个可以执行的命令，
//如果可以就执行，不行就返回0，等待数据。
static int try_read_network(conn *c) {
    int gotdata = 0;
    int res;

    while (1) {
        if (c->rbytes >= c->rsize) {
            char *new_rbuf = realloc(c->rbuf, c->rsize * 2);
            c->rcurr = c->rbuf = new_rbuf;
            c->rsize *= 2;
        }

        res = read(c->sfd, c->rbuf + c->rbytes, c->rsize - c->rbytes);
        if (res > 0) {
            continue;
        }
        if (res == 0) {
            /* connection closed */
            conn_set_state(c, conn_closing);
            return 1;
        }
        if (res == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) break;
            else return 0;
        }
    }
    return gotdata;
}

//这个函数就是获取用户输入的第一行命令的一个预处理，将一个命令的\r\n结束改为以\0作为结束。
//比如说用户输入 “get a\r\n“那么经过这里处理就变成 “get a\0\n“,为的是给后面做分割
static int try_read_command(conn *c) {
    char *el, *cont;

    if (c->rbytes == 0)
        return 0;
    el = memchr(c->rcurr, '\n', c->rbytes);
    if (!el)
        return 0;
    cont = el + 1;
    if ((el - c->rcurr) > 1 && *(el - 1) == '\r') {
        el--;
    }
    *el = '\0';

    process_command(c, c->rcurr);

    return 1;
}

//处理用户输入,这里只会处理用户输入的第一行。
//即使用户输入的是 set a 0 0 4\r\n  
// 1234\r\n
//第一个\r\n后的1234不是这里处理的，它会交由drive_machine的conn_nread这里来读取和处理。
static void process_command(conn *c, char *command) {

    token_t tokens[MAX_TOKENS];
    size_t ntokens;
    //用户输入的字符串分割开，tokens数组放着这些值
    ntokens = tokenize_command(command, tokens, MAX_TOKENS);
    if (ntokens >= 3 &&
        ((strcmp(tokens[COMMAND_TOKEN].value, "get") == 0) ||
         (strcmp(tokens[COMMAND_TOKEN].value, "bget") == 0))) {

        process_get_command(c, tokens, ntokens, false);

    }else if (ntokens == 6 &&
               ((strcmp(tokens[COMMAND_TOKEN].value, "add") == 0 && (comm = NREAD_ADD)) ||
                (strcmp(tokens[COMMAND_TOKEN].value, "set") == 0 && (comm = NREAD_SET)) ||
                (strcmp(tokens[COMMAND_TOKEN].value, "replace") == 0 && (comm = NREAD_REPLACE)) ||
                (strcmp(tokens[COMMAND_TOKEN].value, "prepend") == 0 && (comm = NREAD_PREPEND)) ||
                (strcmp(tokens[COMMAND_TOKEN].value, "append") == 0 && (comm = NREAD_APPEND)) )) {

        process_update_command(c, tokens, ntokens, comm, false);

    }
    ...
    //处理其他的命令

    return;
}

//分割字符串
//如用户输入get a\r\n它这里会返回3，分别为get, a, a. 这是我测试的结果，原因我也不清楚。
//用户输入set a 0 0 4\r\n它会返回6，分别为set, a, 0, 0, 4, 4.
static size_t tokenize_command(char *command, token_t *tokens, const size_t max_tokens) {
    char *s, *e;
    size_t ntokens = 0;

    assert(command != NULL && tokens != NULL && max_tokens > 1);

    for (s = e = command; ntokens < max_tokens - 1; ++e) {
        if (*e == ' ') {
            if (s != e) {
                tokens[ntokens].value = s;
                tokens[ntokens].length = e - s;
                ntokens++;
                *e = '\0';
            }
            s = e + 1;
        }
        else if (*e == '\0') {
            if (s != e) {
                tokens[ntokens].value = s;
                tokens[ntokens].length = e - s;
                ntokens++;
            }

            break; /* string end */
        }
    }

    /*
     * If we scanned the whole string, the terminal value pointer is null,
     * otherwise it is the first unprocessed character.
     */
    tokens[ntokens].value =  *e == '\0' ? NULL : e;
    tokens[ntokens].length = 0;
    ntokens++;

    return ntokens;
}

//对tokens进行保存，改变状态，交由drive_machine去处理
static void process_update_command(conn *c, token_t *tokens, const size_t ntokens, int comm, bool handle_cas) {
    char *key;
    size_t nkey;
    int flags;
    time_t exptime;
    int vlen, old_vlen;
    uint64_t req_cas_id;
    item *it, *old_it;
    //将命令行中的各个值提取出来
    key = tokens[KEY_TOKEN].value;
    nkey = tokens[KEY_TOKEN].length;

    flags = strtoul(tokens[2].value, NULL, 10);
    exptime = strtol(tokens[3].value, NULL, 10);
    vlen = strtol(tokens[4].value, NULL, 10);
    //分配一个item的空间来寸数据，第二行输入的数据是存在item里面的
    it = item_alloc(key, nkey, flags, realtime(exptime), vlen+2);

    c->item = it;
    c->ritem = ITEM_data(it);
    c->rlbytes = it->nbytes;
    c->item_comm = comm;
    //将这个连接的状态设置为conn_nread，交由drive_machine去处理,现在可以返回到drive_machine那里看看你conn_nread要做什么了，conn_nread主要是要读取接下来的数据，接下来的数据是读到item里面去的哦。接下来如果要保存到hash桶里，也是直接用这个item的指针而已。读完数据之后会执行complete_nread.
    conn_set_state(c, conn_nread);
}

//将数据保存到memcached
static void complete_nread(conn *c) {
    assert(c != NULL);

    item *it = c->item;
    int comm = c->item_comm;
    int ret;

    if (strncmp(ITEM_data(it) + it->nbytes - 2, "\r\n", 2) != 0) {
        out_string(c, "CLIENT_ERROR bad data chunk");
    } else {
      ret = store_item(it, comm);
      if (ret == 1)
          out_string(c, "STORED");
      else if(ret == 2)
          out_string(c, "EXISTS");
      else if(ret == 3)
          out_string(c, "NOT_FOUND");
      else
          out_string(c, "NOT_STORED");
    }

    item_remove(c->item);       /* release the c->item reference */
    c->item = 0;
}