xyz/my-chat_-server
1
0
Fork 0
mirror of https://gitee.com/Zhaoxin59/my-chat_-server.git synced 2026-02-14 01:21:50 +08:00
Code Issues Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
凝望
2025-10-13 18:34:48 +08:00
commit 37865d041f
116 changed files with 31168 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
user/CMakeLists.txt Normal file
View File

@ -0,0 +1,93 @@
# 1. 添加cmake版本说明
cmake_minimum_required(VERSION 3.1.3)
# 2. 声明工程名称
project(user_server)
set(target "user_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 file.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 user.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
/usr/lib/x86_64-linux-gnu/libjsoncpp.so.19
-lalibabacloud-sdk-core -lcpr -lelasticlient
-lhiredis -lredis++)
set(test_client "user_client")
set(test_files "")
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/test test_files)
add_executable(${test_client} ${test_files} ${proto_srcs})
target_link_libraries(${test_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} ${test_client} RUNTIME DESTINATION bin)

16
user/dockerfile Normal file
View File

@ -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/user_server /im/bin/
# 将可执行程序文件，拷贝进镜像
COPY ./depends /lib/x86_64-linux-gnu/
# 设置容器启动的默认操作 ---运行程序
CMD /im/bin/user_server -flagfile=/im/conf/user_server.conf

59
user/source/user_server.cc Normal file
View File

@ -0,0 +1,59 @@
//主要实现语音识别子服务的服务器的搭建
#include "user_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, "/user_service/instance", "当前实例名称");
DEFINE_string(access_host, "127.0.0.1:10003", "当前实例的外部访问地址");
DEFINE_int32(listen_port, 10003, "Rpc服务器监听端口");
DEFINE_int32(rpc_timeout, -1, "Rpc调用超时时间");
DEFINE_int32(rpc_threads, 1, "Rpc的IO线程数量");
DEFINE_string(base_service, "/service", "服务监控根目录");
DEFINE_string(file_service, "/service/file_service", "文件管理子服务名称");
DEFINE_string(es_host, "http://127.0.0.1:9200/", "ES搜索引擎服务器URL");
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(redis_host, "127.0.0.1", "Redis服务器访问地址");
DEFINE_int32(redis_port, 6379, "Redis服务器访问端口");
DEFINE_int32(redis_db, 0, "Redis默认库号");
DEFINE_bool(redis_keep_alive, true, "Redis长连接保活选项");
DEFINE_string(dms_key_id, "LTAI5t6NF7vt499UeqYX6LB9", "短信平台密钥ID");
DEFINE_string(dms_key_secret, "5hx1qvpXHDKfQDk73aJs6j53Q8KcF2", "短信平台密钥");
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::UserServerBuilder usb;
// usb.make_dms_object(FLAGS_dms_key_id, FLAGS_dms_key_secret);
usb.make_SendE_object();
usb.make_es_object({FLAGS_es_host});
usb.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);
usb.make_redis_object(FLAGS_redis_host, FLAGS_redis_port, FLAGS_redis_db, FLAGS_redis_keep_alive);
usb.make_discovery_object(FLAGS_registry_host, FLAGS_base_service, FLAGS_file_service);
usb.make_rpc_server(FLAGS_listen_port, FLAGS_rpc_timeout, FLAGS_rpc_threads);
usb.make_registry_object(FLAGS_registry_host, FLAGS_base_service + FLAGS_instance_name, FLAGS_access_host);
auto server = usb.build();
server->start();
return 0;
}

800
user/source/user_server.hpp Normal file
View File

