TeamTalk消息服务器（未读计数）

已于 2024-11-02 18:35:53 修改
阅读量640 收藏 5
点赞数 10
分类专栏： Teamtalk 文章标签： 服务器
于 2024-08-31 17:47:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/COOL_jack/article/details/141755029
版权

redis应用

消息序列号和未读消息计数

消息序列号（msg_id）

应用场景：DB_PROXY:sendMessage发送消息的时候使用（保证聊天消息的有序性）
void sendMessage(ClmPdu.uint32_tconn_uuid)
·单聊:CMessageModel:sendMessage
·群聊:CGroupMessageModel::sendMessage

  • 单聊RelateId的的设计思路?
    分析：
    –用户关系表，标识两个用户之间的唯一关系id，用于消息分表。relationId % 消息表数目。
CREATE TABLE `IMRelationShip` (
    `id` int(11) NOT NULL AUTO_INCREMENT,
    `smallId` int(11) unsigned NOT NULL COMMENT '用户A的id',
    `bigId` int(11) unsigned NOT NULL COMMENT '用户B的id',
    `status` tinyint(1) unsigned DEFAULT '0' COMMENT '用户:0-正常, 1-用户A删除,群组:0-正常, 1-被删除',
    `created` int(11) unsigned NOT NULL DEFAULT '0' COMMENT '创建时间',
    `updated` int(11) unsigned NOT NULL DEFAULT '0' COMMENT '更新时间',
    PRIMARY KEY (`id`),
    KEY `idx_smallId_bigId_status_updated` (`smallId`,`bigId`,`status`,`updated`)   
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

答：RelateId 来自于mysql的自增id，取决于两个人之间的id映射。

  • 群聊msg_id和单聊的区别
  • 消息ID为什么这么设计?
    分析如下。
消息计数之单聊

存储在unread连接池所在的redis数据库
key设计：“msg_id_ + nRelateld”

uint32_t CMessageModel::getMsgId(uint32_t nRelateId)
{
    uint32_t nMsgId = 0;
    CacheManager* pCacheManager = CacheManager::getInstance();
    CacheConn* pCacheConn = pCacheManager->GetCacheConn("unread");
    if(pCacheConn)
    {
        string strKey = "msg_id_" + int2string(nRelateId);
        nMsgId = pCacheConn->incrBy(strKey, 1);
        pCacheManager->RelCacheConn(pCacheConn);
    }
    return nMsgId;
}
消息计数之群聊

存储在unread连接池所在的redis数据库
key设计:“group_msg_id_ + group_id”

/**
 *  获取一个群组的msgId，自增，通过redis控制
 *
 *  @param nGroupId 群Id
 *
 *  @return 返回msgId
 */
uint32_t CGroupMessageModel::getMsgId(uint32_t nGroupId)
{
    uint32_t nMsgId = 0;
    CacheManager* pCacheManager = CacheManager::getInstance();
    CacheConn* pCacheConn = pCacheManager->GetCacheConn("unread");
    if(pCacheConn)
    {
        string strKey = "group_msg_id_" + int2string(nGroupId);
        nMsgId = pCacheConn->incrBy(strKey, 1);
        pCacheManager->RelCacheConn(pCacheConn);
    }
    else
    {
        log("no cache connection for unread");
    }
    return nMsgId;
}

未读消息计数

  • 未读消息为什么不可以用MySQL？
未读消息计数之单聊

key设计：“unread_ + int2string(nUserld)”
使用一个hash存储同一个user_id对应不同聊天的未读消息数量
暂时无法在飞书文档外展示此内容
发送消息时，写入数据库后；增加对方未读消息计数调用 incMsgCount 函数接口。

void CMessageModel::incMsgCount(uint32_t nFromId, uint32_t nToId)
{
    CacheManager* pCacheManager = CacheManager::getInstance();
    // increase message count
    CacheConn* pCacheConn = pCacheManager->GetCacheConn("unread");
    if (pCacheConn) {
        pCacheConn->hincrBy("unread_" + int2string(nToId), int2string(nFromId), 1);
        pCacheManager->RelCacheConn(pCacheConn);
    } else {
        log("no cache connection to increase unread count: %d->%d", nFromId, nToId);
    }
}
未读消息计数之群聊

思考：一千人的大群，1个人发信息，其他人都不在线，给每个群成员做未读计数吗?
群聊的未读消息机制如果和单聊做同样样的设计？即收到群聊后对每个群成员聊天数量+1？答：效率低下。
方案如下：

  1. 一个群groud_id对应多个user_id
  2. 同一个groud_id,不同的user_id对应的未读消息数量是不一样的
  3. 每次发消息时群消息数量+1,发消息的个人计数也+1
  4. 未读消息数量：群消息数量 - 个人已读消息数量
    对于群组未读消息，每个人都是不一样的，所以设计如下：
    key为"nGroupld_ + nUserld"结合。
#define GROUP_TOTAL_MSG_COUNTER_REDIS_KEY_SUFFIX    "_im_group_msg"
#define GROUP_USER_MSG_COUNTER_REDIS_KEY_SUFFIX     "_im_user_group"
#define GROUP_COUNTER_SUBKEY_COUNTER_FIELD          "count"

作为消息发送者，首先增加群消息总共的消息数量，同时在发送群聊的时候也要把自己的消息计数设置成和群消息数量一样（即没有未读计数）。

/**
 *  增加群消息计数
 *
 *  @param nUserId  用户Id
 *  @param nGroupId 群组Id
 *
 *  @return 成功返回true，失败返回false
 */
bool CGroupMessageModel::incMessageCount(uint32_t nUserId, uint32_t nGroupId)
{
    bool bRet = false;
    CacheManager* pCacheManager = CacheManager::getInstance();
    CacheConn* pCacheConn = pCacheManager->GetCacheConn("unread");
    if (pCacheConn)
    {
        string strGroupKey = int2string(nGroupId) + GROUP_TOTAL_MSG_COUNTER_REDIS_KEY_SUFFIX;
        pCacheConn->hincrBy(strGroupKey, GROUP_COUNTER_SUBKEY_COUNTER_FIELD, 1);
        map<string, string> mapGroupCount;
        bool bRet = pCacheConn->hgetAll(strGroupKey, mapGroupCount);
        if(bRet)
        {
            string strUserKey = int2string(nUserId) + "_" + int2string(nGroupId) + GROUP_USER_MSG_COUNTER_REDIS_KEY_SUFFIX;
            string strReply = pCacheConn->hmset(strUserKey, mapGroupCount);
            if(!strReply.empty())
            {
                bRet = true;
            }
            else
            {
                log("hmset %s failed !", strUserKey.c_str());
            }
        }
        else
        {
            log("hgetAll %s failed!", strGroupKey.c_str());
        }
        pCacheManager->RelCacheConn(pCacheConn);
    }
    else
    {
        log("no cache connection for unread");
    }
    return bRet;
}

清除未读消息计数

单聊和群聊：
客户端读取消息后要发送CID_MSG_READ_ACK给服务器，服务器根据该命令清除未读消息计数。

  • 单聊：直接删除"unread_nUserId" 的key
  • 群聊：更新 “user_id+group_id+_im_user_group”(自己已经读取的消息数量) 对应的value和"group_id+_im_group_msg"（群总共的消息数量）一致
m_handler_map.insert(make_pair(
    uint32_t(CID_MSG_READ_ACK), DB_PROXY::clearUnreadMsgCounter));
 
    void clearUnreadMsgCounter(CImPdu* pPdu, uint32_t conn_uuid)
    {
        IM::Message::IMMsgDataReadAck msg;
        if(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()))
        {
            uint32_t nUserId = msg.user_id();
            uint32_t nFromId = msg.session_id();
            IM::BaseDefine::SessionType nSessionType = msg.session_type();
            CUserModel::getInstance()->clearUserCounter(nUserId, nFromId, nSessionType);
            log("userId=%u, peerId=%u, type=%u", nFromId, nUserId, nSessionType);
        }
        else
        {
            log("parse pb failed");
        }
    }
