sudo apt-get install -y git g++ make libssl-dev libprotobuf-dev libprotoc-dev protobuf-compiler libleveldb-dev

git clone https://github.com/apache/brpc.git 	 # 可能需要多试几次
cd brpc/
mkdir build && cd build
cmake -DCMAKE_INSTALL_PREFIX=/usr .. && cmake --build . -j6
make && sudo make install

namespace logging {
    // 该枚举类型用于指定日志的输出目的地，不同的枚举值代表不同的输出目标
    enum LoggingDestination {
		LOG_TO_NONE = 0 // 当将日志输出目标设置为该值时，不会产生任何日志输出
    };
    
    // 日志设置结构体，用于配置日志系统的相关参数
    struct BUTIL_EXPORT LoggingSettings {
        LoggingSettings();
        LoggingDestination logging_dest;
    };
    
    // 初始化日志系统
	bool InitLogging(const LoggingSettings& settings);
}

namespace google {
    namespace protobuf {
        // 通常用于异步操作完成时的回调机制（后面有个ClosureGuard来保护内存泄漏问题）
        class PROTOBUF_EXPORT Closure 
        {
        public:
            Closure() {}
            virtual ~Closure(); 
            virtual void Run() = 0; // 当异步任务完成时，会调用此方法来执行回调逻辑。
        };
        
        // 此函数用于创建一个 Closure 对象，该对象会在其 Run 方法被调用时执行传入的函数
        inline Closure* NewCallback(void (*function)());
        
        // 提供了一些方法来检查 RPC 调用的状态，例如是否失败以及失败的错误信息
        class PROTOBUF_EXPORT RpcController 
        {
        public:
            bool Failed(); // 检查 RPC 调用是否失败
            std::string ErrorText(); // 获取 RPC 调用失败的错误信息
        } 
    } 
}

namespace brpc {
    /**
     * @brief 服务器启动选项结构体，用于配置服务器的行为。
     * 
     * 该结构体包含了一系列用于配置 brpc::Server 的选项，可在启动服务器时指定。
     */
    struct ServerOptions {
        /**
         * @brief 连接的空闲超时时间（秒）。
         * 
         * 如果在指定的时间内没有数据传输，连接将被关闭。默认值为 -1，表示禁用此功能。
         */
        int idle_timeout_sec;
 
        /**
         * @brief 服务器使用的线程数量。
         * 
         * 指定服务器处理请求时使用的线程数量，默认值为 CPU 核心数。
         */
        int num_threads;
 
        // .... 可能还有其他未显示的选项
    };
 
    /**
     * @brief 服务所有权枚举，用于指定服务器对服务对象的管理方式。
     * 
     * 该枚举定义了在将服务添加到服务器时，服务器对服务对象的所有权和生命周期管理策略。
     */
    enum ServiceOwnership {
        /**
         * @brief 服务器拥有服务对象的所有权。
         * 
         * 当添加服务失败时，服务器将负责删除服务对象，管理其生命周期。
         */
        SERVER_OWNS_SERVICE,
 
        /**
         * @brief 服务器不拥有服务对象的所有权。
         * 
         * 即使添加服务失败，服务器也不会删除服务对象，由调用者负责管理其生命周期。
         */
        SERVER_DOESNT_OWN_SERVICE
    };
 
    /**
     * @brief 代表一个 RPC 服务器。
     * 
     * 该类提供了管理服务器生命周期、添加服务以及启动和停止服务器的方法。
     */
    class Server {
    public:
        /**
         * @brief 向服务器添加一个服务。
         * 
         * @param service 指向要添加的 google::protobuf::Service 对象的指针。
         * @param ownership 服务所有权策略，指定服务器对服务对象的管理方式。
         * @return 成功时返回 0，失败时返回-1。
         */
        int AddService(google::protobuf::Service* service,
                       ServiceOwnership ownership);
 
        /**
         * @brief 启动服务器。
         * 
         * @param port 服务器监听的端口号。
         * @param opt 指向 ServerOptions 结构体的指针，用于配置服务器的行为。如果为 nullptr，则使用默认选项。
         * @return 成功时返回 0，失败时返回非零错误码。
         */
        int Start(int port, const ServerOptions* opt);
 
