【项目设计】仿 muduo 库实现 OneThreadOneEventLoop 式并发服务器

#include <sys/timerfd.h>
int timerfd_create(int clockid, int flags);
clockid: 
	CLOCK_REALTIME - 表示系统实时时间，如果定时器运行过程中修改了系统时间就会出现问题
	CLOCK_MONOTONIC - 从系统开机到现在的时间，是⼀种相对时间
flags: 0 - 默认阻塞
返回值：timerfd的操作和普通文件操作是一样的，因此timerfd_create返回的时一个文件描述符

int timerfd_settime(int fd, int flags, struct itimerspec *new, struct itimerspec *old);
fd: timerfd_create 返回的⽂件描述符
flags: 0 - 表示使用相对时间， 1 - 表示使用绝对时间；默认设置为0即可
new： 用于设置定时器的新超时时间
old： ⽤于接收原来的超时时间，不关心直接设置为NULL即可
返回值：启动成功返回0，失败返回-1

// timerfd 中用于设置时间的两个结构体
struct timespec {
    time_t tv_sec;  /* 秒 */
    long tv_nsec;   /* 纳秒 */
};

struct itimerspec {
    struct timespec it_interval;  /* 第⼀次超时之后每次超时的间隔时间 */
    struct timespec it_value;    /* 第⼀次超时时间 */
};

#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/timerfd.h>

int main() 
{
    // 创建定时器
    int timefd = timerfd_create(CLOCK_MONOTONIC, 0);
    if(timefd < 0) {
        printf("timerfd create error\n");
        return 1;
    }
    // 设置首次超时时间
    struct itimerspec itime;
    itime.it_value.tv_sec = 3;
    itime.it_value.tv_nsec = 0;
    // 设置后续超时时间间隔
    itime.it_interval.tv_sec = 1;
    itime.it_interval.tv_nsec = 0;
    // 启动定时器
    int n = timerfd_settime(timefd, 0, &itime, NULL);
    if (n == -1) {
        printf("timerfd settime error\n");
        return 1;
    }
    // 从timefd中读取超时次数
    while(1) {
        // 注意一次读取8字节数据
        uint64_t times;
        int n = read(timefd, &times, 8);
        if (n < 0) {
            printf("read error\n");
            return 1;
        }
        printf("超时次数：%ld\n", times);
    }
    return 0;
}

using TaskFunc_t = std::function<void()>;
using ReleaseFunc_t = std::function<void()>;

/*定时任务*/
class TimerTask {
public:
    TimerTask(uint64_t id, uint32_t timeout, const TaskFunc_t &task_cb)
    : _id(id), _timeout(timeout), _cancelled(false), _task_cb(task_cb)
    {}

    /*设置release_cb回调函数*/
    void SetRelease(const ReleaseFunc_t &release_cb) { _release_cb = release_cb; }

    /*返回定时器任务超时时间*/
    uint64_t Timeout() { return _timeout; }

    /*取消定时任务*/
    void Cancel() { _cancelled = true; }

    /*在析构函数中执行定时任务*/
    ~TimerTask() {
        if(_cancelled == false) _task_cb();
        _release_cb();
    }
private:
    uint64_t _id;          // 定时器任务id
    uint32_t _timeout;     // 超时时间
    bool _cancelled;       // 定时任务是否被取消
    TaskFunc_t _task_cb;   // 超时后执行的定时任务
    ReleaseFunc_t _release_cb;  // 用于删除TimerWheel中保存的定时器任务对象信息(weak_ptr)
};

using TaskPtr = std::shared_ptr<TimerTask>;
using TaskWeak = std::weak_ptr<TimerTask>;

/*时间轮*/
class TimerWheel {
private:
    /*SetRelease回调函数 -- 从unordered_map中将定时任务信息移除*/
    void RemoveTimer(uint64_t id) {
        auto it = _timers.find(id);
        if(it != _timers.end()) 
            _timers.erase(it);
    }
public:
    TimerWheel()
    : _capacity(60), _tick(0), _wheel(_capacity)
    {}

    /*添加定时任务*/
    void TimerAdd(uint64_t id, uint32_t timeout, const TaskFunc_t &cb) {
        // 实例化定时任务对象并交由智能指针管理
        TaskPtr tp(new TimerTask(id, timeout, cb));
        // 为了不增加引用计数，这里不能使用shared_ptr
        _timers[id] = TaskWeak(tp);
        tp->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        // 将定时任务对象的shared_ptr添加到时间轮中
        int pos = (_tick + timeout) % _capacity;
        _wheel[pos].push_back(tp);
    }

    /*刷新/延迟定时任务*/
    void TimerReFlush(uint64_t id) {
        // 通过定时任务的weak_ptr构造一个shared_ptr
        auto it = _timers.find(id);
        if(it == _timers.end()) return;
        TaskPtr tp = (it->second).lock();
        // 获取超时时间
        uint32_t timeout = tp->Timeout();
        // 将shared_ptr添加到时间轮中
        int pos = (_tick + timeout) % _capacity;
        _wheel[pos].push_back(tp);
    }

    /*取消定时任务*/
    void TimerCancel(uint64_t id) {
        // 通过定时任务的weak_ptr构造一个shared_ptr
        auto it = _timers.find(id);
        if(it == _timers.end()) return;
        TaskPtr tp = (it->second).lock();
        // 通过shared_ptr设置定时任务的取消状态
        tp->Cancel();        
    }

    /*执行定时任务 -- 此函数应一秒被执行一次，相当于秒针向后移动一步*/
    void RunTimerTask() {
        _tick = (_tick + 1) % _capacity;
        // 将秒针对应位置的定时任务队列清空，即释放定时任务对象的shared_ptr
        _wheel[_tick].clear();
    }
private:
    int _capacity;                                  // 容量，代表最大延迟时间
    int _tick;                                      // 当前的秒针，指向哪里就执行哪里的定时任务
    std::vector<std::vector<TaskPtr>> _wheel;       // 时间轮
    std::unordered_map<uint64_t, TaskWeak> _timers; // 定时器任务id与管理定时任务对象的weak_ptr之间的关联关系
};

class Test {
public:
    Test() { std::cout << "构造" << std::endl; }
    ~Test() { std::cout << "析构" << std::endl; }
};

void Deltest(Test *t) { delete t; }

int main()
{
    Test *t = new Test();
    TimerWheel tw;
    tw.TimerAdd(1, 5, std::bind(Deltest, t));
    // 刷新定时任务
    for(int i = 0; i < 5; i++) {
        sleep(1);
        // 刷新定时任务
        tw.TimerReFlush(1);  
        // 向后移动秒针
        tw.RunTimerTask();
        std::cout << "刷新定时任务超时时间为5s" << std::endl;
    }
    // 取消定时任务
    // tw.TimerCancel(1);
    // std::cout << "取消定时任务" << std::endl;
    // 让秒针向后走
    while(true) {
        sleep(1);
        tw.RunTimerTask();
        std::cout << "秒针向后移动..." << std::endl;
    }
    return 0;
}

#include <sys/eventfd.h>
int eventfd(unsigned int initval, int flags);
initval: eventfd中计数器的初始值，通常设置为0;
flags：设置描述符属性，通常设置 EFD_CLOEXEC 和 EFD_NONBLOCK 即可。
       EFD_CLOEXEC -- 禁止进程复制
       EFD_NONBLOCK -- 设置描述符非阻塞属性
返回值：返回一个文件描述符用于操作。    

#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <fcntl.h>
#include <sys/eventfd.h>

int main() {
    int fd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
    if (fd < 0) {
        printf("eventfd failed\n");
        return 1;
    }
    // 每次向eventfd中写入1，表示一次事件通知
    // 8字节数据
    uint64_t val = 1;  
    write(fd, &val, sizeof val);
    write(fd, &val, sizeof val);
    write(fd, &val, sizeof val);
    // 读取结果表示事件通知的次数，读取完毕后计数器清0
    uint64_t res;
    read(fd, &res, sizeof res);
    printf("%ld\n", res);
    return 0;
}

GET /login?user=zhangsan&pass=123456 HTTP/1.1\r\n

GET -- 请求方法，我们需要针对不同的请求方法执行不同的操作
/login -- 请求URL，我们需要知道客户端想要访问哪里的数据
user=zhangsan&pass=123456 -- 请求数据
HTTP/1.1 -- 协议版本

// 简单理解 regex_match 函数
bool regex_match(string src, smatch matches, regex e);
src: 用于匹配的原始字符串;
e: 字符串的匹配规则;
matches: 用于存在根据匹配规则e对原始字符串src进行匹配得到的结果;
返回值：匹配成功返回true，匹配失败返回false

bool test1() {
    // 原始字符串
    std::string str = "/number/123";
    // 正则表达式(字符串匹配规则)
    // 前面的 "/number/" 表示原字符串，() 表示开始根据模式进行匹配，"\\" 转义为 "\", "\d"表示匹配数字字符，+表示匹配一次或多次
    std::regex e("/number/(\\d+)");
    // 存放匹配结果的容器
    std::smatch matches;
    // 正则匹配
    bool ret = std::regex_match(str, matches, e);
    if(ret == false) return false;
    for(auto &e : matches) {
        std::cout << e << std::endl;
    }
    return true;
}

bool test2() {
    // HTTP请求行格式："GET /login?user=zhangsan&pass=123456 HTTP/1.1\r\n"
    std::string str = "GET /login?user=zhangsan&pass=123456 HTTP/1.1\r\n";
    std::smatch matches;

    // 正则表达式
    // 提取请求方法：(GET|POST|PUT|DELETE|HEAD) -- |表示或者，()表示提取匹配结果，整体表示提取其中任意一个字符串
    // 提取请求URI：_([^?]*) -- 我们用_表示空格，[^?]表示匹配除?号外的所有字符，*表示可以多次匹配
    // 提取数据：\\?(.*) -- \\?表示普通的?字符，(.*)表示可以多次匹配任意字符并提取\
    //                        外边的(?:)?表示如果没有数据，则匹配但不提取
    // 提取协议版本：_ (HTTP/1\\.[01]) -- _表示空格，HTTP/1\\.表示匹配原字符串中的HTTP/1\\.，其中\\.表示普通的.，最后[01]表示匹配0或者1
    // \r\n处理：(?:\n|\r\n)? -- (?:xxx)表示匹配xxx格式字符串但不提取，最后的?表示执行前面的表达式一次或零次
    std::regex e("(GET|POST|PUT|DELETE|HEAD) ([^?]*)(?:\\?(.*))? (HTTP/1\\.[01])(?:\n|\r\n)?");
    if(std::regex_match(str, matches, e) == false) return false;
    for(int i = 0; i < matches.size(); i++) {
        std::cout << i << ":" << matches[i] << std::endl;
    }
    return true;
}

template<class T>
class Any {
private:
	T _content;
};

Any<int> a1;
Any<float> a2;

class Any{
private:
    template<class T>
    class hodler{
        T _val;
    };
    hodler<T> _content;
};

class Any{
private:
    class hodler {
        // ...
    };
    template<class T>
    class placehodler : public hodler {
     	T_ val;
    };
    hodler *_content;
};

// 定义any时不需要指定any的类型
Any any;
// 需要存储特定数据类型时，直接new该类型对应的placehodler对象，然后将其交由any中的父类指针_content管理
placehodler<int> *h1 = new placehodler;
any._content = h1;
placehodler<double> *h2 = new placehodler;
any._content = h2;

#include <iostream>
#include <typeinfo>
#include <utility>

class Any {
private:
    class holder {
    public:
        virtual ~holder() {}
        virtual const std::type_info& type() = 0;
        virtual holder *clone() = 0;
    };

    template<class T>
    class placeholder : public holder {
    public:
        placeholder(const T &val) : _val(val) {}
        virtual ~placeholder() {}
        /*获取子类保存的数据的类型*/
        virtual const std::type_info& type() { return typeid(T); }
        /*针对当前对象自身，克隆出一个新的子类对象*/
        virtual holder *clone() { return new placeholder(_val); }
    public:
        T _val;  // 真正需要保存的数据
    };
public:
    Any() : _content(nullptr) {}
    /*通过特定类型数据创建Any对象*/
    template<class T>
    Any(const T &val) : _content(new placeholder<T>(val)) {}
    /*通过其他Any对象创建一个新的Any对象*/
    Any(const Any &other) : _content(other._content == nullptr ? nullptr : other._content->clone()) {}
    ~Any() { if(_content) delete _content; }

    /*获取子类placeholder中保存的数据的指针*/
    template<class T>
    T* get() {
        // 想要获取的数据的类型与保存的数据的类型必须是一致的
        if(typeid(T) != _content->type()) return nullptr;
        // 由于父类holder中没有val，所以需要进行强转
        return &((placeholder<T>*)_content)->_val;
    }

    /*交换两个Any对象中的指针*/
    Any& swap(Any &other) { std::swap(_content, other._content); }

    /*赋值运算符重载*/
    template<class T>
    Any& operator=(const T &val) {
        // 利用临时对象来完成赋值操作，赋值完成后原对象中的资源出作用域自动释放
        Any(val).swap(*this);
        return *this;
    }
    
    Any& operator=(Any other) {
        // 利用形参的拷贝构造(临时对象)来完成赋值操作，赋值完成后原对象中的资源出作用域自动释放
        swap(other);
        return *this;
    }
private:
    holder *_content;  // 保存父类指针，利用多态性质完成Any类保存任意类型数据的功能
};

class Test {
public:
    Test() { std::cout << "构造" << std::endl; }
    Test(const Test& t) { std::cout << "拷贝构造" << std::endl; }
    ~Test() { std::cout << "析构" << std::endl; }
};

