update

transmite/CMakeLists.txt

@@ -0,0 +1,92 @@
+# 1. 添加cmake版本说明
+cmake_minimum_required(VERSION 3.1.3)
+# 2. 声明工程名称
+project(transmite_server)
+
+set(target "transmite_server")
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g")
+
+# 3. 检测并生成ODB框架代码
+#   1. 添加所需的proto映射代码文件名称
+set(proto_path ${CMAKE_CURRENT_SOURCE_DIR}/../proto)
+set(proto_files base.proto user.proto transmite.proto)
+#   2. 检测框架代码文件是否已经生成
+set(proto_hxx "")
+set(proto_cxx "")
+set(proto_srcs "")
+foreach(proto_file ${proto_files})
+#   3. 如果没有生成，则预定义生成指令 -- 用于在构建项目之间先生成框架代码
+    string(REPLACE ".proto" ".pb.cc" proto_cc ${proto_file})
+    string(REPLACE ".proto" ".pb.h" proto_hh  ${proto_file})
+    if (NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}${proto_cc})
+        add_custom_command(
+            PRE_BUILD
+            COMMAND protoc
+            ARGS --cpp_out=${CMAKE_CURRENT_BINARY_DIR} -I ${proto_path} --experimental_allow_proto3_optional ${proto_path}/${proto_file}
+            DEPENDS ${proto_path}/${proto_file}
+            OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${proto_cc}
+            COMMENT "生成Protobuf框架代码文件:" ${CMAKE_CURRENT_BINARY_DIR}/${proto_cc}
+        )
+    endif()
+    list(APPEND proto_srcs ${CMAKE_CURRENT_BINARY_DIR}/${proto_cc})
+endforeach()
+
+# 3. 检测并生成ODB框架代码
+#   1. 添加所需的odb映射代码文件名称
+set(odb_path ${CMAKE_CURRENT_SOURCE_DIR}/../odb)
+set(odb_files chat_session_member.hxx)
+#   2. 检测框架代码文件是否已经生成
+set(odb_hxx "")
+set(odb_cxx "")
+set(odb_srcs "")
+foreach(odb_file ${odb_files})
+#   3. 如果没有生成，则预定义生成指令 -- 用于在构建项目之间先生成框架代码
+    string(REPLACE ".hxx" "-odb.hxx" odb_hxx ${odb_file})
+    string(REPLACE ".hxx" "-odb.cxx" odb_cxx ${odb_file})
+    if (NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}${odb_cxx})
+        add_custom_command(
+            PRE_BUILD
+            COMMAND odb
+            ARGS -d mysql --std c++11 --generate-query --generate-schema --profile boost/date-time ${odb_path}/${odb_file}
+            DEPENDS ${odb_path}/${odb_file}
+            OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${odb_cxx}
+            COMMENT "生成ODB框架代码文件:" ${CMAKE_CURRENT_BINARY_DIR}/${odb_cxx}
+        )
+    endif()
+#   4. 将所有生成的框架源码文件名称保存起来 student-odb.cxx classes-odb.cxx
+    list(APPEND odb_srcs ${CMAKE_CURRENT_BINARY_DIR}/${odb_cxx})
+endforeach()
+
+# 4. 获取源码目录下的所有源码文件
+set(src_files "")
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/source src_files)
+# 5. 声明目标及依赖
+add_executable(${target} ${src_files} ${proto_srcs} ${odb_srcs})
+# 7. 设置需要连接的库
+target_link_libraries(${target} -lgflags 
+    -lspdlog -lfmt -lbrpc -lssl -lcrypto 
+    -lprotobuf -lleveldb -letcd-cpp-api 
+    -lcpprest -lcurl -lodb-mysql -lodb -lodb-boost
+    -lamqpcpp -lev)
+
+
+set(trans_user_client "trans_user_client")
+set(trans_user_files ${CMAKE_CURRENT_SOURCE_DIR}/test/user_client.cc)
+add_executable(${trans_user_client} ${trans_user_files} ${proto_srcs})
+target_link_libraries(${trans_user_client} -pthread -lgtest -lgflags -lspdlog -lfmt -lbrpc -lssl -lcrypto -lprotobuf -lleveldb -letcd-cpp-api -lcpprest -lcurl /usr/lib/x86_64-linux-gnu/libjsoncpp.so.19)
+
+set(transmite_client "transmite_client")
+set(transmite_files ${CMAKE_CURRENT_SOURCE_DIR}/test/transmite_client.cc)
+add_executable(${transmite_client} ${transmite_files} ${proto_srcs})
+target_link_libraries(${transmite_client} -pthread -lgtest -lgflags -lspdlog -lfmt -lbrpc -lssl -lcrypto -lprotobuf -lleveldb -letcd-cpp-api -lcpprest -lcurl /usr/lib/x86_64-linux-gnu/libjsoncpp.so.19)
+
+
+# 6. 设置头文件默认搜索路径
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../common)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../odb)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../third/include)
+
+#8. 设置安装路径
+INSTALL(TARGETS ${target} ${trans_user_client} ${transmite_client} RUNTIME DESTINATION bin)

