TeamTalk 服务端源码分析（一）loginserv

　　loginserv的功能和名称，是有些不一致，它并不处理登陆。这个服务相当于一个msgserv的负载管理器，客户端连进来，需要先连接到loginserv，从loginserv获取一个可用的msgserv的信息，剩下的就客户端就直接和msgserv打交道了，所以loginserv需要交互的对像分为两类，一类是客户端，给客户端返回msgserv信息，一类是msgserv，记录msgserv的ip，端口，用户数等信息。客户端因为协议的不同，又分为http客户端和其他客户端。

　　我们从loginserv的入口看下，代码在login_server.cpp，下面对一些步骤做了注释。

int main(int argc, char* argv[])
{
　　
    if ((argc == 2) && (strcmp(argv[1], "-v") == 0)) {
        printf("Server Version: LoginServer/%s\n", VERSION);
        printf("Server Build: %s %s\n", __DATE__, __TIME__);
        return 0;
    }

    signal(SIGPIPE, SIG_IGN);

    CConfigFileReader config_file("loginserver.conf");  //读取配置文件

    char* client_listen_ip = config_file.GetConfigName("ClientListenIP");    // 这个IP用来接入客户端，使用PB协议
    char* str_client_port = config_file.GetConfigName("ClientPort");
    char* http_listen_ip = config_file.GetConfigName("HttpListenIP");        // 这个IP用来接入网页，使用的是http协议
    char* str_http_port = config_file.GetConfigName("HttpPort");
    char* msg_server_listen_ip = config_file.GetConfigName("MsgServerListenIP");  //这个IP用来和msgserv进行通信，长连接
    char* str_msg_server_port = config_file.GetConfigName("MsgServerPort");
    char* str_msfs_url = config_file.GetConfigName("msfs");                   // 这个是配置文件服务器
    char* str_discovery = config_file.GetConfigName("discovery");

    if (!msg_server_listen_ip || !str_msg_server_port || !http_listen_ip
        || !str_http_port || !str_msfs_url || !str_discovery) {
        log("config item missing, exit... ");
        return -1;
    }

    uint16_t client_port = atoi(str_client_port);
    uint16_t msg_server_port = atoi(str_msg_server_port);
    uint16_t http_port = atoi(str_http_port);
    strMsfsUrl = str_msfs_url;
    strDiscovery = str_discovery;
    
    
    pIpParser = new IpParser();  // 这个用来判断IP是电信还是网通
    
    int ret = netlib_init();

    if (ret == NETLIB_ERROR)
        return ret;

　　//分别启动监听，并且传入回调函数

    CStrExplode client_listen_ip_list(client_listen_ip, ';');
    for (uint32_t i = 0; i < client_listen_ip_list.GetItemCnt(); i++) {
        ret = netlib_listen(client_listen_ip_list.GetItem(i), client_port, client_callback, NULL); 
        if (ret == NETLIB_ERROR)
            return ret;
    }

    CStrExplode msg_server_listen_ip_list(msg_server_listen_ip, ';');
    for (uint32_t i = 0; i < msg_server_listen_ip_list.GetItemCnt(); i++) {
        ret = netlib_listen(msg_server_listen_ip_list.GetItem(i), msg_server_port, msg_serv_callback, NULL);
        if (ret == NETLIB_ERROR)
            return ret;
    }
    
    CStrExplode http_listen_ip_list(http_listen_ip, ';');
    for (uint32_t i = 0; i < http_listen_ip_list.GetItemCnt(); i++) {
        ret = netlib_listen(http_listen_ip_list.GetItem(i), http_port, http_callback, NULL);
        if (ret == NETLIB_ERROR)
            return ret;
    }
    

    printf("server start listen on:\nFor client %s:%d\nFor MsgServer: %s:%d\nFor http:%s:%d\n",
    　　client_listen_ip, client_port, msg_server_listen_ip, msg_server_port, http_listen_ip, http_port);
    init_login_conn(); // 这里传入计时器的回调函数
    init_http_conn();  

    printf("now enter the event loop...\n");
    
    writePid();  //写线程文件

    netlib_eventloop();  // 启动事件监听

    return 0;
}　　

