From f3cbca44faf46be1a27f7b177b7ab59be353a3fc Mon Sep 17 00:00:00 2001 From: Artem Vorotnikov Date: Tue, 15 Nov 2022 16:48:17 +0300 Subject: [PATCH] tonic-reflection: commit generated code --- tonic-reflection/Cargo.toml | 4 +- tonic-reflection/build.rs | 19 - .../src/generated/grpc.reflection.v1alpha.rs | 392 ++++++++++++++++++ .../src/generated/reflection_v1alpha1.bin | Bin 0 -> 7190 bytes tonic-reflection/src/lib.rs | 9 +- tonic-reflection/tests/bootstrap.rs | 31 ++ tonic-reflection/tests/server.rs | 68 ++- 7 files changed, 459 insertions(+), 64 deletions(-) delete mode 100644 tonic-reflection/build.rs create mode 100644 tonic-reflection/src/generated/grpc.reflection.v1alpha.rs create mode 100644 tonic-reflection/src/generated/reflection_v1alpha1.bin create mode 100644 tonic-reflection/tests/bootstrap.rs 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 0000000000000000000000000000000000000000..e595305b5676e3dbc2779b40cd5f02cc109a9b4d GIT binary patch literal 7190 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 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