Struct nebula_fbthrift_meta_v2::mock::MetaService

pub struct MetaService<'mock> {

    pub createSpace: createSpace<'mock>,
    pub dropSpace: dropSpace<'mock>,
    pub getSpace: getSpace<'mock>,
    pub listSpaces: listSpaces<'mock>,
    pub createSpaceAs: createSpaceAs<'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>,
    pub addZone: addZone<'mock>,
    pub dropZone: dropZone<'mock>,
    pub addHostIntoZone: addHostIntoZone<'mock>,
    pub dropHostFromZone: dropHostFromZone<'mock>,
    pub getZone: getZone<'mock>,
    pub listZones: listZones<'mock>,
    pub addGroup: addGroup<'mock>,
    pub dropGroup: dropGroup<'mock>,
    pub addZoneIntoGroup: addZoneIntoGroup<'mock>,
    pub dropZoneFromGroup: dropZoneFromGroup<'mock>,
    pub getGroup: getGroup<'mock>,
    pub listGroups: listGroups<'mock>,
    pub createBackup: createBackup<'mock>,
    pub restoreMeta: restoreMeta<'mock>,
    pub addListener: addListener<'mock>,
    pub removeListener: removeListener<'mock>,
    pub listListener: listListener<'mock>,
    pub getStats: getStats<'mock>,
    pub signInFTService: signInFTService<'mock>,
    pub signOutFTService: signOutFTService<'mock>,
    pub listFTClients: listFTClients<'mock>,
    pub createFTIndex: createFTIndex<'mock>,
    pub dropFTIndex: dropFTIndex<'mock>,
    pub listFTIndexes: listFTIndexes<'mock>,
    pub createSession: createSession<'mock>,
    pub updateSessions: updateSessions<'mock>,
    pub listSessions: listSessions<'mock>,
    pub getSession: getSession<'mock>,
    pub removeSession: removeSession<'mock>,
    pub killQuery: killQuery<'mock>,
    pub reportTaskFinish: reportTaskFinish<'mock>,
    pub listCluster: listCluster<'mock>,
    pub getMetaDirInfo: getMetaDirInfo<'mock>,
    pub verifyClientVersion: verifyClientVersion<'mock>,
    /* private fields */
}

Fields

createSpace: createSpace<'mock>

dropSpace: dropSpace<'mock>

getSpace: getSpace<'mock>

listSpaces: listSpaces<'mock>

createSpaceAs: createSpaceAs<'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>

addZone: addZone<'mock>

dropZone: dropZone<'mock>

addHostIntoZone: addHostIntoZone<'mock>

dropHostFromZone: dropHostFromZone<'mock>

getZone: getZone<'mock>

listZones: listZones<'mock>

addGroup: addGroup<'mock>

dropGroup: dropGroup<'mock>

addZoneIntoGroup: addZoneIntoGroup<'mock>

dropZoneFromGroup: dropZoneFromGroup<'mock>

getGroup: getGroup<'mock>

listGroups: listGroups<'mock>

createBackup: createBackup<'mock>

restoreMeta: restoreMeta<'mock>

addListener: addListener<'mock>

removeListener: removeListener<'mock>

listListener: listListener<'mock>

getStats: getStats<'mock>

signInFTService: signInFTService<'mock>

signOutFTService: signOutFTService<'mock>

listFTClients: listFTClients<'mock>

createFTIndex: createFTIndex<'mock>

dropFTIndex: dropFTIndex<'mock>

listFTIndexes: listFTIndexes<'mock>

createSession: createSession<'mock>

updateSessions: updateSessions<'mock>

listSessions: listSessions<'mock>

getSession: getSession<'mock>

removeSession: removeSession<'mock>

killQuery: killQuery<'mock>

reportTaskFinish: reportTaskFinish<'mock>

listCluster: listCluster<'mock>

getMetaDirInfo: getMetaDirInfo<'mock>

verifyClientVersion: verifyClientVersion<'mock>

Trait Implementations

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

fn createSpace(
    &self,
    arg_req: &CreateSpaceReq
) -> BoxFuture<'static, Result<ExecResp, CreateSpaceError>>

fn dropSpace(
    &self,
    arg_req: &DropSpaceReq
) -> BoxFuture<'static, Result<ExecResp, DropSpaceError>>

fn getSpace(
    &self,
    arg_req: &GetSpaceReq
) -> BoxFuture<'static, Result<GetSpaceResp, GetSpaceError>>

fn listSpaces(
    &self,
    arg_req: &ListSpacesReq
) -> BoxFuture<'static, Result<ListSpacesResp, ListSpacesError>>