int main()
{
    Any any;
    any = 10;
    int *pa = any.get<int>();
    std::cout << *pa << std::endl;

    any = 10.24;
    double* pd = any.get<double>();
    std::cout << *pd << std::endl;

    any = std::string("hello");
    std::string *ps = any.get<std::string>();
    std::cout << *ps << std::endl;

    // 测试是否存在内存泄露
    {
        any = Test();
    }
    
    return 0;
}

/*用户缓冲区类*/
class Buffer {
public:
    Buffer() : _capacity(DEFAULT_BUFFER_SIZE), _ridx(0), _widx(0), _buffer(_capacity) {}
    Buffer(const Buffer &buf) : _capacity(buf._capacity), _ridx(buf._ridx), _widx(buf._widx), _buffer(buf._buffer) {}

    /*返回缓冲区中可读数据的大小*/
    uint32_t ReadAbleSize() const { return _widx - _ridx; }

    /*返回当前读取数据的起始地址*/
    const char* ReadStartAddr() const { return &_buffer[_ridx]; }

    /*将读取数据位置向后偏移*/
    void MoveReadOffset(uint32_t len) {
        assert(len <= ReadAbleSize());
        _ridx += len;
    }

    /*清空缓冲区中的数据*/
    void Clear() {
        Buffer buf;
        std::swap(*this, buf);
    }

    /*从缓冲区读取数据*/
    void Read(void* buf, uint32_t len) {
        // 要读取的数据大小一定要小于等于可读数据大小
        assert(len <= ReadAbleSize());
        // 获取当前读取数据的起始地址
        char *raddr = &_buffer[_ridx];
        // 拷贝数据
        std::copy(raddr, raddr + len, (char*)buf);
        // 更新当前读取数据位置
        _ridx += len;
    }

    /*重载读取string类型的数据*/
    std::string Read(uint32_t len) {
        std::string str;
        str.resize(len);
        Read((void*)&str[0], len);
        return str;
    } 

    /*确保缓冲区可写入空间足够(拷贝+扩容)*/
    void CheckWriteSpace(uint32_t len) {
        // 获取缓冲区可写入空间大小 -- 写入位置后面未使用的空间+读取位置前已读取的空间
        uint32_t size = _ridx + (_capacity - _widx);
        // 空间足够则调整数据分布
        if (size >= len) {
            std::copy(&_buffer[_ridx], &_buffer[_ridx] + ReadAbleSize(), &_buffer[0]);
            // 这里需要先更新写位置，再更新读位置，否则ReaableSize()得到的结果不同
            _widx = ReadAbleSize();
            _ridx = 0;
        } 
        // 空间不够则扩容，一次扩容两倍
        else {
            _capacity *= 2;
            _buffer.resize(_capacity);
            // 扩容完毕后再次检查可写入空间是否足够
            CheckWriteSpace(len);
        }
    }

    /*向缓冲区中写入数据*/
    void Write(const void *data, uint32_t len) {
        // 确保缓冲区可写入空间足够
        CheckWriteSpace(len);
        // 写入数据到缓冲区
        std::copy((char*)data, (char*)data + len, &_buffer[_widx]);
        // 更新当前写入数据位置
        _widx += len;
    }

    /*重载写入string类型的数据*/
    void Write(const std::string &data, uint32_t len) {
        Write((const void*)data.c_str(), len);
    }

    // /*重载写入Buffer类型的数据*/
    // void Write(const Buffer &data, uint32_t len) {
    //     // 取出data缓冲区中的所有数据
    //     Write((const void*)data.ReadStartAddr(), data.ReadAbleSize());
    // }

    /*清空缓冲区中数据*/
    void Clean() {
        // 只需要重置读取写入位置即可，不需要清空缓冲区中的原数据，后续写入直接覆盖原数据
        _ridx = 0;
        _widx = 0;
    }

    /*针对HTTP请求行的一些操作*/
    /*查找请求行结束符\r\n*/
    char* FindCRLF() { return (char*)memchr((void*)ReadStartAddr(), '\n', ReadAbleSize()); }

    /*从缓冲区中取出一行HTTP请求数据*/
    std::string GetLine() {
        char *pos = FindCRLF();
        if (pos == nullptr) return std::string();
        // +1是为了将'\n'也取出来
        return Read(pos - ReadStartAddr() + 1);
    }
private:
    uint32_t _capacity;  // 缓冲区大小
    uint32_t _ridx;      // 当前读取数据位置
    uint32_t _widx;      // 当前写入数据位置
    std::vector<char> _buffer;  // 使用vector模拟缓冲区而不是string
};

/*等待连接队列的最大长度*/
#define G_BACKLOG 1024

/*套接字类*/
class Socket {
public:
    Socket() : _sockfd(-1) {}
    Socket(int fd) : _sockfd(fd) {}
    ~Socket() { Close(); }

    /*返回套接字*/
    int Fd() {  return _sockfd; }

    /*创建套接字*/
    bool CreateSocket() {
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if(_sockfd  == -1) {
            LOG(ERROR, "socket create failed");
            return false;
        }
        return true;
    }

    /*绑定ip+port*/
    bool Bind(uint16_t port, const std::string &ip = "0.0.0.0") {
        struct sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        int n = bind(_sockfd, (const sockaddr*)&addr, len);
        if(n == -1) {
            LOG(ERROR, "socket bind failed: %s", strerror(errno));
            return false;
        }
        return true;
    }

    /*开始监听*/
    bool Listen(int g_backlog = G_BACKLOG) {
        int n = listen(_sockfd, g_backlog);
        if(n == -1) {
            LOG(ERROR, "socket listen failed");
            return false;
        }
        return true;
    }

    /*获取新连接*/
    int Accept() {
        // 这里我们不关心客户端的ip和port
        int newfd = accept(_sockfd, nullptr, nullptr);
        if(newfd == -1) {
            LOG(ERROR, "accept new link failed");
        }
        return newfd;
    }

    /*向服务器发起连接*/
    bool Connect(uint16_t port, const std::string &ip) {
        struct sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        int n = connect(_sockfd, (const sockaddr*)&addr, len);
        if(n == -1) {
            LOG(ERROR, "connect server failed");
            return false;
        }
        return true;        
    }

    /*接收数据*/
    ssize_t Recv(void* buf, size_t len) {
        // flag为0表示不使用任何特殊标志，此时函数是否阻塞由套接字属性决定
        // 所以我们可以通过SetNonBlock接口将套接字设置为非阻塞，这样send/recv函数也会变成非阻塞
        if (len == 0) return 0;
        ssize_t n = recv(_sockfd, buf, len, 0);
        // 接收失败
        // 客户端退出
        if (n == 0) {
            LOG(ERROR, "client quit");
            return -1;
        }
        else if (n < 0) {
            // 非阻塞下接收缓冲区无数据或者读取被中断
            if (errno == EAGAIN || errno == EINTR) {
                LOG(DEBUG, "socket recv EAGAIN or EINTR");
                return 0;
            }
            // 读取错误
            LOG(ERROR, "socket recv failed");
            return -1;
        }
        // 返回接收到的数据字节数
        return n;
    }

    /*发送数据*/
    ssize_t Send(const void* buf, size_t len) {
        if (len == 0) return 0;
        ssize_t n = send(_sockfd, buf, len, 0);
        // 发送失败
        // 客户端退出
        if (n == 0) {
            LOG(ERROR, "client quit");
            return -1;
        }
        else if (n < 0) {
            // 非阻塞下发送缓冲区满且写事件未就绪或者发送被中断
            if (errno == EAGAIN || errno == EINTR) {
                LOG(DEBUG, "socket send EAGAIN or EINTR");
                return 0;
            }
            // 发送错误
            LOG(ERROR, "socket send failed");
            return -1;
        }
        // 发送成功返回实际发送的字节数
        return n;
    }

    /*设置套接字选项 -- 开启地址与端口复用*/
    void SetReuseAddr() {
        // 1代表设置套接字选项等级 SOL -- socket options level
        int optval = 1;
        int n1 = setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void*)&optval, sizeof optval);
        optval = 1;
        int n2 = setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void*)&optval, sizeof optval);
        // if (n1 == 0 && n2 == 0) LOG(DEBUG, "SetReuseAddr Success");
        // else LOG(ERROR, "SetReuseAddr Failed: %s", strerror(errno));
    }

    /*设置套接字非阻塞属性*/
    void SetNonBlock() {
        //获取fd当前选项
        int flag = fcntl(_sockfd, F_GETFL);
        //将非阻塞选项设置进fd中
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }

    /*关闭套接字*/
    void Close() {
        if (_sockfd != -1) {
            close(_sockfd);
            _sockfd = -1;
        }
    }

    /*直接创建一个服务端连接*/
    bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool non_block = true) {
        // 创建套接字、设置地址重用、设置非阻塞、绑定、监听
        // 服务器连接一般bind任意ip，所以ip缺省值为0.0.0.0
        if (CreateSocket() == false) return false;
        // 注意：设置地址重用必须放在bind之前，这样才会生效
        SetReuseAddr();
        if (non_block) SetNonBlock();
        if (Bind(port, ip) == false) return false;
        if (Listen() == false) return false;
        return true;
    }

    /*直接创建一个客户端连接*/
    bool CreateClient(uint16_t port, const std::string &ip) {
        // 创建套接字、连接服务器
        // 客户端不需要显示的bind，有OS自动bind，也不需要listen与accept，只需要connect
        if (CreateSocket() == false) return false;
        if (Connect(port, ip) == false) return false;
        return true;
    }
private:
    int _sockfd;
};

class EventLoop;
/*描述符监控事件管理类*/
class Channel {
    using EventCallback = std::function<void()>;
public:
    Channel(EventLoop *loop, int fd) : _loop(loop), _fd(fd), _events(0), _revents(0) {}

    /*返回文件描述符*/
    int Fd() {  return _fd; }

    /*返回被监控的事件*/
    uint32_t Events() { return _events; }

    /*各种回调函数的设置 -- 对应事件被触发后在HandleEvent函数中调用*/
    void SetReadCallback(const EventCallback &cb) { _read_cb = cb; }
    void SetWriteCallback(const EventCallback &cb) { _write_cb = cb; }
    void SetCloseCallback(const EventCallback &cb) { _close_cb = cb; }
    void SetEventCallback(const EventCallback &cb) { _event_cb = cb; }
    void SetErrorCallback(const EventCallback &cb) { _error_cb = cb; }

    /*启动可读事件监控*/
    void EnableRead() { 
        _events |= EPOLLIN;
        Update();
    }

    /*启动可写事件监控*/
    void EnableWrite() {
        _events |= EPOLLOUT;
        Update();
    }

    /*判断当前是否监控了可读事件*/
    bool Readable() { return (_events & EPOLLIN); }

    /*判断当前是否监控了可写事件*/
    bool Writeable() { return (_events & EPOLLOUT); }

    /*关闭可读事件监控*/
    void DisableRead() {
        _events &= ~EPOLLIN;
        Update();
    }

    /*关闭可写事件监控*/
    void DisableWrite() {
        _events &= ~EPOLLOUT;
        Update();
    }

    /*关闭所有事件监控*/
    void DisableEvent() {
        _events = 0;
        Update();
    }

    /*移除事件监控*/
    /*添加/修改事件监控*/
    // 注意：由于我们我们上面只是声明了有EventLoop这个类，并不知道EventLoop里面有哪些函数
    // 但是Remove和Update又需要调用EventLoop::RemoveEvent和EventLoop::UpdateEvent
    // 所以我们需要将它们的实现放到EventLoop类后面，这里仅仅是声明
    void Remove();  
    void Update();

    /*设置就绪事件*/
    void SetRevents(uint32_t events) { _revents = events; }

    /*事件处理 -- 事件触发后调用(函数内部通过_revents判断事件类型)*/
    void HandleEvent() {
        // EPOLLIN读事件就绪/EPOLLRDHUP客户端连接半关闭(需要读取缓冲区中可能的剩余数据)/EPOLLPRI存在优先带外数据
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI)) {
            if (_read_cb) _read_cb();
        }
        // 有可能会让连接释放的就绪事件一次只执行一个
        // EPOLLOUT写事件就绪
        if (_revents & EPOLLOUT) {
            if (_write_cb) _write_cb();
        }
        // EPOLLHUP客户端连接关闭事件就绪
        else if (_revents & EPOLLHUP) {
            if (_close_cb) _close_cb();
        }
        // EPOLLERR错误事件就绪
        else if (_revents & EPOLLERR) {
            if (_error_cb) _error_cb();
        }
        // 虽然错误事件可能导致连接释放，但由于连接释放操作都是先压入到任务队列中，等待业务处理完毕后才会执行任务队列中的任务
        // 即连接真正被释放一定是在就绪事件全部处理完毕后，所以这里可以将event_cb放到最后，这样也保证了连接的活跃度刷新是在业务处理完毕后进行的
        if (_event_cb) _event_cb();        
    }
private:
    int _fd;                  // 进行监控事件管理的连接(描述符)
    EventLoop *_loop;         // 描述符事件管理与处理句柄
    uint32_t _events;         // 当前连接需要被监控的事件
    uint32_t _revents;        // 当前连接已经触发的事件
    EventCallback _read_cb;   // 可读事件被触发的回调函数
    EventCallback _write_cb;  // 可写事件被触发的回调函数   
    EventCallback _close_cb;  // 连接断开事件被触发的回调函数
    EventCallback _event_cb;  // 任意事件被触发的回调函数
    EventCallback _error_cb;  // 错误事件被触发的回调函数
};