transmite/dockerfile

@@ -0,0 +1,16 @@
+# 声明基础经镜像来源
+FROM debian:12
+
+# 声明工作目录
+WORKDIR /im
+RUN mkdir -p /im/logs &&\
+    mkdir -p /im/data &&\
+    mkdir -p /im/conf &&\
+    mkdir -p /im/bin
+
+# 将可执行程序依赖，拷贝进镜像
+COPY ./build/transmite_server /im/bin/
+# 将可执行程序文件，拷贝进镜像
+COPY ./depends /lib/x86_64-linux-gnu/
+# 设置容器启动的默认操作 ---运行程序
+CMD /im/bin/transmite_server -flagfile=/im/conf/transmite_server.conf

transmite/source/transmite_server.cc

@@ -0,0 +1,51 @@
+//主要实现语音识别子服务的服务器的搭建
+#include "transmite_server.hpp"
+
+DEFINE_bool(run_mode, false, "程序的运行模式，false-调试； true-发布；");
+DEFINE_string(log_file, "", "发布模式下，用于指定日志的输出文件");
+DEFINE_int32(log_level, 0, "发布模式下，用于指定日志输出等级");
+
+DEFINE_string(registry_host, "http://127.0.0.1:2379", "服务注册中心地址");
+DEFINE_string(instance_name, "/transmite_service/instance", "当前实例名称");
+DEFINE_string(access_host, "127.0.0.1:10004", "当前实例的外部访问地址");
+
+DEFINE_int32(listen_port, 10004, "Rpc服务器监听端口");
+DEFINE_int32(rpc_timeout, -1, "Rpc调用超时时间");
+DEFINE_int32(rpc_threads, 1, "Rpc的IO线程数量");
+
+DEFINE_string(base_service, "/service", "服务监控根目录");
+DEFINE_string(user_service, "/service/user_service", "用户管理子服务名称");
+
+DEFINE_string(mysql_host, "127.0.0.1", "Mysql服务器访问地址");
+DEFINE_string(mysql_user, "root", "Mysql服务器访问用户名");
+DEFINE_string(mysql_pswd, "123456", "Mysql服务器访问密码");
+DEFINE_string(mysql_db, "bite_im", "Mysql默认库名称");
+DEFINE_string(mysql_cset, "utf8", "Mysql客户端字符集");
+DEFINE_int32(mysql_port, 0, "Mysql服务器访问端口");
+DEFINE_int32(mysql_pool_count, 4, "Mysql连接池最大连接数量");
+
+DEFINE_string(mq_user, "root", "消息队列服务器访问用户名");
+DEFINE_string(mq_pswd, "123456", "消息队列服务器访问密码");
+DEFINE_string(mq_host, "127.0.0.1:5672", "消息队列服务器访问地址");
+DEFINE_string(mq_msg_exchange, "msg_exchange", "持久化消息的发布交换机名称");
+DEFINE_string(mq_msg_queue, "msg_queue", "持久化消息的发布队列名称");
+DEFINE_string(mq_msg_binding_key, "msg_queue", "持久化消息的发布队列名称");
+
+
+int main(int argc, char *argv[])
+{
+    google::ParseCommandLineFlags(&argc, &argv, true);
+    bite_im::init_logger(FLAGS_run_mode, FLAGS_log_file, FLAGS_log_level);
+
+    bite_im::TransmiteServerBuilder tsb;
+    tsb.make_mq_object(FLAGS_mq_user, FLAGS_mq_pswd, FLAGS_mq_host,
+        FLAGS_mq_msg_exchange, FLAGS_mq_msg_queue, FLAGS_mq_msg_binding_key);
+    tsb.make_mysql_object(FLAGS_mysql_user, FLAGS_mysql_pswd, FLAGS_mysql_host, 
+        FLAGS_mysql_db, FLAGS_mysql_cset, FLAGS_mysql_port, FLAGS_mysql_pool_count);
+    tsb.make_discovery_object(FLAGS_registry_host, FLAGS_base_service, FLAGS_user_service);
+    tsb.make_rpc_server(FLAGS_listen_port, FLAGS_rpc_timeout, FLAGS_rpc_threads);
+    tsb.make_registry_object(FLAGS_registry_host, FLAGS_base_service + FLAGS_instance_name, FLAGS_access_host);
+    auto server = tsb.build();
+    server->start();
+    return 0;
+}

