Struct CompactionTrack 

pub(super) struct CompactionTrack {
    config: CompactionScheduleConfig,
    pub(super) registration: Option<Arc<IcebergPkIndexSinkRegistration>>,
    demand: CompactionDemand,
    round: Option<CompactionRound>,
    retry: CompactionRetry,
    latest_observed_snapshot: Option<IcebergCommittedSnapshot>,
    next_check_not_before: Option<Instant>,
    finish_action: CompactionTrackFinishAction,
    state: CompactionTrackState,
    health: CompactionHealth,
}

Fields

config: CompactionScheduleConfig

registration: Option<Arc<IcebergPkIndexSinkRegistration>>

demand: CompactionDemand

round: Option<CompactionRound>

retry: CompactionRetry

latest_observed_snapshot: Option<IcebergCommittedSnapshot>

next_check_not_before: Option<Instant>

Minimum interval between new PK-index rounds, not between continuations.

finish_action: CompactionTrackFinishAction

Legacy temporary/disabled tracks are removed after their task finishes.

state: CompactionTrackState

health: CompactionHealth

Implementations

impl CompactionTrack

fn new(config: CompactionScheduleConfig, now: Instant) -> Self

pub(super) fn source_is_ready(&self) -> bool

pub(super) fn pk_index_registration( &self, ) -> Option<&Arc<IcebergPkIndexSinkRegistration>>

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

Determines if compaction should be triggered.

Trigger conditions:

• An active automatic round follows its next-attempt time. PK-index batches can also continue without new commits or trigger early at the commit threshold.
• Otherwise, pending commit threshold or an interval with pending commits can trigger a task.

This ensures:

• The configured commit threshold is an early trigger
• The configured interval is the maximum dirty wait
• 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, ) -> bool

fn record_commit_at(&mut self, now: Instant)

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 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, error: String, ) -> CompactionTrackFinishAction

fn finish_blocked( &mut self, reason: IcebergReportTaskStatus, 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 demand 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 end_disabled_round(&mut self)

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

Completes a sequence-bounded round while preserving commits that arrived after the last attempt’s boundary for subsequent work.

fn compaction_lag(&self) -> Option<Duration>

fn round_boundary(&self) -> Option<i64>

fn is_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.