GRPC C++  1.39.1
async_unary_call.h
Go to the documentation of this file.
1 /*
2  *
3  * Copyright 2015 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 #ifndef GRPCPP_IMPL_CODEGEN_ASYNC_UNARY_CALL_H
20 #define GRPCPP_IMPL_CODEGEN_ASYNC_UNARY_CALL_H
21 
30 
31 namespace grpc {
32 
33 // Forward declaration for use in Helper class
34 template <class R>
35 class ClientAsyncResponseReader;
36 
39 template <class R>
41  public:
43 
47  virtual void StartCall() = 0;
48 
55  virtual void ReadInitialMetadata(void* tag) = 0;
56 
71  virtual void Finish(R* msg, ::grpc::Status* status, void* tag) = 0;
72 };
73 
74 namespace internal {
75 
77  public:
90  template <class R, class W, class BaseR = R, class BaseW = W>
93  const ::grpc::internal::RpcMethod& method, ::grpc::ClientContext* context,
94  const W& request) /* __attribute__((noinline)) */ {
95  ::grpc::internal::Call call = channel->CreateCall(method, context, cq);
98  call.call(), sizeof(ClientAsyncResponseReader<R>)))
99  ClientAsyncResponseReader<R>(call, context);
100  SetupRequest<BaseR, BaseW>(
101  call.call(), &result->single_buf_, &result->read_initial_metadata_,
102  &result->finish_, static_cast<const BaseW&>(request));
103 
104  return result;
105  }
106 
107  // Various helper functions to reduce templating use
108 
109  template <class R, class W>
110  static void SetupRequest(
111  grpc_call* call,
113  std::function<void(ClientContext*, internal::Call*,
115  read_initial_metadata,
116  std::function<
117  void(ClientContext*, internal::Call*, bool initial_metadata_read,
119  internal::CallOpSetInterface**, void*, Status*, void*)>* finish,
120  const W& request) {
121  using SingleBufType =
128  SingleBufType* single_buf =
130  call, sizeof(SingleBufType))) SingleBufType;
131  *single_buf_ptr = single_buf;
132  // TODO(ctiller): don't assert
133  GPR_CODEGEN_ASSERT(single_buf->SendMessage(request).ok());
134  single_buf->ClientSendClose();
135 
136  // The purpose of the following functions is to type-erase the actual
137  // templated type of the CallOpSet being used by hiding that type inside the
138  // function definition rather than specifying it as an argument of the
139  // function or a member of the class. The type-erased CallOpSet will get
140  // static_cast'ed back to the real type so that it can be used properly.
141  *read_initial_metadata =
142  [](ClientContext* context, internal::Call* call,
143  internal::CallOpSendInitialMetadata* single_buf_view, void* tag) {
144  auto* single_buf = static_cast<SingleBufType*>(single_buf_view);
145  single_buf->set_output_tag(tag);
146  single_buf->RecvInitialMetadata(context);
147  call->PerformOps(single_buf);
148  };
149 
150  // Note that this function goes one step further than the previous one
151  // because it type-erases the message being written down to a void*. This
152  // will be static-cast'ed back to the class specified here by hiding that
153  // class information inside the function definition. Note that this feature
154  // expects the class being specified here for R to be a base-class of the
155  // "real" R without any multiple-inheritance (as applies in protbuf wrt
156  // MessageLite)
157  *finish = [](ClientContext* context, internal::Call* call,
158  bool initial_metadata_read,
159  internal::CallOpSendInitialMetadata* single_buf_view,
160  internal::CallOpSetInterface** finish_buf_ptr, void* msg,
161  Status* status, void* tag) {
162  if (initial_metadata_read) {
163  using FinishBufType = ::grpc::internal::CallOpSet<
166  FinishBufType* finish_buf =
168  call->call(), sizeof(FinishBufType))) FinishBufType;
169  *finish_buf_ptr = finish_buf;
170  finish_buf->set_output_tag(tag);
171  finish_buf->RecvMessage(static_cast<R*>(msg));
172  finish_buf->AllowNoMessage();
173  finish_buf->ClientRecvStatus(context, status);
174  call->PerformOps(finish_buf);
175  } else {
176  auto* single_buf = static_cast<SingleBufType*>(single_buf_view);
177  single_buf->set_output_tag(tag);
178  single_buf->RecvInitialMetadata(context);
179  single_buf->RecvMessage(static_cast<R*>(msg));
180  single_buf->AllowNoMessage();
181  single_buf->ClientRecvStatus(context, status);
182  call->PerformOps(single_buf);
183  }
184  };
185  }
186 
187  static void StartCall(
188  ::grpc::ClientContext* context,
190  single_buf->SendInitialMetadata(&context->send_initial_metadata_,
191  context->initial_metadata_flags());
192  }
193 };
194 
195 // TODO(vjpai): This templated factory is deprecated and will be replaced by
196 //. the non-templated helper as soon as possible.
197 template <class R>
199  public:
200  template <class W>
203  const ::grpc::internal::RpcMethod& method, ::grpc::ClientContext* context,
204  const W& request, bool start) {
205  auto* result = ClientAsyncResponseReaderHelper::Create<R>(
206  channel, cq, method, context, request);
207  if (start) {
208  result->StartCall();
209  }
210  return result;
211  }
212 };
213 
214 } // namespace internal
215 
218 template <class R>
221  public:
222  // always allocated against a call arena, no memory free required
223  static void operator delete(void* /*ptr*/, std::size_t size) {
225  }
226 
227  // This operator should never be called as the memory should be freed as part
228  // of the arena destruction. It only exists to provide a matching operator
229  // delete to the operator new so that some compilers will not complain (see
230  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
231  // there are no tests catching the compiler warning.
232  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
233 
234  void StartCall() override {
235  GPR_CODEGEN_DEBUG_ASSERT(!started_);
236  started_ = true;
238  }
239 
246  void ReadInitialMetadata(void* tag) override {
247  GPR_CODEGEN_DEBUG_ASSERT(started_);
248  GPR_CODEGEN_DEBUG_ASSERT(!context_->initial_metadata_received_);
249  read_initial_metadata_(context_, &call_, single_buf_, tag);
250  initial_metadata_read_ = true;
251  }
252 
258  void Finish(R* msg, ::grpc::Status* status, void* tag) override {
259  GPR_CODEGEN_DEBUG_ASSERT(started_);
260  finish_(context_, &call_, initial_metadata_read_, single_buf_, &finish_buf_,
261  static_cast<void*>(msg), status, tag);
262  }
263 
264  private:
266  ::grpc::ClientContext* const context_;
268  bool started_ = false;
269  bool initial_metadata_read_ = false;
270 
272  ::grpc::ClientContext* context)
273  : context_(context), call_(call) {}
274 
275  // disable operator new
276  static void* operator new(std::size_t size);
277  static void* operator new(std::size_t /*size*/, void* p) { return p; }
278 
279  internal::CallOpSendInitialMetadata* single_buf_;
280  internal::CallOpSetInterface* finish_buf_ = nullptr;
281  std::function<void(ClientContext*, internal::Call*,
282  internal::CallOpSendInitialMetadata*, void*)>
283  read_initial_metadata_;
284  std::function<void(ClientContext*, internal::Call*,
285  bool initial_metadata_read,
286  internal::CallOpSendInitialMetadata*,
287  internal::CallOpSetInterface**, void*, Status*, void*)>
288  finish_;
289 };
290 
293 template <class W>
296  public:
298  : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
299 
307  void SendInitialMetadata(void* tag) override {
308  GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
309 
310  meta_buf_.set_output_tag(tag);
311  meta_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
312  ctx_->initial_metadata_flags());
313  if (ctx_->compression_level_set()) {
314  meta_buf_.set_compression_level(ctx_->compression_level());
315  }
316  ctx_->sent_initial_metadata_ = true;
317  call_.PerformOps(&meta_buf_);
318  }
319 
335  void Finish(const W& msg, const ::grpc::Status& status, void* tag) {
336  finish_buf_.set_output_tag(tag);
337  finish_buf_.set_core_cq_tag(&finish_buf_);
338  if (!ctx_->sent_initial_metadata_) {
339  finish_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
340  ctx_->initial_metadata_flags());
341  if (ctx_->compression_level_set()) {
342  finish_buf_.set_compression_level(ctx_->compression_level());
343  }
344  ctx_->sent_initial_metadata_ = true;
345  }
346  // The response is dropped if the status is not OK.
347  if (status.ok()) {
348  finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_,
349  finish_buf_.SendMessage(msg));
350  } else {
351  finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, status);
352  }
353  call_.PerformOps(&finish_buf_);
354  }
355 
368  void FinishWithError(const ::grpc::Status& status, void* tag) {
369  GPR_CODEGEN_ASSERT(!status.ok());
370  finish_buf_.set_output_tag(tag);
371  if (!ctx_->sent_initial_metadata_) {
372  finish_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
373  ctx_->initial_metadata_flags());
374  if (ctx_->compression_level_set()) {
375  finish_buf_.set_compression_level(ctx_->compression_level());
376  }
377  ctx_->sent_initial_metadata_ = true;
378  }
379  finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, status);
380  call_.PerformOps(&finish_buf_);
381  }
382 
383  private:
384  void BindCall(::grpc::internal::Call* call) override { call_ = *call; }
385 
387  ::grpc::ServerContext* ctx_;
389  meta_buf_;
393  finish_buf_;
394 };
395 
396 } // namespace grpc
397 
398 namespace std {
399 template <class R>
400 class default_delete<::grpc::ClientAsyncResponseReader<R>> {
401  public:
402  void operator()(void* /*p*/) {}
403 };
404 template <class R>
405 class default_delete<::grpc::ClientAsyncResponseReaderInterface<R>> {
406  public:
407  void operator()(void* /*p*/) {}
408 };
409 } // namespace std
410 
411 #endif // GRPCPP_IMPL_CODEGEN_ASYNC_UNARY_CALL_H
Codegen interface for grpc::Channel.
Definition: channel_interface.h:71
Async API for client-side unary RPCs, where the message response received from the server is of type ...
Definition: async_unary_call.h:220
void StartCall() override
Start the call that was set up by the constructor, but only if the constructor was invoked through th...
Definition: async_unary_call.h:234
void ReadInitialMetadata(void *tag) override
See ClientAsyncResponseReaderInterface::ReadInitialMetadata for semantics.
Definition: async_unary_call.h:246
void Finish(R *msg, ::grpc::Status *status, void *tag) override
See ClientAsyncResponseReaderInterface::Finish for semantics.
Definition: async_unary_call.h:258
An interface relevant for async client side unary RPCs (which send one request message to a server an...
Definition: async_unary_call.h:40
virtual void StartCall()=0
Start the call that was set up by the constructor, but only if the constructor was invoked through th...
virtual void ReadInitialMetadata(void *tag)=0
Request notification of the reading of initial metadata.
virtual ~ClientAsyncResponseReaderInterface()
Definition: async_unary_call.h:42
virtual void Finish(R *msg, ::grpc::Status *status, void *tag)=0
Request to receive the server's response msg and final status for the call, and to notify tag on this...
A ClientContext allows the person implementing a service client to:
Definition: client_context.h:193
A thin wrapper around grpc_completion_queue (see src/core/lib/surface/completion_queue....
Definition: completion_queue.h:102
virtual void * grpc_call_arena_alloc(grpc_call *call, size_t length)=0
Async server-side API for handling unary calls, where the single response message sent to the client ...
Definition: async_unary_call.h:295
void SendInitialMetadata(void *tag) override
See ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
Definition: async_unary_call.h:307
ServerAsyncResponseWriter(::grpc::ServerContext *ctx)
Definition: async_unary_call.h:297
void Finish(const W &msg, const ::grpc::Status &status, void *tag)
Indicate that the stream is to be finished and request notification when the server has sent the appr...
Definition: async_unary_call.h:335
void FinishWithError(const ::grpc::Status &status, void *tag)
Indicate that the stream is to be finished with a non-OK status, and request notification for when th...
Definition: async_unary_call.h:368
A ServerContext or CallbackServerContext allows the code implementing a service handler to:
Definition: server_context.h:538
bool compression_level_set() const
Return a bool indicating whether the compression level for this call has been set (either implicitly ...
Definition: server_context.h:243
grpc_compression_level compression_level() const
Return the compression algorithm to be used by the server call.
Definition: server_context.h:228
Did it work? If it didn't, why?
Definition: status.h:31
Straightforward wrapping of the C call object.
Definition: call.h:35
grpc_call * call() const
Definition: call.h:69
void PerformOps(CallOpSetInterface *ops)
Definition: call.h:65
Definition: call_op_set.h:769
void ClientRecvStatus(::grpc::ClientContext *context, Status *status)
Definition: call_op_set.h:774
Definition: call_op_set.h:619
Definition: call_op_set.h:721
Definition: call_op_set.h:424
Definition: call_op_set.h:212
void SendInitialMetadata(std::multimap< std::string, std::string > *metadata, uint32_t flags)
Definition: call_op_set.h:218
Definition: call_op_set.h:282
Definition: call_op_set.h:654
Primary implementation of CallOpSetInterface.
Definition: call_op_set.h:867
An abstract collection of call ops, used to generate the grpc_call_op structure to pass down to the l...
Definition: call_op_set_interface.h:34
Definition: async_unary_call.h:198
static ClientAsyncResponseReader< R > * Create(::grpc::ChannelInterface *channel, ::grpc::CompletionQueue *cq, const ::grpc::internal::RpcMethod &method, ::grpc::ClientContext *context, const W &request, bool start)
Definition: async_unary_call.h:201
Definition: async_unary_call.h:76
static void StartCall(::grpc::ClientContext *context, ::grpc::internal::CallOpSendInitialMetadata *single_buf)
Definition: async_unary_call.h:187
static void SetupRequest(grpc_call *call, ::grpc::internal::CallOpSendInitialMetadata **single_buf_ptr, std::function< void(ClientContext *, internal::Call *, internal::CallOpSendInitialMetadata *, void *)> *read_initial_metadata, std::function< void(ClientContext *, internal::Call *, bool initial_metadata_read, internal::CallOpSendInitialMetadata *, internal::CallOpSetInterface **, void *, Status *, void *)> *finish, const W &request)
Definition: async_unary_call.h:110
static ClientAsyncResponseReader< R > * Create(::grpc::ChannelInterface *channel, ::grpc::CompletionQueue *cq, const ::grpc::internal::RpcMethod &method, ::grpc::ClientContext *context, const W &request)
Start a call and write the request out if start is set.
Definition: async_unary_call.h:91
void operator()(void *)
Definition: async_unary_call.h:402
void operator()(void *)
Definition: async_unary_call.h:407
struct grpc_call grpc_call
A Call represents an RPC.
Definition: grpc_types.h:70
#define GPR_CODEGEN_ASSERT(x)
Codegen specific version of GPR_ASSERT.
Definition: core_codegen_interface.h:146
#define GPR_CODEGEN_DEBUG_ASSERT(x)
Codegen specific version of GPR_DEBUG_ASSERT.
Definition: core_codegen_interface.h:155
::google::protobuf::util::Status Status
Definition: config_protobuf.h:91
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm.h:33
CoreCodegenInterface * g_core_codegen_interface
Definition: completion_queue.h:96
Definition: async_unary_call.h:398