transmite/source/transmite_server.hpp

@@ -0,0 +1,235 @@
+//实现语音识别子服务
+#include <brpc/server.h>
+#include <butil/logging.h>
+
+#include "etcd.hpp"     // 服务注册模块封装
+#include "logger.hpp"   // 日志模块封装
+#include "rabbitmq.hpp"
+#include "channel.hpp"
+#include "utils.hpp"
+#include "mysql_chat_session_member.hpp"
+
+#include "base.pb.h"  // protobuf框架代码
+#include "user.pb.h"  // protobuf框架代码
+#include "transmite.pb.h"  // protobuf框架代码
+
+namespace bite_im{
+class TransmiteServiceImpl : public bite_im::MsgTransmitService {
+    public:
+        TransmiteServiceImpl(const std::string &user_service_name,
+            const ServiceManager::ptr &channels,
+            const std::shared_ptr<odb::core::database> &mysql_client,
+            const std::string &exchange_name,
+            const std::string &routing_key,
+            const MQClient::ptr &mq_client):
+            _user_service_name(user_service_name),
+            _mm_channels(channels),
+            _mysql_session_member_table(std::make_shared<ChatSessionMemeberTable>(mysql_client)),
+            _exchange_name(exchange_name),
+            _routing_key(routing_key),
+            _mq_client(mq_client){}
+        ~TransmiteServiceImpl(){}
+        void GetTransmitTarget(google::protobuf::RpcController* controller,
+                       const ::bite_im::NewMessageReq* request,
+                       ::bite_im::GetTransmitTargetRsp* response,
+                       ::google::protobuf::Closure* done) override {
+            brpc::ClosureGuard rpc_guard(done);
+            auto err_response = [this, response](const std::string &rid, 
+                const std::string &errmsg) -> void {
+                response->set_request_id(rid);
+                response->set_success(false);
+                response->set_errmsg(errmsg);
+                return;
+            };
+            //从请求中获取关键信息：用户ID，所属会话ID，消息内容
+            std::string rid = request->request_id();
+            std::string uid = request->user_id();
+            std::string chat_ssid = request->chat_session_id();
+            const MessageContent &content = request->message();
+            // 进行消息组织：发送者-用户子服务获取信息，所属会话，消息内容，产生时间，消息ID
+            auto channel = _mm_channels->choose(_user_service_name);
+            if (!channel) {
+                LOG_ERROR("{}-{} 没有可供访问的用户子服务节点！", rid, _user_service_name);
+                return err_response(rid, "没有可供访问的用户子服务节点！");
+            }
+            UserService_Stub stub(channel.get());
+            GetUserInfoReq req;
+            GetUserInfoRsp rsp;
+            req.set_request_id(rid);
+            req.set_user_id(uid);
+            brpc::Controller cntl;
+            stub.GetUserInfo(&cntl, &req, &rsp, nullptr);
+            if (cntl.Failed() == true || rsp.success() == false) {
+                LOG_ERROR("{} - 用户子服务调用失败：{}！", request->request_id(), cntl.ErrorText());
+                return err_response(request->request_id(), "用户子服务调用失败!");
+            }
+            MessageInfo message;
+            message.set_message_id(uuid());
+            message.set_chat_session_id(chat_ssid);
+            message.set_timestamp(time(nullptr));
+            message.mutable_sender()->CopyFrom(rsp.user_info());
+            message.mutable_message()->CopyFrom(content);
+            // 获取消息转发客户端用户列表
+            auto target_list = _mysql_session_member_table->members(chat_ssid);
+            // 将封装完毕的消息，发布到消息队列，待消息存储子服务进行消息持久化
+            bool ret = _mq_client->publish(_exchange_name, message.SerializeAsString(), _routing_key);
+            if (ret == false) {
+                LOG_ERROR("{} - 持久化消息发布失败：{}！", request->request_id(), cntl.ErrorText());
+                return err_response(request->request_id(), "持久化消息发布失败：!");
+            }
+            //组织响应
+            response->set_request_id(rid);
+            response->set_success(true);
+            response->mutable_message()->CopyFrom(message);
+            for (const auto &id : target_list) {
+                response->add_target_id_list(id);
+            }
+        }
+    private:
+        //用户子服务调用相关信息
+        std::string _user_service_name;
+        ServiceManager::ptr _mm_channels;
+
+        //聊天会话成员表的操作句柄
+        ChatSessionMemeberTable::ptr _mysql_session_member_table;
+
+        //消息队列客户端句柄
+        std::string _exchange_name;
+        std::string _routing_key;
+        MQClient::ptr _mq_client;
+};
+
+class TransmiteServer {
+    public:
+        using ptr = std::shared_ptr<TransmiteServer>;
+        TransmiteServer(
+            const std::shared_ptr<odb::core::database> &mysql_client,
+            const Discovery::ptr discovery_client,
+            const Registry::ptr &registry_client,
+            const std::shared_ptr<brpc::Server> &server):
+            _service_discoverer(discovery_client),
+            _registry_client(registry_client),
+            _mysql_client(mysql_client),
+            _rpc_server(server){}
+        ~TransmiteServer(){}
+        //搭建RPC服务器，并启动服务器
+        void start() {
+            _rpc_server->RunUntilAskedToQuit();
+        }
+    private:
+        Discovery::ptr _service_discoverer; //服务发现客户端
+        Registry::ptr _registry_client; // 服务注册客户端
+        std::shared_ptr<odb::core::database> _mysql_client; //mysql数据库客户端
+        std::shared_ptr<brpc::Server> _rpc_server;
+};
+
+class TransmiteServerBuilder {
+    public:
+        //构造mysql客户端对象
+        void make_mysql_object(
+            const std::string &user,
+            const std::string &pswd,
+            const std::string &host,
+            const std::string &db,
+            const std::string &cset,
+            int port,
+            int conn_pool_count) {
+            _mysql_client = ODBFactory::create(user, pswd, host, db, cset, port, conn_pool_count);
+        }
+        //用于构造服务发现客户端&信道管理对象
+        void make_discovery_object(const std::string &reg_host,
+            const std::string &base_service_name,
+            const std::string &user_service_name) {
+            _user_service_name = user_service_name;
+            _mm_channels = std::make_shared<ServiceManager>();
+            _mm_channels->declared(user_service_name);
+            LOG_DEBUG("设置用户子服务为需添加管理的子服务：{}", user_service_name);
+            auto put_cb = std::bind(&ServiceManager::onServiceOnline, _mm_channels.get(), std::placeholders::_1, std::placeholders::_2);
+            auto del_cb = std::bind(&ServiceManager::onServiceOffline, _mm_channels.get(), std::placeholders::_1, std::placeholders::_2);
+            _service_discoverer = std::make_shared<Discovery>(reg_host, base_service_name, put_cb, del_cb);
+        }
+        //用于构造服务注册客户端对象
+        void make_registry_object(const std::string &reg_host,
+            const std::string &service_name,
+            const std::string &access_host) {
+            _registry_client = std::make_shared<Registry>(reg_host);
+            _registry_client->registry(service_name, access_host);
+        }
+        //用于构造rabbitmq客户端对象
+        void make_mq_object(const std::string &user, 
+            const std::string &passwd,
+            const std::string &host,
+            const std::string &exchange_name,
+            const std::string &queue_name,
+            const std::string &binding_key) {
+            _routing_key = binding_key;
+            _exchange_name = exchange_name;
+            _mq_client = std::make_shared<MQClient>(user, passwd, host);
+            _mq_client->declareComponents(exchange_name, queue_name, binding_key);
+        }
+        //构造RPC服务器对象
+        void make_rpc_server(uint16_t port, int32_t timeout, uint8_t num_threads) {
+            if (!_mq_client) {
+                LOG_ERROR("还未初始化消息队列客户端模块！");
+                abort();
+            }
+            if (!_mm_channels) {
+                LOG_ERROR("还未初始化信道管理模块！");
+                abort();
+            }
+            if (!_mysql_client) {
+                LOG_ERROR("还未初始化Mysql数据库模块！");
+                abort();
+            }
+
+            _rpc_server = std::make_shared<brpc::Server>();
+
+            TransmiteServiceImpl *transmite_service = new TransmiteServiceImpl(
+                _user_service_name, _mm_channels, _mysql_client, _exchange_name, _routing_key, _mq_client);
+
+            int ret = _rpc_server->AddService(transmite_service, 
+                brpc::ServiceOwnership::SERVER_OWNS_SERVICE);
+            if (ret == -1) {
+                LOG_ERROR("添加Rpc服务失败！");
+                abort();
+            }
+            brpc::ServerOptions options;
+            options.idle_timeout_sec = timeout;
+            options.num_threads = num_threads;
+            ret = _rpc_server->Start(port, &options);
+            if (ret == -1) {
+                LOG_ERROR("服务启动失败！");
+                abort();
+            }
+        }
+        TransmiteServer::ptr build() {
+            if (!_service_discoverer) {
+                LOG_ERROR("还未初始化服务发现模块！");
+                abort();
+            }
+            if (!_registry_client) {
+                LOG_ERROR("还未初始化服务注册模块！");
+                abort();
+            }
+            if (!_rpc_server) {
+                LOG_ERROR("还未初始化RPC服务器模块！");
+                abort();
+            }
+            TransmiteServer::ptr server = std::make_shared<TransmiteServer>(
+                _mysql_client, _service_discoverer, _registry_client, _rpc_server);
+            return server;
+        }
+    private:
+        std::string _user_service_name;
+        ServiceManager::ptr _mm_channels;
+        Discovery::ptr _service_discoverer;
+        
+        std::string _routing_key;
+        std::string _exchange_name;
+        MQClient::ptr _mq_client;
+
+        Registry::ptr _registry_client; // 服务注册客户端
+        std::shared_ptr<odb::core::database> _mysql_client; //mysql数据库客户端
+        std::shared_ptr<brpc::Server> _rpc_server;
+};
+}