　　总体来说，有三个listern比较重要，下面先介绍下listen这个函数，后面再分别介绍三个listen的作用。

　　netlib_listen的原型如下：

int netlib_listen(
        const char*    server_ip, 
        uint16_t    port,
        callback_t    callback,
        void*        callback_data)
{
    CBaseSocket* pSocket = new CBaseSocket();
    if (!pSocket)
        return NETLIB_ERROR;

    int ret =  pSocket->Listen(server_ip, port, callback, callback_data);
    if (ret == NETLIB_ERROR)
        delete pSocket;
    return ret;
}

　　这里new了一个CBaseSocket，并且调用了CBaseSocket的Listen，CBaseSocket的Listen实现如下

int CBaseSocket::Listen(const char* server_ip, uint16_t port, callback_t callback, void* callback_data)
{
    m_local_ip = server_ip;
    m_local_port = port;
    m_callback = callback;
    m_callback_data = callback_data;  

    m_socket = socket(AF_INET, SOCK_STREAM, 0);  //调用底层socket
    if (m_socket == INVALID_SOCKET)
    {
        printf("socket failed, err_code=%d\n", _GetErrorCode());
        return NETLIB_ERROR;
    }

    _SetReuseAddr(m_socket); // 设置socket属性
    _SetNonblock(m_socket);

    sockaddr_in serv_addr;
    _SetAddr(server_ip, port, &serv_addr);
    int ret = ::bind(m_socket, (sockaddr*)&serv_addr, sizeof(serv_addr));  //绑定端口
    if (ret == SOCKET_ERROR)
    {
        log("bind failed, err_code=%d", _GetErrorCode());
        closesocket(m_socket);
        return NETLIB_ERROR;
    }

    ret = listen(m_socket, 64);  // 调用listen
    if (ret == SOCKET_ERROR)
    {
        log("listen failed, err_code=%d", _GetErrorCode());
        closesocket(m_socket);
        return NETLIB_ERROR;
    }

    m_state = SOCKET_STATE_LISTENING;

    log("CBaseSocket::Listen on %s:%d", server_ip, port);

    AddBaseSocket(this);   
    CEventDispatch::Instance()->AddEvent(m_socket, SOCKET_READ | SOCKET_EXCEP);
    return NETLIB_OK;
}

　　前面的没什么特别的，看下AddBaseSocket这个方法，把创建好的socket，加入到一个全局的map中，定义如下：

typedef hash_map SocketMap;
SocketMap    g_socket_map;

void AddBaseSocket(CBaseSocket* pSocket)
{
    g_socket_map.insert(make_pair((net_handle_t)pSocket->GetSocket(), pSocket));
}

　　后续的操作时，需要从g_socket_map中取到对应的对象的指针即可操作。CBaseSocket本身继承了引用计数类。

　　CEventDispatch是个单例，这个类根据平台，实现了select/epoll/kevent的内容封装，把事件分为两类

　　读事件，调用CBaseSocket的onRead方法，函数实现如下：

void CBaseSocket::OnRead()
{
    if (m_state == SOCKET_STATE_LISTENING)
    {
        _AcceptNewSocket();
    }
    else
    {
        u_long avail = 0;
        if ( (ioctlsocket(m_socket, FIONREAD, &avail) == SOCKET_ERROR) || (avail == 0) )
        {
            m_callback(m_callback_data, NETLIB_MSG_CLOSE, (net_handle_t)m_socket, NULL);
        }
        else
        {
            m_callback(m_callback_data, NETLIB_MSG_READ, (net_handle_t)m_socket, NULL);
        }
    }
}

　　写事件，调用CBaseSocket的onWrite方法，函数实现如下：

