GRPC C++  1.50.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_IMPL_CODEGEN_CLIENT_CONTEXT_H
35 #define GRPCPP_IMPL_CODEGEN_CLIENT_CONTEXT_H
36 
37 // IWYU pragma: private, include <grpcpp/client_context.h>
38 
39 #include <map>
40 #include <memory>
41 #include <string>
42 
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>
68 class CallbackUnaryCallImpl;
69 template <class Request, class Response>
70 class ClientCallbackReaderWriterImpl;
71 template <class Response>
72 class ClientCallbackReaderImpl;
73 template <class Request>
74 class ClientCallbackWriterImpl;
75 class ClientCallbackUnaryImpl;
76 class ClientContextAccessor;
77 class ClientAsyncResponseReaderHelper;
78 } // namespace internal
79 
80 template <class R>
81 class ClientReader;
82 template <class W>
83 class ClientWriter;
84 template <class W, class R>
85 class ClientReaderWriter;
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>
103 class BlockingUnaryCallImpl;
104 class CallOpClientRecvStatus;
105 class CallOpRecvInitialMetadata;
106 class ServerContextImpl;
107 template <class InputMessage, class OutputMessage>
108 class CallbackUnaryCallImpl;
109 template <class Request, class Response>
110 class ClientCallbackReaderWriterImpl;
111 template <class Response>
112 class ClientCallbackReaderImpl;
113 template <class Request>
114 class ClientCallbackWriterImpl;
115 class ClientCallbackUnaryImpl;
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 
229 
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  GPR_CODEGEN_ASSERT(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 {
379  return census_context_;
380  }
381 
391  void TryCancel();
392 
398  public:
399  virtual ~GlobalCallbacks() {}
400  virtual void DefaultConstructor(ClientContext* context) = 0;
401  virtual void Destructor(ClientContext* context) = 0;
402  };
403  static void SetGlobalCallbacks(GlobalCallbacks* callbacks);
404 
407  grpc_call* c_call() { return call_; }
408 
414  std::string debug_error_string() const { return debug_error_string_; }
415 
416  private:
417  // Disallow copy and assign.
419  ClientContext& operator=(const ClientContext&);
420 
425  friend class grpc::Channel;
426  template <class R>
427  friend class grpc::ClientReader;
428  template <class W>
429  friend class grpc::ClientWriter;
430  template <class W, class R>
432  template <class R>
434  template <class W>
436  template <class W, class R>
438  template <class R>
441  template <class InputMessage, class OutputMessage>
443  template <class InputMessage, class OutputMessage>
445  template <class Request, class Response>
447  template <class Response>
449  template <class Request>
453 
454  // Used by friend class CallOpClientRecvStatus
455  void set_debug_error_string(const std::string& debug_error_string) {
456  debug_error_string_ = debug_error_string;
457  }
458 
459  grpc_call* call() const { return call_; }
460  void set_call(grpc_call* call, const std::shared_ptr<grpc::Channel>& channel);
461 
462  grpc::experimental::ClientRpcInfo* set_client_rpc_info(
463  const char* method, const char* suffix_for_stats,
465  const std::vector<std::unique_ptr<
467  size_t interceptor_pos) {
468  rpc_info_ = grpc::experimental::ClientRpcInfo(this, type, method,
469  suffix_for_stats, channel);
470  rpc_info_.RegisterInterceptors(creators, interceptor_pos);
471  return &rpc_info_;
472  }
473 
474  uint32_t initial_metadata_flags() const {
475  return (wait_for_ready_ ? GRPC_INITIAL_METADATA_WAIT_FOR_READY : 0) |
476  (wait_for_ready_explicitly_set_
478  : 0);
479  }
480 
481  std::string authority() { return authority_; }
482 
483  void SendCancelToInterceptors();
484 
485  static std::unique_ptr<ClientContext> FromInternalServerContext(
486  const grpc::ServerContextBase& server_context,
487  PropagationOptions options);
488 
489  bool initial_metadata_received_;
490  bool wait_for_ready_;
491  bool wait_for_ready_explicitly_set_;
492  std::shared_ptr<grpc::Channel> channel_;
494  grpc_call* call_;
495  bool call_canceled_;
496  gpr_timespec deadline_;
497  grpc::string authority_;
498  std::shared_ptr<grpc::CallCredentials> creds_;
499  mutable std::shared_ptr<const grpc::AuthContext> auth_context_;
500  struct census_context* census_context_;
501  std::multimap<std::string, std::string> send_initial_metadata_;
502  mutable grpc::internal::MetadataMap recv_initial_metadata_;
503  mutable grpc::internal::MetadataMap trailing_metadata_;
504 
505  grpc_call* propagate_from_call_;
506  PropagationOptions propagation_options_;
507 
508  grpc_compression_algorithm compression_algorithm_;
509  bool initial_metadata_corked_;
510 
511  std::string debug_error_string_;
512 
514 };
515 
516 } // namespace grpc
517 
518 #endif // GRPCPP_IMPL_CODEGEN_CLIENT_CONTEXT_H
grpc::internal::ClientCallbackUnaryImpl
Definition: client_callback.h:1113
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:34
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 (.
grpc::internal::CallOpRecvInitialMetadata
Definition: call_op_set.h:728
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_callback.h:469
grpc::ClientWriter
Synchronous (blocking) client-side API for doing client-streaming RPCs, where the outgoing message st...
Definition: channel_interface.h:33
time.h
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
status.h
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:606
grpc::ClientContext::set_deadline
void set_deadline(const T &deadline)
Set the deadline for the client call.
Definition: client_context.h:274
config.h
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:399
grpc::internal::BlockingUnaryCallImpl
Definition: channel_interface.h:69
grpc::PropagationOptions
Options for ClientContext::FromServerContext specifying which traits from the ServerContext to propag...
Definition: client_context.h:129
propagation_bits.h
auth_context.h
grpc::ServerContextBase
Base class of ServerContext.
Definition: server_context.h:126
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
core_codegen_interface.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.
grpc::PropagationOptions::disable_census_tracing_propagation
PropagationOptions & disable_census_tracing_propagation()
Definition: client_context.h:158
grpc::internal::MetadataMap
Definition: metadata_map.h:35
metadata_map.h
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:66
grpc::internal::MetadataMap::map
std::multimap< grpc::string_ref, grpc::string_ref > * map()
Definition: metadata_map.h:68
GRPC_INITIAL_METADATA_WAIT_FOR_READY
#define GRPC_INITIAL_METADATA_WAIT_FOR_READY
Initial metadata flags.
Definition: grpc_types.h:529
grpc::ClientReader
Synchronous (blocking) client-side API for doing server-streaming RPCs, where the stream of messages ...
Definition: channel_interface.h:31
grpc::CreateAuthContext
std::shared_ptr< const AuthContext > CreateAuthContext(grpc_call *call)
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:532
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:70
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:422
grpc::internal::CallbackUnaryCallImpl
Definition: channel_interface.h:38
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:421
grpc::ChannelInterface
Codegen interface for grpc::Channel.
Definition: channel_interface.h:73
grpc::ClientContext::SetGlobalCallbacks
static void SetGlobalCallbacks(GlobalCallbacks *callbacks)
grpc::internal::ClientAsyncResponseReaderHelper
Definition: async_unary_call.h:78
sync.h
grpc::internal::ClientCallbackWriterImpl
Definition: client_callback.h:885
rpc_method.h
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:33
grpc::PropagationOptions::enable_cancellation_propagation
PropagationOptions & enable_cancellation_propagation()
Definition: client_context.h:163
client_interceptor.h
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:452
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
string_ref.h
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
grpc::experimental::ClientInterceptorFactoryInterface
Definition: client_interceptor.h:46
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: channel_interface.h:35
grpc::ClientContext::GlobalCallbacks
Global Callbacks.
Definition: client_context.h:397
grpc::ClientContext::FromCallbackServerContext
static std::unique_ptr< ClientContext > FromCallbackServerContext(const grpc::CallbackServerContext &server_context, PropagationOptions options=PropagationOptions())
create_auth_context.h
grpc::internal::CallOpClientRecvStatus
Definition: call_op_set.h:776
grpc::Channel
Channels represent a connection to an endpoint. Created by CreateChannel.
Definition: channel.h:54
grpc::internal::ClientCallbackReaderImpl
Definition: client_callback.h:726
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
GPR_CODEGEN_ASSERT
#define GPR_CODEGEN_ASSERT(x)
Codegen specific version of GPR_ASSERT.
Definition: core_codegen_interface.h:151
grpc::PropagationOptions::enable_census_stats_propagation
PropagationOptions & enable_census_stats_propagation()
Definition: client_context.h:143
slice.h
grpc::internal::Mutex
Definition: sync.h:59
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: gpr_types.h:50
grpc::ClientContext::ClientContext
ClientContext()
grpc::ClientContext::credentials
std::shared_ptr< grpc::CallCredentials > credentials()
EXPERIMENTAL debugging API.
Definition: client_context.h:333
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:414
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)
grpc::TimePoint
If you are trying to use CompletionQueue::AsyncNext with a time class that isn't either gpr_timespec ...
Definition: time.h:42
grpc::ClientContext::c_call
grpc_call * c_call()
Should be used for framework-level extensions only.
Definition: client_context.h:407
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