Struct nebula_fbthrift_meta::mock::MetaService

pub struct MetaService<'mock> {
    pub createSpace: createSpace<'mock>,
    pub dropSpace: dropSpace<'mock>,
    pub getSpace: getSpace<'mock>,
    pub listSpaces: listSpaces<'mock>,
    pub createTag: createTag<'mock>,
    pub alterTag: alterTag<'mock>,
    pub dropTag: dropTag<'mock>,
    pub getTag: getTag<'mock>,
    pub listTags: listTags<'mock>,
    pub createEdge: createEdge<'mock>,
    pub alterEdge: alterEdge<'mock>,
    pub dropEdge: dropEdge<'mock>,
    pub getEdge: getEdge<'mock>,
    pub listEdges: listEdges<'mock>,
    pub listHosts: listHosts<'mock>,
    pub getPartsAlloc: getPartsAlloc<'mock>,
    pub listParts: listParts<'mock>,
    pub multiPut: multiPut<'mock>,
    pub get: get<'mock>,
    pub multiGet: multiGet<'mock>,
    pub remove: remove<'mock>,
    pub removeRange: removeRange<'mock>,
    pub scan: scan<'mock>,
    pub createTagIndex: createTagIndex<'mock>,
    pub dropTagIndex: dropTagIndex<'mock>,
    pub getTagIndex: getTagIndex<'mock>,
    pub listTagIndexes: listTagIndexes<'mock>,
    pub rebuildTagIndex: rebuildTagIndex<'mock>,
    pub listTagIndexStatus: listTagIndexStatus<'mock>,
    pub createEdgeIndex: createEdgeIndex<'mock>,
    pub dropEdgeIndex: dropEdgeIndex<'mock>,
    pub getEdgeIndex: getEdgeIndex<'mock>,
    pub listEdgeIndexes: listEdgeIndexes<'mock>,
    pub rebuildEdgeIndex: rebuildEdgeIndex<'mock>,
    pub listEdgeIndexStatus: listEdgeIndexStatus<'mock>,
    pub createUser: createUser<'mock>,
    pub dropUser: dropUser<'mock>,
    pub alterUser: alterUser<'mock>,
    pub grantRole: grantRole<'mock>,
    pub revokeRole: revokeRole<'mock>,
    pub listUsers: listUsers<'mock>,
    pub listRoles: listRoles<'mock>,
    pub getUserRoles: getUserRoles<'mock>,
    pub changePassword: changePassword<'mock>,
    pub heartBeat: heartBeat<'mock>,
    pub balance: balance<'mock>,
    pub leaderBalance: leaderBalance<'mock>,
    pub regConfig: regConfig<'mock>,
    pub getConfig: getConfig<'mock>,
    pub setConfig: setConfig<'mock>,
    pub listConfigs: listConfigs<'mock>,
    pub createSnapshot: createSnapshot<'mock>,
    pub dropSnapshot: dropSnapshot<'mock>,
    pub listSnapshots: listSnapshots<'mock>,
    pub runAdminJob: runAdminJob<'mock>,
    // some fields omitted
}

Fields

createSpace: createSpace<'mock>

dropSpace: dropSpace<'mock>

getSpace: getSpace<'mock>

listSpaces: listSpaces<'mock>

createTag: createTag<'mock>

alterTag: alterTag<'mock>

dropTag: dropTag<'mock>

getTag: getTag<'mock>

listTags: listTags<'mock>

createEdge: createEdge<'mock>

alterEdge: alterEdge<'mock>

dropEdge: dropEdge<'mock>

getEdge: getEdge<'mock>

listEdges: listEdges<'mock>

listHosts: listHosts<'mock>

getPartsAlloc: getPartsAlloc<'mock>

listParts: listParts<'mock>

multiPut: multiPut<'mock>

get: get<'mock>

multiGet: multiGet<'mock>

remove: remove<'mock>

removeRange: removeRange<'mock>

scan: scan<'mock>

createTagIndex: createTagIndex<'mock>

dropTagIndex: dropTagIndex<'mock>

getTagIndex: getTagIndex<'mock>

listTagIndexes: listTagIndexes<'mock>

rebuildTagIndex: rebuildTagIndex<'mock>

listTagIndexStatus: listTagIndexStatus<'mock>

createEdgeIndex: createEdgeIndex<'mock>

dropEdgeIndex: dropEdgeIndex<'mock>

getEdgeIndex: getEdgeIndex<'mock>

listEdgeIndexes: listEdgeIndexes<'mock>

rebuildEdgeIndex: rebuildEdgeIndex<'mock>

listEdgeIndexStatus: listEdgeIndexStatus<'mock>

createUser: createUser<'mock>

dropUser: dropUser<'mock>

alterUser: alterUser<'mock>

grantRole: grantRole<'mock>

revokeRole: revokeRole<'mock>

listUsers: listUsers<'mock>

listRoles: listRoles<'mock>

getUserRoles: getUserRoles<'mock>