void CUserModel::clearUserCounter(uint32_t nUserId, uint32_t nPeerId, IM::BaseDefine::SessionType nSessionType)
{
    if(IM::BaseDefine::SessionType_IsValid(nSessionType))
    {
        CacheManager* pCacheManager = CacheManager::getInstance();
        CacheConn* pCacheConn = pCacheManager->GetCacheConn("unread");
        if (pCacheConn)
        {
            // Clear P2P msg Counter
            if(nSessionType == IM::BaseDefine::SESSION_TYPE_SINGLE)
            {
                int nRet = pCacheConn->hdel("unread_" + int2string(nUserId), int2string(nPeerId));
                if(!nRet)
                {
                    log("hdel failed %d->%d", nPeerId, nUserId);
                }
            }
            // Clear Group msg Counter
            else if(nSessionType == IM::BaseDefine::SESSION_TYPE_GROUP)
            {
                string strGroupKey = int2string(nPeerId) + GROUP_TOTAL_MSG_COUNTER_REDIS_KEY_SUFFIX;
                map<string, string> mapGroupCount;
                bool bRet = pCacheConn->hgetAll(strGroupKey, mapGroupCount);
                if(bRet)
                {
                    string strUserKey = int2string(nUserId) + "_" + int2string(nPeerId) + GROUP_USER_MSG_COUNTER_REDIS_KEY_SUFFIX;
                    string strReply = pCacheConn->hmset(strUserKey, mapGroupCount);
                    if(strReply.empty()) {
                        log("hmset %s failed !", strUserKey.c_str());
                    }
                }
                else
                {
                    log("hgetall %s failed!", strGroupKey.c_str());
                }
                
            }
            pCacheManager->RelCacheConn(pCacheConn);
        }
        else
        {
            log("no cache connection for unread");
        }
    }
    else{
        log("invalid sessionType. userId=%u, fromId=%u, sessionType=%u", nUserId, nPeerId, nSessionType);
    }
}