/*Channel::Remove和Channel::Update函数的实现*/
/*移除事件监控*/
void Channel::Remove() { return _loop->RemoveEvent(this); }

/*添加/修改事件监控*/
void Channel::Update() { return _loop->UpdateEvent(this); }

/*就绪数组一次能够容纳的最大事件数量*/
#define MAX_EPOLLEVENTS 1024
/*epoll_create参数，此参数现已被忽略，但要求大于0*/
#define MAX_SIZE 1024

/*描述符IO事件监控类*/
class Poller {
private:
    /*对epoll相关函数的直接操作*/
    void Update(Channel *channel, int op) {
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.events = channel->Events();
        ev.data.fd = fd;
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret == -1) {
            LOG(ERROR, "fd %d epoll_ctl failed", fd);
            return;
        }
    }

    /*判断一个Channel是否已经添加了事件监控*/
    bool HasChannel(Channel *channel) {
        if (channel == nullptr) return false;
        auto it = _channels.find(channel->Fd());
        return !(it == _channels.end());
    }
public:
    Poller() {
        // 创建epoll模型
        _epfd = epoll_create(MAX_SIZE);
        if (_epfd == -1) {
            LOG(FATAL, "epoll_create failed: %s", strerror(errno));
            // epoll模型创建失败直接退出程序
            abort();
        }
    }

    /*添加或修改事件监控*/
    void UpdateEvent(Channel *channel) {
        // 没添加则添加，已经添加则修改
        if (HasChannel(channel) == false) {
            _channels[channel->Fd()] = channel;
            return Update(channel, EPOLL_CTL_ADD);
        }
        return Update(channel, EPOLL_CTL_MOD);
    }

    /*移除事件监控*/
    void RemoveEvent(Channel *channel) {
        // 存在则移除，不存在直接返回
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end()) return;
        _channels.erase(it);
        Update(channel, EPOLL_CTL_DEL);
    }

    /*启动事件监控并返回活跃连接*/
    void Poll(std::vector<Channel*> *actives) {
        // timeout设为-1表示阻塞式监控
        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1);
        if (nfds < 0) {
            if (errno == EINTR) {
                LOG(DEBUG, "epoll wait EINTR");
                return;
            }
            LOG(FATAL, "epoll wait failed: %s", strerror(errno));
            // 事件监控出错直接退出程序
            abort();
        }
        // 设置实际就绪的事件
        for (int i = 0; i < nfds; i++) {
            int fd = _evs[i].data.fd;
            auto it = _channels.find(fd);
            // 连接如果就绪，那么对应的信息一定存在于_channel中
            assert(it != _channels.end());
            Channel *channel = it->second;
            channel->SetRevents(_evs[i].events);
            actives->push_back(channel);
        }
    }
private:
    int _epfd;  // epoll操作句柄
    struct epoll_event _evs[MAX_EPOLLEVENTS];     // 就绪数组 -- 保存所有的活跃连接
    std::unordered_map<int, Channel*> _channels;  // 建立连接与其监控事件管理Channel句柄的关联关系
};

/*描述符事件监控以及事件处理类*/
class EventLoop {
    using TaskFunc = std::function<void()>;
private:
    /*执行任务队列中的所有任务*/
    void RunAllTask() {
        std::vector<TaskFunc> tasks;
        {
            // 由于任务队列可能会被多个线程并发访问，所以需要加锁保护
            std::unique_lock<std::mutex> lock(_mutex);
            // 取出任务队列中的所有任务
            std::swap(_tasks, tasks);
        }
        // 执行任务
        for (auto &task : tasks) {
            task();
        }
    }

    /*创建event_fd*/
    static int CreatEventFd() {
        int evfd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (evfd  == -1) {
            LOG(FATAL, "eventfd failed: %s", strerror(errno));
            abort();
        }
        return evfd;
    }

    /*eventfd的可读事件回调*/
    void HandleRead() {
        // 读取eventfd中的数据，使其计数器重新变为0(8字节)
        uint64_t count;
        ssize_t n = read(_event_fd, &count, 8);
        if (n < 0) {
            // 被信号中断或者非阻塞情况下无数据可读取
            if (errno == EAGAIN || errno == EINTR) {
                LOG(DEBUG, "read eventfd EAGAIN or EINTR");
                return;
            }
            LOG(FATAL, "read eventfd failed: %s", strerror(errno));
            abort();
        }
    }

    /*唤醒可能因为没有IO事件监控而导致的阻塞*/
    void WeakUpEventFd() {
        // 向eventfd中写入数据(8字节)
        uint64_t val = 1;
        ssize_t n = write(_event_fd, &val, 8);
        if (n < 0) {
            // 被信号中断或者非阻塞情况下无数据可读取
            if (errno == EAGAIN || errno == EINTR) {
                LOG(DEBUG, "write eventfd EAGAIN or EINTR");
                return;
            }
            LOG(FATAL, "write eventfd failed: %s", strerror(errno));
            abort();
        }        
    }
public:
    EventLoop()
    : _thread_id(std::this_thread::get_id()), _poller(), _event_fd(CreatEventFd()), 
                _evfd_channel(new Channel(this, _event_fd)), _timer_whell(this) {
        // 设置_event_fd的可读事件回调并启动其可读事件
        _evfd_channel->SetReadCallback(std::bind(&EventLoop::HandleRead, this));
        _evfd_channel->EnableRead();
    }

    /*判断当前线程是否是EventLoop对应的线程*/
    bool IsInLoop() { return _thread_id == std::this_thread::get_id(); }

    /*确保当前线程就是EventLoop对应的线程*/
    void AssertInLoop() { assert(_thread_id == std::this_thread::get_id()); }

    /*判断将要执行的任务是否处于当前线程中，是则直接执行，不是则将其添加到任务队列中*/
    void RunInLoop(const TaskFunc &task) {
        if (IsInLoop()) return task();
        return QueueInLoop(task);
    }

    /*将任务添加到任务队列中*/
    void QueueInLoop(const TaskFunc &task) {
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _tasks.push_back(task);
        }
        // 唤醒可能因为没有IO事件监控而导致的阻塞
        WeakUpEventFd();
    }

    /*添加/修改描述符的监控事件*/
    void UpdateEvent(Channel *channel) { return _poller.UpdateEvent(channel); }

    /*移除描述符的事件监控*/
    void RemoveEvent(Channel *channel) { return _poller.RemoveEvent(channel); }

    /*添加定时任务*/
    void AddTimer(uint64_t id, uint32_t timeout, const TaskFunc& task) { return _timer_whell.AddTimer(id, timeout, task); }

    /*刷新/延迟定时任务*/
    void ReFlushTimer(uint64_t id) { return _timer_whell.ReFlushTimer(id); }

    /*取消定时任务*/
    void CancelTimer(uint64_t id) { return _timer_whell.CancelTimer(id); }

    /*判断某个定时任务是否存在*/
    bool HasTimer(uint64_t id) { return _timer_whell.HasTimer(id); }

    /*启动EventLoop模块*/
    void Start() {
        while(true) {
            // 开始监控，获取活跃连接
            std::vector<Channel*> actives;
            _poller.Poll(&actives);
            // 处理活跃连接的就绪事件
            for (auto &channel : actives) { channel->HandleEvent(); }
            // 执行任务
            RunAllTask();
        }
    }
private:
    std::thread::id _thread_id;                // EventLoop关联的线程ID
    Poller _poller;                            // 描述符IO事件监控模块
    int _event_fd;                             // eventfd -- 唤醒IO事件监控可能导致的阻塞
    std::unique_ptr<Channel> _evfd_channel;    // 管理_event_fd的监控事件
    std::mutex _mutex;                         // 实现任务队列的线程安全
    std::vector<TaskFunc> _tasks;              // 任务队列
    TimerWheel _timer_whell;                   // 定时器模块
};

class EventLoop;
/*时间轮*/
class TimerWheel {
    using TaskFunc = std::function<void()>;
    using TaskPtr = std::shared_ptr<TimerTask>;
    using TaskWeak = std::weak_ptr<TimerTask>;
private:
    /*SetRelease回调函数 -- 从unordered_map中将定时任务信息移除*/
    void RemoveTimer(uint64_t id) {
        auto it = _timers.find(id);
        if(it != _timers.end()) 
            _timers.erase(it);
    }

    /*创建定时器*/
    static int CreateTimerFd() {
        // 创建定时器
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if(timerfd == -1) {
            LOG(FATAL, "timerfd create failed: %s", strerror(errno));
            abort();
        }
        // 设置首次超时时间 -- 1s
        struct itimerspec itime;
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0;
        // 设置后续超时时间间隔 -- 1s
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0;
        // 启动定时器
        int n = timerfd_settime(timerfd, 0, &itime, NULL);
        if (n == -1) {
            LOG(FATAL, "timerfd settime failed: %s", strerror(errno));
            abort();
        }   
        return timerfd;     
    }

    /*定时器可读事件回调*/
    uint64_t ReadTimerFd() {
        // 读取timerfd中的内容 -- 使其计数器变为0(8字节)
        uint64_t times;
        int n = read(_timer_fd, &times, 8);
        if (n < 0) {
            // 被信号中断或者非阻塞情况下无数据可读取
            if (errno == EAGAIN || errno == EINTR) {
                LOG(DEBUG, "read timerfd EAGAIN or EINTR");
                return 0;
            }
            LOG(FATAL, "read timerfd failed: %s", strerror(errno));
            abort();
        } 
        return times;  
    }

    /*执行定时任务 -- 此函数应一秒被执行一次，相当于秒针向后移动一步*/
    void RunTimerTask() {
        _tick = (_tick + 1) % _capacity;
        // 将秒针对应位置的定时任务队列清空，即释放定时任务对象的shared_ptr
        _wheel[_tick].clear();
    }

    /*定时任务达到超时时间 -- 每秒钟超时一次*/
    void OnTime() {
        // 获取定时器超时次数
        uint64_t times = ReadTimerFd();
        // 执行定时任务
        for (uint64_t i = 0; i < times; i++) {
            RunTimerTask();
        }
    }

    /*在EventLoop对应的线程中添加定时任务*/
    void AddTimerInLoop(uint64_t id, uint32_t timeout, const TaskFunc &cb) {
        // 实例化定时任务对象并交由智能指针管理
        TaskPtr tp(new TimerTask(id, timeout, cb));
        // 为了不增加引用计数，这里不能使用shared_ptr
        _timers[id] = TaskWeak(tp);
        tp->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        // 将定时任务对象的shared_ptr添加到时间轮中
        int pos = (_tick + timeout) % _capacity;
        _wheel[pos].push_back(tp);
    }

    /*在EventLoop对应的线程中刷新/延迟定时任务*/
    void ReFlushTimerInLoop(uint64_t id) {
        // 通过定时任务的weak_ptr构造一个shared_ptr
        auto it = _timers.find(id);
        if(it == _timers.end()) return;
        TaskPtr tp = (it->second).lock();
        // 获取超时时间
        uint32_t timeout = tp->Timeout();
        // 将shared_ptr添加到时间轮中
        int pos = (_tick + timeout) % _capacity;
        _wheel[pos].push_back(tp);
    }

    /*在EventLoop对应的线程中取消定时任务*/
    void CancelTimerInLoop(uint64_t id) {
        // 通过定时任务的weak_ptr构造一个shared_ptr
        auto it = _timers.find(id);
        if(it == _timers.end()) return;
        TaskPtr tp = (it->second).lock();
        // 通过shared_ptr设置定时任务的取消状态
        if (tp) tp->Cancel();        
    }    
public:
    TimerWheel(EventLoop *loop)
    : _capacity(60), _tick(0), _wheel(_capacity), _timer_fd(CreateTimerFd()), _loop(loop), _timerfd_channel(new Channel(_loop, _timer_fd)) {
        // 设置定时器可读事件回调 -- 读取timerfd计数器，执行定时任务
        _timerfd_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
        // 启动定时器可读事件监控
        _timerfd_channel->EnableRead();
    }

    /*判断某个定时任务是否已经存在 -- 存在线程安全问题*/
    // 由于HasTimer的返回值是bool类型，所以无法像Timeradd等函数一样将其放入到EventLoop的任务队列中去执行
    // 所以存在线程安全问题，因此我们在调用此函数时需要保证是在EventLoop对应的线程中调用的
    bool HasTimer(uint64_t id) {
        auto it = _timers.find(id);
        if (it == _timers.end()) return false;
        return true;
    }

    /*为了保证添加/刷新/取消定时器任务的线程安全，我们需要在EventLoop对应的线程中去执行它们*/
    // 同时，这里也和Channel::Remove Channel::Update函数一样，我们使用了EventLoop中的成员函数
    // 所以，下面只给出声明，函数的具体实现需要放到EventLoop类下面
    /*添加定时任务*/
    void AddTimer(uint64_t id, uint32_t timeout, const TaskFunc &cb);

    /*刷新/延迟定时任务*/
    void ReFlushTimer(uint64_t id);
    /*取消定时任务*/
    void CancelTimer(uint64_t id);
private:
    int _capacity;                                  // 容量，代表最大超时时间
    int _tick;                                      // 当前的秒针，指向哪里就执行哪里的定时任务
    std::vector<std::vector<TaskPtr>> _wheel;       // 存放定时任务智能指针的时间轮
    std::unordered_map<uint64_t, TaskWeak> _timers; // 定时器任务id与指针之间的关联关系
    int _timer_fd;                                  // 超时事件描述符
    EventLoop *_loop;                               // 描述符事件监控与处理句柄
    std::unique_ptr<Channel> _timerfd_channel;      // 描述符监控事件管理句柄
};

