#include "Server.h"

//静态变量定义区

bool Server::stop;

unordered_map<Status, HttpResponse> Server::error_map;

//限制参数

int Server::thread_num;

int Server::queue_size;

int Server::max_fd;

//连接参数

int Server::port;

string Server::root;

int Server::listen_fd;

//redis参数

string Server::redis_ip;

int Server::redis_port;

//功能模块

Handler *Server::handler;

ThreadPool Server::thread_pool;

int Server::epoll_fd;

struct epoll_event *Server::ep_events;

//Log模块相关参数

string Server::log_path;

bool Server::info_on;

bool Server::debug_on;

bool Server::warn_on;

bool Server::error_on;

void Server::free()

{

stop = true;

}

void Server::init()

{

stop = false;

Log::init(log_path, info_on, debug_on, warn_on, error_on);

thread_pool.create(thread_num, queue_size);

Log::log("server has inited", INFO);

handler = new Handler[max_fd];

HttpResponse::initContentTypeMap();

error_map.clear();

error_map.insert(make_pair(BAD_REQUEST, HttpResponse(BAD_REQUEST)));

error_map.insert(make_pair(SERVICE_UNAVAILABLE, HttpResponse(SERVICE_UNAVAILABLE)));

error_map.insert(make_pair(INTERNAL_SERVER_ERROR, HttpResponse(INTERNAL_SERVER_ERROR)));

for (auto i = error_map.begin(); i != error_map.end(); i++)

{

i->second.generateResponse();

}

}

void Server::loadConfig(string path)

{

cout << " \033[32m[INFO]: \033[0m" << "Loading config" << endl;

Config config;

config.readFile(path.c_str());

if (!config.lookupValue("server.thread_num", thread_num))

{

cout << " \033[32m[INFO]: \033[0m" << "server thread_num setting not found, use default setting" << endl;

thread_num = 8;

}

if (!config.lookupValue("server.queue_size", queue_size))

{

cout << " \033[32m[INFO]: \033[0m" << "server queue_size setting not found, use default setting" << endl;

queue_size = 1000;

}

if (!config.lookupValue("server.max_fd", max_fd))

{

cout << " \033[32m[INFO]: \033[0m" << "server max_fd setting not found, use default setting" << endl;

max_fd = 1024;

}

if (!config.lookupValue("server.root", root))

{

cout << " \033[32m[INFO]: \033[0m" << "server root setting not found, use default setting" << endl;

root = ".";

}

if (!config.lookupValue("server.redis.redis_ip", redis_ip))

{

cout << " \033[32m[INFO]: \033[0m" << "server redis_ip setting not found, use default setting" << endl;

redis_ip = "127.0.0.1";

}

if (!config.lookupValue("server.redis.redis_port", redis_port))

{

cout << " \033[32m[INFO]: \033[0m" << "server redis_port setting not found, use default setting" << endl;

redis_port = 6379;

}

if (!config.lookupValue("server.log.log_path", log_path))

{

cout << " \033[32m[INFO]: \033[0m" << "server log_path setting not found, use default setting" << endl;

log_path = "log/";

}

if (!config.lookupValue("server.log.info_on", info_on))

{

cout << " \033[32m[INFO]: \033[0m" << "server info_on setting not found, use default setting" << endl;

info_on = true;

}

if (!config.lookupValue("server.log.debug_on", debug_on))

{

cout << " \033[32m[INFO]: \033[0m" << "server debug_on setting not found, use default setting" << endl;

debug_on = true;

}

if (!config.lookupValue("server.log.warn_on", warn_on))

{

cout << " \033[32m[INFO]: \033[0m" << "server warn_on setting not found, use default setting" << endl;

warn_on = true;

}

if (!config.lookupValue("server.log.error_on", error_on))

{

cout << " \033[32m[INFO]: \033[0m" << "server error_on setting not found, use default setting" << endl;

error_on = true;

}

if (!config.lookupValue("server.port", port))

{

cout << " \033[32m[INFO]: \033[0m" << "server port setting not found, use default setting" << endl;

port = 80;

}

redisContext *db = redisConnect(redis_ip.c_str(), redis_port);

if (db->err != 0)

{

cout << " \033[32m[INFO]: \033[0m" << "redis is not running" << endl;

}

redisFree(db);

cout << " \033[32m[INFO]: \033[0m" << "server runs in background" << endl;

}

