arrow_integration_testing/flight_server_scenarios/
middleware.rs1use std::pin::Pin;
8
9use arrow_flight::{
10 Action, ActionType, Criteria, Empty, FlightData, FlightDescriptor, FlightInfo,
11 HandshakeRequest, HandshakeResponse, PollInfo, PutResult, SchemaResult, Ticket,
12 flight_descriptor::DescriptorType, flight_service_server::FlightService,
13 flight_service_server::FlightServiceServer,
14};
15use futures::Stream;
16use tonic::{Request, Response, Status, Streaming, transport::Server};
17
18type TonicStream<T> = Pin<Box<dyn Stream<Item = T> + Send + Sync + 'static>>;
19
20type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
21type Result<T = (), E = Error> = std::result::Result<T, E>;
22
23pub async fn scenario_setup(port: u16) -> Result {
25 let service = MiddlewareScenarioImpl {};
26 let svc = FlightServiceServer::new(service);
27 let addr = super::listen_on(port).await?;
28
29 let server = Server::builder().add_service(svc).serve(addr);
30
31 println!("Server listening on localhost:{}", addr.port());
33 server.await?;
34 Ok(())
35}
36
37#[derive(Clone, Default)]
39pub struct MiddlewareScenarioImpl {}
40
41#[tonic::async_trait]
42impl FlightService for MiddlewareScenarioImpl {
43 type HandshakeStream = TonicStream<Result<HandshakeResponse, Status>>;
44 type ListFlightsStream = TonicStream<Result<FlightInfo, Status>>;
45 type DoGetStream = TonicStream<Result<FlightData, Status>>;
46 type DoPutStream = TonicStream<Result<PutResult, Status>>;
47 type DoActionStream = TonicStream<Result<arrow_flight::Result, Status>>;
48 type ListActionsStream = TonicStream<Result<ActionType, Status>>;
49 type DoExchangeStream = TonicStream<Result<FlightData, Status>>;
50
51 async fn get_schema(
52 &self,
53 _request: Request<FlightDescriptor>,
54 ) -> Result<Response<SchemaResult>, Status> {
55 Err(Status::unimplemented("Not yet implemented"))
56 }
57
58 async fn do_get(
59 &self,
60 _request: Request<Ticket>,
61 ) -> Result<Response<Self::DoGetStream>, Status> {
62 Err(Status::unimplemented("Not yet implemented"))
63 }
64
65 async fn handshake(
66 &self,
67 _request: Request<Streaming<HandshakeRequest>>,
68 ) -> Result<Response<Self::HandshakeStream>, Status> {
69 Err(Status::unimplemented("Not yet implemented"))
70 }
71
72 async fn list_flights(
73 &self,
74 _request: Request<Criteria>,
75 ) -> Result<Response<Self::ListFlightsStream>, Status> {
76 Err(Status::unimplemented("Not yet implemented"))
77 }
78
79 async fn get_flight_info(
80 &self,
81 request: Request<FlightDescriptor>,
82 ) -> Result<Response<FlightInfo>, Status> {
83 let middleware_header = request.metadata().get("x-middleware").cloned();
84
85 let descriptor = request.into_inner();
86
87 if descriptor.r#type == DescriptorType::Cmd as i32 && descriptor.cmd.as_ref() == b"success"
88 {
89 let endpoint = super::endpoint("foo", "grpc+tcp://localhost:10010");
91
92 let info = FlightInfo {
93 flight_descriptor: Some(descriptor),
94 endpoint: vec![endpoint],
95 ..Default::default()
96 };
97
98 let mut response = Response::new(info);
99 if let Some(value) = middleware_header {
100 response.metadata_mut().insert("x-middleware", value);
101 }
102
103 return Ok(response);
104 }
105
106 let mut status = Status::unknown("Unknown");
107 if let Some(value) = middleware_header {
108 status.metadata_mut().insert("x-middleware", value);
109 }
110
111 Err(status)
112 }
113
114 async fn poll_flight_info(
115 &self,
116 _request: Request<FlightDescriptor>,
117 ) -> Result<Response<PollInfo>, Status> {
118 Err(Status::unimplemented("Not yet implemented"))
119 }
120
121 async fn do_put(
122 &self,
123 _request: Request<Streaming<FlightData>>,
124 ) -> Result<Response<Self::DoPutStream>, Status> {
125 Err(Status::unimplemented("Not yet implemented"))
126 }
127
128 async fn do_action(
129 &self,
130 _request: Request<Action>,
131 ) -> Result<Response<Self::DoActionStream>, Status> {
132 Err(Status::unimplemented("Not yet implemented"))
133 }
134
135 async fn list_actions(
136 &self,
137 _request: Request<Empty>,
138 ) -> Result<Response<Self::ListActionsStream>, Status> {
139 Err(Status::unimplemented("Not yet implemented"))
140 }
141
142 async fn do_exchange(
143 &self,
144 _request: Request<Streaming<FlightData>>,
145 ) -> Result<Response<Self::DoExchangeStream>, Status> {
146 Err(Status::unimplemented("Not yet implemented"))
147 }
148}