/*TimerWheel::AddTimer、TimerWheel::ReFlushTimer和TimerWheel::CancelTimer函数的实现*/
/*添加定时任务*/
void TimerWheel::AddTimer(uint64_t id, uint32_t timeout, const TaskFunc &cb) { 
    return _loop->RunInLoop(std::bind(&TimerWheel::AddTimerInLoop, this, id, timeout, cb)); 
}

/*刷新/延迟定时任务*/
void TimerWheel::ReFlushTimer(uint64_t id) {
    return _loop->RunInLoop(std::bind(&TimerWheel::ReFlushTimerInLoop, this, id));
}

/*取消定时任务*/
void TimerWheel::CancelTimer(uint64_t id) {
    return _loop->RunInLoop(std::bind(&TimerWheel::CancelTimerInLoop, this, id));       
}

/*通信连接的状态*/
typedef enum {
    DISCONNECTED, // 连接已断开状态
    CONNECTING,   // 连接建立成功，但连接的各种状态待设置(Channel事件回调、处理上下文等)
    CONNECTED,    // 连接建立完成状态
    DISCONNECTING,// 连接半关闭状态 -- 接收或发送缓冲区中有数据待处理
} ConnStatu;

/*通信连接管理类*/
class Connection : public std::enable_shared_from_this<Connection> {
    // 通信连接的智能指针 -- 最开始的智能指针(引用计数为1)由服务器模块创建
    using ConnectionPtr = std::shared_ptr<Connection>;
    // 组件使用者设置给服务器模块，服务器模块获取新的通信连接后再设置给通信连接模块的回调函数类型
    using ConnectedFunc = std::function<void(const ConnectionPtr&)>;
    using MessageFunc = std::function<void(const ConnectionPtr&, Buffer *)>;
    using CloseFunc = std::function<void(const ConnectionPtr&)>;
    using EventFunc = std::function<void(const ConnectionPtr&)>;
private:
    /*Channel模块各种事件的回调函数*/
    /*设置描述符可读事件回调 -- 真正的数据接收接口*/
    void HandleRead() {
        // 接收socket中的数据
        char buf[65536];  // 64KB
        ssize_t n = _socket.Recv(&buf, sizeof(buf));
        // 接收数据出错不能直接释放连接，因为输出缓冲区可能还有数据待发送，而是通过ShutDownInLooop()将连接设置为待关闭状态
        if (n < 0) { return ShutDownInLoop(); }
        // 将数据写入到输入缓冲区
        _inbuffer.Write(buf, n);
        // 调用_Message_cb()进行业务处理
        // shared_from_this() -- 从当前对象自身获取自身的shared_ptr管理对象，使用时要求类继承enable_shared_from_this<class T>模板类
        if (_inbuffer.ReadAbleSize() > 0) 
            if (_message_cb) _message_cb(shared_from_this(), &_inbuffer);
    }

    /*设置描述符可写事件回调 -- 真正的数据发送接口*/
    void HandleWrite() {
        // 发送发送缓冲区中的数据
        ssize_t n = _socket.Send(_outbuffer.ReadStartAddr(), _outbuffer.ReadAbleSize());
        if (n < 0) {
            // 发送失败观察输入缓冲区中是否有数据待处理，有则处理
            // 没有则将释放连接操作压入到任务队列中，等待全部就绪事件业务处理完毕后再释放连接
            if (_inbuffer.ReadAbleSize() > 0) 
                if (_message_cb) _message_cb(shared_from_this(), &_inbuffer);
            ReleaseToQueue();
        }
        // 移动输出缓冲区的数据读取位置
        _outbuffer.MoveReadOffset(n);
        // 如果输出缓冲区中没有数据待发送了，则关闭写事件监控
        if (_outbuffer.ReadAbleSize() == 0) {
            _channel.DisableWrite();
            // 如果连接是待关闭状态且有数据待发送，此时数据已发送完毕，将释放连接操作压入任务队列
            if (_statu == DISCONNECTING) return ReleaseToQueue();
        }
    }

    /*设置描述符挂断事件事件回调*/
    void HandleClose() {
        // 描述符挂断，则套接字发送与接收数据都失效，此时只能处理一下inbuffer中可能存在的未处理数据
        if (_inbuffer.ReadAbleSize() > 0) 
            if (_message_cb) _message_cb(shared_from_this(), &_inbuffer);
        // 将释放连接操作压入到任务队列中，等待全部就绪事件业务处理完毕后再释放连接
        ReleaseToQueue();
    }

    /*设置描述符错误事件回调*/
    void HandleError() { return HandleClose(); }

    /*设置描述符任意事件回调*/
    void HandleEvent() {
        // 刷新连接活跃度(延迟定时任务销毁时间)
        if (_enable_inactive_release) _loop->ReFlushTimer(_conn_id);
        // 执行组件使用者->服务器模块设置的任意事件回调
        if (_event_cb) _event_cb(shared_from_this());
    }

    /*为保证线程安全，需要在EventLoop对应的线程中完成各种操作*/
    /*连接建立成功后，进行各种状态设置*/
    void EstablishedInLoop() {
        // 修改连接状态
        assert(_statu == CONNECTING);
        _statu = CONNECTED;
        // 启动读事件监控
        _channel.EnableRead();
        // 调用组件使用者->服务器模块设置的连接建立完成回调
        if (_connected_cb) _connected_cb(shared_from_this());
    } 

    /*实际的通信连接释放接口*/
    void ReleaseInLoop() {
        // 修改连接状态
        _statu = DISCONNECTED;
        // 移除描述符事件监控
        _channel.Remove();
        // 关闭描述符
        _socket.Close();
        // 如果有定时任务，则取消定时任务
        if (_loop->HasTimer(_conn_id)) DisableInactiveReleaseInLoop();
        // 调用组件使用者设置的以及服务器模块设置的连接关闭回调函数
        if (_close_cb) _close_cb(shared_from_this());
        if (_server_close_cb) _server_close_cb(shared_from_this());
    }

    /*发送数据 -- 不是真正的发生数据接口，只是将数据放到发送缓冲区，然后启动可写事件监控*/
    /*真正的数据发生是触发可写事件后在Channel可写事件回调HandleWrite中进行的*/
    void SendInLoop(const char data[], size_t len) {
        if (_statu == DISCONNECTED) return;
        // 将数据放到发送缓冲区中
        _outbuffer.Write(data, len);
        // 启动写事件监控
        if (_channel.Writeable() == false) _channel.EnableWrite();
    }

    /*将释放连接操作压入到任务队列中，等待全部就绪事件业务处理完毕后再释放连接，避免业务处理超时导致连接被释放*/
    void ReleaseToQueue() { return _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this)); }

    /*关闭通信连接 -- 不是真正的连接释放接口，只是修改连接状态为DISCONNECTING*/
    void ShutDownInLoop() {
        // 修改连接为半关闭状态
        _statu = DISCONNECTING;
        // 判断是输入缓冲区中是否有数据待处理
        if (_inbuffer.ReadAbleSize() > 0) 
            if (_message_cb) _message_cb(shared_from_this(), &_inbuffer);
        // 判断输出缓冲区中是否有数据待发送
        if (_outbuffer.ReadAbleSize() > 0) 
            if (_channel.Writeable() == false) _channel.EnableWrite();
        // 如果输出缓冲区中无数据，则将释放连接操作压入到任务队列中，等待全部就绪事件的业务处理完毕后再释放连接
        if (_outbuffer.ReadAbleSize() == 0) ReleaseToQueue();
    }

    /*启动非活跃连接定时销毁*/
    void EnableInactiveReleaseInLoop(uint32_t sec) {
        _enable_inactive_release = true;
        // 定时任务存在则刷新，不存在则添加
        if (_loop->HasTimer(_conn_id)) _loop->ReFlushTimer(_conn_id);
        _loop->AddTimer(_conn_id, sec, std::bind(&Connection::ReleaseToQueue, this));
    }

    /*取消非活跃连接定时销毁*/
    void DisableInactiveReleaseInLoop() {
        _enable_inactive_release = false;
        // 定时任务存在则取消
        if (_loop->HasTimer(_conn_id)) _loop->CancelTimer(_conn_id);
    }

    /*切换协议 -- 重置上下文以及组件使用者的阶段性处理函数*/
    void UpgradeInLoop(const Any &context, const ConnectedFunc &conn_cb, const MessageFunc &msg_cb, 
                const CloseFunc &close_cb, const EventFunc &event_cb) {
        _context = context;
        _connected_cb = conn_cb;
        _message_cb = msg_cb;
        _close_cb = close_cb;
        _event_cb = event_cb;
    }    
public: 
    Connection(EventLoop *loop, uint64_t conn_id, int sockfd)
    : _conn_id(conn_id), _sockfd(sockfd), _socket(_sockfd), _enable_inactive_release(false),
      _statu(CONNECTING), _loop(loop), _channel(_loop, _sockfd) {
        // Channel模块各种回调函数的设置
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
    }

    /*获取通信连接id*/
    uint64_t Id() { return _conn_id; }

    /*获取连接描述符*/
    int Fd() { return _sockfd; }

    /*判断通信连接是否已经建立完成，可以直接通信*/
    bool IsConnected() { return _statu == CONNECTED; }

    /*设置处理上下文*/
    void SetContext(const Any &context) { _context = context; }

    /*获取处理上下文*/
    Any *GetContext() { return &_context; }

    /*组件使用者设置给服务器模块，服务器模块获取新的通信连接后再设置给通信连接模块的回调函数*/
    void SetConnectedCallback(const ConnectedFunc &connected_cb) { _connected_cb = connected_cb; }
    void SetMessageCallback(const MessageFunc &mssgage_cb) { _message_cb = mssgage_cb; }
    void SetCloseCallback(const CloseFunc &close_cb) { _close_cb = close_cb; }
    void SetEventCallback(const EventFunc &event_cb) { _event_cb = event_cb; }

    /*服务器模块设置的连接关闭回调函数*/
    void SetServerCloseCallback(const CloseFunc &server_close_cb) { _server_close_cb = server_close_cb; }

    /*连接建立成功后进行各种状态设置 -- 启动可读事件监控、_connected_cb()回调等*/
    void Established() { _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this)); }     

    /*发送数据*/
    void Send(const char data[], size_t len) { _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, data, len)); }
    
    /*关闭通信连接*/
    void ShutDown() { _loop->RunInLoop(std::bind(&Connection::ShutDownInLoop, this)); }

    /*启动非活跃连接定时销毁*/
    void EnableInactiveRelease(uint32_t sec) { _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec)); }

    /*取消非活跃连接定时销毁*/
    void DisableInactiveRelease() { _loop->RunInLoop(std::bind(&Connection::DisableInactiveReleaseInLoop, this)); }

    /*切换协议 -- 更新上下文以及阶段性处理函数*/
    void Upgrade(const Any &context, const ConnectedFunc &conn_cb, const MessageFunc &msg_cb, 
                const CloseFunc &close_cb, const EventFunc &event_cb) 
    {
        // 注意：Upgrage接口必须在EventLoop对应的线程中立即被执行，即当前线程必须就是EventLoop对应的线程，
        // 这样在RunInLoop函数中UpgradeInLoop函数才是直接被执行，而不是加入到任务队列中
        // 否则会导致当UpgradeInLoop函数未被执行，但有新的事件触发时，这个新事件按照原来的协议进行处理
        _loop->AssertInLoop();
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn_cb, msg_cb, close_cb, event_cb));           
    }
private:
    uint64_t _conn_id;               // 唯一通信ID，同时也作为定时器ID使用
    int _sockfd;                     // 连接描述符
    Socket _socket;                  // 套接字模块
    bool _enable_inactive_release;   // 是否启动非活跃连接销毁标志
    ConnStatu _statu;                // 通信连接的状态
    EventLoop *_loop;                // 连接关联的EventLoop
    Channel _channel;                // 描述符监控事件管理模块
    Buffer _inbuffer;                // 用户输入缓冲区
    Buffer _outbuffer;               // 用户输出缓冲区
    Any _context;                    // 请求接收处理上下文
    /*下面的四个回调函数是由组件使用者设置给服务器模块，服务器模块获取新的通信连接后再设置给通信连接模块的*/
    ConnectedFunc _connected_cb;     // 通信连接建立成功的回调
    MessageFunc _message_cb;         // 接收到消息的回调
    CloseFunc _close_cb;             // 通信连接关闭的回调
    EventFunc _event_cb;             // 任意事件的回调
    /*最后的这个回调函数是服务器模块的连接关闭回调，因为通信连接智能指针最开始会在服务器模块中创建*/
    /*因此连接关闭时服务器模块的智能指针对象也需要释放，否则引用计数永远不可能为0，通信连接也就不可能真正被释放*/
    CloseFunc _server_close_cb;      // 服务器模块的连接关闭回调
};

/*监听套接字事件监控与处理类*/
class Acceptor {
    using AcceptCallback = std::function<void(int)>;
private:
    /*创建一个服务器连接并返回监听套接字*/
    int CreateServer(uint16_t port, const std::string &ip, bool non_block) {
        bool ret = _socket.CreateServer(port, ip, non_block);
        if (ret == false) {
            // 监听套接字创建失败，直接终止程序
            LOG(FATAL, "CreateServer failed");
            abort();
        }
        return _socket.Fd();
    }

