GRPC C++  1.26.0
server_callback_impl.h
Go to the documentation of this file.
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 #ifndef GRPCPP_IMPL_CODEGEN_SERVER_CALLBACK_IMPL_H
19 #define GRPCPP_IMPL_CODEGEN_SERVER_CALLBACK_IMPL_H
20 
21 #include <atomic>
22 #include <functional>
23 #include <type_traits>
24 
32 
33 namespace grpc_impl {
34 
35 // Declare base class of all reactors as internal
36 namespace internal {
37 
38 // Forward declarations
39 template <class Request, class Response>
40 class CallbackUnaryHandler;
41 template <class Request, class Response>
42 class CallbackClientStreamingHandler;
43 template <class Request, class Response>
44 class CallbackServerStreamingHandler;
45 template <class Request, class Response>
46 class CallbackBidiHandler;
47 
49  public:
50  virtual ~ServerReactor() = default;
51  virtual void OnDone() = 0;
52  virtual void OnCancel() = 0;
53 
54  // The following is not API. It is for internal use only and specifies whether
55  // all reactions of this Reactor can be run without an extra executor
56  // scheduling. This should only be used for internally-defined reactors with
57  // trivial reactions.
58  virtual bool InternalInlineable() { return false; }
59 
60  private:
61  template <class Request, class Response>
62  friend class CallbackUnaryHandler;
63  template <class Request, class Response>
65  template <class Request, class Response>
67  template <class Request, class Response>
68  friend class CallbackBidiHandler;
69 };
70 
73  public:
74  virtual ~ServerCallbackCall() {}
75 
76  // This object is responsible for tracking when it is safe to call
77  // OnCancel. This function should not be called until after the method handler
78  // is done and the RPC has completed with a cancellation. This is tracked by
79  // counting how many of these conditions have been met and calling OnCancel
80  // when none remain unmet.
81 
82  // Fast version called with known reactor passed in, used from derived
83  // classes, typically in non-cancel case
85  if (GPR_UNLIKELY(on_cancel_conditions_remaining_.fetch_sub(
86  1, std::memory_order_acq_rel) == 1)) {
87  CallOnCancel(reactor);
88  }
89  }
90 
91  // Slower version called from object that doesn't know the reactor a priori
92  // (such as the ServerContext CompletionOp which is formed before the
93  // reactor). This is used in cancel cases only, so it's ok to be slower and
94  // invoke a virtual function.
95  void MaybeCallOnCancel() { MaybeCallOnCancel(reactor()); }
96 
97  protected:
99  void Ref() { callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed); }
100 
102  int Unref() {
103  return callbacks_outstanding_.fetch_sub(1, std::memory_order_acq_rel);
104  }
105 
106  private:
107  virtual ServerReactor* reactor() = 0;
108  virtual void MaybeDone() = 0;
109 
110  // If the OnCancel reaction is inlineable, execute it inline. Otherwise send
111  // it to an executor.
112  void CallOnCancel(ServerReactor* reactor);
113 
114  std::atomic_int on_cancel_conditions_remaining_{2};
115  std::atomic_int callbacks_outstanding_{
116  3}; // reserve for start, Finish, and CompletionOp
117 };
118 
119 template <class Request, class Response>
121  : public ::grpc::experimental::MessageHolder<Request, Response> {
122  public:
124  this->set_request(&request_obj_);
125  this->set_response(&response_obj_);
126  }
127  void Release() override {
128  // the object is allocated in the call arena.
130  }
131 
132  private:
133  Request request_obj_;
134  Response response_obj_;
135 };
136 
137 } // namespace internal
138 
139 // Forward declarations
140 class ServerUnaryReactor;
141 template <class Request>
142 class ServerReadReactor;
143 template <class Response>
144 class ServerWriteReactor;
145 template <class Request, class Response>
146 class ServerBidiReactor;
147 
148 // NOTE: The actual call/stream object classes are provided as API only to
149 // support mocking. There are no implementations of these class interfaces in
150 // the API.
152  public:
153  virtual ~ServerCallbackUnary() {}
154  virtual void Finish(::grpc::Status s) = 0;
155  virtual void SendInitialMetadata() = 0;
156 
157  protected:
158  // Use a template rather than explicitly specifying ServerUnaryReactor to
159  // delay binding and avoid a circular forward declaration issue
160  template <class Reactor>
161  void BindReactor(Reactor* reactor) {
162  reactor->InternalBindCall(this);
163  }
164 };
165 
166 template <class Request>
168  public:
170  virtual void Finish(::grpc::Status s) = 0;
171  virtual void SendInitialMetadata() = 0;
172  virtual void Read(Request* msg) = 0;
173 
174  protected:
176  reactor->InternalBindReader(this);
177  }
178 };
179 
180 template <class Response>
182  public:
184 
185  virtual void Finish(::grpc::Status s) = 0;
186  virtual void SendInitialMetadata() = 0;
187  virtual void Write(const Response* msg, ::grpc::WriteOptions options) = 0;
188  virtual void WriteAndFinish(const Response* msg, ::grpc::WriteOptions options,
189  ::grpc::Status s) = 0;
190 
191  protected:
193  reactor->InternalBindWriter(this);
194  }
195 };
196 
197 template <class Request, class Response>
199  public:
201 
202  virtual void Finish(::grpc::Status s) = 0;
203  virtual void SendInitialMetadata() = 0;
204  virtual void Read(Request* msg) = 0;
205  virtual void Write(const Response* msg, ::grpc::WriteOptions options) = 0;
206  virtual void WriteAndFinish(const Response* msg, ::grpc::WriteOptions options,
207  ::grpc::Status s) = 0;
208 
209  protected:
211  reactor->InternalBindStream(this);
212  }
213 };
214 
215 // The following classes are the reactor interfaces that are to be implemented
216 // by the user, returned as the output parameter of the method handler for a
217 // callback method. Note that none of the classes are pure; all reactions have a
218 // default empty reaction so that the user class only needs to override those
219 // classes that it cares about.
220 
222 template <class Request, class Response>
224  public:
225  // NOTE: Initializing stream_ as a constructor initializer rather than a
226  // default initializer because gcc-4.x requires a copy constructor for
227  // default initializing a templated member, which isn't ok for atomic.
228  // TODO(vjpai): Switch to default constructor and default initializer when
229  // gcc-4.x is no longer supported
230  ServerBidiReactor() : stream_(nullptr) {}
231  ~ServerBidiReactor() = default;
232 
238  stream_.load(std::memory_order_acquire);
239  if (stream == nullptr) {
240  grpc::internal::MutexLock l(&stream_mu_);
241  stream = stream_.load(std::memory_order_relaxed);
242  if (stream == nullptr) {
243  send_initial_metadata_wanted_ = true;
244  return;
245  }
246  }
247  stream->SendInitialMetadata();
248  }
249 
254  void StartRead(Request* req) {
256  stream_.load(std::memory_order_acquire);
257  if (stream == nullptr) {
258  grpc::internal::MutexLock l(&stream_mu_);
259  stream = stream_.load(std::memory_order_relaxed);
260  if (stream == nullptr) {
261  read_wanted_ = req;
262  return;
263  }
264  }
265  stream->Read(req);
266  }
267 
273  void StartWrite(const Response* resp) {
274  StartWrite(resp, ::grpc::WriteOptions());
275  }
276 
283  void StartWrite(const Response* resp, ::grpc::WriteOptions options) {
285  stream_.load(std::memory_order_acquire);
286  if (stream == nullptr) {
287  grpc::internal::MutexLock l(&stream_mu_);
288  stream = stream_.load(std::memory_order_relaxed);
289  if (stream == nullptr) {
290  write_wanted_ = resp;
291  write_options_wanted_ = std::move(options);
292  return;
293  }
294  }
295  stream->Write(resp, std::move(options));
296  }
297 
311  void StartWriteAndFinish(const Response* resp, ::grpc::WriteOptions options,
312  ::grpc::Status s) {
314  stream_.load(std::memory_order_acquire);
315  if (stream == nullptr) {
316  grpc::internal::MutexLock l(&stream_mu_);
317  stream = stream_.load(std::memory_order_relaxed);
318  if (stream == nullptr) {
319  write_and_finish_wanted_ = true;
320  write_wanted_ = resp;
321  write_options_wanted_ = std::move(options);
322  status_wanted_ = std::move(s);
323  return;
324  }
325  }
326  stream->WriteAndFinish(resp, std::move(options), std::move(s));
327  }
328 
337  void StartWriteLast(const Response* resp, ::grpc::WriteOptions options) {
338  StartWrite(resp, std::move(options.set_last_message()));
339  }
340 
347  void Finish(::grpc::Status s) {
349  stream_.load(std::memory_order_acquire);
350  if (stream == nullptr) {
351  grpc::internal::MutexLock l(&stream_mu_);
352  stream = stream_.load(std::memory_order_relaxed);
353  if (stream == nullptr) {
354  finish_wanted_ = true;
355  status_wanted_ = std::move(s);
356  return;
357  }
358  }
359  stream->Finish(std::move(s));
360  }
361 
368  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}
369 
374  virtual void OnReadDone(bool /*ok*/) {}
375 
381  virtual void OnWriteDone(bool /*ok*/) {}
382 
386  void OnDone() override = 0;
387 
391  void OnCancel() override {}
392 
393  private:
394  friend class ServerCallbackReaderWriter<Request, Response>;
395  // May be overridden by internal implementation details. This is not a public
396  // customization point.
397  virtual void InternalBindStream(
400  stream_.store(stream, std::memory_order_release);
401  if (send_initial_metadata_wanted_) {
402  stream->SendInitialMetadata();
403  send_initial_metadata_wanted_ = false;
404  }
405  if (read_wanted_ != nullptr) {
406  stream->Read(read_wanted_);
407  read_wanted_ = nullptr;
408  }
409  if (write_and_finish_wanted_) {
410  // Don't perform actual finish actions while holding lock since it could
411  // trigger OnDone that destroys this object including the still-held lock.
412  write_and_finish_wanted_ = false;
413  const Response* write_wanted = write_wanted_;
414  ::grpc::WriteOptions write_options_wanted =
415  std::move(write_options_wanted_);
416  ::grpc::Status status_wanted = std::move(status_wanted_);
417  l.Unlock();
418  stream->WriteAndFinish(write_wanted, std::move(write_options_wanted),
419  std::move(status_wanted));
420  return;
421  } else {
422  if (write_wanted_ != nullptr) {
423  stream->Write(write_wanted_, std::move(write_options_wanted_));
424  write_wanted_ = nullptr;
425  }
426  if (finish_wanted_) {
427  finish_wanted_ = false;
428  ::grpc::Status status_wanted = std::move(status_wanted_);
429  l.Unlock();
430  stream->Finish(std::move(status_wanted));
431  return;
432  }
433  }
434  }
435 
436  grpc::internal::Mutex stream_mu_;
437  std::atomic<ServerCallbackReaderWriter<Request, Response>*> stream_;
438  bool send_initial_metadata_wanted_ /* GUARDED_BY(stream_mu_) */ = false;
439  bool write_and_finish_wanted_ /* GUARDED_BY(stream_mu_) */ = false;
440  bool finish_wanted_ /* GUARDED_BY(stream_mu_) */ = false;
441  Request* read_wanted_ /* GUARDED_BY(stream_mu_) */ = nullptr;
442  const Response* write_wanted_ /* GUARDED_BY(stream_mu_) */ = nullptr;
443  ::grpc::WriteOptions write_options_wanted_ /* GUARDED_BY(stream_mu_) */;
444  ::grpc::Status status_wanted_ /* GUARDED_BY(stream_mu_) */;
445 };
446 
448 template <class Request>
450  public:
451  ServerReadReactor() : reader_(nullptr) {}
452  ~ServerReadReactor() = default;
453 
457  reader_.load(std::memory_order_acquire);
458  if (reader == nullptr) {
459  grpc::internal::MutexLock l(&reader_mu_);
460  reader = reader_.load(std::memory_order_relaxed);
461  if (reader == nullptr) {
462  send_initial_metadata_wanted_ = true;
463  return;
464  }
465  }
466  reader->SendInitialMetadata();
467  }
468  void StartRead(Request* req) {
470  reader_.load(std::memory_order_acquire);
471  if (reader == nullptr) {
472  grpc::internal::MutexLock l(&reader_mu_);
473  reader = reader_.load(std::memory_order_relaxed);
474  if (reader == nullptr) {
475  read_wanted_ = req;
476  return;
477  }
478  }
479  reader->Read(req);
480  }
481  void Finish(::grpc::Status s) {
483  reader_.load(std::memory_order_acquire);
484  if (reader == nullptr) {
485  grpc::internal::MutexLock l(&reader_mu_);
486  reader = reader_.load(std::memory_order_relaxed);
487  if (reader == nullptr) {
488  finish_wanted_ = true;
489  status_wanted_ = std::move(s);
490  return;
491  }
492  }
493  reader->Finish(std::move(s));
494  }
495 
497  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}
498  virtual void OnReadDone(bool /*ok*/) {}
499  void OnDone() override = 0;
500  void OnCancel() override {}
501 
502  private:
503  friend class ServerCallbackReader<Request>;
504 
505  // May be overridden by internal implementation details. This is not a public
506  // customization point.
507  virtual void InternalBindReader(ServerCallbackReader<Request>* reader) {
509  reader_.store(reader, std::memory_order_release);
510  if (send_initial_metadata_wanted_) {
511  reader->SendInitialMetadata();
512  send_initial_metadata_wanted_ = false;
513  }
514  if (read_wanted_ != nullptr) {
515  reader->Read(read_wanted_);
516  read_wanted_ = nullptr;
517  }
518  if (finish_wanted_) {
519  finish_wanted_ = false;
520  ::grpc::Status status_wanted = std::move(status_wanted_);
521  l.Unlock();
522  reader->Finish(std::move(status_wanted));
523  return;
524  }
525  }
526 
527  grpc::internal::Mutex reader_mu_;
528  std::atomic<ServerCallbackReader<Request>*> reader_;
529  bool send_initial_metadata_wanted_ /* GUARDED_BY(reader_mu_) */ = false;
530  bool finish_wanted_ /* GUARDED_BY(reader_mu_) */ = false;
531  Request* read_wanted_ /* GUARDED_BY(reader_mu_) */ = nullptr;
532  ::grpc::Status status_wanted_ /* GUARDED_BY(reader_mu_) */;
533 };
534 
536 template <class Response>
538  public:
539  ServerWriteReactor() : writer_(nullptr) {}
540  ~ServerWriteReactor() = default;
541 
545  writer_.load(std::memory_order_acquire);
546  if (writer == nullptr) {
547  grpc::internal::MutexLock l(&writer_mu_);
548  writer = writer_.load(std::memory_order_relaxed);
549  if (writer == nullptr) {
550  send_initial_metadata_wanted_ = true;
551  return;
552  }
553  }
554  writer->SendInitialMetadata();
555  }
556  void StartWrite(const Response* resp) {
557  StartWrite(resp, ::grpc::WriteOptions());
558  }
559  void StartWrite(const Response* resp, ::grpc::WriteOptions options) {
561  writer_.load(std::memory_order_acquire);
562  if (writer == nullptr) {
563  grpc::internal::MutexLock l(&writer_mu_);
564  writer = writer_.load(std::memory_order_relaxed);
565  if (writer == nullptr) {
566  write_wanted_ = resp;
567  write_options_wanted_ = std::move(options);
568  return;
569  }
570  }
571  writer->Write(resp, std::move(options));
572  }
573  void StartWriteAndFinish(const Response* resp, ::grpc::WriteOptions options,
574  ::grpc::Status s) {
576  writer_.load(std::memory_order_acquire);
577  if (writer == nullptr) {
578  grpc::internal::MutexLock l(&writer_mu_);
579  writer = writer_.load(std::memory_order_relaxed);
580  if (writer == nullptr) {
581  write_and_finish_wanted_ = true;
582  write_wanted_ = resp;
583  write_options_wanted_ = std::move(options);
584  status_wanted_ = std::move(s);
585  return;
586  }
587  }
588  writer->WriteAndFinish(resp, std::move(options), std::move(s));
589  }
590  void StartWriteLast(const Response* resp, ::grpc::WriteOptions options) {
591  StartWrite(resp, std::move(options.set_last_message()));
592  }
593  void Finish(::grpc::Status s) {
595  writer_.load(std::memory_order_acquire);
596  if (writer == nullptr) {
597  grpc::internal::MutexLock l(&writer_mu_);
598  writer = writer_.load(std::memory_order_relaxed);
599  if (writer == nullptr) {
600  finish_wanted_ = true;
601  status_wanted_ = std::move(s);
602  return;
603  }
604  }
605  writer->Finish(std::move(s));
606  }
607 
609  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}
610  virtual void OnWriteDone(bool /*ok*/) {}
611  void OnDone() override = 0;
612  void OnCancel() override {}
613 
614  private:
615  friend class ServerCallbackWriter<Response>;
616  // May be overridden by internal implementation details. This is not a public
617  // customization point.
618  virtual void InternalBindWriter(ServerCallbackWriter<Response>* writer) {
620  writer_.store(writer, std::memory_order_release);
621  if (send_initial_metadata_wanted_) {
622  writer->SendInitialMetadata();
623  send_initial_metadata_wanted_ = false;
624  }
625  if (write_and_finish_wanted_) {
626  write_and_finish_wanted_ = false;
627  const Response* write_wanted = write_wanted_;
628  ::grpc::WriteOptions write_options_wanted =
629  std::move(write_options_wanted_);
630  ::grpc::Status status_wanted = std::move(status_wanted_);
631  l.Unlock();
632  writer->WriteAndFinish(write_wanted, std::move(write_options_wanted),
633  std::move(status_wanted));
634  return;
635  } else {
636  if (write_wanted_ != nullptr) {
637  writer->Write(write_wanted_, std::move(write_options_wanted_));
638  write_wanted_ = nullptr;
639  }
640  if (finish_wanted_) {
641  finish_wanted_ = false;
642  ::grpc::Status status_wanted = std::move(status_wanted_);
643  l.Unlock();
644  writer->Finish(std::move(status_wanted));
645  return;
646  }
647  }
648  }
649 
650  grpc::internal::Mutex writer_mu_;
651  std::atomic<ServerCallbackWriter<Response>*> writer_;
652  bool send_initial_metadata_wanted_ /* GUARDED_BY(writer_mu_) */ = false;
653  bool write_and_finish_wanted_ /* GUARDED_BY(writer_mu_) */ = false;
654  bool finish_wanted_ /* GUARDED_BY(writer_mu_) */ = false;
655  const Response* write_wanted_ /* GUARDED_BY(writer_mu_) */ = nullptr;
656  ::grpc::WriteOptions write_options_wanted_ /* GUARDED_BY(writer_mu_) */;
657  ::grpc::Status status_wanted_ /* GUARDED_BY(writer_mu_) */;
658 };
659 
661  public:
662  ServerUnaryReactor() : call_(nullptr) {}
663  ~ServerUnaryReactor() = default;
664 
667  ServerCallbackUnary* call = call_.load(std::memory_order_acquire);
668  if (call == nullptr) {
669  grpc::internal::MutexLock l(&call_mu_);
670  call = call_.load(std::memory_order_relaxed);
671  if (call == nullptr) {
672  send_initial_metadata_wanted_ = true;
673  return;
674  }
675  }
676  call->SendInitialMetadata();
677  }
678  void Finish(::grpc::Status s) {
679  ServerCallbackUnary* call = call_.load(std::memory_order_acquire);
680  if (call == nullptr) {
681  grpc::internal::MutexLock l(&call_mu_);
682  call = call_.load(std::memory_order_relaxed);
683  if (call == nullptr) {
684  finish_wanted_ = true;
685  status_wanted_ = std::move(s);
686  return;
687  }
688  }
689  call->Finish(std::move(s));
690  }
691 
693  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}
694  void OnDone() override = 0;
695  void OnCancel() override {}
696 
697  private:
698  friend class ServerCallbackUnary;
699  // May be overridden by internal implementation details. This is not a public
700  // customization point.
701  virtual void InternalBindCall(ServerCallbackUnary* call) {
703  call_.store(call, std::memory_order_release);
704  if (send_initial_metadata_wanted_) {
705  call->SendInitialMetadata();
706  send_initial_metadata_wanted_ = false;
707  }
708  if (finish_wanted_) {
709  finish_wanted_ = false;
710  ::grpc::Status status_wanted = std::move(status_wanted_);
711  l.Unlock();
712  call->Finish(std::move(status_wanted));
713  return;
714  }
715  }
716 
717  grpc::internal::Mutex call_mu_;
718  std::atomic<ServerCallbackUnary*> call_;
719  bool send_initial_metadata_wanted_ /* GUARDED_BY(writer_mu_) */ = false;
720  bool finish_wanted_ /* GUARDED_BY(writer_mu_) */ = false;
721  ::grpc::Status status_wanted_ /* GUARDED_BY(writer_mu_) */;
722 };
723 
724 namespace internal {
725 
726 template <class Base>
727 class FinishOnlyReactor : public Base {
728  public:
729  explicit FinishOnlyReactor(::grpc::Status s) { this->Finish(std::move(s)); }
730  void OnDone() override { this->~FinishOnlyReactor(); }
731 };
732 
734 template <class Request>
736 template <class Response>
739 template <class Request, class Response>
742 
743 } // namespace internal
744 } // namespace grpc_impl
745 
746 #endif // GRPCPP_IMPL_CODEGEN_SERVER_CALLBACK_IMPL_H
Did it work? If it didn't, why?
Definition: status.h:31
Per-message write options.
Definition: call_op_set.h:79
WriteOptions & set_last_message()
last-message bit: indicates this is the last message in a stream client-side: makes Write the equival...
Definition: call_op_set.h:161
Definition: message_allocator.h:40
void set_request(Request *request)
Definition: message_allocator.h:50
void set_response(Response *response)
Definition: message_allocator.h:51
Definition: sync.h:47
Definition: sync.h:69
ServerBidiReactor is the interface for a bidirectional streaming RPC.
Definition: server_callback_impl.h:223
virtual void OnSendInitialMetadataDone(bool)
Notifies the application that an explicit StartSendInitialMetadata operation completed.
Definition: server_callback_impl.h:368
virtual void OnWriteDone(bool)
Notifies the application that a StartWrite (or StartWriteLast) operation completed.
Definition: server_callback_impl.h:381
void StartWrite(const Response *resp)
Initiate a write operation.
Definition: server_callback_impl.h:273
void StartSendInitialMetadata()
Send any initial metadata stored in the RPC context.
Definition: server_callback_impl.h:236
void Finish(::grpc::Status s)
Indicate that the stream is to be finished and the trailing metadata and RPC status are to be sent.
Definition: server_callback_impl.h:347
void StartWriteAndFinish(const Response *resp, ::grpc::WriteOptions options, ::grpc::Status s)
Initiate a write operation with specified options and final RPC Status, which also causes any trailin...
Definition: server_callback_impl.h:311
void StartWriteLast(const Response *resp, ::grpc::WriteOptions options)
Inform system of a planned write operation with specified options, but allow the library to schedule ...
Definition: server_callback_impl.h:337
ServerBidiReactor()
Definition: server_callback_impl.h:230
virtual void OnReadDone(bool)
Notifies the application that a StartRead operation completed.
Definition: server_callback_impl.h:374
void OnDone() override=0
Notifies the application that all operations associated with this RPC have completed.
void StartRead(Request *req)
Initiate a read operation.
Definition: server_callback_impl.h:254
void OnCancel() override
Notifies the application that this RPC has been cancelled.
Definition: server_callback_impl.h:391
void StartWrite(const Response *resp, ::grpc::WriteOptions options)
Initiate a write operation with specified options.
Definition: server_callback_impl.h:283
Definition: server_callback_impl.h:167
virtual ~ServerCallbackReader()
Definition: server_callback_impl.h:169
virtual void Read(Request *msg)=0
void BindReactor(ServerReadReactor< Request > *reactor)
Definition: server_callback_impl.h:175
virtual void Finish(::grpc::Status s)=0
virtual void SendInitialMetadata()=0
Definition: server_callback_impl.h:198
virtual void Read(Request *msg)=0
virtual void Write(const Response *msg, ::grpc::WriteOptions options)=0
virtual void WriteAndFinish(const Response *msg, ::grpc::WriteOptions options, ::grpc::Status s)=0
virtual ~ServerCallbackReaderWriter()
Definition: server_callback_impl.h:200
virtual void Finish(::grpc::Status s)=0
void BindReactor(ServerBidiReactor< Request, Response > *reactor)
Definition: server_callback_impl.h:210
Definition: server_callback_impl.h:151
virtual ~ServerCallbackUnary()
Definition: server_callback_impl.h:153
virtual void Finish(::grpc::Status s)=0
virtual void SendInitialMetadata()=0
void BindReactor(Reactor *reactor)
Definition: server_callback_impl.h:161
Definition: server_callback_impl.h:181
void BindReactor(ServerWriteReactor< Response > *reactor)
Definition: server_callback_impl.h:192
virtual void WriteAndFinish(const Response *msg, ::grpc::WriteOptions options, ::grpc::Status s)=0
virtual void SendInitialMetadata()=0
virtual ~ServerCallbackWriter()
Definition: server_callback_impl.h:183
virtual void Finish(::grpc::Status s)=0
virtual void Write(const Response *msg, ::grpc::WriteOptions options)=0
ServerReadReactor is the interface for a client-streaming RPC.
Definition: server_callback_impl.h:449
ServerReadReactor()
Definition: server_callback_impl.h:451
virtual void OnSendInitialMetadataDone(bool)
The following notifications are exactly like ServerBidiReactor.
Definition: server_callback_impl.h:497
void StartRead(Request *req)
Definition: server_callback_impl.h:468
void OnCancel() override
Definition: server_callback_impl.h:500
virtual void OnReadDone(bool)
Definition: server_callback_impl.h:498
void Finish(::grpc::Status s)
Definition: server_callback_impl.h:481
void StartSendInitialMetadata()
The following operation initiations are exactly like ServerBidiReactor.
Definition: server_callback_impl.h:455
void OnDone() override=0
Definition: server_callback_impl.h:660
ServerUnaryReactor()
Definition: server_callback_impl.h:662
void StartSendInitialMetadata()
The following operation initiations are exactly like ServerBidiReactor.
Definition: server_callback_impl.h:666
void Finish(::grpc::Status s)
Definition: server_callback_impl.h:678
virtual void OnSendInitialMetadataDone(bool)
The following notifications are exactly like ServerBidiReactor.
Definition: server_callback_impl.h:693
void OnCancel() override
Definition: server_callback_impl.h:695
ServerWriteReactor is the interface for a server-streaming RPC.
Definition: server_callback_impl.h:537
void StartWrite(const Response *resp, ::grpc::WriteOptions options)
Definition: server_callback_impl.h:559
void StartSendInitialMetadata()
The following operation initiations are exactly like ServerBidiReactor.
Definition: server_callback_impl.h:543
void OnCancel() override
Definition: server_callback_impl.h:612
void StartWriteLast(const Response *resp, ::grpc::WriteOptions options)
Definition: server_callback_impl.h:590
virtual void OnSendInitialMetadataDone(bool)
The following notifications are exactly like ServerBidiReactor.
Definition: server_callback_impl.h:609
ServerWriteReactor()
Definition: server_callback_impl.h:539
void StartWriteAndFinish(const Response *resp, ::grpc::WriteOptions options, ::grpc::Status s)
Definition: server_callback_impl.h:573
virtual void OnWriteDone(bool)
Definition: server_callback_impl.h:610
void Finish(::grpc::Status s)
Definition: server_callback_impl.h:593
void StartWrite(const Response *resp)
Definition: server_callback_impl.h:556
Definition: server_callback_handlers.h:607
Definition: server_callback_handlers.h:241
Definition: server_callback_handlers.h:404
Definition: server_callback_handlers.h:31
Definition: server_callback_impl.h:121
void Release() override
Definition: server_callback_impl.h:127
DefaultMessageHolder()
Definition: server_callback_impl.h:123
Definition: server_callback_impl.h:727
FinishOnlyReactor(::grpc::Status s)
Definition: server_callback_impl.h:729
void OnDone() override
Definition: server_callback_impl.h:730
The base class of ServerCallbackUnary etc.
Definition: server_callback_impl.h:72
int Unref()
Decreases the reference count and returns the previous value.
Definition: server_callback_impl.h:102
void MaybeCallOnCancel(ServerReactor *reactor)
Definition: server_callback_impl.h:84
void Ref()
Increases the reference count.
Definition: server_callback_impl.h:99
virtual ~ServerCallbackCall()
Definition: server_callback_impl.h:74
void MaybeCallOnCancel()
Definition: server_callback_impl.h:95
Definition: server_callback_impl.h:48
virtual bool InternalInlineable()
Definition: server_callback_impl.h:58
#define GPR_UNLIKELY(x)
Definition: port_platform.h:702
::grpc_impl::ServerReadReactor< Request > ServerReadReactor
Definition: server_callback.h:27
::grpc_impl::ServerWriteReactor< Response > ServerWriteReactor
Definition: server_callback.h:30
::grpc_impl::ServerBidiReactor< Request, Response > ServerBidiReactor
Definition: server_callback.h:33
::grpc_impl::ServerUnaryReactor ServerUnaryReactor
Definition: server_callback.h:35
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm_impl.h:33