void CBaseSocket::OnWrite()
{
#if ((defined _WIN32) || (defined __APPLE__))
    CEventDispatch::Instance()->RemoveEvent(m_socket, SOCKET_WRITE);
#endif

    if (m_state == SOCKET_STATE_CONNECTING)
    {
        int error = 0;
        socklen_t len = sizeof(error);
#ifdef _WIN32

        getsockopt(m_socket, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
#else
        getsockopt(m_socket, SOL_SOCKET, SO_ERROR, (void*)&error, &len);
#endif
        if (error) {
            m_callback(m_callback_data, NETLIB_MSG_CLOSE, (net_handle_t)m_socket, NULL);
        } else {
            m_state = SOCKET_STATE_CONNECTED;
            m_callback(m_callback_data, NETLIB_MSG_CONFIRM, (net_handle_t)m_socket, NULL);
        }
    }
    else
    {
        m_callback(m_callback_data, NETLIB_MSG_WRITE, (net_handle_t)m_socket, NULL);
    }
}

　　这两类事件中，分别调用回调函数，所以在使用的过程中，需要传入回调函数。

 

　　在main函数中，netlib_eventloop();执行之后，传入的回调函数开始工作，我们先看第一个listen的执行过程，功能上来说，主要是建立和msgserv的连接和通信

　　1、netlib_listen(msg_server_listen_ip_list.GetItem(i), msg_server_port, msg_serv_callback, NULL); 

　　小L(loginserv)：开始接客了（启动了），给你（msgserv）留了后门（端口），你来吧！

　　从上面Listen函数可以知道，服务端的fd，设置了事件为read，并且加入到EventDispatch，所以会调用CBaseSocket的OnRead函数，因为state =  listenning，所以会走到_AcceptNewSocket()的逻辑

　　2、_AcceptNewSocket接收socket的函数，在接收到msgserv的连接，并且调用回调函数，如下

void CBaseSocket::_AcceptNewSocket()
{
	SOCKET fd = 0;
	sockaddr_in peer_addr;
	socklen_t addr_len = sizeof(sockaddr_in);
	char ip_str[64];
	while ( (fd = accept(m_socket, (sockaddr*)&peer_addr, &addr_len)) != INVALID_SOCKET )
	{
		CBaseSocket* pSocket = new CBaseSocket();
		uint32_t ip = ntohl(peer_addr.sin_addr.s_addr);
		uint16_t port = ntohs(peer_addr.sin_port);

		snprintf(ip_str, sizeof(ip_str), "%d.%d.%d.%d", ip >> 24, (ip >> 16) & 0xFF, (ip >> 8) & 0xFF, ip & 0xFF);

		log("AcceptNewSocket, socket=%d from %s:%d\n", fd, ip_str, port);

		pSocket->SetSocket(fd);
		pSocket->SetCallback(m_callback);
		pSocket->SetCallbackData(m_callback_data);
		pSocket->SetState(SOCKET_STATE_CONNECTED);
		pSocket->SetRemoteIP(ip_str);
		pSocket->SetRemotePort(port);

		_SetNoDelay(fd);
		_SetNonblock(fd);
		AddBaseSocket(pSocket);
		CEventDispatch::Instance()->AddEvent(fd, SOCKET_READ | SOCKET_EXCEP);
		m_callback(m_callback_data, NETLIB_MSG_CONNECT, (net_handle_t)fd, NULL);
	}
}

　　小M(msgserv)：我来了（accetp到新的连接）

　　3、这里就走到了msg_serv_callback的调用逻辑，传入参数是NETLIB_MSG_CONNECT

// this callback will be replaced by imconn_callback() in OnConnect()
void msg_serv_callback(void* callback_data, uint8_t msg, uint32_t handle, void* pParam)
{
    log("msg_server come in");

    if (msg == NETLIB_MSG_CONNECT)
    {
        CLoginConn* pConn = new CLoginConn();
        pConn->OnConnect2(handle, LOGIN_CONN_TYPE_MSG_SERV);
    }
    else
    {
        log("!!!error msg: %d ", msg);
    }
}

　　小M(msgserv)：也没带啥礼物，帮你干点啥吧（调用msg_serv_callback）

　　4、回调函数的第三个参数，传入的是msgserv接入的fd，这个fd有新的任务，所以他的回调函数，需要重新设置，具体的设置是在CLoginConnet的OnConnect2里完成

void CLoginConn::OnConnect2(net_handle_t handle, int conn_type)
{
    m_handle = handle;
    m_conn_type = conn_type;
    ConnMap_t* conn_map = &g_msg_serv_conn_map;
    if (conn_type == LOGIN_CONN_TYPE_CLIENT) {
        conn_map = &g_client_conn_map;
    }else

    conn_map->insert(make_pair(handle, this));

    netlib_option(handle, NETLIB_OPT_SET_CALLBACK, (void*)imconn_callback);
    netlib_option(handle, NETLIB_OPT_SET_CALLBACK_DATA, (void*)conn_map);
}

　　小L(loginserv)：这门我一直给你留着（长连接），你下次来有啥事直接自己搞吧（设置回调函数，imconn_callback）

　　5、我们看到，这里设置的回调函数是imconn_callback，这个函数在CLoginConn的父类中实现。具体如下：

void imconn_callback(void* callback_data, uint8_t msg, uint32_t handle, void* pParam)
{
    NOTUSED_ARG(handle);
    NOTUSED_ARG(pParam);

    if (!callback_data)
        return;

    ConnMap_t* conn_map = (ConnMap_t*)callback_data;
    CImConn* pConn = FindImConn(conn_map, handle);
    if (!pConn)
        return;

    //log("msg=%d, handle=%d ", msg, handle);

    switch (msg)
    {
    case NETLIB_MSG_CONFIRM:
        pConn->OnConfirm();
        break;
    case NETLIB_MSG_READ:
        pConn->OnRead();
        break;
    case NETLIB_MSG_WRITE:
        pConn->OnWrite();
        break;
    case NETLIB_MSG_CLOSE:
        pConn->OnClose();
        break;
    default:
        log("!!!imconn_callback error msg: %d ", msg);
        break;
    }

    pConn->ReleaseRef();
}

　　这个连接至此已经建立完成，接下来就可以互相发消息了，

　　msgserv向loginserv发的消息有三个，可以从CLoginConn的handlePdu的方法中看出，handlePdu是父类CImConn的onRead方法中会调用的方案，CLoginConn重载了handlePdu，onRead在执行时，调用的是子类的handlePdu方法，实现如下：

void CLoginConn::HandlePdu(CImPdu* pPdu)
{
    switch (pPdu->GetCommandId()) {
        case CID_OTHER_HEARTBEAT:
            break;
        case CID_OTHER_MSG_SERV_INFO:
            _HandleMsgServInfo(pPdu);
            break;
        case CID_OTHER_USER_CNT_UPDATE:
            _HandleUserCntUpdate(pPdu);
            break;
        case CID_LOGIN_REQ_MSGSERVER:
            _HandleMsgServRequest(pPdu);
            break;

        default:
            log("wrong msg, cmd id=%d ", pPdu->GetCommandId());
            break;
    }
}

1、心跳CID_OTHER_HERTBBEAT 2、告知msgserv的服务器信息，CID_OTHER_MSG_SERV_INFO  3、更新msgserv的承载用户数 CID_OTHER_USER_CNT_UPDATE

第四个消息是给客户端的。

　　下面介绍第二个listen函数，这里是客户端接入的逻辑，套路和服务端类似

　　1、netlib_listen(client_listen_ip_list.GetItem(i), client_port, client_callback, NULL);

　　2、会走到_AcceptNewSocket

　　3、走到 client_callback的逻辑

void client_callback(void* callback_data, uint8_t msg, uint32_t handle, void* pParam)
{
    if (msg == NETLIB_MSG_CONNECT)
    {
        CLoginConn* pConn = new CLoginConn();
        pConn->OnConnect2(handle, LOGIN_CONN_TYPE_CLIENT);
    }
    else
    {
        log("!!!error msg: %d ", msg);
    }
}

　　4、设置客户端fd的回调imconn_callback

　　5、连接建立成功，客户端的交互只有一个消息，即CID_LOGIN_REQ_MSGSERVER，这个消息是申请一个msgserv，所以msgserv会先和loginserv进行通信，客户端才能申请到msgserv。

 

　　HttpConn的部分套路和上面略有不同，这里也罗列下：

　　1、netlib_listen(http_listen_ip_list.GetItem(i), http_port, http_callback, NULL);

　　2、会走到_AcceptNewSocket

　　3、走到http_callback的逻辑

void http_callback(void* callback_data, uint8_t msg, uint32_t handle, void* pParam)
{
    if (msg == NETLIB_MSG_CONNECT)
    {
        CHttpConn* pConn = new CHttpConn();
        pConn->OnConnect(handle);
    }
    else
    {
        log("!!!error msg: %d ", msg);
    }
}

　　4、OnConnet方法设置客户端的回调函数 httpconn_callback

void httpconn_callback(void* callback_data, uint8_t msg, uint32_t handle, uint32_t uParam, void* pParam)
{
    NOTUSED_ARG(uParam);
    NOTUSED_ARG(pParam);

    // convert void* to uint32_t, oops
    uint32_t conn_handle = *((uint32_t*)(&callback_data));
    CHttpConn* pConn = FindHttpConnByHandle(conn_handle);
    if (!pConn) {
        return;
    }

    switch (msg)
    {
    case NETLIB_MSG_READ:
        pConn->OnRead();
        break;
    case NETLIB_MSG_WRITE:
        pConn->OnWrite();
        break;
    case NETLIB_MSG_CLOSE:
        pConn->OnClose();
        break;
    default:
        log("!!!httpconn_callback error msg: %d ", msg);
        break;
    }
}

　　5、连接成功建立，CHttpConn本身不继承自CImConn，因为协议不一样，所以消息处理，直接在onRead方法中，只处理了一个消息，即CID_LOGIN_REQ_MSGSERVER，但不是通过消息判断的，而是通过url判断的，具体如下：

    m_cHttpParser.ParseHttpContent(in_buf, buf_len);

    if (m_cHttpParser.IsReadAll()) {
        string url =  m_cHttpParser.GetUrl();
        if (strncmp(url.c_str(), "/msg_server", 11) == 0) {
            string content = m_cHttpParser.GetBodyContent();
            _HandleMsgServRequest(url, content);
        } else {
            log("url unknown, url=%s ", url.c_str());
            Close();
        }
    }

　　判断url中包含/msg_server字符串，即执行_HandleMsgServRequest函数。

 　  loginserv服务角色上，也是msgserv的资源管理器，或者说进行了简单的负载均衡器，loginserv还有点类似医院的挂号处，所有客户端都得来走一遭，挂个号，给你分配医生（msgserv）。

　　说点别的，看了下TT架构师的关于TT架构的文章http://mogu.io/im-server-develop-01-8，里面提到这样一句话：

　　“目前我们的IM服务器架构设计的单机并发连接10万用户，总并发用户量可以达百万级，对于这样规模的服务器后台，可以采用很简单的架构来处理。有一个DispatchServer来分配客户端到一个消息服务器，消息服务器之间的数据交互通过一个中心的RouteServer来转发，和数据持久化层之间的交互由DBProxy服务器来处理.”

　　所以我想loginserv，应该是预想的DispatchServer的角色。

转载于:https://www.cnblogs.com/xiaomengaliang/p/7663299.html