diff --git a/utils/quartz-proto/build.rs b/utils/quartz-proto/build.rs
index b164a31..755f1e0 100644
--- a/utils/quartz-proto/build.rs
+++ b/utils/quartz-proto/build.rs
@@ -1,4 +1,6 @@
fn main() -> Result<(), Box<dyn std::error::Error>> {
- tonic_build::compile_protos("proto/quartz.proto")?;
+ tonic_build::configure()
+ .out_dir("src/prost")
+ .compile(&["proto/quartz.proto"], &["proto"])?;
Ok(())
}
diff --git a/utils/quartz-proto/src/lib.rs b/utils/quartz-proto/src/lib.rs
index 75a72f8..60fef7c 100644
--- a/utils/quartz-proto/src/lib.rs
+++ b/utils/quartz-proto/src/lib.rs
@@ -1,5 +1,5 @@
#![allow(clippy::unwrap_used, unused_qualifications)]
pub mod quartz {
- tonic::include_proto!("quartz");
+ include!(concat!("prost/", "quartz.rs"));
}
diff --git a/utils/quartz-proto/src/prost/quartz.rs b/utils/quartz-proto/src/prost/quartz.rs
new file mode 100644
index 0000000..10aff4b
--- /dev/null
+++ b/utils/quartz-proto/src/prost/quartz.rs
@@ -0,0 +1,383 @@
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct InstantiateRequest {}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct InstantiateResponse {
+ #[prost(string, tag = "1")]
+ pub message: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SessionCreateRequest {}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SessionCreateResponse {
+ #[prost(string, tag = "1")]
+ pub message: ::prost::alloc::string::String,
+}
+/// Generated client implementations.
+pub mod core_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 CoreClient<T> {
+ inner: tonic::client::Grpc<T>,
+ }
+ impl CoreClient<tonic::transport::Channel> {
+ /// 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: TryInto<tonic::transport::Endpoint>,
+ D::Error: Into<StdError>,
+ {
+ let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+ Ok(Self::new(conn))
+ }
+ }
+ impl<T> CoreClient<T>
+ where
+ T: tonic::client::GrpcService<tonic::body::BoxBody>,
+ T::Error: Into<StdError>,
+ T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+ <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+ inner: T,
+ interceptor: F,
+ ) -> CoreClient<InterceptedService<T, F>>
+ where
+ F: tonic::service::Interceptor,
+ T::ResponseBody: Default,
+ T: tonic::codegen::Service<
+ http::Request<tonic::body::BoxBody>,
+ Response = http::Response<
+ <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+ >,
+ >,
+ <T as tonic::codegen::Service<
+ http::Request<tonic::body::BoxBody>,
+ >>::Error: Into<StdError> + Send + Sync,
+ {
+ CoreClient::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
+ }
+ pub async fn instantiate(
+ &mut self,
+ request: impl tonic::IntoRequest<super::InstantiateRequest>,
+ ) -> std::result::Result<
+ tonic::Response<super::InstantiateResponse>,
+ 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("/quartz.Core/Instantiate");
+ let mut req = request.into_request();
+ req.extensions_mut().insert(GrpcMethod::new("quartz.Core", "Instantiate"));
+ self.inner.unary(req, path, codec).await
+ }
+ pub async fn session_create(
+ &mut self,
+ request: impl tonic::IntoRequest<super::SessionCreateRequest>,
+ ) -> std::result::Result<
+ tonic::Response<super::SessionCreateResponse>,
+ 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(
+ "/quartz.Core/SessionCreate",
+ );
+ let mut req = request.into_request();
+ req.extensions_mut().insert(GrpcMethod::new("quartz.Core", "SessionCreate"));
+ self.inner.unary(req, path, codec).await
+ }
+ }
+}
+/// Generated server implementations.
+pub mod core_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 CoreServer.
+ #[async_trait]
+ pub trait Core: Send + Sync + 'static {
+ async fn instantiate(
+ &self,
+ request: tonic::Request<super::InstantiateRequest>,
+ ) -> std::result::Result<
+ tonic::Response<super::InstantiateResponse>,
+ tonic::Status,
+ >;
+ async fn session_create(
+ &self,
+ request: tonic::Request<super::SessionCreateRequest>,
+ ) -> std::result::Result<
+ tonic::Response<super::SessionCreateResponse>,
+ tonic::Status,
+ >;
+ }
+ #[derive(Debug)]
+ pub struct CoreServer<T: Core> {
+ inner: _Inner<T>,
+ accept_compression_encodings: EnabledCompressionEncodings,
+ send_compression_encodings: EnabledCompressionEncodings,
+ max_decoding_message_size: Option<usize>,
+ max_encoding_message_size: Option<usize>,
+ }
+ struct _Inner<T>(Arc<T>);
+ impl<T: Core> CoreServer<T> {
+ pub fn new(inner: T) -> Self {
+ Self::from_arc(Arc::new(inner))
+ }
+ pub fn from_arc(inner: Arc<T>) -> Self {
+ let inner = _Inner(inner);
+ Self {
+ inner,
+ accept_compression_encodings: Default::default(),
+ send_compression_encodings: Default::default(),
+ max_decoding_message_size: None,
+ max_encoding_message_size: None,
+ }
+ }
+ pub fn with_interceptor<F>(
+ inner: T,
+ interceptor: F,
+ ) -> InterceptedService<Self, F>
+ 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
+ }
+ /// Limits the maximum size of a decoded message.
+ ///
+ /// Default: `4MB`
+ #[must_use]
+ pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+ self.max_decoding_message_size = Some(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.max_encoding_message_size = Some(limit);
+ self
+ }
+ }
+ impl<T, B> tonic::codegen::Service<http::Request<B>> for CoreServer<T>
+ where
+ T: Core,
+ B: Body + Send + 'static,
+ B::Error: Into<StdError> + Send + 'static,
+ {
+ type Response = http::Response<tonic::body::BoxBody>;
+ type Error = std::convert::Infallible;
+ type Future = BoxFuture<Self::Response, Self::Error>;
+ fn poll_ready(
+ &mut self,
+ _cx: &mut Context<'_>,
+ ) -> Poll<std::result::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() {
+ "/quartz.Core/Instantiate" => {
+ #[allow(non_camel_case_types)]
+ struct InstantiateSvc<T: Core>(pub Arc<T>);
+ impl<T: Core> tonic::server::UnaryService<super::InstantiateRequest>
+ for InstantiateSvc<T> {
+ type Response = super::InstantiateResponse;
+ type Future = BoxFuture<
+ tonic::Response<Self::Response>,
+ tonic::Status,
+ >;
+ fn call(
+ &mut self,
+ request: tonic::Request<super::InstantiateRequest>,
+ ) -> Self::Future {
+ let inner = Arc::clone(&self.0);
+ let fut = async move {
+ <T as Core>::instantiate(&inner, request).await
+ };
+ Box::pin(fut)
+ }
+ }
+ let accept_compression_encodings = self.accept_compression_encodings;
+ let send_compression_encodings = self.send_compression_encodings;
+ let max_decoding_message_size = self.max_decoding_message_size;
+ let max_encoding_message_size = self.max_encoding_message_size;
+ let inner = self.inner.clone();
+ let fut = async move {
+ let inner = inner.0;
+ let method = InstantiateSvc(inner);
+ let codec = tonic::codec::ProstCodec::default();
+ let mut grpc = tonic::server::Grpc::new(codec)
+ .apply_compression_config(
+ accept_compression_encodings,
+ send_compression_encodings,
+ )
+ .apply_max_message_size_config(
+ max_decoding_message_size,
+ max_encoding_message_size,
+ );
+ let res = grpc.unary(method, req).await;
+ Ok(res)
+ };
+ Box::pin(fut)
+ }
+ "/quartz.Core/SessionCreate" => {
+ #[allow(non_camel_case_types)]
+ struct SessionCreateSvc<T: Core>(pub Arc<T>);
+ impl<
+ T: Core,
+ > tonic::server::UnaryService<super::SessionCreateRequest>
+ for SessionCreateSvc<T> {
+ type Response = super::SessionCreateResponse;
+ type Future = BoxFuture<
+ tonic::Response<Self::Response>,
+ tonic::Status,
+ >;
+ fn call(
+ &mut self,
+ request: tonic::Request<super::SessionCreateRequest>,
+ ) -> Self::Future {
+ let inner = Arc::clone(&self.0);
+ let fut = async move {
+ <T as Core>::session_create(&inner, request).await
+ };
+ Box::pin(fut)
+ }
+ }
+ let accept_compression_encodings = self.accept_compression_encodings;
+ let send_compression_encodings = self.send_compression_encodings;
+ let max_decoding_message_size = self.max_decoding_message_size;
+ let max_encoding_message_size = self.max_encoding_message_size;
+ let inner = self.inner.clone();
+ let fut = async move {
+ let inner = inner.0;
+ let method = SessionCreateSvc(inner);
+ let codec = tonic::codec::ProstCodec::default();
+ let mut grpc = tonic::server::Grpc::new(codec)
+ .apply_compression_config(
+ accept_compression_encodings,
+ send_compression_encodings,
+ )
+ .apply_max_message_size_config(
+ max_decoding_message_size,
+ max_encoding_message_size,
+ );
+ let res = grpc.unary(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<T: Core> Clone for CoreServer<T> {
+ 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,
+ max_decoding_message_size: self.max_decoding_message_size,
+ max_encoding_message_size: self.max_encoding_message_size,
+ }
+ }
+ }
+ impl<T: Core> Clone for _Inner<T> {
+ fn clone(&self) -> Self {
+ Self(Arc::clone(&self.0))
+ }
+ }
+ 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: Core> tonic::server::NamedService for CoreServer<T> {
+ const NAME: &'static str = "quartz.Core";
+ }
+}