信令和协议设计

enum MessageCmdID {
   // ...... 省略无关逻辑 
  CID_MSG_UNREAD_CNT_REQUEST = 775,
  CID_MSG_UNREAD_CNT_RESPONSE = 776,
   // ...... 省略无关逻辑 
};

message IMUnreadMsgCntReq{
	//cmd id:		0x0307
	required uint32 user_id = 1;
	optional bytes attach_data = 20;	
}

message IMUnreadMsgCntRsp{
	//cmd id:		0x0308
	required uint32 user_id = 1;
	required uint32 total_cnt = 2; // 多个人的未读消息
	repeated IM.BaseDefine.UnreadInfo unreadinfo_list = 3;
	optional bytes attach_data = 20;
}

message UnreadInfo{
	required uint32 session_id = 1; // 会话ID
	required SessionType session_type = 2; // 会话类型
	required uint32 unread_cnt = 3; // 未读消息数量
	required uint32 latest_msg_id = 4; // 最新的消息ID
	required bytes latest_msg_data = 5; // 最新的消息
    required MsgType latest_msg_type = 6;  // 消息类型
    required uint32 latest_msg_from_user_id = 7;  //发送的用户id
}

流程图：

请添加图片描述

代码分析

msg_server收到CID_MSG_UNREAD_CNT_REQUEST后调用 CMsgConn::_HandleClientUnreadMsgCntRequest 函数

void CMsgConn::HandlePdu(CImPdu* pPdu)
{
	// ...... 省略无关逻辑 
	switch (pPdu->GetCommandId()) {
         // ...... 省略无关逻辑          
        case CID_MSG_UNREAD_CNT_REQUEST:
            _HandleClientUnreadMsgCntRequest(pPdu );
		break;              
        // ...... 省略无关逻辑 
	}
}

void CMsgConn::_HandleClientUnreadMsgCntRequest(CImPdu* pPdu)
{
	log("HandleClientUnreadMsgCntReq, from_id=%u ", GetUserId());
    IM::Message::IMUnreadMsgCntReq msg;
    CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
    
	CDBServConn* pDBConn = get_db_serv_conn_for_login();
	if (pDBConn) {
		CDbAttachData attach(ATTACH_TYPE_HANDLE, m_handle, 0);
        msg.set_user_id(GetUserId());
        msg.set_attach_data(attach.GetBuffer(), attach.GetLength());
        pPdu->SetPBMsg(&msg);
        pDBConn->SendPdu(pPdu);
	}
}

