| // 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. |
| |
| #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; |
| } |