http服务器_Epoll类与Server类的实现（C++）

最新推荐文章于 2024-05-23 22:54:45 发布
最新推荐文章于 2024-05-23 22:54:45 发布
阅读量480 收藏
点赞数 1
分类专栏： Linux网络编程 文章标签： c++ epoll http
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44277699/article/details/113769503
版权

http服务器_Epoll类与Server类的设计与实现（C++）

一、回顾Epoll的基础知识

  请参见之前的博客文章《UNP学习_I/0复用之epoll函数实现回射服务器》

二、代码讲解

  很多的细节我会在注释中讲解。

（1）Epoll Class：

//Epoll.h
#ifndef __EPOLL_H__
#define __EPOLL_H__

#include <vector>
#include <memory>
#include <functional>

#include <sys/epoll.h>
#define MAXEVENTS 4096

namespace huhu {
//前向声明
class HttpRequest;
class ThreadPool;

class Epoll {
public:
    using NewConnectionCallback = std::function<void()>;
    using CloseConnectionCallback = std::function<void(HttpRequest*)>;
    using HandleRequestCallback = std::function<void(HttpRequest*)>;
    using HandleResponseCallback = std::function<void(HttpRequest*)>;

    Epoll();
    ~Epoll();
    //epoll_ctl系列函数
    int addFd(int fd, HttpRequest* request, int events);
    int modFd(int fd, HttpRequest* request, int events);
    int delFd(int fd, HttpRequest* request, int events);
    //epoll_wait
    int waitEvents(int time_ms);
	//event dispatch 事件分发函数
    void handleEvent(int listen_fd, std::shared_ptr<ThreadPool>& thread_pool, int events_num);
    
	//回调设置函数
    void setNewConnection(const NewConnectionCallback& cb){
        m_new_conn_cb = cb;
    }
    void setCloseConnection(const CloseConnectionCallback& cb){
        m_close_conn_cb = cb;
    }
    void setRequest(const HandleRequestCallback& cb){
        m_req_cb = cb;
    }
    void setResponse(const HandleResponseCallback& cb){
        m_res_cb = cb;
    }

private:
    using EventList = std::vector<struct epoll_event>;

    int m_epoll_fd;
    EventList m_eventlist;
    NewConnectionCallback m_new_conn_cb;
    CloseConnectionCallback m_close_conn_cb;
    HandleRequestCallback m_req_cb;
    HandleResponseCallback m_res_cb;

};//class epoll

}//namespace huhu

#endif

//Epoll.cpp
#include "../include/Epoll.h"
#include "../include/HttpRequest.h"
#include "../include/ThreadPool.h"

#include <iostream>
#include <cassert>
#include <cstring> // perror

#include <unistd.h> // close

using namespace huhu;

Epoll::Epoll() 
	//epoll_create1不需要再指定size
    : m_epoll_fd(::epoll_create1(EPOLL_CLOEXEC)),
      m_eventlist(MAXEVENTS)
{
    assert(m_epoll_fd >= 0);
}

Epoll::~Epoll()
{
    ::close(m_epoll_fd);
}
//向epoll树上添加监听fd的函数
int Epoll::addFd(int fd, HttpRequest* request, int events)
{
    struct epoll_event event;
    event.data.ptr = static_cast<void*>(request); 
    event.events = events;
    int ret = ::epoll_ctl(m_epoll_fd, EPOLL_CTL_ADD, fd, &event);
    return ret;
}
//在epoll树上修改监听fd的函数
int Epoll::modFd(int fd, HttpRequest* request, int events)
{
    struct epoll_event event;
    event.data.ptr = static_cast<void*>(request); 
    event.events = events;
    int ret = ::epoll_ctl(m_epoll_fd, EPOLL_CTL_MOD, fd, &event);
    return ret;
}
//向epoll树上删除监听fd的函数
int Epoll::delFd(int fd, HttpRequest* request, int events)
{
    struct epoll_event event;
    event.data.ptr = static_cast<void*>(request);
    event.events = events;
    int ret = ::epoll_ctl(m_epoll_fd, EPOLL_CTL_DEL, fd, &event);
    return ret;
}
//epoll_wait函数的封装函数
int Epoll::waitEvents(int time_ms)
{
    int events_num = ::epoll_wait(m_epoll_fd, &*m_eventlist.begin(), \
    static_cast<int>(m_eventlist.size()), time_ms);
    if(events_num == 0) {
        // printf("[Epoll::wait] nothing happen, epoll timeout\n");
    } else if(events_num < 0) {
        printf("[Epoll::wait] epoll : %s\n", strerror(errno));
    }
    
    return events_num;
}