db_proxy_server收到CID_MSG_UNREAD_CNT_REQUEST后调用 DB_PROXY::getUnreadMsgCounter函数

值得注意的是，返回的未读消息里面包含每个会话的未读消息个数，消息类型，最后一条消息。

m_handler_map.insert(make_pair(uint32_t(CID_MSG_UNREAD_CNT_REQUEST), DB_PROXY::getUnreadMsgCounter));

void getUnreadMsgCounter(CImPdu* pPdu, uint32_t conn_uuid)
{
        IM::Message::IMUnreadMsgCntReq msg;
        IM::Message::IMUnreadMsgCntRsp msgResp;
        if(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()))
        {
            CImPdu* pPduResp = new CImPdu;

            uint32_t nUserId = msg.user_id();

            list<IM::BaseDefine::UnreadInfo> lsUnreadCount;
            uint32_t nTotalCnt = 0;
            // 从redis获取未读消息数量 和 从mysql获取最后一条未读消息
            CMessageModel::getInstance()->getUnreadMsgCount(nUserId, nTotalCnt, lsUnreadCount);
            CGroupMessageModel::getInstance()->getUnreadMsgCount(nUserId, nTotalCnt, lsUnreadCount);
            msgResp.set_user_id(nUserId);
            msgResp.set_total_cnt(nTotalCnt);
            for(auto it= lsUnreadCount.begin(); it!=lsUnreadCount.end(); ++it)
            {
                IM::BaseDefine::UnreadInfo* pInfo = msgResp.add_unreadinfo_list();
                pInfo->set_session_id(it->session_id());
                pInfo->set_session_type(it->session_type());
                pInfo->set_unread_cnt(it->unread_cnt());
                pInfo->set_latest_msg_id(it->latest_msg_id());
                pInfo->set_latest_msg_data(it->latest_msg_data());
                pInfo->set_latest_msg_type(it->latest_msg_type());
                pInfo->set_latest_msg_from_user_id(it->latest_msg_from_user_id());
            }
                        
            log("userId=%d, unreadCnt=%u, totalCount=%u", nUserId, msgResp.unreadinfo_list_size(), nTotalCnt);
            msgResp.set_attach_data(msg.attach_data());
            pPduResp->SetPBMsg(&msgResp);
            pPduResp->SetSeqNum(pPdu->GetSeqNum());
            pPduResp->SetServiceId(IM::BaseDefine::SID_MSG);
            pPduResp->SetCommandId(IM::BaseDefine::CID_MSG_UNREAD_CNT_RESPONSE);
            CProxyConn::AddResponsePdu(conn_uuid, pPduResp);
        }
        else
        {
            log("parse pb failed");
        }
}

void CMessageModel::getUnreadMsgCount(uint32_t nUserId, uint32_t &nTotalCnt, list<IM::BaseDefine::UnreadInfo>& lsUnreadCount)
{
	// redis
    CacheManager* pCacheManager = CacheManager::getInstance();
    CacheConn* pCacheConn = pCacheManager->GetCacheConn("unread");
    if (pCacheConn)
    {
        map<string, string> mapUnread;
        string strKey = "unread_" + int2string(nUserId);
        bool bRet = pCacheConn->hgetAll(strKey, mapUnread);
        pCacheManager->RelCacheConn(pCacheConn);
        if(bRet)
        {
            IM::BaseDefine::UnreadInfo cUnreadInfo;
            for (auto it = mapUnread.begin(); it != mapUnread.end(); it++) {
                cUnreadInfo.set_session_id(atoi(it->first.c_str()));
                cUnreadInfo.set_unread_cnt(atoi(it->second.c_str()));
                cUnreadInfo.set_session_type(IM::BaseDefine::SESSION_TYPE_SINGLE);
                uint32_t nMsgId = 0;
                string strMsgData;
                IM::BaseDefine::MsgType nMsgType;
                // 从mysql获取最后一条未读消息 mysql
                getLastMsg(cUnreadInfo.session_id(), nUserId, nMsgId, strMsgData, nMsgType); 
                if(IM::BaseDefine::MsgType_IsValid(nMsgType))
                {
                    cUnreadInfo.set_latest_msg_id(nMsgId);
                    cUnreadInfo.set_latest_msg_data(strMsgData);
                    cUnreadInfo.set_latest_msg_type(nMsgType);
                    cUnreadInfo.set_latest_msg_from_user_id(cUnreadInfo.session_id());
                    lsUnreadCount.push_back(cUnreadInfo);
                    nTotalCnt += cUnreadInfo.unread_cnt();
                }
                else
                {
                    log("invalid msgType. userId=%u, peerId=%u, msgType=%u", nUserId, cUnreadInfo.session_id(), nMsgType);
                }
            }
        }
        else
        {
            log("hgetall %s failed!", strKey.c_str());
        }
    }
    else
    {
        log("no cache connection for unread");
    }
}