        /**
         * @brief 停止服务器。
         * 
         * @param closewait_ms 关闭等待时间（毫秒），此参数已不再使用。
         * @return 成功时返回 0，失败时返回非零错误码。
         */
        int Stop(int closewait_ms/*not used anymore*/);
 
        /**
         * @brief 等待服务器停止。
         * 
         * 阻塞当前线程，直到服务器完全停止。
         * @return 成功时返回 0，失败时返回非零错误码。
         */
        int Join();
 
        /**
         * @brief 运行服务器直到接收到退出信号。
         * 
         * 该方法会使服务器进入运行状态，并休眠直到接收到 Ctrl+C 信号，或者调用 Stop 和 Join 方法停止服务器。
         */
        void RunUntilAskedToQuit();
    };
 
    /**
     * @brief 用于自动管理 google::protobuf::Closure 对象的生命周期。
     * 
     * 该类在构造时接受一个 google::protobuf::Closure 指针，并在析构时自动调用其 Run 方法，确保回调操作被执行。
     */
    class ClosureGuard {
    public:
        explicit ClosureGuard(google::protobuf::Closure* done);
 
        /**
         * @brief 析构函数，自动调用 Closure 对象的 Run 方法。
         * 
         * 如果 _done 指针不为空，则调用其 Run 方法执行回调操作。
         */
        ~ClosureGuard() { if (_done) _done->Run(); }
 
    private:
        google::protobuf::Closure* _done;
    };
 
    /**
     * @brief 表示 HTTP 请求或响应的头部信息。
     * 
     * 该类提供了设置和获取 HTTP 头部字段、URI、方法和状态码的方法。
     */
    class HttpHeader {
    public:
        void set_content_type(const std::string& type);
        const std::string* GetHeader(const std::string& key);
        void SetHeader(const std::string& key, 
                       const std::string& value);
        const URI& uri() const { return _uri; }
        HttpMethod method() const { return _method; }
        void set_method(const HttpMethod method);
        int status_code();
        void set_status_code(int status_code);
 
    private:
        URI _uri;
        HttpMethod _method;
    };
 
    /**
     * @brief 用于控制和报告 RPC 调用的状态。
     * 
     * 该类继承自 google::protobuf::RpcController，并提供了额外的方法来设置超时时间、最大重试次数，
     * 以及获取 HTTP 请求和响应的头部信息。
     */
    class Controller : public google::protobuf::RpcController {
    public:
        /**
         * @brief 设置 RPC 调用的超时时间（毫秒）。
         * 
         * @param timeout_ms 要设置的超时时间（毫秒）。
         */
        void set_timeout_ms(int64_t timeout_ms);
 
        /**
         * @brief 设置 RPC 调用的最大重试次数。
         * 
         * @param max_retry 要设置的最大重试次数。
         */
        void set_max_retry(int max_retry);
 
        /**
         * @brief 获取 RPC 调用的响应消息。
         * 
         * @return 指向 google::protobuf::Message 对象的指针，该对象包含 RPC 调用的响应消息。
         */
        google::protobuf::Message* response();
 
        /**
         * @brief 获取 HTTP 响应的头部信息。
         * 
         * @return 一个引用，指向存储 HTTP 响应头部信息的 HttpHeader 对象。
         */
        HttpHeader& http_response();
 
        /**
         * @brief 获取 HTTP 请求的头部信息。
         * 
         * @return 一个引用，指向存储 HTTP 请求头部信息的 HttpHeader 对象。
         */
        HttpHeader& http_request();
 
        /**
         * @brief 检查 RPC 调用是否失败。
         * 
         * @return 如果 RPC 调用失败，返回 true；否则返回 false。
         */
        bool Failed();
 
        /**
         * @brief 获取 RPC 调用失败的错误信息。
         * 
         * @return 一个包含错误信息的字符串。
         */
        std::string ErrorText();
 