void Epoll::handleEvent(int listen_fd, std::shared_ptr<ThreadPool>& thread_pool, int events_num)
{
    assert(events_num > 0);
    for(int i = 0; i < events_num; ++i) {
        HttpRequest* request = static_cast<HttpRequest*>(m_eventlist[i].data.ptr); 
        int fd = request->fd();

        if(fd == listen_fd) {
            m_new_conn_cb();
        } else {
            // check error
            //如果出错则关闭连接
            if((m_eventlist[i].events & EPOLLERR) ||
               (m_eventlist[i].events & EPOLLHUP) ||
               (!m_eventlist[i].events & EPOLLIN)) {
                request->setStopWorking();
                m_close_conn_cb(request);
			//根据对应的事件向线程池中任务队列添加任务
            } else if(m_eventlist[i].events & EPOLLIN) {
                request->setWorking();
                thread_pool->addTask(std::bind(m_req_cb, request));

            } else if(m_eventlist[i].events & EPOLLOUT) {
                request->setWorking();
                thread_pool->addTask(std::bind(m_res_cb, request));
                
            } else {
                printf("[Epoll::handleEvent] unexpected event\n");
            }
        }
    }
    return;
}

（2）Server Class:

Reactor模型的基本流程：

在这里插入图片描述

//HttpServer.h
#ifndef __HTTP_SERVER_H__
#define __HTTP_SERVER_H__

#include <memory>
#include <mutex>

#define EPOLL_TIMEOUT_MS  -1//epoll_wait timeout
#define CONNECT_TIMEOUT  500
#define WORKERS_NUM  4

namespace huhu{

class HttpRequest;
class Epoll;
class ThreadPool;
class TimerManager;

class HttpServer{
public:
    HttpServer(int port, int thread_num);
    ~HttpServer();
    void runHuHu();

private:
    void __acceptConnection();
    void __closeConnection(HttpRequest* request);
    void __doRequest(HttpRequest* request);
    void __doResponse(HttpRequest* request);

private:
    using ListenRequestPtr = std::unique_ptr<HttpRequest>;
    using EpollPtr = std::unique_ptr<Epoll>;
    using ThreadPoolPtr = std::shared_ptr<ThreadPool>;
    using TimerManagerPtr = std::unique_ptr<TimerManager>;

    int m_port;
    int m_listen_fd;
    std::mutex m_mtx;
    ListenRequestPtr m_listen_request;
    EpollPtr m_epoll;
    ThreadPoolPtr m_threadpool;
    TimerManagerPtr m_timer_manager;

};//class HttpServer

}//namespace huhu

#endif

//HttpServer.cpp
#include "../include/HttpServer.h"
#include "../include/HttpRequest.h"
#include "../include/HttpResponse.h"
#include "../include/Utils.h"
#include "../include/Epoll.h"
#include "../include/ThreadPool.h"
#include "../include/Timer.h"

#include <iostream>
#include <functional> // bind
#include <cassert> // assert
#include <cstring> // bzero
 
#include <unistd.h> // close, read
#include <sys/socket.h> // accept
#include <arpa/inet.h> // sockaddr_in

using namespace huhu;

HttpServer::HttpServer(int port, int thread_num) 
    : m_port(port),
      m_listen_fd(utils::createListenFd(m_port)),
      m_listen_request(new HttpRequest(m_listen_fd)),
      m_epoll(new Epoll()),
      m_threadpool(new ThreadPool(thread_num)),
      m_timer_manager(new TimerManager())
{
    assert(m_listen_fd >= 0);
}

HttpServer::~HttpServer(){}

