GRPC C++  1.62.0
interceptor_common.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_INTERCEPTOR_COMMON_H
20 #define GRPCPP_IMPL_INTERCEPTOR_COMMON_H
21 
22 #include <array>
23 #include <functional>
24 
25 #include <grpc/impl/grpc_types.h>
26 #include <grpc/support/log.h>
27 #include <grpcpp/impl/call.h>
32 
33 namespace grpc {
34 namespace internal {
35 
38  public:
40  for (auto i = static_cast<experimental::InterceptionHookPoints>(0);
42  i = static_cast<experimental::InterceptionHookPoints>(
43  static_cast<size_t>(i) + 1)) {
44  hooks_[static_cast<size_t>(i)] = false;
45  }
46  }
47 
49 
52  return hooks_[static_cast<size_t>(type)];
53  }
54 
55  void Proceed() override {
56  if (call_->client_rpc_info() != nullptr) {
57  return ProceedClient();
58  }
59  GPR_ASSERT(call_->server_rpc_info() != nullptr);
60  ProceedServer();
61  }
62 
63  void Hijack() override {
64  // Only the client can hijack when sending down initial metadata
65  GPR_ASSERT(!reverse_ && ops_ != nullptr &&
66  call_->client_rpc_info() != nullptr);
67  // It is illegal to call Hijack twice
68  GPR_ASSERT(!ran_hijacking_interceptor_);
69  auto* rpc_info = call_->client_rpc_info();
70  rpc_info->hijacked_ = true;
71  rpc_info->hijacked_interceptor_ = current_interceptor_index_;
72  ClearHookPoints();
73  ops_->SetHijackingState();
74  ran_hijacking_interceptor_ = true;
75  rpc_info->RunInterceptor(this, current_interceptor_index_);
76  }
77 
79  hooks_[static_cast<size_t>(type)] = true;
80  }
81 
83  GPR_ASSERT(orig_send_message_ != nullptr);
84  if (*orig_send_message_ != nullptr) {
85  GPR_ASSERT(serializer_(*orig_send_message_).ok());
86  *orig_send_message_ = nullptr;
87  }
88  return send_message_;
89  }
90 
91  const void* GetSendMessage() override {
92  GPR_ASSERT(orig_send_message_ != nullptr);
93  return *orig_send_message_;
94  }
95 
96  void ModifySendMessage(const void* message) override {
97  GPR_ASSERT(orig_send_message_ != nullptr);
98  *orig_send_message_ = message;
99  }
100 
101  bool GetSendMessageStatus() override { return !*fail_send_message_; }
102 
103  std::multimap<std::string, std::string>* GetSendInitialMetadata() override {
104  return send_initial_metadata_;
105  }
106 
107  Status GetSendStatus() override {
108  return Status(static_cast<StatusCode>(*code_), *error_message_,
109  *error_details_);
110  }
111 
112  void ModifySendStatus(const Status& status) override {
113  *code_ = static_cast<grpc_status_code>(status.error_code());
114  *error_details_ = status.error_details();
115  *error_message_ = status.error_message();
116  }
117 
118  std::multimap<std::string, std::string>* GetSendTrailingMetadata() override {
119  return send_trailing_metadata_;
120  }
121 
122  void* GetRecvMessage() override { return recv_message_; }
123 
124  std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvInitialMetadata()
125  override {
126  return recv_initial_metadata_->map();
127  }
128 
129  Status* GetRecvStatus() override { return recv_status_; }
130 
131  void FailHijackedSendMessage() override {
132  GPR_ASSERT(hooks_[static_cast<size_t>(
134  *fail_send_message_ = true;
135  }
136 
137  std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvTrailingMetadata()
138  override {
139  return recv_trailing_metadata_->map();
140  }
141 
142  void SetSendMessage(ByteBuffer* buf, const void** msg,
143  bool* fail_send_message,
144  std::function<Status(const void*)> serializer) {
145  send_message_ = buf;
146  orig_send_message_ = msg;
147  fail_send_message_ = fail_send_message;
148  serializer_ = serializer;
149  }
150 
152  std::multimap<std::string, std::string>* metadata) {
153  send_initial_metadata_ = metadata;
154  }
155 
156  void SetSendStatus(grpc_status_code* code, std::string* error_details,
157  std::string* error_message) {
158  code_ = code;
159  error_details_ = error_details;
160  error_message_ = error_message;
161  }
162 
164  std::multimap<std::string, std::string>* metadata) {
165  send_trailing_metadata_ = metadata;
166  }
167 
168  void SetRecvMessage(void* message, bool* hijacked_recv_message_failed) {
169  recv_message_ = message;
170  hijacked_recv_message_failed_ = hijacked_recv_message_failed;
171  }
172 
174  recv_initial_metadata_ = map;
175  }
176 
177  void SetRecvStatus(Status* status) { recv_status_ = status; }
178 
180  recv_trailing_metadata_ = map;
181  }
182 
183  std::unique_ptr<ChannelInterface> GetInterceptedChannel() override {
184  auto* info = call_->client_rpc_info();
185  if (info == nullptr) {
186  return std::unique_ptr<ChannelInterface>(nullptr);
187  }
188  // The intercepted channel starts from the interceptor just after the
189  // current interceptor
190  return std::unique_ptr<ChannelInterface>(new InterceptedChannel(
191  info->channel(), current_interceptor_index_ + 1));
192  }
193 
194  void FailHijackedRecvMessage() override {
195  GPR_ASSERT(hooks_[static_cast<size_t>(
197  *hijacked_recv_message_failed_ = true;
198  }
199 
200  // Clears all state
201  void ClearState() {
202  reverse_ = false;
203  ran_hijacking_interceptor_ = false;
204  ClearHookPoints();
205  }
206 
207  // Prepares for Post_recv operations
208  void SetReverse() {
209  reverse_ = true;
210  ran_hijacking_interceptor_ = false;
211  ClearHookPoints();
212  }
213 
214  // This needs to be set before interceptors are run
215  void SetCall(Call* call) { call_ = call; }
216 
217  // This needs to be set before interceptors are run using RunInterceptors().
218  // Alternatively, RunInterceptors(std::function<void(void)> f) can be used.
219  void SetCallOpSetInterface(CallOpSetInterface* ops) { ops_ = ops; }
220 
221  // SetCall should have been called before this.
222  // Returns true if the interceptors list is empty
224  auto* client_rpc_info = call_->client_rpc_info();
225  if (client_rpc_info != nullptr) {
226  return client_rpc_info->interceptors_.empty();
227  }
228 
229  auto* server_rpc_info = call_->server_rpc_info();
230  return server_rpc_info == nullptr || server_rpc_info->interceptors_.empty();
231  }
232 
233  // This should be used only by subclasses of CallOpSetInterface. SetCall and
234  // SetCallOpSetInterface should have been called before this. After all the
235  // interceptors are done running, either ContinueFillOpsAfterInterception or
236  // ContinueFinalizeOpsAfterInterception will be called. Note that neither of
237  // them is invoked if there were no interceptors registered.
239  GPR_ASSERT(ops_);
240  auto* client_rpc_info = call_->client_rpc_info();
241  if (client_rpc_info != nullptr) {
242  if (client_rpc_info->interceptors_.empty()) {
243  return true;
244  } else {
245  RunClientInterceptors();
246  return false;
247  }
248  }
249 
250  auto* server_rpc_info = call_->server_rpc_info();
251  if (server_rpc_info == nullptr || server_rpc_info->interceptors_.empty()) {
252  return true;
253  }
254  RunServerInterceptors();
255  return false;
256  }
257 
258  // Returns true if no interceptors are run. Returns false otherwise if there
259  // are interceptors registered. After the interceptors are done running \a f
260  // will be invoked. This is to be used only by BaseAsyncRequest and
261  // SyncRequest.
262  bool RunInterceptors(std::function<void(void)> f) {
263  // This is used only by the server for initial call request
264  GPR_ASSERT(reverse_ == true);
265  GPR_ASSERT(call_->client_rpc_info() == nullptr);
266  auto* server_rpc_info = call_->server_rpc_info();
267  if (server_rpc_info == nullptr || server_rpc_info->interceptors_.empty()) {
268  return true;
269  }
270  callback_ = std::move(f);
271  RunServerInterceptors();
272  return false;
273  }
274 
275  private:
276  void RunClientInterceptors() {
277  auto* rpc_info = call_->client_rpc_info();
278  if (!reverse_) {
279  current_interceptor_index_ = 0;
280  } else {
281  if (rpc_info->hijacked_) {
282  current_interceptor_index_ = rpc_info->hijacked_interceptor_;
283  } else {
284  current_interceptor_index_ = rpc_info->interceptors_.size() - 1;
285  }
286  }
287  rpc_info->RunInterceptor(this, current_interceptor_index_);
288  }
289 
290  void RunServerInterceptors() {
291  auto* rpc_info = call_->server_rpc_info();
292  if (!reverse_) {
293  current_interceptor_index_ = 0;
294  } else {
295  current_interceptor_index_ = rpc_info->interceptors_.size() - 1;
296  }
297  rpc_info->RunInterceptor(this, current_interceptor_index_);
298  }
299 
300  void ProceedClient() {
301  auto* rpc_info = call_->client_rpc_info();
302  if (rpc_info->hijacked_ && !reverse_ &&
303  current_interceptor_index_ == rpc_info->hijacked_interceptor_ &&
304  !ran_hijacking_interceptor_) {
305  // We now need to provide hijacked recv ops to this interceptor
306  ClearHookPoints();
307  ops_->SetHijackingState();
308  ran_hijacking_interceptor_ = true;
309  rpc_info->RunInterceptor(this, current_interceptor_index_);
310  return;
311  }
312  if (!reverse_) {
313  current_interceptor_index_++;
314  // We are going down the stack of interceptors
315  if (current_interceptor_index_ < rpc_info->interceptors_.size()) {
316  if (rpc_info->hijacked_ &&
317  current_interceptor_index_ > rpc_info->hijacked_interceptor_) {
318  // This is a hijacked RPC and we are done with hijacking
320  } else {
321  rpc_info->RunInterceptor(this, current_interceptor_index_);
322  }
323  } else {
324  // we are done running all the interceptors without any hijacking
326  }
327  } else {
328  // We are going up the stack of interceptors
329  if (current_interceptor_index_ > 0) {
330  // Continue running interceptors
331  current_interceptor_index_--;
332  rpc_info->RunInterceptor(this, current_interceptor_index_);
333  } else {
334  // we are done running all the interceptors without any hijacking
336  }
337  }
338  }
339 
340  void ProceedServer() {
341  auto* rpc_info = call_->server_rpc_info();
342  if (!reverse_) {
343  current_interceptor_index_++;
344  if (current_interceptor_index_ < rpc_info->interceptors_.size()) {
345  return rpc_info->RunInterceptor(this, current_interceptor_index_);
346  } else if (ops_) {
347  return ops_->ContinueFillOpsAfterInterception();
348  }
349  } else {
350  // We are going up the stack of interceptors
351  if (current_interceptor_index_ > 0) {
352  // Continue running interceptors
353  current_interceptor_index_--;
354  return rpc_info->RunInterceptor(this, current_interceptor_index_);
355  } else if (ops_) {
357  }
358  }
359  GPR_ASSERT(callback_);
360  callback_();
361  }
362 
363  void ClearHookPoints() {
364  for (auto i = static_cast<experimental::InterceptionHookPoints>(0);
366  i = static_cast<experimental::InterceptionHookPoints>(
367  static_cast<size_t>(i) + 1)) {
368  hooks_[static_cast<size_t>(i)] = false;
369  }
370  }
371 
372  std::array<bool,
373  static_cast<size_t>(
375  hooks_;
376 
377  size_t current_interceptor_index_ = 0; // Current iterator
378  bool reverse_ = false;
379  bool ran_hijacking_interceptor_ = false;
380  Call* call_ = nullptr; // The Call object is present along with CallOpSet
381  // object/callback
382  CallOpSetInterface* ops_ = nullptr;
383  std::function<void(void)> callback_;
384 
385  ByteBuffer* send_message_ = nullptr;
386  bool* fail_send_message_ = nullptr;
387  const void** orig_send_message_ = nullptr;
388  std::function<Status(const void*)> serializer_;
389 
390  std::multimap<std::string, std::string>* send_initial_metadata_;
391 
392  grpc_status_code* code_ = nullptr;
393  std::string* error_details_ = nullptr;
394  std::string* error_message_ = nullptr;
395 
396  std::multimap<std::string, std::string>* send_trailing_metadata_ = nullptr;
397 
398  void* recv_message_ = nullptr;
399  bool* hijacked_recv_message_failed_ = nullptr;
400 
401  MetadataMap* recv_initial_metadata_ = nullptr;
402 
403  Status* recv_status_ = nullptr;
404 
405  MetadataMap* recv_trailing_metadata_ = nullptr;
406 };
407 
408 // A special implementation of InterceptorBatchMethods to send a Cancel
409 // notification down the interceptor stack
412  public:
414  experimental::InterceptionHookPoints type) override {
416  }
417 
418  void Proceed() override {
419  // This is a no-op. For actual continuation of the RPC simply needs to
420  // return from the Intercept method
421  }
422 
423  void Hijack() override {
424  // Only the client can hijack when sending down initial metadata
425  GPR_ASSERT(false &&
426  "It is illegal to call Hijack on a method which has a "
427  "Cancel notification");
428  }
429 
431  GPR_ASSERT(false &&
432  "It is illegal to call GetSendMessage on a method which "
433  "has a Cancel notification");
434  return nullptr;
435  }
436 
437  bool GetSendMessageStatus() override {
438  GPR_ASSERT(false &&
439  "It is illegal to call GetSendMessageStatus on a method which "
440  "has a Cancel notification");
441  return false;
442  }
443 
444  const void* GetSendMessage() override {
445  GPR_ASSERT(false &&
446  "It is illegal to call GetOriginalSendMessage on a method which "
447  "has a Cancel notification");
448  return nullptr;
449  }
450 
451  void ModifySendMessage(const void* /*message*/) override {
452  GPR_ASSERT(false &&
453  "It is illegal to call ModifySendMessage on a method which "
454  "has a Cancel notification");
455  }
456 
457  std::multimap<std::string, std::string>* GetSendInitialMetadata() override {
458  GPR_ASSERT(false &&
459  "It is illegal to call GetSendInitialMetadata on a "
460  "method which has a Cancel notification");
461  return nullptr;
462  }
463 
464  Status GetSendStatus() override {
465  GPR_ASSERT(false &&
466  "It is illegal to call GetSendStatus on a method which "
467  "has a Cancel notification");
468  return Status();
469  }
470 
471  void ModifySendStatus(const Status& /*status*/) override {
472  GPR_ASSERT(false &&
473  "It is illegal to call ModifySendStatus on a method "
474  "which has a Cancel notification");
475  }
476 
477  std::multimap<std::string, std::string>* GetSendTrailingMetadata() override {
478  GPR_ASSERT(false &&
479  "It is illegal to call GetSendTrailingMetadata on a "
480  "method which has a Cancel notification");
481  return nullptr;
482  }
483 
484  void* GetRecvMessage() override {
485  GPR_ASSERT(false &&
486  "It is illegal to call GetRecvMessage on a method which "
487  "has a Cancel notification");
488  return nullptr;
489  }
490 
491  std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvInitialMetadata()
492  override {
493  GPR_ASSERT(false &&
494  "It is illegal to call GetRecvInitialMetadata on a "
495  "method which has a Cancel notification");
496  return nullptr;
497  }
498 
499  Status* GetRecvStatus() override {
500  GPR_ASSERT(false &&
501  "It is illegal to call GetRecvStatus on a method which "
502  "has a Cancel notification");
503  return nullptr;
504  }
505 
506  std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvTrailingMetadata()
507  override {
508  GPR_ASSERT(false &&
509  "It is illegal to call GetRecvTrailingMetadata on a "
510  "method which has a Cancel notification");
511  return nullptr;
512  }
513 
514  std::unique_ptr<ChannelInterface> GetInterceptedChannel() override {
515  GPR_ASSERT(false &&
516  "It is illegal to call GetInterceptedChannel on a "
517  "method which has a Cancel notification");
518  return std::unique_ptr<ChannelInterface>(nullptr);
519  }
520 
521  void FailHijackedRecvMessage() override {
522  GPR_ASSERT(false &&
523  "It is illegal to call FailHijackedRecvMessage on a "
524  "method which has a Cancel notification");
525  }
526 
527  void FailHijackedSendMessage() override {
528  GPR_ASSERT(false &&
529  "It is illegal to call FailHijackedSendMessage on a "
530  "method which has a Cancel notification");
531  }
532 };
533 } // namespace internal
534 } // namespace grpc
535 
536 #endif // GRPCPP_IMPL_INTERCEPTOR_COMMON_H
grpc::internal::InterceptorBatchMethodsImpl::GetSerializedSendMessage
ByteBuffer * GetSerializedSendMessage() override
Send Message Methods GetSerializedSendMessage and GetSendMessage/ModifySendMessage are the available ...
Definition: interceptor_common.h:82
grpc::internal::InterceptorBatchMethodsImpl::Proceed
void Proceed() override
Signal that the interceptor is done intercepting the current batch of the RPC.
Definition: interceptor_common.h:55
grpc::internal::InterceptorBatchMethodsImpl::ModifySendStatus
void ModifySendStatus(const Status &status) override
Overwrites the status with status.
Definition: interceptor_common.h:112
grpc::internal::CancelInterceptorBatchMethods::GetSendTrailingMetadata
std::multimap< std::string, std::string > * GetSendTrailingMetadata() override
Returns a modifiable multimap of the trailing metadata to be sent.
Definition: interceptor_common.h:477
grpc::internal::CancelInterceptorBatchMethods::ModifySendMessage
void ModifySendMessage(const void *) override
Overwrites the message to be sent with message.
Definition: interceptor_common.h:451
grpc::internal::InterceptorBatchMethodsImpl::GetSendStatus
Status GetSendStatus() override
Returns the status to be sent. Valid for PRE_SEND_STATUS interceptions.
Definition: interceptor_common.h:107
grpc::internal::CallOpSetInterface::SetHijackingState
virtual void SetHijackingState()=0
grpc::internal::InterceptorBatchMethodsImpl::QueryInterceptionHookPoint
bool QueryInterceptionHookPoint(experimental::InterceptionHookPoints type) override
Determine whether the current batch has an interception hook point of type type.
Definition: interceptor_common.h:50
grpc
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm.h:33
grpc::internal::InterceptorBatchMethodsImpl::ModifySendMessage
void ModifySendMessage(const void *message) override
Overwrites the message to be sent with message.
Definition: interceptor_common.h:96
grpc_status_code
grpc_status_code
Definition: status.h:28
grpc::internal::InterceptorBatchMethodsImpl::SetRecvInitialMetadata
void SetRecvInitialMetadata(MetadataMap *map)
Definition: interceptor_common.h:173
grpc::internal::CancelInterceptorBatchMethods::GetSendStatus
Status GetSendStatus() override
Returns the status to be sent. Valid for PRE_SEND_STATUS interceptions.
Definition: interceptor_common.h:464
grpc::internal::InterceptorBatchMethodsImpl::SetCallOpSetInterface
void SetCallOpSetInterface(CallOpSetInterface *ops)
Definition: interceptor_common.h:219
grpc::experimental::InterceptionHookPoints::PRE_RECV_MESSAGE
@ PRE_RECV_MESSAGE
grpc::internal::InterceptorBatchMethodsImpl::GetRecvInitialMetadata
std::multimap< grpc::string_ref, grpc::string_ref > * GetRecvInitialMetadata() override
Returns a modifiable multimap of the received initial metadata.
Definition: interceptor_common.h:124
grpc::internal::InterceptorBatchMethodsImpl::SetCall
void SetCall(Call *call)
Definition: interceptor_common.h:215
grpc::internal::InterceptorBatchMethodsImpl::InterceptorsListEmpty
bool InterceptorsListEmpty()
Definition: interceptor_common.h:223
grpc::internal::InterceptorBatchMethodsImpl::InterceptorBatchMethodsImpl
InterceptorBatchMethodsImpl()
Definition: interceptor_common.h:39
grpc::internal::CancelInterceptorBatchMethods::FailHijackedRecvMessage
void FailHijackedRecvMessage() override
On a hijacked RPC, an interceptor can decide to fail a PRE_RECV_MESSAGE op.
Definition: interceptor_common.h:521
grpc::internal::InterceptorBatchMethodsImpl::ClearState
void ClearState()
Definition: interceptor_common.h:201
grpc::internal::Call
Straightforward wrapping of the C call object.
Definition: call.h:36
GPR_ASSERT
#define GPR_ASSERT(x)
abort() the process if x is zero, having written a line to the log.
Definition: log.h:95
grpc::internal::InterceptorBatchMethodsImpl::FailHijackedSendMessage
void FailHijackedSendMessage() override
On a hijacked RPC/ to-be hijacked RPC, this can be called to fail a SEND MESSAGE op.
Definition: interceptor_common.h:131
grpc::internal::MetadataMap
Definition: metadata_map.h:34
grpc::experimental::InterceptionHookPoints::PRE_SEND_CANCEL
@ PRE_SEND_CANCEL
This is a special hook point available to both clients and servers when TryCancel() is performed.
grpc_types.h
grpc::internal::MetadataMap::map
std::multimap< grpc::string_ref, grpc::string_ref > * map()
Definition: metadata_map.h:67
grpc::internal::InterceptorBatchMethodsImpl::GetSendMessageStatus
bool GetSendMessageStatus() override
Checks whether the SEND MESSAGE op succeeded.
Definition: interceptor_common.h:101
grpc::internal::CancelInterceptorBatchMethods::GetInterceptedChannel
std::unique_ptr< ChannelInterface > GetInterceptedChannel() override
Gets an intercepted channel.
Definition: interceptor_common.h:514
grpc::Status
Did it work? If it didn't, why?
Definition: status.h:35
client_interceptor.h
grpc::internal::InterceptorBatchMethodsImpl::SetSendStatus
void SetSendStatus(grpc_status_code *code, std::string *error_details, std::string *error_message)
Definition: interceptor_common.h:156
grpc::internal::CancelInterceptorBatchMethods::GetRecvMessage
void * GetRecvMessage() override
Returns a pointer to the modifiable received message.
Definition: interceptor_common.h:484
log.h
grpc::internal::InterceptorBatchMethodsImpl::RunInterceptors
bool RunInterceptors(std::function< void(void)> f)
Definition: interceptor_common.h:262
grpc::internal::InterceptorBatchMethodsImpl::GetSendTrailingMetadata
std::multimap< std::string, std::string > * GetSendTrailingMetadata() override
Returns a modifiable multimap of the trailing metadata to be sent.
Definition: interceptor_common.h:118
grpc::internal::CancelInterceptorBatchMethods::GetSendMessage
const void * GetSendMessage() override
Returns a non-modifiable pointer to the non-serialized form of the message to be sent.
Definition: interceptor_common.h:444
grpc::internal::CallOpSetInterface
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:36
grpc::ByteBuffer
A sequence of bytes.
Definition: byte_buffer.h:60
grpc::internal::InterceptorBatchMethodsImpl::SetReverse
void SetReverse()
Definition: interceptor_common.h:208
grpc::internal::InterceptorBatchMethodsImpl::SetRecvStatus
void SetRecvStatus(Status *status)
Definition: interceptor_common.h:177
grpc::internal::InterceptorBatchMethodsImpl::GetRecvMessage
void * GetRecvMessage() override
Returns a pointer to the modifiable received message.
Definition: interceptor_common.h:122
grpc::internal::CancelInterceptorBatchMethods::GetRecvInitialMetadata
std::multimap< grpc::string_ref, grpc::string_ref > * GetRecvInitialMetadata() override
Returns a modifiable multimap of the received initial metadata.
Definition: interceptor_common.h:491
grpc::internal::CancelInterceptorBatchMethods::ModifySendStatus
void ModifySendStatus(const Status &) override
Overwrites the status with status.
Definition: interceptor_common.h:471
grpc::internal::InterceptorBatchMethodsImpl::Hijack
void Hijack() override
Indicate that the interceptor has hijacked the RPC (only valid if the batch contains send_initial_met...
Definition: interceptor_common.h:63
grpc::internal::InterceptedChannel
An InterceptedChannel is available to client Interceptors.
Definition: intercepted_channel.h:35
grpc::Status::error_message
std::string error_message() const
Return the instance's error message.
Definition: status.h:120
grpc::StatusCode
StatusCode
Definition: status_code_enum.h:26
grpc::internal::CancelInterceptorBatchMethods::GetSerializedSendMessage
ByteBuffer * GetSerializedSendMessage() override
Send Message Methods GetSerializedSendMessage and GetSendMessage/ModifySendMessage are the available ...
Definition: interceptor_common.h:430
call_op_set_interface.h
grpc::internal::InterceptorBatchMethodsImpl::GetSendInitialMetadata
std::multimap< std::string, std::string > * GetSendInitialMetadata() override
Returns a modifiable multimap of the initial metadata to be sent.
Definition: interceptor_common.h:103
server_interceptor.h
grpc::internal::InterceptorBatchMethodsImpl::GetSendMessage
const void * GetSendMessage() override
Returns a non-modifiable pointer to the non-serialized form of the message to be sent.
Definition: interceptor_common.h:91
grpc::experimental::InterceptionHookPoints::NUM_INTERCEPTION_HOOKS
@ NUM_INTERCEPTION_HOOKS
grpc::experimental::InterceptionHookPoints::PRE_SEND_MESSAGE
@ PRE_SEND_MESSAGE
grpc::internal::InterceptorBatchMethodsImpl::SetRecvMessage
void SetRecvMessage(void *message, bool *hijacked_recv_message_failed)
Definition: interceptor_common.h:168
grpc::Status::error_code
StatusCode error_code() const
Return the instance's error code.
Definition: status.h:118
grpc::internal::CancelInterceptorBatchMethods::GetRecvStatus
Status * GetRecvStatus() override
Returns a modifiable view of the received status on PRE_RECV_STATUS and POST_RECV_STATUS interception...
Definition: interceptor_common.h:499
grpc::internal::CancelInterceptorBatchMethods::Hijack
void Hijack() override
Indicate that the interceptor has hijacked the RPC (only valid if the batch contains send_initial_met...
Definition: interceptor_common.h:423
grpc::internal::InterceptorBatchMethodsImpl::FailHijackedRecvMessage
void FailHijackedRecvMessage() override
On a hijacked RPC, an interceptor can decide to fail a PRE_RECV_MESSAGE op.
Definition: interceptor_common.h:194
grpc::internal::Call::server_rpc_info
experimental::ServerRpcInfo * server_rpc_info() const
Definition: call.h:79
grpc::internal::InterceptorBatchMethodsImpl::GetRecvTrailingMetadata
std::multimap< grpc::string_ref, grpc::string_ref > * GetRecvTrailingMetadata() override
Returns a modifiable multimap of the received trailing metadata on PRE_RECV_STATUS and POST_RECV_STAT...
Definition: interceptor_common.h:137
grpc::internal::CallOpSetInterface::ContinueFillOpsAfterInterception
virtual void ContinueFillOpsAfterInterception()=0
grpc::internal::InterceptorBatchMethodsImpl::SetSendMessage
void SetSendMessage(ByteBuffer *buf, const void **msg, bool *fail_send_message, std::function< Status(const void *)> serializer)
Definition: interceptor_common.h:142
grpc::internal::InterceptorBatchMethodsImpl::~InterceptorBatchMethodsImpl
~InterceptorBatchMethodsImpl() override
Definition: interceptor_common.h:48
grpc::internal::CallOpSetInterface::ContinueFinalizeResultAfterInterception
virtual void ContinueFinalizeResultAfterInterception()=0
grpc::internal::InterceptorBatchMethodsImpl::GetRecvStatus
Status * GetRecvStatus() override
Returns a modifiable view of the received status on PRE_RECV_STATUS and POST_RECV_STATUS interception...
Definition: interceptor_common.h:129
call.h
grpc::internal::InterceptorBatchMethodsImpl::GetInterceptedChannel
std::unique_ptr< ChannelInterface > GetInterceptedChannel() override
Gets an intercepted channel.
Definition: interceptor_common.h:183
grpc::experimental::InterceptorBatchMethods
Class that is passed as an argument to the Intercept method of the application's Interceptor interfac...
Definition: interceptor.h:95
grpc::internal::CancelInterceptorBatchMethods::Proceed
void Proceed() override
Signal that the interceptor is done intercepting the current batch of the RPC.
Definition: interceptor_common.h:418
grpc::internal::CancelInterceptorBatchMethods::GetSendMessageStatus
bool GetSendMessageStatus() override
Checks whether the SEND MESSAGE op succeeded.
Definition: interceptor_common.h:437
intercepted_channel.h
grpc::internal::InterceptorBatchMethodsImpl::RunInterceptors
bool RunInterceptors()
Definition: interceptor_common.h:238
grpc::internal::CancelInterceptorBatchMethods::FailHijackedSendMessage
void FailHijackedSendMessage() override
On a hijacked RPC/ to-be hijacked RPC, this can be called to fail a SEND MESSAGE op.
Definition: interceptor_common.h:527
grpc::internal::CancelInterceptorBatchMethods
Definition: interceptor_common.h:410
grpc::internal::InterceptorBatchMethodsImpl::SetRecvTrailingMetadata
void SetRecvTrailingMetadata(MetadataMap *map)
Definition: interceptor_common.h:179
grpc::internal::InterceptorBatchMethodsImpl::SetSendInitialMetadata
void SetSendInitialMetadata(std::multimap< std::string, std::string > *metadata)
Definition: interceptor_common.h:151
grpc::protobuf::util::Status
::absl::Status Status
Definition: config_protobuf.h:97
grpc::internal::CancelInterceptorBatchMethods::QueryInterceptionHookPoint
bool QueryInterceptionHookPoint(experimental::InterceptionHookPoints type) override
Determine whether the current batch has an interception hook point of type type.
Definition: interceptor_common.h:413
grpc::experimental::InterceptionHookPoints
InterceptionHookPoints
An enumeration of different possible points at which the Intercept method of the Interceptor interfac...
Definition: interceptor.h:56
grpc::internal::InterceptorBatchMethodsImpl
Definition: interceptor_common.h:36
grpc::Status::error_details
std::string error_details() const
Return the (binary) error details.
Definition: status.h:123
grpc::internal::InterceptorBatchMethodsImpl::SetSendTrailingMetadata
void SetSendTrailingMetadata(std::multimap< std::string, std::string > *metadata)
Definition: interceptor_common.h:163
grpc::internal::CancelInterceptorBatchMethods::GetSendInitialMetadata
std::multimap< std::string, std::string > * GetSendInitialMetadata() override
Returns a modifiable multimap of the initial metadata to be sent.
Definition: interceptor_common.h:457
grpc::internal::InterceptorBatchMethodsImpl::AddInterceptionHookPoint
void AddInterceptionHookPoint(experimental::InterceptionHookPoints type)
Definition: interceptor_common.h:78
grpc::internal::Call::client_rpc_info
experimental::ClientRpcInfo * client_rpc_info() const
Definition: call.h:75
grpc::internal::CancelInterceptorBatchMethods::GetRecvTrailingMetadata
std::multimap< grpc::string_ref, grpc::string_ref > * GetRecvTrailingMetadata() override
Returns a modifiable multimap of the received trailing metadata on PRE_RECV_STATUS and POST_RECV_STAT...
Definition: interceptor_common.h:506