Struct tikv::server::service::KvService

pub struct KvService<T: RaftStoreRouter<RocksEngine> + 'static, E: Engine, L: LockManager> {
    store_id: u64,
    gc_worker: GcWorker<E, T>,
    storage: Storage<E, L>,
    copr: Endpoint<E>,
    copr_v2: Endpoint,
    ch: T,
    snap_scheduler: Scheduler<SnapTask>,
    enable_req_batch: bool,
    grpc_thread_load: Arc<ThreadLoad>,
    proxy: Proxy,
}

Service handles the RPC messages for the Tikv service.

Fields

store_id: u64

gc_worker: GcWorker<E, T>

Used to handle requests related to GC.

storage: Storage<E, L>

copr: Endpoint<E>

copr_v2: Endpoint

ch: T

snap_scheduler: Scheduler<SnapTask>

enable_req_batch: bool

grpc_thread_load: Arc<ThreadLoad>

proxy: Proxy

Implementations

impl<T: RaftStoreRouter<RocksEngine> + 'static, E: Engine, L: LockManager> Service<T, E, L>

pub fn new(
    store_id: u64,
    storage: Storage<E, L>,
    gc_worker: GcWorker<E, T>,
    copr: Endpoint<E>,
    copr_v2: Endpoint,
    ch: T,
    snap_scheduler: Scheduler<SnapTask>,
    grpc_thread_load: Arc<ThreadLoad>,
    enable_req_batch: bool,
    proxy: Proxy
) -> Self

Constructs a new Service which provides the Tikv service.

Trait Implementations

impl<T: RaftStoreRouter<RocksEngine> + Clone + 'static, E: Engine + Clone, L: LockManager + Clone> Clone for Service<T, E, L>

fn clone(&self) -> Self

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: RaftStoreRouter<RocksEngine> + 'static, E: Engine, L: LockManager> Tikv for Service<T, E, L>

fn kv_get(
    &mut self,
    ctx: RpcContext<'_>,
    req: GetRequest,
    sink: UnarySink<GetResponse>
)

fn kv_scan(
    &mut self,
    ctx: RpcContext<'_>,
    req: ScanRequest,
    sink: UnarySink<ScanResponse>
)

fn kv_prewrite(
    &mut self,
    ctx: RpcContext<'_>,
    req: PrewriteRequest,
    sink: UnarySink<PrewriteResponse>
)

fn kv_pessimistic_lock(
    &mut self,
    ctx: RpcContext<'_>,
    req: PessimisticLockRequest,
    sink: UnarySink<PessimisticLockResponse>
)

fn kv_pessimistic_rollback(
    &mut self,
    ctx: RpcContext<'_>,
    req: PessimisticRollbackRequest,
    sink: UnarySink<PessimisticRollbackResponse>
)

fn kv_commit(
    &mut self,
    ctx: RpcContext<'_>,
    req: CommitRequest,
    sink: UnarySink<CommitResponse>
)

fn kv_cleanup(
    &mut self,
    ctx: RpcContext<'_>,
    req: CleanupRequest,
    sink: UnarySink<CleanupResponse>
)

fn kv_batch_get(
    &mut self,
    ctx: RpcContext<'_>,
    req: BatchGetRequest,
    sink: UnarySink<BatchGetResponse>
)

fn kv_batch_rollback(
    &mut self,
    ctx: RpcContext<'_>,
    req: BatchRollbackRequest,
    sink: UnarySink<BatchRollbackResponse>
)

fn kv_txn_heart_beat(
    &mut self,
    ctx: RpcContext<'_>,
    req: TxnHeartBeatRequest,
    sink: UnarySink<TxnHeartBeatResponse>
)

fn kv_check_txn_status(
    &mut self,
    ctx: RpcContext<'_>,
    req: CheckTxnStatusRequest,
    sink: UnarySink<CheckTxnStatusResponse>
)

fn kv_check_secondary_locks(
    &mut self,
    ctx: RpcContext<'_>,
    req: CheckSecondaryLocksRequest,
    sink: UnarySink<CheckSecondaryLocksResponse>
)

fn kv_scan_lock(
    &mut self,
    ctx: RpcContext<'_>,
    req: ScanLockRequest,
    sink: UnarySink<ScanLockResponse>
)

fn kv_resolve_lock(
    &mut self,
    ctx: RpcContext<'_>,
    req: ResolveLockRequest,
    sink: UnarySink<ResolveLockResponse>
)

fn kv_delete_range(
    &mut self,
    ctx: RpcContext<'_>,
    req: DeleteRangeRequest,
    sink: UnarySink<DeleteRangeResponse>
)

fn mvcc_get_by_key(
    &mut self,
    ctx: RpcContext<'_>,
    req: MvccGetByKeyRequest,
    sink: UnarySink<MvccGetByKeyResponse>
)

fn mvcc_get_by_start_ts(
    &mut self,
    ctx: RpcContext<'_>,
    req: MvccGetByStartTsRequest,
    sink: UnarySink<MvccGetByStartTsResponse>
)

fn raw_get(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawGetRequest,
    sink: UnarySink<RawGetResponse>
)

fn raw_batch_get(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawBatchGetRequest,
    sink: UnarySink<RawBatchGetResponse>
)