void Server::start()

{

if ((listen_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)

{

throw runtime_error("socket error");

}

int optval = 1;

setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));

struct sockaddr_in sin;

bzero(&sin, sizeof(sin));

sin.sin_family = AF_INET;

sin.sin_addr.s_addr = htonl(INADDR_ANY);

sin.sin_port = htons(port);

if (bind(listen_fd, (const struct sockaddr *)&sin, sizeof(sin)) < 0)

{

throw runtime_error("bind error");

}

if (listen(listen_fd, 5) < 0)

{

throw runtime_error("listen error");

}

//设置listenfd为非阻塞

int old_option = fcntl(listen_fd, F_GETFL);

int new_option = old_option | O_NONBLOCK;

fcntl(listen_fd, F_SETFL, new_option);

//初始化epoll

epoll_fd = epoll_create(max_fd);

struct epoll_event listen_ep_event;

listen_ep_event.events = EPOLLIN | EPOLLET;

listen_ep_event.data.fd = listen_fd;

epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &listen_ep_event);

ep_events = new struct epoll_event[max_fd];

Log::log("start loop", DEBUG);

while (!stop)

{

int n_ready = epoll_wait(epoll_fd, ep_events, max_fd, 2 * 1000);

for (int i = 0; i < n_ready; i++)

{

int temp_fd = ep_events[i].data.fd;

if (temp_fd == listen_fd)

{

int connect_fd;

while((connect_fd = accept(listen_fd, NULL, NULL)) > 0)

{

Log::log("accept", DEBUG);

if (connect_fd >= max_fd)

{

close(connect_fd);

Log::log("connect pool is full", INFO);

//showError(connect_fd, SERVICE_UNAVAILABLE);

continue;

}

else

{

handler[connect_fd].bind(connect_fd);

}

}

}

else if (ep_events[i].events & EPOLLIN)

{

try

{

handler[temp_fd].read();

thread_pool.add(&handler[temp_fd]);

}

catch (const std::exception &e)

{

if (strcmp(e.what(), "server busy") == 0)

{

Log::log(e.what(), INFO);

handler[temp_fd].debind();

//showError(temp_fd, SERVICE_UNAVAILABLE);

}

else if (strcmp(e.what(), "client closed") == 0)

{

Log::log(e.what(), INFO);

handler[temp_fd].debind();

}

else

{

Log::log(e.what(), ERROR);

handler[temp_fd].debind();

showError(temp_fd, INTERNAL_SERVER_ERROR);

}

}

}

else if (ep_events[i].events & EPOLLOUT)

{

try

{

handler[temp_fd].write();

}

catch (const std::exception &e)

{

Log::log(e.what(), ERROR);

handler[temp_fd].debind();

}

}

else if (ep_events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR))

{

Log::log("client closed", INFO);

handler[temp_fd].debind();

}

}

}

close(epoll_fd);

close(listen_fd);

Log::log("free the pool", DEBUG);

thread_pool.free();

Log::log("delete the handle", DEBUG);

delete[] handler;

Log::log("close server", INFO);

Log::stop();

while (!Log::finished());

}

//服务器忙时返回503是废案，后来发现服务器忙时直接关闭连接比发送错误码更现实：更不会占用宝贵的IO资源

void Server::showError(int connfd, Status st)

{

if (error_map.find(st) != error_map.end())

{

send(connfd, error_map[st].getResponse(), error_map[st].getResponseSize(), 0);

}

handler[connfd].debind();

}