fn createSpaceAs(
    &self,
    arg_req: &CreateSpaceAsReq
) -> BoxFuture<'static, Result<ExecResp, CreateSpaceAsError>>

fn createTag(
    &self,
    arg_req: &CreateTagReq
) -> BoxFuture<'static, Result<ExecResp, CreateTagError>>

fn alterTag(
    &self,
    arg_req: &AlterTagReq
) -> BoxFuture<'static, Result<ExecResp, AlterTagError>>

fn dropTag(
    &self,
    arg_req: &DropTagReq
) -> BoxFuture<'static, Result<ExecResp, DropTagError>>

fn getTag(
    &self,
    arg_req: &GetTagReq
) -> BoxFuture<'static, Result<GetTagResp, GetTagError>>

fn listTags(
    &self,
    arg_req: &ListTagsReq
) -> BoxFuture<'static, Result<ListTagsResp, ListTagsError>>

fn createEdge(
    &self,
    arg_req: &CreateEdgeReq
) -> BoxFuture<'static, Result<ExecResp, CreateEdgeError>>

fn alterEdge(
    &self,
    arg_req: &AlterEdgeReq
) -> BoxFuture<'static, Result<ExecResp, AlterEdgeError>>

fn dropEdge(
    &self,
    arg_req: &DropEdgeReq
) -> BoxFuture<'static, Result<ExecResp, DropEdgeError>>

fn getEdge(
    &self,
    arg_req: &GetEdgeReq
) -> BoxFuture<'static, Result<GetEdgeResp, GetEdgeError>>

fn listEdges(
    &self,
    arg_req: &ListEdgesReq
) -> BoxFuture<'static, Result<ListEdgesResp, ListEdgesError>>

fn listHosts(
    &self,
    arg_req: &ListHostsReq
) -> BoxFuture<'static, Result<ListHostsResp, ListHostsError>>

fn getPartsAlloc(
    &self,
    arg_req: &GetPartsAllocReq
) -> BoxFuture<'static, Result<GetPartsAllocResp, GetPartsAllocError>>

fn listParts(
    &self,
    arg_req: &ListPartsReq
) -> BoxFuture<'static, Result<ListPartsResp, ListPartsError>>

fn multiPut(
    &self,
    arg_req: &MultiPutReq
) -> BoxFuture<'static, Result<ExecResp, MultiPutError>>

fn get(&self, arg_req: &GetReq) -> BoxFuture<'static, Result<GetResp, GetError>>

fn multiGet(
    &self,
    arg_req: &MultiGetReq
) -> BoxFuture<'static, Result<MultiGetResp, MultiGetError>>

fn remove(
    &self,
    arg_req: &RemoveReq
) -> BoxFuture<'static, Result<ExecResp, RemoveError>>

fn removeRange(
    &self,
    arg_req: &RemoveRangeReq
) -> BoxFuture<'static, Result<ExecResp, RemoveRangeError>>

fn scan(
    &self,
    arg_req: &ScanReq
) -> BoxFuture<'static, Result<ScanResp, ScanError>>

fn createTagIndex(
    &self,
    arg_req: &CreateTagIndexReq
) -> BoxFuture<'static, Result<ExecResp, CreateTagIndexError>>

fn dropTagIndex(
    &self,
    arg_req: &DropTagIndexReq
) -> BoxFuture<'static, Result<ExecResp, DropTagIndexError>>

fn getTagIndex(
    &self,
    arg_req: &GetTagIndexReq
) -> BoxFuture<'static, Result<GetTagIndexResp, GetTagIndexError>>

fn listTagIndexes(
    &self,
    arg_req: &ListTagIndexesReq
) -> BoxFuture<'static, Result<ListTagIndexesResp, ListTagIndexesError>>

fn rebuildTagIndex(
    &self,
    arg_req: &RebuildIndexReq
) -> BoxFuture<'static, Result<ExecResp, RebuildTagIndexError>>

fn listTagIndexStatus(
    &self,
    arg_req: &ListIndexStatusReq
) -> BoxFuture<'static, Result<ListIndexStatusResp, ListTagIndexStatusError>>

fn createEdgeIndex(
    &self,
    arg_req: &CreateEdgeIndexReq
) -> BoxFuture<'static, Result<ExecResp, CreateEdgeIndexError>>

fn dropEdgeIndex(
    &self,
    arg_req: &DropEdgeIndexReq
) -> BoxFuture<'static, Result<ExecResp, DropEdgeIndexError>>

fn getEdgeIndex(
    &self,
    arg_req: &GetEdgeIndexReq
) -> BoxFuture<'static, Result<GetEdgeIndexResp, GetEdgeIndexError>>

