GRPC C++  1.26.0
client_context_impl.h
Go to the documentation of this file.
1 /*
2  *
3  * Copyright 2015 gRPC authors.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  */
18 
33 
34 #ifndef GRPCPP_IMPL_CODEGEN_CLIENT_CONTEXT_IMPL_H
35 #define GRPCPP_IMPL_CODEGEN_CLIENT_CONTEXT_IMPL_H
36 
37 #include <map>
38 #include <memory>
39 #include <string>
40 
55 
56 struct census_context;
57 struct grpc_call;
58 
59 namespace grpc {
60 
61 class ChannelInterface;
62 
63 namespace internal {
64 class RpcMethod;
65 template <class InputMessage, class OutputMessage>
66 class BlockingUnaryCallImpl;
67 class CallOpClientRecvStatus;
68 class CallOpRecvInitialMetadata;
69 class ServerContextImpl;
70 } // namespace internal
71 
72 namespace testing {
73 class InteropClientContextInspector;
74 } // namespace testing
75 } // namespace grpc
76 namespace grpc_impl {
77 
78 namespace internal {
79 template <class InputMessage, class OutputMessage>
80 class CallbackUnaryCallImpl;
81 template <class Request, class Response>
82 class ClientCallbackReaderWriterImpl;
83 template <class Response>
84 class ClientCallbackReaderImpl;
85 template <class Request>
86 class ClientCallbackWriterImpl;
87 class ClientCallbackUnaryImpl;
88 class ClientContextAccessor;
89 } // namespace internal
90 
91 class CallCredentials;
92 class Channel;
93 class CompletionQueue;
94 class ServerContext;
95 template <class R>
96 class ClientReader;
97 template <class W>
98 class ClientWriter;
99 template <class W, class R>
100 class ClientReaderWriter;
101 template <class R>
102 class ClientAsyncReader;
103 template <class W>
104 class ClientAsyncWriter;
105 template <class W, class R>
107 template <class R>
109 
110 class ServerContextBase;
112 
119  public:
121 
123  propagate_ |= GRPC_PROPAGATE_DEADLINE;
124  return *this;
125  }
126 
128  propagate_ &= ~GRPC_PROPAGATE_DEADLINE;
129  return *this;
130  }
131 
134  return *this;
135  }
136 
139  return *this;
140  }
141 
144  return *this;
145  }
146 
149  return *this;
150  }
151 
153  propagate_ |= GRPC_PROPAGATE_CANCELLATION;
154  return *this;
155  }
156 
158  propagate_ &= ~GRPC_PROPAGATE_CANCELLATION;
159  return *this;
160  }
161 
162  uint32_t c_bitmask() const { return propagate_; }
163 
164  private:
165  uint32_t propagate_;
166 };
167 
185  public:
186  ClientContext();
187  ~ClientContext();
188 
199  static std::unique_ptr<ClientContext> FromServerContext(
200  const grpc_impl::ServerContext& server_context,
202  static std::unique_ptr<ClientContext> FromCallbackServerContext(
203  const grpc_impl::CallbackServerContext& server_context,
205 
223  void AddMetadata(const grpc::string& meta_key,
224  const grpc::string& meta_value);
225 
234  const std::multimap<grpc::string_ref, grpc::string_ref>&
236  GPR_CODEGEN_ASSERT(initial_metadata_received_);
237  return *recv_initial_metadata_.map();
238  }
239 
246  const std::multimap<grpc::string_ref, grpc::string_ref>&
248  // TODO(yangg) check finished
249  return *trailing_metadata_.map();
250  }
251 
258  template <typename T>
259  void set_deadline(const T& deadline) {
260  grpc::TimePoint<T> deadline_tp(deadline);
261  deadline_ = deadline_tp.raw_time();
262  }
263 
269  void set_idempotent(bool idempotent) { idempotent_ = idempotent; }
270 
274  void set_cacheable(bool cacheable) { cacheable_ = cacheable; }
275 
282  void set_wait_for_ready(bool wait_for_ready) {
283  wait_for_ready_ = wait_for_ready;
284  wait_for_ready_explicitly_set_ = true;
285  }
286 
288  void set_fail_fast(bool fail_fast) { set_wait_for_ready(!fail_fast); }
289 
291  std::chrono::system_clock::time_point deadline() const {
292  return grpc::Timespec2Timepoint(deadline_);
293  }
294 
296  gpr_timespec raw_deadline() const { return deadline_; }
297 
300  void set_authority(const grpc::string& authority) { authority_ = authority; }
301 
306  std::shared_ptr<const grpc::AuthContext> auth_context() const {
307  if (auth_context_.get() == nullptr) {
308  auth_context_ = grpc::CreateAuthContext(call_);
309  }
310  return auth_context_;
311  }
312 
323  void set_credentials(
324  const std::shared_ptr<grpc_impl::CallCredentials>& creds);
325 
331  std::shared_ptr<grpc_impl::CallCredentials> credentials() { return creds_; }
332 
337  return compression_algorithm_;
338  }
339 
343  void set_compression_algorithm(grpc_compression_algorithm algorithm);
344 
355  void set_initial_metadata_corked(bool corked) {
356  initial_metadata_corked_ = corked;
357  }
358 
367  grpc::string peer() const;
368 
373  void set_census_context(struct census_context* ccp) { census_context_ = ccp; }
374 
376  struct census_context* census_context() const {
377  return census_context_;
378  }
379 
389  void TryCancel();
390 
396  public:
397  virtual ~GlobalCallbacks() {}
398  virtual void DefaultConstructor(ClientContext* context) = 0;
399  virtual void Destructor(ClientContext* context) = 0;
400  };
401  static void SetGlobalCallbacks(GlobalCallbacks* callbacks);
402 
405  grpc_call* c_call() { return call_; }
406 
412  grpc::string debug_error_string() const { return debug_error_string_; }
413 
414  private:
415  // Disallow copy and assign.
417  ClientContext& operator=(const ClientContext&);
418 
419  friend class ::grpc::testing::InteropClientContextInspector;
420  friend class ::grpc::internal::CallOpClientRecvStatus;
421  friend class ::grpc::internal::CallOpRecvInitialMetadata;
423  template <class R>
425  template <class W>
427  template <class W, class R>
429  template <class R>
431  template <class W>
433  template <class W, class R>
435  template <class R>
437  template <class InputMessage, class OutputMessage>
438  friend class ::grpc::internal::BlockingUnaryCallImpl;
439  template <class InputMessage, class OutputMessage>
440  friend class ::grpc_impl::internal::CallbackUnaryCallImpl;
441  template <class Request, class Response>
442  friend class ::grpc_impl::internal::ClientCallbackReaderWriterImpl;
443  template <class Response>
444  friend class ::grpc_impl::internal::ClientCallbackReaderImpl;
445  template <class Request>
446  friend class ::grpc_impl::internal::ClientCallbackWriterImpl;
447  friend class ::grpc_impl::internal::ClientCallbackUnaryImpl;
448  friend class ::grpc_impl::internal::ClientContextAccessor;
449 
450  // Used by friend class CallOpClientRecvStatus
451  void set_debug_error_string(const grpc::string& debug_error_string) {
452  debug_error_string_ = debug_error_string;
453  }
454 
455  grpc_call* call() const { return call_; }
456  void set_call(grpc_call* call,
457  const std::shared_ptr<::grpc_impl::Channel>& channel);
458 
459  grpc::experimental::ClientRpcInfo* set_client_rpc_info(
460  const char* method, grpc::internal::RpcMethod::RpcType type,
461  grpc::ChannelInterface* channel,
462  const std::vector<std::unique_ptr<
464  size_t interceptor_pos) {
465  rpc_info_ = grpc::experimental::ClientRpcInfo(this, type, method, channel);
466  rpc_info_.RegisterInterceptors(creators, interceptor_pos);
467  return &rpc_info_;
468  }
469 
470  uint32_t initial_metadata_flags() const {
471  return (idempotent_ ? GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST : 0) |
472  (wait_for_ready_ ? GRPC_INITIAL_METADATA_WAIT_FOR_READY : 0) |
473  (cacheable_ ? GRPC_INITIAL_METADATA_CACHEABLE_REQUEST : 0) |
474  (wait_for_ready_explicitly_set_
476  : 0) |
477  (initial_metadata_corked_ ? GRPC_INITIAL_METADATA_CORKED : 0);
478  }
479 
480  grpc::string authority() { return authority_; }
481 
482  void SendCancelToInterceptors();
483 
484  static std::unique_ptr<ClientContext> FromInternalServerContext(
485  const grpc_impl::ServerContextBase& server_context,
486  PropagationOptions options);
487 
488  bool initial_metadata_received_;
489  bool wait_for_ready_;
490  bool wait_for_ready_explicitly_set_;
491  bool idempotent_;
492  bool cacheable_;
493  std::shared_ptr<::grpc_impl::Channel> channel_;
495  grpc_call* call_;
496  bool call_canceled_;
497  gpr_timespec deadline_;
498  grpc::string authority_;
499  std::shared_ptr<grpc_impl::CallCredentials> creds_;
500  mutable std::shared_ptr<const grpc::AuthContext> auth_context_;
501  struct census_context* census_context_;
502  std::multimap<grpc::string, grpc::string> send_initial_metadata_;
503  mutable grpc::internal::MetadataMap recv_initial_metadata_;
504  mutable grpc::internal::MetadataMap trailing_metadata_;
505 
506  grpc_call* propagate_from_call_;
507  PropagationOptions propagation_options_;
508 
509  grpc_compression_algorithm compression_algorithm_;
510  bool initial_metadata_corked_;
511 
512  grpc::string debug_error_string_;
513 
515 };
516 
517 } // namespace grpc_impl
518 
519 #endif // GRPCPP_IMPL_CODEGEN_CLIENT_CONTEXT_IMPL_H
void set_idempotent(bool idempotent)
EXPERIMENTAL: Indicate that this request is idempotent.
Definition: client_context_impl.h:269
struct census_context * census_context() const
Returns the census context that has been set, or nullptr if not set.
Definition: client_context_impl.h:376
struct grpc_call grpc_call
A Call represents an RPC.
Definition: grpc_types.h:70
std::shared_ptr< const AuthContext > CreateAuthContext(grpc_call *call)
::grpc_impl::ClientAsyncReader< R > ClientAsyncReader
Definition: async_stream.h:43
Definition: server_context_impl.h:528
::grpc_impl::ClientContext ClientContext
Definition: client_context.h:26
std::shared_ptr< const grpc::AuthContext > auth_context() const
Return the authentication context for the associated client call.
Definition: client_context_impl.h:306
PropagationOptions & disable_deadline_propagation()
Definition: client_context_impl.h:127
grpc_call * c_call()
Should be used for framework-level extensions only.
Definition: client_context_impl.h:405
PropagationOptions & enable_deadline_propagation()
Definition: client_context_impl.h:122
#define GPR_CODEGEN_ASSERT(x)
Codegen specific version of GPR_ASSERT.
Definition: core_codegen_interface.h:146
::grpc_impl::ServerContextBase ServerContextBase
Definition: server_context.h:30
Synchronous (blocking) client-side API for bi-directional streaming RPCs, where the outgoing message ...
Definition: channel_interface.h:35
void set_cacheable(bool cacheable)
EXPERIMENTAL: Set this request to be cacheable.
Definition: client_context_impl.h:274
std::string string
Definition: config.h:35
PropagationOptions & enable_cancellation_propagation()
Definition: client_context_impl.h:152
grpc::string debug_error_string() const
EXPERIMENTAL debugging API.
Definition: client_context_impl.h:412
A call credentials object encapsulates the state needed by a client to authenticate with a server for...
Definition: credentials_impl.h:111
Synchronous (blocking) client-side API for doing server-streaming RPCs, where the stream of messages ...
Definition: channel_interface.h:31
Definition: metadata_map.h:33
PropagationOptions()
Definition: client_context_impl.h:120
PropagationOptions & enable_census_tracing_propagation()
Definition: client_context_impl.h:142
PropagationOptions & enable_census_stats_propagation()
Definition: client_context_impl.h:132
::grpc_impl::PropagationOptions PropagationOptions
Definition: client_context.h:27
Async client-side interface for bi-directional streaming, where the outgoing message stream going to ...
Definition: async_stream_impl.h:513
::grpc_impl::ClientAsyncReaderWriter< W, R > ClientAsyncReaderWriter
Definition: async_stream.h:56
const std::multimap< grpc::string_ref, grpc::string_ref > & GetServerInitialMetadata() const
Return a collection of initial metadata key-value pairs.
Definition: client_context_impl.h:235
Options for ClientContext::FromServerContext specifying which traits from the ServerContext to propag...
Definition: client_context_impl.h:118
grpc_compression_algorithm compression_algorithm() const
Return the compression algorithm the client call will request be used.
Definition: client_context_impl.h:336
#define GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET
Signal that GRPC_INITIAL_METADATA_WAIT_FOR_READY was explicitly set by the calling application...
Definition: grpc_types.h:472
gpr_timespec raw_time()
Definition: time.h:43
RpcType
Definition: rpc_method.h:31
If you are trying to use CompletionQueue::AsyncNext with a time class that isn&#39;t either gpr_timespec ...
Definition: time.h:40
A ServerContext or CallbackServerContext allows the code implementing a service handler to: ...
Definition: server_context_impl.h:488
#define GRPC_INITIAL_METADATA_CORKED
Signal that the initial metadata should be corked.
Definition: grpc_types.h:474
PropagationOptions & disable_cancellation_propagation()
Definition: client_context_impl.h:157
void set_initial_metadata_corked(bool corked)
Flag whether the initial metadata should be corked.
Definition: client_context_impl.h:355
Async client-side API for doing server-streaming RPCs, where the incoming message stream coming from ...
Definition: async_stream_impl.h:197
gpr_timespec raw_deadline() const
Return a gpr_timespec representation of the client call&#39;s deadline.
Definition: client_context_impl.h:296
PropagationOptions & disable_census_tracing_propagation()
Definition: client_context_impl.h:147
Base class of ServerContext. Experimental until callback API is final.
Definition: server_context_impl.h:117
::grpc_impl::Channel Channel
Definition: channel.h:26
#define GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT
Definition: propagation_bits.h:34
std::chrono::system_clock::time_point deadline() const
Return the deadline for the client call.
Definition: client_context_impl.h:291
grpc_compression_algorithm
The various compression algorithms supported by gRPC (not sorted by compression level) ...
Definition: compression_types.h:57
Definition: sync.h:47
Async API for client-side unary RPCs, where the message response received from the server is of type ...
Definition: async_unary_call_impl.h:94
::grpc_impl::CallbackServerContext CallbackServerContext
Definition: server_context.h:31
::grpc_impl::ClientReaderWriter< W, R > ClientReaderWriter
Definition: sync_stream.h:69
This header provides an object that reads bytes directly from a grpc::ByteBuffer, via the ZeroCopyInp...
Definition: alarm.h:24
Codegen interface for grpc::Channel.
Definition: channel_interface.h:74
#define GRPC_INITIAL_METADATA_CACHEABLE_REQUEST
Signal that the call is cacheable.
Definition: grpc_types.h:469
void set_authority(const grpc::string &authority)
Set the per call authority header (see https://tools.ietf.org/html/rfc7540#section-8.1.2.3).
Definition: client_context_impl.h:300
::grpc_impl::ClientWriter< W > ClientWriter
Definition: sync_stream.h:62
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm_impl.h:33
#define GRPC_INITIAL_METADATA_WAIT_FOR_READY
Signal that the call should not return UNAVAILABLE before it has started.
Definition: grpc_types.h:467
void set_deadline(const T &deadline)
Set the deadline for the client call.
Definition: client_context_impl.h:259
void set_fail_fast(bool fail_fast)
DEPRECATED: Use set_wait_for_ready() instead.
Definition: client_context_impl.h:288
std::shared_ptr< grpc_impl::CallCredentials > credentials()
EXPERIMENTAL debugging API.
Definition: client_context_impl.h:331
#define GRPC_PROPAGATE_DEFAULTS
Default propagation mask: clients of the core API are encouraged to encode deltas from this in their ...
Definition: propagation_bits.h:43
Async API on the client side for doing client-streaming RPCs, where the outgoing message stream going...
Definition: async_stream_impl.h:346
Global Callbacks.
Definition: client_context_impl.h:395
#define GRPC_PROPAGATE_CENSUS_STATS_CONTEXT
Propagate census context.
Definition: propagation_bits.h:33
void set_census_context(struct census_context *ccp)
Sets the census context.
Definition: client_context_impl.h:373
A thin wrapper around grpc_completion_queue (see src/core/lib/surface/completion_queue.h).
Definition: completion_queue_impl.h:100
A ClientContext allows the person implementing a service client to:
Definition: client_context_impl.h:184
Channels represent a connection to an endpoint. Created by CreateChannel.
Definition: channel_impl.h:53
::grpc_impl::ClientAsyncWriter< W > ClientAsyncWriter
Definition: async_stream.h:49
Analogous to struct timespec.
Definition: gpr_types.h:47
std::chrono::system_clock::time_point Timespec2Timepoint(gpr_timespec t)
#define GRPC_PROPAGATE_DEADLINE
Propagation bits: this can be bitwise or-ed to form propagation_mask for grpc_call.
Definition: propagation_bits.h:31
const std::multimap< grpc::string_ref, grpc::string_ref > & GetServerTrailingMetadata() const
Return a collection of trailing metadata key-value pairs.
Definition: client_context_impl.h:247
Synchronous (blocking) client-side API for doing client-streaming RPCs, where the outgoing message st...
Definition: channel_interface.h:33
PropagationOptions & disable_census_stats_propagation()
Definition: client_context_impl.h:137
virtual ~GlobalCallbacks()
Definition: client_context_impl.h:397
::grpc_impl::ClientReader< R > ClientReader
Definition: sync_stream.h:56
uint32_t c_bitmask() const
Definition: client_context_impl.h:162
Definition: client_interceptor.h:69
grpc_impl::ClientAsyncResponseReader< R > ClientAsyncResponseReader
Definition: async_unary_call.h:31
void set_wait_for_ready(bool wait_for_ready)
EXPERIMENTAL: Trigger wait-for-ready or not on this request.
Definition: client_context_impl.h:282
#define GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST
Initial metadata flags.
Definition: grpc_types.h:465
#define GRPC_PROPAGATE_CANCELLATION
Propagate cancellation.
Definition: propagation_bits.h:36