Skip to main content

arrow_integration_testing/flight_server_scenarios/
middleware.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: See the NOTICE file distributed with this work for additional information regarding copyright ownership
3// SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements
4
5//! Middleware test for the Flight server.
6
7use 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
23/// Run a scenario that tests middleware.
24pub 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    // NOTE: Log output used in tests to signal server is ready
32    println!("Server listening on localhost:{}", addr.port());
33    server.await?;
34    Ok(())
35}
36
37/// Middleware interceptor for testing
38#[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            // Return a fake location - the test doesn't read it
90            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}