2.3.1（项目）kv存储——框架梳理(待定)

一、过一遍代码路线：

（1）底层网络框架；（2）业务层的协议筹划(发什么数据，以及收什么数据)；（3）业务层的引擎筹划；
1. 底层网络框架：

目标：通过定义函数创建网络层和业务层的联系，并从原有已以网络框架为主改造后以业务框架为main函数，确保此后网络层隔离和透明（以reactor.c为例）。
要求：reactor.c(手写)、ntyco协程(看懂)、io_uring(看懂)。
做法：用做reactor的做法来做kvstore的网络框架
核心：是设置自定义的布局体，明白什么变乱执行什么回调函数。while(1){}循环里，（a）EPOLLIN变乱执行recv_callback，EPOLLOUT变乱执行send_callback。（b）EPOLLIN变乱包罗sockfd和clientfd，分别执行accept函数和recv/send函数，可以通过recv_callback的index加以区分。
要点：
知识点（1）：通过宏定义开启或关闭不同的功能，由此方便新功能编写。

1. #define ENABLE_KVSTORE        1

复制代码

1. #if    ENABLE_KVSTORE
2.         kvs_request(&connect_list[fd]);
3. #endif
6. #if    ENABLE_KVSTORE
7.         kvs_response(&connect_list[fd]);
8. #endif

复制代码

知识点（2）：(1) 协议处理 → 放到kvstore.c；（2）main入口函数 → 放到网络框架(reactor.c)里面？还是放到kvstore.c里面?
答：如果把main入口函数放到网络框架(reactor.c)就表明主要步调由网络框架实现，按照这个逻辑kvstore.c只是其中的一个业务，而流程不应该如许。所以main要放到kvstore.c里面，以保证网络层被完全的隔离。对于一个服务而言，我们要终极封装成：网络层仅必要传输端口(port)和协议的接口(kvs_protocol)这两个端口已往，
知识点（3）：网络框架(reactor.c)里怎样与kvstore.c毗连：
（a）定义kvs_request和kvs_response；
（b）send_cb和recv_cb分别设置kvs_request和kvs_response；
（c）send_cb里的kvs_request使用kvs_handler处理数据 ←
kvs_handler通过“static msg_handler kvs_handler” 定义范例，在网络框架(reactor.c)主函数里被handler赋值← 
handler作为网络框架(reactor.c)主函数里其中一个输入参数，被msg_handler布局体赋值 ←  
布局体msg_handler在网络框架(reactor.c)被定义，包罗*msg、length、*response，同时也在kvstore.h文件里。←
作为在网络框架(reactor.c)主函数输入参数的handler，在kvstore.c里被定义为kvs_protocal。网络框架(reactor.c)的命令行 “static msg_handler kvs_handler” 为了 “kvs_handler = handler”。←

网络层的编译命令

此处的代码：
server.h(基本没变化)

1. #ifndef __SERVER_H__
2. #define __SERVER_H__
4. #define BUFFER_LENGTH                128
6. #define ENABLE_KVSTORE              1
9. typedef int  (*RCALLBACK)(int fd);
13. struct conn {
14.         int       fd;
16.         char    rbuffer[BUFFER_LENGTH];
17.         int       rlength;
18.         char    wbuffer[BUFFER_LENGTH];
19.         int       wlength;
21.         RCALLBACK  send_callback;
22.         RCALLBACK  recv_callback;
23. };
26. #if ENABLE_KVSTORE
27. int kvs_request(struct conn *c);
28. int kvs_response(struct conn *c);
29. #endif
34. #endif

复制代码

