diff --git a/tonic-reflection/Cargo.toml b/tonic-reflection/Cargo.toml index 66da8889f..a94bd88d7 100644 --- a/tonic-reflection/Cargo.toml +++ b/tonic-reflection/Cargo.toml @@ -25,10 +25,8 @@ tokio = {version = "1.0", features = ["sync", "rt"]} tokio-stream = {version = "0.1", features = ["net"]} tonic = { version = "0.8", path = "../tonic", default-features = false, features = ["codegen", "prost"] } -[build-dependencies] -tonic-build = { version = "0.8", path = "../tonic-build", default-features = false, features = ["prost"] } - [dev-dependencies] tonic = { version = "0.8", path = "../tonic", default-features = false, features = ["transport"] } +tonic-build = { version = "0.8", path = "../tonic-build", default-features = false, features = ["prost"] } futures = "0.3" futures-util = "0.3" diff --git a/tonic-reflection/build.rs b/tonic-reflection/build.rs deleted file mode 100644 index 3bd2dc137..000000000 --- a/tonic-reflection/build.rs +++ /dev/null @@ -1,19 +0,0 @@ -use std::env; -use std::path::PathBuf; - -fn main() -> Result<(), Box> { - let reflection_descriptor = - PathBuf::from(env::var("OUT_DIR").unwrap()).join("reflection_v1alpha1.bin"); - - tonic_build::configure() - .file_descriptor_set_path(&reflection_descriptor) - .type_attribute( - "ServerReflectionResponse.message_response", - "#[allow(clippy::enum_variant_names)]", - ) - .build_server(true) - .build_client(true) // Client is only used for tests - .compile(&["proto/reflection.proto"], &["proto/"])?; - - Ok(()) -} diff --git a/tonic-reflection/src/generated/grpc.reflection.v1alpha.rs b/tonic-reflection/src/generated/grpc.reflection.v1alpha.rs new file mode 100644 index 000000000..d348a4d50 --- /dev/null +++ b/tonic-reflection/src/generated/grpc.reflection.v1alpha.rs @@ -0,0 +1,392 @@ +/// 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. .\[.\] or .). + #[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 + /// . + #[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 . + #[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, + /// 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>, +} +/// 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 . + #[prost(string, tag = "1")] + pub base_type_name: ::prost::alloc::string::String, + #[prost(int32, repeated, tag = "2")] + pub extension_number: ::prost::alloc::vec::Vec, +} +/// 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, +} +/// 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 . + #[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, +} +/// Generated client implementations. +pub mod server_reflection_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct ServerReflectionClient { + inner: tonic::client::Grpc, + } + impl ServerReflectionClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> ServerReflectionClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + ServerReflectionClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// The reflection service is structured as a bidirectional stream, ensuring + /// 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::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 + } + } +} +/// Generated server implementations. +pub mod server_reflection_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with ServerReflectionServer. + #[async_trait] + pub trait ServerReflection: Send + Sync + 'static { + /// Server streaming response type for the ServerReflectionInfo method. + type ServerReflectionInfoStream: futures_core::Stream< + Item = Result, + > + + Send + + 'static; + /// The reflection service is structured as a bidirectional stream, ensuring + /// all related requests go to a single server. + async fn server_reflection_info( + &self, + request: tonic::Request>, + ) -> Result, tonic::Status>; + } + #[derive(Debug)] + pub struct ServerReflectionServer { + inner: _Inner, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + } + struct _Inner(Arc); + impl ServerReflectionServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + let inner = _Inner(inner); + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + } + impl tonic::codegen::Service> for ServerReflectionServer + where + T: ServerReflection, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + match req.uri().path() { + "/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo" => { + #[allow(non_camel_case_types)] + struct ServerReflectionInfoSvc(pub Arc); + impl< + T: ServerReflection, + > tonic::server::StreamingService + for ServerReflectionInfoSvc { + type Response = super::ServerReflectionResponse; + type ResponseStream = T::ServerReflectionInfoStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + tonic::Streaming, + >, + ) -> Self::Future { + let inner = self.0.clone(); + let fut = async move { + (*inner).server_reflection_info(request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ServerReflectionInfoSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ); + 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(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for ServerReflectionServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + } + } + } + impl Clone for _Inner { + fn clone(&self) -> Self { + Self(self.0.clone()) + } + } + impl std::fmt::Debug for _Inner { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl tonic::server::NamedService for ServerReflectionServer { + const NAME: &'static str = "grpc.reflection.v1alpha.ServerReflection"; + } +} diff --git a/tonic-reflection/src/generated/reflection_v1alpha1.bin b/tonic-reflection/src/generated/reflection_v1alpha1.bin new file mode 100644 index 000000000..e595305b5 Binary files /dev/null and b/tonic-reflection/src/generated/reflection_v1alpha1.bin differ diff --git a/tonic-reflection/src/lib.rs b/tonic-reflection/src/lib.rs index c4774c751..1b0b22e12 100644 --- a/tonic-reflection/src/lib.rs +++ b/tonic-reflection/src/lib.rs @@ -15,12 +15,13 @@ #![doc(test(no_crate_inject, attr(deny(rust_2018_idioms))))] #![cfg_attr(docsrs, feature(doc_cfg))] -pub(crate) mod proto { +/// Generated protobuf types from the `grpc.reflection.v1alpha` package. +pub mod proto { #![allow(unreachable_pub)] - tonic::include_proto!("grpc.reflection.v1alpha"); + #![allow(missing_docs)] + include!("generated/grpc.reflection.v1alpha.rs"); - pub(crate) const FILE_DESCRIPTOR_SET: &[u8] = - tonic::include_file_descriptor_set!("reflection_v1alpha1"); + pub const FILE_DESCRIPTOR_SET: &[u8] = include_bytes!("generated/reflection_v1alpha1.bin"); } /// Implementation of the server component of gRPC Server Reflection. diff --git a/tonic-reflection/tests/bootstrap.rs b/tonic-reflection/tests/bootstrap.rs new file mode 100644 index 000000000..36fa8ea73 --- /dev/null +++ b/tonic-reflection/tests/bootstrap.rs @@ -0,0 +1,31 @@ +use std::{path::PathBuf, process::Command}; + +#[test] +fn bootstrap() { + let iface_files = &["proto/reflection.proto"]; + let dirs = &["proto"]; + + let out_dir = PathBuf::from(std::env!("CARGO_MANIFEST_DIR")) + .join("src") + .join("generated"); + + tonic_build::configure() + .build_client(true) + .build_server(true) + .build_transport(false) + .out_dir(format!("{}", out_dir.display())) + .compile(iface_files, dirs) + .unwrap(); + + let status = Command::new("git") + .arg("diff") + .arg("--exit-code") + .arg("--") + .arg(format!("{}", out_dir.display())) + .status() + .unwrap(); + + if !status.success() { + panic!("You should commit the protobuf files"); + } +} diff --git a/tonic-reflection/tests/server.rs b/tonic-reflection/tests/server.rs index 30e78bc88..193a87cd1 100644 --- a/tonic-reflection/tests/server.rs +++ b/tonic-reflection/tests/server.rs @@ -1,37 +1,27 @@ use futures::stream; use futures_util::FutureExt; -use tokio::sync::oneshot; -use tonic::transport::Server; -use tonic::Request; -use tonic_reflection::server::Builder; - -use pb::server_reflection_client::ServerReflectionClient; -use pb::server_reflection_request::MessageRequest; -use pb::server_reflection_response::MessageResponse; -use pb::ServerReflectionRequest; -use pb::ServiceResponse; +use prost::Message; use std::net::SocketAddr; -use tokio_stream::wrappers::TcpListenerStream; -use tokio_stream::StreamExt; - -mod pb { - #![allow(unreachable_pub)] - use prost::Message; - - tonic::include_proto!("grpc.reflection.v1alpha"); - - pub(crate) const REFLECTION_SERVICE_DESCRIPTOR: &[u8] = - tonic::include_file_descriptor_set!("reflection_v1alpha1"); - - pub(crate) fn get_encoded_reflection_service_fd() -> Vec { - let mut expected = Vec::new(); - prost_types::FileDescriptorSet::decode(REFLECTION_SERVICE_DESCRIPTOR) - .expect("decode reflection service file descriptor set") - .file[0] - .encode(&mut expected) - .expect("encode reflection service file descriptor"); - expected - } +use tokio::sync::oneshot; +use tokio_stream::{wrappers::TcpListenerStream, StreamExt}; +use tonic::{transport::Server, Request}; +use tonic_reflection::{ + proto::{ + server_reflection_client::ServerReflectionClient, + server_reflection_request::MessageRequest, server_reflection_response::MessageResponse, + ServerReflectionRequest, ServiceResponse, FILE_DESCRIPTOR_SET, + }, + server::Builder, +}; + +pub(crate) fn get_encoded_reflection_service_fd() -> Vec { + let mut expected = Vec::new(); + prost_types::FileDescriptorSet::decode(FILE_DESCRIPTOR_SET) + .expect("decode reflection service file descriptor set") + .file[0] + .encode(&mut expected) + .expect("encode reflection service file descriptor"); + expected } #[tokio::test] @@ -71,7 +61,7 @@ async fn test_file_by_filename() { .expect("descriptor"); assert_eq!( file_descriptor_proto.as_ref(), - pb::get_encoded_reflection_service_fd() + get_encoded_reflection_service_fd() ); } else { panic!("Expected a FileDescriptorResponse variant"); @@ -95,7 +85,7 @@ async fn test_file_containing_symbol() { .expect("descriptor"); assert_eq!( file_descriptor_proto.as_ref(), - pb::get_encoded_reflection_service_fd() + get_encoded_reflection_service_fd() ); } else { panic!("Expected a FileDescriptorResponse variant"); @@ -108,11 +98,10 @@ async fn make_test_reflection_request(request: ServerReflectionRequest) -> Messa let addr: SocketAddr = "127.0.0.1:0".parse().expect("SocketAddr parse"); let listener = tokio::net::TcpListener::bind(addr).await.expect("bind"); - let local_addr = listener.local_addr().expect("local address"); - let local_addr = format!("http://{}", local_addr.to_string()); + let local_addr = format!("http://{}", listener.local_addr().expect("local address")); let jh = tokio::spawn(async move { let service = Builder::configure() - .register_encoded_file_descriptor_set(pb::REFLECTION_SERVICE_DESCRIPTOR) + .register_encoded_file_descriptor_set(FILE_DESCRIPTOR_SET) .build() .unwrap(); @@ -127,9 +116,12 @@ async fn make_test_reflection_request(request: ServerReflectionRequest) -> Messa tokio::time::sleep(std::time::Duration::from_millis(100)).await; // Construct client and send request, extract response - let mut client = ServerReflectionClient::connect(local_addr) + let conn = tonic::transport::Endpoint::new(local_addr) + .unwrap() + .connect() .await - .expect("connect"); + .unwrap(); + let mut client = ServerReflectionClient::new(conn); let request = Request::new(stream::iter(vec![request])); let mut inbound = client