transmite/test/mysql_test/main.cc

@@ -0,0 +1,66 @@
+#include "../../../common/mysql_chat_session_member.hpp"
+// #include "../../../odb/chat_session_member.hxx"
+// #include "chat_session_member-odb.hxx"
+#include <gflags/gflags.h>
+
+DEFINE_bool(run_mode, false, "程序的运行模式，false-调试； true-发布；");
+DEFINE_string(log_file, "", "发布模式下，用于指定日志的输出文件");
+DEFINE_int32(log_level, 0, "发布模式下，用于指定日志输出等级");
+
+void append_test(bite_im::ChatSessionMemeberTable &tb) {
+    bite_im::ChatSessionMember csm1("会话ID1", "用户ID1");
+    tb.append(csm1);
+    bite_im::ChatSessionMember csm2("会话ID1", "用户ID2");
+    tb.append(csm2);
+    bite_im::ChatSessionMember csm3("会话ID2", "用户ID3");
+    tb.append(csm3);
+}
+
+void multi_append_test(bite_im::ChatSessionMemeberTable &tb) {
+    
+    // bite_im::ChatSessionMember csm1("会话ID3", "用户ID1");
+    // bite_im::ChatSessionMember csm2("会话ID3", "用户ID2");
+    // bite_im::ChatSessionMember csm3("会话ID3", "用户ID3");
+    // std::vector<bite_im::ChatSessionMember> list = {csm1, csm2, csm3};
+    // tb.append(list);
+
+    std::vector<bite_im::ChatSessionMember> list;
+    list.emplace_back("会话ID3", "用户ID1");
+    list.emplace_back("会话ID3", "用户ID2");
+    list.emplace_back("会话ID3", "用户ID3");
+    tb.append(list);
+}
+
+void remove_test(bite_im::ChatSessionMemeberTable &tb) {
+    bite_im::ChatSessionMember csm3("会话ID2", "用户ID3");
+    tb.remove(csm3);
+}
+
+void ss_members(bite_im::ChatSessionMemeberTable &tb) {
+    auto res = tb.members("会话ID1");
+    for (auto &id : res) {
+        std::cout << id << std::endl;
+    }
+}
+
+void remove_all(bite_im::ChatSessionMemeberTable &tb) {
+    tb.remove("会话ID3");
+}
+
+int main(int argc, char* argv[]) 
+{
+    google::ParseCommandLineFlags(&argc, &argv, true);
+    bite_im::init_logger(FLAGS_run_mode, FLAGS_log_file, FLAGS_log_level);
+
+    auto db = bite_im::ODBFactory::create("root", "123456", "127.0.0.1", "bite_im", "utf8", 0, 1);
+
+    bite_im::ChatSessionMemeberTable csmt(db);
+
+    append_test(csmt);
+    multi_append_test(csmt);
+    // remove_test(csmt);
+    // ss_members(csmt);
+
+    // remove_all(csmt);
+    return 0;
+}

