Struct cdc::endpoint::Endpoint

pub struct Endpoint<T> {
    capture_regions: HashMap<u64, Delegate>,
    connections: HashMap<ConnID, Conn>,
    scheduler: Scheduler<Task>,
    raft_router: T,
    observer: CdcObserver,
    pd_client: Arc<dyn PdClient>,
    timer: SteadyTimer,
    min_ts_interval: Duration,
    tso_worker: Runtime,
    store_meta: Arc<Mutex<StoreMeta>>,
    concurrency_manager: ConcurrencyManager,
    workers: Runtime,
    scan_speed_limter: Limiter,
    max_scan_batch_bytes: usize,
    max_scan_batch_size: usize,
    min_resolved_ts: TimeStamp,
    min_ts_region_id: u64,
    old_value_cache: OldValueCache,
    hibernate_regions_compatible: bool,
    resolved_region_count: usize,
    unresolved_region_count: usize,
    tikv_clients: Arc<Mutex<HashMap<u64, TikvClient>>>,
    env: Arc<Environment>,
    security_mgr: Arc<SecurityManager>,
}

Fields

capture_regions: HashMap<u64, Delegate>

connections: HashMap<ConnID, Conn>

scheduler: Scheduler<Task>

raft_router: T

observer: CdcObserver

pd_client: Arc<dyn PdClient>

timer: SteadyTimer

min_ts_interval: Duration

tso_worker: Runtime

store_meta: Arc<Mutex<StoreMeta>>

concurrency_manager: ConcurrencyManager

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

workers: Runtime

scan_speed_limter: Limiter

max_scan_batch_bytes: usize

max_scan_batch_size: usize

min_resolved_ts: TimeStamp

min_ts_region_id: u64

old_value_cache: OldValueCache

hibernate_regions_compatible: bool

resolved_region_count: usize

unresolved_region_count: usize

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

env: Arc<Environment>

security_mgr: Arc<SecurityManager>

Implementations

impl<T: 'static + RaftStoreRouter<RocksEngine>> Endpoint<T>

pub fn new(
    cfg: &CdcConfig,
    pd_client: Arc<dyn PdClient>,
    scheduler: Scheduler<Task>,
    raft_router: T,
    observer: CdcObserver,
    store_meta: Arc<Mutex<StoreMeta>>,
    concurrency_manager: ConcurrencyManager,
    env: Arc<Environment>,
    security_mgr: Arc<SecurityManager>
) -> Endpoint<T>

pub fn set_min_ts_interval(&mut self, dur: Duration)

pub fn set_max_scan_batch_size(&mut self, max_scan_batch_size: usize)

fn on_deregister(&mut self, deregister: Deregister)

pub fn on_register(
    &mut self,
    request: ChangeDataRequest,
    downstream: Downstream,
    conn_id: ConnID,
    version: Version
)

pub fn on_multi_batch(
    &mut self,
    multi: Vec<CmdBatch>,
    old_value_cb: Box<dyn Fn(Key, TimeStamp, &mut OldValueCache) -> (Option<Vec<u8>>, Option<Statistics>) + Send>
)

fn on_region_ready(
    &mut self,
    observe_id: ObserveID,
    resolver: Resolver,
    region: Region
)

fn on_min_ts(&mut self, regions: Vec<u64>, min_ts: TimeStamp)

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

fn broadcast_resolved_ts_compact(
    &self,
    region_id: u64,
    resolved_ts: u64,
    conn: &Conn
)

fn register_min_ts_event(&self)

async fn region_resolved_ts_raft(
    regions: Vec<(u64, ObserveID)>,
    scheduler: &Scheduler<Task>,
    raft_router: T,
    min_ts: TimeStamp
) -> Vec<u64>

async fn region_resolved_ts_store(
    regions: Vec<(u64, ObserveID)>,
    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>

fn on_open_conn(&mut self, conn: Conn)

Trait Implementations

impl<T: 'static + RaftStoreRouter<RocksEngine>> Runnable for Endpoint<T>

type Task = Task

fn run(&mut self, task: Task)

Runs a task.

pub fn on_tick(&mut self)

pub fn shutdown(&mut self)

impl<T: 'static + RaftStoreRouter<RocksEngine>> RunnableWithTimer for Endpoint<T>

fn on_timeout(&mut self)

fn get_interval(&self) -> Duration