void HttpServer::runHuHu()
{
	//添加监听fd到epoll树上，ET
    m_epoll->addFd(m_listen_fd, m_listen_request.get(), (EPOLLIN | EPOLLET));
    //设置相应的回调函数
    m_epoll->setNewConnection(std::bind(&HttpServer::__acceptConnection, this));
    m_epoll->setCloseConnection(std::bind(&HttpServer::__closeConnection, this, \
    std::placeholders::_1));
    m_epoll->setRequest(std::bind(&HttpServer::__doRequest, this, \
    std::placeholders::_1));
    m_epoll->setResponse(std::bind(&HttpServer::__doResponse, this, \
    std::placeholders::_1));

    // event loop
    while(1) {
    	//获取距离下一次超时的时间
        int time_ms = m_timer_manager->getNextExpireTime();

        int events_num = m_epoll->waitEvents(time_ms);

        if(events_num > 0) {
            // event dispatch
            m_epoll->handleEvent(m_listen_fd, m_threadpool, events_num);
        }
        //处理超时事件
        m_timer_manager->handleExpireTimer(); 
    }
}

// ET
void HttpServer::__acceptConnection()
{
    while(1) {
        int accept_fd = ::accept4(m_listen_fd, nullptr, nullptr, SOCK_NONBLOCK | SOCK_CLOEXEC);
        if(accept_fd == -1) {
            if(errno == EAGAIN)
                break;
            printf("[HttpServer::__acceptConnection] accept : %s\n", strerror(errno));
            break;
        }
        HttpRequest* request = new HttpRequest(accept_fd);
        m_timer_manager->addTimer(request, CONNECT_TIMEOUT, std::bind(&HttpServer::__closeConnection, this, request));
        //EPOLLIN, edge trigger, oneshot
        m_epoll->addFd(accept_fd, request, (EPOLLIN | EPOLLET | EPOLLONESHOT));
    }
}

void HttpServer::__closeConnection(HttpRequest* request)
{
	//此处必须加锁，否则在处理较大静态文件响应时会造成2次释放
	std::unique_lock<mutex> lock(m_mtx);
    int fd = request->fd();
    if(request->isWorking()) {
        return;
    }
    m_timer_manager->delTimer(request);
    m_epoll->delFd(fd, request, 0);
    if(request != nullptr){
        delete request;
        request = nullptr;
    }
}

// LT
void HttpServer::__doRequest(HttpRequest* request)
{
	//处理请求时先删除定时器
    m_timer_manager->delTimer(request);
    assert(request != nullptr);
    int fd = request->fd();

    int read_error;
    int n_read = request->readData(&read_error);

    // client disconnection
    if(n_read == 0) {
        request->setStopWorking();
        __closeConnection(request);
        return; 
    }

    // connection error
    if(n_read < 0 && (read_error != EAGAIN)) {
        request->setStopWorking();
        __closeConnection(request);
        return; 
    }

    // EAGAIN error, m_epoll->mod(...)
    if(n_read < 0 && read_error == EAGAIN) {
    	//因为之前是oneshot，所以这里需要重新modFd，使得下次读写事件就绪的时候epoll_wait会返回
        m_epoll->modFd(fd, request, (EPOLLIN | EPOLLONESHOT));
        request->setStopWorking();
        m_timer_manager->addTimer(request, CONNECT_TIMEOUT, \
        std::bind(&HttpServer::__closeConnection, this, request));

        return;
    }

    // parse request
    //如果解析请求错误就返回400响应报文，并断开连接
    if(!request->parseRequest()) {
        
        HttpResponse response(400, "", false);
        request->appendOutBuffer(response.makeResponse());

        int write_error;
        request->writeData(&write_error);
        request->setStopWorking();
        __closeConnection(request); 
        return; 
    }
	//报文解析完成就构造响应报文，modFd为默认的LT模式
    if(request->parseFinish()) {
        HttpResponse response(200, request->getPath(), request->keepAlive());
        request->appendOutBuffer(response.makeResponse());
        m_epoll->modFd(fd, request, (EPOLLIN | EPOLLOUT | EPOLLONESHOT));
    }
}