void CMessageModel::getLastMsg(uint32_t nFromId, uint32_t nToId, uint32_t& nMsgId, string& strMsgData, IM::BaseDefine::MsgType& nMsgType, uint32_t nStatus)
{
    uint32_t nRelateId = CRelationModel::getInstance()->getRelationId(nFromId, nToId, false);
    
    if (nRelateId != INVALID_VALUE)
    {
        CDBManager* pDBManager = CDBManager::getInstance();
        // 读从库
        CDBConn* pDBConn = pDBManager->GetDBConn("teamtalk_slave");
        if (pDBConn)
        {
            string strTableName = "IMMessage_" + int2string(nRelateId % 8);
            string strSql = "select msgId,type,content from " + strTableName + " force index (idx_relateId_status_created) where relateId= " + int2string(nRelateId) + " and status = 0 order by created desc, id desc limit 1";
            CResultSet* pResultSet = pDBConn->ExecuteQuery(strSql.c_str());
            if (pResultSet)
            {
                while (pResultSet->Next())
                {
                    nMsgId = pResultSet->GetInt("msgId");

                    nMsgType = IM::BaseDefine::MsgType(pResultSet->GetInt("type"));
                    if (nMsgType == IM::BaseDefine::MSG_TYPE_SINGLE_AUDIO)
                    {
                        // "[语音]"加密后的字符串
                        strMsgData = strAudioEnc;
                    }
                    else
                    {
                        strMsgData = pResultSet->GetString("content");
                    }
                }
                delete pResultSet;
            }
            else
            {
                log("no result set: %s", strSql.c_str());
            }
            pDBManager->RelDBConn(pDBConn);
        }
        else
        {
            log("no db connection_slave");
        }
    }
    else
    {
        log("no relation between %lu and %lu", nFromId, nToId);
    }
}

db_proxy_server回复信令CID_MSG_UNREAD_CNT_RESPONSE给msg_server，调用CDBServConn::_HandleUnreadMsgCountResponse

