// Copyright (c) 2014 Baidu, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // A client sending requests to server every 1 second. If the response does // not come back within FLAGS_backup_request_ms, it sends another request // and ends the RPC when any response comes back. #include <gflags/gflags.h> #include <butil/logging.h> #include <butil/time.h> #include <brpc/channel.h> #include "echo.pb.h" DEFINE_string(protocol, "baidu_std", "Protocol type. Defined in src/brpc/options.proto"); DEFINE_string(connection_type, "", "Connection type. Available values: single, pooled, short"); DEFINE_string(server, "0.0.0.0:8000", "IP Address of server"); DEFINE_string(load_balancer, "", "The algorithm for load balancing"); DEFINE_int32(timeout_ms, 100, "RPC timeout in milliseconds"); DEFINE_int32(max_retry, 3, "Max retries(not including the first RPC)"); DEFINE_int32(backup_request_ms, 2, "Timeout for sending backup request"); int main(int argc, char* argv[]) { // Parse gflags. We recommend you to use gflags as well. google::ParseCommandLineFlags(&argc, &argv, true); // A Channel represents a communication line to a Server. Notice that // Channel is thread-safe and can be shared by all threads in your program. brpc::Channel channel; // Initialize the channel, NULL means using default options. brpc::ChannelOptions options; options.protocol = FLAGS_protocol; options.connection_type = FLAGS_connection_type; options.timeout_ms = FLAGS_timeout_ms/*milliseconds*/; options.max_retry = FLAGS_max_retry; options.backup_request_ms = FLAGS_backup_request_ms; if (channel.Init(FLAGS_server.c_str(), FLAGS_load_balancer.c_str(), &options) != 0) { LOG(ERROR) << "Fail to initialize channel"; return -1; } // Normally, you should not call a Channel directly, but instead construct // a stub Service wrapping it. stub can be shared by all threads as well. example::EchoService_Stub stub(&channel); // Send a request and wait for the response every 1 second. int counter = 0; while (!brpc::IsAskedToQuit()) { // We will receive response synchronously, safe to put variables // on stack. example::EchoRequest request; example::EchoResponse response; brpc::Controller cntl; request.set_index(++counter); // Because `done'(last parameter) is NULL, this function waits until // the response comes back or error occurs(including timedout). stub.Echo(&cntl, &request, &response, NULL); if (!cntl.Failed()) { LOG(INFO) << "Received response[index=" << response.index() << "] from " << cntl.remote_side() << " to " << cntl.local_side() << " latency=" << cntl.latency_us() << "us"; } else { LOG(WARNING) << cntl.ErrorText(); } sleep(1); } LOG(INFO) << "EchoClient is going to quit"; return 0; }