Struct GlobalRefreshManager 

pub struct GlobalRefreshManager {
    metadata_manager: MetadataManager,
    barrier_scheduler: BarrierScheduler,
    scale_controller: ScaleControllerRef,
    cycles: Mutex<Cycles>,
    scheduler_wakeup: Notify,
}

Owns the refresh cycles. The refresh_job row is the source of truth: a cycle is its last_trigger_time, and both transitions are the post-collect of a barrier (RefreshStart moves the job to Refreshing, FinishRefresh back to Idle). A recovery kills every cycle of the databases it re-initializes and moves their rows back to Idle before those databases accept commands again (abandon_cycles), so nothing has to infer an abandoned cycle afterwards. The in-memory tracker of a cycle is installed by the same barrier that started it, before the row moves.

Fields

metadata_manager: MetadataManager

barrier_scheduler: BarrierScheduler

scale_controller: ScaleControllerRef

cycles: Mutex<Cycles>

scheduler_wakeup: Notify

Implementations

impl GlobalRefreshManager

pub async fn start( metadata_manager: MetadataManager, barrier_scheduler: BarrierScheduler, scale_controller: ScaleControllerRef, scheduler_interval: Duration, ) -> MetaResult<(GlobalRefreshManagerRef, JoinHandle<()>, Sender<()>)>

pub async fn trigger_manual_refresh( self: &Arc<Self>, request: RefreshRequest, ) -> MetaResult<RefreshResponse>

Returns once the RefreshStart barrier of the cycle is collected.

async fn trigger_cycle( self: &Arc<Self>, table_id: TableId, associated_source_id: Option<SourceId>, reason: TriggerReason, ) -> MetaResult<()>

The cycle is started by a spawned task, so a caller that goes away does not release the reschedule guard before the RefreshStart barrier is collected.

async fn start_cycle( &self, table_id: TableId, associated_source_id: Option<SourceId>, reason: TriggerReason, ) -> MetaResult<()>

pub async fn cycle_started( &self, table_id: TableId, database_id: DatabaseId, associated_source_id: SourceId, staging_table_id: TableId, trigger_time: NaiveDateTime, actors: RefreshCycleActors, ) -> MetaResult<()>

Post-collect of the RefreshStart barrier.

pub fn report_stage( &self, table_id: TableId, stage: RefreshStage, actors: HashSet<ActorId>, ) -> MetaResult<()>

Schedules the next stage once every actor of the stage reported; an unexpected reporter fails the barrier, which abandons the cycle through a recovery.

pub async fn complete_refresh( &self, table_id: TableId, trigger_time: NaiveDateTime, ) -> MetaResult<()>

Post-collect of the FinishRefresh barrier.

pub async fn abandon_cycles( &self, database_id: Option<DatabaseId>, ) -> MetaResult<()>

Called while a recovery re-initializes the database(s), before they accept commands again: every cycle of theirs is dead, so its row moves back to Idle here and it is re-run once.

pub fn remove_progress_tracker(&self, table_id: TableId, status: &str)

Called when the table is dropped; status labels the metrics of an interrupted cycle.

pub fn notify_scheduler(&self)

async fn run_scheduler( self: Arc<Self>, shutdown_rx: Receiver<()>, scheduler_interval: Duration, )

async fn tick(self: &Arc<Self>)

async fn created_at_millis( &self, table_ids: &[TableId], ) -> MetaResult<HashMap<TableId, i64>>