    /*监听套接字的可读事件回调*/
    void HandleRead() { 
        // 获取新连接
        int newfd = _socket.Accept(); 
        // 对新连接进行处理 -- 创建Connection对象等
        if (newfd < 0) return;
        if (_accept_cb) _accept_cb(newfd);
    }
public:
    Acceptor(EventLoop *loop, uint16_t port, const std::string &ip = "0.0.0.0", bool non_block = true)
    : _socket(CreateServer(port, ip, non_block)), _loop(loop), _channel(loop, _socket.Fd()) {
        // 设置监听套接字可读事件回调
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
        // 注意，启动读事件监控不能放在构造函数中，因为此时通信连接回调函数还未设置，可能会出现获取了新连接但得不到处理的情况
    }

    /*设置通信连接处理回调函数 -- 为获取到的新连接创建Connetion对象*/
    void SetAcceptCallback(const AcceptCallback &accept_cb) { _accept_cb = accept_cb; }

    /*启动读事件监控*/
    void EnableRead() { _channel.EnableRead(); }
private:
    Socket _socket;             // 套接字模块
    EventLoop *_loop;           // 描述符事件监控与处理模块
    Channel _channel;           // 描述符监控事件管理模块
    AcceptCallback _accept_cb;  // 对新的通信连接进行处理的回调函数
};

/*为每个通信连接创建从线程，在从线程中实例化连接对应的EventLoop对象，完成描述符事件监控与处理*/
class LoopThread {
    /*线程入口函数*/
    void ThreadEntry() {
        // 创建EventLoop对象 -- 这里创建局部对象即可，不必new，因为_loop.start是死循环运行的
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _loop = &loop;
            // 唤醒可能正在阻塞的GetLoop操作
            _cond.notify_all();
        }
        // 运行EventLoop模块 -- 获取并处理活跃连接，执行任务
        _loop->Start();
    }
public:
    LoopThread() : _loop(nullptr), _thread(std::thread(&LoopThread::ThreadEntry, this)) {}

    /*获取EventLoop对象指针*/
    EventLoop *GetLoop() {
        EventLoop *loop;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            // 如果_loop为空说明EventLoop对象还未实例化，则阻塞等待条件成立，即_loop不为空
            _cond.wait(lock, [&](){ return _loop != nullptr; });
            loop = _loop;
        }
        return loop;
    }
private:
    // 互斥锁和条件变量用于实现获取_loop指针的同步关系，避免线程创建了但EventLoop还未实例化时获取_loop指针
    std::mutex _mutex;              // 互斥锁
    std::condition_variable _cond;  // 条件变量
    EventLoop *_loop;               // EventLoop指针变量，需要在线程内部进行实例化
    std::thread _thread;            // EventLoop对应的线程
};

/*LoopThread线程池，用于管理及分配所有的LoopThread*/
class LoopThreadPool {
public:
    LoopThreadPool(EventLoop *main_loop) : _thread_count(0), _loop_idx(0), _main_loop(main_loop) {}
    
    /*设置从线程数量*/
    void SetThreadCount(uint32_t count) { 
        _thread_count = count; 
        _threads.resize(_thread_count);
        _loops.resize(_thread_count);
    }

    /*创建所有的从属LoopThread线程*/
    void CreateThreads() {
        if (_thread_count == 0) return;
        for (size_t i = 0; i < _thread_count; i++) {
            _threads[i] = new LoopThread();
            _loops[i] = _threads[i]->GetLoop();
        }
    }

    /*为通信连接分配EventLoop*/
    EventLoop *GetLoop() {
        // 如果_thread_count为0，即单Reactor模型，则全部连接的全部事件都在主EventLoop中完成
        if (_thread_count == 0) return _main_loop;
        // 如果是主从Reactor模型，则为每个连接分配一个EventLoop，连接的所有事件都在对应的EventLoop中完成
        EventLoop *loop = _loops[_loop_idx];
        _loop_idx = (_loop_idx + 1) % _thread_count;
        return  loop;
    }
private:
    uint32_t _thread_count;             // 从线程数量
    int _loop_idx;                      // 当前未分配的EventLoop的下标
    EventLoop *_main_loop;              // 主EventLoop(主Reactor主线程)，当从线程数量为0时连接的所有操作都在主线程中执行
    std::vector<LoopThread*> _threads;  // 保存所有的从LoopThread
    std::vector<EventLoop*> _loops;     // 保存所有的EventLoop，当从线程数量大于0时从_threads中为EventLoop分配线程
};

/*整合封装服务器模块*/
class TcpServer {
    // 通信连接的智能指针 -- 最开始的智能指针(引用计数为1)
    using ConnectionPtr = std::shared_ptr<Connection>;
    // 组件使用者设置给服务器模块的各种事件回调
    using ConnectedFunc = std::function<void(const ConnectionPtr&)>;
    using MessageFunc = std::function<void(const ConnectionPtr&, Buffer *)>;
    using CloseFunc = std::function<void(const ConnectionPtr&)>;
    using EventFunc = std::function<void(const ConnectionPtr&)>;
    // 任务类型
    using TaskFunc = std::function<void()>;
private:
    /*在EventLoop对应的线程中添加定时任务*/
    void AddTimerInLoop(const TaskFunc &cb, uint32_t timeout) {
        _main_loop.AddTimer(_conn_id, timeout, cb);
        ++_conn_id;
    }

    /*为获取到的新连接创建Connection对象并管理其shared_ptr*/
    void CreateConnection(int fd) {
        ConnectionPtr conn(new Connection(_pool.GetLoop(), _conn_id, fd));
        // 为通信连接设置各种用户层的事件回调
        conn->SetConnectedCallback(_connected_cb);
        conn->SetMessageCallback(_message_cb);
        conn->SetCloseCallback(_close_cb);
        conn->SetEventCallback(_event_cb);
        // 设置服务器模块的连接关闭回调 -- 释放Connection对象
        conn->SetServerCloseCallback(std::bind(&TcpServer::RemoveConncetion, this, std::placeholders::_1));
        // 启动连接非活跃超时销毁
        if (_enable_inactive_release) conn->EnableInactiveRelease(_timeout);
        // 完成连接建立成功后的各种初识化工作
        conn->Established();
        // 管理通信连接
        _conns[_conn_id] = conn;
        ++_conn_id;       
    }

    /*在EventLoop对应的线程中移除_conns中保存的Connection对象的shared_ptr*/
    void RemoveConncetionInLoop(const ConnectionPtr &conn) {
        uint64_t conn_id = conn->Id();
        auto it = _conns.find(conn_id);
        if (it != _conns.end()) _conns.erase(it);
    }

    /*通信连接关闭时移除_conns中保存的最后一份Connection对象的shared_ptr，从而释放掉连接对应的Connection对象*/
    void RemoveConncetion(const ConnectionPtr &conn) {
        return _main_loop.RunInLoop(std::bind(&TcpServer::RemoveConncetionInLoop, this, conn)); 
    }
public:
    TcpServer(uint16_t port, const std::string &ip = "0.0.0.0", bool non_block = true)
    : _conn_id(0), _port(port), _enable_inactive_release(false), 
      _acceptor(&_main_loop, port, ip, non_block), _pool(&_main_loop) {
        // 设置通信连接回调函数 -- 为通信连接创建Connection对象
        _acceptor.SetAcceptCallback(std::bind(&TcpServer::CreateConnection, this, std::placeholders::_1));
    }
    
    /*设置从属线程池线程数量*/
    void SetThreadCount(uint32_t count) { _pool.SetThreadCount(count); }

    /*启动非活跃连接定时销毁任务*/
    void EnableInactiveRelease(uint32_t timeout) {
        _timeout = timeout;
        _enable_inactive_release = true;
    }

    /*取消非活跃连接定时销毁*/
    void DisableInactiveRelease() { _enable_inactive_release = false; }    

    /*添加定时任务*/
    void AddTimer(const TaskFunc &cb, uint32_t timeout) { 
        return _main_loop.RunInLoop(std::bind(&TcpServer::AddTimerInLoop, this, cb, timeout)); 
    }

    /*启动服务器*/
    void Start() { 
        // 创建从属EventLoop线程池
        _pool.CreateThreads();
        // 启动监听套接字的读事件监控(并不是开始监听，只是添加EPOLLIN事件)
        _acceptor.EnableRead();  
        // 开始监听并获取活跃连接、处理活跃连接的就绪事件以及执行任务      
        _main_loop.Start(); 
    }

    /*组件使用者设置给服务器模块的各种事件回调*/
    void SetConnectedCallback(const ConnectedFunc &connected_cb) { _connected_cb = connected_cb; }
    void SetMessageCallback(const MessageFunc &mssgage_cb) { _message_cb = mssgage_cb; }
    void SetCloseCallback(const CloseFunc &close_cb) { _close_cb = close_cb; }
    void SetEventCallback(const EventFunc &event_cb) { _event_cb = event_cb; }
private:
    uint64_t _conn_id;               // 自增通信连接ID
    uint16_t _port;                  // 监听端口
    uint32_t _timeout;               // 定时任务的超时时间
    bool _enable_inactive_release;   // 是否启动非活跃连接定时销毁任务的标志
    EventLoop _main_loop;            // 主EventLoop -- 主Reactor主线程，实现对监听套接字的事件监控
    Acceptor _acceptor;              // 监听套接字管理模块
    LoopThreadPool _pool;            // 从属EventLoop线程池 -- 从Reactor从线程，实现对通信连接的事件监控
    std::unordered_map<uint64_t, ConnectionPtr> _conns;  // 保存管理通信连接对象的shared_ptr指针
    /*组件使用者设置给服务器模块的各种事件回调*/
    ConnectedFunc _connected_cb;     // 通信连接建立成功的回调
    MessageFunc _message_cb;         // 接收到消息的回调
    CloseFunc _close_cb;             // 通信连接关闭的回调
    EventFunc _event_cb;             // 任意事件的回调    
};

/*日志等级*/    
enum  {
    NORMAL, 
    DEBUG, 
    ERROR,
    FATAL
};

/*将日志等级转化为字符串*/
const char* level_to_stirng(int level) {
    switch (level)
    {
    case NORMAL:
        return "NORMAL";
    case DEBUG:
        return "DEBUG";
    case ERROR:
        return "ERROR";
    case FATAL:
        return "FATAL";
    default:
        return nullptr;
    }
}

/*日志宏函数*/
#define LOG(level, format, ...) do {\
    const char* levelstr = level_to_stirng(level); /*日志等级*/\
    time_t ts = time(NULL);  /*时间戳*/\
    struct tm *lt = localtime(&ts);  /*格式化时间*/\
    char timebuf[32] = { 0 };\
    strftime(timebuf, sizeof(timebuf) - 1, "%y-%m-%d %H:%M:%S", lt);  /*格式化时间到字符串*/\
    fprintf(stdout, "[%s][%p][%s][%s:%d] " format "\n", levelstr, (void*)pthread_self(), timebuf, __FILE__, __LINE__, ##__VA_ARGS__); /*##解除必须传递可变参数的限制*/\
} while(0)

#ifndef __ECHOSERVER_HPP__
#define __ECHOSERVER_HPP__

#include "../server.hpp"
/*使用TcpServer服务器组件搭建一个回显服务器demo*/
class EchoServer {
    using ConnectionPtr = std::shared_ptr<Connection>;
private:
    void OnConnected(const ConnectionPtr &conn) {
        LOG(DEBUG, "Connection Created Success: %p", conn.get());    
    }

    void OnClose(const ConnectionPtr &conn) {
        LOG(DEBUG, "Connection Released Success: %p", conn.get());
    }

    void OnMessage(const ConnectionPtr &conn,  Buffer *buf) {
        // 读取输入缓冲区中的数据
        size_t size = buf->ReadableSzie();
        char data[size];
        buf->Read(data, size);  
        // 业务处理，构建响应 -- 这里简单的回显即可
        // 回复响应 -- 将响应写入到输出缓冲区
        conn->Send(data, size);
    }
public:
    EchoServer(uint16_t port) : _port(port), _server(_port) {
        _server.SetThreadCount(2);
        _server.EnableInactiveRelease(10);
        _server.SetConnectedCallback(std::bind(&EchoServer::OnConnected, this, std::placeholders::_1));
        _server.SetCloseCallback(std::bind(&EchoServer::OnClose, this, std::placeholders::_1));
        _server.SetMessageCallback(std::bind(&EchoServer::OnMessage, this, std::placeholders::_1, std::placeholders::_2));
    }
    void Start() { _server.Start(); }
private:
    uint16_t _port;
    TcpServer _server;
};
#endif

#include "../source/server.hpp"

int main()
{
    // 创建客户端连接
    Socket clientSock;
    clientSock.CreateClient(8082, "127.0.0.1");
    for (int i = 0; i < 5; i++) {
        // 向服务器发送数据
        std::string msg = "hello server";
        clientSock.Send(msg.c_str(), msg.size());
        // 接收服务器响应
        char buffer[1024];
        ssize_t n = clientSock.Recv(buffer, sizeof(buffer) - 1);
        buffer[n] = 0;
        LOG(DEBUG, "[echo]# %s", buffer);
        sleep(1);
    }
    while(1) sleep(1);
    clientSock.Close();
    return 0;
}

#include "echoServer.hpp"

int main()
{
    EchoServer server(8082);
    server.Start();
}

