2 程序逻辑

目录

• 2 程序逻辑
  • 1 main 函数
  • 2 具体流程模块函数
    • 2.1 初始化全局结构体
    • 2.2 创建监听套接字
    • 2.3 初始化连接设置
      • 2.3.1 conn_set(listen_fd, EPOLLIN, (void *)add_conn)
      • 2.3.2 event_set(new_ev, fd, call_back, arg);
      • 2.3.3 event_add(g_manager.ep_fd, events, new_ev, 1);
    • 2.4 监听端口属性设置
    • 2.5 阻塞在 epoll_wait()
    • 2.6 处理事件

2 程序逻辑

1 main 函数

2 具体流程模块函数

2.1 初始化全局结构体

int manager_init() {
	g_manager.m_pool = ukey_create_pool(2048); // 创建内存池
	g_manager.t_pool = threadpool_create(50, 1024, 1024); // 创建线程池
	g_manager.conn = (connections_t *)ukey_palloc(g_manager.m_pool, sizeof(connections_t ) * 1024);// 预先分配1024个连接
	g_manager.nconnections = 1024;
	conn_init(g_manager.conn, g_manager.nconnections);// 给每个连接初始化(创建内存池，分为读连接，写连接)
	g_manager.ep_fd = epoll_create(EPOLL_SIZE);// 创建epoll描述符
	if (g_manager.ep_fd < 0) {
		perror("epoll create error");
		return -1;
	}
	g_manager.ep_events = (struct epoll_event *)ukey_palloc(g_manager.m_pool, sizeof(struct epoll_event) * 4096); // 预先分配4096个epoll事件的内存空间
	g_manager.nep_events = 4096;
	pthread_mutex_init(&(g_manager.conn_lock), NULL);// 初始化锁

	return 0;
}

2.2 创建监听套接字

	struct sockaddr_in server_addr;
	int listen_fd;
	int ep_fd = g_manager.ep_fd;
	listen_fd = socket(AF_INET,SOCK_STREAM,0);

2.3 初始化连接设置

2.3.1 conn_set(listen_fd, EPOLLIN, (void *)add_conn)

int conn_set(int fd, int events, void (*call_back)(int, int, void *)) {
	if (fd > g_manager.nconnections) {
		fprintf(stderr, "fd max limits\n");
		return -1;
	}

	connections_t *new_conn = &g_manager.conn[fd]; // 找到对应连接预先分配的空间
	if (new_conn == NULL) {
		fprintf(stderr, "conn set error\n");
		return -1;
	}
	event_t *new_ev = (event_t *)ukey_palloc(new_conn->m_cpool, sizeof(event_t)); //在连接的内存空间中分配一个事件的空间
	if (new_ev == NULL) {
		fprintf(stderr, "alloc from coon m_cpoll error\n");
		return -1;
	}
	void *arg = (void *)new_ev;
	event_set(new_ev, fd, call_back, arg); // 设置事件回调函数
	event_add(g_manager.ep_fd, events, new_ev, 1);// 添加事件
                            // 根据传入的参数设置对应得事件类型时读还是写	
	if (events & EPOLLIN) {
		new_conn->read = new_ev; 
	}
	if (events & EPOLLOUT) {
		new_conn->write = new_ev;
	}
	
	return 0;
}	

2.3.2 event_set(new_ev, fd, call_back, arg);

void event_set(event_t *ev, int fd, void (*call_back)(int, int, void *), void *arg) {

	ev->ev_fd = fd; //事件的描述符
	ev->ev_callback = call_back; // 事件的回调函数
	ev->ev_arg = arg; // 参数
	ev->ev_events = 0; // 事件类型 EPOLLIN 还是 EPOLLOUT
	ev->ev_status = 0; // 控制事件的状态  是否已经在 epoll 监听中

	return ;
}

2.3.3 event_add(g_manager.ep_fd, events, new_ev, 1);

void event_add(int ep_fd, int events, event_t *ev, int et_flag) {
	struct epoll_event ep_event = {0, {0}}; // 初始化epoll_event
	int option; // 属性参数

	if (et_flag) {
		fcntl(ev->ev_fd, F_SETFL, O_NONBLOCK); //设置为非阻塞epoll ET触发
		events |= EPOLLET;                     // event 本来为 EPOLLIN 读事件
	}

	ep_event.data.fd = ev->ev_fd; // 设置监听的描述符
	ep_event.events = ev->ev_events = events;  // 设置属性

	if (ev->ev_status == 1) {
		option = EPOLL_CTL_MOD; // 如果之前已经在epoll中 则为修改
	} else {
		option = EPOLL_CTL_ADD; // 之前没在epoll中 添加
		ev->ev_status = 1;
	}

	if (epoll_ctl(ep_fd, option, ev->ev_fd, &ep_event) < 0) { // 在epoll中注册事件
		perror("epoll ctl error");
		exit(-1);
	}
	return ;
}

2.4 监听端口属性设置

    bzero(&server_addr,sizeof(server_addr));
    
    // 设置端口复用
    int flag = 1;
    setsockopt(listen_fd,SOL_SOCKET,SO_REUSEADDR,&flag,sizeof(flag));// SOL_SOCKET: 基本套接口  SO_REUSERADDR 允许重用本地地址和端口（在timewait状态时）
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	server_addr.sin_port = htons(SERV_PORT);
	
	bind(listen_fd,(struct sockaddr *)&server_addr,sizeof(server_addr));
	listen(listen_fd,20);

2.5 阻塞在 epoll_wait()

int event_count = epoll_wait(ep_fd, g_manager.ep_events, g_manager.nep_events, -1);

2.6 处理事件

int i = 0;
for(; i < event_count; i++)
{
	int fd = g_manager.ep_events[i].data.fd; // 得到连接的描述符
	int events = g_manager.ep_events[i].events; // 得到连接对应的事件
	connections_t *ev_conn = &g_manager.conn[fd]; // 找到触发事件的实体

	if (ev_conn == NULL)
		continue;
	if (events & EPOLLIN) { // 如果是读事件
		if (ev_conn->read) { // 如果有事件挂在连接上
			event_t *read_ev = ev_conn->read; // 取得对应的事件
			if (read_ev->ev_callback) // 若有回调函数 执行回调函数
				read_ev->ev_callback(read_ev->ev_fd, read_ev->ev_events, read_ev->ev_arg);
		}
	}
	if (events & EPOLLOUT) { // 如果是写事件
		if (ev_conn->write) {
			event_t *write_ev= ev_conn->write;
			write_ev->ev_callback(write_ev->ev_fd, write_ev->ev_events, write_ev->ev_arg);
		}
	}
	/* 需要扩展epoll_event数组 */
	if (event_count == g_manager.nep_events) {
		if (epev_ralloc() < 0) {
			fprintf(stderr, "epoll event realloc error\n");
			exit(-1);
		}
	}
}