transmite/test/transmite_client.cc

@@ -0,0 +1,129 @@
+//speech_server的测试客户端实现
+//1. 进行服务发现--发现speech_server的服务器节点地址信息并实例化的通信信道
+//2. 读取语音文件数据
+//3. 发起语音识别RPC调用
+
+#include "etcd.hpp"
+#include "channel.hpp"
+#include "utils.hpp"
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+#include <thread>
+#include "transmite.pb.h"
+
+
+DEFINE_bool(run_mode, false, "程序的运行模式，false-调试； true-发布；");
+DEFINE_string(log_file, "", "发布模式下，用于指定日志的输出文件");
+DEFINE_int32(log_level, 0, "发布模式下，用于指定日志输出等级");
+
+DEFINE_string(etcd_host, "http://127.0.0.1:2379", "服务注册中心地址");
+DEFINE_string(base_service, "/service", "服务监控根目录");
+DEFINE_string(transmite_service, "/service/transmite_service", "服务监控根目录");
+
+bite_im::ServiceManager::ptr sm;
+
+void string_message(const std::string &uid, const std::string &sid, const std::string &msg) {
+    auto channel = sm->choose(FLAGS_transmite_service);
+    if (!channel) {
+        std::cout << "获取通信信道失败！" << std::endl;
+        return;
+    }
+    bite_im::MsgTransmitService_Stub stub(channel.get());
+    bite_im::NewMessageReq req;
+    bite_im::GetTransmitTargetRsp rsp;
+    req.set_request_id(bite_im::uuid());
+    req.set_user_id(uid);
+    req.set_chat_session_id(sid);
+    req.mutable_message()->set_message_type(bite_im::MessageType::STRING);
+    req.mutable_message()->mutable_string_message()->set_content(msg);
+    brpc::Controller cntl;
+    stub.GetTransmitTarget(&cntl, &req, &rsp, nullptr);
+    ASSERT_FALSE(cntl.Failed());
+    ASSERT_TRUE(rsp.success());
+}
+
+void image_message(const std::string &uid, const std::string &sid, const std::string &msg) {
+    auto channel = sm->choose(FLAGS_transmite_service);
+    if (!channel) {
+        std::cout << "获取通信信道失败！" << std::endl;
+        return;
+    }
+    bite_im::MsgTransmitService_Stub stub(channel.get());
+    bite_im::NewMessageReq req;
+    bite_im::GetTransmitTargetRsp rsp;
+    req.set_request_id(bite_im::uuid());
+    req.set_user_id(uid);
+    req.set_chat_session_id(sid);
+    req.mutable_message()->set_message_type(bite_im::MessageType::IMAGE);
+    req.mutable_message()->mutable_image_message()->set_image_content(msg);
+    brpc::Controller cntl;
+    stub.GetTransmitTarget(&cntl, &req, &rsp, nullptr);
+    ASSERT_FALSE(cntl.Failed());
+    ASSERT_TRUE(rsp.success());
+}
+
+void speech_message(const std::string &uid, const std::string &sid, const std::string &msg) {
+    auto channel = sm->choose(FLAGS_transmite_service);
+    if (!channel) {
+        std::cout << "获取通信信道失败！" << std::endl;
+        return;
+    }
+    bite_im::MsgTransmitService_Stub stub(channel.get());
+    bite_im::NewMessageReq req;
+    bite_im::GetTransmitTargetRsp rsp;
+    req.set_request_id(bite_im::uuid());
+    req.set_user_id(uid);
+    req.set_chat_session_id(sid);
+    req.mutable_message()->set_message_type(bite_im::MessageType::SPEECH);
+    req.mutable_message()->mutable_speech_message()->set_file_contents(msg);
+    brpc::Controller cntl;
+    stub.GetTransmitTarget(&cntl, &req, &rsp, nullptr);
+    ASSERT_FALSE(cntl.Failed());
+    ASSERT_TRUE(rsp.success());
+}
+
+void file_message(const std::string &uid, const std::string &sid, 
+    const std::string &filename, const std::string &content) {
+    auto channel = sm->choose(FLAGS_transmite_service);
+    if (!channel) {
+        std::cout << "获取通信信道失败！" << std::endl;
+        return;
+    }
+    bite_im::MsgTransmitService_Stub stub(channel.get());
+    bite_im::NewMessageReq req;
+    bite_im::GetTransmitTargetRsp rsp;
+    req.set_request_id(bite_im::uuid());
+    req.set_user_id(uid);
+    req.set_chat_session_id(sid);
+    req.mutable_message()->set_message_type(bite_im::MessageType::FILE);
+    req.mutable_message()->mutable_file_message()->set_file_contents(content);
+    req.mutable_message()->mutable_file_message()->set_file_name(filename);
+    req.mutable_message()->mutable_file_message()->set_file_size(content.size());
+    brpc::Controller cntl;
+    stub.GetTransmitTarget(&cntl, &req, &rsp, nullptr);
+    ASSERT_FALSE(cntl.Failed());
+    ASSERT_TRUE(rsp.success());
+}
+
+int main(int argc, char *argv[])
+{
+    google::ParseCommandLineFlags(&argc, &argv, true);
+    bite_im::init_logger(FLAGS_run_mode, FLAGS_log_file, FLAGS_log_level);
+
+    
+    //1. 先构造Rpc信道管理对象
+    sm = std::make_shared<bite_im::ServiceManager>();
+    sm->declared(FLAGS_transmite_service);
+    auto put_cb = std::bind(&bite_im::ServiceManager::onServiceOnline, sm.get(), std::placeholders::_1, std::placeholders::_2);
+    auto del_cb = std::bind(&bite_im::ServiceManager::onServiceOffline, sm.get(), std::placeholders::_1, std::placeholders::_2);
+    //2. 构造服务发现对象
+    bite_im::Discovery::ptr dclient = std::make_shared<bite_im::Discovery>(FLAGS_etcd_host, FLAGS_base_service, put_cb, del_cb);
+    
+    //3. 通过Rpc信道管理对象，获取提供Echo服务的信道
+    string_message("672f-c755e83e-0000", "会话ID1", "吃饭了吗？");
+    string_message("ee55-9043bfd7-0001", "会话ID1", "吃的盖浇饭！！");
+    image_message("672f-c755e83e-0000", "会话ID1", "可爱表情图片数据");
+    speech_message("672f-c755e83e-0000", "会话ID1", "动听猪叫声数据");
+    file_message("672f-c755e83e-0000", "会话ID1", "猪爸爸的文件名称", "猪爸爸的文件数据");
+    return 0;
+}