kvs_reactor.c

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <sys/socket.h>
4. #include <arpa/inet.h>
5. #include <string.h>
6. #include <errno.h>
7. #include <sys/epoll.h>
8. #include <unistd.h>
9. #include <sys/time.h>
10. #include "server.h"
14. //#define BUFFER_LENGTH       1024
15. #define CONNECT_SIZE           1048576
16. #define PORT_SIZE                   1
20. #define TIME_SUB_MS(tv1, tv2)  ((tv1.tv_sec - tv2.tv_sec) * 1000 + (tv1.tv_usec - tv2.tv_usec) / 1000)
23. #if ENABLE_KVSTORE
25. typedef int (*msg_handler)(char *msg, int length, char *response);
26. static msg_handler kvs_handler;
28. int kvs_request(struct conn *c){
30. //        printf("recv %d: %s\n", c->rlength ,c->rbuffer);
32.         c->wlength = kvs_handler(c->rbuffer, c->rlength, c->wbuffer);
34. }
36. #endif
39. int kvs_response(struct conn *c){
42. }
45. //typedef int  (*RCALLBACK)(int fd);
47. int accept_cb(int fd);
48. int recv_cb(int fd);
49. int send_cb(int fd);
51. int epfd = 0;
53. struct timeval begin;
55. /*
56. struct conn {
57.         int       fd;
59.         char    rbuffer[BUFFER_LENGTH];
60.         int       rlength;
61.         char    wbuffer[BUFFER_LENGTH];
62.         int       wlength;
64.         RCALLBACK  send_callback;
65.         RCALLBACK  recv_callback;
66. };
67. */
69. struct conn connect_list[CONNECT_SIZE] = {0};
73. int set_event(int fd, int event, int flag){
75.         if (flag == 1){ // non-zero add
76.         struct epoll_event ev;
77.         ev.data.fd = fd;
78.         ev.events = event;
79.         epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
80.         } else {           // zero MOD
81.         struct epoll_event ev;
82.         ev.data.fd = fd;
83.         ev.events = event;
84.         epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev);
85.         }
87. }
89. int event_register(int fd, int event){
91.         if (fd < 0){
92.                 return -1;
93.         }
95.         connect_list[fd].fd = fd;
96.         connect_list[fd].recv_callback = recv_cb;
97.         connect_list[fd].send_callback = send_cb;
99.         memset(connect_list[fd].rbuffer, 0, BUFFER_LENGTH);
100.         connect_list[fd].rlength = 0;
101.         memset(connect_list[fd].wbuffer, 0, BUFFER_LENGTH);
102.         connect_list[fd].wlength = 0;
104.         set_event(fd, EPOLLIN, 1);
106. }
109. int accept_cb(int fd){
111.         struct sockaddr_in clientaddr;
112.         socklen_t len = sizeof(clientaddr);
113.         int clientfd = accept(fd, (struct sockaddr*)&clientaddr, &len);
115.         if (clientfd < 0){
116.                 printf("accept error:  %d, %s\n", errno, strerror(errno));
117.                 return -1;
118.         }
120.         event_register(clientfd, EPOLLIN);
122.         if((clientfd % 1000) == 0){
123.                 struct timeval current;
124.                 gettimeofday(&current, NULL);
125.                 int time_used = TIME_SUB_MS(current, begin);
126.                 memcpy(&begin, &current, sizeof(struct timeval));
128.                 printf("Accept clientfd : %d, time_used: %d\n", clientfd, time_used);
129.         }
132.         return 0;
133. }
135. int recv_cb(int fd){
136.         int count = recv(fd, connect_list[fd].rbuffer, BUFFER_LENGTH, 0);
137.         if (count ==0){
138.                 printf("client disconnect: %d\n", fd);
139.                 close(fd);
140.                 epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);  // unfinished
141.                 return 0;
142.         }
144.         connect_list[fd].rlength = count;
147. //        printf("rbuffer: %s, recv: %d\n", connect_list[fd].rbuffer, count);
149. # if 0 //echo
150.         connect_list[fd].wlength = connect_list[fd].rlength;
151.         memcpy(connect_list[fd].wbuffer, connect_list[fd].rbuffer, connect_list[fd].wlength);
152. #endif
154. #if    ENABLE_KVSTORE
155.         kvs_request(&connect_list[fd]);
156. #endif
158.         set_event(fd, EPOLLOUT, 0);
160.         return count;
161. }
163. int send_cb(int fd){
165. #if    ENABLE_KVSTORE
166.         kvs_response(&connect_list[fd]);
167. #endif
170.         int count = 0;
171.         count = send(fd, connect_list[fd].wbuffer, connect_list[fd].wlength, 0);
172. //        printf("wbuffer: %s, send: %d\n", connect_list[fd].wbuffer, count);
174.         set_event(fd, EPOLLIN, 0);
175.         return count;
177. }
180. int r_init_server(unsigned short port){
181.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);
182.         struct sockaddr_in servaddr;
183.         servaddr.sin_family = AF_INET;
184.         servaddr.sin_addr.s_addr= htonl(INADDR_ANY);  // uint32_t
185.         servaddr.sin_port = htons(port);
187.         if (-1 == bind(sockfd, (struct sockaddr*)&servaddr, sizeof(struct sockaddr))) {
188.                 printf("bind failed: %s\n", strerror(errno));
189.         }
191.         listen(sockfd, 10);
192. //        printf("listen finished: %d\n", sockfd);
194.         return sockfd;
195. }
198. int reactor_start(unsigned short port, msg_handler handler){
200.         epfd = epoll_create(1);
201.         //unsigned short port = 2000;
203.         kvs_handler =  handler;
205.         int i = 0;
206.         for (i = 0; i < PORT_SIZE; i ++){
208.                 int sockfd = r_init_server(port + i);
209.                 connect_list[sockfd].fd =  sockfd;
210.                 connect_list[sockfd].recv_callback = accept_cb;
211.                 printf("sockfd: %d\n", sockfd);
212.                 set_event(sockfd, EPOLLIN, 1);
213.         }
215.         gettimeofday(&begin, NULL);
217.         while(1){
218.                 struct epoll_event events[1024] = {0};
219.                 int nready = epoll_wait(epfd, events, 1024, -1);
220. //                printf("epoll_wait is %d\n", nready);
221.                 int i = 0;
222.                 for (i = 0; i < nready; i ++){
223.                         int connfd = events[i].data.fd;
224.                         if (events[i].events & EPOLLIN){
225.                                 connect_list[connfd].recv_callback(connfd);
226.                         }
227.                         if (events[i].events & EPOLLOUT){
228.                                 connect_list[connfd].send_callback(connfd);
229.                         }
230.                 }
231.         }
233.         return 0;
234. }