changePassword: changePassword<'mock>

heartBeat: heartBeat<'mock>

balance: balance<'mock>

leaderBalance: leaderBalance<'mock>

regConfig: regConfig<'mock>

getConfig: getConfig<'mock>

setConfig: setConfig<'mock>

listConfigs: listConfigs<'mock>

createSnapshot: createSnapshot<'mock>

dropSnapshot: dropSnapshot<'mock>

listSnapshots: listSnapshots<'mock>

runAdminJob: runAdminJob<'mock>

Trait Implementations

impl<'mock> MetaService for MetaService<'mock>

pub fn createSpace(
    &self,
    arg_req: &CreateSpaceReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, CreateSpaceError>> + Send + 'static>>

pub fn dropSpace(
    &self,
    arg_req: &DropSpaceReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, DropSpaceError>> + Send + 'static>>

pub fn getSpace(
    &self,
    arg_req: &GetSpaceReq
) -> Pin<Box<dyn Future<Output = Result<GetSpaceResp, GetSpaceError>> + Send + 'static>>

pub fn listSpaces(
    &self,
    arg_req: &ListSpacesReq
) -> Pin<Box<dyn Future<Output = Result<ListSpacesResp, ListSpacesError>> + Send + 'static>>

pub fn createTag(
    &self,
    arg_req: &CreateTagReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, CreateTagError>> + Send + 'static>>

pub fn alterTag(
    &self,
    arg_req: &AlterTagReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, AlterTagError>> + Send + 'static>>

pub fn dropTag(
    &self,
    arg_req: &DropTagReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, DropTagError>> + Send + 'static>>

pub fn getTag(
    &self,
    arg_req: &GetTagReq
) -> Pin<Box<dyn Future<Output = Result<GetTagResp, GetTagError>> + Send + 'static>>

pub fn listTags(
    &self,
    arg_req: &ListTagsReq
) -> Pin<Box<dyn Future<Output = Result<ListTagsResp, ListTagsError>> + Send + 'static>>

pub fn createEdge(
    &self,
    arg_req: &CreateEdgeReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, CreateEdgeError>> + Send + 'static>>

pub fn alterEdge(
    &self,
    arg_req: &AlterEdgeReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, AlterEdgeError>> + Send + 'static>>

pub fn dropEdge(
    &self,
    arg_req: &DropEdgeReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, DropEdgeError>> + Send + 'static>>

pub fn getEdge(
    &self,
    arg_req: &GetEdgeReq
) -> Pin<Box<dyn Future<Output = Result<GetEdgeResp, GetEdgeError>> + Send + 'static>>

pub fn listEdges(
    &self,
    arg_req: &ListEdgesReq
) -> Pin<Box<dyn Future<Output = Result<ListEdgesResp, ListEdgesError>> + Send + 'static>>

pub fn listHosts(
    &self,
    arg_req: &ListHostsReq
) -> Pin<Box<dyn Future<Output = Result<ListHostsResp, ListHostsError>> + Send + 'static>>

pub fn getPartsAlloc(
    &self,
    arg_req: &GetPartsAllocReq
) -> Pin<Box<dyn Future<Output = Result<GetPartsAllocResp, GetPartsAllocError>> + Send + 'static>>

pub fn listParts(
    &self,
    arg_req: &ListPartsReq
) -> Pin<Box<dyn Future<Output = Result<ListPartsResp, ListPartsError>> + Send + 'static>>

pub fn multiPut(
    &self,
    arg_req: &MultiPutReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, MultiPutError>> + Send + 'static>>

pub fn get(
    &self,
    arg_req: &GetReq
) -> Pin<Box<dyn Future<Output = Result<GetResp, GetError>> + Send + 'static>>

pub fn multiGet(
    &self,
    arg_req: &MultiGetReq
) -> Pin<Box<dyn Future<Output = Result<MultiGetResp, MultiGetError>> + Send + 'static>>

pub fn remove(
    &self,
    arg_req: &RemoveReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, RemoveError>> + Send + 'static>>

pub fn removeRange(
    &self,
    arg_req: &RemoveRangeReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, RemoveRangeError>> + Send + 'static>>

pub fn scan(
    &self,
    arg_req: &ScanReq
) -> Pin<Box<dyn Future<Output = Result<ScanResp, ScanError>> + Send + 'static>>

pub fn createTagIndex(
    &self,
    arg_req: &CreateTagIndexReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, CreateTagIndexError>> + Send + 'static>>

pub fn dropTagIndex(
    &self,
    arg_req: &DropTagIndexReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, DropTagIndexError>> + Send + 'static>>

pub fn getTagIndex(
    &self,
    arg_req: &GetTagIndexReq
) -> Pin<Box<dyn Future<Output = Result<GetTagIndexResp, GetTagIndexError>> + Send + 'static>>

pub fn listTagIndexes(
    &self,
    arg_req: &ListTagIndexesReq
) -> Pin<Box<dyn Future<Output = Result<ListTagIndexesResp, ListTagIndexesError>> + Send + 'static>>

pub fn rebuildTagIndex(
    &self,
    arg_req: &RebuildIndexReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, RebuildTagIndexError>> + Send + 'static>>

pub fn listTagIndexStatus(
    &self,
    arg_req: &ListIndexStatusReq
) -> Pin<Box<dyn Future<Output = Result<ListIndexStatusResp, ListTagIndexStatusError>> + Send + 'static>>

pub fn createEdgeIndex(
    &self,
    arg_req: &CreateEdgeIndexReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, CreateEdgeIndexError>> + Send + 'static>>

pub fn dropEdgeIndex(
    &self,
    arg_req: &DropEdgeIndexReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, DropEdgeIndexError>> + Send + 'static>>

pub fn getEdgeIndex(
    &self,
    arg_req: &GetEdgeIndexReq
) -> Pin<Box<dyn Future<Output = Result<GetEdgeIndexResp, GetEdgeIndexError>> + Send + 'static>>

pub fn listEdgeIndexes(
    &self,
    arg_req: &ListEdgeIndexesReq
) -> Pin<Box<dyn Future<Output = Result<ListEdgeIndexesResp, ListEdgeIndexesError>> + Send + 'static>>

pub fn rebuildEdgeIndex(
    &self,
    arg_req: &RebuildIndexReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, RebuildEdgeIndexError>> + Send + 'static>>

pub fn listEdgeIndexStatus(
    &self,
    arg_req: &ListIndexStatusReq
) -> Pin<Box<dyn Future<Output = Result<ListIndexStatusResp, ListEdgeIndexStatusError>> + Send + 'static>>

pub fn createUser(
    &self,
    arg_req: &CreateUserReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, CreateUserError>> + Send + 'static>>

pub fn dropUser(
    &self,
    arg_req: &DropUserReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, DropUserError>> + Send + 'static>>

pub fn alterUser(
    &self,
    arg_req: &AlterUserReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, AlterUserError>> + Send + 'static>>

pub fn grantRole(
    &self,
    arg_req: &GrantRoleReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, GrantRoleError>> + Send + 'static>>

pub fn revokeRole(
    &self,
    arg_req: &RevokeRoleReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, RevokeRoleError>> + Send + 'static>>

pub fn listUsers(
    &self,
    arg_req: &ListUsersReq
) -> Pin<Box<dyn Future<Output = Result<ListUsersResp, ListUsersError>> + Send + 'static>>

pub fn listRoles(
    &self,
    arg_req: &ListRolesReq
) -> Pin<Box<dyn Future<Output = Result<ListRolesResp, ListRolesError>> + Send + 'static>>

pub fn getUserRoles(
    &self,
    arg_req: &GetUserRolesReq
) -> Pin<Box<dyn Future<Output = Result<ListRolesResp, GetUserRolesError>> + Send + 'static>>

pub fn changePassword(
    &self,
    arg_req: &ChangePasswordReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, ChangePasswordError>> + Send + 'static>>

pub fn heartBeat(
    &self,
    arg_req: &HBReq
) -> Pin<Box<dyn Future<Output = Result<HBResp, HeartBeatError>> + Send + 'static>>

pub fn balance(
    &self,
    arg_req: &BalanceReq
) -> Pin<Box<dyn Future<Output = Result<BalanceResp, BalanceError>> + Send + 'static>>

pub fn leaderBalance(
    &self,
    arg_req: &LeaderBalanceReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, LeaderBalanceError>> + Send + 'static>>

pub fn regConfig(
    &self,
    arg_req: &RegConfigReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, RegConfigError>> + Send + 'static>>

pub fn getConfig(
    &self,
    arg_req: &GetConfigReq
) -> Pin<Box<dyn Future<Output = Result<GetConfigResp, GetConfigError>> + Send + 'static>>

pub fn setConfig(
    &self,
    arg_req: &SetConfigReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, SetConfigError>> + Send + 'static>>

pub fn listConfigs(
    &self,
    arg_req: &ListConfigsReq
) -> Pin<Box<dyn Future<Output = Result<ListConfigsResp, ListConfigsError>> + Send + 'static>>

pub fn createSnapshot(
    &self,
    arg_req: &CreateSnapshotReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, CreateSnapshotError>> + Send + 'static>>

pub fn dropSnapshot(
    &self,
    arg_req: &DropSnapshotReq
) -> Pin<Box<dyn Future<Output = Result<ExecResp, DropSnapshotError>> + Send + 'static>>

pub fn listSnapshots(
    &self,
    arg_req: &ListSnapshotsReq
) -> Pin<Box<dyn Future<Output = Result<ListSnapshotsResp, ListSnapshotsError>> + Send + 'static>>

pub fn runAdminJob(
    &self,
    arg_req: &AdminJobReq
) -> Pin<Box<dyn Future<Output = Result<AdminJobResp, RunAdminJobError>> + Send + 'static>>