├── CGImysql
    ├── sql_connection_pool.cpp
    └── sql_connection_pool.h
├── Debug.md
├── LICENSE
├── README.md
├── README_local.md
├── TinyWebServer.drawio
├── bin
    ├── skiplist_stress_test
    └── skiplist_test
├── build.sh
├── config.cpp
├── config.h
├── http
    ├── http_conn.cpp
    └── http_conn.h
├── locker
    └── locker.h
├── log
    ├── block_queue.h
    ├── log.cpp
    └── log.h
├── main.cpp
├── makefile
├── resource
    ├── TinyWebServer.mp4
    ├── TinyWebServer.png
    ├── TinyWebServer0.png
    ├── TinyWebServer1.png
    ├── TinyWebServer2.png
    ├── TinyWebServer3.png
    ├── skiplist.png
    ├── skiplist_test1.png
    └── skiplist_test2.png
├── root
    ├── awei.html
    ├── awei.png
    ├── judge.html
    ├── log.html
    ├── logError.html
    ├── picture.html
    ├── pricture.png
    ├── register.html
    ├── registerError.html
    ├── video.html
    ├── video.mp4
    └── welcome.html
├── skiplist
    └── skiplist.h
├── store
    └── dumpFile
├── test
    ├── makefile
    ├── skiplist_stress_test.cpp
    ├── skiplist_stress_test.sh
    └── skiplist_test.cpp
├── threadpool
    └── threadpool.h
├── timer
    ├── list_timer.cpp
    └── list_timer.h
├── webserver.cpp
└── webserver.h


/CGImysql/sql_connection_pool.cpp:
--------------------------------------------------------------------------------
  1 | #include <mysql/mysql.h>
  2 | #include <stdio.h>
  3 | #include <string>
  4 | #include <string.h>
  5 | #include <stdlib.h>
  6 | #include <list>
  7 | #include <pthread.h>
  8 | #include <iostream>
  9 | 
 10 | #include "sql_connection_pool.h"
 11 | 
 12 | using namespace std;
 13 | 
 14 | Connection_Pool::Connection_Pool()
 15 | {
 16 |     m_CurrentConnections = 0;
 17 |     m_FreeConnections = 0;
 18 | }
 19 | 
 20 | Connection_Pool::~Connection_Pool()
 21 | {
 22 |     DestroyPool();
 23 | }
 24 | 
 25 | // RAII
 26 | Connection_Pool *Connection_Pool::get_Instance()
 27 | {
 28 |     static Connection_Pool connection_pool;
 29 |     return &connection_pool;
 30 | }
 31 | 
 32 | // Initialize the connection pool
 33 | void Connection_Pool::init(string url,string user,string password,
 34 |         string DataBaseName,int port,int maxConnections,int close_log)
 35 | {
 36 |     // Initializing the Data Base
 37 |     m_url          = url;
 38 |     m_user         = user;
 39 |     m_password     = password;
 40 |     m_DataBaseName = DataBaseName;
 41 |     m_port         = port;
 42 |     m_close_log    = close_log; 
 43 | 
 44 |     // Creating the max connection of sql
 45 |     for( int i = 0; i < maxConnections; i++ )
 46 |     {
 47 |         MYSQL *con = NULL;
 48 |         con = mysql_init(con);
 49 | 
 50 |         if( con == NULL )
 51 |         {
 52 |             LOG_ERROR("MySQL Error: Unable to create connection");
 53 |             exit(1);
 54 |         }
 55 | 
 56 |         con = mysql_real_connect(con, url.c_str(),user.c_str(),password.c_str(),
 57 |             DataBaseName.c_str(),port,NULL,0);
 58 | 
 59 |         if( con == NULL )
 60 |         {
 61 |             LOG_ERROR("MySQL Error: Unable to create connection");
 62 |             exit(1);
 63 |         }
 64 | 
 65 |         // Updating the connection pool
 66 |         connection_list.push_back(con);
 67 |         m_FreeConnections++;
 68 |     }
 69 | 
 70 |     // Updating the max connections
 71 |     reserve = sem(m_FreeConnections);
 72 |     m_MaxConnections = m_FreeConnections;
 73 |     
 74 | 
 75 | }
 76 | 
 77 | // Getting a free connection from the pool
 78 | MYSQL *Connection_Pool::GetConnection()
 79 | {
 80 |     MYSQL *con = NULL;
 81 | 
 82 |     if( connection_list.size() == 0 )
 83 |     {
 84 |         return NULL;
 85 |     }
 86 | 
 87 |     reserve.wait();
 88 | 
 89 |     lock.lock();
 90 | 
 91 |     con = connection_list.front();
 92 |     connection_list.pop_front();
 93 |     
 94 |     --m_FreeConnections;
 95 |     ++m_CurrentConnections;
 96 | 
 97 |     lock.unlock();
 98 | 
 99 |     return con;
100 | }
101 | 
102 | // Release a connection back to the pool
103 | bool Connection_Pool::ReleaseConnection(MYSQL* con)
104 | {
105 |     if( con == NULL )
106 |     {
107 |         return false;
108 |     }
109 | 
110 |     lock.lock();
111 | 
112 |     connection_list.push_back(con);
113 |     ++m_FreeConnections;
114 |     --m_CurrentConnections;
115 | 
116 |     lock.unlock();
117 | 
118 |     // Post + 1
119 |     reserve.post();
120 |     return true;
121 | }
122 | 
123 | // Destroying the connection pool
124 | void Connection_Pool::DestroyPool()
125 | {
126 |     lock.lock();
127 | 
128 |     if( connection_list.size() > 0 )
129 |     {
130 |         list<MYSQL *>::iterator it;
131 |         for( it = connection_list.begin(); it != connection_list.end(); ++it)
132 |         {
133 |             MYSQL *connection = *it;
134 |             mysql_close(connection);
135 |         }
136 | 
137 |         m_CurrentConnections = 0;
138 |         m_FreeConnections = 0;
139 |         connection_list.clear();
140 |     }
141 | 
142 |     lock.unlock();
143 | 
144 | }
145 | 
146 | // Getting the number of free connections
147 | int Connection_Pool::GetFreeConnections()
148 | {
149 |     return this->m_FreeConnections;
150 | }
151 | 
152 | // *!* Using RAII to release/get the connection 
153 | 
154 | Connection_RAII::Connection_RAII(MYSQL **SQL, Connection_Pool *connection_pool)
155 | {
156 |     *SQL = connection_pool->GetConnection();
157 |     
158 |     con_RAII  = *SQL;
159 |     pool_RAII = connection_pool;
160 | }
161 | 
162 | Connection_RAII::~Connection_RAII()
163 | {
164 |     pool_RAII->ReleaseConnection(con_RAII);
165 | }
166 | 
167 | 
168 | 


--------------------------------------------------------------------------------
/CGImysql/sql_connection_pool.h:
--------------------------------------------------------------------------------
 1 | #ifndef SQL_CONNECTION_POOL_H
 2 | #define SQL_CONNECTION_POOL_H
 3 | 
 4 | // *!* This project is divided into two parts: Connection Pool and  Sign/Register function
 5 | 
 6 | #include <stdio.h>
 7 | #include <list>
 8 | #include <mysql/mysql.h>
 9 | #include <errno.h>
10 | #include <string.h>
11 | #include <iostream>
12 | #include <string>
13 | 
14 | #include "../locker/locker.h"
15 | #include "../log/log.h"
16 | 
17 | 
18 | using namespace std;
19 | class Connection_Pool
20 | {
21 | public:
22 |     MYSQL *GetConnection();   // Get the connection
23 |     bool ReleaseConnection(MYSQL *connection); // Release the connection
24 |     int GetFreeConnections();  // Get the free connection
25 |     void DestroyPool(); // Destroy the connection pool
26 | 
27 |     // Single model
28 |     static Connection_Pool *get_Instance(); // Get the instance
29 | 
30 |     // Initialize the connection pool
31 |     void init(string url,string user,string password,
32 |         string DataBaseName,int port,int maxConnections,int close_log); 
33 | 
34 | private:
35 |     Connection_Pool();
36 |     ~Connection_Pool();
37 | 
38 |     int m_MaxConnections;   // Max number of connections
39 |     int m_CurrentConnections; // Current number of connections
40 |     int m_FreeConnections; // Number of free connections
41 | 
42 |     locker lock;
43 | 
44 |     list<MYSQL *> connection_list; // List of connections
45 |     sem reserve;
46 | 
47 | public:
48 |     string m_url;   // URL of the connection pool
49 |     string m_user;  // Username of the connection pool
50 |     string m_port;  // Port of the connection pool
51 |     string m_DataBaseName;  // Data base name
52 |     string m_password; // Password of the connection pool
53 | 
54 |     int m_close_log;    // Close connection flag
55 | 
56 | };
57 | 
58 | class Connection_RAII
59 | {
60 | public:
61 |     Connection_RAII(MYSQL **SQL, Connection_Pool *connection_pool);
62 |     ~Connection_RAII();
63 | 
64 | private:
65 |     MYSQL *con_RAII;
66 |     Connection_Pool *pool_RAII;
67 | 
68 | };
69 | 
70 | 
71 | #endif /* SQL_CONNECTION_POOL_H */
72 | 