/*HTTP响应状态码对应的描述信息*/
std::unordered_map<int, std::string> g_statuMsg = {
    {100,  "Continue"},
    {101,  "Switching Protocol"},
    {102,  "Processing"},
    {103,  "Early Hints"},
    {200,  "OK"},
    {201,  "Created"},
    {202,  "Accepted"},
    {203,  "Non-Authoritative Information"},
    {204,  "No Content"},
    {205,  "Reset Content"},
    {206,  "Partial Content"},
    {207,  "Multi-Status"},
    {208,  "Already Reported"},
    {226,  "IM Used"},
    {300,  "Multiple Choice"},
    {301,  "Moved Permanently"},
    {302,  "Found"},
    {303,  "See Other"},
    {304,  "Not Modified"},
    {305,  "Use Proxy"},
    {306,  "unused"},
    {307,  "Temporary Redirect"},
    {308,  "Permanent Redirect"},
    {400,  "Bad Request"},
    {401,  "Unauthorized"},
    {402,  "Payment Required"},
    {403,  "Forbidden"},
    {404,  "Not Found"},
    {405,  "Method Not Allowed"},
    {406,  "Not Acceptable"},
    {407,  "Proxy Authentication Required"},
    {408,  "Request Timeout"},
    {409,  "Conflict"},
    {410,  "Gone"},
    {411,  "Length Required"},
    {412,  "Precondition Failed"},
    {413,  "Payload Too Large"},
    {414,  "URI Too Long"},
    {415,  "Unsupported Media Type"},
    {416,  "Range Not Satisfiable"},
    {417,  "Expectation Failed"},
    {418,  "I'm a teapot"},
    {421,  "Misdirected Request"},
    {422,  "Unprocessable Entity"},
    {423,  "Locked"},
    {424,  "Failed Dependency"},
    {425,  "Too Early"},
    {426,  "Upgrade Required"},
    {428,  "Precondition Required"},
    {429,  "Too Many Requests"},
    {431,  "Request Header Fields Too Large"},
    {451,  "Unavailable For Legal Reasons"},
    {501,  "Not Implemented"},
    {502,  "Bad Gateway"},
    {503,  "Service Unavailable"},
    {504,  "Gateway Timeout"},
    {505,  "HTTP Version Not Supported"},
    {506,  "Variant Also Negotiates"},
    {507,  "Insufficient Storage"},
    {508,  "Loop Detected"},
    {510,  "Not Extended"},
    {511,  "Network Authentication Required"}            
};