@ -0,0 +1,800 @@
//实现语音识别子服务
#include <brpc/server.h>
#include <butil/logging.h>
#include "data_es.hpp" // es数据管理客户端封装
#include "data_redis.hpp" // redis数据管理客户端封装
#include "mysql_user.hpp" // mysql数据管理客户端封装
#include "etcd.hpp" // 服务注册模块封装
#include "logger.hpp" // 日志模块封装
#include "utils.hpp" // 基础工具接口
// #include "dms.hpp" // 短信平台SDK模块封装
#include "sendemail.hpp" //邮件发送模块
#include "channel.hpp" // 信道管理模块封装
#include "user.hxx"
#include "user-odb.hxx"
#include "user.pb.h" // protobuf框架代码
#include "base.pb.h" // protobuf框架代码
#include "file.pb.h" // protobuf框架代码
namespace bite_im{
class UserServiceImpl : public bite_im::UserService {
public:
UserServiceImpl(const SendEmail::ptr &SendE_client,
//const DMSClient::ptr &dms_client,
const std::shared_ptr<elasticlient::Client> &es_client,
const std::shared_ptr<odb::core::database> &mysql_client,
const std::shared_ptr<sw::redis::Redis> &redis_client,
const ServiceManager::ptr &channel_manager,
const std::string &file_service_name) :
_es_user(std::make_shared<ESUser>(es_client)),
_mysql_user(std::make_shared<UserTable>(mysql_client)),
_redis_session(std::make_shared<Session>(redis_client)),
_redis_status(std::make_shared<Status>(redis_client)),
_redis_codes(std::make_shared<Codes>(redis_client)),
_file_service_name(file_service_name),
_mm_channels(channel_manager),
// _dms_client(dms_client)
_SendE_client(SendE_client)
{
_es_user->createIndex();
}
~UserServiceImpl(){}
bool nickname_check(const std::string &nickname) {
return nickname.size() < 22;
}
bool password_check(const std::string &password) {
if (password.size() < 6 || password.size() > 15) {
LOG_ERROR("密码长度不合法：{}-{}", password, password.size());
return false;
}
for (int i = 0; i < password.size(); i++) {
if (!((password[i] > 'a' && password[i] < 'z') ||
(password[i] > 'A' && password[i] < 'Z') ||
(password[i] > '0' && password[i] < '9') ||
password[i] == '_' || password[i] == '-')) {
LOG_ERROR("密码字符不合法：{}", password);
return false;
}
}
return true;
}
virtual void UserRegister(::google::protobuf::RpcController* controller,
const ::bite_im::UserRegisterReq* request,
::bite_im::UserRegisterRsp* response,
::google::protobuf::Closure* done) {
LOG_DEBUG("收到用户注册请求！");
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;
};
//1. 从请求中取出昵称和密码
std::string nickname = request->nickname();
std::string password = request->password();
//2. 检查昵称是否合法（只能包含字母，数字，连字符-，下划线_，长度限制 3~15 之间）
bool ret = nickname_check(nickname);
if (ret == false) {
LOG_ERROR("{} - 用户名长度不合法！", request->request_id());
return err_response(request->request_id(), "用户名长度不合法！");
}
//3. 检查密码是否合法（只能包含字母，数字，长度限制 6~15 之间）
ret = password_check(password);
if (ret == false) {
LOG_ERROR("{} - 密码格式不合法！", request->request_id());
return err_response(request->request_id(), "密码格式不合法！");
}
//4. 根据昵称在数据库进行判断是否昵称已存在
auto user = _mysql_user->select_by_nickname(nickname);
if (user) {
LOG_ERROR("{} - 用户名被占用- {}！", request->request_id(), nickname);
return err_response(request->request_id(), "用户名被占用!");
}
//5. 向数据库新增数据
std::string uid = uuid();
user = std::make_shared<User>(uid, nickname, password);
ret = _mysql_user->insert(user);
if (ret == false) {
LOG_ERROR("{} - Mysql数据库新增数据失败！", request->request_id());
return err_response(request->request_id(), "Mysql数据库新增数据失败!");
}
//6. 向 ES 服务器中新增用户信息
ret = _es_user->appendData(uid, "", nickname, "", "");
if (ret == false) {
LOG_ERROR("{} - ES搜索引擎新增数据失败！", request->request_id());
return err_response(request->request_id(), "ES搜索引擎新增数据失败！");
}
//7. 组织响应，进行成功与否的响应即可。
response->set_request_id(request->request_id());
response->set_success(true);
}
virtual void UserLogin(::google::protobuf::RpcController* controller,
const ::bite_im::UserLoginReq* request,
::bite_im::UserLoginRsp* response,
::google::protobuf::Closure* done){
LOG_DEBUG("收到用户登录请求！");
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;
};
//1. 从请求中取出昵称和密码
std::string nickname = request->nickname();
std::string password = request->password();
//2. 通过昵称获取用户信息，进行密码是否一致的判断
auto user = _mysql_user->select_by_nickname(nickname);
if (!user || password != user->password()) {
LOG_ERROR("{} - 用户名或密码错误 - {}-{}！", request->request_id(), nickname, password);
return err_response(request->request_id(), "用户名或密码错误!");
}
//3. 根据 redis 中的登录标记信息是否存在判断用户是否已经登录。
bool ret = _redis_status->exists(user->user_id());
if (ret == true) {
LOG_ERROR("{} - 用户已在其他地方登录 - {}！", request->request_id(), nickname);
return err_response(request->request_id(), "用户已在其他地方登录!");
}
//4. 构造会话 ID，生成会话键值对，向 redis 中添加会话信息以及登录标记信息
std::string ssid = uuid();
_redis_session->append(ssid, user->user_id());
//5. 添加用户登录信息
_redis_status->append(user->user_id());
//5. 组织响应，返回生成的会话 ID
response->set_request_id(request->request_id());
response->set_login_session_id(ssid);
response->set_success(true);
}
bool phone_check(const std::string &phone) {
if (phone.size() != 11) return false;
if (phone[0] != '1') return false;
if (phone[1] < '3' || phone[1] > '9') return false;
for (int i = 2; i < 11; i++) {
if (phone[i] < '0' || phone[i] > '9') return false;
}
return true;
}
virtual void GetPhoneVerifyCode(::google::protobuf::RpcController* controller,
const ::bite_im::PhoneVerifyCodeReq* request,
::bite_im::PhoneVerifyCodeRsp* response,
::google::protobuf::Closure* done){
LOG_DEBUG("收到短信验证码获取请求！");
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;
};
// 1. 从请求中取出手机号码
std::string phone = request->phone_number();
// 2. 验证手机号码格式是否正确（必须以 1 开始，第二位 3~9 之间，后边 9 个数字字符）
//由于此处使用的是邮箱，所以进行邮箱格式的验证
// bool ret = phone_check(phone);
// if (ret == false) {
// LOG_ERROR("{} - 手机号码格式错误 - {}！", request->request_id(), phone);
// return err_response(request->request_id(), "手机号码格式错误!");
// }
// 3. 生成 4 位随机验证码
// std::string code_id = uuid();
// std::string code = vcode();
// // 4. 基于短信平台 SDK 发送验证码
// ret = _dms_client->send(phone, code);
// if (ret == false) {
// LOG_ERROR("{} - 短信验证码发送失败 - {}！", request->request_id(), phone);
// return err_response(request->request_id(), "短信验证码发送失败!");
// }
std::string code_id = uuid();
bool ret = _SendE_client->SEND_email(phone);
if (ret == false) {
LOG_ERROR("{} - 邮箱验证码发送失败 - {}！", request->request_id(), phone);
return err_response(request->request_id(), "邮箱验证码发送失败!");
}
// 5. 构造验证码 ID，添加到 redis 验证码映射键值索引中
_redis_codes->append(code_id, _SendE_client->getVerifyCode());
// 6. 组织响应，返回生成的验证码 ID
response->set_request_id(request->request_id());
response->set_success(true);
response->set_verify_code_id(code_id);
LOG_DEBUG("获取邮箱验证码处理完成！");
}
virtual void PhoneRegister(::google::protobuf::RpcController* controller,
const ::bite_im::PhoneRegisterReq* request,
::bite_im::PhoneRegisterRsp* response,
::google::protobuf::Closure* done){
LOG_DEBUG("收到邮箱注册请求！");
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;
};
// 1. 从请求中取出手机号码和验证码,验证码ID
std::string phone = request->phone_number();
std::string code_id = request->verify_code_id();
std::string code = request->verify_code();
// 2. 检查注册手机号码是否合法
// bool ret = phone_check(phone);
// if (ret == false) {
// LOG_ERROR("{} - 手机号码格式错误 - {}！", request->request_id(), phone);
// return err_response(request->request_id(), "手机号码格式错误!");
// }
// 3. 从 redis 数据库中进行验证码 ID-验证码一致性匹配
auto vcode = _redis_codes->code(code_id);
if (vcode != code) {
LOG_ERROR("{} - 验证码错误 - {}-{}！", request->request_id(), code_id, code);
return err_response(request->request_id(), "验证码错误!");
}
// 4. 通过数据库查询判断手机号是否已经注册过
auto user = _mysql_user->select_by_phone(phone);
if (user) {
LOG_ERROR("{} - 该邮箱号已注册过用户 - {}！", request->request_id(), phone);
return err_response(request->request_id(), "该邮箱号已注册过用户!");
}
// 5. 向数据库新增用户信息
std::string uid = uuid();
user = std::make_shared<User>(uid, phone);
bool ret = _mysql_user->insert(user);
if (ret == false) {
LOG_ERROR("{} - 向数据库添加用户信息失败 - {}！", request->request_id(), phone);
return err_response(request->request_id(), "向数据库添加用户信息失败!");
}
// 6. 向 ES 服务器中新增用户信息
ret = _es_user->appendData(uid, phone, uid, "", "");
if (ret == false) {
LOG_ERROR("{} - ES搜索引擎新增数据失败！", request->request_id());
return err_response(request->request_id(), "ES搜索引擎新增数据失败！");
}
//7. 组织响应，进行成功与否的响应即可。
response->set_request_id(request->request_id());
response->set_success(true);
}
virtual void PhoneLogin(::google::protobuf::RpcController* controller,
const ::bite_im::PhoneLoginReq* request,
::bite_im::PhoneLoginRsp* response,
::google::protobuf::Closure* done){
LOG_DEBUG("收到手机号登录请求！");
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;
};
// 1. 从请求中取出手机号码和验证码 ID，以及验证码。
std::string phone = request->phone_number();
std::string code_id = request->verify_code_id();
std::string code = request->verify_code();
// 2. 检查注册手机号码是否合法
// bool ret = phone_check(phone);
// if (ret == false) {
// LOG_ERROR("{} - 手机号码格式错误 - {}！", request->request_id(), phone);
// return err_response(request->request_id(), "手机号码格式错误!");
// }
// 3. 根据手机号从数据数据进行用户信息查询，判断用用户是否存在
auto user = _mysql_user->select_by_phone(phone);
if (!user) {
LOG_ERROR("{} - 该手机号未注册用户 - {}！", request->request_id(), phone);
return err_response(request->request_id(), "该手机号未注册用户!");
}
// 4. 从 redis 数据库中进行验证码 ID-验证码一致性匹配
auto vcode = _redis_codes->code(code_id);
if (vcode != code) {
LOG_ERROR("{} - 验证码错误 - {}-{}！", request->request_id(), code_id, code);
return err_response(request->request_id(), "验证码错误!");
}
_redis_codes->remove(code_id);
// 5. 根据 redis 中的登录标记信息是否存在判断用户是否已经登录。
bool ret = _redis_status->exists(user->user_id());
if (ret == true) {
LOG_ERROR("{} - 用户已在其他地方登录 - {}！", request->request_id(), phone);
return err_response(request->request_id(), "用户已在其他地方登录!");
}
//4. 构造会话 ID，生成会话键值对，向 redis 中添加会话信息以及登录标记信息
std::string ssid = uuid();
_redis_session->append(ssid, user->user_id());
//5. 添加用户登录信息
_redis_status->append(user->user_id());
// 7. 组织响应，返回生成的会话 ID
response->set_request_id(request->request_id());
response->set_login_session_id(ssid);
response->set_success(true);
}
//从这一步开始，用户登录之后才会进行的操作
virtual void GetUserInfo(::google::protobuf::RpcController* controller,
const ::bite_im::GetUserInfoReq* request,
::bite_im::GetUserInfoRsp* response,
::google::protobuf::Closure* done){
LOG_DEBUG("收到获取单个用户信息请求！");
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;
};
// 1. 从请求中取出用户 ID
std::string uid = request->user_id();
// 2. 通过用户 ID，从数据库中查询用户信息
auto user = _mysql_user->select_by_id(uid);
if (!user) {
LOG_ERROR("{} - 未找到用户信息 - {}！", request->request_id(), uid);
return err_response(request->request_id(), "未找到用户信息!");
}
// 3. 根据用户信息中的头像 ID，从文件服务器获取头像文件数据，组织完整用户信息
UserInfo *user_info = response->mutable_user_info();
user_info->set_user_id(user->user_id());
user_info->set_nickname(user->nickname());
user_info->set_description(user->description());
user_info->set_phone(user->phone());
if (!user->avatar_id().empty()) {
//从信道管理对象中，获取到连接了文件管理子服务的channel
auto channel = _mm_channels->choose(_file_service_name);
if (!channel) {
LOG_ERROR("{} - 未找到文件管理子服务节点 - {} - {}！",
request->request_id(), _file_service_name, uid);
return err_response(request->request_id(), "未找到文件管理子服务节点!");
}
//进行文件子服务的rpc请求，进行头像文件下载
bite_im::FileService_Stub stub(channel.get());
bite_im::GetSingleFileReq req;
bite_im::GetSingleFileRsp rsp;
req.set_request_id(request->request_id());
req.set_file_id(user->avatar_id());
brpc::Controller cntl;
stub.GetSingleFile(&cntl, &req, &rsp, nullptr);
if (cntl.Failed() == true || rsp.success() == false) {
LOG_ERROR("{} - 文件子服务调用失败：{}！", request->request_id(), cntl.ErrorText());
return err_response(request->request_id(), "文件子服务调用失败!");
}
user_info->set_avatar(rsp.file_data().file_content());
}
// 4. 组织响应，返回用户信息
response->set_request_id(request->request_id());
response->set_success(true);
}
virtual void GetMultiUserInfo(::google::protobuf::RpcController* controller,
const ::bite_im::GetMultiUserInfoReq* request,
::bite_im::GetMultiUserInfoRsp* response,
::google::protobuf::Closure* done){
LOG_DEBUG("收到批量用户信息获取请求！");
brpc::ClosureGuard rpc_guard(done);
//1. 定义错误回调
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;
};
//2. 从请求中取出用户ID --- 列表
std::vector<std::string> uid_lists;
for (int i = 0; i < request->users_id_size(); i++) {
uid_lists.push_back(request->users_id(i));
}
//3. 从数据库进行批量用户信息查询
auto users = _mysql_user->select_multi_users(uid_lists);
if (users.size() != request->users_id_size()) {
LOG_ERROR("{} - 从数据库查找的用户信息数量不一致 {}-{}！",
request->request_id(), request->users_id_size(), users.size());
return err_response(request->request_id(), "从数据库查找的用户信息数量不一致!");
}
//4. 批量从文件管理子服务进行文件下载
auto channel = _mm_channels->choose(_file_service_name);
if (!channel) {
LOG_ERROR("{} - 未找到文件管理子服务节点 - {}！", request->request_id(), _file_service_name);
return err_response(request->request_id(), "未找到文件管理子服务节点!");
}
bite_im::FileService_Stub stub(channel.get());
bite_im::GetMultiFileReq req;
bite_im::GetMultiFileRsp rsp;
req.set_request_id(request->request_id());
for (auto &user : users) {
if (user.avatar_id().empty()) continue;
req.add_file_id_list(user.avatar_id());
}
brpc::Controller cntl;
stub.GetMultiFile(&cntl, &req, &rsp, nullptr);
if (cntl.Failed() == true || rsp.success() == false) {
LOG_ERROR("{} - 文件子服务调用失败：{} - {}！", request->request_id(),
_file_service_name, cntl.ErrorText());
return err_response(request->request_id(), "文件子服务调用失败!");
}
//5. 组织响应（）
for (auto &user : users) {
auto user_map = response->mutable_users_info();//本次请求要响应的用户信息map
auto file_map = rsp.mutable_file_data(); //这是批量文件请求响应中的map
UserInfo user_info;
user_info.set_user_id(user.user_id());
user_info.set_nickname(user.nickname());
user_info.set_description(user.description());
user_info.set_phone(user.phone());
user_info.set_avatar((*file_map)[user.avatar_id()].file_content());
(*user_map)[user_info.user_id()] = user_info;
}
response->set_request_id(request->request_id());
response->set_success(true);
}
virtual void SetUserAvatar(::google::protobuf::RpcController* controller,
const ::bite_im::SetUserAvatarReq* request,
::bite_im::SetUserAvatarRsp* response,
::google::protobuf::Closure* done)
{
LOG_DEBUG("收到用户头像设置请求！");
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;
};
// 1. 从请求中取出用户 ID 与头像数据
std::string uid = request->user_id();
// 2. 从数据库通过用户 ID 进行用户信息查询，判断用户是否存在
auto user = _mysql_user->select_by_id(uid);
if (!user) {
LOG_ERROR("{} - 未找到用户信息 - {}！", request->request_id(), uid);
return err_response(request->request_id(), "未找到用户信息!");
}
// 3. 上传头像文件到文件子服务，
auto channel = _mm_channels->choose(_file_service_name);
if (!channel) {
LOG_ERROR("{} - 未找到文件管理子服务节点 - {}！", request->request_id(), _file_service_name);
return err_response(request->request_id(), "未找到文件管理子服务节点!");
}
bite_im::FileService_Stub stub(channel.get());
bite_im::PutSingleFileReq req;
bite_im::PutSingleFileRsp rsp;
req.set_request_id(request->request_id());
req.mutable_file_data()->set_file_name("");
req.mutable_file_data()->set_file_size(request->avatar().size());
req.mutable_file_data()->set_file_content(request->avatar());
brpc::Controller cntl;
stub.PutSingleFile(&cntl, &req, &rsp, nullptr);
if (cntl.Failed() == true || rsp.success() == false) {
LOG_ERROR("{} - 文件子服务调用失败：{}！", request->request_id(), cntl.ErrorText());
return err_response(request->request_id(), "文件子服务调用失败!");
}
std::string avatar_id = rsp.file_info().file_id();
// 4. 将返回的头像文件 ID 更新到数据库中
user->avatar_id(avatar_id);
bool ret = _mysql_user->update(user);
if (ret == false) {
LOG_ERROR("{} - 更新数据库用户头像ID失败 ：{}！", request->request_id(), avatar_id);
return err_response(request->request_id(), "更新数据库用户头像ID失败!");
}
// 5. 更新 ES 服务器中用户信息
ret = _es_user->appendData(user->user_id(), user->phone(),
user->nickname(), user->description(), user->avatar_id());
if (ret == false) {
LOG_ERROR("{} - 更新搜索引擎用户头像ID失败 ：{}！", request->request_id(), avatar_id);
return err_response(request->request_id(), "更新搜索引擎用户头像ID失败!");
}
// 6. 组织响应，返回更新成功与否
response->set_request_id(request->request_id());
response->set_success(true);
}
virtual void SetUserNickname(::google::protobuf::RpcController* controller,
const ::bite_im::SetUserNicknameReq* request,
::bite_im::SetUserNicknameRsp* response,
::google::protobuf::Closure* done){
LOG_DEBUG("收到用户昵称设置请求！");
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;
};
// 1. 从请求中取出用户 ID 与新的昵称
std::string uid = request->user_id();
std::string new_nickname = request->nickname();
// 2. 判断昵称格式是否正确
bool ret = nickname_check(new_nickname);
if (ret == false) {
LOG_ERROR("{} - 用户名长度不合法！", request->request_id());
return err_response(request->request_id(), "用户名长度不合法！");
}
// 3. 从数据库通过用户 ID 进行用户信息查询，判断用户是否存在
auto user = _mysql_user->select_by_id(uid);
if (!user) {
LOG_ERROR("{} - 未找到用户信息 - {}！", request->request_id(), uid);
return err_response(request->request_id(), "未找到用户信息!");
}
// 4. 将新的昵称更新到数据库中
user->nickname(new_nickname);
ret = _mysql_user->update(user);
if (ret == false) {
LOG_ERROR("{} - 更新数据库用户昵称失败 ：{}！", request->request_id(), new_nickname);
return err_response(request->request_id(), "更新数据库用户昵称失败!");
}
// 5. 更新 ES 服务器中用户信息
ret = _es_user->appendData(user->user_id(), user->phone(),
user->nickname(), user->description(), user->avatar_id());
if (ret == false) {
LOG_ERROR("{} - 更新搜索引擎用户昵称失败 ：{}！", request->request_id(), new_nickname);
return err_response(request->request_id(), "更新搜索引擎用户昵称失败!");
}
// 6. 组织响应，返回更新成功与否
response->set_request_id(request->request_id());
response->set_success(true);
}
virtual void SetUserDescription(::google::protobuf::RpcController* controller,
const ::bite_im::SetUserDescriptionReq* request,
::bite_im::SetUserDescriptionRsp* response,
::google::protobuf::Closure* done){
LOG_DEBUG("收到用户签名设置请求！");
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;
};
// 1. 从请求中取出用户 ID 与新的昵称
std::string uid = request->user_id();
std::string new_description = request->description();
// 3. 从数据库通过用户 ID 进行用户信息查询，判断用户是否存在
auto user = _mysql_user->select_by_id(uid);
if (!user) {
LOG_ERROR("{} - 未找到用户信息 - {}！", request->request_id(), uid);
return err_response(request->request_id(), "未找到用户信息!");
}
// 4. 将新的昵称更新到数据库中
user->description(new_description);
bool ret = _mysql_user->update(user);
if (ret == false) {
LOG_ERROR("{} - 更新数据库用户签名失败 ：{}！", request->request_id(), new_description);
return err_response(request->request_id(), "更新数据库用户签名失败!");
}
// 5. 更新 ES 服务器中用户信息
ret = _es_user->appendData(user->user_id(), user->phone(),
user->nickname(), user->description(), user->avatar_id());
if (ret == false) {
LOG_ERROR("{} - 更新搜索引擎用户签名失败 ：{}！", request->request_id(), new_description);
return err_response(request->request_id(), "更新搜索引擎用户签名失败!");
}
// 6. 组织响应，返回更新成功与否
response->set_request_id(request->request_id());
response->set_success(true);
}
virtual void SetUserPhoneNumber(::google::protobuf::RpcController* controller,
const ::bite_im::SetUserPhoneNumberReq* request,
::bite_im::SetUserPhoneNumberRsp* response,
::google::protobuf::Closure* done){
LOG_DEBUG("收到用户邮箱号设置请求！");
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;
};
// 1. 从请求中取出用户 ID 与新的昵称
std::string uid = request->user_id();
std::string new_phone = request->phone_number();
std::string code = request->phone_verify_code();
std::string code_id = request->phone_verify_code_id();
// 2. 对验证码进行验证
auto vcode = _redis_codes->code(code_id);
if (vcode != code) {
LOG_ERROR("{} - 验证码错误 - {}-{}！", request->request_id(), code_id, code);
return err_response(request->request_id(), "验证码错误!");
}
// 3. 从数据库通过用户 ID 进行用户信息查询，判断用户是否存在
auto user = _mysql_user->select_by_id(uid);
if (!user) {
LOG_ERROR("{} - 未找到用户信息 - {}！", request->request_id(), uid);
return err_response(request->request_id(), "未找到用户信息!");
}
// 4. 将新的昵称更新到数据库中
user->phone(new_phone);
bool ret = _mysql_user->update(user);
if (ret == false) {
LOG_ERROR("{} - 更新数据库用户邮箱号失败 ：{}！", request->request_id(), new_phone);
return err_response(request->request_id(), "更新数据库用户邮箱号失败!");
}
// 5. 更新 ES 服务器中用户信息
ret = _es_user->appendData(user->user_id(), user->phone(),
user->nickname(), user->description(), user->avatar_id());
if (ret == false) {
LOG_ERROR("{} - 更新搜索引擎用户邮箱号失败 ：{}！", request->request_id(), new_phone);
return err_response(request->request_id(), "更新搜索引擎用户邮箱号失败!");
}
// 6. 组织响应，返回更新成功与否
response->set_request_id(request->request_id());
response->set_success(true);
}
private:
ESUser::ptr _es_user;
UserTable::ptr _mysql_user;
Session::ptr _redis_session;
Status::ptr _redis_status;
Codes::ptr _redis_codes;
//这边是rpc调用客户端相关对象
std::string _file_service_name;
ServiceManager::ptr _mm_channels;
// DMSClient::ptr _dms_client;
SendEmail::ptr _SendE_client;
};
class UserServer {
public:
using ptr = std::shared_ptr<UserServer>;
UserServer(const Discovery::ptr service_discoverer,
const Registry::ptr &reg_client,
const std::shared_ptr<elasticlient::Client> &es_client,
const std::shared_ptr<odb::core::database> &mysql_client,
std::shared_ptr<sw::redis::Redis> &redis_client,
const std::shared_ptr<brpc::Server> &server):
_service_discoverer(service_discoverer),
_registry_client(reg_client),
_es_client(es_client),
_mysql_client(mysql_client),
_redis_client(redis_client),
_rpc_server(server){}
~UserServer(){}
//搭建RPC服务器，并启动服务器
void start() {
_rpc_server->RunUntilAskedToQuit();
}
private:
Discovery::ptr _service_discoverer;
Registry::ptr _registry_client;
std::shared_ptr<elasticlient::Client> _es_client;
std::shared_ptr<odb::core::database> _mysql_client;
std::shared_ptr<sw::redis::Redis> _redis_client;
std::shared_ptr<brpc::Server> _rpc_server;
};
class UserServerBuilder {
public:
//构造es客户端对象
void make_es_object(const std::vector<std::string> host_list) {
_es_client = ESClientFactory::create(host_list);
}
// void make_dms_object(const std::string &access_key_id,
// const std::string &access_key_secret) {
// _dms_client = std::make_shared<DMSClient>(access_key_id, access_key_secret);
// }
void make_SendE_object() {
_SendE_client = std::make_shared<SendEmail>();
}
//构造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);
}
//构造redis客户端对象
void make_redis_object(const std::string &host,
int port,
int db,
bool keep_alive) {
_redis_client = RedisClientFactory::create(host, port, db, keep_alive);
}
//用于构造服务发现客户端&信道管理对象
void make_discovery_object(const std::string &reg_host,
const std::string &base_service_name,
const std::string &file_service_name) {
_file_service_name = file_service_name;
_mm_channels = std::make_shared<ServiceManager>();
_mm_channels->declared(file_service_name);
LOG_DEBUG("设置文件子服务为需添加管理的子服务：{}", file_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);
}
void make_rpc_server(uint16_t port, int32_t timeout, uint8_t num_threads) {
if (!_es_client) {
LOG_ERROR("还未初始化ES搜索引擎模块！");
abort();
}
if (!_mysql_client) {
LOG_ERROR("还未初始化Mysql数据库模块！");
abort();
}
if (!_redis_client) {
LOG_ERROR("还未初始化Redis数据库模块！");
abort();
}
if (!_mm_channels) {
LOG_ERROR("还未初始化信道管理模块！");
abort();
}
if (!_SendE_client) { //_dms_client
// LOG_ERROR("还未初始化短信平台模块！");
LOG_ERROR("还未初始化发送邮件模块！");
abort();
}
_rpc_server = std::make_shared<brpc::Server>();
UserServiceImpl *user_service = new UserServiceImpl(_SendE_client, _es_client,
_mysql_client, _redis_client, _mm_channels, _file_service_name);
int ret = _rpc_server->AddService(user_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();
}
}
//构造RPC服务器对象
UserServer::ptr build() {
if (!_service_discoverer) {
LOG_ERROR("还未初始化服务发现模块！");
abort();
}
if (!_registry_client) {
LOG_ERROR("还未初始化服务注册模块！");
abort();
}
if (!_rpc_server) {
LOG_ERROR("还未初始化RPC服务器模块！");
abort();
}
UserServer::ptr server = std::make_shared<UserServer>(
_service_discoverer, _registry_client,
_es_client, _mysql_client, _redis_client, _rpc_server);
return server;
}
private:
Registry::ptr _registry_client;
std::shared_ptr<elasticlient::Client> _es_client;
std::shared_ptr<odb::core::database> _mysql_client;
std::shared_ptr<sw::redis::Redis> _redis_client;
std::string _file_service_name;
ServiceManager::ptr _mm_channels;
Discovery::ptr _service_discoverer;
// std::shared_ptr<DMSClient> _dms_client;
std::shared_ptr<SendEmail> _SendE_client;
std::shared_ptr<brpc::Server> _rpc_server;
};
}