fn raw_scan(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawScanRequest,
    sink: UnarySink<RawScanResponse>
)

fn raw_batch_scan(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawBatchScanRequest,
    sink: UnarySink<RawBatchScanResponse>
)

fn raw_put(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawPutRequest,
    sink: UnarySink<RawPutResponse>
)

fn raw_batch_put(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawBatchPutRequest,
    sink: UnarySink<RawBatchPutResponse>
)

fn raw_delete(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawDeleteRequest,
    sink: UnarySink<RawDeleteResponse>
)

fn raw_batch_delete(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawBatchDeleteRequest,
    sink: UnarySink<RawBatchDeleteResponse>
)

fn raw_delete_range(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawDeleteRangeRequest,
    sink: UnarySink<RawDeleteRangeResponse>
)

fn raw_get_key_ttl(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawGetKeyTtlRequest,
    sink: UnarySink<RawGetKeyTtlResponse>
)

fn raw_compare_and_swap(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawCasRequest,
    sink: UnarySink<RawCasResponse>
)

fn kv_import(
    &mut self,
    _: RpcContext<'_>,
    _: ImportRequest,
    _: UnarySink<ImportResponse>
)

fn kv_gc(
    &mut self,
    ctx: RpcContext<'_>,
    _: GcRequest,
    sink: UnarySink<GcResponse>
)

fn coprocessor(
    &mut self,
    ctx: RpcContext<'_>,
    req: Request,
    sink: UnarySink<Response>
)

fn raw_coprocessor(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawCoprocessorRequest,
    sink: UnarySink<RawCoprocessorResponse>
)

fn register_lock_observer(
    &mut self,
    ctx: RpcContext<'_>,
    req: RegisterLockObserverRequest,
    sink: UnarySink<RegisterLockObserverResponse>
)

fn check_lock_observer(
    &mut self,
    ctx: RpcContext<'_>,
    req: CheckLockObserverRequest,
    sink: UnarySink<CheckLockObserverResponse>
)

fn remove_lock_observer(
    &mut self,
    ctx: RpcContext<'_>,
    req: RemoveLockObserverRequest,
    sink: UnarySink<RemoveLockObserverResponse>
)

fn physical_scan_lock(
    &mut self,
    ctx: RpcContext<'_>,
    req: PhysicalScanLockRequest,
    sink: UnarySink<PhysicalScanLockResponse>
)

fn unsafe_destroy_range(
    &mut self,
    ctx: RpcContext<'_>,
    req: UnsafeDestroyRangeRequest,
    sink: UnarySink<UnsafeDestroyRangeResponse>
)

fn coprocessor_stream(
    &mut self,
    ctx: RpcContext<'_>,
    req: Request,
    sink: ServerStreamingSink<Response>
)

fn raft(
    &mut self,
    ctx: RpcContext<'_>,
    stream: RequestStream<RaftMessage>,
    sink: ClientStreamingSink<Done>
)

fn batch_raft(
    &mut self,
    ctx: RpcContext<'_>,
    stream: RequestStream<BatchRaftMessage>,
    sink: ClientStreamingSink<Done>
)

fn snapshot(
    &mut self,
    ctx: RpcContext<'_>,
    stream: RequestStream<SnapshotChunk>,
    sink: ClientStreamingSink<Done>
)

fn split_region(
    &mut self,
    ctx: RpcContext<'_>,
    req: SplitRegionRequest,
    sink: UnarySink<SplitRegionResponse>
)

fn read_index(
    &mut self,
    ctx: RpcContext<'_>,
    req: ReadIndexRequest,
    sink: UnarySink<ReadIndexResponse>
)

fn batch_commands(
    &mut self,
    ctx: RpcContext<'_>,
    stream: RequestStream<BatchCommandsRequest>,
    sink: DuplexSink<BatchCommandsResponse>
)

fn batch_coprocessor(
    &mut self,
    _ctx: RpcContext<'_>,
    _req: BatchRequest,
    _sink: ServerStreamingSink<BatchResponse>
)

fn dispatch_mpp_task(
    &mut self,
    _ctx: RpcContext<'_>,
    _req: DispatchTaskRequest,
    _sink: UnarySink<DispatchTaskResponse>
)

fn cancel_mpp_task(
    &mut self,
    _ctx: RpcContext<'_>,
    _req: CancelTaskRequest,
    _sink: UnarySink<CancelTaskResponse>
)

fn establish_mpp_connection(
    &mut self,
    _ctx: RpcContext<'_>,
    _req: EstablishMppConnectionRequest,
    _sink: ServerStreamingSink<MppDataPacket>
)

fn check_leader(
    &mut self,
    ctx: RpcContext<'_>,
    request: CheckLeaderRequest,
    sink: UnarySink<CheckLeaderResponse>
)

fn get_store_safe_ts(
    &mut self,
    ctx: RpcContext<'_>,
    request: StoreSafeTsRequest,
    sink: UnarySink<StoreSafeTsResponse>
)

fn get_lock_wait_info(
    &mut self,
    ctx: RpcContext<'_>,
    _request: GetLockWaitInfoRequest,
    sink: UnarySink<GetLockWaitInfoResponse>
)