curve源码分析 nebd—part2

源码目录
curve-release2.2\nebd\src\part2

nebd_server.cpp
file_service.cpp
request_executor.cpp
request_executor_curve.cpp
metafile_manager.cpp
file_entity.cpp
file_manager.cpp 
heartbeat_manager.cpp 
heartbeat_service.cpp

由于nebd_server.cpp文件内容较长，我将分段进行注释和分析，以便更好地理解代码的结构和功能。

// 引入必要的头文件
#include <glog/logging.h>
#include <memory>
#include "nebd/src/common/file_lock.h"
#include "nebd/src/part2/nebd_server.h"
#include "nebd/src/part2/file_service.h"
#include "nebd/src/part2/heartbeat_service.h"
#include "nebd/src/common/nebd_version.h"

// 命名空间声明
namespace nebd {
   
namespace server {
   

// NebdServer类的初始化函数
int NebdServer::Init(const std::string &confPath, std::shared_ptr<CurveClient> curveClient) {
   
    // 检查服务器是否已经处于运行状态
    if (isRunning_) {
   
        LOG(WARNING) << "NebdServer is inited";
        return -1;
    }

    // 从配置文件中加载配置信息
    bool loadConf = LoadConfFromFile(confPath);
    if (false == loadConf) {
   
        LOG(ERROR) << "NebdServer load config from file fail";
        return -1;
    }
    LOG(INFO) << "NebdServer load config from file ok";

    // 初始化服务器监听地址
    bool initAddressOk = conf_.GetStringValue(LISTENADDRESS, &listenAddress_);
    if (false == initAddressOk) {
   
        LOG(ERROR) << "NebdServer init socket file address fail";
        return -1;
    }
    LOG(INFO) << "NebdServer init socket file address ok";

    // 初始化CurveClient
    curveClient_ = curveClient;
    bool initExecutorOk = InitCurveRequestExecutor();
    if (false == initExecutorOk) {
   
        LOG(ERROR) << "NebdServer init curveRequestExecutor fail";
        return -1;
    }
    LOG(INFO) << "NebdServer init curveRequestExecutor ok";

    // 初始化文件管理器
    bool initFileManagerOk = InitFileManager();
    if (false == initFileManagerOk) {
   
        LOG(ERROR) << "NebdServer init fileManager fail";
        return -1;
    }
    LOG(INFO) << "NebdServer init fileManager ok";

    // 初始化心跳管理器
    bool initHeartbeatManagerOk = InitHeartbeatManager();
    if (false == initHeartbeatManagerOk) {
   
        LOG(ERROR) << "NebdServer init heartbeatManager fail";
        return -1;
    }
    LOG(INFO) << "NebdServer init heartbeatManager ok";

    // 记录日志信息
    LOG(INFO) << "NebdServer init ok";
    // 暴露版本信息
    LOG(INFO) << "nebd version: " << nebd::common::NebdVersion();
    nebd::common::ExposeNebdVersion();
    return 0;
}

// NebdServer类的运行函数，直到服务器被要求停止
int NebdServer::RunUntilAskedToQuit() {
   
    // 启动服务器
    if (false == StartServer()) {
   
        LOG(INFO) << "start server fail";
        return -1;
    }

    return 0;
}

// NebdServer类的析构函数
int NebdServer::Fini() {
   
    // 如果服务器正在运行，则请求停止
    if (isRunning_) {
   
        brpc::AskToQuit();
    }

    // 停止文件管理器
    if (fileManager_ != nullptr) {
   
        fileManager_->Fini();
    }

    // 卸载CurveClient
    if (curveClient_ != nullptr) {
   
        curveClient_->UnInit();
    }

    // 停止心跳管理器
    if (heartbeatManager_ != nullptr) {
   
        heartbeatManager_->Fini();
    }

    return 0;
}

// 从配置文件中加载配置信息的函数
bool NebdServer::LoadConfFromFile(const std::string &confPath) {
   
    // 设置配置文件路径并加载配置
    conf_.SetConfigPath(confPath);
    return conf_.LoadConfig();
}

// 初始化文件管理器的函数
bool NebdServer::InitFileManager() {
   
    // 初始化元数据文件管理器
    MetaFileManagerPtr metaFileManager = InitMetaFileManager();
    if (nullptr == metaFileManager) {
   
        LOG(ERROR) << "NebdServer init meta file manager fail";
        return false;
    }

    // 创建文件管理器并运行
    fileManager_ = std::make_shared<NebdFileManager>(metaFileManager);
    CHECK(fileManager_ != nullptr) << "Init file manager failed.";
    int runRes = fileManager_->Run();
    if (0 != runRes) {
   
        LOG(ERROR) << "nebd file manager run fail";
        return false;
    }

    return true;
}

// 初始化CurveRequestExecutor的函数
bool NebdServer::InitCurveRequestExecutor() {
   
    // 获取CurveClient的配置路径
    std::string confPath;
    bool getOk = conf_.GetStringValue(CURVECLIENTCONFPATH, &confPath);
    if (!getOk) {
   
        LOG(ERROR) << "get " << CURVECLIENTCONFPATH << " fail";
        return false;
    }

    // 初始化CurveClient
    int initRes = curveClient_->Init(confPath);
    if (initRes < 0) {
   
        LOG(ERROR) << "Init curve client fail";
        return false;
    }

    // 初始化请求执行器
    CurveRequestExecutor::GetInstance().Init(curveClient_);
    return true;
}

// 初始化元数据文件管理器的函数
MetaFileManagerPtr NebdServer::InitMetaFileManager() {
   
    // 设置元数据文件路径
    NebdMetaFileManagerOption option;
    option.wrapper = std::make_shared<PosixWrapper>();
    option.parser = std::make_shared<NebdMetaFileParser>();
    bool getOk = conf_.GetStringValue(METAFILEPATH, &option.metaFilePath);
    if (false == getOk) {
   
        return nullptr;
    }

    // 创建并初始化元数据文件管理器
    MetaFileManagerPtr metaFileManager = std::make_shared<NebdMetaFileManager>();
    CHECK(metaFileManager != nullptr) << "meta file manager is nullptr";
    int ret = metaFileManager->Init(option);
    if (ret != 0) {
   
        LOG(ERROR) << "Init meta file manager failed.";
        return nullptr;
    }

    return metaFileManager;
}

// 初始化心跳管理器的函数
bool NebdServer::InitHeartbeatManager() {
   
    // 创建心跳管理器选项
    HeartbeatManagerOption option;
    bool initOptionSuccess = InitHeartbeatManagerOption(&option);
    if (!initOptionSuccess) {
   
        LOG(ERROR) << "NebdServer init heartbeat manager option fail";
        return false;
    }

    // 创建心跳管理器并运行
    heartbeatManager_ = std::make_shared<HeartbeatManager>(option);
    CHECK(heartbeatManager_ != nullptr) << "Init heartbeat manager failed.";
    int runRes = heartbeatManager_->Run();
    if (0 != runRes) {
   
        LOG(ERROR) << "nebd heartbeat manager run fail";
        return false;
    }

    return true;
}

// 启动服务器的函数
bool NebdServer::StartServer() {
   
    // 添加服务
    bool returnRpcWhenIoError;
    bool ret = conf_.GetBoolValue(RESPONSERETURNRPCWHENIOERROR, &returnRpcWhenIoError);
    if (false == ret) {
   
        LOG(ERROR) << "get " << RESPONSERETURNRPCWHENIOERROR << " fail";
        return false;
    }

    // 创建文件服务并添加到服务器
    NebdFileServiceImpl fileService(fileManager_, returnRpcWhenIoError);
    int addFileServiceRes = server_.AddService(&fileService, brpc::SERVER_DOESNT_OWN_SERVICE);
    if (0 != addFileServiceRes) {
   
        LOG(ERROR) << "NebdServer add file service fail";
        return false;
    }

    // 创建心跳服务并添加到服务器
    NebdHeartbeatServiceImpl heartbeatService(heartbeatManager_);
    addFileServiceRes = server_.AddService(&heartbeatService, brpc::SERVER_DOESNT_OWN_SERVICE);
    if (0 != addFileServiceRes) {
   
        LOG(ERROR) << "NebdServer add heartbeat service fail";
        return false;
    }

    // 启动brpc服务器
    brpc::ServerOptions option;
    option.idle_timeout_sec = -1;
    // 获取文件锁
    common::FileLock fileLock(listenAddress_ + ".lock");
    if (fileLock.AcquireFileLock() != 0) {
   
        LOG(ERROR) << "Address already in use";
        return -1;
    }
    int startBrpcServerRes = server_.StartAtSockFile(listenAddress_.c_str(), &option);
    if (0 != startBrpcServerRes) {
   
        LOG(ERROR) << "NebdServer start brpc server fail, res=" << startBrpcServerRes;
        return false;
    }

    // 允许所有用户连接到这个socket
    int r =