fn listEdgeIndexes(
    &self,
    arg_req: &ListEdgeIndexesReq
) -> BoxFuture<'static, Result<ListEdgeIndexesResp, ListEdgeIndexesError>>

fn rebuildEdgeIndex(
    &self,
    arg_req: &RebuildIndexReq
) -> BoxFuture<'static, Result<ExecResp, RebuildEdgeIndexError>>

fn listEdgeIndexStatus(
    &self,
    arg_req: &ListIndexStatusReq
) -> BoxFuture<'static, Result<ListIndexStatusResp, ListEdgeIndexStatusError>>

fn createUser(
    &self,
    arg_req: &CreateUserReq
) -> BoxFuture<'static, Result<ExecResp, CreateUserError>>

fn dropUser(
    &self,
    arg_req: &DropUserReq
) -> BoxFuture<'static, Result<ExecResp, DropUserError>>

fn alterUser(
    &self,
    arg_req: &AlterUserReq
) -> BoxFuture<'static, Result<ExecResp, AlterUserError>>

fn grantRole(
    &self,
    arg_req: &GrantRoleReq
) -> BoxFuture<'static, Result<ExecResp, GrantRoleError>>

fn revokeRole(
    &self,
    arg_req: &RevokeRoleReq
) -> BoxFuture<'static, Result<ExecResp, RevokeRoleError>>

fn listUsers(
    &self,
    arg_req: &ListUsersReq
) -> BoxFuture<'static, Result<ListUsersResp, ListUsersError>>

fn listRoles(
    &self,
    arg_req: &ListRolesReq
) -> BoxFuture<'static, Result<ListRolesResp, ListRolesError>>

fn getUserRoles(
    &self,
    arg_req: &GetUserRolesReq
) -> BoxFuture<'static, Result<ListRolesResp, GetUserRolesError>>

fn changePassword(
    &self,
    arg_req: &ChangePasswordReq
) -> BoxFuture<'static, Result<ExecResp, ChangePasswordError>>

fn heartBeat(
    &self,
    arg_req: &HBReq
) -> BoxFuture<'static, Result<HBResp, HeartBeatError>>

fn balance(
    &self,
    arg_req: &BalanceReq
) -> BoxFuture<'static, Result<BalanceResp, BalanceError>>

fn leaderBalance(
    &self,
    arg_req: &LeaderBalanceReq
) -> BoxFuture<'static, Result<ExecResp, LeaderBalanceError>>

fn regConfig(
    &self,
    arg_req: &RegConfigReq
) -> BoxFuture<'static, Result<ExecResp, RegConfigError>>

fn getConfig(
    &self,
    arg_req: &GetConfigReq
) -> BoxFuture<'static, Result<GetConfigResp, GetConfigError>>

fn setConfig(
    &self,
    arg_req: &SetConfigReq
) -> BoxFuture<'static, Result<ExecResp, SetConfigError>>

fn listConfigs(
    &self,
    arg_req: &ListConfigsReq
) -> BoxFuture<'static, Result<ListConfigsResp, ListConfigsError>>

fn createSnapshot(
    &self,
    arg_req: &CreateSnapshotReq
) -> BoxFuture<'static, Result<ExecResp, CreateSnapshotError>>

fn dropSnapshot(
    &self,
    arg_req: &DropSnapshotReq
) -> BoxFuture<'static, Result<ExecResp, DropSnapshotError>>

fn listSnapshots(
    &self,
    arg_req: &ListSnapshotsReq
) -> BoxFuture<'static, Result<ListSnapshotsResp, ListSnapshotsError>>

fn runAdminJob(
    &self,
    arg_req: &AdminJobReq
) -> BoxFuture<'static, Result<AdminJobResp, RunAdminJobError>>

fn addZone(
    &self,
    arg_req: &AddZoneReq
) -> BoxFuture<'static, Result<ExecResp, AddZoneError>>

fn dropZone(
    &self,
    arg_req: &DropZoneReq
) -> BoxFuture<'static, Result<ExecResp, DropZoneError>>

fn addHostIntoZone(
    &self,
    arg_req: &AddHostIntoZoneReq
) -> BoxFuture<'static, Result<ExecResp, AddHostIntoZoneError>>

fn dropHostFromZone(
    &self,
    arg_req: &DropHostFromZoneReq
) -> BoxFuture<'static, Result<ExecResp, DropHostFromZoneError>>

fn getZone(
    &self,
    arg_req: &GetZoneReq
) -> BoxFuture<'static, Result<GetZoneResp, GetZoneError>>

fn listZones(
    &self,
    arg_req: &ListZonesReq
) -> BoxFuture<'static, Result<ListZonesResp, ListZonesError>>

