// Licensed to the Apache Software Foundation (ASF) under one // or more contributor license agreements. See the NOTICE file // distributed with this work for additional information // regarding copyright ownership. The ASF licenses this file // to you 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 using grpc. // Authors: Jiashun Zhu(zhujiashun@bilibili.com) #include <gflags/gflags.h> #include <butil/logging.h> #include <butil/time.h> #include <brpc/channel.h> #include "helloworld.pb.h" DEFINE_string(protocol, "h2:grpc", "Protocol type. Defined in src/brpc/options.proto"); DEFINE_string(server, "0.0.0.0:50051", "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(interval_ms, 1000, "Milliseconds between consecutive requests"); DEFINE_bool(gzip, false, "compress body using gzip"); int main(int argc, char* argv[]) { // Parse gflags. We recommend you to use gflags as well. GFLAGS_NS::ParseCommandLineFlags(&argc, &argv, true); if (FLAGS_gzip) { GFLAGS_NS::SetCommandLineOption("http_body_compress_threshold", 0); } // 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.timeout_ms = FLAGS_timeout_ms/*milliseconds*/; options.max_retry = FLAGS_max_retry; 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. helloworld::Greeter_Stub stub(&channel); // Send a request and wait for the response every 1 second. while (!brpc::IsAskedToQuit()) { // We will receive response synchronously, safe to put variables // on stack. helloworld::HelloRequest request; helloworld::HelloReply response; brpc::Controller cntl; request.set_name("grpc_req_from_brpc"); if (FLAGS_gzip) { cntl.set_request_compress_type(brpc::COMPRESS_TYPE_GZIP); } // Because `done'(last parameter) is NULL, this function waits until // the response comes back or error occurs(including timedout). stub.SayHello(&cntl, &request, &response, NULL); if (!cntl.Failed()) { LOG(INFO) << "Received response from " << cntl.remote_side() << " to " << cntl.local_side() << ": " << response.message() << " latency=" << cntl.latency_us() << "us"; } else { LOG(WARNING) << cntl.ErrorText(); } usleep(FLAGS_interval_ms * 1000L); } return 0; }