【slighttpd】基于lighttpd架构的Server项目实战(4)—简单的echo服务器

转载地址:https://blog.csdn.net/jiange_zh/article/details/50636536

在这一部分，我们将对上一篇中的master-worker进行拓展，成为一个简单的echo服务器。

这一步我们需要添加两个类：Listener和Connection；

Listener的职责:

    1.创建监听套接字;

    2.注册监听套接字事件;

    3.在监听事件的回调函数中进行accept并创建新连接;

其头文件如下:

/*************************************************************************
    > File Name: listener.h
    > Author: Jiange
    > Mail: [email protected] 
    > Created Time: 2016年01月27日 星期三 19时46分34秒
 ************************************************************************/
#ifndef _LISTENER_H
#define _LISTENER_H

#include <string>

#include "event2/event.h"
#include "event2/util.h"

#include "util.h"

class Worker;

class Listener
{
    public:
        Listener(const std::string &ip, unsigned short port);
        ~Listener();

        bool InitListener(Worker *worker);
        void AddListenEvent();

        static void ListenEventCallback(evutil_socket_t fd, short event, void *arg);
        
        Worker *listen_worker;
        evutil_socket_t listen_sockfd;
        struct sockaddr_in listen_addr;
        struct event *listen_event;
        uint64_t cnt_connection;
};

#endif

 接下来看看具体实现:

/*************************************************************************
    > File Name: listener.cpp
    > Author: Jiange
    > Mail: [email protected] 
    > Created Time: 2016年01月27日 星期三 19时48分56秒
 ************************************************************************/
#include "listener.h"
#include "worker.h"
#include "connection.h"

#include <iostream>

Listener::Listener(const std::string &ip, unsigned short port)
{
    //ipv4
    listen_addr.sin_family = AF_INET;
    listen_addr.sin_addr.s_addr = inet_addr(ip.c_str());
    listen_addr.sin_port = htons(port);
    listen_event = NULL;
    cnt_connection = 0;
    std::cout << "Init listener" << std::endl;
}

Listener::~Listener()
{
    if (listen_event)
    {
        event_free(listen_event);
        close(listen_sockfd);
    }
    std::cout<< "Listener closed" << std::endl;
}