32
user/test/es_test/main.cc Normal file
View File

@ -0,0 +1,32 @@
#include "../../../common/data_es.hpp"
#include <gflags/gflags.h>
DEFINE_bool(run_mode, false, "程序的运行模式，false-调试； true-发布；");
DEFINE_string(log_file, "", "发布模式下，用于指定日志的输出文件");
DEFINE_int32(log_level, 0, "发布模式下，用于指定日志输出等级");
DEFINE_string(es_host, "http://127.0.0.1:9200/", "es服务器URL");
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 es_client = bite_im::ESClientFactory::create({FLAGS_es_host});
auto es_user = std::make_shared<bite_im::ESUser>(es_client);
es_user->createIndex();
// es_user->appendData("用户ID1", "手机号1", "小猪佩奇", "这是一只小猪", "小猪头像1");
// es_user->appendData("用户ID2", "手机号2", "小猪乔治", "这是一只小小猪", "小猪头像2");
auto res = es_user->search("小猪", {"用户ID1"});
for (auto &u : res) {
std::cout << "-----------------" << std::endl;
std::cout << u.user_id() << std::endl;
std::cout << *u.phone() << std::endl;
std::cout << *u.nickname() << std::endl;
std::cout << *u.description() << std::endl;
std::cout << *u.avatar_id() << std::endl;
}
return 0;
}

