pub mod accounts_client {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
use tonic::codegen::http::Uri;
#[derive(Debug, Clone)]
pub struct AccountsClient<T> {
inner: tonic::client::Grpc<T>,
}
impl AccountsClient<tonic::transport::Channel> {
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> AccountsClient<T>
where
T: tonic::client::GrpcService<tonic::body::Body>,
T::Error: Into<StdError>,
T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
<T::ResponseBody as Body>::Error: Into<StdError> + std::marker::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,
) -> AccountsClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T::ResponseBody: Default,
T: tonic::codegen::Service<
http::Request<tonic::body::Body>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<
http::Request<tonic::body::Body>,
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
{
AccountsClient::new(InterceptedService::new(inner, interceptor))
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.send_compressed(encoding);
self
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.accept_compressed(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.inner = self.inner.max_decoding_message_size(limit);
self
}
#[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 list_accounts(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::AccountsView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Accounts/ListAccounts",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Accounts", "ListAccounts"));
self.inner.unary(req, path, codec).await
}
pub async fn begin_sign_in(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::platform::VendorId>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::SignIn>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Accounts/BeginSignIn",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Accounts", "BeginSignIn"));
self.inner.unary(req, path, codec).await
}
pub async fn disconnect_account(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::platform::VendorProfile>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::Empty>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Accounts/DisconnectAccount",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(
GrpcMethod::new("arvo.services.v1.Accounts", "DisconnectAccount"),
);
self.inner.unary(req, path, codec).await
}
pub async fn store_account_keys(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::platform::AccountKeys>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::Empty>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Accounts/StoreAccountKeys",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(
GrpcMethod::new("arvo.services.v1.Accounts", "StoreAccountKeys"),
);
self.inner.unary(req, path, codec).await
}
}
}
pub mod accounts_server {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
#[async_trait]
pub trait Accounts: std::marker::Send + std::marker::Sync + 'static {
async fn list_accounts(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::AccountsView>,
tonic::Status,
>;
async fn begin_sign_in(
&self,
request: tonic::Request<::arvo_api::platform::VendorId>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::SignIn>,
tonic::Status,
>;
async fn disconnect_account(
&self,
request: tonic::Request<::arvo_api::platform::VendorProfile>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::Empty>,
tonic::Status,
>;
async fn store_account_keys(
&self,
request: tonic::Request<::arvo_api::platform::AccountKeys>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::Empty>,
tonic::Status,
>;
}
#[derive(Debug)]
pub struct AccountsServer<T> {
inner: Arc<T>,
accept_compression_encodings: EnabledCompressionEncodings,
send_compression_encodings: EnabledCompressionEncodings,
max_decoding_message_size: Option<usize>,
max_encoding_message_size: Option<usize>,
}
impl<T> AccountsServer<T> {
pub fn new(inner: T) -> Self {
Self::from_arc(Arc::new(inner))
}
pub fn from_arc(inner: Arc<T>) -> Self {
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)
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.accept_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.send_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.max_decoding_message_size = Some(limit);
self
}
#[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 AccountsServer<T>
where
T: Accounts,
B: Body + std::marker::Send + 'static,
B::Error: Into<StdError> + std::marker::Send + 'static,
{
type Response = http::Response<tonic::body::Body>;
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 {
match req.uri().path() {
"/arvo.services.v1.Accounts/ListAccounts" => {
#[allow(non_camel_case_types)]
struct ListAccountsSvc<T: Accounts>(pub Arc<T>);
impl<
T: Accounts,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ListAccountsSvc<T> {
type Response = ::arvo_api::platform::AccountsView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Accounts>::list_accounts(&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 method = ListAccountsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Accounts/BeginSignIn" => {
#[allow(non_camel_case_types)]
struct BeginSignInSvc<T: Accounts>(pub Arc<T>);
impl<
T: Accounts,
> tonic::server::UnaryService<::arvo_api::platform::VendorId>
for BeginSignInSvc<T> {
type Response = ::arvo_api::platform::SignIn;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::platform::VendorId>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Accounts>::begin_sign_in(&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 method = BeginSignInSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Accounts/DisconnectAccount" => {
#[allow(non_camel_case_types)]
struct DisconnectAccountSvc<T: Accounts>(pub Arc<T>);
impl<
T: Accounts,
> tonic::server::UnaryService<::arvo_api::platform::VendorProfile>
for DisconnectAccountSvc<T> {
type Response = ::arvo_api::common::Empty;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::platform::VendorProfile>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Accounts>::disconnect_account(&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 method = DisconnectAccountSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Accounts/StoreAccountKeys" => {
#[allow(non_camel_case_types)]
struct StoreAccountKeysSvc<T: Accounts>(pub Arc<T>);
impl<
T: Accounts,
> tonic::server::UnaryService<::arvo_api::platform::AccountKeys>
for StoreAccountKeysSvc<T> {
type Response = ::arvo_api::common::Empty;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::platform::AccountKeys>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Accounts>::store_account_keys(&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 method = StoreAccountKeysSvc(inner);
let codec = tonic_prost::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 {
let mut response = http::Response::new(
tonic::body::Body::default(),
);
let headers = response.headers_mut();
headers
.insert(
tonic::Status::GRPC_STATUS,
(tonic::Code::Unimplemented as i32).into(),
);
headers
.insert(
http::header::CONTENT_TYPE,
tonic::metadata::GRPC_CONTENT_TYPE,
);
Ok(response)
})
}
}
}
}
impl<T> Clone for AccountsServer<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,
}
}
}
pub const SERVICE_NAME: &str = "arvo.services.v1.Accounts";
impl<T> tonic::server::NamedService for AccountsServer<T> {
const NAME: &'static str = SERVICE_NAME;
}
}
pub mod market_client {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
use tonic::codegen::http::Uri;
#[derive(Debug, Clone)]
pub struct MarketClient<T> {
inner: tonic::client::Grpc<T>,
}
impl MarketClient<tonic::transport::Channel> {
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> MarketClient<T>
where
T: tonic::client::GrpcService<tonic::body::Body>,
T::Error: Into<StdError>,
T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
<T::ResponseBody as Body>::Error: Into<StdError> + std::marker::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,
) -> MarketClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T::ResponseBody: Default,
T: tonic::codegen::Service<
http::Request<tonic::body::Body>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<
http::Request<tonic::body::Body>,
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
{
MarketClient::new(InterceptedService::new(inner, interceptor))
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.send_compressed(encoding);
self
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.accept_compressed(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.inner = self.inner.max_decoding_message_size(limit);
self
}
#[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 view_library(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::market::DataLibraryView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Market/ViewLibrary",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Market", "ViewLibrary"));
self.inner.unary(req, path, codec).await
}
pub async fn list_sources(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::market::SourcesView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Market/ListSources",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Market", "ListSources"));
self.inner.unary(req, path, codec).await
}
pub async fn search_instruments(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::market::InstrumentSearch>,
) -> std::result::Result<
tonic::Response<::arvo_api::market::MatchesView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Market/SearchInstruments",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Market", "SearchInstruments"));
self.inner.unary(req, path, codec).await
}
pub async fn fetch_bars(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::market::FetchRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::market::FetchView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Market/FetchBars",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Market", "FetchBars"));
self.inner.unary(req, path, codec).await
}
pub async fn compare_sources(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::market::CompareRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::market::SourceComparisonView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Market/CompareSources",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Market", "CompareSources"));
self.inner.unary(req, path, codec).await
}
pub async fn watchlist(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::market::WatchlistView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Market/Watchlist",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Market", "Watchlist"));
self.inner.unary(req, path, codec).await
}
pub async fn stream_quotes(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<tonic::codec::Streaming<::arvo_api::market::QuoteTick>>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Market/StreamQuotes",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Market", "StreamQuotes"));
self.inner.server_streaming(req, path, codec).await
}
}
}
pub mod market_server {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
#[async_trait]
pub trait Market: std::marker::Send + std::marker::Sync + 'static {
async fn view_library(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::market::DataLibraryView>,
tonic::Status,
>;
async fn list_sources(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::market::SourcesView>,
tonic::Status,
>;
async fn search_instruments(
&self,
request: tonic::Request<::arvo_api::market::InstrumentSearch>,
) -> std::result::Result<
tonic::Response<::arvo_api::market::MatchesView>,
tonic::Status,
>;
async fn fetch_bars(
&self,
request: tonic::Request<::arvo_api::market::FetchRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::market::FetchView>,
tonic::Status,
>;
async fn compare_sources(
&self,
request: tonic::Request<::arvo_api::market::CompareRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::market::SourceComparisonView>,
tonic::Status,
>;
async fn watchlist(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::market::WatchlistView>,
tonic::Status,
>;
type StreamQuotesStream: tonic::codegen::tokio_stream::Stream<
Item = std::result::Result<::arvo_api::market::QuoteTick, tonic::Status>,
>
+ std::marker::Send
+ 'static;
async fn stream_quotes(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<Self::StreamQuotesStream>,
tonic::Status,
>;
}
#[derive(Debug)]
pub struct MarketServer<T> {
inner: Arc<T>,
accept_compression_encodings: EnabledCompressionEncodings,
send_compression_encodings: EnabledCompressionEncodings,
max_decoding_message_size: Option<usize>,
max_encoding_message_size: Option<usize>,
}
impl<T> MarketServer<T> {
pub fn new(inner: T) -> Self {
Self::from_arc(Arc::new(inner))
}
pub fn from_arc(inner: Arc<T>) -> Self {
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)
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.accept_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.send_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.max_decoding_message_size = Some(limit);
self
}
#[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 MarketServer<T>
where
T: Market,
B: Body + std::marker::Send + 'static,
B::Error: Into<StdError> + std::marker::Send + 'static,
{
type Response = http::Response<tonic::body::Body>;
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 {
match req.uri().path() {
"/arvo.services.v1.Market/ViewLibrary" => {
#[allow(non_camel_case_types)]
struct ViewLibrarySvc<T: Market>(pub Arc<T>);
impl<
T: Market,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ViewLibrarySvc<T> {
type Response = ::arvo_api::market::DataLibraryView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Market>::view_library(&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 method = ViewLibrarySvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Market/ListSources" => {
#[allow(non_camel_case_types)]
struct ListSourcesSvc<T: Market>(pub Arc<T>);
impl<
T: Market,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ListSourcesSvc<T> {
type Response = ::arvo_api::market::SourcesView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Market>::list_sources(&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 method = ListSourcesSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Market/SearchInstruments" => {
#[allow(non_camel_case_types)]
struct SearchInstrumentsSvc<T: Market>(pub Arc<T>);
impl<
T: Market,
> tonic::server::UnaryService<::arvo_api::market::InstrumentSearch>
for SearchInstrumentsSvc<T> {
type Response = ::arvo_api::market::MatchesView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::market::InstrumentSearch>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Market>::search_instruments(&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 method = SearchInstrumentsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Market/FetchBars" => {
#[allow(non_camel_case_types)]
struct FetchBarsSvc<T: Market>(pub Arc<T>);
impl<
T: Market,
> tonic::server::UnaryService<::arvo_api::market::FetchRequest>
for FetchBarsSvc<T> {
type Response = ::arvo_api::market::FetchView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::market::FetchRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Market>::fetch_bars(&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 method = FetchBarsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Market/CompareSources" => {
#[allow(non_camel_case_types)]
struct CompareSourcesSvc<T: Market>(pub Arc<T>);
impl<
T: Market,
> tonic::server::UnaryService<::arvo_api::market::CompareRequest>
for CompareSourcesSvc<T> {
type Response = ::arvo_api::market::SourceComparisonView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::market::CompareRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Market>::compare_sources(&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 method = CompareSourcesSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Market/Watchlist" => {
#[allow(non_camel_case_types)]
struct WatchlistSvc<T: Market>(pub Arc<T>);
impl<
T: Market,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for WatchlistSvc<T> {
type Response = ::arvo_api::market::WatchlistView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Market>::watchlist(&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 method = WatchlistSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Market/StreamQuotes" => {
#[allow(non_camel_case_types)]
struct StreamQuotesSvc<T: Market>(pub Arc<T>);
impl<
T: Market,
> tonic::server::ServerStreamingService<::arvo_api::common::Empty>
for StreamQuotesSvc<T> {
type Response = ::arvo_api::market::QuoteTick;
type ResponseStream = T::StreamQuotesStream;
type Future = BoxFuture<
tonic::Response<Self::ResponseStream>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Market>::stream_quotes(&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 method = StreamQuotesSvc(inner);
let codec = tonic_prost::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.server_streaming(method, req).await;
Ok(res)
};
Box::pin(fut)
}
_ => {
Box::pin(async move {
let mut response = http::Response::new(
tonic::body::Body::default(),
);
let headers = response.headers_mut();
headers
.insert(
tonic::Status::GRPC_STATUS,
(tonic::Code::Unimplemented as i32).into(),
);
headers
.insert(
http::header::CONTENT_TYPE,
tonic::metadata::GRPC_CONTENT_TYPE,
);
Ok(response)
})
}
}
}
}
impl<T> Clone for MarketServer<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,
}
}
}
pub const SERVICE_NAME: &str = "arvo.services.v1.Market";
impl<T> tonic::server::NamedService for MarketServer<T> {
const NAME: &'static str = SERVICE_NAME;
}
}
pub mod platform_client {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
use tonic::codegen::http::Uri;
#[derive(Debug, Clone)]
pub struct PlatformClient<T> {
inner: tonic::client::Grpc<T>,
}
impl PlatformClient<tonic::transport::Channel> {
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> PlatformClient<T>
where
T: tonic::client::GrpcService<tonic::body::Body>,
T::Error: Into<StdError>,
T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
<T::ResponseBody as Body>::Error: Into<StdError> + std::marker::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,
) -> PlatformClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T::ResponseBody: Default,
T: tonic::codegen::Service<
http::Request<tonic::body::Body>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<
http::Request<tonic::body::Body>,
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
{
PlatformClient::new(InterceptedService::new(inner, interceptor))
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.send_compressed(encoding);
self
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.accept_compressed(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.inner = self.inner.max_decoding_message_size(limit);
self
}
#[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 list_jobs(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::JobsView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Platform/ListJobs",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Platform", "ListJobs"));
self.inner.unary(req, path, codec).await
}
pub async fn run_job(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::platform::JobId>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::Empty>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Platform/RunJob",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Platform", "RunJob"));
self.inner.unary(req, path, codec).await
}
pub async fn list_plugins(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::PluginsView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Platform/ListPlugins",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Platform", "ListPlugins"));
self.inner.unary(req, path, codec).await
}
pub async fn refresh_plugins(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::PluginsView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Platform/RefreshPlugins",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Platform", "RefreshPlugins"));
self.inner.unary(req, path, codec).await
}
pub async fn list_signals(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::SignalsView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Platform/ListSignals",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Platform", "ListSignals"));
self.inner.unary(req, path, codec).await
}
pub async fn reconcile_providers(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::Empty>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Platform/ReconcileProviders",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(
GrpcMethod::new("arvo.services.v1.Platform", "ReconcileProviders"),
);
self.inner.unary(req, path, codec).await
}
pub async fn extension_strategies(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::ExtensionStrategiesView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Platform/ExtensionStrategies",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(
GrpcMethod::new("arvo.services.v1.Platform", "ExtensionStrategies"),
);
self.inner.unary(req, path, codec).await
}
}
}
pub mod platform_server {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
#[async_trait]
pub trait Platform: std::marker::Send + std::marker::Sync + 'static {
async fn list_jobs(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::JobsView>,
tonic::Status,
>;
async fn run_job(
&self,
request: tonic::Request<::arvo_api::platform::JobId>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::Empty>,
tonic::Status,
>;
async fn list_plugins(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::PluginsView>,
tonic::Status,
>;
async fn refresh_plugins(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::PluginsView>,
tonic::Status,
>;
async fn list_signals(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::SignalsView>,
tonic::Status,
>;
async fn reconcile_providers(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::Empty>,
tonic::Status,
>;
async fn extension_strategies(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::ExtensionStrategiesView>,
tonic::Status,
>;
}
#[derive(Debug)]
pub struct PlatformServer<T> {
inner: Arc<T>,
accept_compression_encodings: EnabledCompressionEncodings,
send_compression_encodings: EnabledCompressionEncodings,
max_decoding_message_size: Option<usize>,
max_encoding_message_size: Option<usize>,
}
impl<T> PlatformServer<T> {
pub fn new(inner: T) -> Self {
Self::from_arc(Arc::new(inner))
}
pub fn from_arc(inner: Arc<T>) -> Self {
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)
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.accept_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.send_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.max_decoding_message_size = Some(limit);
self
}
#[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 PlatformServer<T>
where
T: Platform,
B: Body + std::marker::Send + 'static,
B::Error: Into<StdError> + std::marker::Send + 'static,
{
type Response = http::Response<tonic::body::Body>;
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 {
match req.uri().path() {
"/arvo.services.v1.Platform/ListJobs" => {
#[allow(non_camel_case_types)]
struct ListJobsSvc<T: Platform>(pub Arc<T>);
impl<
T: Platform,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ListJobsSvc<T> {
type Response = ::arvo_api::platform::JobsView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Platform>::list_jobs(&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 method = ListJobsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Platform/RunJob" => {
#[allow(non_camel_case_types)]
struct RunJobSvc<T: Platform>(pub Arc<T>);
impl<
T: Platform,
> tonic::server::UnaryService<::arvo_api::platform::JobId>
for RunJobSvc<T> {
type Response = ::arvo_api::common::Empty;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::platform::JobId>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Platform>::run_job(&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 method = RunJobSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Platform/ListPlugins" => {
#[allow(non_camel_case_types)]
struct ListPluginsSvc<T: Platform>(pub Arc<T>);
impl<
T: Platform,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ListPluginsSvc<T> {
type Response = ::arvo_api::platform::PluginsView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Platform>::list_plugins(&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 method = ListPluginsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Platform/RefreshPlugins" => {
#[allow(non_camel_case_types)]
struct RefreshPluginsSvc<T: Platform>(pub Arc<T>);
impl<
T: Platform,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for RefreshPluginsSvc<T> {
type Response = ::arvo_api::platform::PluginsView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Platform>::refresh_plugins(&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 method = RefreshPluginsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Platform/ListSignals" => {
#[allow(non_camel_case_types)]
struct ListSignalsSvc<T: Platform>(pub Arc<T>);
impl<
T: Platform,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ListSignalsSvc<T> {
type Response = ::arvo_api::platform::SignalsView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Platform>::list_signals(&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 method = ListSignalsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Platform/ReconcileProviders" => {
#[allow(non_camel_case_types)]
struct ReconcileProvidersSvc<T: Platform>(pub Arc<T>);
impl<
T: Platform,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ReconcileProvidersSvc<T> {
type Response = ::arvo_api::common::Empty;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Platform>::reconcile_providers(&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 method = ReconcileProvidersSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Platform/ExtensionStrategies" => {
#[allow(non_camel_case_types)]
struct ExtensionStrategiesSvc<T: Platform>(pub Arc<T>);
impl<
T: Platform,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ExtensionStrategiesSvc<T> {
type Response = ::arvo_api::platform::ExtensionStrategiesView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Platform>::extension_strategies(&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 method = ExtensionStrategiesSvc(inner);
let codec = tonic_prost::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 {
let mut response = http::Response::new(
tonic::body::Body::default(),
);
let headers = response.headers_mut();
headers
.insert(
tonic::Status::GRPC_STATUS,
(tonic::Code::Unimplemented as i32).into(),
);
headers
.insert(
http::header::CONTENT_TYPE,
tonic::metadata::GRPC_CONTENT_TYPE,
);
Ok(response)
})
}
}
}
}
impl<T> Clone for PlatformServer<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,
}
}
}
pub const SERVICE_NAME: &str = "arvo.services.v1.Platform";
impl<T> tonic::server::NamedService for PlatformServer<T> {
const NAME: &'static str = SERVICE_NAME;
}
}
pub mod portfolio_client {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
use tonic::codegen::http::Uri;
#[derive(Debug, Clone)]
pub struct PortfolioClient<T> {
inner: tonic::client::Grpc<T>,
}
impl PortfolioClient<tonic::transport::Channel> {
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> PortfolioClient<T>
where
T: tonic::client::GrpcService<tonic::body::Body>,
T::Error: Into<StdError>,
T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
<T::ResponseBody as Body>::Error: Into<StdError> + std::marker::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,
) -> PortfolioClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T::ResponseBody: Default,
T: tonic::codegen::Service<
http::Request<tonic::body::Body>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<
http::Request<tonic::body::Body>,
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
{
PortfolioClient::new(InterceptedService::new(inner, interceptor))
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.send_compressed(encoding);
self
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.accept_compressed(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.inner = self.inner.max_decoding_message_size(limit);
self
}
#[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 list_portfolios(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::portfolio::PortfolioLibraryView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Portfolio/ListPortfolios",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Portfolio", "ListPortfolios"));
self.inner.unary(req, path, codec).await
}
pub async fn sync_accounts(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::portfolio::PortfolioLibraryView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Portfolio/SyncAccounts",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Portfolio", "SyncAccounts"));
self.inner.unary(req, path, codec).await
}
pub async fn sync_portfolio(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::portfolio::PortfolioName>,
) -> std::result::Result<
tonic::Response<::arvo_api::portfolio::PortfolioLibraryView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Portfolio/SyncPortfolio",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Portfolio", "SyncPortfolio"));
self.inner.unary(req, path, codec).await
}
}
}
pub mod portfolio_server {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
#[async_trait]
pub trait Portfolio: std::marker::Send + std::marker::Sync + 'static {
async fn list_portfolios(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::portfolio::PortfolioLibraryView>,
tonic::Status,
>;
async fn sync_accounts(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::portfolio::PortfolioLibraryView>,
tonic::Status,
>;
async fn sync_portfolio(
&self,
request: tonic::Request<::arvo_api::portfolio::PortfolioName>,
) -> std::result::Result<
tonic::Response<::arvo_api::portfolio::PortfolioLibraryView>,
tonic::Status,
>;
}
#[derive(Debug)]
pub struct PortfolioServer<T> {
inner: Arc<T>,
accept_compression_encodings: EnabledCompressionEncodings,
send_compression_encodings: EnabledCompressionEncodings,
max_decoding_message_size: Option<usize>,
max_encoding_message_size: Option<usize>,
}
impl<T> PortfolioServer<T> {
pub fn new(inner: T) -> Self {
Self::from_arc(Arc::new(inner))
}
pub fn from_arc(inner: Arc<T>) -> Self {
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)
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.accept_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.send_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.max_decoding_message_size = Some(limit);
self
}
#[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 PortfolioServer<T>
where
T: Portfolio,
B: Body + std::marker::Send + 'static,
B::Error: Into<StdError> + std::marker::Send + 'static,
{
type Response = http::Response<tonic::body::Body>;
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 {
match req.uri().path() {
"/arvo.services.v1.Portfolio/ListPortfolios" => {
#[allow(non_camel_case_types)]
struct ListPortfoliosSvc<T: Portfolio>(pub Arc<T>);
impl<
T: Portfolio,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ListPortfoliosSvc<T> {
type Response = ::arvo_api::portfolio::PortfolioLibraryView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Portfolio>::list_portfolios(&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 method = ListPortfoliosSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Portfolio/SyncAccounts" => {
#[allow(non_camel_case_types)]
struct SyncAccountsSvc<T: Portfolio>(pub Arc<T>);
impl<
T: Portfolio,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for SyncAccountsSvc<T> {
type Response = ::arvo_api::portfolio::PortfolioLibraryView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Portfolio>::sync_accounts(&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 method = SyncAccountsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Portfolio/SyncPortfolio" => {
#[allow(non_camel_case_types)]
struct SyncPortfolioSvc<T: Portfolio>(pub Arc<T>);
impl<
T: Portfolio,
> tonic::server::UnaryService<::arvo_api::portfolio::PortfolioName>
for SyncPortfolioSvc<T> {
type Response = ::arvo_api::portfolio::PortfolioLibraryView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::portfolio::PortfolioName>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Portfolio>::sync_portfolio(&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 method = SyncPortfolioSvc(inner);
let codec = tonic_prost::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 {
let mut response = http::Response::new(
tonic::body::Body::default(),
);
let headers = response.headers_mut();
headers
.insert(
tonic::Status::GRPC_STATUS,
(tonic::Code::Unimplemented as i32).into(),
);
headers
.insert(
http::header::CONTENT_TYPE,
tonic::metadata::GRPC_CONTENT_TYPE,
);
Ok(response)
})
}
}
}
}
impl<T> Clone for PortfolioServer<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,
}
}
}
pub const SERVICE_NAME: &str = "arvo.services.v1.Portfolio";
impl<T> tonic::server::NamedService for PortfolioServer<T> {
const NAME: &'static str = SERVICE_NAME;
}
}
pub mod research_client {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
use tonic::codegen::http::Uri;
#[derive(Debug, Clone)]
pub struct ResearchClient<T> {
inner: tonic::client::Grpc<T>,
}
impl ResearchClient<tonic::transport::Channel> {
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> ResearchClient<T>
where
T: tonic::client::GrpcService<tonic::body::Body>,
T::Error: Into<StdError>,
T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
<T::ResponseBody as Body>::Error: Into<StdError> + std::marker::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,
) -> ResearchClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T::ResponseBody: Default,
T: tonic::codegen::Service<
http::Request<tonic::body::Body>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<
http::Request<tonic::body::Body>,
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
{
ResearchClient::new(InterceptedService::new(inner, interceptor))
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.send_compressed(encoding);
self
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.accept_compressed(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.inner = self.inner.max_decoding_message_size(limit);
self
}
#[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 list_strategies(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Strategies>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ListStrategies",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ListStrategies"));
self.inner.unary(req, path, codec).await
}
pub async fn list_instruments(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::market::Instruments>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ListInstruments",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ListInstruments"));
self.inner.unary(req, path, codec).await
}
pub async fn list_findings(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Findings>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ListFindings",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ListFindings"));
self.inner.unary(req, path, codec).await
}
pub async fn open_finding(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::FindingId>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Finding>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/OpenFinding",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "OpenFinding"));
self.inner.unary(req, path, codec).await
}
pub async fn run_study(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::RunRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Finding>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/RunStudy",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "RunStudy"));
self.inner.unary(req, path, codec).await
}
pub async fn run_walk_forward(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::RunRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Finding>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/RunWalkForward",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "RunWalkForward"));
self.inner.unary(req, path, codec).await
}
pub async fn record_finding(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::ReportRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Finding>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/RecordFinding",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "RecordFinding"));
self.inner.unary(req, path, codec).await
}
pub async fn attach_file(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::AttachRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Attachments>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/AttachFile",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "AttachFile"));
self.inner.unary(req, path, codec).await
}
pub async fn list_rulesets(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Rulesets>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ListRulesets",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ListRulesets"));
self.inner.unary(req, path, codec).await
}
pub async fn read_ruleset(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::RulesetPath>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::RulesetForm>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ReadRuleset",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ReadRuleset"));
self.inner.unary(req, path, codec).await
}
pub async fn write_ruleset(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::RulesetForm>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Ruleset>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/WriteRuleset",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "WriteRuleset"));
self.inner.unary(req, path, codec).await
}
pub async fn list_rules(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Rules>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ListRules",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ListRules"));
self.inner.unary(req, path, codec).await
}
pub async fn list_rule_files(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::RuleFiles>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ListRuleFiles",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ListRuleFiles"));
self.inner.unary(req, path, codec).await
}
pub async fn write_rule(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::RuleText>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::RuleFile>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/WriteRule",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "WriteRule"));
self.inner.unary(req, path, codec).await
}
pub async fn translate_pine(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::PineScript>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::PineTranslation>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/TranslatePine",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "TranslatePine"));
self.inner.unary(req, path, codec).await
}
pub async fn get_risk_model(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::RiskModel>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/GetRiskModel",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "GetRiskModel"));
self.inner.unary(req, path, codec).await
}
pub async fn view_study(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::StudyRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::StudyView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ViewStudy",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ViewStudy"));
self.inner.unary(req, path, codec).await
}
pub async fn view_walk_forward(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::StudyRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::WalkForwardView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ViewWalkForward",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ViewWalkForward"));
self.inner.unary(req, path, codec).await
}
pub async fn view_panel(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::PanelView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ViewPanel",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ViewPanel"));
self.inner.unary(req, path, codec).await
}
pub async fn run_panel(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::PanelRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::PanelView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/RunPanel",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "RunPanel"));
self.inner.unary(req, path, codec).await
}
pub async fn view_book(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::BookRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::StudyView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ViewBook",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ViewBook"));
self.inner.unary(req, path, codec).await
}
pub async fn view_history(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::HistoryView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ViewHistory",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ViewHistory"));
self.inner.unary(req, path, codec).await
}
pub async fn view_record(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::FindingId>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::RecordView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ViewRecord",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ViewRecord"));
self.inner.unary(req, path, codec).await
}
pub async fn view_replay(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::FindingId>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::ReplayView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ViewReplay",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ViewReplay"));
self.inner.unary(req, path, codec).await
}
pub async fn view_comparison(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::FindingIds>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::ComparisonView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ViewComparison",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ViewComparison"));
self.inner.unary(req, path, codec).await
}
pub async fn read_bars(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::BarsRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::BarsView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ReadBars",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ReadBars"));
self.inner.unary(req, path, codec).await
}
pub async fn stream_bars(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::BarsRequest>,
) -> std::result::Result<
tonic::Response<tonic::codec::Streaming<::arvo_api::research::BarsView>>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/StreamBars",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "StreamBars"));
self.inner.server_streaming(req, path, codec).await
}
pub async fn read_indicator(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::IndicatorRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::NamedCurveView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ReadIndicator",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ReadIndicator"));
self.inner.unary(req, path, codec).await
}
pub async fn view_regime(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::BarsRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::RegimeView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ViewRegime",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ViewRegime"));
self.inner.unary(req, path, codec).await
}
pub async fn view_review(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::ReviewRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::ReviewView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ViewReview",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ViewReview"));
self.inner.unary(req, path, codec).await
}
pub async fn rank_findings(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::RankRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Ranking>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/RankFindings",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "RankFindings"));
self.inner.unary(req, path, codec).await
}
pub async fn view_problems(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::ProblemsView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ViewProblems",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ViewProblems"));
self.inner.unary(req, path, codec).await
}
pub async fn list_attachments(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::FindingId>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Attachments>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/ListAttachments",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "ListAttachments"));
self.inner.unary(req, path, codec).await
}
pub async fn subscribe(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<tonic::codec::Streaming<::arvo_api::platform::EventView>>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Research/Subscribe",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Research", "Subscribe"));
self.inner.server_streaming(req, path, codec).await
}
}
}
pub mod research_server {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
#[async_trait]
pub trait Research: std::marker::Send + std::marker::Sync + 'static {
async fn list_strategies(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Strategies>,
tonic::Status,
>;
async fn list_instruments(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::market::Instruments>,
tonic::Status,
>;
async fn list_findings(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Findings>,
tonic::Status,
>;
async fn open_finding(
&self,
request: tonic::Request<::arvo_api::research::FindingId>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Finding>,
tonic::Status,
>;
async fn run_study(
&self,
request: tonic::Request<::arvo_api::research::RunRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Finding>,
tonic::Status,
>;
async fn run_walk_forward(
&self,
request: tonic::Request<::arvo_api::research::RunRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Finding>,
tonic::Status,
>;
async fn record_finding(
&self,
request: tonic::Request<::arvo_api::research::ReportRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Finding>,
tonic::Status,
>;
async fn attach_file(
&self,
request: tonic::Request<::arvo_api::research::AttachRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Attachments>,
tonic::Status,
>;
async fn list_rulesets(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Rulesets>,
tonic::Status,
>;
async fn read_ruleset(
&self,
request: tonic::Request<::arvo_api::research::RulesetPath>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::RulesetForm>,
tonic::Status,
>;
async fn write_ruleset(
&self,
request: tonic::Request<::arvo_api::research::RulesetForm>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Ruleset>,
tonic::Status,
>;
async fn list_rules(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Rules>,
tonic::Status,
>;
async fn list_rule_files(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::RuleFiles>,
tonic::Status,
>;
async fn write_rule(
&self,
request: tonic::Request<::arvo_api::research::RuleText>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::RuleFile>,
tonic::Status,
>;
async fn translate_pine(
&self,
request: tonic::Request<::arvo_api::research::PineScript>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::PineTranslation>,
tonic::Status,
>;
async fn get_risk_model(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::RiskModel>,
tonic::Status,
>;
async fn view_study(
&self,
request: tonic::Request<::arvo_api::research::StudyRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::StudyView>,
tonic::Status,
>;
async fn view_walk_forward(
&self,
request: tonic::Request<::arvo_api::research::StudyRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::WalkForwardView>,
tonic::Status,
>;
async fn view_panel(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::PanelView>,
tonic::Status,
>;
async fn run_panel(
&self,
request: tonic::Request<::arvo_api::research::PanelRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::PanelView>,
tonic::Status,
>;
async fn view_book(
&self,
request: tonic::Request<::arvo_api::research::BookRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::StudyView>,
tonic::Status,
>;
async fn view_history(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::HistoryView>,
tonic::Status,
>;
async fn view_record(
&self,
request: tonic::Request<::arvo_api::research::FindingId>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::RecordView>,
tonic::Status,
>;
async fn view_replay(
&self,
request: tonic::Request<::arvo_api::research::FindingId>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::ReplayView>,
tonic::Status,
>;
async fn view_comparison(
&self,
request: tonic::Request<::arvo_api::research::FindingIds>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::ComparisonView>,
tonic::Status,
>;
async fn read_bars(
&self,
request: tonic::Request<::arvo_api::research::BarsRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::BarsView>,
tonic::Status,
>;
type StreamBarsStream: tonic::codegen::tokio_stream::Stream<
Item = std::result::Result<::arvo_api::research::BarsView, tonic::Status>,
>
+ std::marker::Send
+ 'static;
async fn stream_bars(
&self,
request: tonic::Request<::arvo_api::research::BarsRequest>,
) -> std::result::Result<tonic::Response<Self::StreamBarsStream>, tonic::Status>;
async fn read_indicator(
&self,
request: tonic::Request<::arvo_api::research::IndicatorRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::NamedCurveView>,
tonic::Status,
>;
async fn view_regime(
&self,
request: tonic::Request<::arvo_api::research::BarsRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::RegimeView>,
tonic::Status,
>;
async fn view_review(
&self,
request: tonic::Request<::arvo_api::research::ReviewRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::ReviewView>,
tonic::Status,
>;
async fn rank_findings(
&self,
request: tonic::Request<::arvo_api::research::RankRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Ranking>,
tonic::Status,
>;
async fn view_problems(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::ProblemsView>,
tonic::Status,
>;
async fn list_attachments(
&self,
request: tonic::Request<::arvo_api::research::FindingId>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::Attachments>,
tonic::Status,
>;
type SubscribeStream: tonic::codegen::tokio_stream::Stream<
Item = std::result::Result<
::arvo_api::platform::EventView,
tonic::Status,
>,
>
+ std::marker::Send
+ 'static;
async fn subscribe(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<tonic::Response<Self::SubscribeStream>, tonic::Status>;
}
#[derive(Debug)]
pub struct ResearchServer<T> {
inner: Arc<T>,
accept_compression_encodings: EnabledCompressionEncodings,
send_compression_encodings: EnabledCompressionEncodings,
max_decoding_message_size: Option<usize>,
max_encoding_message_size: Option<usize>,
}
impl<T> ResearchServer<T> {
pub fn new(inner: T) -> Self {
Self::from_arc(Arc::new(inner))
}
pub fn from_arc(inner: Arc<T>) -> Self {
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)
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.accept_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.send_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.max_decoding_message_size = Some(limit);
self
}
#[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 ResearchServer<T>
where
T: Research,
B: Body + std::marker::Send + 'static,
B::Error: Into<StdError> + std::marker::Send + 'static,
{
type Response = http::Response<tonic::body::Body>;
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 {
match req.uri().path() {
"/arvo.services.v1.Research/ListStrategies" => {
#[allow(non_camel_case_types)]
struct ListStrategiesSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ListStrategiesSvc<T> {
type Response = ::arvo_api::research::Strategies;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::list_strategies(&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 method = ListStrategiesSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ListInstruments" => {
#[allow(non_camel_case_types)]
struct ListInstrumentsSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ListInstrumentsSvc<T> {
type Response = ::arvo_api::market::Instruments;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::list_instruments(&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 method = ListInstrumentsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ListFindings" => {
#[allow(non_camel_case_types)]
struct ListFindingsSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ListFindingsSvc<T> {
type Response = ::arvo_api::research::Findings;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::list_findings(&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 method = ListFindingsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/OpenFinding" => {
#[allow(non_camel_case_types)]
struct OpenFindingSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::FindingId>
for OpenFindingSvc<T> {
type Response = ::arvo_api::research::Finding;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::FindingId>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::open_finding(&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 method = OpenFindingSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/RunStudy" => {
#[allow(non_camel_case_types)]
struct RunStudySvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::RunRequest>
for RunStudySvc<T> {
type Response = ::arvo_api::research::Finding;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::RunRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::run_study(&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 method = RunStudySvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/RunWalkForward" => {
#[allow(non_camel_case_types)]
struct RunWalkForwardSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::RunRequest>
for RunWalkForwardSvc<T> {
type Response = ::arvo_api::research::Finding;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::RunRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::run_walk_forward(&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 method = RunWalkForwardSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/RecordFinding" => {
#[allow(non_camel_case_types)]
struct RecordFindingSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::ReportRequest>
for RecordFindingSvc<T> {
type Response = ::arvo_api::research::Finding;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::ReportRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::record_finding(&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 method = RecordFindingSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/AttachFile" => {
#[allow(non_camel_case_types)]
struct AttachFileSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::AttachRequest>
for AttachFileSvc<T> {
type Response = ::arvo_api::research::Attachments;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::AttachRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::attach_file(&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 method = AttachFileSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ListRulesets" => {
#[allow(non_camel_case_types)]
struct ListRulesetsSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ListRulesetsSvc<T> {
type Response = ::arvo_api::research::Rulesets;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::list_rulesets(&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 method = ListRulesetsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ReadRuleset" => {
#[allow(non_camel_case_types)]
struct ReadRulesetSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::RulesetPath>
for ReadRulesetSvc<T> {
type Response = ::arvo_api::research::RulesetForm;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::RulesetPath>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::read_ruleset(&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 method = ReadRulesetSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/WriteRuleset" => {
#[allow(non_camel_case_types)]
struct WriteRulesetSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::RulesetForm>
for WriteRulesetSvc<T> {
type Response = ::arvo_api::research::Ruleset;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::RulesetForm>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::write_ruleset(&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 method = WriteRulesetSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ListRules" => {
#[allow(non_camel_case_types)]
struct ListRulesSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ListRulesSvc<T> {
type Response = ::arvo_api::research::Rules;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::list_rules(&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 method = ListRulesSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ListRuleFiles" => {
#[allow(non_camel_case_types)]
struct ListRuleFilesSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ListRuleFilesSvc<T> {
type Response = ::arvo_api::research::RuleFiles;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::list_rule_files(&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 method = ListRuleFilesSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/WriteRule" => {
#[allow(non_camel_case_types)]
struct WriteRuleSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::RuleText>
for WriteRuleSvc<T> {
type Response = ::arvo_api::research::RuleFile;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::RuleText>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::write_rule(&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 method = WriteRuleSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/TranslatePine" => {
#[allow(non_camel_case_types)]
struct TranslatePineSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::PineScript>
for TranslatePineSvc<T> {
type Response = ::arvo_api::research::PineTranslation;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::PineScript>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::translate_pine(&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 method = TranslatePineSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/GetRiskModel" => {
#[allow(non_camel_case_types)]
struct GetRiskModelSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for GetRiskModelSvc<T> {
type Response = ::arvo_api::research::RiskModel;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::get_risk_model(&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 method = GetRiskModelSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ViewStudy" => {
#[allow(non_camel_case_types)]
struct ViewStudySvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::StudyRequest>
for ViewStudySvc<T> {
type Response = ::arvo_api::research::StudyView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::StudyRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::view_study(&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 method = ViewStudySvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ViewWalkForward" => {
#[allow(non_camel_case_types)]
struct ViewWalkForwardSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::StudyRequest>
for ViewWalkForwardSvc<T> {
type Response = ::arvo_api::research::WalkForwardView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::StudyRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::view_walk_forward(&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 method = ViewWalkForwardSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ViewPanel" => {
#[allow(non_camel_case_types)]
struct ViewPanelSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ViewPanelSvc<T> {
type Response = ::arvo_api::research::PanelView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::view_panel(&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 method = ViewPanelSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/RunPanel" => {
#[allow(non_camel_case_types)]
struct RunPanelSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::PanelRequest>
for RunPanelSvc<T> {
type Response = ::arvo_api::research::PanelView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::PanelRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::run_panel(&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 method = RunPanelSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ViewBook" => {
#[allow(non_camel_case_types)]
struct ViewBookSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::BookRequest>
for ViewBookSvc<T> {
type Response = ::arvo_api::research::StudyView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::BookRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::view_book(&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 method = ViewBookSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ViewHistory" => {
#[allow(non_camel_case_types)]
struct ViewHistorySvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ViewHistorySvc<T> {
type Response = ::arvo_api::research::HistoryView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::view_history(&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 method = ViewHistorySvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ViewRecord" => {
#[allow(non_camel_case_types)]
struct ViewRecordSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::FindingId>
for ViewRecordSvc<T> {
type Response = ::arvo_api::research::RecordView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::FindingId>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::view_record(&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 method = ViewRecordSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ViewReplay" => {
#[allow(non_camel_case_types)]
struct ViewReplaySvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::FindingId>
for ViewReplaySvc<T> {
type Response = ::arvo_api::research::ReplayView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::FindingId>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::view_replay(&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 method = ViewReplaySvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ViewComparison" => {
#[allow(non_camel_case_types)]
struct ViewComparisonSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::FindingIds>
for ViewComparisonSvc<T> {
type Response = ::arvo_api::research::ComparisonView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::FindingIds>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::view_comparison(&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 method = ViewComparisonSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ReadBars" => {
#[allow(non_camel_case_types)]
struct ReadBarsSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::BarsRequest>
for ReadBarsSvc<T> {
type Response = ::arvo_api::research::BarsView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::BarsRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::read_bars(&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 method = ReadBarsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/StreamBars" => {
#[allow(non_camel_case_types)]
struct StreamBarsSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::ServerStreamingService<
::arvo_api::research::BarsRequest,
> for StreamBarsSvc<T> {
type Response = ::arvo_api::research::BarsView;
type ResponseStream = T::StreamBarsStream;
type Future = BoxFuture<
tonic::Response<Self::ResponseStream>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::BarsRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::stream_bars(&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 method = StreamBarsSvc(inner);
let codec = tonic_prost::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.server_streaming(method, req).await;
Ok(res)
};
Box::pin(fut)
}
"/arvo.services.v1.Research/ReadIndicator" => {
#[allow(non_camel_case_types)]
struct ReadIndicatorSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::IndicatorRequest>
for ReadIndicatorSvc<T> {
type Response = ::arvo_api::research::NamedCurveView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<
::arvo_api::research::IndicatorRequest,
>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::read_indicator(&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 method = ReadIndicatorSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ViewRegime" => {
#[allow(non_camel_case_types)]
struct ViewRegimeSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::BarsRequest>
for ViewRegimeSvc<T> {
type Response = ::arvo_api::research::RegimeView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::BarsRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::view_regime(&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 method = ViewRegimeSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ViewReview" => {
#[allow(non_camel_case_types)]
struct ViewReviewSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::ReviewRequest>
for ViewReviewSvc<T> {
type Response = ::arvo_api::research::ReviewView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::ReviewRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::view_review(&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 method = ViewReviewSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/RankFindings" => {
#[allow(non_camel_case_types)]
struct RankFindingsSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::RankRequest>
for RankFindingsSvc<T> {
type Response = ::arvo_api::research::Ranking;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::RankRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::rank_findings(&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 method = RankFindingsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ViewProblems" => {
#[allow(non_camel_case_types)]
struct ViewProblemsSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ViewProblemsSvc<T> {
type Response = ::arvo_api::research::ProblemsView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::view_problems(&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 method = ViewProblemsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/ListAttachments" => {
#[allow(non_camel_case_types)]
struct ListAttachmentsSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::UnaryService<::arvo_api::research::FindingId>
for ListAttachmentsSvc<T> {
type Response = ::arvo_api::research::Attachments;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::FindingId>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::list_attachments(&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 method = ListAttachmentsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Research/Subscribe" => {
#[allow(non_camel_case_types)]
struct SubscribeSvc<T: Research>(pub Arc<T>);
impl<
T: Research,
> tonic::server::ServerStreamingService<::arvo_api::common::Empty>
for SubscribeSvc<T> {
type Response = ::arvo_api::platform::EventView;
type ResponseStream = T::SubscribeStream;
type Future = BoxFuture<
tonic::Response<Self::ResponseStream>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Research>::subscribe(&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 method = SubscribeSvc(inner);
let codec = tonic_prost::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.server_streaming(method, req).await;
Ok(res)
};
Box::pin(fut)
}
_ => {
Box::pin(async move {
let mut response = http::Response::new(
tonic::body::Body::default(),
);
let headers = response.headers_mut();
headers
.insert(
tonic::Status::GRPC_STATUS,
(tonic::Code::Unimplemented as i32).into(),
);
headers
.insert(
http::header::CONTENT_TYPE,
tonic::metadata::GRPC_CONTENT_TYPE,
);
Ok(response)
})
}
}
}
}
impl<T> Clone for ResearchServer<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,
}
}
}
pub const SERVICE_NAME: &str = "arvo.services.v1.Research";
impl<T> tonic::server::NamedService for ResearchServer<T> {
const NAME: &'static str = SERVICE_NAME;
}
}
pub mod research_files_client {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
use tonic::codegen::http::Uri;
#[derive(Debug, Clone)]
pub struct ResearchFilesClient<T> {
inner: tonic::client::Grpc<T>,
}
impl ResearchFilesClient<tonic::transport::Channel> {
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> ResearchFilesClient<T>
where
T: tonic::client::GrpcService<tonic::body::Body>,
T::Error: Into<StdError>,
T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
<T::ResponseBody as Body>::Error: Into<StdError> + std::marker::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,
) -> ResearchFilesClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T::ResponseBody: Default,
T: tonic::codegen::Service<
http::Request<tonic::body::Body>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<
http::Request<tonic::body::Body>,
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
{
ResearchFilesClient::new(InterceptedService::new(inner, interceptor))
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.send_compressed(encoding);
self
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.accept_compressed(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.inner = self.inner.max_decoding_message_size(limit);
self
}
#[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 run_shared_experiment(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::SharedExperiment>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::StudyView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.ResearchFiles/RunSharedExperiment",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(
GrpcMethod::new(
"arvo.services.v1.ResearchFiles",
"RunSharedExperiment",
),
);
self.inner.unary(req, path, codec).await
}
pub async fn export_trades(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::TradeExport>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::ExportedPath>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.ResearchFiles/ExportTrades",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(
GrpcMethod::new("arvo.services.v1.ResearchFiles", "ExportTrades"),
);
self.inner.unary(req, path, codec).await
}
pub async fn export_experiment(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::FindingId>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::ExportedPath>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.ResearchFiles/ExportExperiment",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(
GrpcMethod::new("arvo.services.v1.ResearchFiles", "ExportExperiment"),
);
self.inner.unary(req, path, codec).await
}
pub async fn compose_report(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::ReportFigure>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::ExportedPath>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.ResearchFiles/ComposeReport",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(
GrpcMethod::new("arvo.services.v1.ResearchFiles", "ComposeReport"),
);
self.inner.unary(req, path, codec).await
}
pub async fn attachment_path(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::research::AttachmentRef>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::ExportedPath>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.ResearchFiles/AttachmentPath",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(
GrpcMethod::new("arvo.services.v1.ResearchFiles", "AttachmentPath"),
);
self.inner.unary(req, path, codec).await
}
}
}
pub mod research_files_server {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
#[async_trait]
pub trait ResearchFiles: std::marker::Send + std::marker::Sync + 'static {
async fn run_shared_experiment(
&self,
request: tonic::Request<::arvo_api::research::SharedExperiment>,
) -> std::result::Result<
tonic::Response<::arvo_api::research::StudyView>,
tonic::Status,
>;
async fn export_trades(
&self,
request: tonic::Request<::arvo_api::research::TradeExport>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::ExportedPath>,
tonic::Status,
>;
async fn export_experiment(
&self,
request: tonic::Request<::arvo_api::research::FindingId>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::ExportedPath>,
tonic::Status,
>;
async fn compose_report(
&self,
request: tonic::Request<::arvo_api::research::ReportFigure>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::ExportedPath>,
tonic::Status,
>;
async fn attachment_path(
&self,
request: tonic::Request<::arvo_api::research::AttachmentRef>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::ExportedPath>,
tonic::Status,
>;
}
#[derive(Debug)]
pub struct ResearchFilesServer<T> {
inner: Arc<T>,
accept_compression_encodings: EnabledCompressionEncodings,
send_compression_encodings: EnabledCompressionEncodings,
max_decoding_message_size: Option<usize>,
max_encoding_message_size: Option<usize>,
}
impl<T> ResearchFilesServer<T> {
pub fn new(inner: T) -> Self {
Self::from_arc(Arc::new(inner))
}
pub fn from_arc(inner: Arc<T>) -> Self {
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)
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.accept_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.send_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.max_decoding_message_size = Some(limit);
self
}
#[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 ResearchFilesServer<T>
where
T: ResearchFiles,
B: Body + std::marker::Send + 'static,
B::Error: Into<StdError> + std::marker::Send + 'static,
{
type Response = http::Response<tonic::body::Body>;
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 {
match req.uri().path() {
"/arvo.services.v1.ResearchFiles/RunSharedExperiment" => {
#[allow(non_camel_case_types)]
struct RunSharedExperimentSvc<T: ResearchFiles>(pub Arc<T>);
impl<
T: ResearchFiles,
> tonic::server::UnaryService<::arvo_api::research::SharedExperiment>
for RunSharedExperimentSvc<T> {
type Response = ::arvo_api::research::StudyView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<
::arvo_api::research::SharedExperiment,
>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as ResearchFiles>::run_shared_experiment(&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 method = RunSharedExperimentSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.ResearchFiles/ExportTrades" => {
#[allow(non_camel_case_types)]
struct ExportTradesSvc<T: ResearchFiles>(pub Arc<T>);
impl<
T: ResearchFiles,
> tonic::server::UnaryService<::arvo_api::research::TradeExport>
for ExportTradesSvc<T> {
type Response = ::arvo_api::common::ExportedPath;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::TradeExport>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as ResearchFiles>::export_trades(&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 method = ExportTradesSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.ResearchFiles/ExportExperiment" => {
#[allow(non_camel_case_types)]
struct ExportExperimentSvc<T: ResearchFiles>(pub Arc<T>);
impl<
T: ResearchFiles,
> tonic::server::UnaryService<::arvo_api::research::FindingId>
for ExportExperimentSvc<T> {
type Response = ::arvo_api::common::ExportedPath;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::FindingId>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as ResearchFiles>::export_experiment(&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 method = ExportExperimentSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.ResearchFiles/ComposeReport" => {
#[allow(non_camel_case_types)]
struct ComposeReportSvc<T: ResearchFiles>(pub Arc<T>);
impl<
T: ResearchFiles,
> tonic::server::UnaryService<::arvo_api::research::ReportFigure>
for ComposeReportSvc<T> {
type Response = ::arvo_api::common::ExportedPath;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::ReportFigure>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as ResearchFiles>::compose_report(&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 method = ComposeReportSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.ResearchFiles/AttachmentPath" => {
#[allow(non_camel_case_types)]
struct AttachmentPathSvc<T: ResearchFiles>(pub Arc<T>);
impl<
T: ResearchFiles,
> tonic::server::UnaryService<::arvo_api::research::AttachmentRef>
for AttachmentPathSvc<T> {
type Response = ::arvo_api::common::ExportedPath;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::research::AttachmentRef>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as ResearchFiles>::attachment_path(&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 method = AttachmentPathSvc(inner);
let codec = tonic_prost::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 {
let mut response = http::Response::new(
tonic::body::Body::default(),
);
let headers = response.headers_mut();
headers
.insert(
tonic::Status::GRPC_STATUS,
(tonic::Code::Unimplemented as i32).into(),
);
headers
.insert(
http::header::CONTENT_TYPE,
tonic::metadata::GRPC_CONTENT_TYPE,
);
Ok(response)
})
}
}
}
}
impl<T> Clone for ResearchFilesServer<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,
}
}
}
pub const SERVICE_NAME: &str = "arvo.services.v1.ResearchFiles";
impl<T> tonic::server::NamedService for ResearchFilesServer<T> {
const NAME: &'static str = SERVICE_NAME;
}
}
pub mod scripts_client {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
use tonic::codegen::http::Uri;
#[derive(Debug, Clone)]
pub struct ScriptsClient<T> {
inner: tonic::client::Grpc<T>,
}
impl ScriptsClient<tonic::transport::Channel> {
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> ScriptsClient<T>
where
T: tonic::client::GrpcService<tonic::body::Body>,
T::Error: Into<StdError>,
T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
<T::ResponseBody as Body>::Error: Into<StdError> + std::marker::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,
) -> ScriptsClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T::ResponseBody: Default,
T: tonic::codegen::Service<
http::Request<tonic::body::Body>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<
http::Request<tonic::body::Body>,
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
{
ScriptsClient::new(InterceptedService::new(inner, interceptor))
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.send_compressed(encoding);
self
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.accept_compressed(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.inner = self.inner.max_decoding_message_size(limit);
self
}
#[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 run_script(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::platform::ScriptPath>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::RunId>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Scripts/RunScript",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Scripts", "RunScript"));
self.inner.unary(req, path, codec).await
}
pub async fn stop_script(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::platform::RunId>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::Empty>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Scripts/StopScript",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Scripts", "StopScript"));
self.inner.unary(req, path, codec).await
}
pub async fn watch_output(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<
tonic::codec::Streaming<::arvo_api::platform::ScriptOutputView>,
>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Scripts/WatchOutput",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Scripts", "WatchOutput"));
self.inner.server_streaming(req, path, codec).await
}
pub async fn list_script_jobs(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::ScriptJobsView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Scripts/ListScriptJobs",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Scripts", "ListScriptJobs"));
self.inner.unary(req, path, codec).await
}
pub async fn save_script_job(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::platform::ScriptSchedule>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::ScriptJobsView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Scripts/SaveScriptJob",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Scripts", "SaveScriptJob"));
self.inner.unary(req, path, codec).await
}
pub async fn remove_script_job(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::platform::ScriptPath>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::ScriptJobsView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Scripts/RemoveScriptJob",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Scripts", "RemoveScriptJob"));
self.inner.unary(req, path, codec).await
}
}
}
pub mod scripts_server {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
#[async_trait]
pub trait Scripts: std::marker::Send + std::marker::Sync + 'static {
async fn run_script(
&self,
request: tonic::Request<::arvo_api::platform::ScriptPath>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::RunId>,
tonic::Status,
>;
async fn stop_script(
&self,
request: tonic::Request<::arvo_api::platform::RunId>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::Empty>,
tonic::Status,
>;
type WatchOutputStream: tonic::codegen::tokio_stream::Stream<
Item = std::result::Result<
::arvo_api::platform::ScriptOutputView,
tonic::Status,
>,
>
+ std::marker::Send
+ 'static;
async fn watch_output(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<Self::WatchOutputStream>,
tonic::Status,
>;
async fn list_script_jobs(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::ScriptJobsView>,
tonic::Status,
>;
async fn save_script_job(
&self,
request: tonic::Request<::arvo_api::platform::ScriptSchedule>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::ScriptJobsView>,
tonic::Status,
>;
async fn remove_script_job(
&self,
request: tonic::Request<::arvo_api::platform::ScriptPath>,
) -> std::result::Result<
tonic::Response<::arvo_api::platform::ScriptJobsView>,
tonic::Status,
>;
}
#[derive(Debug)]
pub struct ScriptsServer<T> {
inner: Arc<T>,
accept_compression_encodings: EnabledCompressionEncodings,
send_compression_encodings: EnabledCompressionEncodings,
max_decoding_message_size: Option<usize>,
max_encoding_message_size: Option<usize>,
}
impl<T> ScriptsServer<T> {
pub fn new(inner: T) -> Self {
Self::from_arc(Arc::new(inner))
}
pub fn from_arc(inner: Arc<T>) -> Self {
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)
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.accept_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.send_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.max_decoding_message_size = Some(limit);
self
}
#[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 ScriptsServer<T>
where
T: Scripts,
B: Body + std::marker::Send + 'static,
B::Error: Into<StdError> + std::marker::Send + 'static,
{
type Response = http::Response<tonic::body::Body>;
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 {
match req.uri().path() {
"/arvo.services.v1.Scripts/RunScript" => {
#[allow(non_camel_case_types)]
struct RunScriptSvc<T: Scripts>(pub Arc<T>);
impl<
T: Scripts,
> tonic::server::UnaryService<::arvo_api::platform::ScriptPath>
for RunScriptSvc<T> {
type Response = ::arvo_api::platform::RunId;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::platform::ScriptPath>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Scripts>::run_script(&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 method = RunScriptSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Scripts/StopScript" => {
#[allow(non_camel_case_types)]
struct StopScriptSvc<T: Scripts>(pub Arc<T>);
impl<
T: Scripts,
> tonic::server::UnaryService<::arvo_api::platform::RunId>
for StopScriptSvc<T> {
type Response = ::arvo_api::common::Empty;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::platform::RunId>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Scripts>::stop_script(&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 method = StopScriptSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Scripts/WatchOutput" => {
#[allow(non_camel_case_types)]
struct WatchOutputSvc<T: Scripts>(pub Arc<T>);
impl<
T: Scripts,
> tonic::server::ServerStreamingService<::arvo_api::common::Empty>
for WatchOutputSvc<T> {
type Response = ::arvo_api::platform::ScriptOutputView;
type ResponseStream = T::WatchOutputStream;
type Future = BoxFuture<
tonic::Response<Self::ResponseStream>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Scripts>::watch_output(&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 method = WatchOutputSvc(inner);
let codec = tonic_prost::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.server_streaming(method, req).await;
Ok(res)
};
Box::pin(fut)
}
"/arvo.services.v1.Scripts/ListScriptJobs" => {
#[allow(non_camel_case_types)]
struct ListScriptJobsSvc<T: Scripts>(pub Arc<T>);
impl<
T: Scripts,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ListScriptJobsSvc<T> {
type Response = ::arvo_api::platform::ScriptJobsView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Scripts>::list_script_jobs(&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 method = ListScriptJobsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Scripts/SaveScriptJob" => {
#[allow(non_camel_case_types)]
struct SaveScriptJobSvc<T: Scripts>(pub Arc<T>);
impl<
T: Scripts,
> tonic::server::UnaryService<::arvo_api::platform::ScriptSchedule>
for SaveScriptJobSvc<T> {
type Response = ::arvo_api::platform::ScriptJobsView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::platform::ScriptSchedule>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Scripts>::save_script_job(&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 method = SaveScriptJobSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Scripts/RemoveScriptJob" => {
#[allow(non_camel_case_types)]
struct RemoveScriptJobSvc<T: Scripts>(pub Arc<T>);
impl<
T: Scripts,
> tonic::server::UnaryService<::arvo_api::platform::ScriptPath>
for RemoveScriptJobSvc<T> {
type Response = ::arvo_api::platform::ScriptJobsView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::platform::ScriptPath>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Scripts>::remove_script_job(&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 method = RemoveScriptJobSvc(inner);
let codec = tonic_prost::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 {
let mut response = http::Response::new(
tonic::body::Body::default(),
);
let headers = response.headers_mut();
headers
.insert(
tonic::Status::GRPC_STATUS,
(tonic::Code::Unimplemented as i32).into(),
);
headers
.insert(
http::header::CONTENT_TYPE,
tonic::metadata::GRPC_CONTENT_TYPE,
);
Ok(response)
})
}
}
}
}
impl<T> Clone for ScriptsServer<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,
}
}
}
pub const SERVICE_NAME: &str = "arvo.services.v1.Scripts";
impl<T> tonic::server::NamedService for ScriptsServer<T> {
const NAME: &'static str = SERVICE_NAME;
}
}
pub mod sessions_client {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
use tonic::codegen::http::Uri;
#[derive(Debug, Clone)]
pub struct SessionsClient<T> {
inner: tonic::client::Grpc<T>,
}
impl SessionsClient<tonic::transport::Channel> {
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> SessionsClient<T>
where
T: tonic::client::GrpcService<tonic::body::Body>,
T::Error: Into<StdError>,
T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
<T::ResponseBody as Body>::Error: Into<StdError> + std::marker::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,
) -> SessionsClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T::ResponseBody: Default,
T: tonic::codegen::Service<
http::Request<tonic::body::Body>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<
http::Request<tonic::body::Body>,
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
{
SessionsClient::new(InterceptedService::new(inner, interceptor))
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.send_compressed(encoding);
self
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.accept_compressed(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.inner = self.inner.max_decoding_message_size(limit);
self
}
#[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 start_session(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::session::StartRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::session::SessionStatus>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Sessions/StartSession",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Sessions", "StartSession"));
self.inner.unary(req, path, codec).await
}
pub async fn stop_session(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::session::SessionId>,
) -> std::result::Result<
tonic::Response<::arvo_api::session::SessionStatus>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Sessions/StopSession",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Sessions", "StopSession"));
self.inner.unary(req, path, codec).await
}
pub async fn reconcile_session(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::session::SessionId>,
) -> std::result::Result<
tonic::Response<::arvo_api::session::SessionStatus>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Sessions/ReconcileSession",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(
GrpcMethod::new("arvo.services.v1.Sessions", "ReconcileSession"),
);
self.inner.unary(req, path, codec).await
}
pub async fn resume_session(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::session::SessionId>,
) -> std::result::Result<
tonic::Response<::arvo_api::session::SessionStatus>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Sessions/ResumeSession",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Sessions", "ResumeSession"));
self.inner.unary(req, path, codec).await
}
pub async fn halt_session(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::session::HaltRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::session::SessionStatus>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Sessions/HaltSession",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Sessions", "HaltSession"));
self.inner.unary(req, path, codec).await
}
pub async fn list_sessions(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::session::SessionList>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Sessions/ListSessions",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Sessions", "ListSessions"));
self.inner.unary(req, path, codec).await
}
pub async fn check_promotion(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::session::StartRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::session::PromotionView>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Sessions/CheckPromotion",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Sessions", "CheckPromotion"));
self.inner.unary(req, path, codec).await
}
pub async fn shutdown(
&mut self,
request: impl tonic::IntoRequest<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::Empty>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic_prost::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/arvo.services.v1.Sessions/Shutdown",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(GrpcMethod::new("arvo.services.v1.Sessions", "Shutdown"));
self.inner.unary(req, path, codec).await
}
}
}
pub mod sessions_server {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
#[async_trait]
pub trait Sessions: std::marker::Send + std::marker::Sync + 'static {
async fn start_session(
&self,
request: tonic::Request<::arvo_api::session::StartRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::session::SessionStatus>,
tonic::Status,
>;
async fn stop_session(
&self,
request: tonic::Request<::arvo_api::session::SessionId>,
) -> std::result::Result<
tonic::Response<::arvo_api::session::SessionStatus>,
tonic::Status,
>;
async fn reconcile_session(
&self,
request: tonic::Request<::arvo_api::session::SessionId>,
) -> std::result::Result<
tonic::Response<::arvo_api::session::SessionStatus>,
tonic::Status,
>;
async fn resume_session(
&self,
request: tonic::Request<::arvo_api::session::SessionId>,
) -> std::result::Result<
tonic::Response<::arvo_api::session::SessionStatus>,
tonic::Status,
>;
async fn halt_session(
&self,
request: tonic::Request<::arvo_api::session::HaltRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::session::SessionStatus>,
tonic::Status,
>;
async fn list_sessions(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::session::SessionList>,
tonic::Status,
>;
async fn check_promotion(
&self,
request: tonic::Request<::arvo_api::session::StartRequest>,
) -> std::result::Result<
tonic::Response<::arvo_api::session::PromotionView>,
tonic::Status,
>;
async fn shutdown(
&self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> std::result::Result<
tonic::Response<::arvo_api::common::Empty>,
tonic::Status,
>;
}
#[derive(Debug)]
pub struct SessionsServer<T> {
inner: Arc<T>,
accept_compression_encodings: EnabledCompressionEncodings,
send_compression_encodings: EnabledCompressionEncodings,
max_decoding_message_size: Option<usize>,
max_encoding_message_size: Option<usize>,
}
impl<T> SessionsServer<T> {
pub fn new(inner: T) -> Self {
Self::from_arc(Arc::new(inner))
}
pub fn from_arc(inner: Arc<T>) -> Self {
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)
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.accept_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.send_compression_encodings.enable(encoding);
self
}
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.max_decoding_message_size = Some(limit);
self
}
#[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 SessionsServer<T>
where
T: Sessions,
B: Body + std::marker::Send + 'static,
B::Error: Into<StdError> + std::marker::Send + 'static,
{
type Response = http::Response<tonic::body::Body>;
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 {
match req.uri().path() {
"/arvo.services.v1.Sessions/StartSession" => {
#[allow(non_camel_case_types)]
struct StartSessionSvc<T: Sessions>(pub Arc<T>);
impl<
T: Sessions,
> tonic::server::UnaryService<::arvo_api::session::StartRequest>
for StartSessionSvc<T> {
type Response = ::arvo_api::session::SessionStatus;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::session::StartRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Sessions>::start_session(&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 method = StartSessionSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Sessions/StopSession" => {
#[allow(non_camel_case_types)]
struct StopSessionSvc<T: Sessions>(pub Arc<T>);
impl<
T: Sessions,
> tonic::server::UnaryService<::arvo_api::session::SessionId>
for StopSessionSvc<T> {
type Response = ::arvo_api::session::SessionStatus;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::session::SessionId>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Sessions>::stop_session(&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 method = StopSessionSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Sessions/ReconcileSession" => {
#[allow(non_camel_case_types)]
struct ReconcileSessionSvc<T: Sessions>(pub Arc<T>);
impl<
T: Sessions,
> tonic::server::UnaryService<::arvo_api::session::SessionId>
for ReconcileSessionSvc<T> {
type Response = ::arvo_api::session::SessionStatus;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::session::SessionId>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Sessions>::reconcile_session(&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 method = ReconcileSessionSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Sessions/ResumeSession" => {
#[allow(non_camel_case_types)]
struct ResumeSessionSvc<T: Sessions>(pub Arc<T>);
impl<
T: Sessions,
> tonic::server::UnaryService<::arvo_api::session::SessionId>
for ResumeSessionSvc<T> {
type Response = ::arvo_api::session::SessionStatus;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::session::SessionId>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Sessions>::resume_session(&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 method = ResumeSessionSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Sessions/HaltSession" => {
#[allow(non_camel_case_types)]
struct HaltSessionSvc<T: Sessions>(pub Arc<T>);
impl<
T: Sessions,
> tonic::server::UnaryService<::arvo_api::session::HaltRequest>
for HaltSessionSvc<T> {
type Response = ::arvo_api::session::SessionStatus;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::session::HaltRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Sessions>::halt_session(&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 method = HaltSessionSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Sessions/ListSessions" => {
#[allow(non_camel_case_types)]
struct ListSessionsSvc<T: Sessions>(pub Arc<T>);
impl<
T: Sessions,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ListSessionsSvc<T> {
type Response = ::arvo_api::session::SessionList;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Sessions>::list_sessions(&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 method = ListSessionsSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Sessions/CheckPromotion" => {
#[allow(non_camel_case_types)]
struct CheckPromotionSvc<T: Sessions>(pub Arc<T>);
impl<
T: Sessions,
> tonic::server::UnaryService<::arvo_api::session::StartRequest>
for CheckPromotionSvc<T> {
type Response = ::arvo_api::session::PromotionView;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::session::StartRequest>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Sessions>::check_promotion(&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 method = CheckPromotionSvc(inner);
let codec = tonic_prost::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)
}
"/arvo.services.v1.Sessions/Shutdown" => {
#[allow(non_camel_case_types)]
struct ShutdownSvc<T: Sessions>(pub Arc<T>);
impl<
T: Sessions,
> tonic::server::UnaryService<::arvo_api::common::Empty>
for ShutdownSvc<T> {
type Response = ::arvo_api::common::Empty;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<::arvo_api::common::Empty>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
<T as Sessions>::shutdown(&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 method = ShutdownSvc(inner);
let codec = tonic_prost::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 {
let mut response = http::Response::new(
tonic::body::Body::default(),
);
let headers = response.headers_mut();
headers
.insert(
tonic::Status::GRPC_STATUS,
(tonic::Code::Unimplemented as i32).into(),
);
headers
.insert(
http::header::CONTENT_TYPE,
tonic::metadata::GRPC_CONTENT_TYPE,
);
Ok(response)
})
}
}
}
}
impl<T> Clone for SessionsServer<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,
}
}
}
pub const SERVICE_NAME: &str = "arvo.services.v1.Sessions";
impl<T> tonic::server::NamedService for SessionsServer<T> {
const NAME: &'static str = SERVICE_NAME;
}
}