复制代码

kvstore.c

1. #include <stdio.h>
2. #include <string.h>
3. #include <stdlib.h>
4. #include "kvstore.h"
7. /*
8. * msg: request message
9. * length: length of request message
10. * response:  need to seed
11. *@return: length of response
12. */
15. int kvs_protocal(char *msg, int length, char *response){
16.         printf("recv %d: %s\n", length, msg);
17.         memcpy(response, msg, length);
18.         return strlen(response);
19. }
25. int main(int argc, char *argv[]){ //  input parameters
27.         if (argc != 2) return -1;
28.         // ./program Hello World: Number of arguments is 3
30.         int port = atoi(argv[1]);
32. #if   (NETWORK_SELECT  ==  NETWORK_REACTOR)
33.         reactor_start(port, kvs_protocal);
34. #elif
36. #endif
39. }

复制代码

kvstore.h

1. #ifndef   __KV_STORE_H__
2. #define  __KV_STORE_H__
5. #define NETWORK_REACTOR     0
7. #define NETWORK_SELECT        NETWORK_REACTOR
11. typedef int (*msg_handler)(char *msg, int length, char *response);
13. extern int reactor_start(unsigned short port, msg_handler handler);
16. const char *command[] = {
17.         "SET", "GET", "DEL", "MOD", "EXIST"
18. };
20. const char *response[] = {
22. };
24. #endif

复制代码

2. 业务层的协议筹划：

目标：在前面已经创建tcp公共协议毗连的根本上，创建发什么数据和接收什么数据的私有协议 / 自定义协议 / 发数据的格式。
具体做法：对于网络部门已经实现了数据的接收和发送，所以接下来我们要在收数据的地方修改，在原有reactor.c的根本上，
（1）新建kvstore.c定义有关业务联系的函数(接收request和输出response)；
（2）新建kvstore.h为函数(接收request和输出response)定义函数具体的协议、具体response。
具体5个response格式：

1. command(命令)
2. SET         Key     Value
4. GET         Key
6. DEL         Key
8. MOD         Key     Value
9.   
10. EXIST       Key

复制代码

（3）在上一部门网络已经封装根本上，以kvstore.c里的自定义kvs_protocol函数(也就是对应网络框架(reactor.c) 的主函数第2个输入参数)为入口函数，进行具体的协议解析功能(也就是定义接收和发送的数据规则寄义，如下2种模式)。

1. SET Key Value
2. Get Key

复制代码