58
user/test/mysql_test/main.cc Normal file
View File

@ -0,0 +1,58 @@
#include "../../../common/data_mysql.hpp"
#include "../../../odb/user.hxx"
#include "user-odb.hxx"
#include <gflags/gflags.h>
DEFINE_bool(run_mode, false, "程序的运行模式，false-调试； true-发布；");
DEFINE_string(log_file, "", "发布模式下，用于指定日志的输出文件");
DEFINE_int32(log_level, 0, "发布模式下，用于指定日志输出等级");
void insert(bite_im::UserTable &user) {
auto user1 = std::make_shared<bite_im::User>("uid1", "昵称1", "123456");
user.insert(user1);
auto user2 = std::make_shared<bite_im::User>("uid2", "15566667777");
user.insert(user2);
}
void update_by_id(bite_im::UserTable &user_tb) {
auto user = user_tb.select_by_id("uid1");
user->description("我是一个风一样的男子！！");
user_tb.update(user);
}
void update_by_phone(bite_im::UserTable &user_tb) {
auto user = user_tb.select_by_phone("15566667777");
user->password("22223333");
user_tb.update(user);
}
void update_by_nickname(bite_im::UserTable &user_tb) {
auto user = user_tb.select_by_nickname("uid2");
user->nickname("昵称2");
user_tb.update(user);
}
void select_users(bite_im::UserTable &user_tb) {
std::vector<std::string> id_list = {"uid1", "uid2"};
auto res = user_tb.select_multi_users(id_list);
for (auto user : res) {
std::cout << user.nickname() << std::endl;
}
}
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::UserTable user(db);
//insert(user);
//update_by_id(user);
//update_by_phone(user);
//update_by_nickname(user);
select_users(user);
return 0;
}

