Struct resolved_ts::advance::AdvanceTsWorker

pub struct AdvanceTsWorker<T, E: KvEngine> {
    store_meta: Arc<Mutex<StoreMeta>>,
    pd_client: Arc<dyn PdClient>,
    timer: SteadyTimer,
    worker: Runtime,
    raft_router: T,
    advance_ts_interval: Duration,
    scheduler: Scheduler<Task<E::Snapshot>>,
    concurrency_manager: ConcurrencyManager,
    hibernate_regions_compatible: bool,
    tikv_clients: Arc<Mutex<HashMap<u64, TikvClient>>>,
    env: Arc<Environment>,
    security_mgr: Arc<SecurityManager>,
}

Fields

store_meta: Arc<Mutex<StoreMeta>>

pd_client: Arc<dyn PdClient>

timer: SteadyTimer

worker: Runtime

raft_router: T

advance_ts_interval: Duration

scheduler: Scheduler<Task<E::Snapshot>>

concurrency_manager: ConcurrencyManager

The concurrency manager for transactions. It’s needed for CDC to check locks when calculating resolved_ts.

hibernate_regions_compatible: bool

tikv_clients: Arc<Mutex<HashMap<u64, TikvClient>>>

env: Arc<Environment>

security_mgr: Arc<SecurityManager>

Implementations

impl<T, E: KvEngine> AdvanceTsWorker<T, E>

pub fn new(
    pd_client: Arc<dyn PdClient>,
    scheduler: Scheduler<Task<E::Snapshot>>,
    raft_router: T,
    store_meta: Arc<Mutex<StoreMeta>>,
    concurrency_manager: ConcurrencyManager,
    env: Arc<Environment>,
    security_mgr: Arc<SecurityManager>,
    advance_ts_interval: Duration,
    hibernate_regions_compatible: bool
) -> Self

impl<T: 'static + RaftStoreRouter<E>, E: KvEngine> AdvanceTsWorker<T, E>

pub fn register_advance_event(&self, regions: Vec<u64>)

async fn region_resolved_ts_raft(
    regions: Vec<u64>,
    raft_router: T,
    min_ts: TimeStamp
) -> Vec<u64>

async fn region_resolved_ts_store(
    regions: Vec<u64>,
    store_meta: Arc<Mutex<StoreMeta>>,
    pd_client: Arc<dyn PdClient>,
    security_mgr: Arc<SecurityManager>,
    env: Arc<Environment>,
    cdc_clients: Arc<Mutex<HashMap<u64, TikvClient>>>,
    min_ts: TimeStamp
) -> Vec<u64>