void CDBServConn::_HandleUnreadMsgCountResponse(CImPdu* pPdu)
{
    IM::Message::IMUnreadMsgCntRsp msg;
    CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));

	uint32_t user_id = msg.user_id();
    uint32_t total_cnt = msg.total_cnt();
	uint32_t user_unread_cnt = msg.unreadinfo_list_size();
    CDbAttachData attach_data((uchar_t*)msg.attach_data().c_str(), msg.attach_data().length());
	uint32_t handle = attach_data.GetHandle();
	
	log("HandleUnreadMsgCntResp, userId=%u, total_cnt=%u, user_unread_cnt=%u.", user_id,
        total_cnt, user_unread_cnt);

    CMsgConn* pMsgConn = CImUserManager::GetInstance()->GetMsgConnByHandle(user_id, handle);

	if (pMsgConn && pMsgConn->IsOpen()) {
        msg.clear_attach_data();
        pPdu->SetPBMsg(&msg);
        pMsgConn->SendPdu(pPdu);
	}
}
TeamTalk5：TeamTalk 5开发
02-10
TeamTalk 5 TeamTalk 5开发的存储库。 总览 获取用于构建自己的软件的客户端和服务器二进制文件 可用于开发客户端和服务器的库（API） 显示如何构建自己的TeamTalk客户端的示例项目 显示如何构建自己的TeamTalk服务器的示例项目 下载TeamTalk 5 SDK 要构建TeamTalk客户端或服务器项目，必须首先下载以获取客户端和服务器二进制文件。 您也可以试用TeamTalk 5 SDK的最新Beta版。 有些TeamTalk 5 SDK Beta版本仅适用于某些平台，因此，如果未列出您的平台，请尝试以前发布的Beta。 TeamTalk 5库 将客户DLL文件包装在TeamTalk SDK中的项目。 TeamTalkLib （依赖关系： ） 用于构建TeamTalk 5 DLL和服务器可执行文件的源代码 阅读License.txt以获取使用条款
TTServerWin:TeamTalk 服务器端 For Windows
07-12
TeamTalk是一套开源的企业办公即时通讯软件，作为整套系统的组成部分之一，TTServer为TeamTalk 客户端提供用户登录，消息转发及存储等基础服务。 TTServer主要包含了以下几种服务器: - LoginServer (C++): 登录...
TeamTalk 5
weixin_34209406的博客
08-17 361
TeamTalk 5 Repository for TeamTalk 5 development. Download TeamTalk 5 SDK To build the TeamTalk client or server projects you must first download the TeamTalk 5 SDK to obtain the client and server ...
浅谈teamtalk
huosiren44的博客
12-02 989
蘑菇街开源的teamtalk可以作为2-3年初学者学习之用，或者小型公司当作内部im办公交流之用。至于源码讲解，网上开源的挺多。迷茫且闲着没事的初学者们可以简单看看，看网络框架大概一天可以看明白，看业务，大概需要一到两周，需要去centos7.0以上部署下，msgserver可以看完代码配置2个试试，调试。客户端代码也可以简单看看。还是有一定价值的，像网络框架通用，简单，没有过多炫技...
探索高效协作的新篇章：TeamTalk - 一站式团队协作平台
gitblog_00095的博客
04-12 460
探索高效协作的新篇章：TeamTalk - 一站式团队协作平台 TeamTalk 这是我维护的蘑菇街TeamTalk源码版本。 项目地址: https://gitcode.com/gh_mirrors/te/TeamTalk ...
Teamtalk简介
stone-jin
12-06 1690
Teamtalk是 蘑菇街 IM团队开源的一个IM的软件。 github地址:  https://github.com/mogujie/TeamTalk 官方网址:      http://tt.mogu.io/ 官方团队的博客地址：http://mogu.io/ 架构: 开发环境搭建: Windows版本:  Visual Studio 2013 Linux服务器代码:
TeamTalk 服务器思维导图
11-13
TeamTalk服务器思维导图是一个关于TeamTalk平台服务器架构的详细知识体系，旨在帮助理解其核心设计和工作原理。TeamTalk作为一个通信系统，它的服务器架构是支撑实时音视频通话、聊天和协作功能的基础。 1. **...
开源TeamTalk(mogutt)未删减代码
10-13
TeamTalk是一套开源的企业办公即时通讯软件，作为整套系统的组成部分之一，TTServer为TeamTalk 客户端提供用户登录，消息转发及存储等基础服务。 TTServer主要包含了以下几种服务器: LoginServer (C++): 登录服务器...
sctalk:基于spring cloud + Netty实现的聊天，兼容蘑菇街TeamTalk客户端，配合hazelcast提供消息服务器集群功能，同时支持socket和websocket
05-13
当前项目是由蘑菇街的TeamTalk协议，完全用JAVA生态重构而成。以用于线上业务使用，并适当进行了调整，基本上还是与原Teamtalk协议保持兼容。 大家在开发过程中遇到问题，请提交到。 具体文档见doc目录下,安装之前请...
TeamTalk服务器架构及功能思维导图解析
- TeamTalk服务器的设计应考虑与其他即时消息系统（如Y1 IM）的兼容性和对接方式。 9. 文档管理 - 文件名称列表中包含多个以.mmap结尾的文件，表明了TeamTalk可能使用特定的软件或格式来组织其思维导图和相关文档...
teamtalk简介
lcalqf的专栏
10-21 5536
置顶：关于用smart pointer修改的demo源码我放在了我的开源中国的git目录下， 这个地址：http://git.oschina.net/benben-de-eggs/tt-code-fragment 修改基于一个原则，不会动老的接口，也就是说，以前的代码不需要修改成智能指针也一样能编译运行。 文章有点长，而且废话较多，看得不耐烦的同学敬请谅解，本人第一次写博客，有点
TeamTalk——ubuntu服务端部署
s569646547的博客
12-03 3932
这是第二次部署了，第一次在双系统Ubuntu上部署，这次准备在虚拟机上部署，所用版本Ubuntu 14.04.2 32位，上次用的新版64位的。这里要感谢蓝狐的教程http://www.bluefoxah.org/teamtalk/new_tt_deploy.html 一、准本工作 1、更新操作系统(非必须)          sudo apt-get update 2、删除已安装
探索TeamTalk：一个强大的团队协作平台
gitblog_00094的博客
04-05 707
探索TeamTalk：一个强大的团队协作平台 去发现同类优质开源项目:https://gitcode.com/ 是一个开源的、基于Web的团队协作工具，旨在提供高效的沟通、文件共享和任务管理功能。它是一个由 LegendZhouQiang 开发并维护的项目，旨在为各种规模的团队提供一个集中化的协作环境。 技术分析 TeamTalk 基于现代Web技术构建，包括但不限于： 前端框架：采用React...
TeamTalk整体梳理
最新发布
COOL_jack的博客
11-17 1036
答：A发送消息给客户端B，msg_server收到后，直接将数据包转发db_proxy_server，db_proxy_server有一个map来映射信令所对应的处理函数。msg_server连上login_server后会立刻给login_server发一个数据包，该数据包里面含有该msg_server上的用户数量、最大可容纳的用户数量、自己的ip地址和端口号。多个msg_server和db_proxy_server建立连接时，会将每个proxyconn连接和m_uuid一一对应映射起来。
teamtalk mysql.h_TeamTalk编译和部署（一）
weixin_35755823的博客
02-03 166
TeamTalk编译和部署(一)发布时间：2018-07-26 00:10,浏览次数：364, 标签：TeamTalk1、准备环境：CentOS7(在虚拟机上会出现一些问题：安装一些软件后，图形化界面会黑屏，本人部署在腾讯云服务器上，可以使用SSH Secure ShellClient等软件远程连接，传输文件)。2、下载TeamTalk源码(github或者百度网盘均可下载ps：源码写的真的是.....
TeamTalk初学笔记4---关于win-client【第二篇：入口文件teamtalk.cpp】
weixin_34248705的博客
10-17 184
为什么80%的码农都做不了架构师？>>> ...
【teamtalk】企业级办公即时通信软件TeamTalk的安装部署
michaelwoshi的博客
05-05 654
TT 项目背景 https://github.com/mogutt/README https://github.com/meili/TeamTalk TeamTalk 一键部署方案：TTAutoDeploy https://www.open-open.com/lib/view/open1414591839840.html TeamTalk 之 Mac 客户端架构分析 http://blog.makeex.com/2015/05/30/the-architecture-of-teamt..
TeamTalk GroupModel详解
aixiaoql的博客
03-17 1180
此模块用于即时通讯群组管理
探索TeamTalk：一款高效协作的开源项目
gitblog_00027的博客
04-12 633
探索TeamTalk：一款高效协作的开源项目 TeamTalk项目地址:https://gitcode.com/gh_mirrors/tea/TeamTalk 引言 在数字化的世界中，团队间的高效协作至关重要。是一个专为此目的设计的开源项目，它提供了实时通信、文件共享和日程管理等功能，以助力团队提升工作效率。本文将深入探讨TeamTalk的技术背景，功能特性，并解释为什么它值得你的团队采用。 技...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值