84
user/test/redis_test/main.cc Normal file
View File

@ -0,0 +1,84 @@
#include "../../../common/data_redis.hpp"
#include <gflags/gflags.h>
#include <thread>
DEFINE_bool(run_mode, false, "程序的运行模式，false-调试； true-发布；");
DEFINE_string(log_file, "", "发布模式下，用于指定日志的输出文件");
DEFINE_int32(log_level, 0, "发布模式下，用于指定日志输出等级");
DEFINE_string(ip, "127.0.0.1", "这是服务器的IP地址，格式：127.0.0.1");
DEFINE_int32(port, 6379, "这是服务器的端口, 格式: 8080");
DEFINE_int32(db, 0, "库的编号：默认0号");
DEFINE_bool(keep_alive, true, "是否进行长连接保活");
void session_test(const std::shared_ptr<sw::redis::Redis> &client) {
bite_im::Session ss(client);
ss.append("会话ID1", "用户ID1");
ss.append("会话ID2", "用户ID2");
ss.append("会话ID3", "用户ID3");
ss.append("会话ID4", "用户ID4");
ss.remove("会话ID2");
ss.remove("会话ID3");
auto res1 = ss.uid("会话ID1");
if (res1) std::cout << *res1 << std::endl;
auto res2 = ss.uid("会话ID2");
if (res2) std::cout << *res2 << std::endl;
auto res3 = ss.uid("会话ID3");
if (res3) std::cout << *res3 << std::endl;
auto res4 = ss.uid("会话ID4");
if (res4) std::cout << *res4 << std::endl;
}
void status_test(const std::shared_ptr<sw::redis::Redis> &client) {
bite_im::Status status(client);
status.append("用户ID1");
status.append("用户ID2");
status.append("用户ID3");
status.remove("用户ID2");
if (status.exists("用户ID1")) std::cout << "用户1在线！" << std::endl;
if (status.exists("用户ID2")) std::cout << "用户2在线！" << std::endl;
if (status.exists("用户ID3")) std::cout << "用户3在线！" << std::endl;
}
void code_test(const std::shared_ptr<sw::redis::Redis> &client) {
bite_im::Codes codes(client);
codes.append("验证码ID1", "验证码1");
codes.append("验证码ID2", "验证码2");
codes.append("验证码ID3", "验证码3");
codes.remove("验证码ID2");
auto y1 = codes.code("验证码ID1");
auto y2 = codes.code("验证码ID2");
auto y3 = codes.code("验证码ID3");
if (y1) std::cout << *y1 << std::endl;
if (y2) std::cout << *y2 << std::endl;
if (y3) std::cout << *y3 << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(4));
auto y4 = codes.code("验证码ID1");
auto y5 = codes.code("验证码ID2");
auto y6 = codes.code("验证码ID3");
if (!y4) std::cout << "验证码ID1不存在" << std::endl;
if (!y5) std::cout << "验证码ID2不存在" << std::endl;
if (!y6) std::cout << "验证码ID3不存在" << std::endl;
}
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 client = bite_im::RedisClientFactory::create(FLAGS_ip, FLAGS_port, FLAGS_db, FLAGS_keep_alive);
//session_test(client);
//status_test(client);
code_test(client);
return 0;
}

