Struct cdc::delegate::Delegate

pub struct Delegate {
    pub handle: ObserveHandle,
    pub region_id: u64,
    region: Option<Region>,
    pub downstreams: Vec<Downstream>,
    pub resolver: Option<Resolver>,
    pending: Option<Pending>,
    failed: bool,
    pub txn_extra_op: TxnExtraOp,
}

A CDC delegate of a raftstore region peer.

It converts raft commands into CDC events and broadcast to downstreams. It also track trancation on the fly in order to compute resolved ts.

Fields

handle: ObserveHandle

region_id: u64

region: Option<Region>

downstreams: Vec<Downstream>

resolver: Option<Resolver>

pending: Option<Pending>

failed: bool

txn_extra_op: TxnExtraOp

Implementations

impl Delegate

pub fn new(region_id: u64) -> Delegate

Create a Delegate the given region.

pub fn subscribe(&mut self, downstream: Downstream) -> bool

Return false if subscribe failed.

pub fn downstream(&self, downstream_id: DownstreamID) -> Option<&Downstream>

pub fn downstreams(&self) -> &Vec<Downstream>

pub fn downstreams_mut(&mut self) -> &mut Vec<Downstream>

pub fn unsubscribe(&mut self, id: DownstreamID, err: Option<Error>) -> bool

fn error_event(&self, err: Error) -> EventError

pub fn mark_failed(&mut self)

pub fn has_failed(&self) -> bool

pub fn stop(&mut self, err: Error)

Stop the delegate

This means the region has met an unrecoverable error for CDC. It broadcasts errors to all downstream and stops.

fn broadcast<F>(&self, send: F) -> Result<()> where
    F: Fn(&Downstream) -> Result<()>, 

pub fn on_region_ready(
    &mut self,
    resolver: Resolver,
    region: Region
) -> Vec<Downstream>

Install a resolver and return pending downstreams.

pub fn on_min_ts(&mut self, min_ts: TimeStamp) -> Option<TimeStamp>

Try advance and broadcast resolved ts.

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

pub(crate) fn convert_to_grpc_events(
    region_id: u64,
    request_id: u64,
    entries: Vec<Option<TxnEntry>>
) -> Vec<CdcEvent>

fn sink_data(
    &mut self,
    index: u64,
    requests: Vec<Request>,
    old_value_cb: &Box<dyn Fn(Key, TimeStamp, &mut OldValueCache) -> (Option<Vec<u8>>, Option<Statistics>) + Send>,
    old_value_cache: &mut OldValueCache,
    is_one_pc: bool
) -> Result<()>

fn sink_put(
    &mut self,
    put: PutRequest,
    is_one_pc: bool,
    rows: &mut HashMap<Vec<u8>, EventRow>,
    read_old_value: impl FnMut(&mut EventRow, TimeStamp)
)

fn sink_delete(&mut self, delete: DeleteRequest)

fn sink_admin(
    &mut self,
    request: AdminRequest,
    response: AdminResponse
) -> Result<()>