1 //
2 //
3 // Copyright 2019 gRPC authors.
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17 //
18
19 #include "test/cpp/microbenchmarks/callback_test_service.h"
20
21 #include "absl/log/check.h"
22 #include "absl/log/log.h"
23
24 namespace grpc {
25 namespace testing {
26 namespace {
27
ToString(const grpc::string_ref & r)28 std::string ToString(const grpc::string_ref& r) {
29 return std::string(r.data(), r.size());
30 }
31
GetIntValueFromMetadataHelper(const char * key,const std::multimap<grpc::string_ref,grpc::string_ref> & metadata,int default_value)32 int GetIntValueFromMetadataHelper(
33 const char* key,
34 const std::multimap<grpc::string_ref, grpc::string_ref>& metadata,
35 int default_value) {
36 if (metadata.find(key) != metadata.end()) {
37 std::istringstream iss(ToString(metadata.find(key)->second));
38 iss >> default_value;
39 }
40
41 return default_value;
42 }
43
GetIntValueFromMetadata(const char * key,const std::multimap<grpc::string_ref,grpc::string_ref> & metadata,int default_value)44 int GetIntValueFromMetadata(
45 const char* key,
46 const std::multimap<grpc::string_ref, grpc::string_ref>& metadata,
47 int default_value) {
48 return GetIntValueFromMetadataHelper(key, metadata, default_value);
49 }
50 } // namespace
51
Echo(CallbackServerContext * context,const EchoRequest *,EchoResponse * response)52 ServerUnaryReactor* CallbackStreamingTestService::Echo(
53 CallbackServerContext* context, const EchoRequest* /*request*/,
54 EchoResponse* response) {
55 int response_msgs_size = GetIntValueFromMetadata(
56 kServerMessageSize, context->client_metadata(), 0);
57 if (response_msgs_size > 0) {
58 response->set_message(std::string(response_msgs_size, 'a'));
59 } else {
60 response->set_message("");
61 }
62 auto* reactor = context->DefaultReactor();
63 reactor->Finish(grpc::Status::OK);
64 return reactor;
65 }
66
67 ServerBidiReactor<EchoRequest, EchoResponse>*
BidiStream(CallbackServerContext * context)68 CallbackStreamingTestService::BidiStream(CallbackServerContext* context) {
69 class Reactor : public ServerBidiReactor<EchoRequest, EchoResponse> {
70 public:
71 explicit Reactor(CallbackServerContext* context) {
72 message_size_ = GetIntValueFromMetadata(kServerMessageSize,
73 context->client_metadata(), 0);
74 StartRead(&request_);
75 }
76 void OnDone() override {
77 CHECK(finished_);
78 delete this;
79 }
80 void OnCancel() override {}
81 void OnReadDone(bool ok) override {
82 if (!ok) {
83 // Stream is over
84 Finish(grpc::Status::OK);
85 finished_ = true;
86 return;
87 }
88 if (message_size_ > 0) {
89 response_.set_message(std::string(message_size_, 'a'));
90 } else {
91 response_.set_message("");
92 }
93 StartWrite(&response_);
94 }
95 void OnWriteDone(bool ok) override {
96 if (!ok) {
97 LOG(ERROR) << "Server write failed";
98 return;
99 }
100 StartRead(&request_);
101 }
102
103 private:
104 EchoRequest request_;
105 EchoResponse response_;
106 int message_size_;
107 bool finished_{false};
108 };
109
110 return new Reactor(context);
111 }
112 } // namespace testing
113 } // namespace grpc
114