/*文件拓展名对应的MIME名称*/
std::unordered_map<std::string, std::string> g_extMime = {
    {".aac",        "audio/aac"},
    {".abw",        "application/x-abiword"},
    {".arc",        "application/x-freearc"},
    {".avi",        "video/x-msvideo"},
    {".azw",        "application/vnd.amazon.ebook"},
    {".bin",        "application/octet-stream"},
    {".bmp",        "image/bmp"},
    {".bz",         "application/x-bzip"},
    {".bz2",        "application/x-bzip2"},
    {".csh",        "application/x-csh"},
    {".css",        "text/css"},
    {".csv",        "text/csv"},
    {".doc",        "application/msword"},
    {".docx",       "application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
    {".eot",        "application/vnd.ms-fontobject"},
    {".epub",       "application/epub+zip"},
    {".gif",        "image/gif"},
    {".htm",        "text/html"},
    {".html",       "text/html"},
    {".ico",        "image/vnd.microsoft.icon"},
    {".ics",        "text/calendar"},
    {".jar",        "application/java-archive"},
    {".jpeg",       "image/jpeg"},
    {".jpg",        "image/jpeg"},
    {".js",         "text/javascript"},
    {".json",       "application/json"},
    {".jsonld",     "application/ld+json"},
    {".mid",        "audio/midi"},
    {".midi",       "audio/x-midi"},
    {".mjs",        "text/javascript"},
    {".mp3",        "audio/mpeg"},
    {".mpeg",       "video/mpeg"},
    {".mpkg",       "application/vnd.apple.installer+xml"},
    {".odp",        "application/vnd.oasis.opendocument.presentation"},
    {".ods",        "application/vnd.oasis.opendocument.spreadsheet"},
    {".odt",        "application/vnd.oasis.opendocument.text"},
    {".oga",        "audio/ogg"},
    {".ogv",        "video/ogg"},
    {".ogx",        "application/ogg"},
    {".otf",        "font/otf"},
    {".png",        "image/png"},
    {".pdf",        "application/pdf"},
    {".ppt",        "application/vnd.ms-powerpoint"},
    {".pptx",       "application/vnd.openxmlformats-officedocument.presentationml.presentation"},
    {".rar",        "application/x-rar-compressed"},
    {".rtf",        "application/rtf"},
    {".sh",         "application/x-sh"},
    {".svg",        "image/svg+xml"},
    {".swf",        "application/x-shockwave-flash"},
    {".tar",        "application/x-tar"},
    {".tif",        "image/tiff"},
    {".tiff",       "image/tiff"},
    {".ttf",        "font/ttf"},
    {".txt",        "text/plain"},
    {".vsd",        "application/vnd.visio"},
    {".wav",        "audio/wav"},
    {".weba",       "audio/webm"},
    {".webm",       "video/webm"},
    {".webp",       "image/webp"},
    {".woff",       "font/woff"},
    {".woff2",      "font/woff2"},
    {".xhtml",      "application/xhtml+xml"},
    {".xls",        "application/vnd.ms-excel"},
    {".xlsx",       "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
    {".xml",        "application/xml"},
    {".xul",        "application/vnd.mozilla.xul+xml"},
    {".zip",        "application/zip"},
    {".3gp",        "video/3gpp"},
    {".3g2",        "video/3gpp2"},
    {".7z",         "application/x-7z-compressed"}            
};

/*实用工具类*/
class Util {
public:
    /*读取文件内容*/
    static bool ReadFile(const std::string &filename, std::string *data) {
        // 以二进制形式打开文件
        std::ifstream ifs(filename.c_str(), std::ios::binary);
        if(ifs.is_open() == false) {
            LOG(ERROR, "Open %s file failed", filename.c_str());
            return false;
        }
        // 获取文件大小
        size_t size;
        ifs.seekg(0, std::ios::end);  // 跳转读写位置到文件末尾
        size = ifs.tellg();           // 获取当前读写位置相较于文件起始位置的偏移量，即文件大小
        ifs.seekg(0, std::ios::beg);  // 跳转回读写位置到文件起始位置
        // 读取文件内容
        data->resize(size);
        ifs.read(&(*data)[0], size);
        // 判断是否读取成功
        if(ifs.good() == false) {
            LOG(ERROR, "Read %s file content failed", filename.c_str());
            ifs.close();
            return false;
        }
        // 关闭文件
        ifs.close();
        return true;
    }
    
    /*向文件中写入数据*/
    static bool WriteFile(const std::string &filename, const std::string &data) {
        // 以二进制形式打开文件，并清空原文件内容
        std::ofstream ofs(filename.c_str(), std::ios::binary | std::ios::trunc);
        if(ofs.is_open() == false) {
            LOG(ERROR, "Open %s file failed", filename.c_str());
            return false;
        }
        // 向文件中写入数据
        ofs.write(data.c_str(), data.size());
        // 判断是否写入成功
        if(ofs.good() == false) {
            LOG(ERROR, "Read %s file content failed", filename.c_str());
            ofs.close();
            return false;
        }
        // 关闭文件
        ofs.close();
        return true;        
    }

    /*URL编码 -- 避免资源请求路径或者查询字符串中的特殊字符与HTTP请求中的的特殊字符产生歧义*/
    // RFC3986文档规定的编码格式：特殊字符转化为两个十六进制字符，并带上前缀%. 比如 C++ -> C%2B%2B
    // RFC3986文档规定以下字符为绝对不编码字符，即除了它们以外的字符都需要编码：. - _ ~ 数字 字母
    // 同时W3C标准规定：查询字符中的空格需要被编码为 + ,而不是两个十六进制字符和前缀%
    static std::string UrlEncode(const std::string &url, bool convert_space_to_plus) {
        std::string str;
        for(auto ch : url) {
            // 绝对不编码字符
            if (ch == '.' || ch == '-' || ch == '_' || ch == '~' || isalnum(ch)) {
                str += ch;
                continue;
            }
            // 空格且空格编码标志为真
            if (ch == ' ' && convert_space_to_plus) {
                str += '+';
                continue;
            }
            // 编码字符，或者特殊编码字符空格但空格编码标志为假 ch -> %HH
            char tmp[4] = { 0 };
            // %% -> %    %02X -> %X 十六进制大写 0 填充0 2 占位两个字符  ==> %HH
            snprintf(tmp, 4, "%%%02X", ch);
            str += tmp;
        }
        return str;
    }

    /*UrlDecode子函数 -- 将一个十六进制字符转换为一个十进制字符*/
    static int HexToDec(char ch) {
        if (ch >= '0' && ch <= '9') return ch - '0';
        if (ch >= 'a' && ch <= 'z') return ch - 'a' + 10;
        if (ch >= 'A' && ch <= 'Z') return ch - 'A' + 10;
        return -1;
    }

    /*URL解码*/
    static std::string UrlDecode(const std::string &url, bool convert_plus_to_space) {
        // 遇到 % 就将其后面的两个十六进制字符转换为一个十进制字符即可
        // 如果设置了空格字符的特殊编码，则将 + 替换为空格
        std::string str;
        for(int i = 0; i < url.size(); i++) {
            if (url[i] == '%' && (i + 2) < url.size()) {
                int ch1 = HexToDec(url[i + 1]);
                int ch2 = HexToDec(url[i + 2]); 
                char ch = ch1 * 16 + ch2;
                str += ch;
                i += 2;
                continue;
            }
            if (url[i] == '+' && convert_plus_to_space) {
                str += ' ';
                continue;
            }
            str += url[i];
        }
        return str;
    }

    /*获取响应状态码的描述信息*/
    static std::string StatuDesc(int statu) {
        auto it = g_statuMsg.find(statu);
        if (it == g_statuMsg.end()) return "Unknown";
        return it->second;
    }

    /*根据文件扩展名获取文件mime*/
    static std::string ExtMime(const std::string &filename) {
        // 获取文件扩展名
        size_t pos = filename.rfind(".");
        // 如果文件没有后缀，则返回二进制流，表示二进制文件
        if (pos == std::string::npos) return "application/actet-stream";
        std::string suffix = filename.substr(pos);
        auto it = g_extMime.find(suffix);
        if (it == g_extMime.end()) return "application/actet-stream";
        return it->second;
    }

    /*判断一个文件是否是目录*/
    static bool IsDirectory(const std::string &filename) {
        struct stat st;
        int n = stat(filename.c_str(), &st);
        if (n < 0) return false;
        // S_ISDIR宏函数：S_ISDIR(m)	(((m) & S_IFMT) == S_IFDIR)
        return S_ISDIR(st.st_mode);
    }

    /*判断一个文件是否是普通文件*/
    static bool IsRegularFile(const std::string &filename) {
        struct stat st;
        int n = stat(filename.c_str(), &st);
        if (n < 0) return false;
        // S_ISREG宏函数：S_ISREG(m)	(((m) & S_IFMT) == S_IFREG)
        return S_ISREG(st.st_mode);        
    }

    /*字符串分割*/
    static size_t Split(const std::string &src, const std::string &sep, std::vector<std::string> *arr) {
        arr->clear();
        int offset = 0;
        // ;abc;;def;efg;
        while(offset < src.size()) {
            size_t pos = src.find(sep, offset);
            if (pos == std::string::npos) {
                arr->push_back(src.substr(offset));
                return arr->size();
            }
            // 当子串为空时跳过
            if (pos == offset) {
                offset = pos + sep.size();
                continue;
            }
            arr->push_back(src.substr(offset, pos - offset));
            offset = pos + sep.size();
        }
        return arr->size();
    }

    /*判断HTTP请求资源路径是否有效*/
    static bool IsValidPath(const std::string &path) {
        // 资源路径的有效性是指客户端只能访问web根目录下的文件，不能通过..回退访问根目录的上级目录
        // 以/为分隔符将路径分隔开来
        std::vector<std::string> arr;
        Util::Split(path, "/", &arr);
        int level = 0;
        for(const auto& s : arr) {
            // 遇到..回退上级目录操作目录深度减一
            if (s == "..") {
                --level;
                // 在任意位置如果目录深度小于0，说明访问到了web根目录的上级目录，直接返回false
                if (level < 0) return false;
                continue;
            }
            // 遇到正常路径则目录深度加一
            ++level;
        }
        return true;
    }
};

/*存储HTTP请求的相关要素信息*/
class HttpRequest {
public:
    HttpRequest() : _version("HTTP/1.1") {}

    /*添加头部字段*/
    void SetHeader(const std::string &key, const std::string &value) { _headers[key] = value; }

    /*查询是否存在指定头部字段*/
    bool HasHeader(const std::string &key) const {
        auto it = _headers.find(key);
        if (it == _headers.end()) return false;
        return true;
    }

    /*获取指定头部字段的值*/
    std::string GetHearder(const std::string &key) const {
        auto it = _headers.find(key);
        if (it == _headers.end()) return "";
        return it->second;
    }

    /*插入查询字符串*/
    void SetParam(const std::string &key, const std::string &value) { _params[key] = value; }

    /*查询是否存在指定查询字符串*/
    bool HasParam(const std::string &key)  const {
        auto it = _params.find(key);
        if (it == _params.end()) return false;
        return true;
    }

    /*获取指定查询字符串的值*/
    std::string GetParam(const std::string &key) const {
        auto it = _params.find(key);
        if (it == _params.end()) return "";
        return it->second;
    }

    /*获取正文长度*/
    size_t ContentLength() const {
        if (HasHeader("Content-Length") == false) return 0;
        return std::stoi(GetHearder("Content-Length"));
    }

    /*判断是否是短连接通信*/
    bool IsClose() const {
        // Connection字段存在并且为keep-alive则是长连接通信
        if ((HasHeader("Connection") == true) && (GetHearder("Connection") == "keep-alive")) return false;
        return true;
    }

    /*重置请求内容*/
    void Reset() {
        _method.clear();
        _path.clear();
        _version = "HTTP/1.1";
        _body.clear();
        _params.clear();
        _headers.clear();
        std::smatch match;
        _matches.swap(match);
    }
public:
    // 由于外部需要直接对成员变量进行设置和读取，所以这里使用public修饰
    std::string _method;    // 请求方法
    std::string _path;      // 资源路径
    std::string _version;   // 协议版本
    std::string _body;      // 请求正文
    std::smatch _matches;   // 保存资源路径正则匹配的结果
    std::unordered_map<std::string, std::string> _params;  // 查询字符串
    std::unordered_map<std::string, std::string> _headers; // 请求头部字段
};

/*保存HTTP响应的相关要素信息*/
class HttpResponse {
public:
    HttpResponse() : _statu(200), _redirect_flag(false) {}
    HttpResponse(int statu) : _statu(statu), _redirect_flag(false) {}

    /*添加头部字段*/
    void SetHeader(const std::string &key, const std::string &value) { _headers[key] = value; }

    /*查询是否存在指定头部字段*/
    bool HasHeader(const std::string &key) const {
        auto it = _headers.find(key);
        if (it == _headers.end()) return false;
        return true;
    }

    /*获取指定头部字段的值*/
    std::string GetHearder(const std::string &key) const {
        auto it = _headers.find(key);
        if (it == _headers.end()) return "";
        return it->second;
    } 

    /*设置响应正文及其相关的头部字段*/
    void SetContent(const std::string &body, const std::string &type) {
        _body = body;
        SetHeader("Content-Type", type);
        SetHeader("Content-Length", std::to_string(body.size()));
    }

    /*设置重定向以及Location头部字段*/
    void SetRedirect(const std::string &url, int statu = 302) {
        _statu = statu;
        _redirect_flag = true;
        _redirect_url = url;
        SetHeader("Location", _redirect_url);
    }  

    /*判断是否是短连接通信*/
    bool IsClose() const {
        // Connection字段存在并且为keep-alive则是长连接通信
        if ((HasHeader("Connection") == true) && (GetHearder("Connection") == "keep-alive")) return false;
        return true;
    }

    /*重置响应内容*/
    void Reset() {
        _statu = 200;
        _body.clear();
        _redirect_flag = false;
        _redirect_url.clear();
        _headers.clear();
    }    
public:
    // 为了便于外界访问，这里我们同样将成员变量设置为公有
    int _statu;                 // 响应状态码
    std::string _body;          // 响应正文
    bool _redirect_flag;        // 重定向标志
    std::string _redirect_url;  // 重定向路径
    std::unordered_map<std::string, std::string> _headers;  // 响应头部字段
};

/*HTTP请求行的最大长度 -- 8KB*/
#define MAX_LINE 8192

/*HTTP请求接收不同阶段的状态*/
typedef enum {
    RECV_HTTP_ERROR, // 接收HTTP请求出错
    RECV_HTTP_LINE,  // 接收HTTP请求行
    RECV_HTTP_HEAD,  // 接收HTTP请求头部
    RECV_HTTP_BODY,  // 接收HTTP请求正文
    RECV_HTTP_OVER,  // HTTP请求接收完毕
} HttpRecvStatu;

/*HTTP请求接收与解析上下文模块 -- 记录HTTP请求接收与解析的进度*/
class HttpContext {
private:
    /*解析HTTP请求行*/
    bool ParseHttpLine(const std::string &line) {
        // 原始请求行：GET /login?user=zhangsan&pass=12 3456 HTTP/1.1\r\n
        // 编码后的请求行：GET %2Flogin?user%3Dzhangsan%26pass%3D12+3456 HTTP/1.1        
        // 使用正则表达式进行请求行的正则匹配
        // std::regex::icase：匹配时忽略大小写
        std::smatch matches;
        std::regex e("(GET|POST|PUT|DELETE|HEAD) ([^?]*)(?:\\?(.*))? (HTTP/1\\.[01])(?:\n|\r\n)?", std::regex::icase);
        bool ret = std::regex_match(line, matches, e);
        if (ret == false) {
            // 解析失败说明请求格式错误
                _recv_statu = RECV_HTTP_ERROR;
                // Bad Request
                _resp_statu = 400;
                return false;              
        }
        // matches中保存的正则匹配后的请求要素信息如下(没有开头的num:)：
        // 0:GET %2Flogin?user%3Dzhangsan%26pass%3D12+3456 HTTP/1.1\r\n
        // 1:GET
        // 2:%2Flogin
        // 3:user%3Dzhangsan%26pass%3D12+3456
        // 4:HTTP/1.1  
        // 填充请求方法(注意：这里需要将可能的小写请求方法转换为大写)
        std::string method = matches[1];
        for(int i = 0; i < method.size(); i++) {
            method[i] = toupper(method[i]);
        }
        _request._method = method;
        // 填充资源路径 -- 需要进行解码
        _request._path = Util::UrlDecode(matches[2], false);
        // 填充协议版本
        _request._version = matches[4];    
        // 获取查询字符串 -- 需要进行解码，同时需要将+特殊解码为空格
        std::string queryStr = Util::UrlDecode(matches[3], true);
        // 分割查询字符串 -- 首先以&为分隔符得到多个查询键值对，然后以=为分隔符得到键值对中的key与value，最终填充到请求信息的_params中
        std::vector<std::string> queryStr_arr;
        Util::Split(queryStr, "&", &queryStr_arr);
        for(auto &kv : queryStr_arr) {
            size_t pos = kv.find("=");
            // 如果键值对中没有=号分割，说明请求行格式错误
            if (pos == std::string::npos) {
                _recv_statu = RECV_HTTP_ERROR;
                // Bad Request
                _resp_statu = 400;
                return false;                
            }
            // 填充查询字符串
            std::string key = kv.substr(0, pos);
            std::string value = kv.substr(pos + 1);
            _request.SetParam(key, value);
        }
        return true;
    }

    /*接收HTTP请求行*/
    bool RecvHttpLine(Buffer *buf) {
        if (_recv_statu != RECV_HTTP_LINE) return false;
        std::string line = buf->GetLine();
        // 如果line长度为0，说明获取一行数据失败
        if (line.size() == 0) {
            // 如果inbuffer中可读数据长度请求行的最大长度，则说明inbuffer中的请求行数据有问题
            if (buf->ReadAbleSize() > MAX_LINE) {
                _recv_statu = RECV_HTTP_ERROR;
                // URI Too Long
                _resp_statu = 414;
                return false;  
            }
            // 否则说明inbuffer中数据太少，不足一个完整的请求行，等待新数据到来
            return true;
        }
        // 否则说明成功接收到了请求行
        // 如果请求行的数据长度大规定的请求行的最大长度，则也是有问题的
        if (line.size() > MAX_LINE) {
            _recv_statu = RECV_HTTP_ERROR;
            // URI Too Long
            _resp_statu = 414;
            return false;  
        }
        // 走到这里，说明接收到了一个合法的请求行，调用ParseHttpLine进行解析
        bool ret = ParseHttpLine(line);
        if (ret == false) return false;
        // 如果HTTP请求行解析成功，则将接收状态修改为RECV_HTTP_HEAD
        _recv_statu = RECV_HTTP_HEAD;
        return true;
    }

    /*解析HTTP请求头部*/
    bool ParseHttpHead(const std::string &line) {
        // key: value\r\n
        size_t pos1 = line.find(": ");
        if (pos1 == std::string::npos) {
                _recv_statu = RECV_HTTP_ERROR;
                // Bad Request
                _resp_statu = 400;
                return false;             
        }
        // 找到末尾的\r\n -- 注意有的请求末尾可能只有\n，没有\r
        size_t pos2 = line.find('\r');
        if (pos2 == std::string::npos) pos2 = line.find('\n');
        std::string key = line.substr(0, pos1);
        std::string value = line.substr(pos1 + strlen(": "), pos2 - (pos1 + strlen(": ")));
        _request.SetHeader(key, value);
        return true;
    }

    /*接收HTTP请求头部*/
    bool RecvHttpHead(Buffer *buf) {
        if (_recv_statu != RECV_HTTP_HEAD) return false;
        // HTTP请求头部格式：key: value\r\nkey: value\r\n...
        // 所以逐行取出缓冲区中的数据进行解析，直到遇到空行即可
        while(true) {
            std::string line = buf->GetLine();
            if (line.size() == 0) {
                if (buf->ReadAbleSize() > MAX_LINE) {
                    _recv_statu = RECV_HTTP_ERROR;
                    _resp_statu = 414;
                    return false;  
                }
                return true;
            }
            if (line.size() > MAX_LINE) {
                _recv_statu = RECV_HTTP_ERROR;
                _resp_statu = 414;
                return false;  
            } 
            // 如果读取到空行，说明请求头部读取完毕
            if (line == "\n" || line == "\r\n") break;
            // 调用ParseHttpHead进行解析
            bool ret = ParseHttpHead(line);
            if (ret == false) return false;           
        }
        // 如果全部请求头部字段都解析成功，则将接收状态修改为RECV_HTTP_BODY
        _recv_statu = RECV_HTTP_BODY;
        return true;
    }

    /*接收HTTP请求正文*/
    bool RecvHttpBody(Buffer *buf) {
        if (_recv_statu != RECV_HTTP_BODY) return false;
        // 获取正文长度
        size_t total_length = _request.ContentLength();
        // 获取已接收的正文长度(_request._body中已有数据的长度)
        size_t received_length = _request._body.size();
        // 当前仍需接收的正文长度
        size_t unreceived_length = total_length - received_length;
        // 检查缓冲区中的数据长度，如果大于等于所需数据长度则请求正文接收解析成功，修改接收状态
        if (buf->ReadAbleSize() >= unreceived_length) {
            std::string body = buf->Read(unreceived_length);
            _request._body += body;
            _recv_statu = RECV_HTTP_OVER;
            return true;
        } 
        // 如果不足所需数据长度，则读取缓冲区中已有的数据，但不修改接收状态，等待新数据到来
        std::string body = buf->Read(buf->ReadAbleSize());
        _request._body += body;
        return true;
    }
public:
    HttpContext() : _resp_statu(200), _recv_statu(RECV_HTTP_LINE) {}

    /*获取HTTP响应状态码*/
    int GetRespStatu() { return _resp_statu; }

    /*获取HTTP请求接收阶段状态码*/
    HttpRecvStatu GetHttpRecvStatu() { return _recv_statu; }

    /*接收并解析HTTP请求*/
    void RecvAndParse(Buffer *buf) {
        switch(_recv_statu) {
            // 注意：case后面不需要加break，因为请求行接收解析完毕后，接下来本来就是要接收解析请求头部的，头部后面又是正文
            case RECV_HTTP_LINE: RecvHttpLine(buf);
            case RECV_HTTP_HEAD: RecvHttpHead(buf);
            case RECV_HTTP_BODY: RecvHttpBody(buf);
        }
    }

    /*获取保存请求接收与解析得到的要素信息*/
    HttpRequest GetRequest() { return _request; }

    /*重置上下文*/
    void Reset() {
        _resp_statu = 200;
        _recv_statu = RECV_HTTP_LINE;
        _request.Reset();
    }
private:
    int _resp_statu;            // 响应状态码
    HttpRecvStatu _recv_statu;  // 当前处于的HTTP请求接收阶段
    HttpRequest _request;       // HTTP请求接收并解析完毕后的请求要素信息
};

/*整合封装HTTP服务器模块*/
class HttpServer {
    using HandleFunc = std::function<void (const HttpRequest &, HttpResponse *)>;
    using ConnectionPtr = std::shared_ptr<Connection>;
private:
    /*错误处理函数*/
    void ErrorHandler(HttpResponse *resp) {
        // 组织一个错误页面
        std::string body = "<html><head><meta http-equiv='Content-Type' content='text/html;charset=utf-8'>";
        body += "</head><body><h1>";
        body += std::to_string(resp->_statu) + " " + Util::StatuDesc(resp->_statu);
        body += "</h1></body></html>";
        // 将响应页面数据作为正文进行响应
        resp->SetContent(body, Util::ExtMime(".html"));
    }

    /*判断是否是静态资源请求*/
    bool IsFileRequest(HttpRequest &req) {
        // 是否设置了静态资源根目录
        if (_wwwroot.empty()) return false;
        // 请求方法是否是GET或者HEAD
        if (req._method != "GET" && req._method != "HEAD") return false;
        // 请求资源路径是否合法
        if (Util::IsValidPath(req._path) == false) return false;
        // 请求的资源是否存在(注意：如果资源路径是目录，则在其后面默认追加一个index.html)
        std::string path = _wwwroot + req._path;  // 实际的资源路径
        if (path.back() == '/') path += "index.html";
        if (Util::IsRegularFile(path) == false) return false;
        // 以上条件都满足，说明这是一个静态资源请求，则将相对资源路径替换为实际路径并返回true
        req._path = path;
        return true;
    }

    /*静态资源请求业务处理函数*/
    void FileHandler(const HttpRequest &req, HttpResponse *resp) {
        // 读取静态资源文件中的数据
        std::string body;
        Util::ReadFile(req._path, &body);
        // 设置响应正文及相关头部字段
        resp->SetContent(body, Util::ExtMime(req._path));
    }

    using Handlers = std::vector<std::pair<std::regex, HandleFunc>>;
    /*功能性请求业务处理函数*/
    void Dispatcher(HttpRequest &req, HttpResponse *resp, Handlers &route) {
        // 由于路由表中存储的是正则表达式以及对应的业务处理函数
        // 所以我们需要使用路由表中的正则表达式对HTTP请求的资源路径进行正则匹配
        // 匹配成功说明该路径有对应的业务处理函数，调用该函数进行业务处理；匹配失败则继续匹配
        for (const auto &handler : route) {
            // 正则表达式
            const std::regex &e = handler.first;
            // 正则匹配
            bool ret = std::regex_match(req._path, req._matches, e);
            // 匹配成功执行对应的业务处理函数
            if (ret == true) return handler.second(req, resp);
        }
        // 如果路由表中没有与该资源路径匹配的元素，则返回404
        resp->_statu = 404;  // Not Found
    }

    /*请求路由与业务处理*/
    void Route(HttpRequest &req, HttpResponse *resp) {
        // 处理静态资源请求
        if (IsFileRequest(req) == true) return FileHandler(req, resp);
        // 分类处理功能性请求
        if (req._method == "GET" || req._method == "HEAD") return Dispatcher(req, resp, _get_route);
        else if (req._method == "POST") return Dispatcher(req, resp, _post_route);
        else if (req._method == "PUT") return Dispatcher(req, resp, _put_route);
        else if (req._method == "DELETE") return Dispatcher(req, resp, _delete_route);
        // 既不是静态资源请求，又不是功能性请求，则返回错误响应
        resp->_statu = 405; // Method Not Allowed
        return;
    }

    /*根据HttpResponse中的响应要素信息组织HTTP响应并发送*/
    void FormResponse(const ConnectionPtr &conn, const HttpRequest &req, HttpResponse &resp) {
        // 完善头部字段
        if (req.IsClose() == true) resp.SetHeader("Connection", "close");
        else resp.SetHeader("Connection", "keep-alive");
        // 组织HTTP响应 -- 响应首行+响应头部+空行+正文
        std::string respStr;
        // 响应首行 -- HTTP/1.1 200 ok\r\n
        respStr += req._version + " " + std::to_string(resp._statu) + " " + Util::StatuDesc(resp._statu) + "\r\n";
        // 响应头部 -- Content-Type: text/html\r\nContent-Length: 500\r\n...
        for(const auto& hander : resp._headers) {
            respStr += hander.first + ": " + hander.second + "\r\n";
        }
        // 空行
        respStr += "\r\n";
        // 响应正文
        respStr += resp._body;
        // 发送HTTP响应
        conn->Send(respStr.c_str(), respStr.size());
    }    

    /*连接建立成功回调函数 -- 由HttpServer模块设置给TcpServer模块，完成上下文的设置*/
    void OnConnected(const ConnectionPtr &conn) {
        conn->SetContext(HttpContext());
        LOG(DEBUG, "New Connection %p", conn.get());
    }   

    /*收到消息回调函数 -- 由HttpServer模块设置给TcpServer模块，完成业务处理*/
    void OnMessage(const ConnectionPtr &conn, Buffer *buf) {
        while(true) {
            // 获取请求上下文
            HttpContext *context = conn->GetContext()->get<HttpContext>();
            // 通过上下文对缓冲区数据进行接收与解析，得到HTTP请求要素信息 -- HttpRequest
            context->RecvAndParse(buf);
            HttpRequest req = context->GetRequest();    
            HttpResponse resp(context->GetRespStatu());
            // 如果接收解析失败，则进行错误处理，构建错误响应，并关闭连接
            if (context->GetHttpRecvStatu() == RECV_HTTP_ERROR) {
                ErrorHandler(&resp);
                FormResponse(conn, req, resp);
                // 为了避免接收缓冲区中存在数据导致在实际释放连接(ShutdownInLoop函数)时又重新调用OnMessage函数，我们需要将接收缓冲区中的内容清空
                // 即使不清空接收缓冲区中的数据，也需要重置请求接收解析的状态，避免程序陷入死循环
                buf->Clear();
                conn->ShutDown();
                return;
            }
            // 如果接收解析未出错，但也不是完成状态，说明缓冲区数据不足，等待新数据到来
            if (context->GetHttpRecvStatu() != RECV_HTTP_OVER) {
                return;
            }
            // 走到这里说明接收解析完成，则循环的进行路由与业务处理，直到缓冲区中的完整请求都被处理完毕
            // 请求路由以及业务处理
            Route(req, &resp);
            // 根据HttpResponse中的响应要素信息组织HTTP响应并发送
            FormResponse(conn, req, resp);
            // 重置上下文
            context->Reset();
            // 检查当前是否是短连接通信，是则直接关闭连接，不是则继续处理
            if (resp.IsClose()) {
                conn->ShutDown();
                return;
            }
        }
    }

    /*连接关闭回调函数*/
    void OnClose(const ConnectionPtr &conn) {
        LOG(DEBUG, "Release Connection %p", conn.get());
    }     
public:
    HttpServer(uint16_t port, uint32_t timeout = DEFAULT_TIMEOUT, std::string ip = "0.0.0.0", bool non_block = true) 
    : _server(port, ip, non_block) {
        // 默认启动非活跃连接的定时销毁，超时时间为30s
        if (timeout > 0) _server.EnableInactiveRelease(timeout);
        _server.SetConnectedCallback(std::bind(&HttpServer::OnConnected, this, std::placeholders::_1));
        _server.SetMessageCallback(std::bind(&HttpServer::OnMessage, this, std::placeholders::_1, std::placeholders::_2));
        _server.SetCloseCallback(std::bind(&HttpServer::OnClose, this, std::placeholders::_1));
    }

    /*设置静态资源根目录*/
    void SetWWWRoot(const std::string &wwwroot) { 
        // 静态资源根目录必须是已存在的目录
        assert(Util::IsDirectory(wwwroot) == true);
        _wwwroot = wwwroot; }

    /*添加GET路由 -- 请求资源的正则表达式与对应的业务处理函数*/
    void Get(const std::string &regExp, const HandleFunc &handler) { _get_route.push_back(make_pair(std::regex(regExp), handler)); }

    /*添加POST路由*/
    void Post(const std::string &regExp, const HandleFunc &handler) {  _post_route.push_back(make_pair(std::regex(regExp), handler)); }  

    /*添加PUT路由*/
    void Put(const std::string &regExp, const HandleFunc &handler) { _put_route.push_back(make_pair(std::regex(regExp), handler)); }

    /*添加DELETE路由*/
    void Delete(const std::string &regExp, const HandleFunc &handler) { _delete_route.push_back(make_pair(std::regex(regExp), handler)); }

    /*设置从属线程池数量*/
    void SetThreadCount(size_t count) { return _server.SetThreadCount(count); }

    /*启动HTTP服务器*/
    void Start() { return _server.Start(); }
private:
    // 请求路由表 -- 请求资源的正则表达式与对应的业务处理函数
    // 注意：由于std::regex没有默认的哈希函数，也没有默认的相等比较运算符，所以不能使用unordered_map来存储路由信息
    std::vector<std::pair<std::regex, HandleFunc>> _get_route;
    std::vector<std::pair<std::regex, HandleFunc>> _post_route;
    std::vector<std::pair<std::regex, HandleFunc>> _put_route;
    std::vector<std::pair<std::regex, HandleFunc>> _delete_route;
    std::string _wwwroot;  // 静态资源根目录
    TcpServer _server;     // 主从Reactor高并发TCP服务器
};

#include "http.hpp"

#define WWWROOT "./wwwroot"

/*组织HTTP请求用于简单回显*/
std::string FormRequest(const HttpRequest &req) {
    std::string reqStr;
    // 请求首行 -- GET /login HTTP/1.1\r\n
    reqStr += req._method + " " + req._path + " " + req._version + "\r\n";
    // 查询字符串
    for(const auto &param : req._params) {
        reqStr += param.first + ": " + param.second + "\r\n";
    }
    // 请求头部 -- Content-Type: text/html\r\nContent-Length: 123\r\n...
    for(const auto &header : req._headers) {
        reqStr += header.first + ": " + header.second + "\r\n";
    }
    // 空行
    reqStr += "\r\n";
    // 请求正文
    reqStr += req._body;
    return reqStr;
}

/*HTTP服务器各种功能性请求对应的业务处理函数，为了便于测试这里只是简单回显*/
void Hello(const HttpRequest &req, HttpResponse *resp) {
    // 测试业务处理超时
    // sleep(25);
    resp->SetContent(FormRequest(req), "text/plain");
}

void Login(const HttpRequest &req, HttpResponse *resp) {
    resp->SetContent(FormRequest(req), "text/plain");
}

void PutFile(const HttpRequest &req, HttpResponse *resp) {
    resp->SetContent(FormRequest(req), "text/plain");
    // 大文件传输测试
    // std::string pathname = WWWROOT + req._path;
    // Util::WriteFile(pathname, req._body);
}

void DeleteFile(const HttpRequest &req, HttpResponse *resp) {
    resp->SetContent(FormRequest(req), "text/plain");
}

int main() 
{
    HttpServer server(8082);
    // 设置静态资源根目录与子线程数量
    server.SetWWWRoot(WWWROOT);
    server.SetThreadCount(4);
    // 添加路由信息
    server.Get("/hello", Hello);
    server.Post("/login", Login);
    server.Put("/file.txt", PutFile);
    server.Delete("/file.txt", DeleteFile);
    // 启动HTTP服务器
    server.Start();
    return 0;
}

/*服务器长连接测试 -- 设置Connection为keep-alive，观察客户端持续通信是否正常*/
void LongConnection_test() {
    Socket clientSock;
    clientSock.CreateClient(8082, "127.0.0.1");
    std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
    while(true) {
        // 发送数据
        ssize_t n = clientSock.Send(req.c_str(), req.size());
        // 接收数据
        char buf[1024] = { 0 };
        n = clientSock.Recv(buf, sizeof(buf) - 1);
        LOG(DEBUG, "[%s]", buf);
        sleep(3);
    }
    clientSock.Close();
}

/*服务器非活跃连接释放测试 -- 设置Connection为keep-alive，通信一段时间后客户端不再发送数据，观察TIMEOUT时间后服务器是否会释放客户端连接*/
void ConnectionTimeout_test() {
    Socket clientSock;
    clientSock.CreateClient(8082, "127.0.0.1");
    std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
    for(int i = 0; true; i++) {
        ssize_t n = clientSock.Send(req.c_str(), req.size());
        char buf[1024] = { 0 };
        n = clientSock.Recv(buf, sizeof(buf) - 1);
        LOG(DEBUG, "[%s]", buf);
        sleep(3);
        if (i == 3) break;
    }
    while(true) sleep(1);
    clientSock.Close();
}

/*错误请求测试*/
void ErrorRequest_test() {
    Socket clientSock;
    clientSock.CreateClient(8082, "127.0.0.1");
    // 正文长度声明为100，但实际的正文只有11个字符
    std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 100\r\n\r\nHelloServe";
    while(true) {
        // 发送一次数据，得不到响应
        assert(clientSock.Send(req.c_str(), req.size()) >= 0);
        // 发送多次数据，超过100字节时会得到一次响应，后续处理出错导致连接被释放
        assert(clientSock.Send(req.c_str(), req.size()) >= 0);
        assert(clientSock.Send(req.c_str(), req.size()) >= 0);
        char buf[1024] = { 0 };
        assert(clientSock.Recv(buf, sizeof(buf) - 1) >= 0);
        LOG(DEBUG, "[%s]", buf);
    }
    while(true) sleep(1);
    clientSock.Close();
}

void HandleTimeout_test() {
    signal(SIGCHLD, SIG_IGN);
    for (int i = 0; i < 10; i++)
    {
        pid_t tid = fork();
        if (tid == -1) {
            LOG(DEBUG, "Fork Error");
            return;
        }
        // 子进程模拟客户端向服务器发送请求
        if (tid == 0) {
            Socket clientSock;
            clientSock.CreateClient(8082, "127.0.0.1");
            std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
            for(int i = 0; true; i++) {
                assert(clientSock.Send(req.c_str(), req.size()) >= 0);
                char buf[1024] = { 0 };
                assert(clientSock.Recv(buf, sizeof(buf) - 1) >= 0);
                LOG(DEBUG, "[%s]", buf);
            }
            clientSock.Close();
            exit(0);
        }
    }
    while(true) sleep(1);
}

/*多条请求处理测试 -- 客户端一次性给服务器发送多条请求，观察服务器处理结果*/
void MutilpleRequests_test() {
    Socket clientSock;
    clientSock.CreateClient(8082, "127.0.0.1");
    std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
    // 后面拼接多条请求
    req += req;
    req += req;
    assert(clientSock.Send(req.c_str(), req.size()) >= 0);
    char buf[1024] = { 0 };
    assert(clientSock.Recv(buf, sizeof(buf) - 1) >= 0);
    LOG(DEBUG, "[%s]", buf);
    clientSock.Close();
}

/*大文件传输测试 -- 使用PUT方法向服务器传输大文件，观察服务器处理结果*/
void LargeFile_test() {
    Socket clientSock;
    clientSock.CreateClient(8082, "127.0.0.1");
    std::string req = "PUT /file.txt HTTP/1.1\r\nConnection: keep-alive\r\n";
    std::string body;
    // 由于云服务器内存空间限制，这里test.txt大小为200M
    Util::ReadFile("./test.txt", &body);
    req += "Content-Length: " + std::to_string(body.size()) + "\r\n\r\n";
    assert(clientSock.Send(req.c_str(), req.size()) >= 0);
    assert(clientSock.Send(body.c_str(), body.size()) >= 0);
    char buf[1024] = { 0 };
    assert(clientSock.Recv(buf, sizeof(buf) - 1) >= 0);
    LOG(DEBUG, "[%s]", buf);
    clientSock.Close();
}