Trait FlightService

pub trait FlightService:
    Send
    + Sync
    + 'static {
    type HandshakeStream: Stream<Item = Result<HandshakeResponse, Status>> + Send + 'static;
    type ListFlightsStream: Stream<Item = Result<FlightInfo, Status>> + Send + 'static;
    type DoGetStream: Stream<Item = Result<FlightData, Status>> + Send + 'static;
    type DoPutStream: Stream<Item = Result<PutResult, Status>> + Send + 'static;
    type DoExchangeStream: Stream<Item = Result<FlightData, Status>> + Send + 'static;
    type DoActionStream: Stream<Item = Result<Result, Status>> + Send + 'static;
    type ListActionsStream: Stream<Item = Result<ActionType, Status>> + Send + 'static;

    // Required methods
    fn handshake<'life0, 'async_trait>(
        &'life0 self,
        request: Request<Streaming<HandshakeRequest>>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::HandshakeStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_flights<'life0, 'async_trait>(
        &'life0 self,
        request: Request<Criteria>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::ListFlightsStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_flight_info<'life0, 'async_trait>(
        &'life0 self,
        request: Request<FlightDescriptor>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<FlightInfo>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn poll_flight_info<'life0, 'async_trait>(
        &'life0 self,
        request: Request<FlightDescriptor>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<PollInfo>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_schema<'life0, 'async_trait>(
        &'life0 self,
        request: Request<FlightDescriptor>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<SchemaResult>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn do_get<'life0, 'async_trait>(
        &'life0 self,
        request: Request<Ticket>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::DoGetStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn do_put<'life0, 'async_trait>(
        &'life0 self,
        request: Request<Streaming<FlightData>>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::DoPutStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn do_exchange<'life0, 'async_trait>(
        &'life0 self,
        request: Request<Streaming<FlightData>>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::DoExchangeStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn do_action<'life0, 'async_trait>(
        &'life0 self,
        request: Request<Action>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::DoActionStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_actions<'life0, 'async_trait>(
        &'life0 self,
        request: Request<Empty>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::ListActionsStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
}

Generated trait containing gRPC methods that should be implemented for use with FlightServiceServer.

Required Associated Types

type HandshakeStream: Stream<Item = Result<HandshakeResponse, Status>> + Send + 'static

Server streaming response type for the Handshake method.

type ListFlightsStream: Stream<Item = Result<FlightInfo, Status>> + Send + 'static

Server streaming response type for the ListFlights method.

type DoGetStream: Stream<Item = Result<FlightData, Status>> + Send + 'static

Server streaming response type for the DoGet method.

type DoPutStream: Stream<Item = Result<PutResult, Status>> + Send + 'static

Server streaming response type for the DoPut method.

type DoExchangeStream: Stream<Item = Result<FlightData, Status>> + Send + 'static

Server streaming response type for the DoExchange method.

type DoActionStream: Stream<Item = Result<Result, Status>> + Send + 'static

Server streaming response type for the DoAction method.

type ListActionsStream: Stream<Item = Result<ActionType, Status>> + Send + 'static

Server streaming response type for the ListActions method.

Required Methods

fn handshake<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<HandshakeRequest>>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::HandshakeStream>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handshake between client and server. Depending on the server, the handshake may be required to determine the token that should be used for future operations. Both request and response are streams to allow multiple round-trips depending on auth mechanism.

fn list_flights<'life0, 'async_trait>( &'life0 self, request: Request<Criteria>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::ListFlightsStream>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get a list of available streams given a particular criteria. Most flight services will expose one or more streams that are readily available for retrieval. This api allows listing the streams available for consumption. A user can also provide a criteria. The criteria can limit the subset of streams that can be listed via this interface. Each flight service allows its own definition of how to consume criteria.

fn get_flight_info<'life0, 'async_trait>( &'life0 self, request: Request<FlightDescriptor>, ) -> Pin<Box<dyn Future<Output = Result<Response<FlightInfo>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

For a given FlightDescriptor, get information about how the flight can be consumed. This is a useful interface if the consumer of the interface already can identify the specific flight to consume. This interface can also allow a consumer to generate a flight stream through a specified descriptor. For example, a flight descriptor might be something that includes a SQL statement or a Pickled Python operation that will be executed. In those cases, the descriptor will not be previously available within the list of available streams provided by ListFlights but will be available for consumption for the duration defined by the specific flight service.

fn poll_flight_info<'life0, 'async_trait>( &'life0 self, request: Request<FlightDescriptor>, ) -> Pin<Box<dyn Future<Output = Result<Response<PollInfo>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

For a given FlightDescriptor, start a query and get information to poll its execution status. This is a useful interface if the query may be a long-running query. The first PollFlightInfo call should return as quickly as possible. (GetFlightInfo doesn’t return until the query is complete.)

A client can consume any available results before the query is completed. See PollInfo.info for details.

A client can poll the updated query status by calling PollFlightInfo() with PollInfo.flight_descriptor. A server should not respond until the result would be different from last time. That way, the client can “long poll” for updates without constantly making requests. Clients can set a short timeout to avoid blocking calls if desired.

A client can’t use PollInfo.flight_descriptor after PollInfo.expiration_time passes. A server might not accept the retry descriptor anymore and the query may be cancelled.

A client may use the CancelFlightInfo action with PollInfo.info to cancel the running query.

fn get_schema<'life0, 'async_trait>( &'life0 self, request: Request<FlightDescriptor>, ) -> Pin<Box<dyn Future<Output = Result<Response<SchemaResult>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema This is used when a consumer needs the Schema of flight stream. Similar to GetFlightInfo this interface may generate a new flight that was not previously available in ListFlights.

fn do_get<'life0, 'async_trait>( &'life0 self, request: Request<Ticket>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::DoGetStream>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve a single stream associated with a particular descriptor associated with the referenced ticket. A Flight can be composed of one or more streams where each stream can be retrieved using a separate opaque ticket that the flight service uses for managing a collection of streams.

fn do_put<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<FlightData>>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::DoPutStream>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Push a stream to the flight service associated with a particular flight stream. This allows a client of a flight service to upload a stream of data. Depending on the particular flight service, a client consumer could be allowed to upload a single stream per descriptor or an unlimited number. In the latter, the service might implement a ‘seal’ action that can be applied to a descriptor once all streams are uploaded.

fn do_exchange<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<FlightData>>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::DoExchangeStream>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Open a bidirectional data channel for a given descriptor. This allows clients to send and receive arbitrary Arrow data and application-specific metadata in a single logical stream. In contrast to DoGet/DoPut, this is more suited for clients offloading computation (rather than storage) to a Flight service.

fn do_action<'life0, 'async_trait>( &'life0 self, request: Request<Action>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::DoActionStream>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Flight services can support an arbitrary number of simple actions in addition to the possible ListFlights, GetFlightInfo, DoGet, DoPut operations that are potentially available. DoAction allows a flight client to do a specific action against a flight service. An action includes opaque request and response objects that are specific to the type action being undertaken.

fn list_actions<'life0, 'async_trait>( &'life0 self, request: Request<Empty>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::ListActionsStream>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

A flight service exposes all of the available action types that it has along with descriptions. This allows different flight consumers to understand the capabilities of the flight service.

Implementors

impl<T> FlightService for T

where T: FlightSqlService + Send + 'static,

Implements the lower level interface to handle FlightSQL

type HandshakeStream = Pin<Box<dyn Stream<Item = Result<HandshakeResponse, Status>> + Send>>

type ListFlightsStream = Pin<Box<dyn Stream<Item = Result<FlightInfo, Status>> + Send>>

type DoGetStream = Pin<Box<dyn Stream<Item = Result<FlightData, Status>> + Send>>

type DoPutStream = Pin<Box<dyn Stream<Item = Result<PutResult, Status>> + Send>>

type DoActionStream = Pin<Box<dyn Stream<Item = Result<Result, Status>> + Send>>

type ListActionsStream = Pin<Box<dyn Stream<Item = Result<ActionType, Status>> + Send>>

type DoExchangeStream = Pin<Box<dyn Stream<Item = Result<FlightData, Status>> + Send>>