要点：
知识点（1）：针对tcp的分包和粘包，问题1是什么是分包和粘包，问题2是怎么解决这个问题？
答1：由于send(fd, buffer, length, 0)的次数和recv(fd, buffer, length, 0)大概不一致，大概send()多次发送recv一次性都接收了(这就是粘包)，所以要区分出每次的数据(分包解数据)。
答2：分包的时间必要和对方约定好格式，同时tcp毗连满足假设(1) recv()先接收的数据就是对方先发送的数据，保证了接收数据的次序；(2)  数据在传输过程中不会发生丢包情况，保证了数据必达性。
方式1. send()在发包时就确定约定的长度，比如接收2次就可以接收完整的数据包，第一次接收2字节作为标志，第二次再接收数据包。

1. SEND:
2. [15]SET Key Value\r\n   // 15表示15个字符

复制代码

1. 第一次：接收开头的2个字符，同时通过这2个字符的值得知后面还要接收15字符
2. short length = 0;
3. recv(fd, &length, 2, 0);
4. 第二次：接收剩余数据15个字符
5. recv(fd, buffer, length, 0);

复制代码

方式2. 仿照Redis，先确定有多少(N)个token后就先发送字符N，具体发送格式如下：

1. Refis → SET Key Value
2. 发送顺序如下
3. 3\r\n     // 3表示“SET Key Value”一共是3个token(单词)
4. 3\r\n     // 3表示第一个token(单词)“SET"是3个字符的长度
5. SET\r\n   // 发送一个token，“SET"
6. 3\r\n     // 3表示第二个token(单词)“Key"也是3个字符的长度
7. Key\r\n   // 发送一个token，“Key"
8. 5\r\n     // 5表示第三个token(单词)“Value"也是5个字符的长度
9. Value\r\n   // 发送一个token，“Value"

复制代码

伪代码如下，终极要读(1+2*3)=7次

1. 自行实现readline()函数，要求每一行读到"\r\n"就停止
3. count = atoi(buffer);
4. for (i = 0; i < count; i ++){
5.     readline(fd, tokenlen);
6.     readline(fd, token);
7. }

复制代码

3. 业务层的引擎筹划

数据布局用红黑树、希哈、数组、链表(手写)



二、备注：

(1) “const char *command[] ={};” 什么意思？以及为什么是const以及为什么*?
答：const: 确保字符串内容不能被修改。*: 表现指针，每个数组元素都指向一个字符串。
(2) 定义函数不消分号";"，而布局体必要，那么什么时间必要加“;”？
答：定义一个范例（比方 struct 或 typedef）告诉编译器这个范例存在但并不提供执行行为，必要以分号结束。
（a）必要分号的地方：变量声明、布局体定义、typedef 定义新范例

1. int a = 10; // 表示变量声明结束
3. struct Point {
4.     int x;
5.     char y;
6. }; // 分号表示 `struct Point` 的定义结束
8. typedef struct {
9.     int x;
10.     char y;
11. } PointType; // 分号表示 `typedef` 的结束

复制代码

（b）不必要分号的地方：函数定义、#define 宏(宏是简单的文本替换)。

1. int add(int a, int b) {
2.     return a + b; // 函数体内语句的分号只是代码逻辑的一部分
3. }
5. #define SQUARE(x) ((x) * (x)) // 宏定义

复制代码

（3）为什么分为 .c 和 .h 文件?
答：每个 .c 文件负责一个模块的实现，多个模块通过 .h 文件互相调用。.h 文件只能声明接口，不能包罗具体实现。自定义头文件使用双引号：#include "xxxx.h"。
（4）"int main(int argc, char *argv[]){}" 是一个标准的 C 语言步调入口函数。
答：argc表现参数个数 (Argument Count)，argv表现参数向量 (Argument Vector)。用于获取命令行传递给步调的参数。

1. int main(int argc, char *argv[]) {
2.     printf("Number of arguments: %d\n", argc);
3.     for (int i = 0; i < argc; i++) {
4.         printf("Argument %d: %s\n", i, argv[i]);
5.     }
6.     return 0;
7. }
8. 运行：
9. ./program Hello World
10. 输出：
11. Number of arguments: 3
12. Argument 0: ./program
13. Argument 1: Hello
14. Argument 2: World

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。