        /**
         * @brief 定义 RPC 响应后的回调函数类型。
         * 
         * 该类型的函数将在 RPC 调用完成并收到响应后被调用，可用于处理响应结果。
         */
        using AfterRpcRespFnType = std::function<
            void(Controller* cntl,
                 const google::protobuf::Message* req,
                 const google::protobuf::Message* res)>;
 
        /**
         * @brief 设置 RPC 响应后的回调函数。
         * 
         * @param fn 一个 AfterRpcRespFnType 类型的函数对象，将在 RPC 调用完成并收到响应后被调用。
         */
        void set_after_rpc_resp_fn(AfterRpcRespFnType&& fn);
    };
}

syntax = "proto3";
package example;
 
option cc_generic_services = true; // 需要继承RPC服务类就需要cc_generic_services设置开启才能生成
 
message EchoRequest {
    string message = 1;
}
 
message EchoResponse {
    string message = 1;
}
 
// 定义一个rpc服务
service EchoSerive {
    rpc Echo(EchoRequest) returns (EchoResponse);
}

namespace brpc {
    /**
     * @brief 用于配置 brpc 通道的选项结构体
     * 
     * 该结构体包含了一系列参数，用于控制通过 brpc 通道发起的 RPC 调用的行为，
     * 例如连接超时时间、请求超时时间、重试次数以及序列化协议类型等。
     */
    struct ChannelOptions {
        /**
         * @brief 请求连接超时时间，单位为毫秒。
         * 
         * 当通过通道发起请求时，若在该时间内未能成功建立与服务器的连接，
         * 则认为连接超时，请求将失败。默认值为 200 毫秒。
         */
        int32_t connect_timeout_ms; 
 
        /**
         * @brief RPC 请求超时时间，单位为毫秒。
         * 
         * 从请求发送开始计时，若在该时间内未收到服务器的响应，
         * 则认为请求超时，请求将失败。默认值为 500 毫秒。
         */
        int32_t timeout_ms; 
 
        /**
         * @brief 最大重试次数。
         * 
         * 当请求失败时，通道会尝试重新发送请求，最多重试该指定的次数。
         * 默认值为 3 次。
         */
        int max_retry;
 
        /**
         * @brief 序列化协议类型。
         * 
         * 指定在进行 RPC 通信时所使用的序列化协议，例如可以设置为 "baidu_std" 等。
         * 不同的协议在数据格式、性能等方面可能存在差异。
         */
        AdaptiveProtocolType protocol;
 
        //....其他未显示的选项
    };
 
    /**
     * @brief 代表一个 brpc 通道，用于与服务器进行 RPC 通信。
     * 
     * 该类继承自 ChannelBase，提供了初始化通道的方法，以便后续通过该通道发起 RPC 请求。
     */
    class Channel : public ChannelBase {
    public:
        /**
         * @brief 初始化通道。
         * 
         * 该方法用于配置并启动通道，使其可以与指定的服务器进行通信。
         * 
         * @param server_addr_and_port 服务器的地址和端口信息，格式通常为 "ip:port"。
         * @param options 指向 ChannelOptions 结构体的指针，用于指定通道的配置选项。
         *                如果为 nullptr，则使用默认的配置选项。
         * @return 初始化成功时返回 0；若初始化过程中出现错误，则返回非零的错误码。
         */
        int Init(const char* server_addr_and_port, 
                 const ChannelOptions* options);
    };
}

syntax = "proto3";
package example;
 
option cc_generic_services = true; // 需要继承RPC服务类就需要cc_generic_services设置开启才能生成
 
message EchoRequest {
    string message = 1;
}
 
message EchoResponse {
    string message = 1;
}
 
// 定义RPC远端方法
service EchoService {
    rpc Echo(EchoRequest) returns (EchoResponse);
}

#include <brpc/server.h>
#include <butil/logging.h>
#include "main.pb.h"
 
// 别忘了要声明命名空间example
class EchoServiceImpl : public example::EchoService {
public:
    EchoServiceImpl() {}
    ~EchoServiceImpl() {}
 