--------------------------------------------------------------------------------
/Debug.md:
--------------------------------------------------------------------------------
  1 | ```cpp
  2 | bool http_conn::write()
  3 |  2{
  4 |  3    int temp=0;
  5 |  4    int bytes_have_send=0;
  6 |  5    int bytes_to_send=m_write_idx;
  7 |  6    if(bytes_to_send==0)
  8 |  7    {
  9 |  8        modfd(m_epollfd,m_sockfd,EPOLLIN);
 10 |  9        init();
 11 | 10        return true;
 12 | 11    }
 13 | 12    while(1)
 14 | 13    {
 15 | 14        temp=writev(m_sockfd,m_iv,m_iv_count);
 16 | 15        if(temp<=-1)
 17 | 16        {
 18 | 17            if(errno==EAGAIN)
 19 | 18            {
 20 | 19                modfd(m_epollfd,m_sockfd,EPOLLOUT);
 21 | 20                return true;
 22 | 21            }
 23 | 22            unmap();
 24 | 23            return false;
 25 | 24        }
 26 | 25        bytes_to_send-=temp;
 27 | 26        bytes_have_send+=temp;
 28 | 27        if(bytes_to_send<=bytes_have_send)
 29 | 28        {
 30 | 29            unmap();
 31 | 30            if(m_linger)
 32 | 31            {
 33 | 32                init();
 34 | 33                modfd(m_epollfd,m_sockfd,EPOLLIN);
 35 | 34                return true;
 36 | 35            }
 37 | 36            else
 38 | 37            {
 39 | 38                modfd(m_epollfd,m_sockfd,EPOLLIN);
 40 | 39                return false;
 41 | 40            }
 42 | 41        }
 43 | 42    }
 44 | 43}
 45 | 
 46 | ```
 47 | 
 48 | ```cpp
 49 | bool http_conn::write()
 50 |  2{
 51 |  3    int temp = 0;
 52 |  4
 53 |  5    int newadd = 0;
 54 |  6
 55 |  7    if (bytes_to_send == 0)
 56 |  8    {
 57 |  9        modfd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
 58 | 10        init();
 59 | 11        return true;
 60 | 12    }
 61 | 13
 62 | 14    while (1)
 63 | 15    {
 64 | 16        temp = writev(m_sockfd, m_iv, m_iv_count);
 65 | 17
 66 | 18        if (temp >= 0)
 67 | 19        {
 68 | 20            bytes_have_send += temp;
 69 | 21            newadd = bytes_have_send - m_write_idx;
 70 | 22        }
 71 | 23        else
 72 | 24        {
 73 | 25            if (errno == EAGAIN)
 74 | 26            {
 75 | 27                if (bytes_have_send >= m_iv[0].iov_len)
 76 | 28                {
 77 | 29                    m_iv[0].iov_len = 0;
 78 | 30                    m_iv[1].iov_base = m_file_address + newadd;
 79 | 31                    m_iv[1].iov_len = bytes_to_send;
 80 | 32                }
 81 | 33                else
 82 | 34                {
 83 | 35                    m_iv[0].iov_base = m_write_buf + bytes_have_send;
 84 | 36                    m_iv[0].iov_len = m_iv[0].iov_len - bytes_have_send;
 85 | 37                }
 86 | 38                modfd(m_epollfd, m_sockfd, EPOLLOUT, m_TRIGMode);
 87 | 39                return true;
 88 | 40            }
 89 | 41            unmap();
 90 | 42            return false;
 91 | 43        }
 92 | 44        bytes_to_send -= temp;
 93 | 45        if (bytes_to_send <= 0)
 94 | 46
 95 | 47        {
 96 | 48            unmap();
 97 | 49            modfd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
 98 | 50
 99 | 51            if (m_linger)
100 | 52            {
101 | 53                init();
102 | 54                return true;
103 | 55            }
104 | 56            else
105 | 57            {
106 | 58                return false;
107 | 59            }
108 | 60        }
109 | 61    }
110 | 62}
111 | 
112 | 
113 | 
114 | 
115 | ```


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2023 awei-lwj
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # TinyWebServer
  2 | 
  3 | ## Introduction
  4 | 
  5 | Linux下的一个C++轻量级Web服务器。
  6 | 
  7 | **Key Points**:
  8 | 
  9 | - 使用 **线程池** + **非阻塞socket** +  **epoll(ET与LT均实现)** + **事件处理(Reactor + 模拟Proactor)** 的并发模型
 10 | - 使用 **状态机**解析HTTP请求报文，支持解析**GET和POST请求**
 11 | - 使用 priority queue 实现的**最小堆结构管理定时器**，使用标记删除，以支持惰性删除，提高性能
 12 | - 使用 **RAII**手法封装互斥器(pthread_mutex_t)、 条件变量(pthread_cond_t)等线程同步互斥机制，管理文件描述符等资源，避免锁争用
 13 | - 访问**服务器数据库**实现web端**用户注册、登录功能**，可以**请求服务器图片和视频文件**
 14 | - 实现**同步/异步日志系统**，记录服务器运行状态
 15 | - 内置一个基于跳表实现的**轻量级key-value型存储引擎**，使用C++实现。可以实现的**操作**有：插入数据、删除数据、查询数据、文件落盘、文件加载数据以及数据库显示大小
 16 | 
 17 | **Tests**:
 18 | 
 19 | - 经过WebBench压力测试可以实现**上万的并发连接数据交换**
 20 | - 随机读写的情况下，所实现的轻量型key-value存储引擎，每秒可处理的的**写请求数量（QPS）**：12.2819 W，每秒可处理的**读请求数目(QPS)**: 14.5819 W。
 21 | 
 22 | **TODO**:
 23 | 
 24 | - WebServer以及内置的key-value存储引擎的测试不是全自动化的
 25 | - 加上一致性协议，提供分布式的存储服务
 26 | - 实现循环缓冲区来实现同步/异步日志系统
 27 | - 实现类 MutexLockGuard，避免锁争用问题
 28 | - 完善eventlooppool进行事件管理和使用C++11的shared_ptr的智能指针进行内存管理
 29 | - 完善skiplist来代替mysql数据库提供分布式服务
 30 | 
 31 | ## Function Demonstration
 32 | 
 33 | ### 1. Key-Value存储引擎
 34 | 
 35 | Key-Value存储引擎的stress test在下文，这里演示Key-Value相应的功能
 36 | 
 37 | SkipList API:
 38 | 
 39 | - [x] insert_element(进行element插入)
 40 | - [x] delete_element(进行element删除)
 41 | - [x] serach_element(进行element查找)
 42 | - [x] display_list(进行skiplist展示)
 43 | - [x] dump_file(数据落盘)
 44 | - [x] load_file(数据加载)
 45 | - [x] size(返回数据落盘)
 46 |   
 47 | --------
 48 | ![在这里插入图片描述](https://img-blog.csdnimg.cn/86aad683aaec4c3c9216abefda439f34.png#pic_center)![在这里插入图片描述](https://img-blog.csdnimg.cn/66a6e138c372428c9de4365a59b30f7d.png#pic_center)
 49 | 
 50 | 
 51 | ### 2.TinyWebServer
 52 | 
 53 | - [x] 注册
 54 | - [x] 已有用户
 55 | - [x] 登录
 56 | - [x] 密码错误
 57 | - [x] 图片测试(海绵宝宝11.8M)，视频测试(Kruskal算法和Prim算法，22.5M)
 58 | - [x] Making friends with awei 
 59 | 
 60 | 
 61 | [video(video-ixKOhPg5-1674019344246)(type-csdn)(url-https://live.csdn.net/v/embed/270761)(image-https://video-community.csdnimg.cn/vod-84deb4/36ba9c7096e571edbfc76723a78f0102/snapshots/27141e426ea947aaa88c564a0a3def70-00005.jpg?auth_key=4827614704-0-0-e15be31db2d61fc71dc7b0194682568b)(title-TinyWebServer)]
 62 | 
 63 | ## Framework
 64 | 
 65 | ### 1.Key-Vaule Storage Enginee based on the skip list
 66 | 
 67 | ![在这里插入图片描述](https://img-blog.csdnimg.cn/035de4884e9b404dab9784a48e8382a7.png#pic_center)
 68 | 
 69 | 
 70 | ### 2. TinyWebServer
 71 | ![在这里插入图片描述](https://img-blog.csdnimg.cn/feb99cf6dcba4d65ad5aa5ef6dea7750.png#pic_center)
 72 | 
 73 | ## Configuration
 74 | 
 75 | - VMare Workstaion + Ubuntu 22.10
 76 | - C++ 11 Configuration
 77 | - MySQL
 78 | - make + cmake + shell
 79 | - Webbench
 80 | 
 81 | ## Build
 82 | 
 83 | ### 1. Key-Value Storgae Enginee
 84 | 
 85 | Stress Tests:
 86 | 
 87 | ~~~shell
 88 | cd test/
 89 | sh skiplist_stress_test.sh // 数据量一开始设定为一百万
 90 | ~~~
 91 | 
 92 | Key-Value enginee operation mode
 93 | 
 94 | ~~~shell
 95 | make
 96 | ../bin/skiplist_test
 97 | ~~~
 98 | 
 99 | ### 2.TinyWebServer
100 | 
101 | - 虚拟机测试环境
102 |   - Ubuntu 22.10
103 |   - mysql  Ver 8.0.31-0ubuntu2 for Linux on x86_64 ((Ubuntu))
104 |   
105 | - 游览器测试环境
106 |   - Linux/Windows
107 |   - Chrone/FireFox
108 |   - 其他游览器没有测试
109 | 
110 | - 在进行**游览器测试**之前请先确保已经安装好MySQL以及相应的MySQL库
111 | 
112 |   ~~~shell
113 |   // Install mysql and mysql dependency library
114 |   sudo apt install mysql-server -y
115 |   sudo apt install libmysqlclient-dev -y
116 |   ~~~
117 | 
118 |   ~~~shell
119 |   // 建立yourdb库
120 |   create database yourdb;
121 | 
122 |   // 创建user表
123 |   USE yourdb;
124 |   CREATE TABLE user(
125 |       username char(50) NULL,
126 |       passwd char(50) NULL
127 |   )ENGINE=InnoDB;
128 | 
129 |   // 添加数据
130 |   INSERT INTO user(username, passwd) VALUES('name', 'passwd'); 
131 |   ~~~
132 | 
133 | - 修改main.cpp中的数据库的初始化信息
134 | 
135 |   ~~~shell
136 |   //数据库登录名,密码,库名
137 |   string user = "root";
138 |   string passwd = "root";
139 |   string databasename = "yourdb";
140 |   ~~~
141 | 
142 | - build以及启动server
143 |   
144 |   ~~~shell
145 |   sh ./build.sh
146 |   ./server
147 |   ~~~
148 | 
149 | - 用ifconfig查找本机的ip地址，然后在游览器端口处进行相应的IP地址访问
150 | 
151 |   ~~~shell
152 |   ifconfig
153 | 
154 |   // 游览器端
155 |   ip:9096
156 |   ~~~
157 | 
158 | - 在进行**Webbench测试**之前请先确保已经安装好Webbench以及相应的依赖库
159 |   
160 |   ~~~shell
161 |   sudo apt install ctags
162 |   cd test/Webbench
163 |   make
164 |   ~~~
165 | 
166 | ## Command for server
167 | 
168 | ~~~shell
169 | ./server [-p port] [-l LOGWrite] [-m TRIGMode] [-o OPT_LINGER] [-s sql_num] [-t thread_num] [-c close_log] [-a actor_model]
170 | ~~~
171 | 
172 | 并非全部都要使用，个性化设置即可
173 | 
174 | - -p，自定义端口号
175 |   - 默认9006
176 | 
177 | - -l，选择日志写入方式，默认同步写入
178 |   - 0，同步写入
179 |   - 1，异步写入
180 |   
181 | - -m，listenfd和connfd的模式组合，默认使用LT + LT
182 |   - 0，表示使用LT + LT
183 |   - 1，表示使用LT + ET
184 |   - 2，表示使用ET + LT
185 |   - 3，表示使用ET + ET
186 |   
187 | - -o，优雅关闭连接，默认不使用
188 |   - 0，不使用
189 |   - 1，使用
190 | - -s，数据库连接数量
191 |   - 默认为8
192 | - -t，线程数量
193 |   - 默认为8
194 | - -c，关闭日志，默认打开
195 |   - 0, 打开日志
196 |   - 1，关闭日志
197 | - -a，选择反应堆模型，默认Proactor
198 |   - 0，Proactor模型
199 |   - 1，Reactor模型
200 | 
201 | ## Tests
202 | 
203 | ### 1.Key-Value Storgae Enginee
204 | 
205 | Insert element operation
206 | | 插入的数据规模(万条)| 耗费时间 |
207 | |---|---|
208 | | 1 | 0.0625142 |
209 | | 10| 0.688054  |
210 | | 15| 1.2213   |
211 | | 20| 1.77769   |
212 | | 50| 5.33906   |
213 | | 100| 11.5311  |
214 | 
215 | 每秒可以处理的写请求数目（QPS）：12.2819 W
216 | 
217 | Get element operation
218 | | 读取的数据规模(万条)| 耗费时间 |
219 | |---|---|
220 | | 1 | 0.0443168 |
221 | | 10| 0.96824  |
222 | | 15| 1.12037   |
223 | | 20| 1.17522   |
224 | | 50| 4.14332   |
225 | | 100| 9.7482  |
226 | 
227 | 每秒可以处理的读请求数目（QPS）：14.5819 W
228 | 
229 | ### 2.WebServer
230 | 
231 | 在关闭服务器日志之后，使用Webbench对服务器进行压力测试，对listen_fd和connection_fd分别采用ET或LT模式，均可以实现近万的并发连接以下列出组合后的测试结果
232 | 
233 | - Proactor，TRIGMode = 0, Listen_fd = LT, connection_fd = LT，QPS = 202927
234 | ![在这里插入图片描述](https://img-blog.csdnimg.cn/712a247abb1a43148fbaeb819a895b87.png#pic_center)
235 | - Proactor，TRIGMode = 1, Listen_fd = LT, connection_fd = ET, QPS = 216614
236 | ![在这里插入图片描述](https://img-blog.csdnimg.cn/fbf2d5ff8e8d493aa8a280634bd160f5.png#pic_center)
237 | - Proactor，TRIGMode = 2, Listen_fd = ET, connection_fd = LT, QPS = 124588
238 | ![在这里插入图片描述](https://img-blog.csdnimg.cn/5a04c90fb2744ab19c636f9f7595e8bb.png#pic_center)
239 | 
240 | - Proactor，TRIGMode = 3, Listen_fd = ET, connection_fd = ET, QPS = 180345
241 | ![在这里插入图片描述](https://img-blog.csdnimg.cn/460cc98e84974c8584a391dfee005d7e.png#pic_center)
242 | 
243 | 
244 | ## Debug过程中的一些难点
245 |   
246 | - [x] 小的bug不多说
247 | - [x] 由于并发模型构建的不完善，seg implement在查看了游侠的高性能网络编程以及学会了利用GDB调试来进行查看线程安全问题
248 | - [x] 书上的http对大文件进行读取存在问题，在查阅资料和问了大佬之后得以修复
249 | 
250 | ~~~cpp
251 | // 原先代码
252 | bool http_conn::write()
253 | {
254 |     int temp=0;
255 |     int bytes_have_send=0;
256 |     int bytes_to_send=m_write_idx;
257 |     if(bytes_to_send==0)
258 |     {
259 |         modfd(m_epollfd,m_sockfd,EPOLLIN);
260 |         init();
261 |         return true;
262 |     }
263 |     while(1)
264 |     {
265 |         temp=writev(m_sockfd,m_iv,m_iv_count);
266 |         if(temp<=-1)
267 |         {
268 |             if(errno==EAGAIN)
269 |             {
270 |                 modfd(m_epollfd,m_sockfd,EPOLLOUT);
271 |                 return true;
272 |             }
273 |             unmap();
274 |             return false;
275 |         }
276 |         bytes_to_send-=temp;
277 |         bytes_have_send+=temp;
278 |         if(bytes_to_send<=bytes_have_send)
279 |         {
280 |             unmap();
281 |             if(m_linger)
282 |             {
283 |                 init();
284 |                 modfd(m_epollfd,m_sockfd,EPOLLIN);
285 |                 return true;
286 |             }
287 |             else
288 |             {
289 |                 modfd(m_epollfd,m_sockfd,EPOLLIN);
290 |                 return false;
291 |             }
292 |         }
293 |     }
294 | }
295 | 
296 | ~~~
297 | 
298 | ---
299 | 
300 | ~~~cpp
301 | // Debug
302 | bool http_conn::write()
303 | {
304 |     int temp = 0;
305 | 
306 |     int newadd = 0;
307 | 
308 |     if (bytes_to_send == 0)
309 |     {
310 |         modfd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
311 |         init();
312 |         return true;
313 |     }
314 | 
315 |     while (1)
316 |     {
317 |         temp = writev(m_sockfd, m_iv, m_iv_count);
318 | 
319 |         if (temp >= 0)
320 |         {
321 |             bytes_have_send += temp;
322 |             newadd = bytes_have_send - m_write_idx;
323 |         }
324 |         else
325 |         {
326 |             if (errno == EAGAIN)
327 |             {
328 |                 if (bytes_have_send >= m_iv[0].iov_len)
329 |                 {
330 |                     m_iv[0].iov_len = 0;
331 |                     m_iv[1].iov_base = m_file_address + newadd;
332 |                     m_iv[1].iov_len = bytes_to_send;
333 |                 }
334 |                 else
335 |                 {
336 |                     m_iv[0].iov_base = m_write_buf + bytes_have_send;
337 |                     m_iv[0].iov_len = m_iv[0].iov_len - bytes_have_send;
338 |                 }
339 |                 modfd(m_epollfd, m_sockfd, EPOLLOUT, m_TRIGMode);
340 |                 return true;
341 |             }
342 |             unmap();
343 |             return false;
344 |         }
345 |         bytes_to_send -= temp;
346 |         if (bytes_to_send <= 0)
347 |         {
348 |             unmap();
349 |             modfd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
350 | 
351 |             if (m_linger)
352 |             {
353 |                 init();
354 |                 return true;
355 |             }
356 |             else
357 |             {
358 |                 return false;
359 |             }
360 |         }
361 |     }
362 | }
363 | 
364 | 
365 | ~~~
366 | 


--------------------------------------------------------------------------------
/README_local.md:
--------------------------------------------------------------------------------
  1 | # TinyWebServer
  2 | 
  3 | ## Introduction
  4 | 
  5 | Linux下的一个C++轻量级Web服务器。
  6 | 
  7 | **Key Points**:
  8 | 
  9 | - 使用 **线程池** + **非阻塞socket** +  **epoll(ET与LT均实现)** + **事件处理(Reactor + 模拟Proactor)** 的并发模型
 10 | - 使用 **状态机**解析HTTP请求报文，支持解析**GET和POST请求**
 11 | - 使用 priority queue 实现的**最小堆结构管理定时器**，使用标记删除，以支持惰性删除，提高性能
 12 | - 使用 **RAII**手法封装线程连接池
 13 | - 使用**单例模式**进行资源管理
 14 | - 访问**服务器数据库**实现web端**用户注册、登录功能**，可以**请求服务器图片和视频文件**
 15 | - 实现**同步/异步日志系统**，记录服务器运行状态
 16 | - 内置一个基于跳表实现的**轻量级key-value型存储引擎**，使用C++实现。可以实现的**操作**有：插入数据、删除数据、查询数据、文件落盘、文件加载数据以及数据库显示大小
 17 | 
 18 | **Tests**:
 19 | 
 20 | - 经过WebBench压力测试可以实现**上万的并发连接数据交换**
 21 | - 随机读写的情况下，所实现的轻量型key-value存储引擎，每秒可处理的的**写请求数量（QPS）**：24.39W，每秒可处理的**读请求数目(QPS)**: 18.41W。
 22 | 
 23 | **TODO**:
 24 | 
 25 | - WebServer以及内置的key-value存储引擎的测试不是全自动化的
 26 | - 加上一致性协议，提供分布式的存储服务
 27 | - 实现循环缓冲区来实现同步/异步日志系统
 28 | - 实现类 MutexLockGuard，避免锁争用问题
 29 | - 完善eventlooppool进行事件管理和使用C++11的shared_ptr的智能指针进行内存管理
 30 | - 完善skiplist来代替mysql数据库提供分布式服务
 31 | 
 32 | ## Function Demonstration
 33 | 
 34 | ### 1. Key-Value存储引擎
 35 | 
 36 | Key-Value存储引擎的stress test在下文，这里演示Key-Value相应的功能
 37 | 
 38 | SkipList API:
 39 | 
 40 | - [x] insert_element(进行element插入)
 41 | - [x] delete_element(进行element删除)
 42 | - [x] serach_element(进行element查找)
 43 | - [x] display_list(进行skiplist展示)
 44 | - [x] dump_file(数据落盘)
 45 | - [x] load_file(数据加载)
 46 | - [x] size(返回数据落盘)
 47 |   
 48 | --------
 49 | 
 50 | ![skiplist1](./resource/skiplist_test1.png)
 51 | 
 52 | 删除key5/7并且展示跳表
 53 | 
 54 | ![skiplist2](./resource/skiplist_test2.png)
 55 | 
 56 | ### 2.TinyWebServer
 57 | 
 58 | - [x] 注册
 59 | - [x] 已有用户
 60 | - [x] 登录
 61 | - [x] 密码错误
 62 | - [x] 图片测试(海绵宝宝11.8M)，视频测试(Kruskal算法和Prim算法，22.5M)
 63 | - [x] Making friends with awei 
 64 | 
 65 | ~~~cpp
 66 | // TODO: <iframe height=498 width=510 src="./resource/TinyWebServer.mp4">
 67 | ~~~
 68 | 
 69 | // TODO: 直接用CSDN的视频进行连接即可
 70 | 
 71 | ## Framework
 72 | 
 73 | ### 1.Key-Vaule Storage Enginee based on the skip list
 74 | 
 75 | ![skiplist](./resource/skiplist.png)
 76 | 
 77 | ### 2. TinyWebServer
 78 | 
 79 | ![TinyWebserver](./resource/TinyWebServer.png)
 80 | 
 81 | ## Configuration
 82 | 
 83 | - VMare Workstaion + Ubuntu 22.10
 84 | - C++ 11 Configuration
 85 | - MySQL
 86 | - make + cmake + shell
 87 | - Webbench
 88 | 
 89 | ## Build
 90 | 
 91 | ### 1. Key-Value Storgae Enginee
 92 | 
 93 | Stress Tests:
 94 | 
 95 | ~~~shell
 96 | cd test/
 97 | sh skiplist_stress_test.sh // 数据量一开始设定为一百万
 98 | ~~~
 99 | 
100 | Key-Value enginee operation mode
101 | 
102 | ~~~shell
103 | make
104 | ../bin/skiplist_test
105 | ~~~
106 | 
107 | ### 2.TinyWebServer
108 | 
109 | - 虚拟机测试环境
110 |   - Ubuntu 22.10
111 |   - mysql  Ver 8.0.31-0ubuntu2 for Linux on x86_64 ((Ubuntu))
112 |   
113 | - 游览器测试环境
114 |   - Linux/Windows
115 |   - Chrone/FireFox
116 |   - 其他游览器没有测试
117 | 
118 | - 在进行**游览器测试**之前请先确保已经安装好MySQL以及相应的MySQL库
119 | 
120 |   ~~~shell
121 |   // Install mysql and mysql dependency library
122 |   sudo apt install mysql-server -y
123 |   sudo apt install libmysqlclient-dev -y
124 |   ~~~
125 | 
126 |   ~~~shell
127 |   // 建立yourdb库
128 |   create database yourdb;
129 | 
130 |   // 创建user表
131 |   USE yourdb;
132 |   CREATE TABLE user(
133 |       username char(50) NULL,
134 |       passwd char(50) NULL
135 |   )ENGINE=InnoDB;
136 | 
137 |   // 添加数据
138 |   INSERT INTO user(username, passwd) VALUES('name', 'passwd'); 
139 |   ~~~
140 | 
141 | - 修改main.cpp中的数据库的初始化信息
142 | 
143 |   ~~~shell
144 |   //数据库登录名,密码,库名
145 |   string user = "root";
146 |   string passwd = "root";
147 |   string databasename = "yourdb";
148 |   ~~~
149 | 
150 | - build以及启动server
151 |   
152 |   ~~~shell
153 |   sh ./build.sh
154 |   ./server
155 |   ~~~
156 | 
157 | - 用ifconfig查找本机的ip地址，然后在游览器端口处进行相应的IP地址访问
158 | 
159 |   ~~~shell
160 |   ifconfig
161 | 
162 |   // 游览器端
163 |   ip:9096
164 |   ~~~
165 | 
166 | - 在进行**Webbench测试**之前请先确保已经安装好Webbench以及相应的依赖库
167 |   
168 |   ~~~shell
169 |   sudo apt install ctags
170 |   cd test/Webbench
171 |   make
172 |   ~~~
173 | 
174 | ## Command for server
175 | 
176 | ~~~shell
177 | ./server [-p port] [-l LOGWrite] [-m TRIGMode] [-o OPT_LINGER] [-s sql_num] [-t thread_num] [-c close_log] [-a actor_model]
178 | ~~~
179 | 
180 | 并非全部都要使用，个性化设置即可
181 | 
182 | - -p，自定义端口号
183 |   - 默认9006
184 | 
185 | - -l，选择日志写入方式，默认同步写入
186 |   - 0，同步写入
187 |   - 1，异步写入
188 |   
189 | - -m，listenfd和connfd的模式组合，默认使用LT + LT
190 |   - 0，表示使用LT + LT
191 |   - 1，表示使用LT + ET
192 |   - 2，表示使用ET + LT
193 |   - 3，表示使用ET + ET
194 |   
195 | - -o，优雅关闭连接，默认不使用
196 |   - 0，不使用
197 |   - 1，使用
198 | - -s，数据库连接数量
199 |   - 默认为8
200 | - -t，线程数量
201 |   - 默认为8
202 | - -c，关闭日志，默认打开
203 |   - 0, 打开日志
204 |   - 1，关闭日志
205 | - -a，选择反应堆模型，默认Proactor
206 |   - 0，Proactor模型
207 |   - 1，Reactor模型
208 | 
209 | ## Tests
210 | 
211 | ### 1.Key-Value Storgae Enginee
212 | 
213 | Insert element operation
214 | | 插入的数据规模(万条)| 耗费时间 |
215 | |---|---|
216 | | 1 | 0.0625142 |
217 | | 10| 0.688054  |
218 | | 15| 1.2213   |
219 | | 20| 1.77769   |
220 | | 50| 5.33906   |
221 | | 100| 11.5311  |
222 | 
223 | 每秒可以处理的写请求数目（QPS）：12.2819 W
224 | 
225 | Get element operation
226 | | 读取的数据规模(万条)| 耗费时间 |
227 | |---|---|
228 | | 1 | 0.0443168 |
229 | | 10| 0.96824  |
230 | | 15| 1.12037   |
231 | | 20| 1.17522   |
232 | | 50| 4.14332   |
233 | | 100| 9.7482  |
234 | 
235 | 每秒可以处理的读请求数目（QPS）：14.5819 W
236 | 
237 | ### 2.WebServer
238 | 
239 | 在关闭服务器日志之后，使用Webbench对服务器进行压力测试，对listen_fd和connection_fd分别采用ET或LT模式，均可以实现近万的并发连接以下列出组合后的测试结果
240 | 
241 | - Proactor，TRIGMode = 0, Listen_fd = LT, connection_fd = LT，QPS = 202927
242 |   ![TinyWebServer0](./resource/TinyWebServer0.png)
243 | - Proactor，TRIGMode = 1, Listen_fd = LT, connection_fd = ET, QPS = 216614
244 |   ![TinyWebServer1](./resource/TinyWebServer1.png)
245 | - Proactor，TRIGMode = 2, Listen_fd = ET, connection_fd = LT, QPS = 124588
246 |   ![TinyWebServer2](./resource/TinyWebServer2.png)
247 | - Proactor，TRIGMode = 3, Listen_fd = ET, connection_fd = ET, QPS = 180345
248 |   ![TinyWebServer3](./resource/TinyWebServer3.png)
249 | 
250 | ## Debug过程中的一些难点
251 |   
252 | - [x] 小的bug不多说
253 | - [x] 由于并发模型构建的不完善，seg implement了.看了游侠的高性能网络编程,并且在学会用GDB调试,随后解决线程安全问题
254 | - [x] 书上的http对大文件进行读取存在问题，在查阅资料和问了大佬之后得以修复
255 | 
256 | ~~~cpp
257 | // 原先代码
258 | bool http_conn::write()
259 | {
260 |     int temp=0;
261 |     int bytes_have_send=0;
262 |     int bytes_to_send=m_write_idx;
263 |     if(bytes_to_send==0)
264 |     {
265 |         modfd(m_epollfd,m_sockfd,EPOLLIN);
266 |         init();
267 |         return true;
268 |     }
269 |     while(1)
270 |     {
271 |         temp=writev(m_sockfd,m_iv,m_iv_count);
272 |         if(temp<=-1)
273 |         {
274 |             if(errno==EAGAIN)
275 |             {
276 |                 modfd(m_epollfd,m_sockfd,EPOLLOUT);
277 |                 return true;
278 |             }
279 |             unmap();
280 |             return false;
281 |         }
282 |         bytes_to_send-=temp;
283 |         bytes_have_send+=temp;
284 |         if(bytes_to_send<=bytes_have_send)
285 |         {
286 |             unmap();
287 |             if(m_linger)
288 |             {
289 |                 init();
290 |                 modfd(m_epollfd,m_sockfd,EPOLLIN);
291 |                 return true;
292 |             }
293 |             else
294 |             {
295 |                 modfd(m_epollfd,m_sockfd,EPOLLIN);
296 |                 return false;
297 |             }
298 |         }
299 |     }
300 | }
301 | 
302 | ~~~
303 | 
304 | ---
305 | 
306 | ~~~cpp
307 | // Debug
308 | bool http_conn::write()
309 | {
310 |     int temp = 0;
311 | 
312 |     int newadd = 0;
313 | 
314 |     if (bytes_to_send == 0)
315 |     {
316 |         modfd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
317 |         init();
318 |         return true;
319 |     }
320 | 
321 |     while (1)
322 |     {
323 |         temp = writev(m_sockfd, m_iv, m_iv_count);
324 | 
325 |         if (temp >= 0)
326 |         {
327 |             bytes_have_send += temp;
328 |             newadd = bytes_have_send - m_write_idx;
329 |         }
330 |         else
331 |         {
332 |             if (errno == EAGAIN)
333 |             {
334 |                 if (bytes_have_send >= m_iv[0].iov_len)
335 |                 {
336 |                     m_iv[0].iov_len = 0;
337 |                     m_iv[1].iov_base = m_file_address + newadd;
338 |                     m_iv[1].iov_len = bytes_to_send;
339 |                 }
340 |                 else
341 |                 {
342 |                     m_iv[0].iov_base = m_write_buf + bytes_have_send;
343 |                     m_iv[0].iov_len = m_iv[0].iov_len - bytes_have_send;
344 |                 }
345 |                 modfd(m_epollfd, m_sockfd, EPOLLOUT, m_TRIGMode);
346 |                 return true;
347 |             }
348 |             unmap();
349 |             return false;
350 |         }
351 |         bytes_to_send -= temp;
352 |         if (bytes_to_send <= 0)
353 |         {
354 |             unmap();
355 |             modfd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
356 | 
357 |             if (m_linger)
358 |             {
359 |                 init();
360 |                 return true;
361 |             }
362 |             else
363 |             {
364 |                 return false;
365 |             }
366 |         }
367 |     }
368 | }
369 | 
370 | 
371 | ~~~
372 | 


--------------------------------------------------------------------------------
/bin/skiplist_stress_test:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awei-lwj/TinyWebServer/093cd0177c119f26ec9105e48522b18e33090dec/bin/skiplist_stress_test


--------------------------------------------------------------------------------
/bin/skiplist_test:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awei-lwj/TinyWebServer/093cd0177c119f26ec9105e48522b18e33090dec/bin/skiplist_test


--------------------------------------------------------------------------------
/build.sh:
--------------------------------------------------------------------------------
1 | make server


--------------------------------------------------------------------------------
/config.cpp:
--------------------------------------------------------------------------------
 1 | #include "config.h"
 2 | 
 3 | Config::Config()
 4 | {
 5 |     port = 9096;
 6 | 
 7 |     LOGWrite = 0;   // the ways of writing in log
 8 | 
 9 |     TRIGMode = 0;    // listen fd LT + connection fd LT
10 |     LISTENTrigmode  = 0; // listen fd LT
11 |     CONNECTTrigmode = 0; // connect fd LT
12 | 
13 |     OPT_LINGER = 0;   
14 | 
15 |     sql_num    = 8;        // number of connections of sql
16 |     thread_num = 8;
17 | 
18 |     close_log   = 0;       // 1 close / 0 open
19 |     actor_model = 0;
20 | 
21 | }
22 | 
23 | void Config::parse_args(int argc, char *argv[])
24 | {
25 |     int opt;
26 | 
27 |     const char *str = "p:l:m:o:s:t:c:a:";
28 | 
29 |     while( (opt = getopt(argc,argv,str)) != -1 )
30 |     {
31 |         switch(opt)
32 |         {
33 |             case 'p':
34 |             {
35 |                 port = atoi(optarg);
36 |                 break;
37 |             }
38 | 
39 |             case 'l':
40 |             {
41 |                 LOGWrite = atoi(optarg);
42 |                 break;
43 |             }
44 | 
45 |             case 'm':
46 |             {
47 |                 TRIGMode = atoi(optarg);
48 |                 break;
49 |             }
50 | 
51 |             case 'o':
52 |             {
53 |                 OPT_LINGER = atoi(optarg);
54 |                 break;
55 |             }
56 | 
57 |             case 's':
58 |             {
59 |                 sql_num = atoi(optarg);
60 |                 break;
61 |             }
62 | 
63 |             case 't':
64 |             {
65 |                 thread_num = atoi(optarg);
66 |                 break;
67 |             }
68 | 
69 |             case 'c':
70 |             {
71 |                 close_log = atoi(optarg);
72 |                 break;
73 |             }
74 | 
75 |             case 'a':
76 |             {
77 |                 actor_model = atoi(optarg);
78 |                 break;
79 |             }
80 |             default:
81 |             {
82 |                 break;
83 |             }
84 | 
85 |         }
86 | 
87 |     }
88 | 
89 | }


--------------------------------------------------------------------------------
/config.h:
--------------------------------------------------------------------------------
 1 | #ifndef CONFIG_H
 2 | #define CONFIG_H
 3 | 
 4 | #include "webserver.h"
 5 | 
 6 | class Config
 7 | {
 8 | public:
 9 |     Config();
10 |     ~Config() {};
11 | 
12 |     void parse_args(int argc, char *argv[]);
13 | 
14 | public:
15 |     int port;         // port number
16 | 
17 |     int LOGWrite;     // log
18 | 
19 |     int TRIGMode;    // TRIG
20 | 
21 |     int LISTENTrigmode;   // listen fd mode
22 | 
23 |     int CONNECTTrigmode; // connect fd mode
24 | 
25 |     int OPT_LINGER;      // Closing the linger option
26 | 
27 |     int sql_num;       // the number of sql
28 | 
29 |     int thread_num;   // the number of threads
30 | 
31 |     int close_log;     // close the connection
32 |     
33 |     int actor_model;   // the actor model
34 | 
35 | };
36 | 
37 | 
38 | 
39 | 
40 | 
41 | 
42 | 
43 | 
44 | #endif  /* CONFIG_H */


--------------------------------------------------------------------------------
/http/http_conn.cpp:
--------------------------------------------------------------------------------
  1 | #include "http_conn.h"
  2 | 
  3 | #include <mysql/mysql.h>
  4 | #include <fstream>
  5 | 
  6 | // Define the the statement of the http response
  7 | const char *ok_200_title    = "OK";
  8 | 
  9 | const char *error_400_title = "Bad Request";
 10 | const char *error_400_form  = "Your request has bad syntax or is inherently impossible to satisfy.\n";
 11 | 
 12 | const char *error_403_title = "Forbidden";
 13 | const char *error_403_form  = "You do not have permission to get file form this server.\n";
 14 | 
 15 | const char *error_404_title = "Not Found";
 16 | const char *error_404_form  = "The requested file was not found on this server.\n";
 17 | 
 18 | const char *error_500_title = "Internal Error";
 19 | const char *error_500_form  = "There was an unusual problem serving the request file.\n";
 20 | 
 21 | locker m_lock;
 22 | map<string, string> users;
 23 | 
 24 | // *!* In this project, the epoll functions are including : \
 25 | // *!*Non-blocking, Register Events, Delete Events, Modify EPOLLONESHOT
 26 | 
 27 | // *!* The http connection is about Four parts:
 28 | // *!* 1. HTTP request receive
 29 | // *!* 2. Main/Slave statement machine to parse the HTTP request
 30 | // *!* 3. Generating the HTTP response
 31 | // *!* 4. MySql
 32 | 
 33 | // *!* HTTP request receive
 34 | // Setting the file descriptor as the unblocking model
 35 | int setnonblocking(int fd)
 36 | {
 37 |     int old_option = fcntl(fd, F_GETFL);
 38 |     int new_option = old_option | O_NONBLOCK;
 39 |     fcntl(fd, F_SETFL, new_option);
 40 |     return old_option;
 41 | }
 42 | 
 43 | // Registering the kernel event table with read events in ET mode, and select EPOLLONESHO
 44 | void add_fd(int epollfd, int fd, bool one_shot, int TRIGMode)
 45 | {
 46 |     epoll_event event;
 47 |     event.data.fd = fd;
 48 | 
 49 |     if (TRIGMode == 1)   // ET 
 50 |     {
 51 |         event.events = EPOLLIN | EPOLLET | EPOLLRDHUP;
 52 |     }
 53 |     else                // LT
 54 |     {
 55 |         event.events = EPOLLIN | EPOLLRDHUP;
 56 |     }
 57 |        
 58 | 
 59 |     if (one_shot)
 60 |     {
 61 |         event.events |= EPOLLONESHOT;
 62 |     }
 63 |         
 64 |     epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
 65 |     setnonblocking(fd);
 66 | }
 67 | 
 68 | // Deleting the file descriptor from the kernel time table
 69 | void remove_fd(int epollfd, int fd)
 70 | {
 71 |     epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, 0);
 72 |     close(fd);
 73 | }
 74 | 
 75 | // Setting the event flags as the EPOLLONESHOT flag
 76 | void mod_fd(int epollfd, int fd, int ev, int TRIGMode)
 77 | {
 78 |     epoll_event event;
 79 |     event.data.fd = fd;
 80 | 
 81 |     if ( TRIGMode == 1)   // ET
 82 |     {
 83 |         event.events = ev | EPOLLET | EPOLLONESHOT | EPOLLRDHUP;
 84 |     }
 85 |     else                 // LT
 86 |     {                
 87 |         event.events = ev | EPOLLONESHOT | EPOLLRDHUP;
 88 |     }
 89 |         
 90 |     epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &event);
 91 | 
 92 | }
 93 | 
 94 | // *!* Initialing the sql server
 95 | void Http_Conn::initmysql_result(Connection_Pool *connPool)
 96 | {
 97 |     // Getting a free connection from the pool
 98 |     MYSQL *mysql = NULL;
 99 |     Connection_RAII mysqlcon(&mysql, connPool);    // mysql connection
100 | 
101 |     // Username and password
102 |     if (mysql_query(mysql, "SELECT username,passwd FROM user"))
103 |     {
104 |         LOG_ERROR("SELECT error:%s\n", mysql_error(mysql));
105 |     }
106 | 
107 |     // Result
108 |     MYSQL_RES *result = mysql_store_result(mysql);
109 | 
110 |     // The lines of the result
111 |     int num_fields = mysql_num_fields(result);
112 | 
113 |     // the fields of the result
114 |     MYSQL_FIELD *fields = mysql_fetch_fields(result);
115 | 
116 |     // Insert it in the map
117 |     // TODO: Using the skiplist to storage the user and password
118 |     while (MYSQL_ROW row = mysql_fetch_row(result))
119 |     {
120 |         string tmp1(row[0]);
121 |         string tmp2(row[1]);
122 |         users[tmp1] = tmp2;
123 |     }
124 | }
125 | 
126 | int Http_Conn::m_user_cnt = 0;
127 | int Http_Conn::m_epollfd  = -1;
128 | 
129 | // Initializing the connection and Setting the check_state as default analyze requests line status
130 | void Http_Conn::init()
131 | {
132 |     mysql = NULL;
133 |     m_check_state = CHECK_STATE_REQUESTLINE;
134 |     cgi = 0;        
135 |     m_state    = 0;     // Read status
136 | 
137 |     // Timer
138 |     timer_flag = 0;
139 |     improv     = 0;
140 | 
141 |     bytes_to_send   = 0;
142 |     bytes_have_sent = 0;
143 | 
144 |     // HTTP
145 |     m_linger  = false;
146 |     m_method  = GET;
147 |     m_url     = 0;
148 |     m_version = 0;
149 |     m_content_length = 0;
150 |     m_host    = 0;
151 | 
152 |     // Read and Write
153 |     m_start_line    = 0;
154 |     m_checked_index = 0;
155 |     m_read_index    = 0;
156 |     m_write_index   = 0;
157 | 
158 |     // Buffer and File
159 |     memset(m_read_buf , '\0', READ_BUFFER_SIZE);
160 |     memset(m_write_buf, '\0', WRITE_BUFFER_SIZE);
161 |     memset(m_real_file, '\0', FILENAME_LEN);
162 | }
163 | 
164 | // Initializing the connection
165 | void Http_Conn::init(int sockfd, const sockaddr_in &addr, char *root, int TRIGMode,
166 |                      int close_log, string user, string passwd, string sqlname)
167 | {
168 |     m_sockfd  = sockfd;
169 |     m_address = addr;
170 | 
171 |     add_fd(m_epollfd, sockfd, true, m_TRIGMode);
172 |     m_user_cnt++;
173 | 
174 |     // Connection reset
175 |     doc_root = root;
176 |     m_TRIGMode = TRIGMode;
177 |     m_close_log = close_log;
178 | 
179 |     strcpy(sql_user  , user.c_str());       // user name
180 |     strcpy(sql_passwd, passwd.c_str());   // password
181 |     strcpy(sql_name  , sqlname.c_str());    // database
182 | 
183 |     init();
184 | 
185 | }
186 | 
187 | 
188 | // Closing a connection. the user count - 1;
189 | void Http_Conn::close_conn(bool real_close)
190 | {
191 |     if (real_close && (m_sockfd != -1))
192 |     {
193 |         printf("close %d\n", m_sockfd);
194 |         remove_fd(m_epollfd, m_sockfd);
195 |         m_sockfd = -1;
196 |         m_user_cnt--;
197 |     }
198 | }
199 | 
200 | // *!* Slave status machine
201 | // Dealing with a line data and Returning the status code of line data
202 | // Returning Line ok,line bad,line open
203 | Http_Conn::LINE_STATUS Http_Conn::parse_line()
204 | {
205 |     char temp;
206 |     for (; m_checked_index < m_read_index; ++m_checked_index)
207 |     {
208 |         temp = m_read_buf[m_checked_index]; // Dealing with a line
209 | 
210 |         if (temp == '\r')
211 |         {
212 |             if ((m_checked_index + 1) == m_read_index)
213 |             {
214 |                  return LINE_OPEN;
215 |             }
216 |             else if (m_read_buf[m_checked_index + 1] == '\n')
217 |             {
218 |                 m_read_buf[m_checked_index++] = '\0';
219 |                 m_read_buf[m_checked_index++] = '\0';
220 |                 return LINE_OK;
221 |             }
222 | 
223 |             // Error grammar parsing
224 |             return LINE_BAD;
225 |         }
226 |         else if (temp == '\n') // Getting the complete line
227 |         {
228 |             // If the last character is '\r', meaning that receiving the complete line
229 |             if (m_checked_index > 1 && m_read_buf[m_checked_index - 1] == '\r') 
230 |             {
231 |                 m_read_buf[m_checked_index - 1] = '\0';
232 |                 m_read_buf[m_checked_index++]   = '\0';
233 |                 return LINE_OK;
234 |             }
235 | 
236 |             // Error grammar
237 |             return LINE_BAD;
238 |         }
239 | 
240 |     }
241 | 
242 |     return LINE_OPEN;
243 | }
244 | 
245 | // Reading customer data circularly until no data is readable or the other party closes the connection
246 | bool Http_Conn::read_once()
247 | {
248 |     if (m_read_index >= READ_BUFFER_SIZE)
249 |     {
250 |         return false;
251 |     }
252 | 
253 |     int bytes_read = 0;
254 | 
255 |     // LT
256 |     if (m_TRIGMode == 0)
257 |     {
258 |         bytes_read = recv(m_sockfd, m_read_buf + m_read_index, READ_BUFFER_SIZE - m_read_index, 0);
259 |         m_read_index += bytes_read;
260 | 
261 |         if (bytes_read <= 0)
262 |         {
263 |             return false;
264 |         }
265 | 
266 |         return true;
267 |     }
268 |     else // ET
269 |     {
270 |         while (true)
271 |         {
272 |             // Reading the data from the socket and storing it in the m_read_buffer
273 |             bytes_read = recv(m_sockfd, m_read_buf + m_read_index, READ_BUFFER_SIZE - m_read_index, 0);
274 | 
275 |             if (bytes_read == -1)
276 |             {
277 |                 if (errno == EAGAIN || errno == EWOULDBLOCK)
278 |                 {
279 |                     break;
280 |                 }
281 |                     
282 |                 return false;
283 |             }
284 |             else if (bytes_read == 0)
285 |             {
286 |                 return false;
287 |             }
288 | 
289 |             m_read_index += bytes_read;
290 |         }
291 | 
292 |         return true;
293 | 
294 |     }
295 | 
296 | }
297 | 
298 | // *!* Main statement machine function
299 | // Parsing the http request line,getting the method,url and http version
300 | Http_Conn::HTTP_CODE Http_Conn::parse_request_line(char *text)
301 | {
302 |     // In the HTTP message, the request line is used to specify the request type, \
303 |     // the resources to be accessed, and the HTTP version used. \
304 |     // Each part is separated by t or a space.
305 | 
306 |     // Getting the url
307 |     m_url = strpbrk(text, " \t");
308 | 
309 |     // Error grammar
310 |     if (!m_url)
311 |     {
312 |         return BAD_REQUEST;
313 |     }
314 | 
315 |     *m_url++ = '\0';
316 | 
317 |     // Getting the data to compare Get and Post methods for ensuring the method
318 |     char *method = text;
319 |     if (strcasecmp(method, "GET") == 0)
320 |     {
321 |         m_method = GET;
322 |     }
323 |     else if (strcasecmp(method, "POST") == 0)
324 |     {
325 |         m_method = POST;
326 |         cgi = 1;
327 |     }
328 |     else
329 |     {
330 |         // Error grammar
331 |         return BAD_REQUEST;
332 |     }
333 | 
334 |     // Passing the space and '\t'
335 |     m_url += strspn(m_url, " \t");
336 | 
337 |     // Getting the version
338 |     m_version = strpbrk(m_url, " \t");
339 |     if (!m_version)
340 |     {
341 |         // Error grammar
342 |         return BAD_REQUEST;
343 |     }
344 | 
345 |     // Passing the space and '\t'
346 |     *m_version++ = '\0';
347 |     m_version += strspn(m_version, " \t");
348 | 
349 |     // Only supporting HTTP 1.1
350 |     if (strcasecmp(m_version, "HTTP/1.1") != 0)
351 |     {
352 |         // Error grammar
353 |         return BAD_REQUEST;
354 |     }
355 | 
356 |     // Dealing with "http://" and "https://"
357 |     if (strncasecmp(m_url, "http://", 7) == 0)
358 |     {
359 |         m_url += 7;
360 |         m_url = strchr(m_url, '/');
361 |     }
362 | 
363 |     if (strncasecmp(m_url, "https://", 8) == 0)
364 |     {
365 |         m_url += 8;
366 |         m_url = strchr(m_url, '/');
367 |     }
368 | 
369 |     if (!m_url || m_url[0] != '/')
370 |     {
371 |         return BAD_REQUEST;
372 |     }
373 |         
374 |     // Showing the judge.html when the m_url is '/'
375 |     if (strlen(m_url) == 1)
376 |     {
377 |         strcat(m_url, "judge.html");
378 |     }
379 |         
380 |     m_check_state = CHECK_STATE_HEADER;
381 |     return NO_REQUEST;
382 | }
383 | 
384 | // Parsing the header line of HTTP request
385 | Http_Conn::HTTP_CODE Http_Conn::parse_headers(char *text)
386 | {
387 |     // Judging null or Get and Post headers
388 |     if (text[0] == '\0')
389 |     {
390 |         // Get or Post headers
391 |         if (m_content_length != 0)
392 |         {
393 |             m_check_state = CHECK_STATE_CONTENT;
394 |             return NO_REQUEST;
395 |         }
396 | 
397 |         return GET_REQUEST;
398 |     }
399 |     else if (strncasecmp(text, "Connection:", 11) == 0) // Parsing the connection part of headers
400 |     {
401 |         text += 11;
402 |         text += strspn(text, " \t");
403 | 
404 |         if (strcasecmp(text, "keep-alive") == 0)
405 |         {
406 |             m_linger = true;
407 |         }
408 |     }
409 |     else if (strncasecmp(text, "Content-length:", 15) == 0) // Content-Length
410 |     {
411 |         text += 15;
412 |         text += strspn(text, " \t");
413 |         m_content_length = atol(text);
414 |     }
415 |     else if (strncasecmp(text, "Host:", 5) == 0)   // Host
416 |     {
417 |         text += 5;
418 |         text += strspn(text, " \t");
419 |         m_host = text;
420 |     }
421 |     else  // Error
422 |     {
423 |         LOG_INFO("oop!unknow header: %s", text);
424 |     }
425 | 
426 | 
427 |     return NO_REQUEST;
428 | }
429 | 
430 | // parse contents
431 | // Judging the HTTP request content completion
432 | Http_Conn::HTTP_CODE Http_Conn::parse_content(char *text)
433 | {
434 |     if (m_read_index >= (m_content_length + m_checked_index))
435 |     {
436 |         text[m_content_length] = '\0';
437 | 
438 |         // The last part of the Post request is Username and password
439 |         m_string = text;
440 | 
441 |         return GET_REQUEST;
442 |     }
443 | 
444 |     return NO_REQUEST;
445 | }
446 | 
447 | // *!* Server thread
448 | Http_Conn::HTTP_CODE Http_Conn::process_read()
449 | {
450 |     LINE_STATUS line_status = LINE_OK;
451 |     HTTP_CODE ret = NO_REQUEST;
452 |     char *text = 0;
453 | 
454 |     while ((m_check_state == CHECK_STATE_CONTENT && line_status == LINE_OK) || ((line_status = parse_line()) == LINE_OK))
455 |     {
456 |         text = get_line();
457 |         m_start_line = m_checked_index;
458 |         LOG_INFO("%s", text);
459 |         switch (m_check_state)
460 |         {
461 |         case CHECK_STATE_REQUESTLINE:
462 |         {
463 |             ret = parse_request_line(text);
464 |             if (ret == BAD_REQUEST)
465 |                 return BAD_REQUEST;
466 |             break;
467 |         }
468 |         case CHECK_STATE_HEADER:
469 |         {
470 |             ret = parse_headers(text);
471 |             if (ret == BAD_REQUEST)
472 |                 return BAD_REQUEST;
473 |             else if (ret == GET_REQUEST)
474 |             {
475 |                 return do_request();
476 |             }
477 |             break;
478 |         }
479 |         case CHECK_STATE_CONTENT:
480 |         {
481 |             ret = parse_content(text);
482 |             if (ret == GET_REQUEST)
483 |                 return do_request();
484 |             line_status = LINE_OPEN;
485 |             break;
486 |         }
487 |         default:
488 |             return INTERNAL_ERROR;
489 |         }
490 |     }
491 |     return NO_REQUEST;
492 | }
493 | 
494 | Http_Conn::HTTP_CODE Http_Conn::do_request()
495 | {
496 |     strcpy(m_real_file, doc_root);
497 |     int len = strlen(doc_root);
498 |     //printf("m_url:%s\n", m_url);
499 |     const char *p = strrchr(m_url, '/');
500 | 
501 |     //处理cgi
502 |     if (cgi == 1 && (*(p + 1) == '2' || *(p + 1) == '3'))
503 |     {
504 | 
505 |         //根据标志判断是登录检测还是注册检测
506 |         char flag = m_url[1];
507 | 
508 |         char *m_url_real = (char *)malloc(sizeof(char) * 200);
509 |         strcpy(m_url_real, "/");
510 |         strcat(m_url_real, m_url + 2);
511 |         strncpy(m_real_file + len, m_url_real, FILENAME_LEN - len - 1);
512 |         free(m_url_real);
513 | 
514 |         //将用户名和密码提取出来
515 |         //user=123&passwd=123
516 |         char name[100], password[100];
517 |         int i;
518 |         for (i = 5; m_string[i] != '&'; ++i)
519 |             name[i - 5] = m_string[i];
520 |         name[i - 5] = '\0';
521 | 
522 |         int j = 0;
523 |         for (i = i + 10; m_string[i] != '\0'; ++i, ++j)
524 |             password[j] = m_string[i];
525 |         password[j] = '\0';
526 | 
527 |         if (*(p + 1) == '3')
528 |         {
529 |             //如果是注册，先检测数据库中是否有重名的
530 |             //没有重名的，进行增加数据
531 |             char *sql_insert = (char *)malloc(sizeof(char) * 200);
532 |             strcpy(sql_insert, "INSERT INTO user(username, passwd) VALUES(");
533 |             strcat(sql_insert, "'");
534 |             strcat(sql_insert, name);
535 |             strcat(sql_insert, "', '");
536 |             strcat(sql_insert, password);
537 |             strcat(sql_insert, "')");
538 | 
539 |             if (users.find(name) == users.end())
540 |             {
541 |                 m_lock.lock();
542 |                 int res = mysql_query(mysql, sql_insert);
543 |                 users.insert(pair<string, string>(name, password));
544 |                 m_lock.unlock();
545 | 
546 |                 if (!res)
547 |                     strcpy(m_url, "/log.html");
548 |                 else
549 |                     strcpy(m_url, "/registerError.html");
550 |             }
551 |             else
552 |                 strcpy(m_url, "/registerError.html");
553 |         }
554 |         //如果是登录，直接判断
555 |         //若浏览器端输入的用户名和密码在表中可以查找到，返回1，否则返回0
556 |         else if (*(p + 1) == '2')
557 |         {
558 |             if (users.find(name) != users.end() && users[name] == password)
559 |                 strcpy(m_url, "/welcome.html");
560 |             else
561 |                 strcpy(m_url, "/logError.html");
562 |         }
563 |     }
564 | 
565 |     if (*(p + 1) == '0')
566 |     {
567 |         char *m_url_real = (char *)malloc(sizeof(char) * 200);
568 |         strcpy(m_url_real, "/register.html");
569 |         strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
570 | 
571 |         free(m_url_real);
572 |     }
573 |     else if (*(p + 1) == '1')
574 |     {
575 |         char *m_url_real = (char *)malloc(sizeof(char) * 200);
576 |         strcpy(m_url_real, "/log.html");
577 |         strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
578 | 
579 |         free(m_url_real);
580 |     }
581 |     else if (*(p + 1) == '5')
582 |     {
583 |         char *m_url_real = (char *)malloc(sizeof(char) * 200);
584 |         strcpy(m_url_real, "/picture.html");
585 |         strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
586 | 
587 |         free(m_url_real);
588 |     }
589 |     else if (*(p + 1) == '6')
590 |     {
591 |         char *m_url_real = (char *)malloc(sizeof(char) * 200);
592 |         strcpy(m_url_real, "/video.html");
593 |         strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
594 | 
595 |         free(m_url_real);
596 |     }
597 |     else if (*(p + 1) == '7')
598 |     {
599 |         char *m_url_real = (char *)malloc(sizeof(char) * 200);
600 |         strcpy(m_url_real, "/awei.html");
601 |         strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
602 | 
603 |         free(m_url_real);
604 |     }
605 |     else
606 |         strncpy(m_real_file + len, m_url, FILENAME_LEN - len - 1);
607 | 
608 |     if (stat(m_real_file, &m_file_stat) < 0)
609 |         return NO_RESOURCE;
610 | 
611 |     if (!(m_file_stat.st_mode & S_IROTH))
612 |         return FORBIDDEN_REQUEST;
613 | 
614 |     if (S_ISDIR(m_file_stat.st_mode))
615 |         return BAD_REQUEST;
616 | 
617 |     int fd = open(m_real_file, O_RDONLY);
618 |     m_file_address = (char *)mmap(0, m_file_stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
619 |     close(fd);
620 |     return FILE_REQUEST;
621 | }
622 | void Http_Conn::unmap()
623 | {
624 |     if (m_file_address)
625 |     {
626 |         munmap(m_file_address, m_file_stat.st_size);
627 |         m_file_address = 0;
628 |     }
629 | }
630 | bool Http_Conn::write()
631 | {
632 |     int temp = 0;
633 | 
634 |     if (bytes_to_send == 0)
635 |     {
636 |         mod_fd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
637 |         init();
638 |         return true;
639 |     }
640 | 
641 |     while (1)
642 |     {
643 |         temp = writev(m_sockfd, m_file_iov, m_file_iov_cnt);
644 | 
645 |         if (temp < 0)
646 |         {
647 |             if (errno == EAGAIN)
648 |             {
649 |                 mod_fd(m_epollfd, m_sockfd, EPOLLOUT, m_TRIGMode);
650 |                 return true;
651 |             }
652 |             
653 |             unmap();
654 |             return false;
655 |         }
656 | 
657 |         bytes_have_sent += temp;
658 |         bytes_to_send -= temp;
659 | 
660 |         if (bytes_have_sent >= m_file_iov[0].iov_len)
661 |         {
662 |             m_file_iov[0].iov_len  = 0;
663 |             m_file_iov[1].iov_base = m_file_address + (bytes_have_sent - m_write_index);
664 |             m_file_iov[1].iov_len  = bytes_to_send;
665 |         }
666 |         else
667 |         {
668 |             m_file_iov[0].iov_base = m_write_buf + bytes_have_sent;
669 |             m_file_iov[0].iov_len  = m_file_iov[0].iov_len - bytes_have_sent;
670 |         }
671 | 
672 |         if (bytes_to_send <= 0)
673 |         {
674 |             unmap();
675 |             mod_fd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
676 | 
677 |             if (m_linger)
678 |             {
679 |                 init();
680 |                 return true;
681 |             }
682 |             else
683 |             {
684 |                 return false;
685 |             }
686 |         }
687 |     }
688 | }
689 | 
690 | // *!*  Generating 8 corresponding parts based on the format of the request message
691 | bool Http_Conn::add_response(const char *format, ...)
692 | {
693 |     if (m_write_index >= WRITE_BUFFER_SIZE)
694 |         return false;
695 | 
696 |     va_list arg_list;
697 |     va_start(arg_list, format);
698 | 
699 |     int len = vsnprintf(m_write_buf + m_write_index, WRITE_BUFFER_SIZE - 1 - m_write_index, format, arg_list);
700 |     
701 |     if (len >= (WRITE_BUFFER_SIZE - 1 - m_write_index))
702 |     {
703 |         va_end(arg_list);
704 |         return false;
705 |     }
706 | 
707 |     m_write_index += len;
708 |     va_end(arg_list);
709 | 
710 |     LOG_INFO("request:%s", m_write_buf);
711 | 
712 |     return true;
713 | }
714 | 
715 | bool Http_Conn::add_status_line(int status, const char *title)
716 | {
717 |     return add_response("%s %d %s\r\n", "HTTP/1.1", status, title);
718 | }
719 | 
720 | bool Http_Conn::add_headers(int content_len)
721 | {
722 |     return add_content_length(content_len) && add_linger() &&
723 |            add_blank_line();
724 | }
725 | 
726 | bool Http_Conn::add_content_length(int content_len)
727 | {
728 |     return add_response("Content-Length:%d\r\n", content_len);
729 | }
730 | 
731 | bool Http_Conn::add_content_type()
732 | {
733 |     return add_response("Content-Type:%s\r\n", "text/html");
734 | }
735 | 
736 | bool Http_Conn::add_linger()
737 | {
738 |     return add_response("Connection:%s\r\n", (m_linger == true) ? "keep-alive" : "close");
739 | }
740 | 
741 | bool Http_Conn::add_blank_line()
742 | {
743 |     return add_response("%s", "\r\n");
744 | }
745 | 
746 | bool Http_Conn::add_content(const char *content)
747 | {
748 |     return add_response("%s", content);
749 | }
750 | 
751 | bool Http_Conn::process_write(HTTP_CODE ret)
752 | {
753 |     switch (ret)
754 |     {
755 |     case INTERNAL_ERROR:
756 |     {
757 |         add_status_line(500, error_500_title);
758 |         add_headers(strlen(error_500_form));
759 | 
760 |         if (!add_content(error_500_form))
761 |         {
762 |             return false;
763 |         }
764 |             
765 |         break;
766 |     }
767 |     case BAD_REQUEST:
768 |     {
769 |         add_status_line(404, error_404_title);
770 |         add_headers(strlen(error_404_form));
771 | 
772 |         if (!add_content(error_404_form))
773 |         {
774 |             return false;
775 |         }
776 |             
777 |         break;
778 |     }
779 | 
780 |     case FORBIDDEN_REQUEST:
781 |     {
782 |         add_status_line(403, error_403_title);
783 |         add_headers(strlen(error_403_form));
784 | 
785 |         if (!add_content(error_403_form))
786 |         {
787 |             return false;
788 |         }
789 |             
790 |         break;
791 |     }
792 | 
793 |     case FILE_REQUEST:
794 |     {
795 |         add_status_line(200, ok_200_title);
796 |         if (m_file_stat.st_size != 0)
797 |         {
798 |             add_headers(m_file_stat.st_size);
799 | 
800 |             m_file_iov[0].iov_base = m_write_buf;
801 |             m_file_iov[0].iov_len  = m_write_index;
802 |             m_file_iov[1].iov_base = m_file_address;
803 |             m_file_iov[1].iov_len  = m_file_stat.st_size;
804 |             m_file_iov_cnt = 2;
805 | 
806 |             bytes_to_send = m_write_index + m_file_stat.st_size;
807 |             return true;
808 |         }
809 |         else
810 |         {
811 |             const char *ok_string = "<html><body></body></html>";
812 |             add_headers(strlen(ok_string));
813 |             if (!add_content(ok_string))
814 |                 return false;
815 |         }
816 | 
817 |     }
818 | 
819 |     default:
820 |         return false;
821 |     }
822 | 
823 |     m_file_iov[0].iov_base = m_write_buf;
824 |     m_file_iov[0].iov_len  = m_write_index;
825 |     m_file_iov_cnt         = 1;
826 | 
827 |     bytes_to_send = m_write_index;
828 |     return true;
829 | }
830 | 
831 | 
832 | void Http_Conn::process()
833 | {
834 |     HTTP_CODE read_ret = process_read();
835 | 
836 |     if (read_ret == NO_REQUEST)
837 |     {
838 |         mod_fd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
839 |         return;
840 |     }
841 | 
842 |     bool write_ret = process_write(read_ret);
843 | 
844 |     if (!write_ret)
845 |     {
846 |         close_conn();
847 |     }
848 | 
849 |     mod_fd(m_epollfd, m_sockfd, EPOLLOUT, m_TRIGMode);
850 | }
851 | 


--------------------------------------------------------------------------------
/http/http_conn.h:
--------------------------------------------------------------------------------
  1 | #ifndef HTTPCONNECTION_H
  2 | #define HTTPCONNECTION_H
  3 | 
  4 | #include <unistd.h>
  5 | #include <signal.h>
  6 | #include <sys/types.h>
  7 | #include <sys/epoll.h>
  8 | #include <fcntl.h>
  9 | #include <sys/socket.h>
 10 | #include <netinet/in.h>
 11 | #include <arpa/inet.h>
 12 | #include <assert.h>
 13 | #include <sys/stat.h>
 14 | #include <string.h>
 15 | #include <pthread.h>
 16 | #include <stdio.h>
 17 | #include <stdlib.h>
 18 | #include <sys/mman.h>
 19 | #include <stdarg.h>
 20 | #include <errno.h>
 21 | #include <sys/wait.h>
 22 | #include <sys/uio.h>
 23 | #include <map>
 24 | 
 25 | #include "../locker/locker.h"
 26 | #include "../CGImysql/sql_connection_pool.h"
 27 | #include "../timer/list_timer.h"
 28 | #include "../log/log.h"
 29 | 
 30 | class Http_Conn
 31 | {
 32 | public:
 33 |     static const int FILENAME_LEN = 200;
 34 | 
 35 |     // The size of buffer in Read and Write
 36 |     static const int READ_BUFFER_SIZE = 2048;
 37 |     static const int WRITE_BUFFER_SIZE = 1024;
 38 |     enum METHOD
 39 |     {
 40 |         GET = 0,
 41 |         POST,
 42 |         HEAD,
 43 |         PUT,
 44 |         DELETE,
 45 |         TRACE,
 46 |         OPTIONS,
 47 |         CONNECT,
 48 |         PATH
 49 |     };
 50 | 
 51 |     enum CHECK_STATE
 52 |     {
 53 |         CHECK_STATE_REQUESTLINE = 0,
 54 |         CHECK_STATE_HEADER,
 55 |         CHECK_STATE_CONTENT
 56 |     };
 57 | 
 58 |     enum HTTP_CODE
 59 |     {
 60 |         NO_REQUEST,
 61 |         GET_REQUEST,
 62 |         BAD_REQUEST,
 63 |         NO_RESOURCE,
 64 |         FORBIDDEN_REQUEST,
 65 |         FILE_REQUEST,
 66 |         INTERNAL_ERROR,
 67 |         CLOSED_CONNECTION
 68 |     };
 69 | 
 70 |     enum LINE_STATUS
 71 |     {
 72 |         LINE_OK = 0,
 73 |         LINE_BAD,
 74 |         LINE_OPEN
 75 |     };
 76 | 
 77 | public:
 78 |     Http_Conn() {}
 79 |     ~Http_Conn() {}
 80 | 
 81 | public:
 82 | 
 83 |     // MYSQL
 84 |     void init(int sockfd, const sockaddr_in &addr, char *, int, int, string user, 
 85 |     string passwd, string sqlname);
 86 | 
 87 |     // Closing the connection
 88 |     void close_conn(bool real_close = true);
 89 | 
 90 |     void process();
 91 | 
 92 |     bool read_once(); // Read  all data from the browser connection
 93 | 
 94 |     bool write();  // Writing the request data
 95 | 
 96 |     sockaddr_in *get_address()
 97 |     {
 98 |         return &m_address;
 99 |     }
100 | 
101 |     // Synchronization thread initializes database reading table
102 |     void initmysql_result(Connection_Pool *connPool); 
103 | 
104 |     int timer_flag; // Timer flag
105 |     int improv;
106 | 
107 | 
108 | private:
109 |     void init();
110 | 
111 |     // Read and Write
112 |     HTTP_CODE process_read();    // Reading data from the reader buffer and dealing with request
113 |     bool process_write(HTTP_CODE ret);  // Writing the request data in the writer buffer
114 | 
115 |     // Main state machine processing message
116 |     HTTP_CODE parse_request_line(char *text);
117 |     HTTP_CODE parse_headers(char *text);
118 |     HTTP_CODE parse_content(char *text);
119 |     HTTP_CODE do_request();
120 | 
121 |     char *get_line() { return m_read_buf + m_start_line; };
122 | 
123 |     // Parsing the part of the request message
124 |     LINE_STATUS parse_line();
125 | 
126 |     void unmap();
127 | 
128 |     // Generating 8 corresponding parts based on the format of the request message
129 |     // All of them are calling the do_request method
130 |     bool add_response(const char *format, ...);
131 |     bool add_content(const char *content);
132 |     bool add_status_line(int status, const char *title);
133 |     bool add_headers(int content_length);
134 |     bool add_content_type();
135 |     bool add_content_length(int content_length);
136 |     bool add_linger();
137 |     bool add_blank_line();
138 | 
139 | public:
140 |     static int m_epollfd;
141 |     static int m_user_cnt;
142 | 
143 |     MYSQL *mysql;
144 |     int m_state;  // Read = 0 / Write = 1
145 | 
146 | private:
147 |     int m_sockfd;      // Socket fd
148 |     sockaddr_in m_address; // Socket address
149 | 
150 |     // Read
151 |     char m_read_buf[READ_BUFFER_SIZE];
152 |     int m_read_index;    // Index of the last pointer in the read buffer
153 |     int m_checked_index;
154 |     int m_start_line;
155 | 
156 |     // Write
157 |     char m_write_buf[WRITE_BUFFER_SIZE];
158 |     int m_write_index;
159 | 
160 |     // Main statement machine
161 |     CHECK_STATE m_check_state;
162 |     METHOD m_method;
163 | 
164 |     // Dealing the request message
165 |     // Storing the name of the read file
166 |     char m_real_file[FILENAME_LEN];
167 |     char *m_url;
168 |     char *m_version;
169 |     char *m_host;
170 |     int m_content_length;
171 |     bool m_linger;
172 | 
173 |     // File
174 |     char *m_file_address;
175 |     struct stat m_file_stat;
176 |     struct iovec m_file_iov[2];
177 |     int m_file_iov_cnt;
178 |     int cgi;                   // POST
179 |     char *m_string;            // header data
180 | 
181 | 
182 |     int bytes_to_send;
183 |     int bytes_have_sent;
184 | 
185 |     // LOG
186 |     char *doc_root;   
187 |     int m_TRIGMode;
188 |     int m_close_log;
189 | 
190 |     // SQL
191 |     map<string, string> m_users;
192 |     char sql_user[100];
193 |     char sql_passwd[100];
194 |     char sql_name[100];
195 | };
196 | 
197 | #endif
198 | 
199 | 


--------------------------------------------------------------------------------
/locker/locker.h:
--------------------------------------------------------------------------------
  1 | #ifndef LOCKER_H
  2 | #define LOCKER_H
  3 | 
  4 | #include <exception>
  5 | #include <pthread.h>
  6 | #include <semaphore.h>
  7 | 
  8 | // RAII: Resource Acquisition is Initialization
  9 | 
 10 | // TODO: Class MutexLockGuard
 11 | 
 12 | class sem     // semaphore
 13 | {
 14 | public:
 15 |     sem()
 16 |     {
 17 |         if( sem_init(&m_sem, 0,0) != 0)
 18 |         {
 19 |             throw std::exception();
 20 |         }
 21 |     }
 22 | 
 23 |     sem(int num)
 24 |     {
 25 |         if( sem_init(&m_sem, 0, num)!= 0)
 26 |         {
 27 |             throw std::exception();
 28 |         }
 29 |     }
 30 | 
 31 |     ~sem()
 32 |     {
 33 |         sem_destroy(&m_sem);
 34 |     }
 35 | 
 36 |     bool wait()   // P operation
 37 |     {
 38 |         return sem_wait(&m_sem) == 0;
 39 |     }
 40 | 
 41 |     bool post() // V operation
 42 |     {
 43 |         return sem_post(&m_sem) == 0;
 44 |     }
 45 | 
 46 | private:
 47 |     sem_t m_sem;
 48 | 
 49 | };
 50 | 
 51 | class locker    // locker for process synchronization/mutual exclusion mechanism
 52 | {
 53 | public:
 54 |     locker()
 55 |     {
 56 |         if( pthread_mutex_init(&m_mutex, NULL)!= 0)
 57 |         {
 58 |             throw std::exception();
 59 |         }
 60 |     };
 61 | 
 62 |     ~locker()
 63 |     {
 64 |         pthread_mutex_destroy(&m_mutex);
 65 |     };
 66 | 
 67 |     bool lock()
 68 |     {
 69 |         return pthread_mutex_lock(&m_mutex) == 0;
 70 |     }
 71 | 
 72 |     bool unlock()
 73 |     {
 74 |         return pthread_mutex_unlock(&m_mutex) == 0;
 75 |     }
 76 | 
 77 |     pthread_mutex_t *get()
 78 |     {
 79 |         return &m_mutex;
 80 |     }
 81 | 
 82 | private:
 83 |     pthread_mutex_t m_mutex;  // mutex locker
 84 | 
 85 | };
 86 | 
 87 | 
 88 | 
 89 | class cond   // Conditional variable is used in the monitor
 90 | {
 91 | public:
 92 |     cond()
 93 |     {
 94 |         if( pthread_cond_init(&m_cond, NULL)!= 0)
 95 |         {
 96 |             throw std::exception();
 97 |         }
 98 |     };
 99 | 
100 |     ~cond()
101 |     {
102 |         pthread_cond_destroy(&m_cond);
103 |     }
104 | 
105 |     bool wait(pthread_mutex_t *m_mutex)
106 |     {
107 |         int ret = 0;
108 | 
109 |         // pthread_mutex_lock(&m_mutex);
110 |         ret = pthread_cond_wait(&m_cond,m_mutex);
111 |         // pthread_mutex_unlock(&m_mutex);
112 | 
113 |         return ret == 0;
114 |     }
115 | 
116 |     bool timewait(pthread_mutex_t *m_mutex, struct timespec t)
117 |     {
118 | 
119 |         int ret = 0;
120 | 
121 |         // pthread_mutex_lock(&m_mutex);
122 |         ret = pthread_cond_timedwait(&m_cond,m_mutex,&t);
123 |         // pthread_mutex_unlock(&m_mutex);
124 | 
125 |         return ret == 0;
126 | 
127 |     }
128 | 
129 |     bool signal()
130 |     {
131 |         return pthread_cond_signal(&m_cond) == 0;
132 |     }
133 | 
134 |     bool broadcast()
135 |     {
136 |         return pthread_cond_broadcast(&m_cond) == 0;
137 |     }
138 | 
139 |     
140 | private:
141 |     pthread_cond_t m_cond; 
142 |     // static pthread_mutex_t m_mutex;
143 | 
144 | };
145 | 
146 | 
147 | #endif // LOCKER_H


--------------------------------------------------------------------------------
/log/block_queue.h:
--------------------------------------------------------------------------------
  1 | #ifndef BLOCK_QUEUE_H
  2 | #define BLOCK_QUEUE_H
  3 | 
  4 | #include <iostream>
  5 | #include <stdlib.h>
  6 | #include <pthread.h>
  7 | #include <sys/time.h>
  8 | 
  9 | #include "../locker/locker.h"
 10 | 
 11 | using namespace std;
 12 | 
 13 | // Producers and Consumers model
 14 | template<class T>
 15 | class Block_Queue
 16 | {
 17 | public:
 18 |     Block_Queue(int max_size = 1000)
 19 |     {
 20 |         if( max_size <= 0 )
 21 |         {
 22 |             exit(-1);
 23 |         }
 24 | 
 25 |         // Creating a circular array
 26 |         m_max_size = max_size;
 27 |         m_array    = new T[max_size];
 28 |         m_size     = 0;
 29 |         m_front    = -1;
 30 |         m_back     = -1;
 31 | 
 32 |     }
 33 | 
 34 |     void clear()
 35 |     {
 36 |         m_mutex.lock();
 37 | 
 38 |         m_size  = 0;
 39 |         m_front = -1;
 40 |         m_back  = -1;
 41 | 
 42 |         m_mutex.unlock();
 43 | 
 44 |     }
 45 | 
 46 |     ~Block_Queue()
 47 |     {
 48 |         m_mutex.lock();
 49 |         if( m_array != NULL )
 50 |         {
 51 |             delete[] m_array;
 52 |         }
 53 |         m_mutex.unlock();
 54 |     }
 55 | 
 56 |     bool full()
 57 |     {
 58 |         m_mutex.lock();
 59 |         if( m_size >= m_max_size )
 60 |         {
 61 |             m_mutex.unlock();
 62 |             return true;
 63 |         }
 64 | 
 65 |         m_mutex.unlock();
 66 |         return false;
 67 | 
 68 |     }
 69 | 
 70 |     bool empty()
 71 |     {
 72 |         m_mutex.lock();
 73 |         if( m_size == 0 )
 74 |         {
 75 |             m_mutex.unlock();
 76 |             return true;
 77 |         }
 78 | 
 79 |         m_mutex.unlock();
 80 |         return false;
 81 |     }
 82 | 
 83 |     // Returning the front element
 84 |     bool front(T &value)
 85 |     {
 86 |         m_mutex.lock();
 87 |         if( m_size == 0 )
 88 |         {
 89 |             m_mutex.unlock();
 90 |             return false;
 91 |         }
 92 | 
 93 |         value = m_array[m_front];
 94 |         m_mutex.unlock();
 95 |         return true;
 96 |     }
 97 | 
 98 |     // Returning the back element
 99 |     bool back(T &value)
100 |     {
101 |         m_mutex.lock();
102 |         if( m_size == 0 )
103 |         {
104 |             m_mutex.unlock();
105 |             return false;
106 |         }
107 |         value = m_array[m_back];
108 |         m_mutex.unlock();
109 |         return true;
110 |     }
111 | 
112 |     // Returning the size of the queue
113 |     int size()
114 |     {
115 |         int tmp = 0;
116 | 
117 |         m_mutex.lock();
118 |         tmp = m_size;
119 | 
120 |         m_mutex.unlock();
121 | 
122 |         return tmp;
123 |     }
124 | 
125 |     // Returning the maximum size of the queue
126 |     int max_size()
127 |     {
128 |         int tmp = 0;
129 |         m_mutex.lock();
130 |         tmp = m_max_size;
131 | 
132 |         m_mutex.unlock();
133 | 
134 |         return tmp;
135 |     }
136 | 
137 | 
138 |     // Adding the element in the queue
139 |     // Producing and Creating model
140 |     bool push(const T &item)
141 |     {
142 |         m_mutex.lock();
143 |         if( m_size >= m_max_size )
144 |         { 
145 |             m_cond.broadcast();
146 |             m_mutex.unlock();
147 |             return false;
148 |         }
149 | 
150 |         m_back = ( m_back + 1 ) % m_max_size;
151 |         m_array[m_back] = item;
152 | 
153 |         m_size++;
154 |         
155 |         m_cond.broadcast();
156 |         m_mutex.unlock();
157 | 
158 |         return true;
159 |     }
160 | 
161 |     // Popping the element
162 |     // Producer and Consumer model
163 |     bool pop(T &item)
164 |     {
165 |         m_mutex.lock();
166 |         while( m_size <= 0 )
167 |         {
168 |             if( !m_cond.wait( m_mutex.get() ) )
169 |             {
170 |                 m_mutex.unlock();
171 |                 return false;
172 |             }
173 | 
174 |         }
175 | 
176 |         m_front = ( m_front + 1 ) % m_max_size;
177 |         item = m_array[m_front];
178 |         m_size--;
179 | 
180 |         m_mutex.unlock();
181 |         return true;
182 |     }
183 | 
184 |     // Adding the function of timeout handler
185 |     bool pop(T &item, int ms_timeout)
186 |     {
187 |         struct timespec  t  = {0,0};
188 |         struct timeval  now = {0,0};
189 | 
190 |         gettimeofday(&now, NULL);
191 |         
192 |         m_mutex.lock();
193 |         if( m_size <= 0 )
194 |         {
195 |             t.tv_sec  = now.tv_sec + ms_timeout/1000;
196 |             t.tv_nsec = (ms_timeout % 1000) * 1000;
197 | 
198 |             if( !m_cond.timewait( m_mutex.get(),t ) )
199 |             {
200 |                 m_mutex.unlock();
201 |                 return false;
202 |             }
203 |         }
204 | 
205 |         if( m_size <= 0 )
206 |         {
207 |             m_mutex.unlock();
208 |             return false;
209 |         }
210 | 
211 |         m_front = ( m_front + 1 ) % m_max_size;
212 |         item = m_array[m_front];
213 |         m_size--;
214 | 
215 |         m_mutex.unlock();
216 |         return true;
217 | 
218 |     }
219 |     
220 | private:
221 |     locker m_mutex;       // Locker
222 |     cond m_cond;          // Condition semaphore
223 | 
224 |     T *m_array;
225 | 
226 |     int m_size;
227 |     int m_max_size;
228 |     int m_front;
229 |     int m_back;
230 |     
231 | 
232 | };
233 | 
234 | #endif /* BLOCK_QUEUE_H */


--------------------------------------------------------------------------------
/log/log.cpp:
--------------------------------------------------------------------------------
  1 | #include <string.h>
  2 | #include <time.h>
  3 | #include <sys/time.h>
  4 | #include <stdarg.h>
  5 | #include <pthread.h>
  6 | 
  7 | #include "log.h"
  8 | 
  9 | Log::Log()
 10 | {
 11 |     m_count = 0;
 12 |     m_is_async = false;     // Setting as the sync flag at the beginning
 13 | }
 14 | 
 15 | Log::~Log()
 16 | {
 17 |     if( m_fp != NULL )
 18 |     {
 19 |         fclose(m_fp);
 20 |     }
 21 | }
 22 | 
 23 | bool Log::init(const char* file_name,int close_log, int log_buffer_size,int split_lines,int max_queue_size)
 24 | {
 25 |     // If the max block size have been setted, using as the async model
 26 |     if( max_queue_size >= 1 )
 27 |     {
 28 |         m_is_async = true;  // Setting the flag
 29 | 
 30 |         // Creating the block queue
 31 |         m_log_queue = new Block_Queue<std::string>(max_queue_size);
 32 |         pthread_t tid;
 33 | 
 34 |         // Creating thread to create async file
 35 |         pthread_create(&tid, NULL,flush_log_thread,NULL);
 36 | 
 37 |     }
 38 | 
 39 |     // Cout the length of content
 40 |     m_close_log = close_log;
 41 |     m_log_buffer_size = log_buffer_size;
 42 |     m_buffer = new char[m_log_buffer_size];
 43 | 
 44 |     memset(m_buffer, '\0',m_log_buffer_size);
 45 | 
 46 |     // The max lines of the log
 47 |     m_spilt_lines = split_lines;
 48 | 
 49 |     time_t t = time(NULL);
 50 |     struct tm *sys_tm = localtime(&t);
 51 |     struct tm my_tm = *sys_tm;
 52 | 
 53 |     // Finding the first '/' index
 54 |     const char *p = strrchr(file_name, '/');
 55 |     char log_full_name[256] = {0};
 56 | 
 57 |     // Defining the name of log
 58 |     if( p == NULL )
 59 |     {
 60 |         snprintf(log_full_name, 255, "%d_%02d_%02d_%s", my_tm.tm_year + 1900,
 61 |             my_tm.tm_mon + 1,my_tm.tm_mday, file_name);
 62 |     }
 63 |     else
 64 |     {
 65 |         strcpy(log_name,p + 1);
 66 |         strncpy(dir_name, file_name, p - file_name + 1);
 67 | 
 68 |         snprintf(log_full_name, 255, "%s%d_%02d_%02d_%s", dir_name,
 69 |             my_tm.tm_year + 1900,my_tm.tm_mon + 1,my_tm.tm_mday, log_name);
 70 |     }
 71 | 
 72 |     m_today = my_tm.tm_mday;
 73 | 
 74 |     m_fp = fopen(log_full_name,"a");
 75 | 
 76 |     if( m_fp == NULL )
 77 |     {
 78 |         return false;
 79 |     }
 80 | 
 81 |     return true;
 82 | 
 83 | }
 84 | 
 85 | void Log::write_log(int level, const char *format,...)
 86 | {
 87 |     struct timeval now = {0,0};
 88 | 
 89 |     gettimeofday(&now,NULL);
 90 | 
 91 |     time_t t = now.tv_sec;
 92 | 
 93 |     struct tm *sys_tm = localtime(&t);
 94 |     struct tm my_tm = *sys_tm;
 95 | 
 96 |     char s[16] = {0};
 97 | 
 98 |     // Log classification
 99 |     switch( level )
100 |     {
101 |         case 0:
102 |             strcpy( s, "[debug]: ");
103 |             break;
104 | 
105 |         case 1:
106 |             strcpy( s, "[info]: ");
107 |             break;
108 | 
109 |         case 2:
110 |             strcpy( s, "[warning]: ");
111 |             break;
112 | 
113 |         case 3:
114 |             strcpy( s, "[error]: ");
115 |             break;
116 |         
117 |         default:
118 |             strcpy( s, "[info]: ");
119 |             break;
120 | 
121 |     }
122 | 
123 |     m_mutex.lock();
124 | 
125 |     // Updating the current lines
126 |     m_count++;
127 | 
128 |     if( m_today != my_tm.tm_mday || m_count % m_spilt_lines == 0 )
129 |     {
130 |         char new_log[256] = {0};
131 |         fflush(m_fp);
132 |         fclose(m_fp);
133 |         char tail[16] = {0};
134 | 
135 |         // Formate the timestamp of the log file
136 |         snprintf(tail,16, "%d_%02d_%02d_",my_tm.tm_year + 1900, my_tm.tm_mon + 1, my_tm.tm_mday);
137 | 
138 |         if ( m_today != my_tm.tm_mday )
139 |         {
140 |             snprintf(new_log, 255, "%s%s%s", dir_name, tail, log_name);
141 |             m_today = my_tm.tm_mday;
142 |             m_count = 0;
143 |         }
144 |         else
145 |         {
146 |             snprintf(new_log, 255, "%s%s%s.%lld", dir_name, tail, log_name,m_count / m_spilt_lines);
147 |         }
148 | 
149 |         m_fp = fopen(new_log,"a");
150 | 
151 |     }
152 | 
153 |     m_mutex.unlock();
154 | 
155 |     va_list valist;
156 | 
157 |     va_start(valist, format);
158 | 
159 |     std::string log_str;
160 | 
161 |     m_mutex.lock();
162 | 
163 |     // Format: timestamp + content
164 |     // Time format: timestamp
165 |     int n = snprintf(m_buffer, 48, "%d-%02d-%02d %02d:%02d:%02d.%06ld %s ",
166 |             my_tm.tm_year + 1900, my_tm.tm_mon + 1, my_tm.tm_mday,
167 |             my_tm.tm_hour, my_tm.tm_min, my_tm.tm_sec, now.tv_usec, s);
168 | 
169 |     // Content format:
170 |     int m = vsnprintf(m_buffer + n, m_log_buffer_size - 1, format, valist);
171 | 
172 |     m_buffer[ n + m ] = '\n';
173 |     m_buffer[ n + m + 1 ] = '\0';
174 | 
175 |     log_str = m_buffer;
176 | 
177 |     m_mutex.unlock();
178 | 
179 |     // Synchronous, mutex is locked,writing it in the file
180 |     // Asynchronous, put it in the blocking queue
181 |     if( m_is_async && ! m_log_queue->full() )
182 |     {
183 |         m_log_queue->push(log_str);
184 |     }
185 |     else
186 |     {
187 |         m_mutex.lock();
188 |         fputs(log_str.c_str(),m_fp);
189 |         m_mutex.unlock();
190 |     }
191 | 
192 |     va_end(valist);
193 | 
194 |     return ;
195 | 
196 | }
197 | 
198 | 
199 | void Log::flush(void)
200 | {
201 |     m_mutex.lock();
202 | 
203 |     // Flushing the write stream buffer
204 |     fflush(m_fp);
205 | 
206 |     m_mutex.unlock();
207 | 
208 |     return ;
209 | }
210 | 
211 | 
212 | 
213 | 
214 | 


--------------------------------------------------------------------------------
/log/log.h:
--------------------------------------------------------------------------------
 1 | #ifndef LOG_H
 2 | #define LOG_H
 3 | 
 4 | /**
 5 | * Use the single instance mode to create a log system to record the server's running status, 
 6 | * error information and access data. 
 7 | * he system can realize the daily classification and super row classification 
 8 | * functions, and can use synchronous and asynchronous write methods 
 9 | * respectively according to the actual situation.
10 | */
11 | 
12 | #include <stdio.h>
13 | #include <iostream>
14 | #include <string>
15 | #include <stdarg.h>
16 | #include <pthread.h>
17 | 
18 | #include "block_queue.h"
19 | 
20 | class Log
21 | {
22 | public:
23 | 
24 |     //  Using the local variables by lazy initialization doesn't need to lock
25 |     static Log* get_instance()
26 |     {
27 |         static Log instance;
28 |         return &instance;
29 |     }
30 | 
31 |     bool init(const char *file_name,int close_log,int log_buffer_size = 8192,int split_buffer_size = 5000000, int max_queue_size = 0);
32 | 
33 |     // Sync log writing public method, calling private method async_ write_ log
34 |     static void *flush_log_thread(void *args)
35 |     {
36 |         Log::get_instance()->async_write_log();
37 |         return nullptr;
38 |     }
39 | 
40 |     //Organizing the output content according to the standard format
41 |     void write_log(int level, const char *format,...);
42 | 
43 |     // Flushing the buffer
44 |     void flush(void);
45 | 
46 | private:
47 |     Log();
48 |     virtual ~Log();
49 | 
50 |     // Asynchronous write log
51 |     void *async_write_log()
52 |     {
53 |         std::string single_log;
54 | 
55 |         // Getting a single log from the blocking queue and writing it to the file
56 |         while( m_log_queue->pop(single_log) )
57 |         {
58 |             m_mutex.lock();
59 |             fputs(single_log.c_str(), m_fp);
60 |             m_mutex.unlock();
61 |         }
62 | 
63 |         return nullptr;
64 |     }
65 | 
66 | private:
67 |     char dir_name[128]; // name of the directory
68 |     char log_name[128]; // name of the log file
69 | 
70 |     int m_spilt_lines; // number of lines
71 |     int m_log_buffer_size; // size of log buffer
72 | 
73 |     long long m_count; // number of the log files lines
74 | 
75 |     int m_today;
76 | 
77 |     FILE *m_fp;  // the open file pointer of the log file
78 |     char *m_buffer; // the log buffer
79 | 
80 |     Block_Queue<std::string> *m_log_queue; // the log queue
81 | 
82 |     bool m_is_async;     // true if using asynchronous
83 | 
84 |     locker m_mutex;     // Synchronous lock
85 | 
86 |     int m_close_log;    // Closing the log file
87 | 
88 | };
89 | 
90 | 
91 | 
92 | // LOG Judgement
93 | #define LOG_DEBUG(format, ...) if(m_close_log == 0) {Log::get_instance()->write_log(0, format, ##__VA_ARGS__); Log::get_instance()->flush();}
94 | #define LOG_INFO(format, ...)  if(m_close_log == 0) {Log::get_instance()->write_log(1, format, ##__VA_ARGS__); Log::get_instance()->flush();}
95 | #define LOG_WARN(format, ...)  if(m_close_log == 0) {Log::get_instance()->write_log(2, format, ##__VA_ARGS__); Log::get_instance()->flush();}
96 | #define LOG_ERROR(format, ...) if(m_close_log == 0) {Log::get_instance()->write_log(3, format, ##__VA_ARGS__); Log::get_instance()->flush();}
97 | 
98 | #endif /* LOG_H */


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "config.h"
 2 | 
 3 | int main(int argc, char *argv[])
 4 | {
 5 |     string user = "root";
 6 |     string passwd = "9024";
 7 |     string database_name = "awei";
 8 | 
 9 |     // Parse command line arguments
10 |     Config config;
11 |     config.parse_args(argc, argv);
12 | 
13 |     WebServer server;
14 | 
15 |     // Initializing the server
16 |     server.init(config.port, user, passwd, database_name, config.LOGWrite, 
17 |                 config.OPT_LINGER, config.TRIGMode,  config.sql_num,  config.thread_num, 
18 |                 config.close_log, config.actor_model);
19 |     
20 | 
21 |     // LOG
22 |     server.log_write();
23 | 
24 |     // Database
25 |     server.sql_pool();
26 | 
27 |     // Thread pool
28 |     server.thread_pool();
29 | 
30 |     // Trig mode
31 |     server.trig_mode();
32 | 
33 |     // Event
34 |     server.event_listen();
35 | 
36 |     // Run
37 |     server.eventLoop();
38 | 
39 |     return 0;
40 | }


--------------------------------------------------------------------------------
/makefile:
--------------------------------------------------------------------------------
 1 | CXX ?= g++
 2 | 
 3 | DEBUG ?= 1
 4 | ifeq ($(DEBUG), 1)
 5 |     CXXFLAGS += -g
 6 | else
 7 |     CXXFLAGS += -O2
 8 | 
 9 | endif
10 | 
11 | server: main.cpp  ./timer/list_timer.cpp ./http/http_conn.cpp ./log/log.cpp ./CGImysql/sql_connection_pool.cpp  webserver.cpp config.cpp
12 | 	$(CXX) -o server  $^ $(CXXFLAGS) -lpthread -lmysqlclient
13 | 
14 | clean:
15 | 	rm  -r server
16 | 


--------------------------------------------------------------------------------
/resource/TinyWebServer.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awei-lwj/TinyWebServer/093cd0177c119f26ec9105e48522b18e33090dec/resource/TinyWebServer.mp4


--------------------------------------------------------------------------------
/resource/TinyWebServer.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awei-lwj/TinyWebServer/093cd0177c119f26ec9105e48522b18e33090dec/resource/TinyWebServer.png


--------------------------------------------------------------------------------
/resource/TinyWebServer0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awei-lwj/TinyWebServer/093cd0177c119f26ec9105e48522b18e33090dec/resource/TinyWebServer0.png


--------------------------------------------------------------------------------
/resource/TinyWebServer1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awei-lwj/TinyWebServer/093cd0177c119f26ec9105e48522b18e33090dec/resource/TinyWebServer1.png


--------------------------------------------------------------------------------
/resource/TinyWebServer2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awei-lwj/TinyWebServer/093cd0177c119f26ec9105e48522b18e33090dec/resource/TinyWebServer2.png


--------------------------------------------------------------------------------
/resource/TinyWebServer3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awei-lwj/TinyWebServer/093cd0177c119f26ec9105e48522b18e33090dec/resource/TinyWebServer3.png


--------------------------------------------------------------------------------
/resource/skiplist.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awei-lwj/TinyWebServer/093cd0177c119f26ec9105e48522b18e33090dec/resource/skiplist.png


--------------------------------------------------------------------------------
/resource/skiplist_test1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awei-lwj/TinyWebServer/093cd0177c119f26ec9105e48522b18e33090dec/resource/skiplist_test1.png


--------------------------------------------------------------------------------
/resource/skiplist_test2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awei-lwj/TinyWebServer/093cd0177c119f26ec9105e48522b18e33090dec/resource/skiplist_test2.png


--------------------------------------------------------------------------------
/root/awei.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |     <head>
 4 |         <meta charset="UTF-8">
 5 |         <title>awei</title>
 6 |     </head>
 7 |     <body><br/>
 8 | <br/>
 9 | <div align="center"><font size="5"> <strong> 阿伟，2023年一定瘦下30斤 </strong></font></div>
10 | <br/>
11 | <!--<div  align="center">a w s l</div>-->
12 | <br/>
13 | <br/>
14 | <div align="center"><img src="./awei.png" title="awei"/></div>
15 | </html>
16 | 


--------------------------------------------------------------------------------
/root/awei.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awei-lwj/TinyWebServer/093cd0177c119f26ec9105e48522b18e33090dec/root/awei.png


--------------------------------------------------------------------------------
/root/judge.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |     <head>
 4 |         <meta charset="UTF-8">
 5 |         <title>WebServer</title>
 6 |     </head>
 7 |     <body>
 8 |     <br/>
 9 |     <br/>
10 |     <div align="center"><font size="5"> <strong>欢迎访问</strong></font></div>
11 | 	<br/>
12 | 		<br/>
13 | 		<form action="0" method="post">
14 |  			<div align="center"><button type="submit">新用户</button></div>
15 |                 </form>
16 | 		<br/>
17 |                 <form action="1" method="post">
18 |                         <div align="center"><button type="submit" >已有账号</button></div>
19 |                 </form>
20 | 		
21 | 		
22 |         </div>
23 |     </body>
24 | </html>
25 | 
26 | 
27 | 


--------------------------------------------------------------------------------
/root/log.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |     <head>
 4 |         <meta charset="UTF-8">
 5 |         <title>Sign in</title>
 6 |     </head>
 7 |     <body>
 8 | <br/>
 9 | <br/>
10 |     <div align="center"><font size="5"> <strong>登录</strong></font></div>
11 |     <br/>
12 |         <div class="login">
13 |                 <form action="2CGISQL.cgi" method="post">
14 |                         <div align="center"><input type="text" name="user" placeholder="用户名" required="required"></div><br/>
15 |                         <div align="center"><input type="password" name="password" placeholder="登录密码" required="required"></div><br/>
16 |                         <div align="center"><button type="submit">确定</button></div>
17 |                 </form>
18 |         </div>
19 |     </body>
20 | </html>
21 | 
22 | 


--------------------------------------------------------------------------------
/root/logError.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |     <head>
 4 |         <meta charset="UTF-8">
 5 |         <title>Sign in</title>
 6 |     </head>
 7 |     <body>
 8 | <br/>
 9 | <br/>
10 |     <div align="center"><font size="5"> <strong>登录</strong></font></div>
11 |     <br/>
12 |         <div class="login">
13 |                 <form action="2CGISQL.cgi" method="post">
14 |                         <div align="center"><input type="text" name="user" placeholder="用户名" required="required"></div><br/>
15 |                         <div align="center"><input type="password" name="password" placeholder="登录密码" required="required"></div><br/>
16 |                         <div align="center"><button type="submit">确定</button></div>
17 |                 </form>
18 | 		<br/>
19 |                <div  align="center">提示：用户名或密码错误，请重试</div>
20 |         </div>
21 |     </body>
22 | </html>
23 | 
24 | 


--------------------------------------------------------------------------------
/root/picture.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |     <head>
 4 |         <meta charset="UTF-8">
 5 |         <title>awei</title>
 6 |     </head>
 7 |     <body><br/>
 8 | <br/>
 9 | <div align="center"><font size="5"> <strong> 图片测试 </strong></font></div>
10 | <br/>
11 | <!--<div  align="center">a w s l</div>-->
12 | <br/>
13 | <br/>
14 | <div align="center"><img src="./pricture.png" title="awei"/></div>
15 | </html>
16 | 


--------------------------------------------------------------------------------
/root/pricture.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awei-lwj/TinyWebServer/093cd0177c119f26ec9105e48522b18e33090dec/root/pricture.png


--------------------------------------------------------------------------------
/root/register.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |     <head>
 4 |         <meta charset="UTF-8">
 5 |         <title>Sign up</title>
 6 |     </head>
 7 |     <body>
 8 | <br/>
 9 | <br/>
10 |     <div align="center"><font size="5"> <strong>注册</strong></font></div>
11 |     <br/>
12 |         <div class="login">
13 |                 <form action="3CGISQL.cgi" method="post">
14 |                         <div align="center"><input type="text" name="user" placeholder="用户名" required="required"></div><br/>
15 |                         <div align="center"><input type="password" name="password" placeholder="用户密码" required="required"></div><br/>
16 |                         <div align="center"><button type="submit">注册</button></div>
17 |                 </form>
18 |         </div>
19 |     </body>
20 | </html>
21 | 


--------------------------------------------------------------------------------
/root/registerError.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |     <head>
 4 |         <meta charset="UTF-8">
 5 |         <title>Sign up</title>
 6 |     </head>
 7 |     <body>
 8 | <br/>
 9 | <br/>
10 |     <div align="center"><font size="5"> <strong>注册</strong></font></div>
11 |     <br/>
12 |         <div class="login">
13 |                 <form action="3CGISQL.cgi" method="post">
14 |                         <div align="center"><input type="text" name="user" placeholder="用户名" required="required"></div><br/>
15 |                         <div align="center"><input type="password" name="password" placeholder="用户密码" required="required"></div><br/>
16 |                         <div align="center"><button type="submit">注册</button></div>
17 |                 </form>
18 | 		<div  align="center">提示：该用户名被注册.</div>
19 |         </div>
20 |     </body>
21 | </html>
22 | 
23 | 


--------------------------------------------------------------------------------
/root/video.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |     <head>
 4 |         <meta charset="UTF-8">
 5 |         <title></title>
 6 |     </head>
 7 |     <body><br/>
 8 | <br/>
 9 | <div align="center"><font size="5">  视频测试页面  <strong></strong></font></div>
10 | <br/>
11 | 
12 | <br/>
13 | <br/>
14 | <div align="center"><video width="906" height="506" controls>
15 |     <source src="video.mp4" type="video/mp4">
16 | </video></div>
17 | </html>
18 | 


--------------------------------------------------------------------------------
/root/video.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awei-lwj/TinyWebServer/093cd0177c119f26ec9105e48522b18e33090dec/root/video.mp4


--------------------------------------------------------------------------------
/root/welcome.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |     <head>
 4 |         <meta charset="UTF-8">
 5 |         <title>WebServer</title>
 6 |     </head>
 7 |     <body>
 8 |     <br/>
 9 |     <br/>
10 |     <div align="center"><font size="5"> <strong> Making your choice </strong></font></div>
11 | 	<br/>
12 | 		<br/>
13 | 		<form action="5" method="post">
14 |  			<div align="center"><button type="submit"> 海绵宝宝.jpg</button></div>
15 |                 </form>
16 | 		<br/>
17 |                 <form action="6" method="post">
18 |                         <div align="center"><button type="submit" > Kruskal算法和Prim算法.mp4</button></div>
19 |                 </form>
20 | 		<br/>
21 | 		<form action="7" method="post">
22 |  			<div align="center"><button type="submit"> awei </button></div>
23 |                 </form>
24 | 		
25 |         </div>
26 |     </body>
27 | </html>
28 | 


--------------------------------------------------------------------------------
/skiplist/skiplist.h:
--------------------------------------------------------------------------------
  1 | #ifndef SKIPLIST_H
  2 | #define SKIPLIST_H
  3 | 
  4 | // TODO: Add the adequate functions to replace MySql in this server
  5 | // TODO: RAII in the resource
  6 | // TODO: Synchronization mode in Reader-Writer model
  7 | // TODO: Raft
  8 | // TODO: Template different key and value
  9 | // TODO: Printf replace cout function
 10 | 
 11 | // *!* this is just a toy storage engine and still has a long way to the really database. 
 12 | 
 13 | #include <iostream>
 14 | #include <cstdlib>
 15 | #include <cmath>
 16 | #include <cstring>
 17 | #include <fstream>
 18 | #include <mutex>
 19 | 
 20 | #include "../locker/locker.h"
 21 | 
 22 | #define STORE_FILE "../store/dumpFile"
 23 | 
 24 | std::string delimiter = ":";
 25 | 
 26 | locker m_skipListLocker;      // locker for critical section
 27 | 
 28 | // class template to implement node
 29 | template<typename K,typename V>
 30 | class Node
 31 | {
 32 | public:
 33 |     Node() {}
 34 | 
 35 |     Node(K k,V v,int);
 36 | 
 37 |     ~Node();
 38 | 
 39 |     K get_key() const;
 40 |     V get_value() const;
 41 | 
 42 |     void set_Value(V);
 43 | 
 44 |     Node<K,V> **forward; // Linear array to hold pointers to next node of different level
 45 | 
 46 |     int node_level;
 47 | 
 48 | private:
 49 |     
 50 |     // Key-value node
 51 |     K key;
 52 |     V value;   
 53 | 
 54 | };
 55 | 
 56 | template<typename K,typename V>
 57 | Node<K,V>::Node(const K k,const V v,int level)
 58 | {
 59 |     this->key = k;
 60 |     this->value = v;
 61 |     this->node_level = level;
 62 | 
 63 |     // level + 1, because array index is from 0 to level
 64 |     this->forward = new Node<K,V>* [level+1]; 
 65 | 
 66 |     // SkipList = List + binary search List
 67 |     memset(this->forward, 0, sizeof(Node<K,V>*) * (level + 1) ); // Full forward array with 0
 68 | };
 69 | 
 70 | template<typename K,typename V>
 71 | Node<K,V>::~Node()
 72 | {
 73 |     delete []forward;
 74 | };
 75 | 
 76 | template<typename K,typename V>
 77 | void Node<K,V>::set_Value(V value)
 78 | {
 79 |     this->value = value;
 80 | };
 81 | 
 82 | template<typename K,typename V>
 83 | K Node<K,V>::get_key() const
 84 | {
 85 |     return key;
 86 | };
 87 | 
 88 | template<typename K,typename V>
 89 | V Node<K,V>::get_value() const
 90 | {
 91 |     return value;
 92 | };
 93 | 
 94 | // The data structure of the skip list is shown in the ../TinyWebServer.drawio
 95 | // Class template for Skip list
 96 | template<typename K,typename V>
 97 | class SkipList
 98 | {
 99 | public:
100 |     SkipList(int);
101 |     ~SkipList();
102 | 
103 |     int get_random_level();   
104 | 
105 |     Node<K,V>* create_node(K, V, int); 
106 | 
107 |     int  insert_element(K ,V);
108 |     bool search_element(K);
109 |     void delete_element(K);
110 | 
111 |     void display_list();
112 | 
113 |     void dump_file();
114 |     void load_file();
115 | 
116 |     int size();
117 | 
118 | 
119 | private:
120 |     void get_key_value_from_string(const std::string& str,std::string* key,std::string* value);
121 |     bool is_valid_string(const std::string& str);
122 | 
123 | private:
124 |     
125 |     // The max level of this skip list
126 |     int _max_level;
127 | 
128 |     // The current level of this skip list
129 |     int _skip_list_level;
130 | 
131 |     // the pointer to the head node of this skip list
132 |     Node<K,V> *_header;
133 | 
134 |     // file operator
135 |     std::ofstream _file_writer;    // writer
136 |     std::ifstream _file_reader;    // reader   
137 | 
138 |     int _element_count;            // the current element count of this SkipList
139 | 
140 | };
141 | 
142 | // *!* Public function
143 | 
144 | /*
145 | Take this following SkipList as an example
146 | 
147 | level  3          1                                                  10
148 | 
149 | 
150 | level 2           1                     5                            10
151 | 
152 | 
153 | level 1           1          3          5                 8          10        
154 | 
155 |     
156 | level 0          1     2     3    4     5           7     8    9     10               
157 | 
158 | The fast table formed by adding a multi row index to  a common linked list\
159 | is the key data structure of Redis SortedSet and LevelDB MemTable. 
160 | 
161 | Compared with the common linked list, the time complexity of its\
162 | insert/delete/search operations  can be O(log(n))
163 | 
164 | */
165 | 
166 | template<typename K,typename V>
167 | SkipList<K,V>::SkipList(int max_level)
168 | {
169 |     this->_max_level       = max_level;
170 |     this->_skip_list_level = 0;
171 |     this->_element_count   = 0;
172 | 
173 |     // Create header node and initialize key and value of a null node
174 |     K key;
175 |     V value;
176 |     this->_header = new Node<K,V>(key, value, _max_level);
177 | 
178 | }
179 | 
180 | template<typename K,typename V>
181 | SkipList<K,V>::~SkipList()
182 | {
183 |     if( _file_writer.is_open() )
184 |     {
185 |         _file_writer.close();
186 |     }
187 | 
188 |     if( _file_reader.is_open() )
189 |     {
190 |         _file_reader.close();
191 |     }
192 | 
193 |     delete _header;
194 | 
195 | }
196 | 
197 | template<typename K,typename V>
198 | int SkipList<K,V>::get_random_level()
199 | {
200 |     int k = 1;
201 |     while( rand() % 2 )
202 |     {
203 |         k++;
204 |     }
205 | 
206 |     k = (k < _max_level) ? k : _max_level;
207 | 
208 |     return k;
209 | }
210 | 
211 | // Insert element in this skip list
212 | // return 1 means element exiting
213 | // return 0 means insert the new element successful
214 | 
215 | /*
216 | Insert the element 6 in the Skip List
217 | 
218 | 
219 | level  3  +----->  1                                                  10
220 |                    |
221 |                    |
222 | level 2           1 ------------------>  5                           10
223 |                                          |
224 |                                          |   insert
225 | level 1           1          3          5 -> | 6 |        8          10        
226 |                                              |   |
227 | level 0          1     2     3    4     5    | 6 |  7     8    9     10               
228 | 
229 | 
230 | */
231 | 
232 | // Create new Node
233 | template<typename K,typename V>
234 | Node<K,V>* SkipList<K,V>::create_node(const K key,const V value,int level)
235 | {
236 |     Node<K,V> *newNode = new Node<K,V>(key, value, level);
237 |     return newNode;
238 | }
239 | 
240 | template<typename K,typename V>
241 | int SkipList<K,V>::insert_element(const K key,const V value)
242 | {
243 |     m_skipListLocker.lock();
244 | 
245 |     Node<K, V> *current = this->_header;
246 | 
247 |     // Create an update array and Initialize it
248 |     // Update the array when we put this node so that node->forward[i] could be operated later
249 | 
250 |     Node<K,V> *update[_max_level + 1];
251 |     memset(update, 0, sizeof(Node<K,V>*) * (_max_level + 1));
252 | 
253 |     // Begin at the highest level of this skip list
254 |     for( int i = _skip_list_level; i >= 0; i-- )
255 |     {
256 |         while( current->forward[i] != NULL &&  current->forward[i]->get_key() < key)
257 |         {
258 |             current = current->forward[i];
259 |         }
260 |         update[i] = current;
261 |     }
262 | 
263 |     // Inserting the new node needs to begin at the level 0
264 |     current = current->forward[0];
265 | 
266 |     // If this node is exit, we should get its key
267 |     if( current != NULL && current->get_key() == key )
268 |     {
269 |         std::cout << "Key: " << key << ", exists" << std::endl;
270 |         m_skipListLocker.unlock();
271 |         return 1;   // Tips: Return 1 = this element exists
272 |     }
273 | 
274 |     // If this node is not exit, we should insert the new node
275 |     // If this key of this node isn't equal the key of the insert node\
276 |     // initializing update value with the header pointer
277 |     if( current == NULL || current->get_key() != key )
278 |     {
279 |         // Generating a random level of this new node
280 |         int random_level = get_random_level();
281 | 
282 |         // If random_level is more than the current skip_list_level, initializing update \
283 |         // value with the header pointer
284 |         if( random_level > _skip_list_level )
285 |         {
286 |             for( int i = _skip_list_level + 1; i < random_level + 1;i++ )
287 |             {
288 |                 update[i] = _header;
289 |             }
290 | 
291 |             _skip_list_level = random_level;
292 |         }
293 | 
294 |         // Creating new node with the generated random level
295 |         Node<K,V>* inserted_node = create_node(key,value,random_level);
296 | 
297 |         // Inserting the new node
298 |         for(int i = 0; i <= random_level;i++)
299 |         {
300 |             inserted_node->forward[i] = update[i]->forward[i];
301 |             update[i]->forward[i] = inserted_node;
302 |         }
303 | 
304 |         std::cout << "Inserting key: " << key << " - value: " << value << std::endl;
305 |         _element_count++;
306 | 
307 |     }
308 | 
309 |     m_skipListLocker.unlock();
310 |     return 0;
311 | 
312 | }
313 | 
314 | template<typename K,typename V>
315 | void SkipList<K,V>::delete_element(K key)
316 | {
317 |     m_skipListLocker.lock();
318 |     Node<K,V>* current = this->_header;
319 |     Node<K,V> *update[_max_level + 1];
320 | 
321 |     memset(update, 0, sizeof( Node<K,V>* ) * (_max_level + 1));
322 | 
323 |     // Begin at the highest level of this skip list
324 |     for( int i = _skip_list_level; i >= 0; i-- )
325 |     {
326 |         while( current->forward[i]!= NULL &&  current->forward[i]->get_key() < key )
327 |         {
328 |             current = current->forward[i];
329 |         }
330 | 
331 |         update[i] = current;
332 |     }
333 | 
334 |     current = current->forward[0];   // The first Node in the skip list
335 |     
336 |     if( current != nullptr && current->get_key() == key )
337 |     {
338 |         // Starting at the lowest level of the skip list and Deleting this node in each level
339 |         for( int i = 0; i <= _skip_list_level; i++ )
340 |         {
341 |             // If this node not exits in this level, breaking it
342 |             if( update[i]->forward[i] != current )
343 |             {
344 |                 break;
345 |             }
346 | 
347 |             update[i]->forward[i] = current->forward[i]; // Move the node to the next level
348 |         }
349 | 
350 |         // Removing the level which not exits any elements
351 |         while( _skip_list_level > 0 && _header->forward[_skip_list_level] == 0 )
352 |         {
353 |             _skip_list_level--;
354 |         }
355 | 
356 |         std::cout << "Successfully deleting the key : " << key << std::endl;
357 |         _element_count--;
358 | 
359 |     }
360 | 
361 |     m_skipListLocker.unlock();
362 |     return ;
363 | 
364 | }
365 | 
366 | template<typename K,typename V>
367 | bool SkipList<K,V>::search_element(K key)
368 | {
369 |     std::cout << "Begin to search_element " << std::endl;
370 |     // The search operation not need to mutex lock
371 |     // m_skipListLocker.lock();
372 | 
373 |     Node<K,V>* current = _header;
374 | 
375 |     // Begin at the highest level of this skip list
376 |     for( int i = _skip_list_level; i >= 0; i-- )
377 |     {
378 |         while( current->forward[i]!= NULL &&  current->forward[i]->get_key() < key )
379 |         {
380 |             current = current->forward[i];
381 |         }
382 | 
383 |     }
384 | 
385 |     current = current->forward[0];   // The first Node in the skip list
386 | 
387 |     // Current_node exits
388 |     if( current != nullptr && current->get_key() == key )
389 |     {
390 |         std::cout << "Found the key : " << key << " - value:  "<< current->get_value() << std::endl;
391 |         return true;
392 |     }
393 | 
394 |     // m_skipListLocker.unlock();
395 | 
396 |     std::cout << "Failed to find the key : " << key << std::endl;
397 |     return false;
398 |     
399 | }
400 | 
401 | template<typename K,typename V>
402 | void SkipList<K,V>::display_list()
403 | {
404 |     std::cout << "\n ---------------- Skip List --------------- " << "\n";
405 |     for( int i = 0; i <= _skip_list_level; i++ )
406 |     {
407 |         std::cout << "--------------------------------------------" << std::endl;
408 | 
409 |         Node<K,V>* current = this->_header->forward[i];
410 |         std::cout << "Level : " << i << std::endl;
411 | 
412 |         while( current!= nullptr )
413 |         {   
414 |             std::cout << "Key : " << current->get_key() << " , Value: " << current->get_value() << std::endl;
415 |             current = current->forward[i];
416 |         }
417 | 
418 |         std::cout << std::endl;
419 | 
420 |         std::cout << "--------------------------------------------" << std::endl;
421 |     }
422 | 
423 | }
424 | 
425 | template<typename K,typename V>
426 | void SkipList<K,V>::dump_file()
427 | {
428 |     std::cout << "\n ------------- Dump File --------------- " << "\n";
429 | 
430 |     _file_writer.open(STORE_FILE);   // ../store/dumpFile
431 | 
432 |     Node<K,V> *current = this->_header->forward[0];
433 | 
434 |     while( current != nullptr )
435 |     {
436 |         _file_writer << current->get_key() << " : " << current->get_value() << "\n";
437 |         std::cout    << current->get_key() << " : " << current->get_value() << "\n";
438 |         current = current->forward[0];
439 |     }
440 | 
441 |     _file_writer.flush();
442 |     _file_writer.close();
443 | 
444 |     return ;
445 |     
446 | }
447 | 
448 | template<typename K,typename V>
449 | void SkipList<K,V>::load_file()
450 | {
451 |     _file_reader.open(STORE_FILE);   // ../store/dumpFile
452 | 
453 |     std::cout << "\n ------------- Load File --------------- " << "\n";
454 | 
455 |     std::string line;
456 |     std::string* key   = new std::string();
457 |     std::string* value = new std::string();
458 | 
459 |     while( getline(_file_reader, line) )
460 |     {
461 |         get_key_value_from_string(line, key, value);
462 | 
463 |         if( key->empty() || value->empty() )
464 |         {
465 |             continue;
466 |         }
467 | 
468 |         insert_element(*key,*value);
469 | 
470 |       std::cout << "Key : " << *key << " , Value: " << *value << std::endl;
471 | 
472 |     }
473 | 
474 |     _file_reader.close();
475 | 
476 | }
477 | 
478 | template<typename K,typename V>
479 | int SkipList<K,V>::size()
480 | {
481 |     return _element_count;
482 | }
483 | 
484 | // *!* Private Function
485 | 
486 | template<typename K,typename V>
487 | void SkipList<K,V>::get_key_value_from_string(const std::string& str,std::string* key,std::string* value)
488 | {
489 |     if( !is_valid_string(str) )
490 |     {
491 |         return;
492 |     }
493 | 
494 |     // delimiter = ":"
495 |     *key = str.substr(0, str.find(delimiter));    
496 |     *value = str.substr(str.find(delimiter) + 1, str.length());
497 | 
498 | }
499 | 
500 | template<typename K,typename V>
501 | bool SkipList<K,V>::is_valid_string(const std::string& str)
502 | {
503 |     if( str.empty() )
504 |     {
505 |         return false;
506 |     }
507 | 
508 |     if( str.find(delimiter) == std::string::npos )
509 |     {
510 |         return false;
511 |     }
512 | 
513 |     return true;
514 | 
515 | }
516 | 
517 | 
518 | #endif /* SKIPLIST_H */


--------------------------------------------------------------------------------
/store/dumpFile:
--------------------------------------------------------------------------------
1 | 1 : awei
2 | 2 : 2023年
3 | 3 : 一定
4 | 5 : 会
5 | 7 : 瘦掉60斤
6 | 9 : 取得良好的考研成绩
7 | 


--------------------------------------------------------------------------------
/test/makefile:
--------------------------------------------------------------------------------
 1 | CC=g++  
 2 | CXXFLAGS = -std=c++0x
 3 | CFLAGS=-I
 4 | skiplist: skiplist_test.o 
 5 | 	$(CC) -o ../bin/skiplist_test skiplist_test.o --std=c++11 -pthread 
 6 | 	rm -f ./*.o
 7 | 
 8 | clean: 
 9 | 	rm -f ./*.o
10 | 


--------------------------------------------------------------------------------
/test/skiplist_stress_test.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <chrono>
  3 | #include <cstdlib>
  4 | #include <pthread.h>
  5 | #include <time.h>
  6 | 
  7 | #include "../skiplist/skiplist.h"
  8 | 
  9 | // *!* Testing the Key-Value storage basing on the SkipList
 10 | 
 11 | #define NUM_THREADS 1
 12 | #define TEST_COUNT 1000000
 13 | 
 14 | 
 15 | SkipList<int, std::string> skipList(18);
 16 | 
 17 | void *insertElement(void* threadId)
 18 | {
 19 |     long tid;
 20 | 
 21 |     tid = (long)threadId;
 22 | 
 23 |     std::cout << tid << std::endl;
 24 |     int tmp = TEST_COUNT / NUM_THREADS;
 25 | 
 26 |     for( int i = tid * tmp, count = 0; count < tmp;i++ )
 27 |     {
 28 |         count++;
 29 |         skipList.insert_element( rand() % TEST_COUNT, "awei" ); 
 30 |     }   
 31 | 
 32 |     pthread_exit(NULL);
 33 | 
 34 | }
 35 | 
 36 | void *getElement(void* threadId)
 37 | {
 38 |     long tid;
 39 |     tid = (long)threadId;
 40 |     std::cout << tid << std::endl;
 41 |     int tmp = TEST_COUNT / NUM_THREADS;
 42 | 
 43 |     for( int i = tid * tmp, count = 0; count < tmp;i++)
 44 |     {
 45 |         count++;
 46 |         skipList.search_element( rand() % TEST_COUNT );
 47 |     }
 48 | 
 49 |     pthread_exit(NULL);
 50 | }
 51 | 
 52 | int main()
 53 | {
 54 |     
 55 |     srand( time(NULL) );
 56 | 
 57 |     // Insert Element operation tests
 58 |     {
 59 |         pthread_t threads[NUM_THREADS];
 60 |         int rc;
 61 |         int i;
 62 | 
 63 |         auto start = std::chrono::high_resolution_clock::now();
 64 | 
 65 |         for( int i = 0; i < NUM_THREADS;i++ )
 66 |         {
 67 |             std::cout << "main() : creating thread" << i << std::endl;
 68 |             rc = pthread_create( &threads[i], NULL, insertElement, (void *)i);
 69 | 
 70 |             if( rc )
 71 |             {
 72 |                 std::cout << "Error : Unable to create thread, " << rc << std::endl;
 73 |                 exit(-1);
 74 |             }
 75 | 
 76 |         }
 77 | 
 78 |         void *ret;
 79 |         for( i = 0; i < NUM_THREADS;i++ )
 80 |         {
 81 |             if( pthread_join(threads[i], &ret) != 0 )
 82 |             {
 83 |                 perror("pthread_create() error");
 84 |                 exit(3);
 85 |             }
 86 |         }
 87 | 
 88 |         auto finish = std::chrono::high_resolution_clock::now();
 89 |         std::chrono::duration<double> elapsed = finish - start;
 90 |         std::cout << "Insert elapsed: " << elapsed.count() << std::endl;
 91 |     }
 92 |     
 93 | 
 94 |  
 95 |     // Search Element operation tests
 96 | 
 97 |     // skipList.display_list();
 98 | 
 99 |     // Get Element operation tests
100 |     {
101 |         pthread_t threads[NUM_THREADS];
102 |         int rc;
103 |         int i;
104 | 
105 |         auto start = std::chrono::high_resolution_clock::now();
106 | 
107 |         for( int i = 0; i < NUM_THREADS;i++ )
108 |         {
109 |             std::cout << "main() : creating thread" << i << std::endl;
110 |             rc = pthread_create( &threads[i], NULL, getElement, (void *)i);
111 | 
112 |             if( rc )
113 |             {
114 |                 std::cout << "Error : Unable to create thread, " << rc << std::endl;
115 |                 exit(-1);
116 |             }
117 | 
118 |         }
119 | 
120 |         void *ret;
121 |         for( i = 0; i < NUM_THREADS;i++ )
122 |         {
123 |             if( pthread_join(threads[i], &ret) != 0 )
124 |             {
125 |                 perror("pthread_create() error");
126 |                 exit(3);
127 |             }
128 |         }
129 | 
130 |         auto finish = std::chrono::high_resolution_clock::now();
131 |         std::chrono::duration<double> elapsed = finish - start;
132 |         std::cout << "Get elapsed: " << elapsed.count() << std::endl;
133 |     }
134 | 
135 |     pthread_exit(NULL);
136 | 
137 | 
138 |     return 0;
139 | 
140 | }


--------------------------------------------------------------------------------
/test/skiplist_stress_test.sh:
--------------------------------------------------------------------------------
1 | # ! /bin/bash
2 | g++ skiplist_stress_test.cpp -o ../bin/skiplist_stress_test --std=c++11 -pthread
3 | ../bin/skiplist_stress_test


--------------------------------------------------------------------------------
/test/skiplist_test.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include "../skiplist/skiplist.h"
 3 | #define FILE_PATH "../store/dumpFile"
 4 | 
 5 | int main() {
 6 | 
 7 |     // 键值中的key用int型，如果用其他类型，需要自定义比较函数
 8 |     // 而且如果修改key的类型，同时需要修改skipList.load_file函数
 9 |     SkipList<int, std::string> skipList(6);
10 | 	skipList.insert_element(1, "awei"); 
11 | 	skipList.insert_element(2, "2023年"); 
12 | 	skipList.insert_element(3, "一定"); 
13 | 	skipList.insert_element(5, "会"); 
14 | 	skipList.insert_element(7, "瘦掉60斤"); 
15 | 	skipList.insert_element(9, "取得良好的考研成绩"); 
16 | 	skipList.insert_element(9, "上岸中国海洋大学"); 
17 | 
18 |     std::cout << "skipList size:" << skipList.size() << std::endl;
19 | 
20 |     skipList.dump_file();
21 | 
22 |     // skipList.load_file();
23 | 
24 |     skipList.search_element(1);
25 |     skipList.search_element(9);
26 | 
27 | 
28 |     skipList.display_list();
29 | 
30 |     skipList.delete_element(5);
31 |     skipList.delete_element(7);
32 | 
33 |     std::cout << "skipList size:" << skipList.size() << std::endl;
34 | 
35 |     skipList.display_list();
36 | }
37 | 


--------------------------------------------------------------------------------
/threadpool/threadpool.h:
--------------------------------------------------------------------------------
  1 | #ifndef THREADPOOL_H
  2 | #define THREADPOOL_H
  3 | 
  4 | #include <list>
  5 | #include <cstdio>
  6 | #include <exception>
  7 | #include <pthread.h>
  8 | 
  9 | #include "../locker/locker.h"
 10 | #include "../CGImysql/sql_connection_pool.h"
 11 | 
 12 | template<typename T>
 13 | class ThreadPool 
 14 | {
 15 | public:
 16 |     ThreadPool(int actor_model, Connection_Pool *conPool,int threads_number = 8, int max_requests = 1000);
 17 |     ~ThreadPool();
 18 | 
 19 |     // Adding a task in the requests queue
 20 |     bool append(T* request);           
 21 | 
 22 |     // Adding a task in the requests queue and Marking the state of this task
 23 |     bool append_s(T* request,int state);  
 24 | 
 25 | private:
 26 | 
 27 |     // The worker function will get the task from the working queue and run it
 28 |     static void *worker( void* arg );   
 29 |     void run();
 30 | 
 31 | private:
 32 |     int m_thread_number;           // The number of threads in the threads pool
 33 |     int m_max_requests;            // The max number of requests in the working queue
 34 | 
 35 |     pthread_t *m_threads;          // Threads[]
 36 | 
 37 |     std::list<T *> m_workQueue;    // Working Queue
 38 | 
 39 |     sem m_queueState;               // Having the tasks to deal?
 40 |     locker m_workQueueLocker;       // Working queue locker
 41 | 
 42 |     int m_actor_model;             // Actor model
 43 | 
 44 |     Connection_Pool *m_connPool;    // Connection pool
 45 | };
 46 | 
 47 | 
 48 | // *!* Public function
 49 | 
 50 | template<typename T>
 51 | ThreadPool<T>::ThreadPool(int actor_model, Connection_Pool *con_pool,int threads_number, int max_requests)
 52 |     : m_actor_model( actor_model ),
 53 |       m_thread_number(threads_number),
 54 |       m_max_requests(max_requests),
 55 |       m_threads(NULL),
 56 |       m_connPool(con_pool)
 57 |       
 58 | {
 59 |     // Base Case
 60 |     if( threads_number <= 0 || max_requests <= 0)
 61 |     {
 62 |         throw std::exception();
 63 |     }
 64 | 
 65 |     // Initializing the threads ID
 66 |     m_threads = new pthread_t[m_thread_number];
 67 |     if( !m_threads )
 68 |     {
 69 |         throw std::exception();
 70 |     }
 71 | 
 72 |     for( int i = 0; i < threads_number; i++ )
 73 |     {
 74 |         // Creating the working threads
 75 |         if( pthread_create( m_threads + i, NULL, worker, this ) != 0 )
 76 |         {
 77 |             delete[] m_threads;
 78 |             throw std::exception();
 79 |         }
 80 | 
 81 |         // Detaching the working threads and the free threads;
 82 |         // Don't delete the working threads
 83 |         if( pthread_detach( m_threads[i] ))
 84 |         {
 85 |             delete[] m_threads;
 86 |             throw std::exception();
 87 |         }      
 88 |         
 89 |     }
 90 | 
 91 | }
 92 | 
 93 | template<typename T>
 94 | ThreadPool<T>::~ThreadPool()
 95 | {
 96 |     delete[] m_threads; 
 97 | }
 98 | 
 99 | template<typename T>
100 | bool ThreadPool<T>::append(T* request)
101 | {
102 |     m_workQueueLocker.lock();          // Protecting the critical section
103 |     if( m_workQueue.size() >= m_max_requests )
104 |     {
105 |         m_workQueueLocker.unlock();    // Protecting the critical section
106 |         return false;
107 |     }
108 | 
109 |     m_workQueue.push_back( request );
110 |     m_workQueueLocker.unlock();       // Protecting the critical section
111 |     m_queueState.post(); 
112 | 
113 |     return true;
114 | }
115 | 
116 | template<typename T>
117 | bool ThreadPool<T>::append_s(T* request, int state)
118 | {
119 |     m_workQueueLocker.lock();       
120 | 
121 |     if( m_workQueue.size() >= m_max_requests )
122 |     {
123 |         m_workQueueLocker.unlock();    
124 |         return false;
125 |     }
126 | 
127 |     request->m_state = state;     // Changing the state of this task
128 |     m_workQueue.push_back( request );
129 |     m_workQueueLocker.unlock();       
130 |     m_queueState.post(); 
131 |     return true;
132 | }
133 | 
134 | template<typename T>
135 | void* ThreadPool<T>::worker( void* arg )
136 | {
137 |     ThreadPool *pool = (ThreadPool *) arg;
138 |     pool->run();
139 |     return pool;
140 | }
141 | 
142 | template<typename T>
143 | void ThreadPool<T>::run()
144 | {
145 |     while( true )
146 |     {
147 |         m_queueState.wait();        // Wait semaphore
148 |         m_workQueueLocker.lock();   // locker the semaphore
149 | 
150 |         if( m_workQueue.empty() )
151 |         {
152 |             m_workQueueLocker.unlock();
153 |             continue;
154 |         }
155 | 
156 |         // Getting the first task of this working queue and Deleting this task
157 |         T *request = m_workQueue.front();
158 |         m_workQueue.pop_front();
159 |         m_workQueueLocker.unlock();
160 | 
161 |         if( !request )
162 |         {
163 |             continue;
164 |         }
165 | 
166 |         if( m_actor_model == 1 )
167 |         {
168 |             if( request->m_state == 0 )
169 |             {
170 |                 if( request->read_once() )
171 |                 {
172 |                     request->improv = 1;
173 |                     Connection_RAII my_sql_con(&request->mysql,m_connPool);
174 |                     request->process();
175 |                 }
176 |                 else
177 |                 {
178 |                     request->improv = 1;
179 |                     request->timer_flag = 1;
180 |                 }
181 |             }
182 |             else
183 |             {
184 |                 if( request->write() )
185 |                 {
186 |                     request->improv = 1;
187 |                 }
188 |                 else
189 |                 {
190 |                     request->improv = 1;
191 |                     request->timer_flag = 1;
192 |                 }
193 |             }
194 |         }
195 |         else
196 |         {
197 |             Connection_RAII my_sql_conn(&request->mysql,m_connPool);
198 |             request->process();
199 |         }
200 |     }
201 | }
202 | 
203 | #endif /* THREADPOOL_H */


--------------------------------------------------------------------------------
/timer/list_timer.cpp:
--------------------------------------------------------------------------------
  1 | #include "list_timer.h"
  2 | #include "../http/http_conn.h"
  3 | 
  4 | Sort_Timer_List::Sort_Timer_List()
  5 | {
  6 |     head = NULL;
  7 |     tail = NULL;
  8 | }
  9 | 
 10 | Sort_Timer_List::~Sort_Timer_List()
 11 | {
 12 |     Util_Timer *tmp = head;
 13 |     while (tmp)
 14 |     {
 15 |         head = tmp->next;
 16 |         delete tmp;
 17 |         tmp = head;
 18 |     }
 19 | }
 20 | 
 21 | void Sort_Timer_List::add_timer(Util_Timer *timer)
 22 | {
 23 |     if (!timer)
 24 |     {
 25 |         return;
 26 |     }
 27 | 
 28 |     if (!head)
 29 |     {
 30 |         head = tail = timer;
 31 |         return;
 32 |     }
 33 | 
 34 |     if (timer->expire < head->expire)
 35 |     {
 36 |         timer->next = head;
 37 |         head->prev = timer;
 38 |         head = timer;
 39 |         return;
 40 |     }
 41 | 
 42 |     add_timer(timer, head);
 43 | }
 44 | 
 45 | void Sort_Timer_List::adjust_timer(Util_Timer *timer)
 46 | {
 47 |     if (!timer)
 48 |     {
 49 |         return;
 50 |     }
 51 | 
 52 |     Util_Timer *temp = timer->next;
 53 | 
 54 |     if (!temp || (timer->expire < temp->expire))
 55 |     {
 56 |         return;
 57 |     }
 58 | 
 59 |     if (timer == head)
 60 |     {
 61 |         head = head->next;
 62 |         head->prev = NULL;
 63 |         timer->next = NULL;
 64 |         add_timer(timer, head);
 65 |     }
 66 |     else
 67 |     {
 68 |         temp->prev->next = timer->next;
 69 |         timer->next->prev = timer->prev;
 70 |         add_timer(timer, timer->next);
 71 |     }
 72 | }
 73 | 
 74 | void Sort_Timer_List::delete_timer(Util_Timer *timer)
 75 | {
 76 |     if (!timer)
 77 |     {
 78 |         return;
 79 |     }
 80 | 
 81 |     if ((timer == head) && (timer == tail))
 82 |     {
 83 |         delete timer;
 84 |         head = NULL;
 85 |         tail = NULL;
 86 |         return;
 87 |     }
 88 | 
 89 |     if (timer == head)
 90 |     {
 91 |         head = head->next;
 92 |         head->prev = NULL;
 93 |         delete timer;
 94 |         return;
 95 |     }
 96 | 
 97 |     if (timer == tail)
 98 |     {
 99 |         tail = tail->prev;
100 |         tail->next = NULL;
101 |         delete timer;
102 |         return;
103 |     }
104 | 
105 |     timer->prev->next = timer->next;
106 |     timer->next->prev = timer->prev;
107 |     delete timer;
108 | }
109 | 
110 | void Sort_Timer_List::trick()
111 | {
112 |     if (!head)
113 |     {
114 |         return;
115 |     }
116 | 
117 |     time_t cur = time(NULL);
118 | 
119 |     Util_Timer *tmp = head;
120 |     while (tmp)
121 |     {
122 |         if (cur < tmp->expire)
123 |         {
124 |             break;
125 |         }
126 | 
127 |         tmp->cb_func(tmp->user_data);
128 | 
129 |         head = tmp->next;
130 | 
131 |         if (head)
132 |         {
133 |             head->prev = NULL;
134 |         }
135 | 
136 |         delete tmp;
137 |         tmp = head;
138 |     }
139 | }
140 | 
141 | void Sort_Timer_List::add_timer(Util_Timer *timer, Util_Timer *list_head)
142 | {
143 |     Util_Timer *prev = list_head;
144 |     Util_Timer *tmp  = prev->next;
145 | 
146 |     while (tmp)
147 |     {
148 |         if (timer->expire < tmp->expire)
149 |         {
150 |             prev->next = timer;
151 |             timer->next = tmp;
152 |             tmp->prev = timer;
153 |             timer->prev = prev;
154 |             
155 |             break;
156 |         }
157 |         prev = tmp;
158 |         tmp = tmp->next;
159 |     }
160 | 
161 |     if (!tmp)
162 |     {
163 |         prev->next = timer;
164 |         timer->prev = prev;
165 |         timer->next = NULL;
166 |         tail = timer;
167 |     }
168 | }
169 | 
170 | void Utils::init(int timeslot)
171 | {
172 |     m_TIMESLOT = timeslot;
173 | }
174 | 
175 | int Utils::setnonblocking(int fd)
176 | {
177 |     int old_option = fcntl(fd, F_GETFL);
178 |     int new_option = old_option | O_NONBLOCK;
179 |     fcntl(fd, F_SETFL, new_option);
180 |     return old_option;
181 | }
182 | 
183 | void Utils::add_fd(int epollfd, int fd, bool one_shot, int TRIGMode)
184 | {
185 |     epoll_event event;
186 |     event.data.fd = fd;
187 | 
188 |     if ( TRIGMode == 1)    // LT
189 |         event.events = EPOLLIN | EPOLLET | EPOLLRDHUP;
190 |     else // ET
191 |         event.events = EPOLLIN | EPOLLRDHUP;
192 | 
193 |     if (one_shot)
194 |         event.events |= EPOLLONESHOT;
195 |     epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
196 | 
197 |     setnonblocking(fd);
198 | }
199 | 
200 | void Utils::sig_handler(int signal)
201 | {
202 |     int save_errno = errno;
203 |     int message = signal;
204 |     send( u_pipe_fd[1], (char *)&message,1 ,0 );
205 |     errno = save_errno;
206 | }
207 | 
208 | void Utils::add_sig(int signal, void(handler)(int),bool restart)
209 | {
210 |     struct sigaction sa;
211 |     memset(&sa, '\0', sizeof(sa));
212 |     sa.sa_handler = handler;
213 | 
214 |     if( restart )
215 |     {
216 |         sa.sa_flags |= SA_RESTART;
217 |     }
218 | 
219 |     sigfillset(&sa.sa_mask);
220 |     assert( sigaction( signal, &sa, NULL ) != -1 );
221 | }
222 | 
223 | void Utils::timer_handler()
224 | {
225 |     m_timer_list.trick();
226 |     alarm(m_TIMESLOT);
227 | }
228 | 
229 | void Utils::show_error(int conn_fd, const char *info)
230 | {
231 |     send(conn_fd, info, strlen(info),0);
232 |     close(conn_fd);
233 | 
234 | }
235 | 
236 | int *Utils::u_pipe_fd = 0;
237 | int Utils::u_epoll_fd = 0;
238 | 
239 | class Utils;
240 | void cb_func(client_data *user_data)
241 | {
242 |     epoll_ctl( Utils::u_epoll_fd, EPOLL_CTL_DEL, user_data->sockfd, 0 );
243 |     assert(user_data);
244 | 
245 |     close(user_data->sockfd);
246 |     Http_Conn::m_user_cnt--;
247 | }


--------------------------------------------------------------------------------
/timer/list_timer.h:
--------------------------------------------------------------------------------
  1 | #ifndef LIST_TIMER
  2 | #define LIST_TIMER
  3 | 
  4 | #include <unistd.h>
  5 | #include <signal.h>
  6 | #include <sys/types.h>
  7 | #include <sys/epoll.h>
  8 | #include <fcntl.h>
  9 | #include <sys/socket.h>
 10 | #include <netinet/in.h>
 11 | #include <arpa/inet.h>
 12 | #include <assert.h>
 13 | #include <sys/stat.h>
 14 | #include <string.h>
 15 | #include <pthread.h>
 16 | #include <stdio.h>
 17 | #include <stdlib.h>
 18 | #include <sys/mman.h>
 19 | #include <stdarg.h>
 20 | #include <errno.h>
 21 | #include <sys/wait.h>
 22 | #include <sys/uio.h>
 23 | 
 24 | #include <time.h>
 25 | 
 26 | #include "../log/log.h"
 27 | 
 28 | class Util_Timer;
 29 | 
 30 | struct client_data  // Connection resources
 31 | {
 32 |     sockaddr_in address;
 33 |     int sockfd;
 34 |     Util_Timer *timer;
 35 | };
 36 | 
 37 | class Util_Timer    // Timer Node
 38 | {
 39 | public:
 40 |     Util_Timer() : prev(NULL), next(NULL) {}
 41 | 
 42 | public:
 43 |     time_t expire;    // The expire time
 44 | 
 45 |     void (*cb_func) ( client_data*);
 46 | 
 47 |     // Connection resources
 48 |     client_data *user_data;
 49 | 
 50 |     // Forward timer callback
 51 |     Util_Timer *prev;
 52 | 
 53 |     // Backward timer callback
 54 |     Util_Timer *next;
 55 | 
 56 | };
 57 | 
 58 | class Sort_Timer_List
 59 | {
 60 | public:
 61 |     Sort_Timer_List();
 62 |     ~Sort_Timer_List();
 63 | 
 64 |     void add_timer(Util_Timer *timer);
 65 | 
 66 |     // When the task is changed, adjusting the timer list
 67 |     void adjust_timer(Util_Timer *timer);
 68 |     void delete_timer(Util_Timer *timer);
 69 | 
 70 |     // Scheduling task processing function
 71 |     void trick();
 72 | 
 73 | 
 74 | private:
 75 | 
 76 |     void add_timer(Util_Timer *timer,Util_Timer *list_head);
 77 | 
 78 |     Util_Timer *head;
 79 |     Util_Timer *tail;
 80 | 
 81 | };
 82 | 
 83 | class Utils
 84 | {
 85 | public:
 86 |     Utils() {};
 87 |     ~Utils() {};
 88 | 
 89 |     void init(int timeslot);
 90 | 
 91 |     // Setting the unblocked mode
 92 |     int setnonblocking(int fd);
 93 | 
 94 |     void add_fd(int epollfd,int fd,bool one_shot,int TRIGMode);
 95 | 
 96 |     static void sig_handler( int signal );
 97 | 
 98 |     void add_sig(int signal, void(handler)(int), bool restart = true);
 99 | 
100 |     void timer_handler();
101 | 
102 |     void show_error(int conn_fd,const char *info);
103 | 
104 | public:
105 |     static int *u_pipe_fd;
106 |     Sort_Timer_List m_timer_list;
107 |     static int u_epoll_fd;
108 |     int m_TIMESLOT;
109 | 
110 | };
111 | 
112 | void cb_func(client_data* user_data);
113 | 
114 | #endif /* LIST_TIMER */


--------------------------------------------------------------------------------
/webserver.cpp:
--------------------------------------------------------------------------------
  1 | #include "webserver.h"
  2 | 
  3 | WebServer::WebServer()
  4 | {
  5 |     // Http connection
  6 |     users = new Http_Conn[MAX_FD];
  7 | 
  8 |     // Root path
  9 |     char server_path[200];
 10 |     getcwd(server_path,200);
 11 |     char root[6] = "/root";
 12 |     m_root = (char *) malloc(strlen(server_path) + strlen(root) + 1);
 13 |     strcpy(m_root, server_path);
 14 |     strcat(m_root, root);
 15 | 
 16 |     // Timer
 17 |     users_timer = new client_data[MAX_FD];
 18 | 
 19 | }
 20 | 
 21 | // Close each connection
 22 | WebServer::~WebServer()
 23 | {
 24 |     close(m_epoll_fd);
 25 |     close(m_listen_fd);
 26 |     close(m_pipe_fd[1]);
 27 |     close(m_pipe_fd[0]);
 28 | 
 29 |     delete [] users;
 30 |     delete [] users_timer;
 31 | 
 32 |     delete m_thread_pool;
 33 | }
 34 | 
 35 | // Initialize
 36 | void WebServer::init(int port, string user, string password,
 37 |         string databaseName, int log_write, int opt_linger,
 38 |         int trigmode, int sql_num, int thread_num,
 39 |         int close_log, int actor_model
 40 |     )
 41 | {
 42 |     m_port = port;
 43 |     m_user = user;
 44 | 
 45 |     m_password = password;
 46 |     m_database = databaseName;
 47 | 
 48 |     m_log_write  = log_write;
 49 |     m_OPT_LINGER = opt_linger;
 50 | 
 51 |     m_TRIGMode = trigmode;
 52 |     m_sql_num  = sql_num;
 53 | 
 54 |     m_thread_num  = thread_num;
 55 |     m_close_log   = close_log;
 56 |     m_actor_model = actor_model;
 57 | 
 58 | }
 59 | 
 60 | // LT / ET model
 61 | void WebServer::trig_mode()
 62 | {
 63 |     // LT + LT
 64 |     if( m_TRIGMode == 0 )
 65 |     {
 66 |         m_LISTENTrigMode = 0;
 67 |         m_CONNTrigMode   = 0;
 68 |     }
 69 |     else if( m_TRIGMode == 1 )   // LT + ET
 70 |     {
 71 |         m_LISTENTrigMode = 0;
 72 |         m_CONNTrigMode   = 1;
 73 |     }
 74 |     else if( m_TRIGMode == 2 )   // ET + LT
 75 |     {
 76 |         m_LISTENTrigMode = 1;
 77 |         m_CONNTrigMode   = 0;
 78 |     }
 79 |     else if( m_TRIGMode == 3 )   // ET + ET
 80 |     {
 81 |         m_LISTENTrigMode = 1;
 82 |         m_CONNTrigMode   = 1;
 83 |     }
 84 | 
 85 | }
 86 | 
 87 | // Log Write
 88 | void WebServer::log_write()
 89 | {
 90 |     if( m_close_log == 0 )
 91 |     {
 92 |         // LOG
 93 |         if( m_log_write == 1 )
 94 |         {
 95 |             Log::get_instance()->init("./ServerLog", m_close_log,2000,800000,800);
 96 |         }
 97 |         else
 98 |         {
 99 |             Log::get_instance()->init("./ServerLog", m_close_log,2000,800000,0);
100 |         }
101 |     }
102 | }
103 | 
104 | // Sql pool
105 | void WebServer::sql_pool()
106 | {
107 |     // Sql connection pool
108 |     m_connection_pool = Connection_Pool::get_Instance();
109 |     m_connection_pool->init("localhost",m_user,m_password,m_database,3306,m_sql_num,m_close_log);
110 | 
111 |     // Data base write table
112 |     users->initmysql_result(m_connection_pool);
113 | }
114 | 
115 | // Thread pool
116 | void WebServer::thread_pool()
117 | {
118 |     // Threads pool
119 |     m_thread_pool = new ThreadPool<Http_Conn>(m_actor_model,m_connection_pool,m_thread_num);
120 | }
121 | 
122 | void WebServer::event_listen()
123 | {
124 |     m_listen_fd = socket(PF_INET, SOCK_STREAM, 0 );
125 |     assert( m_listen_fd >= 0 );
126 | 
127 |     // Close connection
128 |     if( m_OPT_LINGER == 0 )
129 |     {
130 |         struct linger tmp = {0,1};
131 |         setsockopt( m_listen_fd, SOL_SOCKET, SO_LINGER, &tmp, sizeof(tmp));
132 |     }
133 |     else if( m_OPT_LINGER == 1 )
134 |     {
135 |         struct linger tmp = {1,1};
136 |         setsockopt( m_listen_fd, SOL_SOCKET, SO_LINGER, &tmp,sizeof(tmp) );
137 |     }
138 | 
139 |     int ret = 0;
140 |     struct sockaddr_in address;
141 |     bzero(&address,sizeof(address));
142 |     address.sin_family = AF_INET;
143 |     address.sin_addr.s_addr = htonl(INADDR_ANY);
144 |     address.sin_port = htons(m_port);
145 | 
146 |     int flag = 1;
147 |     setsockopt(m_listen_fd, SOL_SOCKET,SO_REUSEADDR, &flag, sizeof(flag));
148 |     ret = bind(m_listen_fd, (struct sockaddr *)&address, sizeof(address));
149 |     
150 |     assert( ret >= 0 );
151 |     ret = listen(m_listen_fd, 5);
152 |     assert( ret >= 0 );
153 | 
154 |     utils.init(TIMESLOT);
155 | 
156 |     // Creating event in kernel table through epoll
157 |     epoll_event events[MAX_EVENTS];
158 |     m_epoll_fd = epoll_create(5);
159 |     assert( m_epoll_fd != -1 );
160 | 
161 |     utils.add_fd(m_epoll_fd, m_listen_fd, false, m_LISTENTrigMode);
162 |     Http_Conn::m_epollfd = m_epoll_fd;
163 | 
164 |     ret = socketpair(PF_UNIX, SOCK_STREAM, 0, m_pipe_fd);
165 |     assert(ret != -1);
166 |     utils.setnonblocking(m_pipe_fd[1]);
167 |     utils.add_fd(m_epoll_fd, m_pipe_fd[0], false, 0);
168 | 
169 |     utils.add_sig(SIGPIPE, SIG_IGN);
170 |     utils.add_sig(SIGALRM, utils.sig_handler, false);
171 |     utils.add_sig(SIGTERM, utils.sig_handler, false);
172 | 
173 |     alarm(TIMESLOT);
174 | 
175 |     // Pipe fd/Epoll fd
176 |     Utils::u_pipe_fd  = m_pipe_fd;
177 |     Utils::u_epoll_fd = m_epoll_fd;
178 | 
179 | }
180 | 
181 | // Timer
182 | void WebServer::timer(int conn_fd,struct sockaddr_in client_address)
183 | {
184 |     users[conn_fd].init(conn_fd,client_address,m_root, m_CONNTrigMode,
185 |         m_close_log,m_user,m_password,m_database);
186 | 
187 |     // Initializing client data
188 |     users_timer[conn_fd].address = client_address;
189 |     users_timer[conn_fd].sockfd  = conn_fd;
190 | 
191 |     // Timer
192 |     Util_Timer *timer = new Util_Timer;
193 |     timer->user_data = &users_timer[conn_fd];
194 |     timer->cb_func   = cb_func;
195 |     time_t cur = time(NULL);
196 |     timer->expire = cur + 3 * TIMESLOT;
197 |     users_timer[conn_fd].timer = timer;
198 |     utils.m_timer_list.add_timer(timer);
199 | }
200 | 
201 | // If there has the data transmission, delaying the timer by 3 and adjusting the timer list
202 | void WebServer::adjust_timer(Util_Timer *timer)
203 | {
204 |     time_t cur = time(NULL);
205 | 
206 |     timer->expire = cur + 3 * TIMESLOT;
207 |     utils.m_timer_list.add_timer(timer);
208 | 
209 |     LOG_INFO("%s","adjust timer once");
210 | }
211 | 
212 | // Dealing timer
213 | void WebServer::deal_timer(Util_Timer *timer,int sock_fd)
214 | {
215 |     timer->cb_func(&users_timer[sock_fd]);
216 |     if( timer )
217 |     {
218 |         utils.m_timer_list.delete_timer(timer);
219 |     }
220 | 
221 |     LOG_INFO("close fd %d", users_timer[sock_fd].sockfd);
222 | 
223 | }
224 | 
225 | bool WebServer::deal_client_data()
226 | {
227 |     struct sockaddr_in client_address;
228 |     socklen_t client_addr_length = sizeof(client_address);
229 | 
230 |     if ( m_LISTENTrigMode == 0 )
231 |     {
232 |         int conn_fd = accept(m_listen_fd, (struct sockaddr *)&client_address, &client_addr_length);
233 | 
234 |         if (conn_fd < 0)
235 |         {
236 |             LOG_ERROR("%s:errno is:%d", "accept error", errno);
237 |             return false;
238 |         }
239 | 
240 |         if (Http_Conn::m_user_cnt >= MAX_FD)
241 |         {
242 |             utils.show_error(conn_fd, "Internal server busy");
243 |             LOG_ERROR("%s", "Internal server busy");
244 |             return false;
245 |         }
246 | 
247 |         timer(conn_fd, client_address);
248 |     }
249 |     else
250 |     {
251 |         while (1)
252 |         {
253 |             int conn_fd = accept(m_listen_fd, (struct sockaddr *)&client_address, &client_addr_length);
254 | 
255 |             if (conn_fd < 0)
256 |             {
257 |                 LOG_ERROR("%s:errno is:%d", "accept error", errno);
258 |                 break;
259 |             }
260 | 
261 |             if (Http_Conn::m_user_cnt >= MAX_FD)
262 |             {
263 |                 utils.show_error(conn_fd, "Internal server busy");
264 |                 LOG_ERROR("%s", "Internal server busy");
265 |                 break;
266 |             }
267 | 
268 |             timer(conn_fd, client_address);
269 |         }
270 |         return false;
271 |     }
272 | 
273 |     return true;
274 | 
275 | }
276 | 
277 | bool WebServer::deal_signal(bool &timeout, bool &stop_server)
278 | {
279 |     int ret = 0;
280 |     int sig;
281 |     char signals[1024];
282 | 
283 |     ret = recv(m_pipe_fd[0], signals, sizeof(signals), 0);
284 |     if (ret == -1)
285 |     {
286 |         return false;
287 |     }
288 |     else if (ret == 0)
289 |     {
290 |         return false;
291 |     }
292 |     else
293 |     {
294 |         for (int i = 0; i < ret; ++i)
295 |         {
296 |             switch (signals[i])
297 |             {
298 |             case SIGALRM:
299 |             {
300 |                 timeout = true;
301 |                 break;
302 |             }
303 |             case SIGTERM:
304 |             {
305 |                 stop_server = true;
306 |                 break;
307 |             }
308 |             }
309 | 
310 |         }
311 |     }
312 | 
313 |     return true;
314 | }
315 | 
316 | void WebServer::deal_read(int sock_fd)
317 | {
318 |     Util_Timer *timer = users_timer[sock_fd].timer;
319 | 
320 |     //reactor
321 |     if ( m_actor_model == 1 )
322 |     {
323 |         if (timer)
324 |         {
325 |             adjust_timer(timer);
326 |         }
327 | 
328 |         m_thread_pool->append_s(users + sock_fd, 0);
329 | 
330 |         while (true)
331 |         {
332 |             if ( users[sock_fd].improv == 1)
333 |             {
334 |                 if ( users[sock_fd].timer_flag == 1)
335 |                 {
336 |                     deal_timer(timer, sock_fd);
337 |                     users[sock_fd].timer_flag = 0;
338 |                 }
339 | 
340 |                 users[sock_fd].improv = 0;
341 | 
342 |                 break;
343 |             }
344 |         }
345 | 
346 |     }
347 |     else
348 |     {
349 |         //Proactor model
350 |         if (users[sock_fd].read_once())
351 |         {
352 |             LOG_INFO("deal with the client(%s)", inet_ntoa(users[sock_fd].get_address()->sin_addr));
353 | 
354 |             m_thread_pool->append(users + sock_fd);
355 | 
356 |             if (timer)
357 |             {
358 |                 adjust_timer(timer);
359 |             }
360 |         }
361 |         else
362 |         {
363 |             deal_timer(timer, sock_fd);
364 |         }
365 | 
366 |     } // end if
367 | 
368 | }
369 | 
370 | void WebServer::deal_write(int sock_fd)
371 | {
372 |     Util_Timer *timer = users_timer[sock_fd].timer;
373 |     
374 |     //reactor
375 |     if ( m_actor_model == 1)
376 |     {
377 |         if (timer)
378 |         {
379 |             adjust_timer(timer);
380 |         }
381 | 
382 |         m_thread_pool->append_s(users + sock_fd, 1);
383 | 
384 |         while (true)
385 |         {
386 |             if (users[sock_fd].improv == 1)
387 |             {
388 | 
389 |                 if ( users[sock_fd].timer_flag == 1)
390 |                 {
391 |                     deal_timer(timer, sock_fd);
392 |                     users[sock_fd].timer_flag = 0;
393 |                 }
394 | 
395 |                 users[sock_fd].improv = 0;
396 | 
397 |                 break;
398 |             }
399 |         }
400 | 
401 |     }
402 |     else
403 |     {
404 |         //proactor
405 |         if (users[sock_fd].write())
406 |         {
407 |             LOG_INFO("send data to the client(%s)", inet_ntoa(users[sock_fd].get_address()->sin_addr));
408 | 
409 |             if (timer)
410 |             {
411 |                 adjust_timer(timer);
412 |             }
413 | 
414 |         }
415 |         else
416 |         {
417 |             deal_timer(timer, sock_fd);
418 |         }
419 |     }
420 | }
421 | 
422 | void WebServer::eventLoop()
423 | {
424 |     bool timeout     = false;
425 |     bool stop_server = false;
426 | 
427 |     while (!stop_server)
428 |     {
429 |         int number = epoll_wait(m_epoll_fd, events, MAX_EVENTS, -1);
430 | 
431 |         if (number < 0 && errno != EINTR)
432 |         {
433 |             LOG_ERROR("%s", "epoll failure");
434 |             break;
435 |         }
436 | 
437 |         for (int i = 0; i < number; i++)
438 |         {
439 |             int sock_fd = events[i].data.fd;
440 | 
441 |             // Dealing with the new client connection
442 |             if (sock_fd == m_listen_fd)
443 |             {
444 |                 bool flag = deal_client_data();
445 | 
446 |                 if (false == flag)
447 |                     continue;
448 | 
449 |             }
450 |             else if ( events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR ) )
451 |             {
452 |                 // Closing connection and Removing timer
453 |                 Util_Timer *timer = users_timer[sock_fd].timer;
454 |                 deal_timer(timer, sock_fd);
455 | 
456 |             }
457 |             else if ((sock_fd == m_pipe_fd[0]) && (events[i].events & EPOLLIN)) // Dealing signal
458 |             { 
459 | 
460 |                 bool flag = deal_signal(timeout, stop_server);
461 |                 if (flag == false)
462 |                     LOG_ERROR("%s", "deal_client_data failure");
463 | 
464 |             }
465 |             else if (events[i].events & EPOLLIN)    // Dealing with client data
466 |             {
467 |                 deal_read(sock_fd);
468 |             }
469 |             else if (events[i].events & EPOLLOUT)
470 |             {
471 |                 deal_write(sock_fd);
472 |             }
473 | 
474 |         } // end for
475 | 
476 |         if (timeout)
477 |         {
478 |             utils.timer_handler();
479 | 
480 |             LOG_INFO("%s", "timer tick");
481 | 
482 |             timeout = false;
483 |         }
484 | 
485 |     } // End while
486 | }
487 | 


--------------------------------------------------------------------------------
/webserver.h:
--------------------------------------------------------------------------------
  1 | #ifndef WEBSERVER_H
  2 | #define WEBSERVER_H
  3 | 
  4 | #include <sys/socket.h>
  5 | #include <netinet/in.h>
  6 | #include <arpa/inet.h>
  7 | #include <stdio.h>
  8 | #include <unistd.h>
  9 | #include <errno.h>
 10 | #include <fcntl.h>
 11 | #include <stdlib.h>
 12 | #include <cassert>
 13 | #include <sys/errno.h>
 14 | 
 15 | #include "./threadpool/threadpool.h"
 16 | #include "./http/http_conn.h"
 17 | 
 18 | const int MAX_FD     = 65536;      // Maximum number of file descriptors
 19 | const int MAX_EVENTS = 10000;        // Maximum number of events
 20 | const int TIMESLOT   = 5;          // The max out timestamp
 21 | 
 22 | 
 23 | class WebServer
 24 | {
 25 | public:
 26 |     WebServer();
 27 |     ~WebServer();
 28 | 
 29 |     void init(int port, string user, string password,
 30 |         string databaseName, int log_write, int opt_linger,
 31 |         int trigmode, int sql_num, int thread_num,
 32 |         int close_log, int actor_model
 33 |     );
 34 | 
 35 |     void thread_pool();
 36 |     void sql_pool();
 37 |     void log_write();
 38 |     void trig_mode();
 39 | 
 40 |     // Event
 41 |     void event_listen();
 42 |     void eventLoop();
 43 | 
 44 |     // Timer
 45 |     void timer( int conn_fd, struct sockaddr_in client_address);
 46 |     void adjust_timer(Util_Timer *timer);
 47 |     void deal_timer(Util_Timer *timer,int sock_fd);
 48 | 
 49 |     // Client
 50 |     bool deal_client_data();
 51 |     bool deal_signal(bool& timeout, bool& stop_server);
 52 | 
 53 |     // Read and write
 54 |     void deal_read(int socket_fd);
 55 |     void deal_write(int socket_fd);
 56 | 
 57 | public:
 58 |     
 59 |     // Basic elements
 60 |     int m_port;         // The port
 61 |     char *m_root;       // The root
 62 |     int m_log_write;    // The flag of writing in the log
 63 |     int m_close_log;    // The flag of closing the log
 64 |     int m_actor_model;  // The actor model
 65 | 
 66 |     // Epoll
 67 |     int m_pipe_fd[2];     // The epoll fd
 68 |     int m_epoll_fd;         // The epoll fd
 69 |     Http_Conn *users;
 70 | 
 71 |     // Data base
 72 |     Connection_Pool *m_connection_pool; // The connection pool
 73 |     string m_user;        // The user
 74 |     string m_password;    // The password
 75 |     string m_database;    // The database
 76 |     int m_sql_num;       // The number of sql
 77 | 
 78 |     // Thread pool
 79 |     ThreadPool<Http_Conn> *m_thread_pool; // The thread pool
 80 |     int m_thread_num;  // The number of threads
 81 | 
 82 |     // Epoll Events
 83 |     epoll_event events[MAX_EVENTS]; 
 84 | 
 85 |     int m_listen_fd;
 86 |     int m_OPT_LINGER; 
 87 |     int m_TRIGMode;
 88 |     int m_LISTENTrigMode;
 89 |     int m_CONNTrigMode;
 90 | 
 91 |     // Timer
 92 |     struct client_data *users_timer;
 93 |     Utils utils;
 94 | 
 95 | };
 96 | 
 97 | 
 98 | 
 99 | #endif /* WEBSERVER_H*/
100 | 


--------------------------------------------------------------------------------