Struct CompactionTrack 

pub(super) struct CompactionTrack {
    configured_task_type: TaskType,
    write_mode: IcebergWriteMode,
    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>,
    round_max_file_sequence_number: Option<i64>,
    finish_action: CompactionTrackFinishAction,
    state: CompactionTrackState,
}

Fields

configured_task_type: TaskType

Configured task type for the next automatic attempt.

write_mode: IcebergWriteMode

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>

round_max_file_sequence_number: Option<i64>

Inclusive file sequence number boundary for the current automatic compaction round.

finish_action: CompactionTrackFinishAction

Track lifecycle policy after the queued task or active attempt finishes. Disabling automatic compaction lets an existing task finish before removing its track; re-enabling can restore KeepTrack.

state: CompactionTrackState

Implementations

impl CompactionTrack

fn new( configured_task_type: TaskType, write_mode: IcebergWriteMode, 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:

• An active automatic round is controlled only by its next-attempt time.
• Otherwise, pending commit threshold or an interval with pending commits can trigger a task.

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 legacy empty compaction runs (an active automatic round is intentionally retryable)

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 mark_config_refreshed(&mut self, now: Instant)

fn effective_task_type(&self) -> TaskType

fn start_attempt(&mut self) -> Arc<CompactionAttempt>

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

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

fn is_pending_dispatch(&self) -> bool

fn removes_track_after_finish(&self) -> bool

fn has_queued_task_or_active_attempt(&self) -> bool

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

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

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

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 starts a short retry backoff rather than restoring its previous timestamp. 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 monopolize dispatch slots.

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

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

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

Completes a sequence-bounded round while preserving commits that arrived after its fixed boundary for the next round.

fn is_in_flight_bounded_attempt(&self) -> bool

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.