    // 重写Echo接口，实现具体的业务逻辑，以响应客户端发起的 Echo RPC 调用
    void Echo(::google::protobuf::RpcController* controller,
                const ::example::EchoRequest* request,
                ::example::EchoResponse* response,
                ::google::protobuf::Closure* done)
    {
        // 1. 使用RAII方式自动释放done对象，内部会调用run()接口
        brpc::ClosureGuard guard(done);
 
        // 2. 进行请求输出和响应
        std::cout << "收到消息：" << request->message() << std::endl;
        response->set_message("这是一条用于测试的响应信息！");
    }
};
 
int main(int argc, char* argv[])
{
    // 1. 关闭rpc自带的日志输出
    logging::LoggingSettings settings;
    settings.logging_dest = logging::LoggingDestination::LOG_TO_NONE;
    logging::InitLogging(settings);
 
    // 2. 创建服务器对象
    brpc::Server server;
 
    // 3. 向服务器对象中新增EchoService服务（局部变量，不需要去服务器去清除服务对象）
    EchoServiceImpl impl;
    int ret = server.AddService(&impl, brpc::ServiceOwnership::SERVER_DOESNT_OWN_SERVICE);
    if(ret != 0) {
        std::cout << "添加rpc服务失败！\n";
        return -1;
    }
 
    // 4. 启动服务器
    brpc::ServerOptions options;
    options.num_threads = 1;
    ret = server.Start(8080, &options);
    if(ret != 0) {
        std::cout << "启动rpc服务器失败！\n";
        return -1;
    }
    server.RunUntilAskedToQuit(); // 休眠等待运行结束
    return 0;
}

#include <brpc/channel.h>
#include <thread>
#include "main.pb.h"
 
int main(int argc, char* argv[])
{
    // 1. 构造Channel信道，连接服务器
    brpc::Channel channel;
    int ret = channel.Init("127.0.0.1:8080", nullptr);
    if(ret != 0) {
        std::cout << "初始化信道失败！\n";
        return -1;
    }
    
    // 2. 构造EchoService_Stub对象，用于进行rpc调用
    example::EchoService_Stub stub(&channel);
    
    // 3. 进行Rpc调用（同步调用）
    example::EchoRequest req;
    req.set_message("你好，利刃！");
    brpc::Controller *ctl = new brpc::Controller();
    example::EchoResponse *resp = new example::EchoResponse();
 
    stub.Echo(ctl, &req, resp, nullptr); // 同步方式调用，不需要Closure对象
    if(ctl->Failed() == true) {
        std::cout << "Rpc调用失败：" << ctl->ErrorText() << std::endl;
        return -1;
    }
    std::cout << "收到响应: " << resp->message() << std::endl;
    
    // 别忘了释放资源
    delete ctl; 
    delete resp;
    std::this_thread::sleep_for(std::chrono::seconds(3));
    return 0;
}

all : server client
server : server.cc main.pb.cc
	g++ -std=c++17 $^ -o $@ -lbrpc -lgflags -lssl -lcrypto -lprotobuf -lleveldb
client : client.cc main.pb.cc
	g++ -std=c++17 $^ -o $@ -lbrpc -lgflags -lssl -lcrypto -lprotobuf -lleveldb

#include <brpc/channel.h>
#include <thread>
#include "main.pb.h"
 
void callback(brpc::Controller* ctl, example::EchoResponse* resp)
{
    std::unique_ptr<brpc::Controller> ctl_guard(ctl);
    std::unique_ptr<example::EchoResponse> resp_guard(resp);
    if (ctl->Failed() == true) {
        std::cout << "Rpc调用失败：" << ctl->ErrorText() << std::endl;
        return;
    }
    std::cout << "收到响应: " << resp->message() << std::endl;
}
 
int main(int argc, char* argv[])
{
    // 1. 构造Channel信道，连接服务器
    brpc::Channel channel;
    int ret = channel.Init("127.0.0.1:8080", nullptr);
    if(ret != 0) {
        std::cout << "初始化信道失败！\n";
        return -1;
    }
    
    // 2. 构造EchoService_Stub对象，用于进行rpc调用
    example::EchoService_Stub stub(&channel);
    
    // 3. 进行Rpc调用（异步调用）
    example::EchoRequest req;
    req.set_message("你好，利刃！");
    brpc::Controller *ctl = new brpc::Controller();
    example::EchoResponse *resp = new example::EchoResponse();
 
    // 设置回调函数，然后返回Closure对象指针
    auto closure = google::protobuf::NewCallback(callback, ctl, resp); 
    stub.Echo(ctl, &req, resp, closure); 
    
    std::this_thread::sleep_for(std::chrono::seconds(3));
    return 0;
}

