【brpc学习实践七】dummy server、DynamicPartitionChannel
dummy server
如果你的程序只使用了baidu-rpc的client或根本没有使用baidu-rpc，但你也想使用baidu-rpc的内置服务，只要在程序中启动一个空的server就行了，这种server我们称为dummy server。
Dummy server 可以用于原型设计和开发目的，作为简单的 http 服务器使用，多数场景用不上。
brpc怎么开启dummy server
使用brpc的client
方式一（推荐方式）
通过gflags方式声明dummy server port，比如：–dummy_server_port=8888，需要重启服务才能生效，优先级低于方式二。
这种方式使用成本较低，优先级低于方式二的原因是：晚于方式二出现，因此需要兼容方式二。
方式二
在程序运行目录建立dummy_server.port文件，填入一个端口号（比如8888），不需要重启服务就能生效，优先级高于方式一。
没有使用baidu-rpc的client
你必须手动加入dummy server
#include r31803之后加入dummy server更容易了，只要一行：
#include 使用brpc客户端的dummy示例
值得注意的是，我们在这里用了bvar::LatencyRecorder g_latency_recorder(“client”);来记录延迟，我们将在下一篇章详细讲述bvar的功能
#include DynamicPartitionChannel
主要是用来，就是可以在保持客户端代码不变的情况下，将服务器从一个分区方式更改为另一个分区，这样可以实现服务器之间的无缝切换，提高了系统的可用性和稳定性。具体实例代码如下，由于工作中没用到，大概记录下，后续用到再来补充细节：
client示例：
#include server分区配置示例
0.0.0.0:8004 0/3
0.0.0.0:8004 1/3
0.0.0.0:8004 2/3
# 0.0.0.0:8008 0/3
0.0.0.0:8005 0/4
0.0.0.0:8005 1/4
0.0.0.0:8005 2/4
0.0.0.0:8005 3/4
0.0.0.0:8006 0/4
0.0.0.0:8006 1/4
0.0.0.0:8006 2/4
0.0.0.0:8006 3/4
server端示例
DEFINE_bool(echo_attachment, true, "Echo attachment as well");
DEFINE_int32(port, 8004, "TCP Port of this server");
DEFINE_int32(idle_timeout_s, -1, "Connection will be closed if there is no "
"read/write operations during the last `idle_timeout_s'");
DEFINE_int32(logoff_ms, 2000, "Maximum duration of server's LOGOFF state "
"(waiting for client to close connection before server stops)");
DEFINE_int32(max_concurrency, 0, "Limit of request processing in parallel");
DEFINE_int32(server_num, 1, "Number of servers");
DEFINE_string(sleep_us, "", "Sleep so many microseconds before responding");
DEFINE_bool(spin, false, "spin rather than sleep");
DEFINE_double(exception_ratio, 0.1, "Percentage of irregular latencies");
DEFINE_double(min_ratio, 0.2, "min_sleep / sleep_us");
DEFINE_double(max_ratio, 10, "max_sleep / sleep_us");
// Your implementation of example::EchoService
class EchoServiceImpl : public example::EchoService {
public:
EchoServiceImpl() : _index(0) {}
virtual ~EchoServiceImpl() {};
void set_index(size_t index, int64_t sleep_us) {
_index = index;
_sleep_us = sleep_us;
}
virtual void Echo(google::protobuf::RpcController* cntl_base,
const example::EchoRequest* request,
example::EchoResponse* response,
google::protobuf::Closure* done) {
brpc::ClosureGuard done_guard(done);
brpc::Controller* cntl =
static_cast<brpc::Controller*>(cntl_base);
if (_sleep_us > 0) {
double delay = _sleep_us;
const double a = FLAGS_exception_ratio * 0.5;
if (a >= 0.0001) {
double x = butil::RandDouble();
if (x < a) {
const double min_sleep_us = FLAGS_min_ratio * _sleep_us;
delay = min_sleep_us + (_sleep_us - min_sleep_us) * x / a;
} else if (x + a > 1) {
const double max_sleep_us = FLAGS_max_ratio * _sleep_us;
delay = _sleep_us + (max_sleep_us - _sleep_us) * (x + a - 1) / a;
}
}
if (FLAGS_spin) {
int64_t end_time = butil::gettimeofday_us() + (int64_t)delay;
while (butil::gettimeofday_us() < end_time) {}
} else {
bthread_usleep((int64_t)delay);
}
}
// Echo request and its attachment
response->set_message(request->message());
if (FLAGS_echo_attachment) {
cntl->response_attachment().append(cntl->request_attachment());
}
_nreq << 1;
}
size_t num_requests() const { return _nreq.get_value(); }
private:
size_t _index;
int64_t _sleep_us;
bvar::Adder<size_t> _nreq;
};
int main(int argc, char* argv[]) {
// Parse gflags. We recommend you to use gflags as well.
GFLAGS_NS::ParseCommandLineFlags(&argc, &argv, true);
if (FLAGS_server_num <= 0) {
LOG(ERROR) << "server_num must be positive";
return -1;
}
// We need multiple servers in this example.
brpc::Server* servers = new brpc::Server[FLAGS_server_num];
// For more options see `brpc/server.h'.
brpc::ServerOptions options;
options.idle_timeout_sec = FLAGS_idle_timeout_s;
options.max_concurrency = FLAGS_max_concurrency;
butil::StringSplitter sp(FLAGS_sleep_us.c_str(), ',');
std::vector<int64_t> sleep_list;
for (; sp; ++sp) {
sleep_list.push_back(strtoll(sp.field(), NULL, 10));
}
if (sleep_list.empty()) {
sleep_list.push_back(0);
}
// Instance of your services.
EchoServiceImpl* echo_service_impls = new EchoServiceImpl[FLAGS_server_num];
// Add the service into servers. Notice the second parameter, because the
// service is put on stack, we don't want server to delete it, otherwise
// use brpc::SERVER_OWNS_SERVICE.
for (int i = 0; i < FLAGS_server_num; ++i) {
int64_t sleep_us = sleep_list[(size_t)i < sleep_list.size() ? i : (sleep_list.size() - 1)];
echo_service_impls[i].set_index(i, sleep_us);
// will be shown on /version page
servers[i].set_version(butil::string_printf(
"example/dynamic_partition_echo_c++[%d]", i));
if (servers[i].AddService(&echo_service_impls[i],
brpc::SERVER_DOESNT_OWN_SERVICE) != 0) {
LOG(ERROR) << "Fail to add service";
return -1;
}
// Start the server.
int port = FLAGS_port + i;
if (servers[i].Start(port, &options) != 0) {
LOG(ERROR) << "Fail to start EchoServer";
return -1;
}
}
// Service logic are running in separate worker threads, for main thread,
// we don't have much to do, just spinning.
std::vector<size_t> last_num_requests(FLAGS_server_num);
while (!brpc::IsAskedToQuit()) {
sleep(1);
size_t cur_total = 0;
for (int i = 0; i < FLAGS_server_num; ++i) {
const size_t current_num_requests =
echo_service_impls[i].num_requests();
size_t diff = current_num_requests - last_num_requests[i];
cur_total += diff;
last_num_requests[i] = current_num_requests;
LOG(INFO) << "S[" << i << "]=" << diff << ' ' << noflush;
}
LOG(INFO) << "[total=" << cur_total << ']';
}
// Don't forget to stop and join the server otherwise still-running
// worker threads may crash your program. Clients will have/ at most
// `FLAGS_logoff_ms' to close their connections. If some connections
// still remains after `FLAGS_logoff_ms', they will be closed by force.
for (int i = 0; i < FLAGS_server_num; ++i) {
servers[i].Stop(FLAGS_logoff_ms);
}
for (int i = 0; i < FLAGS_server_num; ++i) {
servers[i].Join();
}
delete [] servers;
delete [] echo_service_impls;
return 0;
}