Trait nebula_fbthrift_storage::client::StorageServiceExt

pub trait StorageServiceExt<T>: StorageServicewhere
    T: Transport,{
    fn getBound_with_rpc_opts(
        &self,
        arg_req: &GetNeighborsRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<QueryResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn boundStats_with_rpc_opts(
        &self,
        arg_req: &GetNeighborsRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<QueryStatsResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn getProps_with_rpc_opts(
        &self,
        arg_req: &VertexPropRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<QueryResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn getEdgeProps_with_rpc_opts(
        &self,
        arg_req: &EdgePropRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<EdgePropResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn addVertices_with_rpc_opts(
        &self,
        arg_req: &AddVerticesRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<ExecResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn addEdges_with_rpc_opts(
        &self,
        arg_req: &AddEdgesRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<ExecResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn deleteEdges_with_rpc_opts(
        &self,
        arg_req: &DeleteEdgesRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<ExecResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn deleteVertices_with_rpc_opts(
        &self,
        arg_req: &DeleteVerticesRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<ExecResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn updateVertex_with_rpc_opts(
        &self,
        arg_req: &UpdateVertexRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<UpdateResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn updateEdge_with_rpc_opts(
        &self,
        arg_req: &UpdateEdgeRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<UpdateResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn scanEdge_with_rpc_opts(
        &self,
        arg_req: &ScanEdgeRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<ScanEdgeResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn scanVertex_with_rpc_opts(
        &self,
        arg_req: &ScanVertexRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<ScanVertexResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn transLeader_with_rpc_opts(
        &self,
        arg_req: &TransLeaderReq,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn addPart_with_rpc_opts(
        &self,
        arg_req: &AddPartReq,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn addLearner_with_rpc_opts(
        &self,
        arg_req: &AddLearnerReq,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn waitingForCatchUpData_with_rpc_opts(
        &self,
        arg_req: &CatchUpDataReq,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn removePart_with_rpc_opts(
        &self,
        arg_req: &RemovePartReq,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn memberChange_with_rpc_opts(
        &self,
        arg_req: &MemberChangeReq,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn checkPeers_with_rpc_opts(
        &self,
        arg_req: &CheckPeersReq,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn getLeaderPart_with_rpc_opts(
        &self,
        arg_req: &GetLeaderReq,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<GetLeaderResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn createCheckpoint_with_rpc_opts(
        &self,
        arg_req: &CreateCPRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn dropCheckpoint_with_rpc_opts(
        &self,
        arg_req: &DropCPRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn blockingWrites_with_rpc_opts(
        &self,
        arg_req: &BlockingSignRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn rebuildTagIndex_with_rpc_opts(
        &self,
        arg_req: &RebuildIndexRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn rebuildEdgeIndex_with_rpc_opts(
        &self,
        arg_req: &RebuildIndexRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn put_with_rpc_opts(
        &self,
        arg_req: &PutRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<ExecResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn get_with_rpc_opts(
        &self,
        arg_req: &GetRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<GeneralResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn remove_with_rpc_opts(
        &self,
        arg_req: &RemoveRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<ExecResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn removeRange_with_rpc_opts(
        &self,
        arg_req: &RemoveRangeRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<ExecResponse, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn getUUID_with_rpc_opts(
        &self,
        arg_req: &GetUUIDReq,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<GetUUIDResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
    fn lookUpIndex_with_rpc_opts(
        &self,
        arg_req: &LookUpIndexRequest,
        rpc_options: <T as Transport>::RpcOptions
    ) -> Pin<Box<dyn Future<Output = Result<LookUpIndexResp, NonthrowingFunctionError>> + Send + 'static, Global>>;
}

Required Methods

fn getBound_with_rpc_opts(
    &self,
    arg_req: &GetNeighborsRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<QueryResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn boundStats_with_rpc_opts(
    &self,
    arg_req: &GetNeighborsRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<QueryStatsResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn getProps_with_rpc_opts(
    &self,
    arg_req: &VertexPropRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<QueryResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn getEdgeProps_with_rpc_opts(
    &self,
    arg_req: &EdgePropRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<EdgePropResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn addVertices_with_rpc_opts(
    &self,
    arg_req: &AddVerticesRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<ExecResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn addEdges_with_rpc_opts(
    &self,
    arg_req: &AddEdgesRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<ExecResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn deleteEdges_with_rpc_opts(
    &self,
    arg_req: &DeleteEdgesRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<ExecResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn deleteVertices_with_rpc_opts(
    &self,
    arg_req: &DeleteVerticesRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<ExecResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn updateVertex_with_rpc_opts(
    &self,
    arg_req: &UpdateVertexRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<UpdateResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn updateEdge_with_rpc_opts(
    &self,
    arg_req: &UpdateEdgeRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<UpdateResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn scanEdge_with_rpc_opts(
    &self,
    arg_req: &ScanEdgeRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<ScanEdgeResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn scanVertex_with_rpc_opts(
    &self,
    arg_req: &ScanVertexRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<ScanVertexResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn transLeader_with_rpc_opts(
    &self,
    arg_req: &TransLeaderReq,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>

fn addPart_with_rpc_opts(
    &self,
    arg_req: &AddPartReq,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>

fn addLearner_with_rpc_opts(
    &self,
    arg_req: &AddLearnerReq,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>

fn waitingForCatchUpData_with_rpc_opts(
    &self,
    arg_req: &CatchUpDataReq,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>

fn removePart_with_rpc_opts(
    &self,
    arg_req: &RemovePartReq,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>

fn memberChange_with_rpc_opts(
    &self,
    arg_req: &MemberChangeReq,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>

fn checkPeers_with_rpc_opts(
    &self,
    arg_req: &CheckPeersReq,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>

fn getLeaderPart_with_rpc_opts(
    &self,
    arg_req: &GetLeaderReq,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<GetLeaderResp, NonthrowingFunctionError>> + Send + 'static, Global>>

fn createCheckpoint_with_rpc_opts(
    &self,
    arg_req: &CreateCPRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>

fn dropCheckpoint_with_rpc_opts(
    &self,
    arg_req: &DropCPRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>

fn blockingWrites_with_rpc_opts(
    &self,
    arg_req: &BlockingSignRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>

fn rebuildTagIndex_with_rpc_opts(
    &self,
    arg_req: &RebuildIndexRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>

fn rebuildEdgeIndex_with_rpc_opts(
    &self,
    arg_req: &RebuildIndexRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<AdminExecResp, NonthrowingFunctionError>> + Send + 'static, Global>>

fn put_with_rpc_opts(
    &self,
    arg_req: &PutRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<ExecResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn get_with_rpc_opts(
    &self,
    arg_req: &GetRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<GeneralResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn remove_with_rpc_opts(
    &self,
    arg_req: &RemoveRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<ExecResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn removeRange_with_rpc_opts(
    &self,
    arg_req: &RemoveRangeRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<ExecResponse, NonthrowingFunctionError>> + Send + 'static, Global>>

fn getUUID_with_rpc_opts(
    &self,
    arg_req: &GetUUIDReq,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<GetUUIDResp, NonthrowingFunctionError>> + Send + 'static, Global>>

fn lookUpIndex_with_rpc_opts(
    &self,
    arg_req: &LookUpIndexRequest,
    rpc_options: <T as Transport>::RpcOptions
) -> Pin<Box<dyn Future<Output = Result<LookUpIndexResp, NonthrowingFunctionError>> + Send + 'static, Global>>

Implementations

impl<T> dyn StorageServiceExt<T> + 'staticwhere
    T: Transport,

pub fn new<P>(
    protocol: P,
    transport: T
) -> Arc<impl StorageServiceExt<T> + Send + Sync + 'static>where
    P: Protocol<Frame = T>,
    <P as Protocol>::Deserializer: Send,

pub fn with_spawner<P, S>(
    protocol: P,
    transport: T,
    spawner: S
) -> Arc<impl StorageServiceExt<T> + Send + Sync + 'static>where
    P: Protocol<Frame = T>,
    <P as Protocol>::Deserializer: Send,
    S: Spawner,

Implementors

impl<'a, S, T> StorageServiceExt<T> for Swhere
    S: AsRef<dyn StorageService + 'a> + AsRef<dyn StorageServiceExt<T> + 'a> + Send,
    T: Transport,

impl<P, T, S> StorageServiceExt<T> for StorageServiceImpl<P, T, S>where
    P: Protocol,
    T: Transport,
    <P as Protocol>::Frame: Framing<DecBuf = <T as Framing>::DecBuf>,
    <<P as Protocol>::Frame as Framing>::EncBuf: BufMutExt<Final = <<T as Framing>::EncBuf as BufMutExt>::Final>,
    <P as Protocol>::Deserializer: Send,
    S: Spawner,