#pragma once
#include <brpc/channel.h>
#include <string>
#include <vector>
#include <unordered_map>
#include <mutex>
#include "logger.hpp"
 
// 单个服务的信道管理类
class ChannelManager {
public:
    using channel_ptr = std::shared_ptr<brpc::Channel>;
    using ptr = std::shared_ptr<ChannelManager>;
public:
    ChannelManager(const std::string& service_name)
        : _service_name(service_name)
        , _index(0)
    {}
 
    // 服务上线了一个节点，则调用append新增信道
    void append(const std::string& host)
    {
        // 构造初始化Channel信道
        channel_ptr channel = std::make_shared<brpc::Channel>();
        brpc::ChannelOptions options;
        options.connect_timeout_ms = -1;
        options.timeout_ms = -1;
        options.max_retry = 3;
        options.protocol = "baidu_std";
        int ret = channel->Init(host.c_str(), &options);
        if(ret != 0) {
            LOG_ERROR("初始化 {}-{} 信道失败！", _service_name, host);
            return;
        }
 
        // 先加锁再添加信息
        std::unique_lock<std::mutex> lock(_mtx);
        _channels.push_back(channel);
        _hosts[host] = channel;
    }
 
    // 服务下线了一个节点，则调用remove释放信道
    void remove(const std::string& host)
    {
        std::unique_lock<std::mutex> lock(_mtx);
        auto it = _hosts.find(host);
        if(it == _hosts.end())
        {
            LOG_WARN("删除 {}-{} 信道失败，没有找到该信道！", _service_name, host);
            return;
        }
 
        for(auto ait = _channels.begin(); ait != _channels.end(); ++ait)
            if(*ait == it->second)
            {
                _channels.erase(ait);
                break;
            }
        _hosts.erase(it);
    }
 
    // 通过RR轮转策略，获取一个Channel用于发起对应服务的rpc调用
    channel_ptr get()
    {
        std::unique_lock<std::mutex> lock(_mtx);
        if(_channels.size() == 0)
        {
            LOG_ERROR("当前无信道可用，已为你创建新信道");
            return channel_ptr();
        }
        int32_t idx = _index++ % _channels.size();
        return _channels[idx];
    }
private:
    std::mutex _mtx;
    int32_t _index;                                      // 当前轮转下标计数器
    std::string _service_name;                           // 服务名
    std::vector<channel_ptr> _channels;                  // 存放channel的集合
    std::unordered_map<std::string, channel_ptr> _hosts; // 存放主机号与channel的映射关系
};
 
// 总体服务的信道管理类
class ServiceManager {
public:
    using channel_ptr = std::shared_ptr<brpc::Channel>;
    using ptr = std::shared_ptr<ServiceManager>;
public:
    // 获取对应服务的一个channel对象，用于rpc调用
    ChannelManager::channel_ptr getChannel(const std::string& service_name)
    {
        std::unique_lock<std::mutex> lock(_mtx);
        auto it = _services.find(service_name);
        if(it == _services.end())
        {
            LOG_ERROR("没有提供 {} 服务的节点", service_name);
            return ChannelManager::channel_ptr();
        }
        return it->second->get();
    }
 
    // 声明关注哪些服务的上下线调用，不关注的服务不需要处理
    void declared(const std::string& service_name)
    {
        std::unique_lock<std::mutex> lock(_mtx);
        _follow_services.insert(service_name);
    }
 
