GRPC C++  1.39.1
call_op_set.h
Go to the documentation of this file.
1 /*
2  *
3  * Copyright 2018 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_CALL_OP_SET_H
20 #define GRPCPP_IMPL_CODEGEN_CALL_OP_SET_H
21 
22 #include <cstring>
23 #include <map>
24 #include <memory>
25 
42 
43 namespace grpc {
44 
45 extern CoreCodegenInterface* g_core_codegen_interface;
46 
47 namespace internal {
48 class Call;
49 class CallHook;
50 
51 // TODO(yangg) if the map is changed before we send, the pointers will be a
52 // mess. Make sure it does not happen.
54  const std::multimap<std::string, std::string>& metadata,
55  size_t* metadata_count, const std::string& optional_error_details) {
56  *metadata_count = metadata.size() + (optional_error_details.empty() ? 0 : 1);
57  if (*metadata_count == 0) {
58  return nullptr;
59  }
60  grpc_metadata* metadata_array =
62  (*metadata_count) * sizeof(grpc_metadata)));
63  size_t i = 0;
64  for (auto iter = metadata.cbegin(); iter != metadata.cend(); ++iter, ++i) {
65  metadata_array[i].key = SliceReferencingString(iter->first);
66  metadata_array[i].value = SliceReferencingString(iter->second);
67  }
68  if (!optional_error_details.empty()) {
69  metadata_array[i].key =
72  metadata_array[i].value = SliceReferencingString(optional_error_details);
73  }
74  return metadata_array;
75 }
76 } // namespace internal
77 
79 class WriteOptions {
80  public:
81  WriteOptions() : flags_(0), last_message_(false) {}
82 
84  inline void Clear() { flags_ = 0; }
85 
87  inline uint32_t flags() const { return flags_; }
88 
93  SetBit(GRPC_WRITE_NO_COMPRESS);
94  return *this;
95  }
96 
101  ClearBit(GRPC_WRITE_NO_COMPRESS);
102  return *this;
103  }
104 
109  inline bool get_no_compression() const {
110  return GetBit(GRPC_WRITE_NO_COMPRESS);
111  }
112 
118  SetBit(GRPC_WRITE_BUFFER_HINT);
119  return *this;
120  }
121 
127  ClearBit(GRPC_WRITE_BUFFER_HINT);
128  return *this;
129  }
130 
135  inline bool get_buffer_hint() const { return GetBit(GRPC_WRITE_BUFFER_HINT); }
136 
140  SetBit(GRPC_WRITE_BUFFER_HINT);
141  return *this;
142  }
143 
145  ClearBit(GRPC_WRITE_BUFFER_HINT);
146  return *this;
147  }
148 
149  inline bool is_corked() const { return GetBit(GRPC_WRITE_BUFFER_HINT); }
150 
157  last_message_ = true;
158  return *this;
159  }
160 
164  last_message_ = false;
165  return *this;
166  }
167 
171  SetBit(GRPC_WRITE_THROUGH);
172  return *this;
173  }
174 
175  inline bool is_write_through() const { return GetBit(GRPC_WRITE_THROUGH); }
176 
181  bool is_last_message() const { return last_message_; }
182 
183  private:
184  void SetBit(const uint32_t mask) { flags_ |= mask; }
185 
186  void ClearBit(const uint32_t mask) { flags_ &= ~mask; }
187 
188  bool GetBit(const uint32_t mask) const { return (flags_ & mask) != 0; }
189 
190  uint32_t flags_;
191  bool last_message_;
192 };
193 
194 namespace internal {
195 
199 template <int Unused>
200 class CallNoOp {
201  protected:
202  void AddOp(grpc_op* /*ops*/, size_t* /*nops*/) {}
203  void FinishOp(bool* /*status*/) {}
205  InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
207  InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
208  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
209  }
210 };
211 
213  public:
215  maybe_compression_level_.is_set = false;
216  }
217 
218  void SendInitialMetadata(std::multimap<std::string, std::string>* metadata,
219  uint32_t flags) {
220  maybe_compression_level_.is_set = false;
221  send_ = true;
222  flags_ = flags;
223  metadata_map_ = metadata;
224  }
225 
227  maybe_compression_level_.is_set = true;
229  }
230 
231  protected:
232  void AddOp(grpc_op* ops, size_t* nops) {
233  if (!send_ || hijacked_) return;
234  grpc_op* op = &ops[(*nops)++];
236  op->flags = flags_;
237  op->reserved = nullptr;
244  if (maybe_compression_level_.is_set) {
247  }
248  }
249  void FinishOp(bool* /*status*/) {
250  if (!send_ || hijacked_) return;
252  send_ = false;
253  }
254 
256  InterceptorBatchMethodsImpl* interceptor_methods) {
257  if (!send_) return;
258  interceptor_methods->AddInterceptionHookPoint(
260  interceptor_methods->SetSendInitialMetadata(metadata_map_);
261  }
262 
264  InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
265 
266  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
267  hijacked_ = true;
268  }
269 
270  bool hijacked_ = false;
271  bool send_;
272  uint32_t flags_;
274  std::multimap<std::string, std::string>* metadata_map_;
276  struct {
277  bool is_set;
280 };
281 
283  public:
284  CallOpSendMessage() : send_buf_() {}
285 
288  template <class M>
289  Status SendMessage(const M& message,
291 
292  template <class M>
293  Status SendMessage(const M& message) GRPC_MUST_USE_RESULT;
294 
298  template <class M>
299  Status SendMessagePtr(const M* message,
301 
304  template <class M>
305  Status SendMessagePtr(const M* message) GRPC_MUST_USE_RESULT;
306 
307  protected:
308  void AddOp(grpc_op* ops, size_t* nops) {
309  if (msg_ == nullptr && !send_buf_.Valid()) return;
310  if (hijacked_) {
311  serializer_ = nullptr;
312  return;
313  }
314  if (msg_ != nullptr) {
315  GPR_CODEGEN_ASSERT(serializer_(msg_).ok());
316  }
317  serializer_ = nullptr;
318  grpc_op* op = &ops[(*nops)++];
319  op->op = GRPC_OP_SEND_MESSAGE;
320  op->flags = write_options_.flags();
321  op->reserved = nullptr;
322  op->data.send_message.send_message = send_buf_.c_buffer();
323  // Flags are per-message: clear them after use.
324  write_options_.Clear();
325  }
326  void FinishOp(bool* status) {
327  if (msg_ == nullptr && !send_buf_.Valid()) return;
328  send_buf_.Clear();
329  if (hijacked_ && failed_send_) {
330  // Hijacking interceptor failed this Op
331  *status = false;
332  } else if (!*status) {
333  // This Op was passed down to core and the Op failed
334  failed_send_ = true;
335  }
336  }
337 
339  InterceptorBatchMethodsImpl* interceptor_methods) {
340  if (msg_ == nullptr && !send_buf_.Valid()) return;
341  interceptor_methods->AddInterceptionHookPoint(
343  interceptor_methods->SetSendMessage(&send_buf_, &msg_, &failed_send_,
344  serializer_);
345  }
346 
348  InterceptorBatchMethodsImpl* interceptor_methods) {
349  if (msg_ != nullptr || send_buf_.Valid()) {
350  interceptor_methods->AddInterceptionHookPoint(
352  }
353  send_buf_.Clear();
354  msg_ = nullptr;
355  // The contents of the SendMessage value that was previously set
356  // has had its references stolen by core's operations
357  interceptor_methods->SetSendMessage(nullptr, nullptr, &failed_send_,
358  nullptr);
359  }
360 
361  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
362  hijacked_ = true;
363  }
364 
365  private:
366  const void* msg_ = nullptr; // The original non-serialized message
367  bool hijacked_ = false;
368  bool failed_send_ = false;
369  ByteBuffer send_buf_;
370  WriteOptions write_options_;
371  std::function<Status(const void*)> serializer_;
372 };
373 
374 template <class M>
376  write_options_ = options;
377  // Serialize immediately since we do not have access to the message pointer
378  bool own_buf;
379  // TODO(vjpai): Remove the void below when possible
380  // The void in the template parameter below should not be needed
381  // (since it should be implicit) but is needed due to an observed
382  // difference in behavior between clang and gcc for certain internal users
384  message, send_buf_.bbuf_ptr(), &own_buf);
385  if (!own_buf) {
386  send_buf_.Duplicate();
387  }
388  return result;
389 }
390 
391 template <class M>
393  return SendMessage(message, WriteOptions());
394 }
395 
396 template <class M>
398  WriteOptions options) {
399  msg_ = message;
400  write_options_ = options;
401  // Store the serializer for later since we have access to the message
402  serializer_ = [this](const void* message) {
403  bool own_buf;
404  // TODO(vjpai): Remove the void below when possible
405  // The void in the template parameter below should not be needed
406  // (since it should be implicit) but is needed due to an observed
407  // difference in behavior between clang and gcc for certain internal users
409  *static_cast<const M*>(message), send_buf_.bbuf_ptr(), &own_buf);
410  if (!own_buf) {
411  send_buf_.Duplicate();
412  }
413  return result;
414  };
415  return Status();
416 }
417 
418 template <class M>
420  return SendMessagePtr(message, WriteOptions());
421 }
422 
423 template <class R>
425  public:
426  void RecvMessage(R* message) { message_ = message; }
427 
428  // Do not change status if no message is received.
429  void AllowNoMessage() { allow_not_getting_message_ = true; }
430 
431  bool got_message = false;
432 
433  protected:
434  void AddOp(grpc_op* ops, size_t* nops) {
435  if (message_ == nullptr || hijacked_) return;
436  grpc_op* op = &ops[(*nops)++];
437  op->op = GRPC_OP_RECV_MESSAGE;
438  op->flags = 0;
439  op->reserved = nullptr;
440  op->data.recv_message.recv_message = recv_buf_.c_buffer_ptr();
441  }
442 
443  void FinishOp(bool* status) {
444  if (message_ == nullptr) return;
445  if (recv_buf_.Valid()) {
446  if (*status) {
447  got_message = *status =
448  SerializationTraits<R>::Deserialize(recv_buf_.bbuf_ptr(), message_)
449  .ok();
450  recv_buf_.Release();
451  } else {
452  got_message = false;
453  recv_buf_.Clear();
454  }
455  } else if (hijacked_) {
456  if (hijacked_recv_message_failed_) {
457  FinishOpRecvMessageFailureHandler(status);
458  } else {
459  // The op was hijacked and it was successful. There is no further action
460  // to be performed since the message is already in its non-serialized
461  // form.
462  }
463  } else {
464  FinishOpRecvMessageFailureHandler(status);
465  }
466  }
467 
469  InterceptorBatchMethodsImpl* interceptor_methods) {
470  if (message_ == nullptr) return;
471  interceptor_methods->SetRecvMessage(message_,
472  &hijacked_recv_message_failed_);
473  }
474 
476  InterceptorBatchMethodsImpl* interceptor_methods) {
477  if (message_ == nullptr) return;
478  interceptor_methods->AddInterceptionHookPoint(
480  if (!got_message) interceptor_methods->SetRecvMessage(nullptr, nullptr);
481  }
482  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
483  hijacked_ = true;
484  if (message_ == nullptr) return;
485  interceptor_methods->AddInterceptionHookPoint(
487  got_message = true;
488  }
489 
490  private:
491  // Sets got_message and \a status for a failed recv message op
492  void FinishOpRecvMessageFailureHandler(bool* status) {
493  got_message = false;
494  if (!allow_not_getting_message_) {
495  *status = false;
496  }
497  }
498 
499  R* message_ = nullptr;
500  ByteBuffer recv_buf_;
501  bool allow_not_getting_message_ = false;
502  bool hijacked_ = false;
503  bool hijacked_recv_message_failed_ = false;
504 };
505 
507  public:
508  virtual Status Deserialize(ByteBuffer* buf) = 0;
509  virtual ~DeserializeFunc() {}
510 };
511 
512 template <class R>
513 class DeserializeFuncType final : public DeserializeFunc {
514  public:
515  explicit DeserializeFuncType(R* message) : message_(message) {}
516  Status Deserialize(ByteBuffer* buf) override {
517  return SerializationTraits<R>::Deserialize(buf->bbuf_ptr(), message_);
518  }
519 
520  ~DeserializeFuncType() override {}
521 
522  private:
523  R* message_; // Not a managed pointer because management is external to this
524 };
525 
527  public:
528  template <class R>
529  void RecvMessage(R* message) {
530  // Use an explicit base class pointer to avoid resolution error in the
531  // following unique_ptr::reset for some old implementations.
532  DeserializeFunc* func = new DeserializeFuncType<R>(message);
533  deserialize_.reset(func);
534  message_ = message;
535  }
536 
537  // Do not change status if no message is received.
538  void AllowNoMessage() { allow_not_getting_message_ = true; }
539 
540  bool got_message = false;
541 
542  protected:
543  void AddOp(grpc_op* ops, size_t* nops) {
544  if (!deserialize_ || hijacked_) return;
545  grpc_op* op = &ops[(*nops)++];
546  op->op = GRPC_OP_RECV_MESSAGE;
547  op->flags = 0;
548  op->reserved = nullptr;
549  op->data.recv_message.recv_message = recv_buf_.c_buffer_ptr();
550  }
551 
552  void FinishOp(bool* status) {
553  if (!deserialize_) return;
554  if (recv_buf_.Valid()) {
555  if (*status) {
556  got_message = true;
557  *status = deserialize_->Deserialize(&recv_buf_).ok();
558  recv_buf_.Release();
559  } else {
560  got_message = false;
561  recv_buf_.Clear();
562  }
563  } else if (hijacked_) {
564  if (hijacked_recv_message_failed_) {
565  FinishOpRecvMessageFailureHandler(status);
566  } else {
567  // The op was hijacked and it was successful. There is no further action
568  // to be performed since the message is already in its non-serialized
569  // form.
570  }
571  } else {
572  got_message = false;
573  if (!allow_not_getting_message_) {
574  *status = false;
575  }
576  }
577  }
578 
580  InterceptorBatchMethodsImpl* interceptor_methods) {
581  if (!deserialize_) return;
582  interceptor_methods->SetRecvMessage(message_,
583  &hijacked_recv_message_failed_);
584  }
585 
587  InterceptorBatchMethodsImpl* interceptor_methods) {
588  if (!deserialize_) return;
589  interceptor_methods->AddInterceptionHookPoint(
591  if (!got_message) interceptor_methods->SetRecvMessage(nullptr, nullptr);
592  deserialize_.reset();
593  }
594  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
595  hijacked_ = true;
596  if (!deserialize_) return;
597  interceptor_methods->AddInterceptionHookPoint(
599  got_message = true;
600  }
601 
602  private:
603  // Sets got_message and \a status for a failed recv message op
604  void FinishOpRecvMessageFailureHandler(bool* status) {
605  got_message = false;
606  if (!allow_not_getting_message_) {
607  *status = false;
608  }
609  }
610 
611  void* message_ = nullptr;
612  std::unique_ptr<DeserializeFunc> deserialize_;
613  ByteBuffer recv_buf_;
614  bool allow_not_getting_message_ = false;
615  bool hijacked_ = false;
616  bool hijacked_recv_message_failed_ = false;
617 };
618 
620  public:
621  CallOpClientSendClose() : send_(false) {}
622 
623  void ClientSendClose() { send_ = true; }
624 
625  protected:
626  void AddOp(grpc_op* ops, size_t* nops) {
627  if (!send_ || hijacked_) return;
628  grpc_op* op = &ops[(*nops)++];
630  op->flags = 0;
631  op->reserved = nullptr;
632  }
633  void FinishOp(bool* /*status*/) { send_ = false; }
634 
636  InterceptorBatchMethodsImpl* interceptor_methods) {
637  if (!send_) return;
638  interceptor_methods->AddInterceptionHookPoint(
640  }
641 
643  InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
644 
645  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
646  hijacked_ = true;
647  }
648 
649  private:
650  bool hijacked_ = false;
651  bool send_;
652 };
653 
655  public:
656  CallOpServerSendStatus() : send_status_available_(false) {}
657 
659  std::multimap<std::string, std::string>* trailing_metadata,
660  const Status& status) {
661  send_error_details_ = status.error_details();
662  metadata_map_ = trailing_metadata;
663  send_status_available_ = true;
664  send_status_code_ = static_cast<grpc_status_code>(status.error_code());
665  send_error_message_ = status.error_message();
666  }
667 
668  protected:
669  void AddOp(grpc_op* ops, size_t* nops) {
670  if (!send_status_available_ || hijacked_) return;
671  trailing_metadata_ = FillMetadataArray(
672  *metadata_map_, &trailing_metadata_count_, send_error_details_);
673  grpc_op* op = &ops[(*nops)++];
676  trailing_metadata_count_;
677  op->data.send_status_from_server.trailing_metadata = trailing_metadata_;
678  op->data.send_status_from_server.status = send_status_code_;
679  error_message_slice_ = SliceReferencingString(send_error_message_);
681  send_error_message_.empty() ? nullptr : &error_message_slice_;
682  op->flags = 0;
683  op->reserved = nullptr;
684  }
685 
686  void FinishOp(bool* /*status*/) {
687  if (!send_status_available_ || hijacked_) return;
688  g_core_codegen_interface->gpr_free(trailing_metadata_);
689  send_status_available_ = false;
690  }
691 
693  InterceptorBatchMethodsImpl* interceptor_methods) {
694  if (!send_status_available_) return;
695  interceptor_methods->AddInterceptionHookPoint(
697  interceptor_methods->SetSendTrailingMetadata(metadata_map_);
698  interceptor_methods->SetSendStatus(&send_status_code_, &send_error_details_,
699  &send_error_message_);
700  }
701 
703  InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
704 
705  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
706  hijacked_ = true;
707  }
708 
709  private:
710  bool hijacked_ = false;
711  bool send_status_available_;
712  grpc_status_code send_status_code_;
713  std::string send_error_details_;
714  std::string send_error_message_;
715  size_t trailing_metadata_count_;
716  std::multimap<std::string, std::string>* metadata_map_;
717  grpc_metadata* trailing_metadata_;
718  grpc_slice error_message_slice_;
719 };
720 
722  public:
723  CallOpRecvInitialMetadata() : metadata_map_(nullptr) {}
724 
726  context->initial_metadata_received_ = true;
727  metadata_map_ = &context->recv_initial_metadata_;
728  }
729 
730  protected:
731  void AddOp(grpc_op* ops, size_t* nops) {
732  if (metadata_map_ == nullptr || hijacked_) return;
733  grpc_op* op = &ops[(*nops)++];
735  op->data.recv_initial_metadata.recv_initial_metadata = metadata_map_->arr();
736  op->flags = 0;
737  op->reserved = nullptr;
738  }
739 
740  void FinishOp(bool* /*status*/) {
741  if (metadata_map_ == nullptr || hijacked_) return;
742  }
743 
745  InterceptorBatchMethodsImpl* interceptor_methods) {
746  interceptor_methods->SetRecvInitialMetadata(metadata_map_);
747  }
748 
750  InterceptorBatchMethodsImpl* interceptor_methods) {
751  if (metadata_map_ == nullptr) return;
752  interceptor_methods->AddInterceptionHookPoint(
754  metadata_map_ = nullptr;
755  }
756 
757  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
758  hijacked_ = true;
759  if (metadata_map_ == nullptr) return;
760  interceptor_methods->AddInterceptionHookPoint(
762  }
763 
764  private:
765  bool hijacked_ = false;
766  MetadataMap* metadata_map_;
767 };
768 
770  public:
772  : recv_status_(nullptr), debug_error_string_(nullptr) {}
773 
774  void ClientRecvStatus(::grpc::ClientContext* context, Status* status) {
775  client_context_ = context;
776  metadata_map_ = &client_context_->trailing_metadata_;
777  recv_status_ = status;
778  error_message_ = g_core_codegen_interface->grpc_empty_slice();
779  }
780 
781  protected:
782  void AddOp(grpc_op* ops, size_t* nops) {
783  if (recv_status_ == nullptr || hijacked_) return;
784  grpc_op* op = &ops[(*nops)++];
786  op->data.recv_status_on_client.trailing_metadata = metadata_map_->arr();
787  op->data.recv_status_on_client.status = &status_code_;
788  op->data.recv_status_on_client.status_details = &error_message_;
789  op->data.recv_status_on_client.error_string = &debug_error_string_;
790  op->flags = 0;
791  op->reserved = nullptr;
792  }
793 
794  void FinishOp(bool* /*status*/) {
795  if (recv_status_ == nullptr || hijacked_) return;
796  if (static_cast<StatusCode>(status_code_) == StatusCode::OK) {
797  *recv_status_ = Status();
798  GPR_CODEGEN_DEBUG_ASSERT(debug_error_string_ == nullptr);
799  } else {
800  *recv_status_ =
801  Status(static_cast<StatusCode>(status_code_),
802  GRPC_SLICE_IS_EMPTY(error_message_)
803  ? std::string()
804  : std::string(GRPC_SLICE_START_PTR(error_message_),
805  GRPC_SLICE_END_PTR(error_message_)),
806  metadata_map_->GetBinaryErrorDetails());
807  if (debug_error_string_ != nullptr) {
808  client_context_->set_debug_error_string(debug_error_string_);
810  const_cast<char*>(debug_error_string_));
811  }
812  }
813  // TODO(soheil): Find callers that set debug string even for status OK,
814  // and fix them.
816  }
817 
819  InterceptorBatchMethodsImpl* interceptor_methods) {
820  interceptor_methods->SetRecvStatus(recv_status_);
821  interceptor_methods->SetRecvTrailingMetadata(metadata_map_);
822  }
823 
825  InterceptorBatchMethodsImpl* interceptor_methods) {
826  if (recv_status_ == nullptr) return;
827  interceptor_methods->AddInterceptionHookPoint(
829  recv_status_ = nullptr;
830  }
831 
832  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
833  hijacked_ = true;
834  if (recv_status_ == nullptr) return;
835  interceptor_methods->AddInterceptionHookPoint(
837  }
838 
839  private:
840  bool hijacked_ = false;
841  ::grpc::ClientContext* client_context_;
842  MetadataMap* metadata_map_;
843  Status* recv_status_;
844  const char* debug_error_string_;
845  grpc_status_code status_code_;
846  grpc_slice error_message_;
847 };
848 
849 template <class Op1 = CallNoOp<1>, class Op2 = CallNoOp<2>,
850  class Op3 = CallNoOp<3>, class Op4 = CallNoOp<4>,
851  class Op5 = CallNoOp<5>, class Op6 = CallNoOp<6>>
852 class CallOpSet;
853 
860 template <class Op1, class Op2, class Op3, class Op4, class Op5, class Op6>
862  public Op1,
863  public Op2,
864  public Op3,
865  public Op4,
866  public Op5,
867  public Op6 {
868  public:
869  CallOpSet() : core_cq_tag_(this), return_tag_(this) {}
870  // The copy constructor and assignment operator reset the value of
871  // core_cq_tag_, return_tag_, done_intercepting_ and interceptor_methods_
872  // since those are only meaningful on a specific object, not across objects.
873  CallOpSet(const CallOpSet& other)
874  : core_cq_tag_(this),
875  return_tag_(this),
876  call_(other.call_),
877  done_intercepting_(false),
878  interceptor_methods_(InterceptorBatchMethodsImpl()) {}
879 
880  CallOpSet& operator=(const CallOpSet& other) {
881  if (&other == this) {
882  return *this;
883  }
884  core_cq_tag_ = this;
885  return_tag_ = this;
886  call_ = other.call_;
887  done_intercepting_ = false;
888  interceptor_methods_ = InterceptorBatchMethodsImpl();
889  return *this;
890  }
891 
892  void FillOps(Call* call) override {
893  done_intercepting_ = false;
895  call_ =
896  *call; // It's fine to create a copy of call since it's just pointers
897 
898  if (RunInterceptors()) {
900  } else {
901  // After the interceptors are run, ContinueFillOpsAfterInterception will
902  // be run
903  }
904  }
905 
906  bool FinalizeResult(void** tag, bool* status) override {
907  if (done_intercepting_) {
908  // Complete the avalanching since we are done with this batch of ops
909  call_.cq()->CompleteAvalanching();
910  // We have already finished intercepting and filling in the results. This
911  // round trip from the core needed to be made because interceptors were
912  // run
913  *tag = return_tag_;
914  *status = saved_status_;
916  return true;
917  }
918 
919  this->Op1::FinishOp(status);
920  this->Op2::FinishOp(status);
921  this->Op3::FinishOp(status);
922  this->Op4::FinishOp(status);
923  this->Op5::FinishOp(status);
924  this->Op6::FinishOp(status);
925  saved_status_ = *status;
926  if (RunInterceptorsPostRecv()) {
927  *tag = return_tag_;
929  return true;
930  }
931  // Interceptors are going to be run, so we can't return the tag just yet.
932  // After the interceptors are run, ContinueFinalizeResultAfterInterception
933  return false;
934  }
935 
936  void set_output_tag(void* return_tag) { return_tag_ = return_tag; }
937 
938  void* core_cq_tag() override { return core_cq_tag_; }
939 
944  void set_core_cq_tag(void* core_cq_tag) { core_cq_tag_ = core_cq_tag; }
945 
946  // This will be called while interceptors are run if the RPC is a hijacked
947  // RPC. This should set hijacking state for each of the ops.
948  void SetHijackingState() override {
949  this->Op1::SetHijackingState(&interceptor_methods_);
950  this->Op2::SetHijackingState(&interceptor_methods_);
951  this->Op3::SetHijackingState(&interceptor_methods_);
952  this->Op4::SetHijackingState(&interceptor_methods_);
953  this->Op5::SetHijackingState(&interceptor_methods_);
954  this->Op6::SetHijackingState(&interceptor_methods_);
955  }
956 
957  // Should be called after interceptors are done running
959  static const size_t MAX_OPS = 6;
960  grpc_op ops[MAX_OPS];
961  size_t nops = 0;
962  this->Op1::AddOp(ops, &nops);
963  this->Op2::AddOp(ops, &nops);
964  this->Op3::AddOp(ops, &nops);
965  this->Op4::AddOp(ops, &nops);
966  this->Op5::AddOp(ops, &nops);
967  this->Op6::AddOp(ops, &nops);
968 
970  call_.call(), ops, nops, core_cq_tag(), nullptr);
971 
972  if (err != GRPC_CALL_OK) {
973  // A failure here indicates an API misuse; for example, doing a Write
974  // while another Write is already pending on the same RPC or invoking
975  // WritesDone multiple times
976  // gpr_log(GPR_ERROR, "API misuse of type %s observed",
977  // g_core_codegen_interface->grpc_call_error_to_string(err));
978  GPR_CODEGEN_ASSERT(false);
979  }
980  }
981 
982  // Should be called after interceptors are done running on the finalize result
983  // path
985  done_intercepting_ = true;
986  // The following call_start_batch is internally-generated so no need for an
987  // explanatory log on failure.
989  call_.call(), nullptr, 0, core_cq_tag(), nullptr) ==
990  GRPC_CALL_OK);
991  }
992 
993  private:
994  // Returns true if no interceptors need to be run
995  bool RunInterceptors() {
996  interceptor_methods_.ClearState();
997  interceptor_methods_.SetCallOpSetInterface(this);
998  interceptor_methods_.SetCall(&call_);
999  this->Op1::SetInterceptionHookPoint(&interceptor_methods_);
1000  this->Op2::SetInterceptionHookPoint(&interceptor_methods_);
1001  this->Op3::SetInterceptionHookPoint(&interceptor_methods_);
1002  this->Op4::SetInterceptionHookPoint(&interceptor_methods_);
1003  this->Op5::SetInterceptionHookPoint(&interceptor_methods_);
1004  this->Op6::SetInterceptionHookPoint(&interceptor_methods_);
1005  if (interceptor_methods_.InterceptorsListEmpty()) {
1006  return true;
1007  }
1008  // This call will go through interceptors and would need to
1009  // schedule new batches, so delay completion queue shutdown
1010  call_.cq()->RegisterAvalanching();
1011  return interceptor_methods_.RunInterceptors();
1012  }
1013  // Returns true if no interceptors need to be run
1014  bool RunInterceptorsPostRecv() {
1015  // Call and OpSet had already been set on the set state.
1016  // SetReverse also clears previously set hook points
1017  interceptor_methods_.SetReverse();
1018  this->Op1::SetFinishInterceptionHookPoint(&interceptor_methods_);
1019  this->Op2::SetFinishInterceptionHookPoint(&interceptor_methods_);
1020  this->Op3::SetFinishInterceptionHookPoint(&interceptor_methods_);
1021  this->Op4::SetFinishInterceptionHookPoint(&interceptor_methods_);
1022  this->Op5::SetFinishInterceptionHookPoint(&interceptor_methods_);
1023  this->Op6::SetFinishInterceptionHookPoint(&interceptor_methods_);
1024  return interceptor_methods_.RunInterceptors();
1025  }
1026 
1027  void* core_cq_tag_;
1028  void* return_tag_;
1029  Call call_;
1030  bool done_intercepting_ = false;
1031  InterceptorBatchMethodsImpl interceptor_methods_;
1032  bool saved_status_;
1033 };
1034 
1035 } // namespace internal
1036 } // namespace grpc
1037 
1038 #endif // GRPCPP_IMPL_CODEGEN_CALL_OP_SET_H
A sequence of bytes.
Definition: byte_buffer.h:60
void Clear()
Remove all data.
Definition: byte_buffer.h:128
void Duplicate()
Make a duplicate copy of the internals of this byte buffer so that we have our own owned version of i...
Definition: byte_buffer.h:140
void Release()
Forget underlying byte buffer without destroying Use this only for un-owned byte buffers.
Definition: byte_buffer.h:146
bool Valid() const
Is this ByteBuffer valid?
Definition: byte_buffer.h:163
A ClientContext allows the person implementing a service client to:
Definition: client_context.h:193
virtual void grpc_call_unref(grpc_call *call)=0
virtual grpc_slice grpc_empty_slice()=0
virtual void grpc_slice_unref(grpc_slice slice)=0
virtual void grpc_call_ref(grpc_call *call)=0
virtual void gpr_free(void *p)=0
virtual grpc_slice grpc_slice_from_static_buffer(const void *buffer, size_t length)=0
virtual void * gpr_malloc(size_t size)=0
virtual grpc_call_error grpc_call_start_batch(grpc_call *call, const grpc_op *ops, size_t nops, void *tag, void *reserved)=0
Defines how to serialize and deserialize some type.
Definition: serialization_traits.h:58
Did it work? If it didn't, why?
Definition: status.h:31
std::string error_message() const
Return the instance's error message.
Definition: status.h:112
StatusCode error_code() const
Return the instance's error code.
Definition: status.h:110
std::string error_details() const
Return the (binary) error details.
Definition: status.h:115
Per-message write options.
Definition: call_op_set.h:79
bool get_no_compression() const
Get value for the flag indicating whether compression for the next message write is forcefully disabl...
Definition: call_op_set.h:109
bool is_write_through() const
Definition: call_op_set.h:175
bool is_corked() const
Definition: call_op_set.h:149
bool get_buffer_hint() const
Get value for the flag indicating that the write may be buffered and need not go out on the wire imme...
Definition: call_op_set.h:135
WriteOptions()
Definition: call_op_set.h:81
WriteOptions & clear_no_compression()
Clears flag for the disabling of compression for the next message write.
Definition: call_op_set.h:100
bool is_last_message() const
Get value for the flag indicating that this is the last message, and should be coalesced with trailin...
Definition: call_op_set.h:181
WriteOptions & clear_buffer_hint()
Clears flag indicating that the write may be buffered and need not go out on the wire immediately.
Definition: call_op_set.h:126
void Clear()
Clear all flags.
Definition: call_op_set.h:84
WriteOptions & clear_last_message()
Clears flag indicating that this is the last message in a stream, disabling coalescing.
Definition: call_op_set.h:163
WriteOptions & set_write_through()
Guarantee that all bytes have been written to the socket before completing this write (usually writes...
Definition: call_op_set.h:170
WriteOptions & clear_corked()
Definition: call_op_set.h:144
uint32_t flags() const
Returns raw flags bitset.
Definition: call_op_set.h:87
WriteOptions & set_corked()
corked bit: aliases set_buffer_hint currently, with the intent that set_buffer_hint will be removed i...
Definition: call_op_set.h:139
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:156
WriteOptions & set_buffer_hint()
Sets flag indicating that the write may be buffered and need not go out on the wire immediately.
Definition: call_op_set.h:117
WriteOptions & set_no_compression()
Sets flag for the disabling of compression for the next message write.
Definition: call_op_set.h:92
Straightforward wrapping of the C call object.
Definition: call.h:35
grpc_call * call() const
Definition: call.h:69
::grpc::CompletionQueue * cq() const
Definition: call.h:70
Default argument for CallOpSet.
Definition: call_op_set.h:200
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:208
void FinishOp(bool *)
Definition: call_op_set.h:203
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:206
void AddOp(grpc_op *, size_t *)
Definition: call_op_set.h:202
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:204
Definition: call_op_set.h:769
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:818
void FinishOp(bool *)
Definition: call_op_set.h:794
CallOpClientRecvStatus()
Definition: call_op_set.h:771
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:824
void ClientRecvStatus(::grpc::ClientContext *context, Status *status)
Definition: call_op_set.h:774
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:782
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:832
Definition: call_op_set.h:619
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:645
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:626
CallOpClientSendClose()
Definition: call_op_set.h:621
void ClientSendClose()
Definition: call_op_set.h:623
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:635
void FinishOp(bool *)
Definition: call_op_set.h:633
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:642
Definition: call_op_set.h:526
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:594
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:586
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:543
bool got_message
Definition: call_op_set.h:540
void FinishOp(bool *status)
Definition: call_op_set.h:552
void RecvMessage(R *message)
Definition: call_op_set.h:529
void AllowNoMessage()
Definition: call_op_set.h:538
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:579
Definition: call_op_set.h:721
CallOpRecvInitialMetadata()
Definition: call_op_set.h:723
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:731
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:749
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:757
void FinishOp(bool *)
Definition: call_op_set.h:740
void RecvInitialMetadata(::grpc::ClientContext *context)
Definition: call_op_set.h:725
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:744
Definition: call_op_set.h:424
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:482
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:468
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:434
void RecvMessage(R *message)
Definition: call_op_set.h:426
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:475
bool got_message
Definition: call_op_set.h:431
void FinishOp(bool *status)
Definition: call_op_set.h:443
void AllowNoMessage()
Definition: call_op_set.h:429
Definition: call_op_set.h:212
grpc_compression_level level
Definition: call_op_set.h:278
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:263
bool send_
Definition: call_op_set.h:271
size_t initial_metadata_count_
Definition: call_op_set.h:273
CallOpSendInitialMetadata()
Definition: call_op_set.h:214
void set_compression_level(grpc_compression_level level)
Definition: call_op_set.h:226
struct grpc::internal::CallOpSendInitialMetadata::@3 maybe_compression_level_
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:266
bool is_set
Definition: call_op_set.h:277
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:232
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:255
grpc_metadata * initial_metadata_
Definition: call_op_set.h:275
uint32_t flags_
Definition: call_op_set.h:272
void SendInitialMetadata(std::multimap< std::string, std::string > *metadata, uint32_t flags)
Definition: call_op_set.h:218
void FinishOp(bool *)
Definition: call_op_set.h:249
std::multimap< std::string, std::string > * metadata_map_
Definition: call_op_set.h:274
bool hijacked_
Definition: call_op_set.h:270
Definition: call_op_set.h:282
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:347
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:361
Status SendMessagePtr(const M *message, WriteOptions options) GRPC_MUST_USE_RESULT
Send message using options for the write.
Definition: call_op_set.h:397
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:308
void FinishOp(bool *status)
Definition: call_op_set.h:326
CallOpSendMessage()
Definition: call_op_set.h:284
Status SendMessage(const M &message, WriteOptions options) GRPC_MUST_USE_RESULT
Send message using options for the write.
Definition: call_op_set.h:375
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:338
Definition: call_op_set.h:654
void ServerSendStatus(std::multimap< std::string, std::string > *trailing_metadata, const Status &status)
Definition: call_op_set.h:658
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:702
void FinishOp(bool *)
Definition: call_op_set.h:686
CallOpServerSendStatus()
Definition: call_op_set.h:656
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:669
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:692
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:705
Primary implementation of CallOpSetInterface.
Definition: call_op_set.h:867
CallOpSet(const CallOpSet &other)
Definition: call_op_set.h:873
bool FinalizeResult(void **tag, bool *status) override
FinalizeResult must be called before informing user code that the operation bound to the underlying c...
Definition: call_op_set.h:906
void ContinueFinalizeResultAfterInterception() override
Definition: call_op_set.h:984
CallOpSet & operator=(const CallOpSet &other)
Definition: call_op_set.h:880
void * core_cq_tag() override
Get the tag to be used at the core completion queue.
Definition: call_op_set.h:938
void set_core_cq_tag(void *core_cq_tag)
set_core_cq_tag is used to provide a different core CQ tag than "this".
Definition: call_op_set.h:944
void set_output_tag(void *return_tag)
Definition: call_op_set.h:936
CallOpSet()
Definition: call_op_set.h:869
void ContinueFillOpsAfterInterception() override
Definition: call_op_set.h:958
void FillOps(Call *call) override
Fills in grpc_op, starting from ops[*nops] and moving upwards.
Definition: call_op_set.h:892
void SetHijackingState() override
Definition: call_op_set.h:948
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: call_op_set.h:506
virtual ~DeserializeFunc()
Definition: call_op_set.h:509
virtual Status Deserialize(ByteBuffer *buf)=0
Definition: call_op_set.h:513
~DeserializeFuncType() override
Definition: call_op_set.h:520
Status Deserialize(ByteBuffer *buf) override
Definition: call_op_set.h:516
DeserializeFuncType(R *message)
Definition: call_op_set.h:515
Definition: interceptor_common.h:37
bool RunInterceptors()
Definition: interceptor_common.h:238
void SetCallOpSetInterface(CallOpSetInterface *ops)
Definition: interceptor_common.h:219
void SetRecvTrailingMetadata(MetadataMap *map)
Definition: interceptor_common.h:179
void ClearState()
Definition: interceptor_common.h:201
void SetSendTrailingMetadata(std::multimap< std::string, std::string > *metadata)
Definition: interceptor_common.h:163
void SetReverse()
Definition: interceptor_common.h:208
void SetSendMessage(ByteBuffer *buf, const void **msg, bool *fail_send_message, std::function< Status(const void *)> serializer)
Definition: interceptor_common.h:142
void SetRecvInitialMetadata(MetadataMap *map)
Definition: interceptor_common.h:173
void SetSendStatus(grpc_status_code *code, std::string *error_details, std::string *error_message)
Definition: interceptor_common.h:156
void AddInterceptionHookPoint(experimental::InterceptionHookPoints type)
Definition: interceptor_common.h:78
bool InterceptorsListEmpty()
Definition: interceptor_common.h:223
void SetCall(Call *call)
Definition: interceptor_common.h:215
void SetRecvMessage(void *message, bool *hijacked_recv_message_failed)
Definition: interceptor_common.h:168
void SetRecvStatus(Status *status)
Definition: interceptor_common.h:177
void SetSendInitialMetadata(std::multimap< std::string, std::string > *metadata)
Definition: interceptor_common.h:151
Definition: metadata_map.h:33
grpc_metadata_array * arr()
Definition: metadata_map.h:70
std::string GetBinaryErrorDetails()
Definition: metadata_map.h:39
grpc_compression_level
Compression levels allow a party with knowledge of its peer's accepted encodings to request compressi...
Definition: compression_types.h:71
#define GRPC_SLICE_IS_EMPTY(slice)
Definition: slice.h:107
#define GRPC_SLICE_START_PTR(slice)
Definition: slice.h:96
#define GRPC_SLICE_END_PTR(slice)
Definition: slice.h:105
grpc_status_code
Definition: status.h:26
grpc_call_error
Result of a grpc call.
Definition: grpc_types.h:441
@ GRPC_CALL_OK
everything went ok
Definition: grpc_types.h:443
struct grpc_metadata grpc_metadata
A single metadata element.
@ GRPC_OP_SEND_STATUS_FROM_SERVER
Send status from the server: one and only one instance MUST be sent from the server unless the call w...
Definition: grpc_types.h:596
@ GRPC_OP_RECV_STATUS_ON_CLIENT
Receive status on the client: one and only one must be made on the client.
Definition: grpc_types.h:611
@ GRPC_OP_SEND_CLOSE_FROM_CLIENT
Send a close from the client: one and only one instance MUST be sent from the client,...
Definition: grpc_types.h:591
@ GRPC_OP_SEND_MESSAGE
Send a message: 0 or more of these operations can occur for each call.
Definition: grpc_types.h:586
@ GRPC_OP_RECV_INITIAL_METADATA
Receive initial metadata: one and only one MUST be made on the client, must not be made on the server...
Definition: grpc_types.h:601
@ GRPC_OP_SEND_INITIAL_METADATA
Send initial metadata: one and only one instance MUST be sent for each call, unless the call was canc...
Definition: grpc_types.h:582
@ GRPC_OP_RECV_MESSAGE
Receive a message: 0 or more of these operations can occur for each call.
Definition: grpc_types.h:605
#define GRPC_WRITE_THROUGH
Force this message to be written to the socket before completing it.
Definition: grpc_types.h:492
#define GRPC_WRITE_BUFFER_HINT
Write Flags:
Definition: grpc_types.h:487
#define GRPC_WRITE_NO_COMPRESS
Force compression to be disabled for a particular write (start_write/add_metadata).
Definition: grpc_types.h:490
#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
#define GRPC_MUST_USE_RESULT
Definition: port_platform.h:524
@ POST_RECV_INITIAL_METADATA
The following two are for all clients and servers.
@ PRE_SEND_INITIAL_METADATA
The first three in this list are for clients and servers.
@ PRE_RECV_INITIAL_METADATA
The following three are for hijacked clients only.
const char kBinaryErrorDetailsKey[]
Definition: metadata_map.h:31
grpc_metadata * FillMetadataArray(const std::multimap< std::string, std::string > &metadata, size_t *metadata_count, const std::string &optional_error_details)
Definition: call_op_set.h:53
::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
grpc_slice SliceReferencingString(const std::string &str)
Definition: slice.h:143
CoreCodegenInterface * g_core_codegen_interface
Null-initializes the global gRPC variables for the codegen library.
Definition: completion_queue.h:96
StatusCode
Definition: status_code_enum.h:24
@ OK
Not an error; returned on success.
Definition: status_code_enum.h:26
A single metadata element.
Definition: grpc_types.h:519
grpc_slice key
the key, value values are expected to line up with grpc_mdelem: if changing them, update metadata....
Definition: grpc_types.h:522
grpc_slice value
Definition: grpc_types.h:523
grpc_metadata_array * recv_initial_metadata
Definition: grpc_types.h:669
struct grpc_byte_buffer ** recv_message
Definition: grpc_types.h:677
grpc_status_code * status
Definition: grpc_types.h:686
const char ** error_string
If this is not nullptr, it will be populated with the full fidelity error string for debugging purpos...
Definition: grpc_types.h:691
grpc_slice * status_details
Definition: grpc_types.h:687
grpc_metadata_array * trailing_metadata
ownership of the array is with the caller, but ownership of the elements stays with the call object (...
Definition: grpc_types.h:685
struct grpc_op::grpc_op_data::grpc_op_send_initial_metadata::grpc_op_send_initial_metadata_maybe_compression_level maybe_compression_level
grpc_metadata * metadata
Definition: grpc_types.h:638
size_t count
Definition: grpc_types.h:637
struct grpc_byte_buffer * send_message
This op takes ownership of the slices in send_message.
Definition: grpc_types.h:652
grpc_metadata * trailing_metadata
Definition: grpc_types.h:656
grpc_slice * status_details
optional: set to NULL if no details need sending, non-NULL if they do pointer will not be retained pa...
Definition: grpc_types.h:661
size_t trailing_metadata_count
Definition: grpc_types.h:655
grpc_status_code status
Definition: grpc_types.h:657
Operation data: one field for each op type (except SEND_CLOSE_FROM_CLIENT which has no arguments)
Definition: grpc_types.h:624
union grpc_op::grpc_op_data data
void * reserved
Reserved for future usage.
Definition: grpc_types.h:630
uint32_t flags
Write flags bitset for grpc_begin_messages.
Definition: grpc_types.h:628
grpc_op_type op
Operation type, as defined by grpc_op_type.
Definition: grpc_types.h:626
A grpc_slice s, if initialized, represents the byte range s.bytes[0..s.length-1].
Definition: slice.h:60
struct grpc_op::grpc_op_data::grpc_op_recv_message recv_message
struct grpc_op::grpc_op_data::grpc_op_recv_initial_metadata recv_initial_metadata
struct grpc_op::grpc_op_data::grpc_op_send_initial_metadata send_initial_metadata
struct grpc_op::grpc_op_data::grpc_op_send_message send_message
struct grpc_op::grpc_op_data::grpc_op_recv_status_on_client recv_status_on_client
struct grpc_op::grpc_op_data::grpc_op_send_status_from_server send_status_from_server