GRPC C++  1.66.0
client_context.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_CLIENT_CONTEXT_H
35 #define GRPCPP_CLIENT_CONTEXT_H
36 
37 #include <map>
38 #include <memory>
39 #include <string>
40 
41 #include "absl/log/absl_check.h"
42 
45 #include <grpc/support/log.h>
48 #include <grpcpp/impl/rpc_method.h>
49 #include <grpcpp/impl/sync.h>
52 #include <grpcpp/support/config.h>
53 #include <grpcpp/support/slice.h>
54 #include <grpcpp/support/status.h>
56 #include <grpcpp/support/time.h>
57 
58 struct census_context;
59 struct grpc_call;
60 
61 namespace grpc {
62 class ServerContext;
63 class ServerContextBase;
64 class CallbackServerContext;
65 
66 namespace internal {
67 template <class InputMessage, class OutputMessage>
69 template <class Request, class Response>
71 template <class Response>
73 template <class Request>
76 class ClientContextAccessor;
78 } // namespace internal
79 
80 template <class R>
82 template <class W>
84 template <class W, class R>
86 template <class R>
88 template <class W>
90 template <class W, class R>
92 template <class R>
94 
95 namespace testing {
96 class InteropClientContextInspector;
97 class ClientContextTestPeer;
98 } // namespace testing
99 
100 namespace internal {
101 class RpcMethod;
102 template <class InputMessage, class OutputMessage>
106 class ServerContextImpl;
107 template <class InputMessage, class OutputMessage>
109 template <class Request, class Response>
111 template <class Response>
113 template <class Request>
116 class ClientContextAccessor;
117 } // namespace internal
118 
119 class CallCredentials;
120 class Channel;
121 class ChannelInterface;
122 class CompletionQueue;
123 
130  public:
132 
134  propagate_ |= GRPC_PROPAGATE_DEADLINE;
135  return *this;
136  }
137 
139  propagate_ &= ~GRPC_PROPAGATE_DEADLINE;
140  return *this;
141  }
142 
145  return *this;
146  }
147 
150  return *this;
151  }
152 
155  return *this;
156  }
157 
160  return *this;
161  }
162 
164  propagate_ |= GRPC_PROPAGATE_CANCELLATION;
165  return *this;
166  }
167 
169  propagate_ &= ~GRPC_PROPAGATE_CANCELLATION;
170  return *this;
171  }
172 
173  uint32_t c_bitmask() const { return propagate_; }
174 
175  private:
176  uint32_t propagate_;
177 };
178 
196  public:
197  ClientContext();
198  ~ClientContext();
199 
210  static std::unique_ptr<ClientContext> FromServerContext(
211  const grpc::ServerContextBase& server_context,
213  static std::unique_ptr<ClientContext> FromCallbackServerContext(
214  const grpc::CallbackServerContext& server_context,
216 
239  void AddMetadata(const std::string& meta_key, const std::string& meta_value);
240 
249  const std::multimap<grpc::string_ref, grpc::string_ref>&
251  ABSL_CHECK(initial_metadata_received_);
252  return *recv_initial_metadata_.map();
253  }
254 
261  const std::multimap<grpc::string_ref, grpc::string_ref>&
263  // TODO(yangg) check finished
264  return *trailing_metadata_.map();
265  }
266 
273  template <typename T>
274  void set_deadline(const T& deadline) {
275  grpc::TimePoint<T> deadline_tp(deadline);
276  deadline_ = deadline_tp.raw_time();
277  }
278 
285  void set_wait_for_ready(bool wait_for_ready) {
286  wait_for_ready_ = wait_for_ready;
287  wait_for_ready_explicitly_set_ = true;
288  }
289 
291  void set_fail_fast(bool fail_fast) { set_wait_for_ready(!fail_fast); }
292 
294  std::chrono::system_clock::time_point deadline() const {
295  return grpc::Timespec2Timepoint(deadline_);
296  }
297 
299  gpr_timespec raw_deadline() const { return deadline_; }
300 
303  void set_authority(const std::string& authority) { authority_ = authority; }
304 
309  std::shared_ptr<const grpc::AuthContext> auth_context() const {
310  if (auth_context_ == nullptr) {
311  auth_context_ = grpc::CreateAuthContext(call_);
312  }
313  return auth_context_;
314  }
315 
326  void set_credentials(const std::shared_ptr<grpc::CallCredentials>& creds);
327 
333  std::shared_ptr<grpc::CallCredentials> credentials() { return creds_; }
334 
339  return compression_algorithm_;
340  }
341 
346 
357  void set_initial_metadata_corked(bool corked) {
358  initial_metadata_corked_ = corked;
359  }
360 
369  std::string peer() const;
370 
375  void set_census_context(struct census_context* ccp) { census_context_ = ccp; }
376 
378  struct census_context* census_context() const { return census_context_; }
379 
392  void TryCancel();
393 
399  public:
400  virtual ~GlobalCallbacks() {}
401  virtual void DefaultConstructor(ClientContext* context) = 0;
402  virtual void Destructor(ClientContext* context) = 0;
403  };
404  static void SetGlobalCallbacks(GlobalCallbacks* callbacks);
405 
408  grpc_call* c_call() { return call_; }
409 
415  std::string debug_error_string() const { return debug_error_string_; }
416 
417  private:
418  // Disallow copy and assign.
420  ClientContext& operator=(const ClientContext&);
421 
426  friend class grpc::Channel;
427  template <class R>
428  friend class grpc::ClientReader;
429  template <class W>
430  friend class grpc::ClientWriter;
431  template <class W, class R>
433  template <class R>
435  template <class W>
437  template <class W, class R>
439  template <class R>
442  template <class InputMessage, class OutputMessage>
444  template <class InputMessage, class OutputMessage>
446  template <class Request, class Response>
448  template <class Response>
450  template <class Request>
454 
455  // Used by friend class CallOpClientRecvStatus
456  void set_debug_error_string(const std::string& debug_error_string) {
457  debug_error_string_ = debug_error_string;
458  }
459 
460  grpc_call* call() const { return call_; }
461  void set_call(grpc_call* call, const std::shared_ptr<grpc::Channel>& channel);
462 
463  grpc::experimental::ClientRpcInfo* set_client_rpc_info(
464  const char* method, const char* suffix_for_stats,
466  const std::vector<std::unique_ptr<
468  size_t interceptor_pos) {
469  rpc_info_ = grpc::experimental::ClientRpcInfo(this, type, method,
470  suffix_for_stats, channel);
471  rpc_info_.RegisterInterceptors(creators, interceptor_pos);
472  return &rpc_info_;
473  }
474 
475  uint32_t initial_metadata_flags() const {
476  return (wait_for_ready_ ? GRPC_INITIAL_METADATA_WAIT_FOR_READY : 0) |
477  (wait_for_ready_explicitly_set_
479  : 0);
480  }
481 
482  std::string authority() { return authority_; }
483 
484  void SendCancelToInterceptors();
485 
486  static std::unique_ptr<ClientContext> FromInternalServerContext(
487  const grpc::ServerContextBase& server_context,
488  PropagationOptions options);
489 
490  bool initial_metadata_received_;
491  bool wait_for_ready_;
492  bool wait_for_ready_explicitly_set_;
493  std::shared_ptr<grpc::Channel> channel_;
495  grpc_call* call_;
496  bool call_canceled_;
497  gpr_timespec deadline_;
498  grpc::string authority_;
499  std::shared_ptr<grpc::CallCredentials> creds_;
500  mutable std::shared_ptr<const grpc::AuthContext> auth_context_;
501  struct census_context* census_context_;
502  std::multimap<std::string, std::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  std::string debug_error_string_;
513 
515 };
516 
517 } // namespace grpc
518 
519 #endif // GRPCPP_CLIENT_CONTEXT_H
grpc::internal::ClientCallbackUnaryImpl
Definition: client_callback.h:1111
census_context
struct census_context census_context
A Census Context is a handle used by Census to represent the current tracing and stats collection inf...
Definition: census.h:33
grpc::ClientContext::FromServerContext
static std::unique_ptr< ClientContext > FromServerContext(const grpc::ServerContextBase &server_context, PropagationOptions options=PropagationOptions())
Create a new ClientContext as a child of an incoming server call, according to options (.
time.h
grpc::internal::CallOpRecvInitialMetadata
Definition: call_op_set.h:723
grpc::ClientContext::compression_algorithm
grpc_compression_algorithm compression_algorithm() const
Return the compression algorithm the client call will request be used.
Definition: client_context.h:338
grpc::ClientContext::set_credentials
void set_credentials(const std::shared_ptr< grpc::CallCredentials > &creds)
Set credentials for the client call.
grpc::ClientContext::~ClientContext
~ClientContext()
grpc::internal::ClientCallbackReaderWriterImpl
Definition: client_context.h:70
grpc::ClientWriter
Synchronous (blocking) client-side API for doing client-streaming RPCs, where the outgoing message st...
Definition: client_context.h:83
grpc::ClientContext::GlobalCallbacks::Destructor
virtual void Destructor(ClientContext *context)=0
grpc
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm.h:33
grpc::ClientContext::set_wait_for_ready
void set_wait_for_ready(bool wait_for_ready)
Trigger wait-for-ready or not on this request.
Definition: client_context.h:285
grpc::CallbackServerContext
Definition: server_context.h:618
grpc::ClientContext::set_deadline
void set_deadline(const T &deadline)
Set the deadline for the client call.
Definition: client_context.h:274
grpc_compression_algorithm
grpc_compression_algorithm
The various compression algorithms supported by gRPC (not sorted by compression level)
Definition: compression_types.h:60
grpc::ClientContext::GlobalCallbacks::~GlobalCallbacks
virtual ~GlobalCallbacks()
Definition: client_context.h:400
grpc::internal::BlockingUnaryCallImpl
Definition: client_context.h:103
grpc::PropagationOptions
Options for ClientContext::FromServerContext specifying which traits from the ServerContext to propag...
Definition: client_context.h:129
propagation_bits.h
grpc::ServerContextBase
Base class of ServerContext.
Definition: server_context.h:124
grpc::ClientContext::GlobalCallbacks::DefaultConstructor
virtual void DefaultConstructor(ClientContext *context)=0
grpc::ClientContext::peer
std::string peer() const
Return the peer uri in a string.
grpc::ClientContext::GetServerInitialMetadata
const std::multimap< grpc::string_ref, grpc::string_ref > & GetServerInitialMetadata() const
Return a collection of initial metadata key-value pairs.
Definition: client_context.h:250
status.h
rpc_method.h
grpc::ClientContext::raw_deadline
gpr_timespec raw_deadline() const
Return a gpr_timespec representation of the client call's deadline.
Definition: client_context.h:299
grpc::PropagationOptions::PropagationOptions
PropagationOptions()
Definition: client_context.h:131
grpc::PropagationOptions::disable_census_stats_propagation
PropagationOptions & disable_census_stats_propagation()
Definition: client_context.h:148
grpc::ClientContext::set_census_context
void set_census_context(struct census_context *ccp)
Sets the census context.
Definition: client_context.h:375
grpc::ClientContext::AddMetadata
void AddMetadata(const std::string &meta_key, const std::string &meta_value)
Add the (meta_key, meta_value) pair to the metadata associated with a client call.
create_auth_context.h
grpc::PropagationOptions::disable_census_tracing_propagation
PropagationOptions & disable_census_tracing_propagation()
Definition: client_context.h:158
grpc::internal::MetadataMap
Definition: metadata_map.h:34
grpc::ClientContext::GetServerTrailingMetadata
const std::multimap< grpc::string_ref, grpc::string_ref > & GetServerTrailingMetadata() const
Return a collection of trailing metadata key-value pairs.
Definition: client_context.h:262
grpc::experimental::ClientRpcInfo
Definition: client_interceptor.h:72
grpc::internal::MetadataMap::map
std::multimap< grpc::string_ref, grpc::string_ref > * map()
Definition: metadata_map.h:67
client_interceptor.h
grpc::CallCredentials
A call credentials object encapsulates the state needed by a client to authenticate with a server for...
Definition: credentials.h:115
GRPC_INITIAL_METADATA_WAIT_FOR_READY
#define GRPC_INITIAL_METADATA_WAIT_FOR_READY
Initial metadata flags.
Definition: grpc_types.h:199
grpc::ClientReader
Synchronous (blocking) client-side API for doing server-streaming RPCs, where the stream of messages ...
Definition: client_context.h:81
grpc::CreateAuthContext
std::shared_ptr< const AuthContext > CreateAuthContext(grpc_call *call)
TODO(ctiller): not sure we want to make this a permanent thing.
log.h
GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET
#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:202
grpc::ClientContext
A ClientContext allows the person implementing a service client to:
Definition: client_context.h:195
grpc::PropagationOptions::disable_deadline_propagation
PropagationOptions & disable_deadline_propagation()
Definition: client_context.h:138
grpc::ClientAsyncResponseReader
Async API for client-side unary RPCs, where the message response received from the server is of type ...
Definition: client_context.h:93
grpc_call
struct grpc_call grpc_call
A Call represents an RPC.
Definition: grpc_types.h:69
grpc::ClientContext::TryCancel
void TryCancel()
Send a best-effort out-of-band cancel on the call associated with this client context.
grpc::ClientContext::ClientContextTestPeer
friend class grpc::testing::ClientContextTestPeer
Definition: client_context.h:423
grpc::internal::CallbackUnaryCallImpl
Definition: client_context.h:68
grpc::TimePoint::raw_time
gpr_timespec raw_time()=delete
GRPC_PROPAGATE_CENSUS_STATS_CONTEXT
#define GRPC_PROPAGATE_CENSUS_STATS_CONTEXT
Propagate census context.
Definition: propagation_bits.h:35
grpc::ClientAsyncReader
Async client-side API for doing server-streaming RPCs, where the incoming message stream coming from ...
Definition: client_context.h:87
grpc::ClientContext::InteropClientContextInspector
friend class grpc::testing::InteropClientContextInspector
Definition: client_context.h:422
grpc::ChannelInterface
Codegen interface for grpc::Channel.
Definition: channel_interface.h:71
grpc::ClientContext::SetGlobalCallbacks
static void SetGlobalCallbacks(GlobalCallbacks *callbacks)
grpc::internal::ClientAsyncResponseReaderHelper
Definition: async_unary_call.h:80
grpc::internal::ClientCallbackWriterImpl
Definition: client_context.h:74
grpc::ClientContext::deadline
std::chrono::system_clock::time_point deadline() const
Return the deadline for the client call.
Definition: client_context.h:294
grpc::internal::RpcMethod::RpcType
RpcType
Definition: rpc_method.h:31
grpc::PropagationOptions::enable_cancellation_propagation
PropagationOptions & enable_cancellation_propagation()
Definition: client_context.h:163
grpc::PropagationOptions::enable_deadline_propagation
PropagationOptions & enable_deadline_propagation()
Definition: client_context.h:133
grpc::ClientContext::ClientContextAccessor
friend class grpc::internal::ClientContextAccessor
Definition: client_context.h:453
compression_types.h
grpc::ClientAsyncWriter
Async API on the client side for doing client-streaming RPCs, where the outgoing message stream going...
Definition: client_context.h:89
grpc::ClientContext::set_fail_fast
void set_fail_fast(bool fail_fast)
DEPRECATED: Use set_wait_for_ready() instead.
Definition: client_context.h:291
GRPC_PROPAGATE_DEFAULTS
#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:45
grpc::PropagationOptions::c_bitmask
uint32_t c_bitmask() const
Definition: client_context.h:173
grpc::ClientAsyncReaderWriter
Async client-side interface for bi-directional streaming, where the outgoing message stream going to ...
Definition: client_context.h:91
grpc::PropagationOptions::enable_census_tracing_propagation
PropagationOptions & enable_census_tracing_propagation()
Definition: client_context.h:153
config.h
grpc::experimental::ClientInterceptorFactoryInterface
Definition: client_interceptor.h:49
grpc::ClientContext::set_initial_metadata_corked
void set_initial_metadata_corked(bool corked)
Flag whether the initial metadata should be corked.
Definition: client_context.h:357
GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT
#define GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT
Definition: propagation_bits.h:36
grpc::ClientReaderWriter
Synchronous (blocking) client-side API for bi-directional streaming RPCs, where the outgoing message ...
Definition: client_context.h:85
grpc::ClientContext::GlobalCallbacks
Global Callbacks.
Definition: client_context.h:398
grpc::ClientContext::FromCallbackServerContext
static std::unique_ptr< ClientContext > FromCallbackServerContext(const grpc::CallbackServerContext &server_context, PropagationOptions options=PropagationOptions())
grpc::internal::CallOpClientRecvStatus
Definition: call_op_set.h:771
grpc::CompletionQueue
A thin wrapper around grpc_completion_queue (see src/core/lib/surface/completion_queue....
Definition: completion_queue.h:105
grpc::Channel
Channels represent a connection to an endpoint. Created by CreateChannel.
Definition: channel.h:54
grpc::internal::ClientCallbackReaderImpl
Definition: client_context.h:72
grpc::ClientContext::auth_context
std::shared_ptr< const grpc::AuthContext > auth_context() const
Return the authentication context for the associated client call.
Definition: client_context.h:309
grpc::PropagationOptions::enable_census_stats_propagation
PropagationOptions & enable_census_stats_propagation()
Definition: client_context.h:143
grpc::internal::Mutex
Definition: sync.h:58
grpc::PropagationOptions::disable_cancellation_propagation
PropagationOptions & disable_cancellation_propagation()
Definition: client_context.h:168
GRPC_PROPAGATE_DEADLINE
#define GRPC_PROPAGATE_DEADLINE
Propagation bits: this can be bitwise or-ed to form propagation_mask for grpc_call.
Definition: propagation_bits.h:33
gpr_timespec
Analogous to struct timespec.
Definition: time.h:48
grpc::ClientContext::ClientContext
ClientContext()
slice.h
auth_context.h
grpc::ClientContext::credentials
std::shared_ptr< grpc::CallCredentials > credentials()
EXPERIMENTAL debugging API.
Definition: client_context.h:333
sync.h
grpc::ClientContext::set_authority
void set_authority(const std::string &authority)
Set the per call authority header (see https://tools.ietf.org/html/rfc7540#section-8....
Definition: client_context.h:303
grpc::ClientContext::debug_error_string
std::string debug_error_string() const
EXPERIMENTAL debugging API.
Definition: client_context.h:415
grpc::ClientContext::census_context
struct census_context * census_context() const
Returns the census context that has been set, or nullptr if not set.
Definition: client_context.h:378
grpc::Timespec2Timepoint
std::chrono::system_clock::time_point Timespec2Timepoint(gpr_timespec t)
string_ref.h
grpc::TimePoint
If you are trying to use CompletionQueue::AsyncNext with a time class that isn't either gpr_timespec ...
Definition: time.h:40
grpc::ClientContext::c_call
grpc_call * c_call()
Should be used for framework-level extensions only.
Definition: client_context.h:408
metadata_map.h
grpc::ClientContext::set_compression_algorithm
void set_compression_algorithm(grpc_compression_algorithm algorithm)
Set algorithm to be the compression algorithm used for the client call.
GRPC_PROPAGATE_CANCELLATION
#define GRPC_PROPAGATE_CANCELLATION
Propagate cancellation.
Definition: propagation_bits.h:38