    // 服务上线时调用的回调接口（即etcd.hpp中Discovery类的put_cb对象）：为服务添加主机地址
    void online(const std::string& instance_name, const std::string& host)
    {
        std::string service_name = instance_to_service(instance_name);
        ChannelManager::ptr service;
        {
            std::unique_lock<std::mutex> lock(_mtx);
            auto fit = _follow_services.find(service_name);
            if(fit == _follow_services.end())
            {
                LOG_DEBUG("{}-{} 服务上线了，但是当前并不关心！\n", service_name, host);
                return;
            }
 
            auto it = _services.find(service_name);
            if(it == _services.end())
            {
                // 说明是新添加的服务节点，此时创建并且插入即可
                service = std::make_shared<ChannelManager>(service_name);
                _services[service_name] = service;
            }
            else
                service = it->second;
        }
        if (!service) 
        {
            LOG_ERROR("新增 {} 服务管理节点失败！", service_name);
            return ;
        }
        service->append(host);
        LOG_DEBUG("{}-{} 服务上线新节点，进行添加管理！", service_name, host);
    }
 
    // 服务下线时调用的回调接口（即etcd.hpp中Discovery类的del_cb对象）：删除服务节点
    void offline(const std::string& instance_name, const std::string& host)
    {
        std::string service_name = instance_to_service(instance_name);
        ChannelManager::ptr service;
        {
            std::unique_lock<std::mutex> lock(_mtx);
            auto fit = _follow_services.find(service_name);
            if(fit == _follow_services.end())
            {
                LOG_DEBUG("{}-{} 服务下线了，但是当前并不关心！", service_name, host);
                return;
            }
 
            auto it = _services.find(service_name);
            if(it == _services.end())
            {
                LOG_WARN("删除服务节点失败：没找到{}节点", service_name);
                return;
            }
            service = it->second;
        }
        service->remove(host);
        LOG_DEBUG("{}-{} 服务下线节点，进行删除管理！", service_name, host);
    }
private:
    // 将实例名转化为服务名（实际上就是去掉最后一个'/'后面的内容
    std::string instance_to_service(const std::string& instance)
    {
        auto pos = instance.find_last_of('/');
        if (pos == std::string::npos) return instance;
        return instance.substr(0, pos);
    }
private:
    std::mutex _mtx;
    std::unordered_set<std::string> _follow_services;               // 存放关注的服务集合
    std::unordered_map<std::string, ChannelManager::ptr> _services; // 存放服务名和ChannelManager映射的集合
};

// discovery.cc
#include <gflags/gflags.h>
#include "../header/etcd.hpp"
#include "../header/channel.hpp"
#include "main.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(basedir, "/service", "服务监控的主目录");
DEFINE_string(call_service, "/service/echo", "测试代码中要获取的提供echo服务节点");
 
