diff --git a/doc/cpp/pending_api_cleanups.md b/doc/cpp/pending_api_cleanups.md index 5c231eda2c8..8684f21efce 100644 --- a/doc/cpp/pending_api_cleanups.md +++ b/doc/cpp/pending_api_cleanups.md @@ -14,7 +14,7 @@ number: - remove `ServerBuilder::SetMaxMessageSize()` method from `include/grpc++/server_builder.h` (commit `6980362`) - remove `ClientContext::set_fail_fast()` method from - `include/grpc++/impl/codegen/client_context.h` (commit `9477724`) + `include/grpc++/client_context.h` (commit `9477724`) - remove directory `include/grpc++` and all headers in it (commit `eb06572`) - make all `Request` and `Mark` methods in `grpc::Service` take a diff --git a/include/grpcpp/client_context.h b/include/grpcpp/client_context.h index 74a91e26421..ce1ab3f2189 100644 --- a/include/grpcpp/client_context.h +++ b/include/grpcpp/client_context.h @@ -34,6 +34,483 @@ #ifndef GRPCPP_CLIENT_CONTEXT_H #define GRPCPP_CLIENT_CONTEXT_H -#include // IWYU pragma: export +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct census_context; +struct grpc_call; + +namespace grpc { +class ServerContext; +class ServerContextBase; +class CallbackServerContext; + +namespace internal { +template +class CallbackUnaryCallImpl; +template +class ClientCallbackReaderWriterImpl; +template +class ClientCallbackReaderImpl; +template +class ClientCallbackWriterImpl; +class ClientCallbackUnaryImpl; +class ClientContextAccessor; +class ClientAsyncResponseReaderHelper; +} // namespace internal + +template +class ClientReader; +template +class ClientWriter; +template +class ClientReaderWriter; +template +class ClientAsyncReader; +template +class ClientAsyncWriter; +template +class ClientAsyncReaderWriter; +template +class ClientAsyncResponseReader; + +namespace testing { +class InteropClientContextInspector; +class ClientContextTestPeer; +} // namespace testing + +namespace internal { +class RpcMethod; +template +class BlockingUnaryCallImpl; +class CallOpClientRecvStatus; +class CallOpRecvInitialMetadata; +class ServerContextImpl; +template +class CallbackUnaryCallImpl; +template +class ClientCallbackReaderWriterImpl; +template +class ClientCallbackReaderImpl; +template +class ClientCallbackWriterImpl; +class ClientCallbackUnaryImpl; +class ClientContextAccessor; +} // namespace internal + +class CallCredentials; +class Channel; +class ChannelInterface; +class CompletionQueue; + +/// Options for \a ClientContext::FromServerContext specifying which traits from +/// the \a ServerContext to propagate (copy) from it into a new \a +/// ClientContext. +/// +/// \see ClientContext::FromServerContext +class PropagationOptions { + public: + PropagationOptions() : propagate_(GRPC_PROPAGATE_DEFAULTS) {} + + PropagationOptions& enable_deadline_propagation() { + propagate_ |= GRPC_PROPAGATE_DEADLINE; + return *this; + } + + PropagationOptions& disable_deadline_propagation() { + propagate_ &= ~GRPC_PROPAGATE_DEADLINE; + return *this; + } + + PropagationOptions& enable_census_stats_propagation() { + propagate_ |= GRPC_PROPAGATE_CENSUS_STATS_CONTEXT; + return *this; + } + + PropagationOptions& disable_census_stats_propagation() { + propagate_ &= ~GRPC_PROPAGATE_CENSUS_STATS_CONTEXT; + return *this; + } + + PropagationOptions& enable_census_tracing_propagation() { + propagate_ |= GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT; + return *this; + } + + PropagationOptions& disable_census_tracing_propagation() { + propagate_ &= ~GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT; + return *this; + } + + PropagationOptions& enable_cancellation_propagation() { + propagate_ |= GRPC_PROPAGATE_CANCELLATION; + return *this; + } + + PropagationOptions& disable_cancellation_propagation() { + propagate_ &= ~GRPC_PROPAGATE_CANCELLATION; + return *this; + } + + uint32_t c_bitmask() const { return propagate_; } + + private: + uint32_t propagate_; +}; + +/// A ClientContext allows the person implementing a service client to: +/// +/// - Add custom metadata key-value pairs that will propagated to the server +/// side. +/// - Control call settings such as compression and authentication. +/// - Initial and trailing metadata coming from the server. +/// - Get performance metrics (ie, census). +/// +/// Context settings are only relevant to the call they are invoked with, that +/// is to say, they aren't sticky. Some of these settings, such as the +/// compression options, can be made persistent at channel construction time +/// (see \a grpc::CreateCustomChannel). +/// +/// \warning ClientContext instances should \em not be reused across rpcs. +/// \warning The ClientContext instance used for creating an rpc must remain +/// alive and valid for the lifetime of the rpc. +class ClientContext { + public: + ClientContext(); + ~ClientContext(); + + /// Create a new \a ClientContext as a child of an incoming server call, + /// according to \a options (\see PropagationOptions). + /// + /// \param server_context The source server context to use as the basis for + /// constructing the client context. + /// \param options The options controlling what to copy from the \a + /// server_context. + /// + /// \return A newly constructed \a ClientContext instance based on \a + /// server_context, with traits propagated (copied) according to \a options. + static std::unique_ptr FromServerContext( + const grpc::ServerContextBase& server_context, + PropagationOptions options = PropagationOptions()); + static std::unique_ptr FromCallbackServerContext( + const grpc::CallbackServerContext& server_context, + PropagationOptions options = PropagationOptions()); + + /// Add the (\a meta_key, \a meta_value) pair to the metadata associated with + /// a client call. These are made available at the server side by the \a + /// grpc::ServerContext::client_metadata() method. + /// + /// \warning This method should only be called before invoking the rpc. + /// + /// \param meta_key The metadata key. If \a meta_value is binary data, it must + /// end in "-bin". + /// \param meta_value The metadata value. If its value is binary, the key name + /// must end in "-bin". + /// + /// Metadata must conform to the following format: + /** + \verbatim + Custom-Metadata -> Binary-Header / ASCII-Header + Binary-Header -> {Header-Name "-bin" } {binary value} + ASCII-Header -> Header-Name ASCII-Value + Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - . + ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII + Custom-Metadata -> Binary-Header / ASCII-Header + \endverbatim + **/ + void AddMetadata(const std::string& meta_key, const std::string& meta_value); + + /// Return a collection of initial metadata key-value pairs. Note that keys + /// may happen more than once (ie, a \a std::multimap is returned). + /// + /// \warning This method should only be called after initial metadata has been + /// received. For streaming calls, see \a + /// ClientReaderInterface::WaitForInitialMetadata(). + /// + /// \return A multimap of initial metadata key-value pairs from the server. + const std::multimap& + GetServerInitialMetadata() const { + GPR_CODEGEN_ASSERT(initial_metadata_received_); + return *recv_initial_metadata_.map(); + } + + /// Return a collection of trailing metadata key-value pairs. Note that keys + /// may happen more than once (ie, a \a std::multimap is returned). + /// + /// \warning This method is only callable once the stream has finished. + /// + /// \return A multimap of metadata trailing key-value pairs from the server. + const std::multimap& + GetServerTrailingMetadata() const { + // TODO(yangg) check finished + return *trailing_metadata_.map(); + } + + /// Set the deadline for the client call. + /// + /// \warning This method should only be called before invoking the rpc. + /// + /// \param deadline the deadline for the client call. Units are determined by + /// the type used. The deadline is an absolute (not relative) time. + template + void set_deadline(const T& deadline) { + grpc::TimePoint deadline_tp(deadline); + deadline_ = deadline_tp.raw_time(); + } + + /// Trigger wait-for-ready or not on this request. + /// See https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md. + /// If set, if an RPC is made when a channel's connectivity state is + /// TRANSIENT_FAILURE or CONNECTING, the call will not "fail fast", + /// and the channel will wait until the channel is READY before making the + /// call. + void set_wait_for_ready(bool wait_for_ready) { + wait_for_ready_ = wait_for_ready; + wait_for_ready_explicitly_set_ = true; + } + + /// DEPRECATED: Use set_wait_for_ready() instead. + void set_fail_fast(bool fail_fast) { set_wait_for_ready(!fail_fast); } + + /// Return the deadline for the client call. + std::chrono::system_clock::time_point deadline() const { + return grpc::Timespec2Timepoint(deadline_); + } + + /// Return a \a gpr_timespec representation of the client call's deadline. + gpr_timespec raw_deadline() const { return deadline_; } + + /// Set the per call authority header (see + /// https://tools.ietf.org/html/rfc7540#section-8.1.2.3). + void set_authority(const std::string& authority) { authority_ = authority; } + + /// Return the authentication context for the associated client call. + /// It is only valid to call this during the lifetime of the client call. + /// + /// \see grpc::AuthContext. + std::shared_ptr auth_context() const { + if (auth_context_ == nullptr) { + auth_context_ = grpc::CreateAuthContext(call_); + } + return auth_context_; + } + + /// Set credentials for the client call. + /// + /// A credentials object encapsulates all the state needed by a client to + /// authenticate with a server and make various assertions, e.g., about the + /// client’s identity, role, or whether it is authorized to make a particular + /// call. + /// + /// It is legal to call this only before initial metadata is sent. + /// + /// \see https://grpc.io/docs/guides/auth.html + void set_credentials(const std::shared_ptr& creds); + + /// EXPERIMENTAL debugging API + /// + /// Returns the credentials for the client call. This should be used only in + /// tests and for diagnostic purposes, and should not be used by application + /// logic. + std::shared_ptr credentials() { return creds_; } + + /// Return the compression algorithm the client call will request be used. + /// Note that the gRPC runtime may decide to ignore this request, for example, + /// due to resource constraints. + grpc_compression_algorithm compression_algorithm() const { + return compression_algorithm_; + } + + /// Set \a algorithm to be the compression algorithm used for the client call. + /// + /// \param algorithm The compression algorithm used for the client call. + void set_compression_algorithm(grpc_compression_algorithm algorithm); + + /// Flag whether the initial metadata should be \a corked + /// + /// If \a corked is true, then the initial metadata will be coalesced with the + /// write of first message in the stream. As a result, any tag set for the + /// initial metadata operation (starting a client-streaming or bidi-streaming + /// RPC) will not actually be sent to the completion queue or delivered + /// via Next. + /// + /// \param corked The flag indicating whether the initial metadata is to be + /// corked or not. + void set_initial_metadata_corked(bool corked) { + initial_metadata_corked_ = corked; + } + + /// Return the peer uri in a string. + /// It is only valid to call this during the lifetime of the client call. + /// + /// \warning This value is never authenticated or subject to any security + /// related code. It must not be used for any authentication related + /// functionality. Instead, use auth_context. + /// + /// \return The call's peer URI. + std::string peer() const; + + /// Sets the census context. + /// It is only valid to call this before the client call is created. A common + /// place of setting census context is from within the DefaultConstructor + /// method of GlobalCallbacks. + void set_census_context(struct census_context* ccp) { census_context_ = ccp; } + + /// Returns the census context that has been set, or nullptr if not set. + struct census_context* census_context() const { + return census_context_; + } + + /// Send a best-effort out-of-band cancel on the call associated with + /// this client context. The call could be in any stage; e.g., if it is + /// already finished, it may still return success. + /// + /// There is no guarantee the call will be cancelled. + /// + /// Note that TryCancel() does not change any of the tags that are pending + /// on the completion queue. All pending tags will still be delivered + /// (though their ok result may reflect the effect of cancellation). + void TryCancel(); + + /// Global Callbacks + /// + /// Can be set exactly once per application to install hooks whenever + /// a client context is constructed and destructed. + class GlobalCallbacks { + public: + virtual ~GlobalCallbacks() {} + virtual void DefaultConstructor(ClientContext* context) = 0; + virtual void Destructor(ClientContext* context) = 0; + }; + static void SetGlobalCallbacks(GlobalCallbacks* callbacks); + + /// Should be used for framework-level extensions only. + /// Applications never need to call this method. + grpc_call* c_call() { return call_; } + + /// EXPERIMENTAL debugging API + /// + /// if status is not ok() for an RPC, this will return a detailed string + /// of the gRPC Core error that led to the failure. It should not be relied + /// upon for anything other than gaining more debug data in failure cases. + std::string debug_error_string() const { return debug_error_string_; } + + private: + // Disallow copy and assign. + ClientContext(const ClientContext&); + ClientContext& operator=(const ClientContext&); + + friend class grpc::testing::InteropClientContextInspector; + friend class grpc::testing::ClientContextTestPeer; + friend class grpc::internal::CallOpClientRecvStatus; + friend class grpc::internal::CallOpRecvInitialMetadata; + friend class grpc::Channel; + template + friend class grpc::ClientReader; + template + friend class grpc::ClientWriter; + template + friend class grpc::ClientReaderWriter; + template + friend class grpc::ClientAsyncReader; + template + friend class grpc::ClientAsyncWriter; + template + friend class grpc::ClientAsyncReaderWriter; + template + friend class grpc::ClientAsyncResponseReader; + friend class grpc::internal::ClientAsyncResponseReaderHelper; + template + friend class grpc::internal::BlockingUnaryCallImpl; + template + friend class grpc::internal::CallbackUnaryCallImpl; + template + friend class grpc::internal::ClientCallbackReaderWriterImpl; + template + friend class grpc::internal::ClientCallbackReaderImpl; + template + friend class grpc::internal::ClientCallbackWriterImpl; + friend class grpc::internal::ClientCallbackUnaryImpl; + friend class grpc::internal::ClientContextAccessor; + + // Used by friend class CallOpClientRecvStatus + void set_debug_error_string(const std::string& debug_error_string) { + debug_error_string_ = debug_error_string; + } + + grpc_call* call() const { return call_; } + void set_call(grpc_call* call, const std::shared_ptr& channel); + + grpc::experimental::ClientRpcInfo* set_client_rpc_info( + const char* method, const char* suffix_for_stats, + grpc::internal::RpcMethod::RpcType type, grpc::ChannelInterface* channel, + const std::vector>& creators, + size_t interceptor_pos) { + rpc_info_ = grpc::experimental::ClientRpcInfo(this, type, method, + suffix_for_stats, channel); + rpc_info_.RegisterInterceptors(creators, interceptor_pos); + return &rpc_info_; + } + + uint32_t initial_metadata_flags() const { + return (wait_for_ready_ ? GRPC_INITIAL_METADATA_WAIT_FOR_READY : 0) | + (wait_for_ready_explicitly_set_ + ? GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET + : 0); + } + + std::string authority() { return authority_; } + + void SendCancelToInterceptors(); + + static std::unique_ptr FromInternalServerContext( + const grpc::ServerContextBase& server_context, + PropagationOptions options); + + bool initial_metadata_received_; + bool wait_for_ready_; + bool wait_for_ready_explicitly_set_; + std::shared_ptr channel_; + grpc::internal::Mutex mu_; + grpc_call* call_; + bool call_canceled_; + gpr_timespec deadline_; + grpc::string authority_; + std::shared_ptr creds_; + mutable std::shared_ptr auth_context_; + struct census_context* census_context_; + std::multimap send_initial_metadata_; + mutable grpc::internal::MetadataMap recv_initial_metadata_; + mutable grpc::internal::MetadataMap trailing_metadata_; + + grpc_call* propagate_from_call_; + PropagationOptions propagation_options_; + + grpc_compression_algorithm compression_algorithm_; + bool initial_metadata_corked_; + + std::string debug_error_string_; + + grpc::experimental::ClientRpcInfo rpc_info_; +}; + +} // namespace grpc #endif // GRPCPP_CLIENT_CONTEXT_H diff --git a/include/grpcpp/impl/codegen/client_context.h b/include/grpcpp/impl/codegen/client_context.h index 172546c5df8..c3818abf561 100644 --- a/include/grpcpp/impl/codegen/client_context.h +++ b/include/grpcpp/impl/codegen/client_context.h @@ -16,503 +16,12 @@ * */ -/// A ClientContext allows the person implementing a service client to: -/// -/// - Add custom metadata key-value pairs that will propagated to the server -/// side. -/// - Control call settings such as compression and authentication. -/// - Initial and trailing metadata coming from the server. -/// - Get performance metrics (ie, census). -/// -/// Context settings are only relevant to the call they are invoked with, that -/// is to say, they aren't sticky. Some of these settings, such as the -/// compression options, can be made persistent at channel construction time -/// (see \a grpc::CreateCustomChannel). -/// -/// \warning ClientContext instances should \em not be reused across rpcs. - #ifndef GRPCPP_IMPL_CODEGEN_CLIENT_CONTEXT_H #define GRPCPP_IMPL_CODEGEN_CLIENT_CONTEXT_H -// IWYU pragma: private, include - -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -struct census_context; -struct grpc_call; - -namespace grpc { -class ServerContext; -class ServerContextBase; -class CallbackServerContext; - -namespace internal { -template -class CallbackUnaryCallImpl; -template -class ClientCallbackReaderWriterImpl; -template -class ClientCallbackReaderImpl; -template -class ClientCallbackWriterImpl; -class ClientCallbackUnaryImpl; -class ClientContextAccessor; -class ClientAsyncResponseReaderHelper; -} // namespace internal - -template -class ClientReader; -template -class ClientWriter; -template -class ClientReaderWriter; -template -class ClientAsyncReader; -template -class ClientAsyncWriter; -template -class ClientAsyncReaderWriter; -template -class ClientAsyncResponseReader; - -namespace testing { -class InteropClientContextInspector; -class ClientContextTestPeer; -} // namespace testing - -namespace internal { -class RpcMethod; -template -class BlockingUnaryCallImpl; -class CallOpClientRecvStatus; -class CallOpRecvInitialMetadata; -class ServerContextImpl; -template -class CallbackUnaryCallImpl; -template -class ClientCallbackReaderWriterImpl; -template -class ClientCallbackReaderImpl; -template -class ClientCallbackWriterImpl; -class ClientCallbackUnaryImpl; -class ClientContextAccessor; -} // namespace internal - -class CallCredentials; -class Channel; -class ChannelInterface; -class CompletionQueue; - -/// Options for \a ClientContext::FromServerContext specifying which traits from -/// the \a ServerContext to propagate (copy) from it into a new \a -/// ClientContext. -/// -/// \see ClientContext::FromServerContext -class PropagationOptions { - public: - PropagationOptions() : propagate_(GRPC_PROPAGATE_DEFAULTS) {} - - PropagationOptions& enable_deadline_propagation() { - propagate_ |= GRPC_PROPAGATE_DEADLINE; - return *this; - } - - PropagationOptions& disable_deadline_propagation() { - propagate_ &= ~GRPC_PROPAGATE_DEADLINE; - return *this; - } - - PropagationOptions& enable_census_stats_propagation() { - propagate_ |= GRPC_PROPAGATE_CENSUS_STATS_CONTEXT; - return *this; - } - - PropagationOptions& disable_census_stats_propagation() { - propagate_ &= ~GRPC_PROPAGATE_CENSUS_STATS_CONTEXT; - return *this; - } - - PropagationOptions& enable_census_tracing_propagation() { - propagate_ |= GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT; - return *this; - } - - PropagationOptions& disable_census_tracing_propagation() { - propagate_ &= ~GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT; - return *this; - } - - PropagationOptions& enable_cancellation_propagation() { - propagate_ |= GRPC_PROPAGATE_CANCELLATION; - return *this; - } - - PropagationOptions& disable_cancellation_propagation() { - propagate_ &= ~GRPC_PROPAGATE_CANCELLATION; - return *this; - } - - uint32_t c_bitmask() const { return propagate_; } - - private: - uint32_t propagate_; -}; - -/// A ClientContext allows the person implementing a service client to: -/// -/// - Add custom metadata key-value pairs that will propagated to the server -/// side. -/// - Control call settings such as compression and authentication. -/// - Initial and trailing metadata coming from the server. -/// - Get performance metrics (ie, census). -/// -/// Context settings are only relevant to the call they are invoked with, that -/// is to say, they aren't sticky. Some of these settings, such as the -/// compression options, can be made persistent at channel construction time -/// (see \a grpc::CreateCustomChannel). -/// -/// \warning ClientContext instances should \em not be reused across rpcs. -/// \warning The ClientContext instance used for creating an rpc must remain -/// alive and valid for the lifetime of the rpc. -class ClientContext { - public: - ClientContext(); - ~ClientContext(); - - /// Create a new \a ClientContext as a child of an incoming server call, - /// according to \a options (\see PropagationOptions). - /// - /// \param server_context The source server context to use as the basis for - /// constructing the client context. - /// \param options The options controlling what to copy from the \a - /// server_context. - /// - /// \return A newly constructed \a ClientContext instance based on \a - /// server_context, with traits propagated (copied) according to \a options. - static std::unique_ptr FromServerContext( - const grpc::ServerContextBase& server_context, - PropagationOptions options = PropagationOptions()); - static std::unique_ptr FromCallbackServerContext( - const grpc::CallbackServerContext& server_context, - PropagationOptions options = PropagationOptions()); - - /// Add the (\a meta_key, \a meta_value) pair to the metadata associated with - /// a client call. These are made available at the server side by the \a - /// grpc::ServerContext::client_metadata() method. - /// - /// \warning This method should only be called before invoking the rpc. - /// - /// \param meta_key The metadata key. If \a meta_value is binary data, it must - /// end in "-bin". - /// \param meta_value The metadata value. If its value is binary, the key name - /// must end in "-bin". - /// - /// Metadata must conform to the following format: - /** - \verbatim - Custom-Metadata -> Binary-Header / ASCII-Header - Binary-Header -> {Header-Name "-bin" } {binary value} - ASCII-Header -> Header-Name ASCII-Value - Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - . - ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII - Custom-Metadata -> Binary-Header / ASCII-Header - \endverbatim - **/ - void AddMetadata(const std::string& meta_key, const std::string& meta_value); - - /// Return a collection of initial metadata key-value pairs. Note that keys - /// may happen more than once (ie, a \a std::multimap is returned). - /// - /// \warning This method should only be called after initial metadata has been - /// received. For streaming calls, see \a - /// ClientReaderInterface::WaitForInitialMetadata(). - /// - /// \return A multimap of initial metadata key-value pairs from the server. - const std::multimap& - GetServerInitialMetadata() const { - GPR_CODEGEN_ASSERT(initial_metadata_received_); - return *recv_initial_metadata_.map(); - } - - /// Return a collection of trailing metadata key-value pairs. Note that keys - /// may happen more than once (ie, a \a std::multimap is returned). - /// - /// \warning This method is only callable once the stream has finished. - /// - /// \return A multimap of metadata trailing key-value pairs from the server. - const std::multimap& - GetServerTrailingMetadata() const { - // TODO(yangg) check finished - return *trailing_metadata_.map(); - } - - /// Set the deadline for the client call. - /// - /// \warning This method should only be called before invoking the rpc. - /// - /// \param deadline the deadline for the client call. Units are determined by - /// the type used. The deadline is an absolute (not relative) time. - template - void set_deadline(const T& deadline) { - grpc::TimePoint deadline_tp(deadline); - deadline_ = deadline_tp.raw_time(); - } - - /// Trigger wait-for-ready or not on this request. - /// See https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md. - /// If set, if an RPC is made when a channel's connectivity state is - /// TRANSIENT_FAILURE or CONNECTING, the call will not "fail fast", - /// and the channel will wait until the channel is READY before making the - /// call. - void set_wait_for_ready(bool wait_for_ready) { - wait_for_ready_ = wait_for_ready; - wait_for_ready_explicitly_set_ = true; - } - - /// DEPRECATED: Use set_wait_for_ready() instead. - void set_fail_fast(bool fail_fast) { set_wait_for_ready(!fail_fast); } - - /// Return the deadline for the client call. - std::chrono::system_clock::time_point deadline() const { - return grpc::Timespec2Timepoint(deadline_); - } - - /// Return a \a gpr_timespec representation of the client call's deadline. - gpr_timespec raw_deadline() const { return deadline_; } - - /// Set the per call authority header (see - /// https://tools.ietf.org/html/rfc7540#section-8.1.2.3). - void set_authority(const std::string& authority) { authority_ = authority; } - - /// Return the authentication context for the associated client call. - /// It is only valid to call this during the lifetime of the client call. - /// - /// \see grpc::AuthContext. - std::shared_ptr auth_context() const { - if (auth_context_ == nullptr) { - auth_context_ = grpc::CreateAuthContext(call_); - } - return auth_context_; - } - - /// Set credentials for the client call. - /// - /// A credentials object encapsulates all the state needed by a client to - /// authenticate with a server and make various assertions, e.g., about the - /// client’s identity, role, or whether it is authorized to make a particular - /// call. - /// - /// It is legal to call this only before initial metadata is sent. - /// - /// \see https://grpc.io/docs/guides/auth.html - void set_credentials(const std::shared_ptr& creds); - - /// EXPERIMENTAL debugging API - /// - /// Returns the credentials for the client call. This should be used only in - /// tests and for diagnostic purposes, and should not be used by application - /// logic. - std::shared_ptr credentials() { return creds_; } - - /// Return the compression algorithm the client call will request be used. - /// Note that the gRPC runtime may decide to ignore this request, for example, - /// due to resource constraints. - grpc_compression_algorithm compression_algorithm() const { - return compression_algorithm_; - } - - /// Set \a algorithm to be the compression algorithm used for the client call. - /// - /// \param algorithm The compression algorithm used for the client call. - void set_compression_algorithm(grpc_compression_algorithm algorithm); - - /// Flag whether the initial metadata should be \a corked - /// - /// If \a corked is true, then the initial metadata will be coalesced with the - /// write of first message in the stream. As a result, any tag set for the - /// initial metadata operation (starting a client-streaming or bidi-streaming - /// RPC) will not actually be sent to the completion queue or delivered - /// via Next. - /// - /// \param corked The flag indicating whether the initial metadata is to be - /// corked or not. - void set_initial_metadata_corked(bool corked) { - initial_metadata_corked_ = corked; - } - - /// Return the peer uri in a string. - /// It is only valid to call this during the lifetime of the client call. - /// - /// \warning This value is never authenticated or subject to any security - /// related code. It must not be used for any authentication related - /// functionality. Instead, use auth_context. - /// - /// \return The call's peer URI. - std::string peer() const; - - /// Sets the census context. - /// It is only valid to call this before the client call is created. A common - /// place of setting census context is from within the DefaultConstructor - /// method of GlobalCallbacks. - void set_census_context(struct census_context* ccp) { census_context_ = ccp; } - - /// Returns the census context that has been set, or nullptr if not set. - struct census_context* census_context() const { - return census_context_; - } - - /// Send a best-effort out-of-band cancel on the call associated with - /// this client context. The call could be in any stage; e.g., if it is - /// already finished, it may still return success. - /// - /// There is no guarantee the call will be cancelled. - /// - /// Note that TryCancel() does not change any of the tags that are pending - /// on the completion queue. All pending tags will still be delivered - /// (though their ok result may reflect the effect of cancellation). - void TryCancel(); - - /// Global Callbacks - /// - /// Can be set exactly once per application to install hooks whenever - /// a client context is constructed and destructed. - class GlobalCallbacks { - public: - virtual ~GlobalCallbacks() {} - virtual void DefaultConstructor(ClientContext* context) = 0; - virtual void Destructor(ClientContext* context) = 0; - }; - static void SetGlobalCallbacks(GlobalCallbacks* callbacks); - - /// Should be used for framework-level extensions only. - /// Applications never need to call this method. - grpc_call* c_call() { return call_; } - - /// EXPERIMENTAL debugging API - /// - /// if status is not ok() for an RPC, this will return a detailed string - /// of the gRPC Core error that led to the failure. It should not be relied - /// upon for anything other than gaining more debug data in failure cases. - std::string debug_error_string() const { return debug_error_string_; } - - private: - // Disallow copy and assign. - ClientContext(const ClientContext&); - ClientContext& operator=(const ClientContext&); - - friend class grpc::testing::InteropClientContextInspector; - friend class grpc::testing::ClientContextTestPeer; - friend class grpc::internal::CallOpClientRecvStatus; - friend class grpc::internal::CallOpRecvInitialMetadata; - friend class grpc::Channel; - template - friend class grpc::ClientReader; - template - friend class grpc::ClientWriter; - template - friend class grpc::ClientReaderWriter; - template - friend class grpc::ClientAsyncReader; - template - friend class grpc::ClientAsyncWriter; - template - friend class grpc::ClientAsyncReaderWriter; - template - friend class grpc::ClientAsyncResponseReader; - friend class grpc::internal::ClientAsyncResponseReaderHelper; - template - friend class grpc::internal::BlockingUnaryCallImpl; - template - friend class grpc::internal::CallbackUnaryCallImpl; - template - friend class grpc::internal::ClientCallbackReaderWriterImpl; - template - friend class grpc::internal::ClientCallbackReaderImpl; - template - friend class grpc::internal::ClientCallbackWriterImpl; - friend class grpc::internal::ClientCallbackUnaryImpl; - friend class grpc::internal::ClientContextAccessor; - - // Used by friend class CallOpClientRecvStatus - void set_debug_error_string(const std::string& debug_error_string) { - debug_error_string_ = debug_error_string; - } - - grpc_call* call() const { return call_; } - void set_call(grpc_call* call, const std::shared_ptr& channel); - - grpc::experimental::ClientRpcInfo* set_client_rpc_info( - const char* method, const char* suffix_for_stats, - grpc::internal::RpcMethod::RpcType type, grpc::ChannelInterface* channel, - const std::vector>& creators, - size_t interceptor_pos) { - rpc_info_ = grpc::experimental::ClientRpcInfo(this, type, method, - suffix_for_stats, channel); - rpc_info_.RegisterInterceptors(creators, interceptor_pos); - return &rpc_info_; - } - - uint32_t initial_metadata_flags() const { - return (wait_for_ready_ ? GRPC_INITIAL_METADATA_WAIT_FOR_READY : 0) | - (wait_for_ready_explicitly_set_ - ? GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET - : 0); - } - - std::string authority() { return authority_; } - - void SendCancelToInterceptors(); - - static std::unique_ptr FromInternalServerContext( - const grpc::ServerContextBase& server_context, - PropagationOptions options); - - bool initial_metadata_received_; - bool wait_for_ready_; - bool wait_for_ready_explicitly_set_; - std::shared_ptr channel_; - grpc::internal::Mutex mu_; - grpc_call* call_; - bool call_canceled_; - gpr_timespec deadline_; - grpc::string authority_; - std::shared_ptr creds_; - mutable std::shared_ptr auth_context_; - struct census_context* census_context_; - std::multimap send_initial_metadata_; - mutable grpc::internal::MetadataMap recv_initial_metadata_; - mutable grpc::internal::MetadataMap trailing_metadata_; - - grpc_call* propagate_from_call_; - PropagationOptions propagation_options_; - - grpc_compression_algorithm compression_algorithm_; - bool initial_metadata_corked_; - - std::string debug_error_string_; - - grpc::experimental::ClientRpcInfo rpc_info_; -}; +// IWYU pragma: private -} // namespace grpc +/// TODO(chengyuc): Remove this file after solving compatibility. +#include #endif // GRPCPP_IMPL_CODEGEN_CLIENT_CONTEXT_H diff --git a/src/compiler/cpp_generator.cc b/src/compiler/cpp_generator.cc index db1fa207f70..00eb3c82f79 100644 --- a/src/compiler/cpp_generator.cc +++ b/src/compiler/cpp_generator.cc @@ -141,7 +141,7 @@ std::string GetHeaderIncludes(grpc_generator::File* file, "grpcpp/support/async_stream.h", "grpcpp/support/async_unary_call.h", "grpcpp/impl/codegen/client_callback.h", - "grpcpp/impl/codegen/client_context.h", + "grpcpp/client_context.h", "grpcpp/impl/codegen/completion_queue.h", "grpcpp/impl/codegen/message_allocator.h", "grpcpp/impl/codegen/method_handler.h", diff --git a/test/cpp/codegen/compiler_test_golden b/test/cpp/codegen/compiler_test_golden index 600201cfa7e..2927c4744fb 100644 --- a/test/cpp/codegen/compiler_test_golden +++ b/test/cpp/codegen/compiler_test_golden @@ -31,7 +31,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/test/cpp/ios/CronetTests/CppCronetEnd2EndTests.mm b/test/cpp/ios/CronetTests/CppCronetEnd2EndTests.mm index 1e582a14749..bf88191cfce 100644 --- a/test/cpp/ios/CronetTests/CppCronetEnd2EndTests.mm +++ b/test/cpp/ios/CronetTests/CppCronetEnd2EndTests.mm @@ -20,8 +20,8 @@ #import #import +#import #import -#import #import #import #import