transmite/test/user_client.cc

@@ -0,0 +1,80 @@
+#include "etcd.hpp"
+#include "channel.hpp"
+#include "utils.hpp"
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+#include <thread>
+#include "user.pb.h"
+#include "base.pb.h"
+
+DEFINE_bool(run_mode, false, "程序的运行模式，false-调试； true-发布；");
+DEFINE_string(log_file, "", "发布模式下，用于指定日志的输出文件");
+DEFINE_int32(log_level, 0, "发布模式下，用于指定日志输出等级");
+
+DEFINE_string(etcd_host, "http://127.0.0.1:2379", "服务注册中心地址");
+DEFINE_string(base_service, "/service", "服务监控根目录");
+DEFINE_string(user_service, "/service/user_service", "服务监控根目录");
+
+bite_im::ServiceManager::ptr user_channels;
+void reg_user(const std::string &nickname, const std::string &pswd) {
+    auto channel = user_channels->choose(FLAGS_user_service);//获取通信信道
+    ASSERT_TRUE(channel);
+
+    bite_im::UserRegisterReq req;
+    req.set_request_id(bite_im::uuid());
+    req.set_nickname(nickname);
+    req.set_password(pswd);
+
+    bite_im::UserRegisterRsp rsp;
+    brpc::Controller cntl;
+    bite_im::UserService_Stub stub(channel.get());
+    stub.UserRegister(&cntl, &req, &rsp, nullptr);
+    ASSERT_FALSE(cntl.Failed());
+    ASSERT_TRUE(rsp.success());
+}
+
+void set_user_avatar(const std::string &uid, const std::string &avatar) {
+    auto channel = user_channels->choose(FLAGS_user_service);//获取通信信道
+    ASSERT_TRUE(channel);
+    bite_im::SetUserAvatarReq req;
+    req.set_request_id(bite_im::uuid());
+    req.set_user_id(uid);
+    req.set_session_id("测试登录会话ID");
+    req.set_avatar(avatar);
+    bite_im::SetUserAvatarRsp rsp;
+    brpc::Controller cntl;
+    bite_im::UserService_Stub stub(channel.get());
+    stub.SetUserAvatar(&cntl, &req, &rsp, nullptr);
+    ASSERT_FALSE(cntl.Failed());
+    ASSERT_TRUE(rsp.success());
+}
+
+int main(int argc, char *argv[])
+{
+    google::ParseCommandLineFlags(&argc, &argv, true);
+    bite_im::init_logger(FLAGS_run_mode, FLAGS_log_file, FLAGS_log_level);
+
+    user_channels = std::make_shared<bite_im::ServiceManager>();
+
+    user_channels->declared(FLAGS_user_service);
+    auto put_cb = std::bind(&bite_im::ServiceManager::onServiceOnline, user_channels.get(), std::placeholders::_1, std::placeholders::_2);
+    auto del_cb = std::bind(&bite_im::ServiceManager::onServiceOffline, user_channels.get(), std::placeholders::_1, std::placeholders::_2);
+    
+    //2. 构造服务发现对象
+    bite_im::Discovery::ptr dclient = std::make_shared<bite_im::Discovery>(FLAGS_etcd_host, FLAGS_base_service, put_cb, del_cb);
+    
+    reg_user("小猪佩奇", "123456");
+    reg_user("小猪乔治", "123456");
+    std::string uid1, uid2;
+    std::cout << "输入佩奇用户ID：";
+    std::fflush(stdout);
+    std::cin >> uid1;
+    std::cout << "输入乔治用户ID：";
+    std::fflush(stdout);
+    std::cin >> uid2;
+    set_user_avatar(uid1, "佩奇的头像数据");
+    set_user_avatar(uid2, "乔治的头像数据");
+    // set_user_avatar("672f-c755e83e-0000", "猪爸爸头像数据");
+    // set_user_avatar("ee55-9043bfd7-0001", "猪妈妈头像数据");
+    return 0;
+}

transmite/transmite_server.conf

@@ -0,0 +1,24 @@
+-run_mode=true
+-log_file=/im/logs/transmite.log
+-log_level=0
+-registry_host=http://10.0.0.235:2379
+-instance_name=/transmite_service/instance
+-access_host=10.0.0.235:10004
+-listen_port=10004
+-rpc_timeout=-1
+-rpc_threads=1
+-base_service=/service
+-user_service=/service/user_service
+-mysql_host=10.0.0.235
+-mysql_user=root
+-mysql_pswd=123456
+-mysql_db=bite_im
+-mysql_cset=utf8
+-mysql_port=0
+-mysql_pool_count=4
+-mq_user=root
+-mq_pswd=123456
+-mq_host=10.0.0.235:5672
+-mq_msg_exchange=msg_exchange
+-mq_msg_queue=msg_queue
+-mq_msg_binding_key=msg_queue