talksik/tonic
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat(tonic): Use BoxBody from http-body crate (#622)

Browse Source 
As of `http-body` 0.4.1 its has had a `BoxBody` type similar to
`tonic::body::BoxBody`. It also has `Empty` and `Body::map_{data,err}`.

That means all the custom body things we had in tonic can basically be
replaced with that.

Note that this is a breaking change so we should merge this next time we
decide to ship a breaking release.

The breaking changes are:

- `tonic::body::Body` has been removed. I think its fine for users to
depend directly on `http-body` if they need this trait.
- `tonic::body::BoxBody` is now just a type alias for
`http_body::combinators::BoxBody<Bytes, Status>`. So the methods it
previously had are gone. The replacements are
  - `tonic::body::Body::new` -> `http_body::Body::boxed`
  - `tonic::body::Body::map_from` -> `http_body::Body::map_data` and
  `http_body::Body::map_err` depending on which part you want to map.
  - `tonic::body::Body::empty` -> `http_body::Empty`

Additionally a `Sync` bound has been added to a few methods. I actually
don't think this is a breaking change because the old
`tonic::body::Body` trait had `Sync` as a supertrait meaning the `Sync`
requirement was already there.

Fixes https://github.com/hyperium/tonic/issues/557
This commit is contained in:
David Pedersen
2021-05-18 10:41:21 +02:00
committed by GitHub
parent f613386d95
commit 4dda4cbcca
16 changed files with 44 additions and 919 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/Cargo.toml
+1 -1
View File
@@ -173,7 +173,7 @@ prost-types = "0.7"
hyper = "0.14"
warp = "0.3"
http = "0.2"
http-body = "0.4"
http-body = "0.4.2"
pin-project = "1.0"
# Health example
tonic-health = { path = "../tonic-health" }
interop/Cargo.toml
+1 -1
View File
@@ -26,7 +26,7 @@ http = "0.2"
futures-core = "0.3"
futures-util = "0.3"
tower = { version = "0.4" }
http-body = "0.4"
http-body = "0.4.2"
hyper = "0.14"
console = "0.14"
structopt = "0.3"
tonic-build/src/client.rs
+2 -2
View File
@@ -37,9 +37,9 @@ pub fn generate<T: Service>(
impl<T> #service_ident<T>
where T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::ResponseBody: Body + HttpBody + Send + 'static,
T::ResponseBody: Body + Send + Sync + 'static,
T::Error: Into<StdError>,
<T::ResponseBody as HttpBody>::Error: Into<StdError> + Send, {
<T::ResponseBody as Body>::Error: Into<StdError> + Send, {
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
tonic-build/src/server.rs
+2 -2
View File
@@ -69,7 +69,7 @@ pub fn generate<T: Service>(
impl<T, B> Service<http::Request<B>> for #server_service<T>
where
T: #server_trait,
B: HttpBody + Send + Sync + 'static,
B: Body + Send + Sync + 'static,
B::Error: Into<StdError> + Send + 'static,
{
type Response = http::Response<tonic::body::BoxBody>;
@@ -91,7 +91,7 @@ pub fn generate<T: Service>(
.status(200)
.header("grpc-status", "12")
.header("content-type", "application/grpc")
.body(tonic::body::BoxBody::empty())
.body(empty_body())
.unwrap())
}),
}
tonic-reflection/tests/proto/grpc.reflection.v1alpha.rs
-337
View File
@@ -1,337 +0,0 @@
/// The message sent by the client when calling ServerReflectionInfo method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServerReflectionRequest {
#[prost(string, tag = "1")]
pub host: ::prost::alloc::string::String,
/// To use reflection service, the client should set one of the following
/// fields in message_request. The server distinguishes requests by their
/// defined field and then handles them using corresponding methods.
#[prost(
oneof = "server_reflection_request::MessageRequest",
tags = "3, 4, 5, 6, 7"
)]
pub message_request: ::core::option::Option<server_reflection_request::MessageRequest>,
}
/// Nested message and enum types in `ServerReflectionRequest`.
pub mod server_reflection_request {
/// To use reflection service, the client should set one of the following
/// fields in message_request. The server distinguishes requests by their
/// defined field and then handles them using corresponding methods.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum MessageRequest {
/// Find a proto file by the file name.
#[prost(string, tag = "3")]
FileByFilename(::prost::alloc::string::String),
/// Find the proto file that declares the given fully-qualified symbol name.
/// This field should be a fully-qualified symbol name
/// (e.g. <package>.<service>[.<method>] or <package>.<type>).
#[prost(string, tag = "4")]
FileContainingSymbol(::prost::alloc::string::String),
/// Find the proto file which defines an extension extending the given
/// message type with the given field number.
#[prost(message, tag = "5")]
FileContainingExtension(super::ExtensionRequest),
/// Finds the tag numbers used by all known extensions of extendee_type, and
/// appends them to ExtensionNumberResponse in an undefined order.
/// Its corresponding method is best-effort: it's not guaranteed that the
/// reflection service will implement this method, and it's not guaranteed
/// that this method will provide all extensions. Returns
/// StatusCode::UNIMPLEMENTED if it's not implemented.
/// This field should be a fully-qualified type name. The format is
/// <package>.<type>
#[prost(string, tag = "6")]
AllExtensionNumbersOfType(::prost::alloc::string::String),
/// List the full names of registered services. The content will not be
/// checked.
#[prost(string, tag = "7")]
ListServices(::prost::alloc::string::String),
}
}
/// The type name and extension number sent by the client when requesting
/// file_containing_extension.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExtensionRequest {
/// Fully-qualified type name. The format should be <package>.<type>
#[prost(string, tag = "1")]
pub containing_type: ::prost::alloc::string::String,
#[prost(int32, tag = "2")]
pub extension_number: i32,
}
/// The message sent by the server to answer ServerReflectionInfo method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServerReflectionResponse {
#[prost(string, tag = "1")]
pub valid_host: ::prost::alloc::string::String,
#[prost(message, optional, tag = "2")]
pub original_request: ::core::option::Option<ServerReflectionRequest>,
/// The server sets one of the following fields according to the
/// message_request in the request.
#[prost(
oneof = "server_reflection_response::MessageResponse",
tags = "4, 5, 6, 7"
)]
pub message_response: ::core::option::Option<server_reflection_response::MessageResponse>,
}
/// Nested message and enum types in `ServerReflectionResponse`.
pub mod server_reflection_response {
/// The server sets one of the following fields according to the
/// message_request in the request.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum MessageResponse {
/// This message is used to answer file_by_filename, file_containing_symbol,
/// file_containing_extension requests with transitive dependencies.
/// As the repeated label is not allowed in oneof fields, we use a
/// FileDescriptorResponse message to encapsulate the repeated fields.
/// The reflection service is allowed to avoid sending FileDescriptorProtos
/// that were previously sent in response to earlier requests in the stream.
#[prost(message, tag = "4")]
FileDescriptorResponse(super::FileDescriptorResponse),
/// This message is used to answer all_extension_numbers_of_type requests.
#[prost(message, tag = "5")]
AllExtensionNumbersResponse(super::ExtensionNumberResponse),
/// This message is used to answer list_services requests.
#[prost(message, tag = "6")]
ListServicesResponse(super::ListServiceResponse),
/// This message is used when an error occurs.
#[prost(message, tag = "7")]
ErrorResponse(super::ErrorResponse),
}
}
/// Serialized FileDescriptorProto messages sent by the server answering
/// a file_by_filename, file_containing_symbol, or file_containing_extension
/// request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FileDescriptorResponse {
/// Serialized FileDescriptorProto messages. We avoid taking a dependency on
/// descriptor.proto, which uses proto2 only features, by making them opaque
/// bytes instead.
#[prost(bytes = "vec", repeated, tag = "1")]
pub file_descriptor_proto: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
}
/// A list of extension numbers sent by the server answering
/// all_extension_numbers_of_type request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExtensionNumberResponse {
/// Full name of the base type, including the package name. The format
/// is <package>.<type>
#[prost(string, tag = "1")]
pub base_type_name: ::prost::alloc::string::String,
#[prost(int32, repeated, tag = "2")]
pub extension_number: ::prost::alloc::vec::Vec<i32>,
}
/// A list of ServiceResponse sent by the server answering list_services request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListServiceResponse {
/// The information of each service may be expanded in the future, so we use
/// ServiceResponse message to encapsulate it.
#[prost(message, repeated, tag = "1")]
pub service: ::prost::alloc::vec::Vec<ServiceResponse>,
}
/// The information of a single service used by ListServiceResponse to answer
/// list_services request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServiceResponse {
/// Full name of a registered service, including its package name. The format
/// is <package>.<service>
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// The error code and error message sent by the server when an error occurs.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ErrorResponse {
/// This field uses the error codes defined in grpc::StatusCode.
#[prost(int32, tag = "1")]
pub error_code: i32,
#[prost(string, tag = "2")]
pub error_message: ::prost::alloc::string::String,
}
#[doc = r" Generated client implementations."]
pub mod server_reflection_client {
#![allow(unused_variables, dead_code, missing_docs)]
use tonic::codegen::*;
pub struct ServerReflectionClient<T> {
inner: tonic::client::Grpc<T>,
}
impl ServerReflectionClient<tonic::transport::Channel> {
#[doc = r" Attempt to create a new client by connecting to a given endpoint."]
pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
where
D: std::convert::TryInto<tonic::transport::Endpoint>,
D::Error: Into<StdError>,
{
let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
Ok(Self::new(conn))
}
}
impl<T> ServerReflectionClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::ResponseBody: Body + HttpBody + Send + 'static,
T::Error: Into<StdError>,
<T::ResponseBody as HttpBody>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor(inner: T, interceptor: impl Into<tonic::Interceptor>) -> Self {
let inner = tonic::client::Grpc::with_interceptor(inner, interceptor);
Self { inner }
}
#[doc = " The reflection service is structured as a bidirectional stream, ensuring"]
#[doc = " all related requests go to a single server."]
pub async fn server_reflection_info(
&mut self,
request: impl tonic::IntoStreamingRequest<Message = super::ServerReflectionRequest>,
) -> Result<
tonic::Response<tonic::codec::Streaming<super::ServerReflectionResponse>>,
tonic::Status,
> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo",
);
self.inner
.streaming(request.into_streaming_request(), path, codec)
.await
}
}
impl<T: Clone> Clone for ServerReflectionClient<T> {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
}
}
}
impl<T> std::fmt::Debug for ServerReflectionClient<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ServerReflectionClient {{ ... }}")
}
}
}
#[doc = r" Generated server implementations."]
pub mod server_reflection_server {
#![allow(unused_variables, dead_code, missing_docs)]
use tonic::codegen::*;
#[doc = "Generated trait containing gRPC methods that should be implemented for use with ServerReflectionServer."]
#[async_trait]
pub trait ServerReflection: Send + Sync + 'static {
#[doc = "Server streaming response type for the ServerReflectionInfo method."]
type ServerReflectionInfoStream: Stream<Item = Result<super::ServerReflectionResponse, tonic::Status>>
+ Send
+ Sync
+ 'static;
#[doc = " The reflection service is structured as a bidirectional stream, ensuring"]
#[doc = " all related requests go to a single server."]
async fn server_reflection_info(
&self,
request: tonic::Request<tonic::Streaming<super::ServerReflectionRequest>>,
) -> Result<tonic::Response<Self::ServerReflectionInfoStream>, tonic::Status>;
}
#[derive(Debug)]
pub struct ServerReflectionServer<T: ServerReflection> {
inner: _Inner<T>,
}
struct _Inner<T>(Arc<T>, Option<tonic::Interceptor>);
impl<T: ServerReflection> ServerReflectionServer<T> {
pub fn new(inner: T) -> Self {
let inner = Arc::new(inner);
let inner = _Inner(inner, None);
Self { inner }
}
pub fn with_interceptor(inner: T, interceptor: impl Into<tonic::Interceptor>) -> Self {
let inner = Arc::new(inner);
let inner = _Inner(inner, Some(interceptor.into()));
Self { inner }
}
}
impl<T, B> Service<http::Request<B>> for ServerReflectionServer<T>
where
T: ServerReflection,
B: HttpBody + Send + Sync + 'static,
B::Error: Into<StdError> + Send + 'static,
{
type Response = http::Response<tonic::body::BoxBody>;
type Error = Never;
type Future = BoxFuture<Self::Response, Self::Error>;
fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call(&mut self, req: http::Request<B>) -> Self::Future {
let inner = self.inner.clone();
match req.uri().path() {
"/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo" => {
#[allow(non_camel_case_types)]
struct ServerReflectionInfoSvc<T: ServerReflection>(pub Arc<T>);
impl<T: ServerReflection>
tonic::server::StreamingService<super::ServerReflectionRequest>
for ServerReflectionInfoSvc<T>
{
type Response = super::ServerReflectionResponse;
type ResponseStream = T::ServerReflectionInfoStream;
type Future =
BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
fn call(
&mut self,
request: tonic::Request<
tonic::Streaming<super::ServerReflectionRequest>,
>,
) -> Self::Future {
let inner = self.0.clone();
let fut = async move { (*inner).server_reflection_info(request).await };
Box::pin(fut)
}
}
let inner = self.inner.clone();
let fut = async move {
let interceptor = inner.1;
let inner = inner.0;
let method = ServerReflectionInfoSvc(inner);
let codec = tonic::codec::ProstCodec::default();
let mut grpc = if let Some(interceptor) = interceptor {
tonic::server::Grpc::with_interceptor(codec, interceptor)
} else {
tonic::server::Grpc::new(codec)
};
let res = grpc.streaming(method, req).await;
Ok(res)
};
Box::pin(fut)
}
_ => Box::pin(async move {
Ok(http::Response::builder()
.status(200)
.header("grpc-status", "12")
.header("content-type", "application/grpc")
.body(tonic::body::BoxBody::empty())
.unwrap())
}),
}
}
}
impl<T: ServerReflection> Clone for ServerReflectionServer<T> {
fn clone(&self) -> Self {
let inner = self.inner.clone();
Self { inner }
}
}
impl<T: ServerReflection> Clone for _Inner<T> {
fn clone(&self) -> Self {
Self(self.0.clone(), self.1.clone())
}
}
impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?}", self.0)
}
}
impl<T: ServerReflection> tonic::transport::NamedService for ServerReflectionServer<T> {
const NAME: &'static str = "grpc.reflection.v1alpha.ServerReflection";
}
}
tonic-reflection/tests/proto/mod.rs
-337
View File
@@ -1,337 +0,0 @@
/// The message sent by the client when calling ServerReflectionInfo method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServerReflectionRequest {
#[prost(string, tag = "1")]
pub host: ::prost::alloc::string::String,
/// To use reflection service, the client should set one of the following
/// fields in message_request. The server distinguishes requests by their
/// defined field and then handles them using corresponding methods.
#[prost(
oneof = "server_reflection_request::MessageRequest",
tags = "3, 4, 5, 6, 7"
)]
pub message_request: ::core::option::Option<server_reflection_request::MessageRequest>,
}
/// Nested message and enum types in `ServerReflectionRequest`.
pub mod server_reflection_request {
/// To use reflection service, the client should set one of the following
/// fields in message_request. The server distinguishes requests by their
/// defined field and then handles them using corresponding methods.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum MessageRequest {
/// Find a proto file by the file name.
#[prost(string, tag = "3")]
FileByFilename(::prost::alloc::string::String),
/// Find the proto file that declares the given fully-qualified symbol name.
/// This field should be a fully-qualified symbol name
/// (e.g. <package>.<service>[.<method>] or <package>.<type>).
#[prost(string, tag = "4")]
FileContainingSymbol(::prost::alloc::string::String),
/// Find the proto file which defines an extension extending the given
/// message type with the given field number.
#[prost(message, tag = "5")]
FileContainingExtension(super::ExtensionRequest),
/// Finds the tag numbers used by all known extensions of extendee_type, and
/// appends them to ExtensionNumberResponse in an undefined order.
/// Its corresponding method is best-effort: it's not guaranteed that the
/// reflection service will implement this method, and it's not guaranteed
/// that this method will provide all extensions. Returns
/// StatusCode::UNIMPLEMENTED if it's not implemented.
/// This field should be a fully-qualified type name. The format is
/// <package>.<type>
#[prost(string, tag = "6")]
AllExtensionNumbersOfType(::prost::alloc::string::String),
/// List the full names of registered services. The content will not be
/// checked.
#[prost(string, tag = "7")]
ListServices(::prost::alloc::string::String),
}
}
/// The type name and extension number sent by the client when requesting
/// file_containing_extension.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExtensionRequest {
/// Fully-qualified type name. The format should be <package>.<type>
#[prost(string, tag = "1")]
pub containing_type: ::prost::alloc::string::String,
#[prost(int32, tag = "2")]
pub extension_number: i32,
}
/// The message sent by the server to answer ServerReflectionInfo method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServerReflectionResponse {
#[prost(string, tag = "1")]
pub valid_host: ::prost::alloc::string::String,
#[prost(message, optional, tag = "2")]
pub original_request: ::core::option::Option<ServerReflectionRequest>,
/// The server sets one of the following fields according to the
/// message_request in the request.
#[prost(
oneof = "server_reflection_response::MessageResponse",
tags = "4, 5, 6, 7"
)]
pub message_response: ::core::option::Option<server_reflection_response::MessageResponse>,
}
/// Nested message and enum types in `ServerReflectionResponse`.
pub mod server_reflection_response {
/// The server sets one of the following fields according to the
/// message_request in the request.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum MessageResponse {
/// This message is used to answer file_by_filename, file_containing_symbol,
/// file_containing_extension requests with transitive dependencies.
/// As the repeated label is not allowed in oneof fields, we use a
/// FileDescriptorResponse message to encapsulate the repeated fields.
/// The reflection service is allowed to avoid sending FileDescriptorProtos
/// that were previously sent in response to earlier requests in the stream.
#[prost(message, tag = "4")]
FileDescriptorResponse(super::FileDescriptorResponse),
/// This message is used to answer all_extension_numbers_of_type requests.
#[prost(message, tag = "5")]
AllExtensionNumbersResponse(super::ExtensionNumberResponse),
/// This message is used to answer list_services requests.
#[prost(message, tag = "6")]
ListServicesResponse(super::ListServiceResponse),
/// This message is used when an error occurs.
#[prost(message, tag = "7")]
ErrorResponse(super::ErrorResponse),
}
}
/// Serialized FileDescriptorProto messages sent by the server answering
/// a file_by_filename, file_containing_symbol, or file_containing_extension
/// request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FileDescriptorResponse {
/// Serialized FileDescriptorProto messages. We avoid taking a dependency on
/// descriptor.proto, which uses proto2 only features, by making them opaque
/// bytes instead.
#[prost(bytes = "vec", repeated, tag = "1")]
pub file_descriptor_proto: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
}
/// A list of extension numbers sent by the server answering
/// all_extension_numbers_of_type request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExtensionNumberResponse {
/// Full name of the base type, including the package name. The format
/// is <package>.<type>
#[prost(string, tag = "1")]
pub base_type_name: ::prost::alloc::string::String,
#[prost(int32, repeated, tag = "2")]
pub extension_number: ::prost::alloc::vec::Vec<i32>,
}
/// A list of ServiceResponse sent by the server answering list_services request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListServiceResponse {
/// The information of each service may be expanded in the future, so we use
/// ServiceResponse message to encapsulate it.
#[prost(message, repeated, tag = "1")]
pub service: ::prost::alloc::vec::Vec<ServiceResponse>,
}
/// The information of a single service used by ListServiceResponse to answer
/// list_services request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServiceResponse {
/// Full name of a registered service, including its package name. The format
/// is <package>.<service>
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// The error code and error message sent by the server when an error occurs.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ErrorResponse {
/// This field uses the error codes defined in grpc::StatusCode.
#[prost(int32, tag = "1")]
pub error_code: i32,
#[prost(string, tag = "2")]
pub error_message: ::prost::alloc::string::String,
}
#[doc = r" Generated client implementations."]
pub mod server_reflection_client {
#![allow(unused_variables, dead_code, missing_docs)]
use tonic::codegen::*;
pub struct ServerReflectionClient<T> {
inner: tonic::client::Grpc<T>,
}
impl ServerReflectionClient<tonic::transport::Channel> {
#[doc = r" Attempt to create a new client by connecting to a given endpoint."]
pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
where
D: std::convert::TryInto<tonic::transport::Endpoint>,
D::Error: Into<StdError>,
{
let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
Ok(Self::new(conn))
}
}
impl<T> ServerReflectionClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::ResponseBody: Body + HttpBody + Send + 'static,
T::Error: Into<StdError>,
<T::ResponseBody as HttpBody>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor(inner: T, interceptor: impl Into<tonic::Interceptor>) -> Self {
let inner = tonic::client::Grpc::with_interceptor(inner, interceptor);
Self { inner }
}
#[doc = " The reflection service is structured as a bidirectional stream, ensuring"]
#[doc = " all related requests go to a single server."]
pub async fn server_reflection_info(
&mut self,
request: impl tonic::IntoStreamingRequest<Message = super::ServerReflectionRequest>,
) -> Result<
tonic::Response<tonic::codec::Streaming<super::ServerReflectionResponse>>,
tonic::Status,
> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo",
);
self.inner
.streaming(request.into_streaming_request(), path, codec)
.await
}
}
impl<T: Clone> Clone for ServerReflectionClient<T> {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
}
}
}
impl<T> std::fmt::Debug for ServerReflectionClient<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ServerReflectionClient {{ ... }}")
}
}
}
#[doc = r" Generated server implementations."]
pub mod server_reflection_server {
#![allow(unused_variables, dead_code, missing_docs)]
use tonic::codegen::*;
#[doc = "Generated trait containing gRPC methods that should be implemented for use with ServerReflectionServer."]
#[async_trait]
pub trait ServerReflection: Send + Sync + 'static {
#[doc = "Server streaming response type for the ServerReflectionInfo method."]
type ServerReflectionInfoStream: Stream<Item = Result<super::ServerReflectionResponse, tonic::Status>>
+ Send
+ Sync
+ 'static;
#[doc = " The reflection service is structured as a bidirectional stream, ensuring"]
#[doc = " all related requests go to a single server."]
async fn server_reflection_info(
&self,
request: tonic::Request<tonic::Streaming<super::ServerReflectionRequest>>,
) -> Result<tonic::Response<Self::ServerReflectionInfoStream>, tonic::Status>;
}
#[derive(Debug)]
pub struct ServerReflectionServer<T: ServerReflection> {
inner: _Inner<T>,
}
struct _Inner<T>(Arc<T>, Option<tonic::Interceptor>);
impl<T: ServerReflection> ServerReflectionServer<T> {
pub fn new(inner: T) -> Self {
let inner = Arc::new(inner);
let inner = _Inner(inner, None);
Self { inner }
}
pub fn with_interceptor(inner: T, interceptor: impl Into<tonic::Interceptor>) -> Self {
let inner = Arc::new(inner);
let inner = _Inner(inner, Some(interceptor.into()));
Self { inner }
}
}
impl<T, B> Service<http::Request<B>> for ServerReflectionServer<T>
where
T: ServerReflection,
B: HttpBody + Send + Sync + 'static,
B::Error: Into<StdError> + Send + 'static,
{
type Response = http::Response<tonic::body::BoxBody>;
type Error = Never;
type Future = BoxFuture<Self::Response, Self::Error>;
fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call(&mut self, req: http::Request<B>) -> Self::Future {
let inner = self.inner.clone();
match req.uri().path() {
"/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo" => {
#[allow(non_camel_case_types)]
struct ServerReflectionInfoSvc<T: ServerReflection>(pub Arc<T>);
impl<T: ServerReflection>
tonic::server::StreamingService<super::ServerReflectionRequest>
for ServerReflectionInfoSvc<T>
{
type Response = super::ServerReflectionResponse;
type ResponseStream = T::ServerReflectionInfoStream;
type Future =
BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
fn call(
&mut self,
request: tonic::Request<
tonic::Streaming<super::ServerReflectionRequest>,
>,
) -> Self::Future {
let inner = self.0.clone();
let fut = async move { (*inner).server_reflection_info(request).await };
Box::pin(fut)
}
}
let inner = self.inner.clone();
let fut = async move {
let interceptor = inner.1;
let inner = inner.0;
let method = ServerReflectionInfoSvc(inner);
let codec = tonic::codec::ProstCodec::default();
let mut grpc = if let Some(interceptor) = interceptor {
tonic::server::Grpc::with_interceptor(codec, interceptor)
} else {
tonic::server::Grpc::new(codec)
};
let res = grpc.streaming(method, req).await;
Ok(res)
};
Box::pin(fut)
}
_ => Box::pin(async move {
Ok(http::Response::builder()
.status(200)
.header("grpc-status", "12")
.header("content-type", "application/grpc")
.body(tonic::body::BoxBody::empty())
.unwrap())
}),
}
}
}
impl<T: ServerReflection> Clone for ServerReflectionServer<T> {
fn clone(&self) -> Self {
let inner = self.inner.clone();
Self { inner }
}
}
impl<T: ServerReflection> Clone for _Inner<T> {
fn clone(&self) -> Self {
Self(self.0.clone(), self.1.clone())
}
}
impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?}", self.0)
}
}
impl<T: ServerReflection> tonic::transport::NamedService for ServerReflectionServer<T> {
const NAME: &'static str = "grpc.reflection.v1alpha.ServerReflection";
}
}
tonic/Cargo.toml
+1 -1
View File
@@ -54,7 +54,7 @@ percent-encoding = "2.1"
tower-service = "0.3"
tokio-util = { version = "0.6", features = ["codec"] }
async-stream = "0.3"
http-body = "0.4"
http-body = "0.4.2"
pin-project = "1.0"
# prost
tonic/benches-disabled/benchmarks/compiled_protos/helloworld.rs
+4 -4
View File
@@ -32,10 +32,10 @@ pub mod client {
impl<T> GreeterClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::ResponseBody: Body + HttpBody + Send + 'static,
T::ResponseBody: Body + Send + 'static,
T::Error: Into<StdError>,
<T::ResponseBody as HttpBody>::Error: Into<StdError> + Send,
<T::ResponseBody as HttpBody>::Data: Into<bytes::Bytes> + Send,
<T::ResponseBody as Body>::Error: Into<StdError> + Send,
<T::ResponseBody as Body>::Data: Into<bytes::Bytes> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
@@ -158,7 +158,7 @@ pub mod server {
Ok(http::Response::builder()
.status(200)
.header("grpc-status", "12")
.body(tonic::body::BoxBody::empty())
.body(empty_body())
.unwrap())
}),
}
tonic/src/body.rs
+7 -213
View File
@@ -1,218 +1,12 @@
//! HTTP specific body utilities.
//!
//! This module contains traits and helper types to work with http bodies. Most
//! of the types in this module are based around [`http_body::Body`].
use crate::{Error, Status};
use bytes::{Buf, Bytes};
use http_body::Body as HttpBody;
use std::{
fmt,
pin::Pin,
task::{Context, Poll},
};
use http_body::Body;
/// A trait alias for [`http_body::Body`].
pub trait Body: sealed::Sealed + Send + Sync {
/// The body data type.
type Data: Buf;
/// The errors produced from the body.
type Error: Into<Error>;
/// A type erased HTTP body used for tonic services.
pub type BoxBody = http_body::combinators::BoxBody<bytes::Bytes, crate::Status>;
/// Check if the stream is over or not.
///
/// Reference [`http_body::Body::is_end_stream`].
fn is_end_stream(&self) -> bool;
/// Poll for more data from the body.
///
/// Reference [`http_body::Body::poll_data`].
fn poll_data(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Option<Result<Self::Data, Self::Error>>>;
/// Poll for the trailing headers.
///
/// Reference [`http_body::Body::poll_trailers`].
fn poll_trailers(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Result<Option<http::HeaderMap>, Self::Error>>;
}
impl<T> Body for T
where
T: HttpBody + Send + Sync + 'static,
T::Error: Into<Error>,
{
type Data = T::Data;
type Error = T::Error;
fn is_end_stream(&self) -> bool {
HttpBody::is_end_stream(self)
}
fn poll_data(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Option<Result<Self::Data, Self::Error>>> {
HttpBody::poll_data(self, cx)
}
fn poll_trailers(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Result<Option<http::HeaderMap>, Self::Error>> {
HttpBody::poll_trailers(self, cx)
}
}
impl<T> sealed::Sealed for T
where
T: HttpBody,
T::Error: Into<Error>,
{
}
mod sealed {
pub trait Sealed {}
}
/// A type erased http body.
pub struct BoxBody {
inner: Pin<Box<dyn Body<Data = Bytes, Error = Status> + Send + Sync + 'static>>,
}
struct MapBody<B>(B);
impl BoxBody {
/// Create a new `BoxBody` mapping item and error to the default types.
pub fn new<B>(inner: B) -> Self
where
B: Body<Data = Bytes, Error = Status> + Send + Sync + 'static,
{
BoxBody {
inner: Box::pin(inner),
}
}
/// Create a new `BoxBody` mapping item and error to the default types.
pub fn map_from<B>(inner: B) -> Self
where
B: Body + Send + Sync + 'static,
B::Error: Into<crate::Error>,
{
BoxBody {
inner: Box::pin(MapBody(inner)),
}
}
/// Create a new `BoxBody` that is empty.
pub fn empty() -> Self {
BoxBody {
inner: Box::pin(EmptyBody::default()),
}
}
}
impl HttpBody for BoxBody {
type Data = Bytes;
type Error = Status;
fn is_end_stream(&self) -> bool {
self.inner.is_end_stream()
}
fn poll_data(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Option<Result<Self::Data, Self::Error>>> {
Body::poll_data(self.inner.as_mut(), cx)
}
fn poll_trailers(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Result<Option<http::HeaderMap>, Self::Error>> {
Body::poll_trailers(self.inner.as_mut(), cx)
}
}
impl<B> HttpBody for MapBody<B>
where
B: Body,
B::Error: Into<crate::Error>,
{
type Data = Bytes;
type Error = Status;
fn is_end_stream(&self) -> bool {
self.0.is_end_stream()
}
fn poll_data(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Option<Result<Self::Data, Self::Error>>> {
let v = unsafe {
let me = self.get_unchecked_mut();
Pin::new_unchecked(&mut me.0).poll_data(cx)
};
match futures_util::ready!(v) {
Some(Ok(mut i)) => Poll::Ready(Some(Ok(i.copy_to_bytes(i.remaining())))),
Some(Err(e)) => {
let err = Status::map_error(e.into());
Poll::Ready(Some(Err(err)))
}
None => Poll::Ready(None),
}
}
fn poll_trailers(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Result<Option<http::HeaderMap>, Self::Error>> {
let v = unsafe {
let me = self.get_unchecked_mut();
Pin::new_unchecked(&mut me.0).poll_trailers(cx)
};
let v = futures_util::ready!(v).map_err(|e| Status::from_error(&*e.into()));
Poll::Ready(v)
}
}
impl fmt::Debug for BoxBody {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("BoxBody").finish()
}
}
#[derive(Debug, Default)]
struct EmptyBody {
_p: (),
}
impl HttpBody for EmptyBody {
type Data = Bytes;
type Error = Status;
fn is_end_stream(&self) -> bool {
true
}
fn poll_data(
self: Pin<&mut Self>,
_cx: &mut Context<'_>,
) -> Poll<Option<Result<Self::Data, Self::Error>>> {
Poll::Ready(None)
}
fn poll_trailers(
self: Pin<&mut Self>,
_cx: &mut Context<'_>,
) -> Poll<Result<Option<http::HeaderMap>, Self::Error>> {
Poll::Ready(Ok(None))
}
// this also exists in `crate::codegen` but we need it here since `codegen` has
// `#[cfg(feature = "codegen")]`.
pub(crate) fn empty_body() -> BoxBody {
http_body::Empty::new().map_err(|err| match err {}).boxed()
}
tonic/src/client/grpc.rs
+10 -10
View File
@@ -1,5 +1,5 @@
use crate::{
body::{Body, BoxBody},
body::BoxBody,
client::GrpcService,
codec::{encode_client, Codec, Streaming},
interceptor::Interceptor,
@@ -11,7 +11,7 @@ use http::{
header::{HeaderValue, CONTENT_TYPE, TE},
uri::{Parts, PathAndQuery, Uri},
};
use http_body::Body as HttpBody;
use http_body::Body;
use std::fmt;
/// A gRPC client dispatcher.
@@ -71,8 +71,8 @@ impl<T> Grpc<T> {
) -> Result<Response<M2>, Status>
where
T: GrpcService<BoxBody>,
T::ResponseBody: Body + HttpBody + Send + 'static,
<T::ResponseBody as HttpBody>::Error: Into<crate::Error>,
T::ResponseBody: Body + Send + Sync + 'static,
<T::ResponseBody as Body>::Error: Into<crate::Error>,
C: Codec<Encode = M1, Decode = M2>,
M1: Send + Sync + 'static,
M2: Send + Sync + 'static,
@@ -90,8 +90,8 @@ impl<T> Grpc<T> {
) -> Result<Response<M2>, Status>
where
T: GrpcService<BoxBody>,
T::ResponseBody: Body + HttpBody + Send + 'static,
<T::ResponseBody as HttpBody>::Error: Into<crate::Error>,
T::ResponseBody: Body + Send + Sync + 'static,
<T::ResponseBody as Body>::Error: Into<crate::Error>,
S: Stream<Item = M1> + Send + Sync + 'static,
C: Codec<Encode = M1, Decode = M2>,
M1: Send + Sync + 'static,
@@ -127,8 +127,8 @@ impl<T> Grpc<T> {
) -> Result<Response<Streaming<M2>>, Status>
where
T: GrpcService<BoxBody>,
T::ResponseBody: Body + HttpBody + Send + 'static,
<T::ResponseBody as HttpBody>::Error: Into<crate::Error>,
T::ResponseBody: Body + Send + Sync + 'static,
<T::ResponseBody as Body>::Error: Into<crate::Error>,
C: Codec<Encode = M1, Decode = M2>,
M1: Send + Sync + 'static,
M2: Send + Sync + 'static,
@@ -146,8 +146,8 @@ impl<T> Grpc<T> {
) -> Result<Response<Streaming<M2>>, Status>
where
T: GrpcService<BoxBody>,
T::ResponseBody: Body + HttpBody + Send + 'static,
<T::ResponseBody as HttpBody>::Error: Into<crate::Error>,
T::ResponseBody: Body + Send + Sync + 'static,
<T::ResponseBody as Body>::Error: Into<crate::Error>,
S: Stream<Item = M1> + Send + Sync + 'static,
C: Codec<Encode = M1, Decode = M2>,
M1: Send + Sync + 'static,
tonic/src/client/service.rs
+4 -5
View File
@@ -1,5 +1,4 @@
use crate::body::Body;
use http_body::Body as HttpBody;
use http_body::Body;
use std::future::Future;
use std::task::{Context, Poll};
use tower_service::Service;
@@ -13,7 +12,7 @@ use tower_service::Service;
/// [`tower_service`]: https://docs.rs/tower-service
pub trait GrpcService<ReqBody> {
/// Responses body given by the service.
type ResponseBody: Body + HttpBody;
type ResponseBody: Body;
/// Errors produced by the service.
type Error: Into<crate::Error>;
/// The future response value.
@@ -34,8 +33,8 @@ impl<T, ReqBody, ResBody> GrpcService<ReqBody> for T
where
T: Service<http::Request<ReqBody>, Response = http::Response<ResBody>>,
T::Error: Into<crate::Error>,
ResBody: Body + HttpBody,
<ResBody as HttpBody>::Error: Into<crate::Error>,
ResBody: Body,
<ResBody as Body>::Error: Into<crate::Error>,
{
type ResponseBody = ResBody;
type Error = T::Error;
tonic/src/codec/decode.rs
+4 -1
View File
@@ -79,7 +79,10 @@ impl<T> Streaming<T> {
{
Self {
decoder: Box::new(decoder),
body: BoxBody::map_from(body),
body: body
.map_data(|mut buf| buf.copy_to_bytes(buf.remaining()))
.map_err(|err| Status::map_error(err.into()))
.boxed(),
state: State::ReadHeader,
direction,
buf: BytesMut::with_capacity(BUFFER_SIZE),
tonic/src/codegen.rs
+5 -2
View File
@@ -4,14 +4,13 @@ pub use async_trait::async_trait;
pub use futures_core;
pub use futures_util::future::{ok, poll_fn, Ready};
pub use http_body::Body as HttpBody;
pub use std::future::Future;
pub use std::pin::Pin;
pub use std::sync::Arc;
pub use std::task::{Context, Poll};
pub use tower_service::Service;
pub type StdError = Box<dyn std::error::Error + Send + Sync + 'static>;
pub use crate::body::Body;
pub use http_body::Body;
pub type BoxFuture<T, E> = self::Pin<Box<dyn self::Future<Output = Result<T, E>> + Send + 'static>>;
pub type BoxStream<T> =
@@ -31,3 +30,7 @@ impl std::fmt::Display for Never {
}
impl std::error::Error for Never {}
pub fn empty_body() -> crate::body::BoxBody {
http_body::Empty::new().map_err(|err| match err {}).boxed()
}
tonic/src/status.rs
+1 -1
View File
@@ -520,7 +520,7 @@ impl Status {
self.add_header(&mut parts.headers).unwrap();
http::Response::from_parts(parts, BoxBody::empty())
http::Response::from_parts(parts, crate::body::empty_body())
}
}
tonic/src/transport/server/mod.rs
+1 -1
View File
@@ -712,7 +712,7 @@ impl Service<Request<Body>> for Unimplemented {
.status(200)
.header("grpc-status", "12")
.header("content-type", "application/grpc")
.body(BoxBody::empty())
.body(crate::body::empty_body())
.unwrap(),
)
}
tonic/src/transport/server/recover_error.rs
+1 -1
View File
@@ -63,7 +63,7 @@ where
Ok(res) => Poll::Ready(Ok(res)),
Err(err) => {
if let Some(status) = Status::try_from_error(&*err) {
let mut res = Response::new(BoxBody::empty());
let mut res = Response::new(crate::body::empty_body());
status.add_header(res.headers_mut()).unwrap();
Poll::Ready(Ok(res))
} else {