消息通信Server端

基于boost实现的消息通信Server端，目前仅用于接收消息并调用消息处理函数。

#ifndef __cooper_server_h_
#define __cooper_server_h_

#include "cooper_message.h"

using boost::asio::ip::tcp;

typedef deque<CooperMessage> MsgQueueType;
typedef boost::function<void(const CooperMessage&)> RecvMsgCallbackFunction;

const string kIPSendMsgToAll = "255.255.255.255";
const char kServerPort[] = "29317";

//----------------------------------------------------------------------

class CooperSession;
typedef boost::shared_ptr<CooperSession> session_ptr;

//----------------------------------------------------------------------

class SessionSet
{
public:
    void Join(session_ptr session);
    void Leave(session_ptr session);
    void AsyncWriteSet(const CooperMessage& msg);

private:
    set<session_ptr>    sessions_;
};

//----------------------------------------------------------------------

class CooperSession : public boost::enable_shared_from_this<CooperSession>
{
public:
    CooperSession(boost::asio::io_service& io_service, SessionSet& session_set)
        : socket_(io_service), session_set_(session_set)
    {
        msg_header_ = new char[CooperMessage::header_length];
    }
    
    ~CooperSession() { delete[] msg_header_; }

    tcp::socket& get_socket();
    const char* get_remote_ip();
    
    void JoinSet();
    void AsyncRead(RecvMsgCallbackFunction func);
    void HandleReadHeader(const boost::system::error_code& error);
    void HandleReadBody(const boost::system::error_code& error);
    void AsyncWrite(const CooperMessage& msg);
    void HandleWrite(const boost::system::error_code& error);

private:
    tcp::socket     socket_;
    SessionSet&     session_set_;
    CooperMessage   read_msg_;
    MsgQueueType    write_msgs_;
    RecvMsgCallbackFunction asyncread_cbf_;
    char*           msg_header_;
};

//----------------------------------------------------------------------

class CooperServer
{
public:
    CooperServer(boost::asio::io_service& io_service, 
        const tcp::endpoint& endpoint, 
        RecvMsgCallbackFunction func);
    
    void HandleAccept(session_ptr session, const boost::system::error_code& error);

private:
    void AsyncAccept();

private:
    RecvMsgCallbackFunction     recvmsg_cbf_;
    SessionSet                  session_set_;
    boost::asio::io_service&    io_service_;
    tcp::acceptor               acceptor_;
};

//----------------------------------------------------------------------

#endif // __cooper_server_h_

 

#include "cooper_server.h"

//----------------------------------------------------------------------

tcp::socket& CooperSession::get_socket()
{
    return socket_;
}

const char* CooperSession::get_remote_ip()
{
    return socket_.remote_endpoint().address().to_string().c_str();
}

void CooperSession::JoinSet()
{
    session_set_.Join(shared_from_this());
    printf("new session joined.\n");
}

void CooperSession::AsyncRead(RecvMsgCallbackFunction func)
{
    asyncread_cbf_ = func;
    // printf("async_read start\n");
    boost::asio::async_read(socket_,
        boost::asio::buffer(msg_header_, CooperMessage::header_length),
        boost::bind(&CooperSession::HandleReadHeader, shared_from_this(), 
            boost::asio::placeholders::error));
}

void CooperSession::HandleReadHeader(const boost::system::error_code& error)
{
    if (!error) {
        uint body_length = read_msg_.get_body_length(msg_header_);
        printf("InitMsg body_length=%d\n", body_length);
        
        if (!read_msg_.InitMsg(msg_header_, body_length)) {
            session_set_.Leave(shared_from_this());
        }
        
        boost::asio::async_read(socket_,
            boost::asio::buffer(read_msg_.get_body(), body_length),
            boost::bind(&CooperSession::HandleReadBody, shared_from_this(),
                boost::asio::placeholders::error));
    } else {
        session_set_.Leave(shared_from_this());
    }
}

void CooperSession::HandleReadBody(const boost::system::error_code& error)
{
    if (!error) {
        asyncread_cbf_(read_msg_);
        boost::asio::async_read(socket_,
            boost::asio::buffer(msg_header_, CooperMessage::header_length),
            boost::bind(&CooperSession::HandleReadHeader, shared_from_this(),
                boost::asio::placeholders::error));
    } else {
        session_set_.Leave(shared_from_this());
    }
}

void CooperSession::AsyncWrite(const CooperMessage& msg)
{
    string dst_ip(msg.get_dst_ip());
    string remote_ip(socket_.remote_endpoint().address().to_string());
    
    if (dst_ip != kIPSendMsgToAll && remote_ip != dst_ip) {
        return;
    }
    
    bool write_in_progress = !write_msgs_.empty();
    write_msgs_.push_back(msg);
    
    if (!write_in_progress) {
        boost::asio::async_write(socket_,
            boost::asio::buffer(write_msgs_.front().get_data(),
            write_msgs_.front().get_data_length()),
            boost::bind(&CooperSession::HandleWrite, shared_from_this(),
                boost::asio::placeholders::error));
    }
}

void CooperSession::HandleWrite(const boost::system::error_code& error)
{
    if (!error) {
        write_msgs_.pop_front();
        
        if (!write_msgs_.empty()) {
            boost::asio::async_write(socket_,
                boost::asio::buffer(write_msgs_.front().get_data(),
                write_msgs_.front().get_data_length()),
                boost::bind(&CooperSession::HandleWrite, shared_from_this(),
                    boost::asio::placeholders::error));
        }
    } else {
        session_set_.Leave(shared_from_this());
    }
}

//----------------------------------------------------------------------

void SessionSet::Join(session_ptr session)
{
    sessions_.insert(session);
}

void SessionSet::Leave(session_ptr session)
{
    printf("%s leave.\n", session->get_remote_ip());
    sessions_.erase(session);
}

void SessionSet::AsyncWriteSet(const CooperMessage& msg)
{
    std::for_each(sessions_.begin(), sessions_.end(),
        boost::bind(&CooperSession::AsyncWrite, _1, boost::ref(msg)));
}

//----------------------------------------------------------------------

CooperServer::CooperServer(boost::asio::io_service& io_service, 
    const tcp::endpoint& endpoint,
    RecvMsgCallbackFunction func)
        : io_service_(io_service),
            acceptor_(io_service, endpoint),
            recvmsg_cbf_(func)
{
    AsyncAccept();
}

void CooperServer::HandleAccept(session_ptr session, const boost::system::error_code& error)
{
    if (!error) {
        printf("Accept connection from %s\n", session->get_remote_ip());
        session->JoinSet();
        session->AsyncRead(recvmsg_cbf_);
        AsyncAccept();
    }
}

void CooperServer::AsyncAccept()
{
    session_ptr new_session(new CooperSession(io_service_, session_set_));
    acceptor_.set_option(tcp::acceptor::reuse_address(true));
    printf("Server start waiting accept connection.\n");
    acceptor_.async_accept(new_session->get_socket(),
        boost::bind(&CooperServer::HandleAccept, this, new_session,
            boost::asio::placeholders::error));
}