// LT
void HttpServer::__doResponse(HttpRequest* request)
{
	//处理响应的时候先删除reques的定时器
    m_timer_manager->delTimer(request);
    assert(request != nullptr);
    int fd = request->fd();

    int to_write = request->writableBytes();
	//如果缓冲区可写大小为0，则设置超时定时器后直接返回
    if(to_write == 0) {
        m_epoll->modFd(fd, request, (EPOLLIN | EPOLLONESHOT));
        request->setStopWorking();
        m_timer_manager->addTimer(request, CONNECT_TIMEOUT, \
        std::bind(&HttpServer::__closeConnection, this, request));
        return;
    }

    int write_error;
    int ret = request->writeData(&write_error);

    if(ret < 0 && write_error == EAGAIN) {
        m_epoll->modFd(fd, request, (EPOLLIN | EPOLLOUT | EPOLLONESHOT));
        return;
    }

    if(ret < 0 && (write_error != EAGAIN)) {
        request->setStopWorking();
        __closeConnection(request);
        return;
    }
	//缓冲区的可写空间已经写完
    if(ret == to_write) {
        if(request->keepAlive()) {//如果是长连接则重新设置解析状态，modFd注册可读事件（因为oneshot），重新设置定时器
            request->resetParseStatus();
            m_epoll->modFd(fd, request, (EPOLLIN | EPOLLONESHOT));
            request->setStopWorking();
            m_timer_manager->addTimer(request, CONNECT_TIMEOUT, \
            std::bind(&HttpServer::__closeConnection, this, request));
        } else {//短连接直接断开连接
            request->setStopWorking();
            __closeConnection(request);
        }
        return;
    }
	//正常情况缓冲区的空间没写完，则modFd读写事件，重新设置定时器
    m_epoll->modFd(fd, request, (EPOLLIN | EPOLLOUT | EPOLLONESHOT));
    request->setStopWorking();
    m_timer_manager->addTimer(request, CONNECT_TIMEOUT, \
    std::bind(&HttpServer::__closeConnection, this, request));
    return;
}
AlexanderGan
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于的epoll模型的简单http服务器
baudgg1992的专栏
04-14 2058
epoll模型主要有2种工作方式：水平触发(LT)和边缘触发(ET)，本文主要是关于边缘触发的。 本文实现的epoll多线程模型主要是，主线程等待事件触发，然后把相关事件放入队列，线程池从队列中取出数据处理事件。
基于epoll的简单的httpserver
weixin_34033624的博客
04-17 151
该httpserver已经能够处理并发连接，支持多个client并发訪问，每一个连接能够持续读写数据。当然。这仅仅是一个简单的学习样例。还有非常多bug，发表出来仅仅是希望大家能够互相学习。我也在不断的改进，希望大家有什么意见能够多多指点，谢谢 server.h /* * server.h * * Created on: Jun 23, 2014 * Aut...
C++实现基于http协议的epoll非阻塞模型的web服务器框架（支持访问服务器目录下文件的解析）
最新发布
wuxiaoyu0806的博客
05-23 957
服务器的IP地址:端口 应用层协议使用:http，数据需要在浏览器端使用该协议进行包装响应消息的处理也是浏览器完成的 => 程序猿不需要管-客户端通过ur1访问服务器资源。客户端发送给的请求消息是基于http的 -需要能够解析http请求 服务器回复客户端数据，使用http协议封装回复的数据=>http响应。content-length ：服务器给客户端的数据快的长度==http协议的第四块的数据块的长度，总字节数；响应的数据，根据客户端请求给客户端回复的数据。第一部分：GET :提交的数据的方式。
基于epoll的简单的http服务器
fangjian1204的专栏
06-25 4758
本人用epoll写了一个简单的http服务器，该服务器在客户端第一次发送数据时可以正确处理，但是当客户端不关闭继续发送数据时，服务器无法读取，请求大家帮忙看看哪里有问题，谢谢server.h/* * server.h * * Created on: Jun 23, 2014 * Author: fangjian */ #include #ifndef SERVER_H_
徒手撸个http服务器(三)------epoll 实现
unicxitoiv的博客
08-19 763
epoll_wait(2)SYNOPSIS#include <sys/epoll.h> int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);DESCRIPTIONepoll_wait()系统调用等待文件描述符epfd引用的epoll实例上的事件. 事件指向的内存区域将包含可用于调用者的事件.
c++ httpserver 服务器
weixin_34204057的博客
06-14 1291
为什么80%的码农都做不了架构师？>>> ...
epollExample.txt.gz_epoll C++_epoll file server_epoll server_epo
07-14
一个简短的epoll服务器示例, 监听5000个端口, 使用线程池 运行这个程序需要预先设置栈内存和文件描述符上限, 否则运行失败
tcp.zip_epoll_epoll client_epoll server_linux tcp epoll_tcp epol
09-22
标题中的“tcp.zip_epoll_epoll client_epoll server_linux tcp epoll_tcp epoll”表明这是一个关于Linux系统下使用epoll实现高性能TCP服务器和客户端的项目。描述中提到“High Performance C++ object oriented TCP...
epoll-server.rar_Server_epoll_tcp_tcp server epoll_tcp_epoll
07-15
epoll tcp server. 适用于TCP server。C/C++ 均可适用。 可以用于TCP server服务器端的通信处理，可扩展性强。
HttpServer.rar_C++ web服务器_HTTPServer_c++ webserver_c++ webserv
07-13
【标题】"HttpServer.rar_C++ web服务器_HTTPServer_c++ webserver_c++ webserv" 涉及的核心知识点是C++实现的Web服务器，通常称为HTTPServer。在Web开发中，服务器端扮演着至关重要的角色，它们负责接收客户端（如...
server.rar_c++ Socket服务类_socket server
07-13
"server.rar_c++ Socket服务类_socket server"这个资源提供了一个基于select模型的Socket服务器端的封装类，带有详细的注释，方便理解和使用。下面将详细介绍相关知识点。 1. **Socket基础**： Socket是网络通信中...
epoll回射服务器
09-14
C++写的epoll回射服务器,适合初学者
cpp-使用epoll从头开始构建基于事件循环的微小http服务器
08-16
使用epoll从头开始构建基于事件循环的微小http服务器
轻量级C++实现的httpserver和httpclient
03-17
轻量级C++实现的httpserver和httpclient，给予mongoose，代码量很小，可以方便嵌入到自己的项目中，为C++项目添加http的功能，抛弃libcurl这种重型库
tinyserver:C++实现的简单http服务器（进程池+epoll）
05-10
tinyserver 使用进程池+epoll方式实现的简单http服务器。父程序创建进程池，并监听客户端连接。父进程与子进程池之间利用管道进行通信，父进程将连接请求通知子进程处理（采用轮询方式选择），子进程完成客户端http请求处理过程。父子进程在接收到注册信号后调用信号处理函数进行处理。信号处理函数仅通知当前信号事件，逻辑处理交由用户态代码完成，避免信号处理时间过长（如果采用signal信号处理方式还可能导致信号丢失）。 实现模型图： cgi程序修改自J.David源码，以验证服务端逻辑功能。后续考虑抽象“子进程选择”功能，采用其他负载均衡策略测试。由于cgi会使用标准输入输出接口，故守护进程功能（daemon_init）未进行部署。 部署方法 make ./tinyserver 在浏览器输入：127.0.0.1:8001 如果POST命令不能正常显示返回结果，将htdocs目录下的cg
Linux + C + Epoll实现高并发服务器(线程池 + 数据库连接池)
09-27
在Linux 系统下面用C 语言实现的高并发服务器的代码，具体用到了Epoll，线程池，数据库连接池。 具体可以看下连接http://blog.csdn.net/wuyuxing24/article/details/48758927
IO多路转接—epoll，并且实现epoll版本的http服务器
qq_37941471的博客
07-10 1618
下面是关于高级IO我总结的一篇文章： https://blog.csdn.net/qq_37941471/article/details/80952057 可以了解一下 五种IO模型 以及 它们之间的关系； 当然还有IO多路转接的其他实现方式：poll epoll 以及三者之间的对比 epoll 1. epoll的目的 : 1. 按照man手册来说：为了处理大批量句...
从零编写c++之http服务器(2)-epoll异步事件驱动框架
kwanson的博客
07-27 2699
       epoll是select/poll基础上改进的为大规模描述符事件监测的机制，常出现在高性能，高并发的服务器设计中。在这里我们需要设计一个框架，实现套接字对象将自身注册到框架中，框架即可利用epoll对其套接字进行事件监测；当事件产生时通知相应的套接字对象。从而实现事件的监测与处理解耦。惯例还是献上类图。 完整源码见&lt;https://github.com/kwansoner/p...
C++实现使用epoll实现一个通用的服务器压力测试程序 代码或者函数
05-04
以下是使用 epoll 实现的服务器压力测试程序的代码： ```c #include #include #include #include #include <sys/epoll.h> #include #include #include #define MAX_EVENTS 1024 #define BUFFER_SIZE 1024 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值