diff --git a/Cargo.toml b/Cargo.toml index 74f61a2..cf10c1b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -63,11 +63,12 @@ rand = "0.8.5" # now only for feature="auth-by-http" reqwest = { version = "0.11", default-features = false, features = [], optional = true } -async-trait = {version = "0.1", optional = true} +# for feature="async" +async-trait = { version = "0.1", optional = true } + async-stream = "0.3.5" -tonic = "0.9.1" -tower = {version = "0.4.13", features = ["filter", "log"]} -http = "0.2.9" +tonic = "0.9" +tower = { version = "0.4.13", features = ["filter", "log"] } pin-project = "1.0.12" futures-util = "0.3.28" want = "0.3.0" @@ -77,9 +78,7 @@ home = "0.5.4" [dev-dependencies] tracing-subscriber = { version = "0.3", features = ["default"] } - -[build-dependencies] -tonic-build = "0.9.1" +tonic-build = "0.9" [[example]] name = "simple_app" diff --git a/build.rs b/build.rs deleted file mode 100644 index 530f23f..0000000 --- a/build.rs +++ /dev/null @@ -1,8 +0,0 @@ -fn main() { - tonic_build::configure() - .build_client(true) - .build_server(false) - .build_transport(true) - .compile(&["proto/nacos_grpc_service.proto"], &["proto"]) - .unwrap() -} diff --git a/src/_.rs b/src/_.rs new file mode 100644 index 0000000..4c3b04f --- /dev/null +++ b/src/_.rs @@ -0,0 +1,241 @@ +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Metadata { + #[prost(string, tag = "3")] + pub r#type: ::prost::alloc::string::String, + #[prost(string, tag = "8")] + pub client_ip: ::prost::alloc::string::String, + #[prost(map = "string, string", tag = "7")] + pub headers: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Payload { + #[prost(message, optional, tag = "2")] + pub metadata: ::core::option::Option, + #[prost(message, optional, tag = "3")] + pub body: ::core::option::Option<::prost_types::Any>, +} +/// Generated client implementations. +pub mod request_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 RequestClient { + inner: tonic::client::Grpc, + } + impl RequestClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl RequestClient + 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, + ) -> RequestClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + RequestClient::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 + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// Sends a commonRequest + pub async fn request( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, 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("/Request/request"); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new("Request", "request")); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated client implementations. +pub mod bi_request_stream_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 BiRequestStreamClient { + inner: tonic::client::Grpc, + } + impl BiRequestStreamClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl BiRequestStreamClient + 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, + ) -> BiRequestStreamClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + BiRequestStreamClient::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 + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// Sends a biStreamRequest + pub async fn request_bi_stream( + &mut self, + request: impl tonic::IntoStreamingRequest, + ) -> std::result::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( + "/BiRequestStream/requestBiStream", + ); + let mut req = request.into_streaming_request(); + req.extensions_mut() + .insert(GrpcMethod::new("BiRequestStream", "requestBiStream")); + self.inner.streaming(req, path, codec).await + } + } +} diff --git a/src/common/remote/grpc/tonic.rs b/src/common/remote/grpc/tonic.rs index 4cae88b..14a0d4e 100644 --- a/src/common/remote/grpc/tonic.rs +++ b/src/common/remote/grpc/tonic.rs @@ -5,8 +5,7 @@ use std::{ }; use futures::{Future, StreamExt}; -use http::Uri; -use tonic::transport::{Channel, Endpoint}; +use tonic::transport::{Uri, Channel, Endpoint}; use tower::{layer::util::Stack, Service}; use tracing::{debug, debug_span, error, Instrument}; diff --git a/src/lib.rs b/src/lib.rs index ae2752e..8888af3 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -72,10 +72,10 @@ mod config; mod naming; #[allow(dead_code)] +#[path = ""] mod nacos_proto { - pub mod v2 { - tonic::include_proto!("_"); - } + #[path = "_.rs"] + pub mod v2; } #[cfg(test)] diff --git a/tests/proto_build.rs b/tests/proto_build.rs new file mode 100644 index 0000000..f1a7b4c --- /dev/null +++ b/tests/proto_build.rs @@ -0,0 +1,29 @@ +// Licensed to the Apache Software Foundation (ASF) under one or more +// contributor license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright ownership. +// The ASF licenses this file to You under the Apache License, Version 2.0 +// (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +// This test helps to keep files generated and used by tonic_build(proto) update to date. +// If the generated files has been changed, please commit they. +#[test] +#[ignore] +fn build_proto() { + tonic_build::configure() + .build_client(true) + .build_server(false) + .build_transport(true) + .out_dir("src") + .compile(&["./proto/nacos_grpc_service.proto"], &["./proto"]) + .unwrap(); +}