308
user/test/user_client.cc Normal file
View File

@ -0,0 +1,308 @@
#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;
bite_im::UserInfo user_info;
std::string login_ssid;
std::string new_nickname = "亲爱的猪妈妈";
//测试已通过
// TEST(用户子服务测试, 用户注册测试) {
// auto channel = _user_channels->choose(FLAGS_user_service);//获取通信信道
// ASSERT_TRUE(channel);
// // user_info.set_nickname("猪爸爸");
// bite_im::UserRegisterReq req;
// // req.set_request_id(bite_im::uuid());
// req.set_request_id(user_info.user_id());
// req.set_nickname(user_info.nickname());
// req.set_password("123456");
// 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());
// }
//测试已通过
// TEST(用户子服务测试, 用户登录测试) {
// auto channel = _user_channels->choose(FLAGS_user_service);//获取通信信道
// ASSERT_TRUE(channel);
// bite_im::UserLoginReq req;
// req.set_request_id(bite_im::uuid());
// req.set_nickname("猪妈妈");
// req.set_password("123456");
// bite_im::UserLoginRsp rsp;
// brpc::Controller cntl;
// bite_im::UserService_Stub stub(channel.get());
// stub.UserLogin(&cntl, &req, &rsp, nullptr);
// ASSERT_FALSE(cntl.Failed());
// ASSERT_TRUE(rsp.success());
// login_ssid = rsp.login_session_id();
// }
//测试已通过
// TEST(用户子服务测试, 用户头像设置测试) {
// 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(user_info.user_id());
// req.set_session_id(login_ssid);
// req.set_avatar(user_info.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());
// }
//测试已通过
// TEST(用户子服务测试, 用户签名设置测试) {
// auto channel = _user_channels->choose(FLAGS_user_service);//获取通信信道
// ASSERT_TRUE(channel);
// bite_im::SetUserDescriptionReq req;
// req.set_request_id(bite_im::uuid());
// req.set_user_id(user_info.user_id());
// req.set_session_id(login_ssid);
// req.set_description(user_info.description());
// bite_im::SetUserDescriptionRsp rsp;
// brpc::Controller cntl;
// bite_im::UserService_Stub stub(channel.get());
// stub.SetUserDescription(&cntl, &req, &rsp, nullptr);
// ASSERT_FALSE(cntl.Failed());
// ASSERT_TRUE(rsp.success());
// }
//测试已通过
// TEST(用户子服务测试, 用户昵称设置测试) {
// auto channel = _user_channels->choose(FLAGS_user_service);//获取通信信道
// ASSERT_TRUE(channel);
// bite_im::SetUserNicknameReq req;
// req.set_request_id(bite_im::uuid());
// req.set_user_id(user_info.user_id());
// req.set_session_id(login_ssid);
// req.set_nickname(new_nickname);
// bite_im::SetUserNicknameRsp rsp;
// brpc::Controller cntl;
// bite_im::UserService_Stub stub(channel.get());
// stub.SetUserNickname(&cntl, &req, &rsp, nullptr);
// ASSERT_FALSE(cntl.Failed());
// ASSERT_TRUE(rsp.success());
// }
//测试已通过
// TEST(用户子服务测试, 用户信息获取测试) {
// auto channel = _user_channels->choose(FLAGS_user_service);//获取通信信道
// ASSERT_TRUE(channel);
// bite_im::GetUserInfoReq req;
// req.set_request_id(bite_im::uuid());
// req.set_user_id(user_info.user_id());
// req.set_session_id(login_ssid);
// bite_im::GetUserInfoRsp rsp;
// brpc::Controller cntl;
// bite_im::UserService_Stub stub(channel.get());
// stub.GetUserInfo(&cntl, &req, &rsp, nullptr);
// ASSERT_FALSE(cntl.Failed());
// ASSERT_TRUE(rsp.success());
// ASSERT_EQ(user_info.user_id(), rsp.user_info().user_id());
// ASSERT_EQ(new_nickname, rsp.user_info().nickname());
// ASSERT_EQ(user_info.description(), rsp.user_info().description());
// ASSERT_EQ("", rsp.user_info().phone());
// ASSERT_EQ(user_info.avatar(), rsp.user_info().avatar());
// }
//测试已通过
// 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(login_ssid);
// 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());
// }
// TEST(用户子服务测试, 批量用户信息获取测试) {
// set_user_avatar("用户ID1", "小猪佩奇的头像数据");
// set_user_avatar("用户ID2", "小猪乔治的头像数据");
// auto channel = _user_channels->choose(FLAGS_user_service);//获取通信信道
// ASSERT_TRUE(channel);
// bite_im::GetMultiUserInfoReq req;
// req.set_request_id(bite_im::uuid());
// req.add_users_id("用户ID1");
// req.add_users_id("用户ID2");
// req.add_users_id("ee55-9043bfd7-0001");
// bite_im::GetMultiUserInfoRsp rsp;
// brpc::Controller cntl;
// bite_im::UserService_Stub stub(channel.get());
// stub.GetMultiUserInfo(&cntl, &req, &rsp, nullptr);
// ASSERT_FALSE(cntl.Failed());
// ASSERT_TRUE(rsp.success());
// auto users_map = rsp.mutable_users_info();
// bite_im::UserInfo fuser = (*users_map)["ee55-9043bfd7-0001"];
// ASSERT_EQ(fuser.user_id(), "ee55-9043bfd7-0001");
// ASSERT_EQ(fuser.nickname(), "猪爸爸");
// ASSERT_EQ(fuser.description(), "这是第一个用户的描述信息");
// ASSERT_EQ(fuser.phone(), "13800138003");
// ASSERT_EQ(fuser.avatar(), "");
// bite_im::UserInfo puser = (*users_map)["用户ID1"];
// ASSERT_EQ(puser.user_id(), "用户ID1");
// ASSERT_EQ(puser.nickname(), "user_nickname_1");
// ASSERT_EQ(puser.description(), "这是第一个用户的描述信息");
// ASSERT_EQ(puser.phone(), "13800138001");
// ASSERT_EQ(puser.avatar(), "小猪佩奇的头像数据");
// bite_im::UserInfo quser = (*users_map)["用户ID2"];
// ASSERT_EQ(quser.user_id(), "用户ID2");
// ASSERT_EQ(quser.nickname(), "user_nickname_2");
// ASSERT_EQ(quser.description(), "这是第二个用户的描述信息");
// ASSERT_EQ(quser.phone(), "13800138002");
// ASSERT_EQ(quser.avatar(), "小猪乔治的头像数据");
// }
std::string code_id;
void get_code() {
auto channel = _user_channels->choose(FLAGS_user_service);//获取通信信道
ASSERT_TRUE(channel);
bite_im::PhoneVerifyCodeReq req;
req.set_request_id(bite_im::uuid());
req.set_phone_number(user_info.phone());
bite_im::PhoneVerifyCodeRsp rsp;
brpc::Controller cntl;
bite_im::UserService_Stub stub(channel.get());
stub.GetPhoneVerifyCode(&cntl, &req, &rsp, nullptr);
ASSERT_FALSE(cntl.Failed());
ASSERT_TRUE(rsp.success());
code_id = rsp.verify_code_id();
}
TEST(用户子服务测试, 手机号注册) {
get_code();
auto channel = _user_channels->choose(FLAGS_user_service);//获取通信信道
ASSERT_TRUE(channel);
bite_im::PhoneRegisterReq req;
req.set_request_id(bite_im::uuid());
req.set_phone_number(user_info.phone());
req.set_verify_code_id(code_id);
std::cout << "手机号注册，输入验证码：" << std::endl;
std::string code;
std::cin >> code;
req.set_verify_code(code);
bite_im::PhoneRegisterRsp rsp;
brpc::Controller cntl;
bite_im::UserService_Stub stub(channel.get());
stub.PhoneRegister(&cntl, &req, &rsp, nullptr);
ASSERT_FALSE(cntl.Failed());
ASSERT_TRUE(rsp.success());
}
TEST(用户子服务测试, 手机号登录) {
std::this_thread::sleep_for(std::chrono::seconds(3));
get_code();
auto channel = _user_channels->choose(FLAGS_user_service);//获取通信信道
ASSERT_TRUE(channel);
bite_im::PhoneLoginReq req;
req.set_request_id(bite_im::uuid());
req.set_phone_number(user_info.phone());
req.set_verify_code_id(code_id);
std::cout << "手机号登录，输入验证码：" << std::endl;
std::string code;
std::cin >> code;
req.set_verify_code(code);
bite_im::PhoneLoginRsp rsp;
brpc::Controller cntl;
bite_im::UserService_Stub stub(channel.get());
stub.PhoneLogin(&cntl, &req, &rsp, nullptr);
ASSERT_FALSE(cntl.Failed());
ASSERT_TRUE(rsp.success());
std::cout << "手机登录会话ID：" << rsp.login_session_id() << std::endl;
}
TEST(用户子服务测试, 手机号设置) {
std::this_thread::sleep_for(std::chrono::seconds(10));
get_code();
auto channel = _user_channels->choose(FLAGS_user_service);//获取通信信道
ASSERT_TRUE(channel);
bite_im::SetUserPhoneNumberReq req;
req.set_request_id(bite_im::uuid());
std::cout << "手机号设置时，输入用户ID：" << std::endl;
std::string user_id;
std::cin >> user_id;
req.set_user_id(user_id);
req.set_phone_number("2050965275@qq.com");
req.set_phone_verify_code_id(code_id);
std::cout << "手机号设置时，输入验证码：" << std::endl;
std::string code;
std::cin >> code;
req.set_phone_verify_code(code);
bite_im::SetUserPhoneNumberRsp rsp;
brpc::Controller cntl;
bite_im::UserService_Stub stub(channel.get());
stub.SetUserPhoneNumber(&cntl, &req, &rsp, nullptr);
ASSERT_FALSE(cntl.Failed());
ASSERT_TRUE(rsp.success());
}
int main(int argc, char *argv[])
{
testing::InitGoogleTest(&argc, argv);
google::ParseCommandLineFlags(&argc, &argv, true);
bite_im::init_logger(FLAGS_run_mode, FLAGS_log_file, FLAGS_log_level);
//1. 先构造Rpc信道管理对象
_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);
user_info.set_nickname("猪妈妈");
user_info.set_user_id("672f-c755e83e-0000");
user_info.set_description("这是一个美丽的猪妈妈");
user_info.set_phone("2050965275@qq.com");
user_info.set_avatar("猪妈妈头像数据");
testing::InitGoogleTest(&argc, argv);
LOG_DEBUG("开始测试！");
return RUN_ALL_TESTS();
}

25
user/user_server.conf Normal file
View File

@ -0,0 +1,25 @@
-run_mode=true
-log_file=/im/logs/user.log
-log_level=0
-registry_host=http://10.0.0.235:2379
-instance_name=/user_service/instance
-access_host=10.0.0.235:10003
-listen_port=10003
-rpc_timeout=-1
-rpc_threads=1
-base_service=/service
-file_service=/service/file_service
-es_host=http://10.0.0.235:9200/
-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
-redis_host=10.0.0.235
-redis_port=6379
-redis_db=0
-redis_keep_alive=true
-dms_key_id=LTAI5t6NF7vt499UeqYX6LB9
-dms_key_secret=5hx1qvpXHDKfQDk73aJs6j53Q8KcF2