bool Listener::InitListener(Worker *worker)
{
    if (-1 == (listen_sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    {
        return false;
    }
    
    //非阻塞
    evutil_make_socket_nonblocking(listen_sockfd);

    int reuse = 1;

    //重用
    setsockopt(listen_sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));

    if (0 != bind(listen_sockfd, (struct sockaddr *)&listen_addr, sizeof(listen_addr))) {
        return false;
    }
    if (0 != listen(listen_sockfd, 5)) {
        return false;
    }
    
    listen_worker = worker;
    return true;
}

/* 这里单独作为一个函数，而不是合并到上面函数中。
 * 因为InitListener是在fork之前调用的，此时
 * worker的w_base还未赋值；
 */
void Listener::AddListenEvent()
{
    //echo先从客户端读取数据，故此处监听读
    listen_event = event_new(listen_worker->w_base, listen_sockfd, EV_READ | EV_PERSIST, Listener::ListenEventCallback, this);
    event_add(listen_event, NULL);
}

void Listener::ListenEventCallback(evutil_socket_t sockfd, short event, void *arg)
{
    evutil_socket_t con_fd;
    struct sockaddr_in con_addr;
    socklen_t addr_len = sizeof(con_addr);
    if (-1 == (con_fd = accept(sockfd, (struct sockaddr *)&con_addr, &addr_len))) {
        return ;
    }

    Listener *listener = (Listener *)arg;
    Connection *con = new Connection();

    con->con_sockfd = con_fd;

    pid_t pid = getpid();
    std::cout << "listen accept: " << con->con_sockfd << " by process " << pid << std::endl;
    
    if (!con->InitConnection(listener->listen_worker))
    {
        Connection::FreeConnection(con);
        return ;
    }

    con->con_worker->con_map[con->con_sockfd] = con;
    ++listener->cnt_connection;
}

接下来看看Connection：

一个Connection实例即代表一个连接，它维护从listener的回调函数那里accept得到的套接字，并在该套接字上监听读写事件，进行request和response。

/*************************************************************************
    > File Name: connection.h
    > Author: Jiange
    > Mail: [email protected] 
    > Created Time: 2016年01月27日 星期三 20时10分35秒
 ************************************************************************/
#ifndef _CONNECTION_H
#define _CONNECTION_H

#include <string>
#include <queue>

#include "event2/event.h"
#include "event2/util.h"

#include "util.h"

class Worker;

class Connection
{
    public:
        Connection();
        ~Connection();

        bool InitConnection(Worker *worker);

        static void ConEventCallback(evutil_socket_t fd, short event, void *arg);

        Worker *con_worker;

        evutil_socket_t con_sockfd;
        struct event *read_event;
        struct event *write_event;

        std::string con_inbuf;
        std::string con_intmp;
        std::string con_outbuf;

        static void FreeConnection(Connection *con);

    private:
        void WantRead();
        void NotWantRead();
        void WantWrite();
        void NotWantWrite();
};

#endif

这里两个event分别负责读写事件，比一个event效率高一些。

在回调函数的设计中，本来打算使用两个回调函数：一个处理读，一个处理写。

不过其实可以合并到同一个回调函数里，所以还是在一个函数中处理，并增加4个函数，来进行监听事件的切换，这样做更有利于后面状态机的拓展：

void Connection::WantRead()
{
    event_add(read_event, NULL); 
}

void Connection::NotWantRead()
{
    event_del(read_event);
}

void Connection::WantWrite()
{
    event_add(write_event, NULL);
}

void Connection::NotWantWrite() 
{
    event_del(write_event);
}

除以上函数外其他部分的具体实现：

/*************************************************************************
    > File Name: connection.cpp
    > Author: Jiange
    > Mail: [email protected] 
    > Created Time: 2016年01月28日 星期四 12时06分22秒
 ************************************************************************/

#include "connection.h"
#include "worker.h"

#include<iostream>

Connection::Connection()
{
    con_worker = NULL;

    read_event = NULL;
    write_event= NULL;
}

Connection::~Connection()
{
    if (read_event && write_event)
    {
        event_free(read_event);
        event_free(write_event);
        std::cout << con_sockfd << " closed" << std::endl;
        close(con_sockfd);
    }
}
/* 删除worker中相应的con，并释放该con */
void Connection::FreeConnection(Connection *con)
{
    Worker *worker = con->con_worker;

    if (con->read_event && con->write_event)
    {
        Worker::ConnectionMap::iterator con_iter = worker->con_map.find(con->con_sockfd);
        worker->con_map.erase(con_iter);
    }

    delete con;
}
bool Connection::InitConnection(Worker *worker)
{
    con_worker = worker;

    try
    {   
        //这里不能开太大，会爆内存！
        //后期可能需要在内存的使用上进行优化～
        con_intmp.reserve(10 * 1024);
        con_inbuf.reserve(10 * 1024);
        con_outbuf.reserve(10 * 1024);

        evutil_make_socket_nonblocking(con_sockfd);
        //test：监听读事件，从客户端读，然后回显
        read_event = event_new(con_worker->w_base, con_sockfd, EV_PERSIST | EV_READ, Connection::ConEventCallback, this);
        write_event = event_new(con_worker->w_base, con_sockfd, EV_PERSIST | EV_WRITE, Connection::ConEventCallback, this);
    }
    catch(std::bad_alloc)
    {
        std::cout << "InitConnection():bad_alloc" <<std::endl;
    }
    WantRead();

    return true;
}

/* 循环读写
 * 注意，在读的时候，此处ret为0时，可能是空字符串之类的
 * 所以在这里暂不做处理
 */
void Connection::ConEventCallback(evutil_socket_t sockfd, short event, void *arg)
{

    Connection *con = (Connection*)arg;

    if (event & EV_READ) 
    {
        int cap = con->con_intmp.capacity();
        int ret = read(sockfd, &con->con_intmp[0], cap);

        if (ret == -1)
        {
            if (errno != EAGAIN && errno != EINTR)
            {
                FreeConnection(con);
                return;
            }
        }
        else if (ret == 0)
        {
            FreeConnection(con); 
            return;
        }
        else
        {
            con->con_inbuf.clear();
            con->con_inbuf.append(con->con_intmp.c_str(), ret);
        }
        con->con_outbuf = con->con_inbuf;
        con->NotWantRead();
        con->WantWrite();
    }

    if (event & EV_WRITE)
    {
        int ret = write(sockfd, con->con_outbuf.c_str(), con->con_outbuf.size());

        if (ret == -1)
        {
            if (errno != EAGAIN && errno != EINTR)
            {
                FreeConnection(con);
                return;
            }
        }
        con->NotWantWrite();
        con->WantRead();
    }   
}

介绍完listener和connection之后，我们需要相应地调整master和worker的代码：

1.修改两者的构造函数：

Master::Master(const std::string &ip, unsigned short port)
    :worker(ip, port)
{
    //……
}

Worker::Worker(const std::string &ip, unsigned short port)
        :listener(ip, port)
{
    //……
}

2.在master中开始创建监听套接字：

bool Master::StartMaster()
{
    std::cout << "Start Master" << std::endl;

    if (!worker.listener.InitListener(&worker))
    {
        return false;
    }
    //……
}

 3.在worker中增加listener和connection map成员：

class Master;
class Connection;

class Worker
{
    public:
        typedef std::map<evutil_socket_t, Connection*> ConnectionMap;
        //……
        Listener            listener;
        ConnectionMap       con_map;
};

4.worker析构函数释放持有的连接：

Worker::~Worker()
{
    //……

    if (w_base)
    {
        ConnectionMap::iterator con_iter = con_map.begin();
        while (con_iter != con_map.end())
        {
            Connection *con = con_iter->second;
            delete con;
            ++con_iter;
        }
        event_base_free(w_base);
    }
}

5.worker增加监听event事件：

void Worker::Run()
{
    w_base = event_base_new();
    listener.AddListenEvent();
    //……
    return;
}

6.修改main函数中的master构造；

最后，附上一个使用到的头文件：

/*************************************************************************
    > File Name: util.h
    > Author: Jiange
    > Mail: [email protected] 
    > Created Time: 2016年01月28日 星期四 10时39分22秒
 ************************************************************************/

#ifndef _UTIL_H
#define _UTIL_H

#include <signal.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <stdint.h>

#endif

至此，我们简单的echo服务器就大功告成啦～

下面给出makefile：

THIRD_LIBS=-levent
LIBS=-ldl
CFLAGS=-I./include

master:src/master.o src/worker.o src/listener.o src/connection.o src/main.o
        g++ -g -o $@ src/master.o src/worker.o src/listener.o src/connection.o src/main.o $(THIRD_LIBS) $(LIBS)

src/master.o:src/master.cpp include/master.h
        g++ -g -o $@ -c $< $(CFLAGS)

src/worker.o:src/worker.cpp include/worker.h include/util.h
        g++ -g -o $@ -c $< $(CFLAGS)

src/listener.o:src/listener.cpp include/listener.h include/util.h
        g++ -g -o $@ -c $< $(CFLAGS)

src/connection.o:src/connection.cpp include/connection.h include/util.h
        g++ -g -o $@ -c $< $(CFLAGS)

src/main.o:src/main.cpp include/master.h
        g++ -g -o $@ -c $< $(CFLAGS)

clean:
        rm -f src/*.o master

我用python写了个用于测试的客户端：

#python2.7.6
#coding=utf-8

import socket

if __name__ == "__main__":
    sockfd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sockfd.connect(('localhost', 8000))
    message = ""
    while 1:
        message = raw_input("Please input:")
        sockfd.send(message)
        message = sockfd.recv(8000)
        print message
    sockfd.close()

另外一个用于测试的：

#python2.7.6
#coding=utf-8

import socket
import time
import threading

http_request = "POST /test_server HTTP/1.1\r\nHost:test.py\r\nContent-Length:5\r\n\r\nHello"

def make_a_request():
    sockfd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sockfd.connect(('localhost', 8000))
    sockfd.sendall(http_request)
    sockfd.recv(8000)
    sockfd.close()

if __name__ == "__main__":
    thread_list = []

    start_time = time.time()

    for i in range(0, 1000):
        thread = threading.Thread(target = make_a_request)
        thread_list.append(thread)
        thread.start()

    for thread in thread_list:
        thread.join()

    print "Time used for 1000 request: ", time.time() - start_time

另外，由于是多进程，所以需要测试一下并发下的运转情况～ 
（可以使用webbench～）

本程序在github的源代码

接下来，我们将引入状态机机制，并开始进行一些http的请求与处理！