#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Result {
#[prost(map="string, bytes", tag="10")]
pub metadata: ::std::collections::HashMap<std::string::String, std::vec::Vec<u8>>,
#[prost(oneof="result::Result", tags="1, 2")]
pub result: ::std::option::Option<result::Result>,
}
pub mod result {
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Result {
#[prost(string, tag="1")]
Ref(std::string::String),
#[prost(message, tag="2")]
Refs(super::RefMap),
}
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RefMap {
#[prost(map="string, string", tag="1")]
pub refs: ::std::collections::HashMap<std::string::String, std::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReturnRequest {
#[prost(message, optional, tag="1")]
pub result: ::std::option::Option<Result>,
#[prost(message, optional, tag="2")]
pub error: ::std::option::Option<super::super::super::super::google::rpc::Status>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReturnResponse {
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResolveImageConfigRequest {
#[prost(string, tag="1")]
pub r#ref: std::string::String,
#[prost(message, optional, tag="2")]
pub platform: ::std::option::Option<super::super::super::super::pb::Platform>,
#[prost(string, tag="3")]
pub resolve_mode: std::string::String,
#[prost(string, tag="4")]
pub log_name: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResolveImageConfigResponse {
#[prost(string, tag="1")]
pub digest: std::string::String,
#[prost(bytes, tag="2")]
pub config: std::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SolveRequest {
#[prost(message, optional, tag="1")]
pub definition: ::std::option::Option<super::super::super::super::pb::Definition>,
#[prost(string, tag="2")]
pub frontend: std::string::String,
#[prost(map="string, string", tag="3")]
pub frontend_opt: ::std::collections::HashMap<std::string::String, std::string::String>,
#[prost(string, repeated, tag="4")]
pub import_cache_refs_deprecated: ::std::vec::Vec<std::string::String>,
#[prost(bool, tag="5")]
pub allow_result_return: bool,
#[prost(bool, tag="10")]
pub r#final: bool,
#[prost(bytes, tag="11")]
pub exporter_attr: std::vec::Vec<u8>,
#[prost(message, repeated, tag="12")]
pub cache_imports: ::std::vec::Vec<CacheOptionsEntry>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CacheOptionsEntry {
#[prost(string, tag="1")]
pub r#type: std::string::String,
#[prost(map="string, string", tag="2")]
pub attrs: ::std::collections::HashMap<std::string::String, std::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SolveResponse {
#[prost(string, tag="1")]
pub r#ref: std::string::String,
#[prost(message, optional, tag="3")]
pub result: ::std::option::Option<Result>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadFileRequest {
#[prost(string, tag="1")]
pub r#ref: std::string::String,
#[prost(string, tag="2")]
pub file_path: std::string::String,
#[prost(message, optional, tag="3")]
pub range: ::std::option::Option<FileRange>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FileRange {
#[prost(int64, tag="1")]
pub offset: i64,
#[prost(int64, tag="2")]
pub length: i64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadFileResponse {
#[prost(bytes, tag="1")]
pub data: std::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadDirRequest {
#[prost(string, tag="1")]
pub r#ref: std::string::String,
#[prost(string, tag="2")]
pub dir_path: std::string::String,
#[prost(string, tag="3")]
pub include_pattern: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadDirResponse {
#[prost(message, repeated, tag="1")]
pub entries: ::std::vec::Vec<super::super::super::super::fsutil::types::Stat>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StatFileRequest {
#[prost(string, tag="1")]
pub r#ref: std::string::String,
#[prost(string, tag="2")]
pub path: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StatFileResponse {
#[prost(message, optional, tag="1")]
pub stat: ::std::option::Option<super::super::super::super::fsutil::types::Stat>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PingRequest {
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PongResponse {
#[prost(message, repeated, tag="1")]
pub frontend_api_caps: ::std::vec::Vec<super::apicaps::ApiCap>,
#[prost(message, repeated, tag="2")]
pub llb_caps: ::std::vec::Vec<super::apicaps::ApiCap>,
#[prost(message, repeated, tag="3")]
pub workers: ::std::vec::Vec<super::types::WorkerRecord>,
}
pub mod client {
use ::tower_grpc::codegen::client::*;
use super::{ResolveImageConfigRequest, ResolveImageConfigResponse, SolveRequest, SolveResponse, ReadFileRequest, ReadFileResponse, ReadDirRequest, ReadDirResponse, StatFileRequest, StatFileResponse, PingRequest, PongResponse, ReturnRequest, ReturnResponse};
#[derive(Debug, Clone)]
pub struct LlbBridge<T> {
inner: grpc::Grpc<T>,
}
impl<T> LlbBridge<T> {
pub fn new(inner: T) -> Self {
let inner = grpc::Grpc::new(inner);
Self { inner }
}
pub fn poll_ready<R>(&mut self) -> futures::Poll<(), grpc::Status>
where T: grpc::GrpcService<R>,
{
self.inner.poll_ready()
}
pub fn ready<R>(self) -> impl futures::Future<Item = Self, Error = grpc::Status>
where T: grpc::GrpcService<R>,
{
futures::Future::map(self.inner.ready(), |inner| Self { inner })
}
pub fn resolve_image_config<R>(&mut self, request: grpc::Request<ResolveImageConfigRequest>) -> grpc::unary::ResponseFuture<ResolveImageConfigResponse, T::Future, T::ResponseBody>
where T: grpc::GrpcService<R>,
grpc::unary::Once<ResolveImageConfigRequest>: grpc::Encodable<R>,
{
let path = http::PathAndQuery::from_static("/moby.buildkit.v1.frontend.LLBBridge/ResolveImageConfig");
self.inner.unary(request, path)
}
pub fn solve<R>(&mut self, request: grpc::Request<SolveRequest>) -> grpc::unary::ResponseFuture<SolveResponse, T::Future, T::ResponseBody>
where T: grpc::GrpcService<R>,
grpc::unary::Once<SolveRequest>: grpc::Encodable<R>,
{
let path = http::PathAndQuery::from_static("/moby.buildkit.v1.frontend.LLBBridge/Solve");
self.inner.unary(request, path)
}
pub fn read_file<R>(&mut self, request: grpc::Request<ReadFileRequest>) -> grpc::unary::ResponseFuture<ReadFileResponse, T::Future, T::ResponseBody>
where T: grpc::GrpcService<R>,
grpc::unary::Once<ReadFileRequest>: grpc::Encodable<R>,
{
let path = http::PathAndQuery::from_static("/moby.buildkit.v1.frontend.LLBBridge/ReadFile");
self.inner.unary(request, path)
}
pub fn read_dir<R>(&mut self, request: grpc::Request<ReadDirRequest>) -> grpc::unary::ResponseFuture<ReadDirResponse, T::Future, T::ResponseBody>
where T: grpc::GrpcService<R>,
grpc::unary::Once<ReadDirRequest>: grpc::Encodable<R>,
{
let path = http::PathAndQuery::from_static("/moby.buildkit.v1.frontend.LLBBridge/ReadDir");
self.inner.unary(request, path)
}
pub fn stat_file<R>(&mut self, request: grpc::Request<StatFileRequest>) -> grpc::unary::ResponseFuture<StatFileResponse, T::Future, T::ResponseBody>
where T: grpc::GrpcService<R>,
grpc::unary::Once<StatFileRequest>: grpc::Encodable<R>,
{
let path = http::PathAndQuery::from_static("/moby.buildkit.v1.frontend.LLBBridge/StatFile");
self.inner.unary(request, path)
}
pub fn ping<R>(&mut self, request: grpc::Request<PingRequest>) -> grpc::unary::ResponseFuture<PongResponse, T::Future, T::ResponseBody>
where T: grpc::GrpcService<R>,
grpc::unary::Once<PingRequest>: grpc::Encodable<R>,
{
let path = http::PathAndQuery::from_static("/moby.buildkit.v1.frontend.LLBBridge/Ping");
self.inner.unary(request, path)
}
pub fn r#return<R>(&mut self, request: grpc::Request<ReturnRequest>) -> grpc::unary::ResponseFuture<ReturnResponse, T::Future, T::ResponseBody>
where T: grpc::GrpcService<R>,
grpc::unary::Once<ReturnRequest>: grpc::Encodable<R>,
{
let path = http::PathAndQuery::from_static("/moby.buildkit.v1.frontend.LLBBridge/Return");
self.inner.unary(request, path)
}
}
}
pub mod server {
use ::tower_grpc::codegen::server::*;
use super::{ResolveImageConfigRequest, ResolveImageConfigResponse, SolveRequest, SolveResponse, ReadFileRequest, ReadFileResponse, ReadDirRequest, ReadDirResponse, StatFileRequest, StatFileResponse, PingRequest, PongResponse, ReturnRequest, ReturnResponse};
macro_rules! try_ready {
($e:expr) => (match $e {
Ok(futures::Async::Ready(t)) => t,
Ok(futures::Async::NotReady) => return Ok(futures::Async::NotReady),
Err(e) => return Err(From::from(e)),
})
}
pub trait LlbBridge: Clone {
type ResolveImageConfigFuture: futures::Future<Item = grpc::Response<ResolveImageConfigResponse>, Error = grpc::Status>;
type SolveFuture: futures::Future<Item = grpc::Response<SolveResponse>, Error = grpc::Status>;
type ReadFileFuture: futures::Future<Item = grpc::Response<ReadFileResponse>, Error = grpc::Status>;
type ReadDirFuture: futures::Future<Item = grpc::Response<ReadDirResponse>, Error = grpc::Status>;
type StatFileFuture: futures::Future<Item = grpc::Response<StatFileResponse>, Error = grpc::Status>;
type PingFuture: futures::Future<Item = grpc::Response<PongResponse>, Error = grpc::Status>;
type ReturnFuture: futures::Future<Item = grpc::Response<ReturnResponse>, Error = grpc::Status>;
fn resolve_image_config(&mut self, request: grpc::Request<ResolveImageConfigRequest>) -> Self::ResolveImageConfigFuture;
fn solve(&mut self, request: grpc::Request<SolveRequest>) -> Self::SolveFuture;
fn read_file(&mut self, request: grpc::Request<ReadFileRequest>) -> Self::ReadFileFuture;
fn read_dir(&mut self, request: grpc::Request<ReadDirRequest>) -> Self::ReadDirFuture;
fn stat_file(&mut self, request: grpc::Request<StatFileRequest>) -> Self::StatFileFuture;
fn ping(&mut self, request: grpc::Request<PingRequest>) -> Self::PingFuture;
fn r#return(&mut self, request: grpc::Request<ReturnRequest>) -> Self::ReturnFuture;
}
#[derive(Debug, Clone)]
pub struct LlbBridgeServer<T> {
llb_bridge: T,
}
impl<T> LlbBridgeServer<T>
where T: LlbBridge,
{
pub fn new(llb_bridge: T) -> Self {
Self { llb_bridge }
}
}
impl<T> tower::Service<http::Request<grpc::BoxBody>> for LlbBridgeServer<T>
where T: LlbBridge,
{
type Response = http::Response<llb_bridge::ResponseBody<T>>;
type Error = grpc::Never;
type Future = llb_bridge::ResponseFuture<T>;
fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
Ok(().into())
}
fn call(&mut self, request: http::Request<grpc::BoxBody>) -> Self::Future {
use self::llb_bridge::Kind::*;
match request.uri().path() {
"/moby.buildkit.v1.frontend.LLBBridge/ResolveImageConfig" => {
let service = llb_bridge::methods::ResolveImageConfig(self.llb_bridge.clone());
let response = grpc::unary(service, request);
llb_bridge::ResponseFuture { kind: ResolveImageConfig(response) }
}
"/moby.buildkit.v1.frontend.LLBBridge/Solve" => {
let service = llb_bridge::methods::Solve(self.llb_bridge.clone());
let response = grpc::unary(service, request);
llb_bridge::ResponseFuture { kind: Solve(response) }
}
"/moby.buildkit.v1.frontend.LLBBridge/ReadFile" => {
let service = llb_bridge::methods::ReadFile(self.llb_bridge.clone());
let response = grpc::unary(service, request);
llb_bridge::ResponseFuture { kind: ReadFile(response) }
}
"/moby.buildkit.v1.frontend.LLBBridge/ReadDir" => {
let service = llb_bridge::methods::ReadDir(self.llb_bridge.clone());
let response = grpc::unary(service, request);
llb_bridge::ResponseFuture { kind: ReadDir(response) }
}
"/moby.buildkit.v1.frontend.LLBBridge/StatFile" => {
let service = llb_bridge::methods::StatFile(self.llb_bridge.clone());
let response = grpc::unary(service, request);
llb_bridge::ResponseFuture { kind: StatFile(response) }
}
"/moby.buildkit.v1.frontend.LLBBridge/Ping" => {
let service = llb_bridge::methods::Ping(self.llb_bridge.clone());
let response = grpc::unary(service, request);
llb_bridge::ResponseFuture { kind: Ping(response) }
}
"/moby.buildkit.v1.frontend.LLBBridge/Return" => {
let service = llb_bridge::methods::Return(self.llb_bridge.clone());
let response = grpc::unary(service, request);
llb_bridge::ResponseFuture { kind: Return(response) }
}
_ => {
llb_bridge::ResponseFuture { kind: __Generated__Unimplemented(grpc::unimplemented(format!("unknown service: {:?}", request.uri().path()))) }
}
}
}
}
impl<T> tower::Service<()> for LlbBridgeServer<T>
where T: LlbBridge,
{
type Response = Self;
type Error = grpc::Never;
type Future = futures::FutureResult<Self::Response, Self::Error>;
fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
Ok(futures::Async::Ready(()))
}
fn call(&mut self, _target: ()) -> Self::Future {
futures::ok(self.clone())
}
}
pub mod llb_bridge {
use ::tower_grpc::codegen::server::*;
use super::LlbBridge;
use super::super::{ResolveImageConfigRequest, SolveRequest, ReadFileRequest, ReadDirRequest, StatFileRequest, PingRequest, ReturnRequest};
pub struct ResponseFuture<T>
where T: LlbBridge,
{
pub(super) kind: Kind<
grpc::unary::ResponseFuture<methods::ResolveImageConfig<T>, grpc::BoxBody, ResolveImageConfigRequest>,
grpc::unary::ResponseFuture<methods::Solve<T>, grpc::BoxBody, SolveRequest>,
grpc::unary::ResponseFuture<methods::ReadFile<T>, grpc::BoxBody, ReadFileRequest>,
grpc::unary::ResponseFuture<methods::ReadDir<T>, grpc::BoxBody, ReadDirRequest>,
grpc::unary::ResponseFuture<methods::StatFile<T>, grpc::BoxBody, StatFileRequest>,
grpc::unary::ResponseFuture<methods::Ping<T>, grpc::BoxBody, PingRequest>,
grpc::unary::ResponseFuture<methods::Return<T>, grpc::BoxBody, ReturnRequest>,
grpc::unimplemented::ResponseFuture,
>,
}
impl<T> futures::Future for ResponseFuture<T>
where T: LlbBridge,
{
type Item = http::Response<ResponseBody<T>>;
type Error = grpc::Never;
fn poll(&mut self) -> futures::Poll<Self::Item, Self::Error> {
use self::Kind::*;
match self.kind {
ResolveImageConfig(ref mut fut) => {
let response = try_ready!(fut.poll());
let response = response.map(|body| {
ResponseBody { kind: ResolveImageConfig(body) }
});
Ok(response.into())
}
Solve(ref mut fut) => {
let response = try_ready!(fut.poll());
let response = response.map(|body| {
ResponseBody { kind: Solve(body) }
});
Ok(response.into())
}
ReadFile(ref mut fut) => {
let response = try_ready!(fut.poll());
let response = response.map(|body| {
ResponseBody { kind: ReadFile(body) }
});
Ok(response.into())
}
ReadDir(ref mut fut) => {
let response = try_ready!(fut.poll());
let response = response.map(|body| {
ResponseBody { kind: ReadDir(body) }
});
Ok(response.into())
}
StatFile(ref mut fut) => {
let response = try_ready!(fut.poll());
let response = response.map(|body| {
ResponseBody { kind: StatFile(body) }
});
Ok(response.into())
}
Ping(ref mut fut) => {
let response = try_ready!(fut.poll());
let response = response.map(|body| {
ResponseBody { kind: Ping(body) }
});
Ok(response.into())
}
Return(ref mut fut) => {
let response = try_ready!(fut.poll());
let response = response.map(|body| {
ResponseBody { kind: Return(body) }
});
Ok(response.into())
}
__Generated__Unimplemented(ref mut fut) => {
let response = try_ready!(fut.poll());
let response = response.map(|body| {
ResponseBody { kind: __Generated__Unimplemented(body) }
});
Ok(response.into())
}
}
}
}
pub struct ResponseBody<T>
where T: LlbBridge,
{
pub(super) kind: Kind<
grpc::Encode<grpc::unary::Once<<methods::ResolveImageConfig<T> as grpc::UnaryService<ResolveImageConfigRequest>>::Response>>,
grpc::Encode<grpc::unary::Once<<methods::Solve<T> as grpc::UnaryService<SolveRequest>>::Response>>,
grpc::Encode<grpc::unary::Once<<methods::ReadFile<T> as grpc::UnaryService<ReadFileRequest>>::Response>>,
grpc::Encode<grpc::unary::Once<<methods::ReadDir<T> as grpc::UnaryService<ReadDirRequest>>::Response>>,
grpc::Encode<grpc::unary::Once<<methods::StatFile<T> as grpc::UnaryService<StatFileRequest>>::Response>>,
grpc::Encode<grpc::unary::Once<<methods::Ping<T> as grpc::UnaryService<PingRequest>>::Response>>,
grpc::Encode<grpc::unary::Once<<methods::Return<T> as grpc::UnaryService<ReturnRequest>>::Response>>,
(),
>,
}
impl<T> tower::HttpBody for ResponseBody<T>
where T: LlbBridge,
{
type Data = <grpc::BoxBody as grpc::Body>::Data;
type Error = grpc::Status;
fn is_end_stream(&self) -> bool {
use self::Kind::*;
match self.kind {
ResolveImageConfig(ref v) => v.is_end_stream(),
Solve(ref v) => v.is_end_stream(),
ReadFile(ref v) => v.is_end_stream(),
ReadDir(ref v) => v.is_end_stream(),
StatFile(ref v) => v.is_end_stream(),
Ping(ref v) => v.is_end_stream(),
Return(ref v) => v.is_end_stream(),
__Generated__Unimplemented(_) => true,
}
}
fn poll_data(&mut self) -> futures::Poll<Option<Self::Data>, Self::Error> {
use self::Kind::*;
match self.kind {
ResolveImageConfig(ref mut v) => v.poll_data(),
Solve(ref mut v) => v.poll_data(),
ReadFile(ref mut v) => v.poll_data(),
ReadDir(ref mut v) => v.poll_data(),
StatFile(ref mut v) => v.poll_data(),
Ping(ref mut v) => v.poll_data(),
Return(ref mut v) => v.poll_data(),
__Generated__Unimplemented(_) => Ok(None.into()),
}
}
fn poll_trailers(&mut self) -> futures::Poll<Option<http::HeaderMap>, Self::Error> {
use self::Kind::*;
match self.kind {
ResolveImageConfig(ref mut v) => v.poll_trailers(),
Solve(ref mut v) => v.poll_trailers(),
ReadFile(ref mut v) => v.poll_trailers(),
ReadDir(ref mut v) => v.poll_trailers(),
StatFile(ref mut v) => v.poll_trailers(),
Ping(ref mut v) => v.poll_trailers(),
Return(ref mut v) => v.poll_trailers(),
__Generated__Unimplemented(_) => Ok(None.into()),
}
}
}
#[allow(non_camel_case_types)]
#[derive(Debug, Clone)]
pub(super) enum Kind<ResolveImageConfig, Solve, ReadFile, ReadDir, StatFile, Ping, Return, __Generated__Unimplemented> {
ResolveImageConfig(ResolveImageConfig),
Solve(Solve),
ReadFile(ReadFile),
ReadDir(ReadDir),
StatFile(StatFile),
Ping(Ping),
Return(Return),
__Generated__Unimplemented(__Generated__Unimplemented),
}
pub mod methods {
use ::tower_grpc::codegen::server::*;
use super::super::{LlbBridge, ResolveImageConfigRequest, ResolveImageConfigResponse, SolveRequest, SolveResponse, ReadFileRequest, ReadFileResponse, ReadDirRequest, ReadDirResponse, StatFileRequest, StatFileResponse, PingRequest, PongResponse, ReturnRequest, ReturnResponse};
pub struct ResolveImageConfig<T>(pub T);
impl<T> tower::Service<grpc::Request<ResolveImageConfigRequest>> for ResolveImageConfig<T>
where T: LlbBridge,
{
type Response = grpc::Response<ResolveImageConfigResponse>;
type Error = grpc::Status;
type Future = T::ResolveImageConfigFuture;
fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
Ok(futures::Async::Ready(()))
}
fn call(&mut self, request: grpc::Request<ResolveImageConfigRequest>) -> Self::Future {
self.0.resolve_image_config(request)
}
}
pub struct Solve<T>(pub T);
impl<T> tower::Service<grpc::Request<SolveRequest>> for Solve<T>
where T: LlbBridge,
{
type Response = grpc::Response<SolveResponse>;
type Error = grpc::Status;
type Future = T::SolveFuture;
fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
Ok(futures::Async::Ready(()))
}
fn call(&mut self, request: grpc::Request<SolveRequest>) -> Self::Future {
self.0.solve(request)
}
}
pub struct ReadFile<T>(pub T);
impl<T> tower::Service<grpc::Request<ReadFileRequest>> for ReadFile<T>
where T: LlbBridge,
{
type Response = grpc::Response<ReadFileResponse>;
type Error = grpc::Status;
type Future = T::ReadFileFuture;
fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
Ok(futures::Async::Ready(()))
}
fn call(&mut self, request: grpc::Request<ReadFileRequest>) -> Self::Future {
self.0.read_file(request)
}
}
pub struct ReadDir<T>(pub T);
impl<T> tower::Service<grpc::Request<ReadDirRequest>> for ReadDir<T>
where T: LlbBridge,
{
type Response = grpc::Response<ReadDirResponse>;
type Error = grpc::Status;
type Future = T::ReadDirFuture;
fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
Ok(futures::Async::Ready(()))
}
fn call(&mut self, request: grpc::Request<ReadDirRequest>) -> Self::Future {
self.0.read_dir(request)
}
}
pub struct StatFile<T>(pub T);
impl<T> tower::Service<grpc::Request<StatFileRequest>> for StatFile<T>
where T: LlbBridge,
{
type Response = grpc::Response<StatFileResponse>;
type Error = grpc::Status;
type Future = T::StatFileFuture;
fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
Ok(futures::Async::Ready(()))
}
fn call(&mut self, request: grpc::Request<StatFileRequest>) -> Self::Future {
self.0.stat_file(request)
}
}
pub struct Ping<T>(pub T);
impl<T> tower::Service<grpc::Request<PingRequest>> for Ping<T>
where T: LlbBridge,
{
type Response = grpc::Response<PongResponse>;
type Error = grpc::Status;
type Future = T::PingFuture;
fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
Ok(futures::Async::Ready(()))
}
fn call(&mut self, request: grpc::Request<PingRequest>) -> Self::Future {
self.0.ping(request)
}
}
pub struct Return<T>(pub T);
impl<T> tower::Service<grpc::Request<ReturnRequest>> for Return<T>
where T: LlbBridge,
{
type Response = grpc::Response<ReturnResponse>;
type Error = grpc::Status;
type Future = T::ReturnFuture;
fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
Ok(futures::Async::Ready(()))
}
fn call(&mut self, request: grpc::Request<ReturnRequest>) -> Self::Future {
self.0.r#return(request)
}
}
}
}
}