Struct CompactionTrack 

pub(super) struct CompactionTrack {
    task_type: TaskType,
    trigger_interval_sec: u64,
    trigger_snapshot_count: usize,
    report_timeout: Duration,
    last_config_refresh_at: Instant,
    pending_commit_count: usize,
    latest_observed_snapshot: Option<IcebergCommittedSnapshot>,
    finish_action: CompactionTrackFinishAction,
    state: CompactionTrackState,
}

Fields

task_type: TaskType

trigger_interval_sec: u64

trigger_snapshot_count: usize

Minimum pending commit threshold to trigger compaction early. Compaction triggers when pending_commit_count >= this threshold, even before interval expires.

report_timeout: Duration

last_config_refresh_at: Instant

pending_commit_count: usize

latest_observed_snapshot: Option<IcebergCommittedSnapshot>

finish_action: CompactionTrackFinishAction

Track lifecycle policy after a selected task finishes. Manual compaction uses RemoveTrack only while automatic compaction is disabled; a later config refresh can turn the temporary track into a normal schedule track.

state: CompactionTrackState

Implementations

impl CompactionTrack

fn new( task_type: TaskType, trigger_interval_sec: u64, trigger_snapshot_count: usize, report_timeout: Duration, now: Instant, ) -> Self

fn should_trigger(&self, now: Instant) -> bool

Determines if compaction should be triggered.

Trigger conditions (OR logic):

1. commit_ready - Pending commit count >= threshold (early trigger)
2. time_ready && has_commits - Interval expired and there’s at least 1 pending commit

This ensures:

• trigger_snapshot_count is an early trigger threshold
• compaction_interval_sec is the maximum wait time (as long as there are new snapshots)
• Force compaction works by setting next_compaction_time to now
• No empty compaction runs (requires at least 1 snapshot for time-based trigger)

fn record_observed_snapshot( &mut self, observed_snapshot: IcebergCommittedSnapshot, )

fn record_commit(&mut self)

fn record_force_compaction( &mut self, now: Instant, forced_task_type: Option<TaskType>, )

fn needs_config_refresh(&self, now: Instant, refresh_interval: Duration) -> bool

fn should_refresh_config( &self, now: Instant, refresh_interval: Duration, ) -> bool

fn mark_config_refreshed(&mut self, now: Instant)

fn current_task_type(&self) -> TaskType

fn start_processing(&mut self) -> TaskType

fn mark_dispatched( &mut self, task_id: IcebergCompactionTaskId, compactor_context_id: HummockContextId, now: Instant, )

pub(super) fn processing_gc_watermark_snapshot( &self, ) -> Option<Option<&IcebergCommittedSnapshot>>

fn is_pending_dispatch(&self) -> bool

fn removes_track_after_finish(&self) -> bool

pub(super) fn is_processing_task( &self, task_id: IcebergCompactionTaskId, ) -> bool

fn scheduled_task(&self) -> Option<ScheduledCompactionTask>

fn is_report_timed_out(&self, now: Instant) -> bool

fn finish_success(&mut self, now: Instant) -> CompactionTrackFinishAction

fn finish_failed(&mut self, now: Instant) -> CompactionTrackFinishAction

fn revert_pre_dispatch_failure( &mut self, now: Instant, ) -> CompactionTrackFinishAction

Re-queue the track as idle after a pre-dispatch failure.

pending_commit_count is intentionally preserved so commits that arrive while the track is pending dispatch are not lost if task dispatch fails before the compactor accepts the task.

next_compaction_time is reset to now (like finish_failed) rather than restored: candidates are dispatched in ascending order of this field, so restoring a stale timestamp would let a repeatedly-failing track sort ahead of every healthy sink and permanently monopolize dispatch slots.

fn update_interval(&mut self, new_interval_sec: u64, now: Instant)

Trait Implementations

impl Clone for CompactionTrack

fn clone(&self) -> CompactionTrack

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompactionTrack

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.