fn addGroup(
    &self,
    arg_req: &AddGroupReq
) -> BoxFuture<'static, Result<ExecResp, AddGroupError>>

fn dropGroup(
    &self,
    arg_req: &DropGroupReq
) -> BoxFuture<'static, Result<ExecResp, DropGroupError>>

fn addZoneIntoGroup(
    &self,
    arg_req: &AddZoneIntoGroupReq
) -> BoxFuture<'static, Result<ExecResp, AddZoneIntoGroupError>>

fn dropZoneFromGroup(
    &self,
    arg_req: &DropZoneFromGroupReq
) -> BoxFuture<'static, Result<ExecResp, DropZoneFromGroupError>>

fn getGroup(
    &self,
    arg_req: &GetGroupReq
) -> BoxFuture<'static, Result<GetGroupResp, GetGroupError>>

fn listGroups(
    &self,
    arg_req: &ListGroupsReq
) -> BoxFuture<'static, Result<ListGroupsResp, ListGroupsError>>

fn createBackup(
    &self,
    arg_req: &CreateBackupReq
) -> BoxFuture<'static, Result<CreateBackupResp, CreateBackupError>>

fn restoreMeta(
    &self,
    arg_req: &RestoreMetaReq
) -> BoxFuture<'static, Result<ExecResp, RestoreMetaError>>

fn addListener(
    &self,
    arg_req: &AddListenerReq
) -> BoxFuture<'static, Result<ExecResp, AddListenerError>>

fn removeListener(
    &self,
    arg_req: &RemoveListenerReq
) -> BoxFuture<'static, Result<ExecResp, RemoveListenerError>>

fn listListener(
    &self,
    arg_req: &ListListenerReq
) -> BoxFuture<'static, Result<ListListenerResp, ListListenerError>>

fn getStats(
    &self,
    arg_req: &GetStatsReq
) -> BoxFuture<'static, Result<GetStatsResp, GetStatsError>>

fn signInFTService(
    &self,
    arg_req: &SignInFTServiceReq
) -> BoxFuture<'static, Result<ExecResp, SignInFTServiceError>>

fn signOutFTService(
    &self,
    arg_req: &SignOutFTServiceReq
) -> BoxFuture<'static, Result<ExecResp, SignOutFTServiceError>>

fn listFTClients(
    &self,
    arg_req: &ListFTClientsReq
) -> BoxFuture<'static, Result<ListFTClientsResp, ListFTClientsError>>

fn createFTIndex(
    &self,
    arg_req: &CreateFTIndexReq
) -> BoxFuture<'static, Result<ExecResp, CreateFTIndexError>>

fn dropFTIndex(
    &self,
    arg_req: &DropFTIndexReq
) -> BoxFuture<'static, Result<ExecResp, DropFTIndexError>>

fn listFTIndexes(
    &self,
    arg_req: &ListFTIndexesReq
) -> BoxFuture<'static, Result<ListFTIndexesResp, ListFTIndexesError>>

fn createSession(
    &self,
    arg_req: &CreateSessionReq
) -> BoxFuture<'static, Result<CreateSessionResp, CreateSessionError>>

fn updateSessions(
    &self,
    arg_req: &UpdateSessionsReq
) -> BoxFuture<'static, Result<UpdateSessionsResp, UpdateSessionsError>>

fn listSessions(
    &self,
    arg_req: &ListSessionsReq
) -> BoxFuture<'static, Result<ListSessionsResp, ListSessionsError>>

fn getSession(
    &self,
    arg_req: &GetSessionReq
) -> BoxFuture<'static, Result<GetSessionResp, GetSessionError>>

fn removeSession(
    &self,
    arg_req: &RemoveSessionReq
) -> BoxFuture<'static, Result<ExecResp, RemoveSessionError>>

fn killQuery(
    &self,
    arg_req: &KillQueryReq
) -> BoxFuture<'static, Result<ExecResp, KillQueryError>>

fn reportTaskFinish(
    &self,
    arg_req: &ReportTaskReq
) -> BoxFuture<'static, Result<ExecResp, ReportTaskFinishError>>

fn listCluster(
    &self,
    arg_req: &ListClusterInfoReq
) -> BoxFuture<'static, Result<ListClusterInfoResp, ListClusterError>>

fn getMetaDirInfo(
    &self,
    arg_req: &GetMetaDirInfoReq
) -> BoxFuture<'static, Result<GetMetaDirInfoResp, GetMetaDirInfoError>>

fn verifyClientVersion(
    &self,
    arg_req: &VerifyClientVersionReq
) -> BoxFuture<'static, Result<VerifyClientVersionResp, VerifyClientVersionError>>