int main(int argc, char* argv[])
{
    // 初始化gflags
    google::ParseCommandLineFlags(&argc, &argv, true);
    init_logger(FLAGS_run_mode, FLAGS_log_file, FLAGS_log_level);
 
    // 1、构造rpc信道管理对象，然后关注“/service/echo”这个服务
    ServiceManager::ptr sm = std::make_shared<ServiceManager>();
    sm->declared(FLAGS_call_service);
  
    // 2、绑定服务上下线的回调处理函数，然后传入回调函数构造服务发现对象Discovery
    auto put_cb = std::bind(&ServiceManager::online, sm.get(), std::placeholders::_1, std::placeholders::_2);
    auto del_cb = std::bind(&ServiceManager::offline, sm.get(), std::placeholders::_1, std::placeholders::_2);
    Discovery::ptr dis = std::make_shared<Discovery>(FLAGS_etcd_host, FLAGS_basedir, put_cb, del_cb);
 
    while(true)
    {
        // 3、通过rpc信道管理对象，获取提供Echo服务的信道对象
        auto channel = sm.get()->getChannel(FLAGS_call_service);
        if(!channel)
        {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            return -1;
        }
 
        // 4、构造EchoService_Stub对象，用于进行rpc调用（同步调用）
        example::EchoService_Stub stub(channel.get());
        example::EchoRequest req;
        req.set_message("你好，利刃！");
        brpc::Controller *ctl = new brpc::Controller();
        example::EchoResponse *resp = new example::EchoResponse();
 
        stub.Echo(ctl, &req, resp, nullptr); // 同步方式调用，不需要Closure对象
        if(ctl->Failed() == true) {
            std::cout << "Rpc调用失败：" << ctl->ErrorText() << std::endl;
            delete ctl; 
            delete resp;
            std::this_thread::sleep_for(std::chrono::seconds(1));
            continue;
        }
        std::cout << "收到响应: " << resp->message() << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    return 0;
}

// registery.cc
#include <brpc/server.h>
#include <butil/logging.h>
#include <gflags/gflags.h>
#include "main.pb.h"
#include "../header/etcd.hpp"
 
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(basedir, "/service", "服务监控的主目录");
DEFINE_string(instance, "/echo/instance", "当前实例名称");
DEFINE_string(host, "127.0.0.1:8080", "服务的主机地址");
DEFINE_int32(listen_port, 8080, "rpc服务器的监听端口");
 
// 别忘了要声明命名空间example
class EchoServiceImpl : public example::EchoService {
public:
    EchoServiceImpl() {}
    ~EchoServiceImpl() {}
 
    // 重写Echo接口，实现具体的业务逻辑，以响应客户端发起的 Echo RPC 调用
    void Echo(::google::protobuf::RpcController* controller,
                const ::example::EchoRequest* request,
                ::example::EchoResponse* response,
                ::google::protobuf::Closure* done)
    {
        // 1. 使用RAII方式自动释放done对象，内部会调用run()接口
        brpc::ClosureGuard guard(done);
 
        // 2. 进行请求输出和响应
        std::cout << "收到消息：" << request->message() << std::endl;
        response->set_message(request->message() + "这是一条用于测试的响应信息！");
    }
};
 
int main(int argc, char* argv[])
{
    // 初始化gflags
    google::ParseCommandLineFlags(&argc, &argv, true);
    init_logger(FLAGS_run_mode, FLAGS_log_file, FLAGS_log_level);
    
    // 1. 关闭rpc自带的日志输出
    logging::LoggingSettings settings;
    settings.logging_dest = logging::LoggingDestination::LOG_TO_NONE;
    logging::InitLogging(settings);
 
    // 2. 创建服务器对象
    brpc::Server server;
 
    // 3. 向服务器对象中新增EchoService服务（局部变量，不需要去服务器去清除服务对象）
    EchoServiceImpl impl;
    int ret = server.AddService(&impl, brpc::ServiceOwnership::SERVER_DOESNT_OWN_SERVICE);
    if(ret != 0) {
        std::cout << "添加rpc服务失败！\n";
        return -1;
    }
 
    // 4. 启动服务器
    brpc::ServerOptions options;
    options.num_threads = 1;
    ret = server.Start(FLAGS_listen_port, &options);
    if(ret != 0) {
        std::cout << "启动rpc服务器失败！\n";
        return -1;
    }
 
    // 5、注册服务（创建注册类对象并用智能指针保护起来）
    Registry::ptr reg = std::make_shared<Registry>(FLAGS_etcd_host);
    reg->regiter(FLAGS_basedir + FLAGS_instance, FLAGS_host);
    
    server.RunUntilAskedToQuit(); // 休眠等待运行结束
    return 0;
}

all : registry discovery
registry : registry.cc main.pb.cc
	g++ -std=c++17 -o $@ $^ -lspdlog -lfmt -lgflags -letcd-cpp-api -lcpprest -lbrpc -lssl -lcrypto -lprotobuf -lleveldb
discovery : discovery.cc main.pb.cc
	g++ -std=c++17 -o $@ $^ -lspdlog -lfmt -lgflags -letcd-cpp-api -lcpprest -lbrpc -lssl -lcrypto -lprotobuf -lleveldb
 
.PHONY:clean
clean:
	rm -f discovery registry

syntax = "proto3";
package example;
 
option cc_generic_services = true; // 需要继承RPC服务类就需要cc_generic_services设置开启才能生成
 
message EchoRequest {
    string message = 1;
}
 
message EchoResponse {
    string message = 1;
}
 
// 定义RPC远端方法
service EchoService {
    rpc Echo(EchoRequest) returns (EchoResponse);
}