Struct forest_actor::miner::ExpirationQueue

pub struct ExpirationQueue<'db, BS> {
    pub amt: Amt<'db, ExpirationSet, BS>,
    pub quant: QuantSpec,
}

A queue of expiration sets by epoch, representing the on-time or early termination epoch for a collection of sectors. Wraps an AMTChainEpoch*ExpirationSet. Keys in the queue are quantized (upwards), modulo some offset, to reduce the cardinality of keys.

Fields

amt: Amt<'db, ExpirationSet, BS>

quant: QuantSpec

Implementations

impl<'db, BS: BlockStore> ExpirationQueue<'db, BS>

pub fn new(
    store: &'db BS,
    root: &Cid,
    quant: QuantSpec
) -> Result<Self, AmtError>

Loads a queue root.

Epochs provided to subsequent method calls will be quantized upwards to quanta mod offsetSeed before being written to/read from queue entries.

pub fn add_active_sectors<'a>(
    &mut self,
    sectors: impl IntoIterator<Item = &'a SectorOnChainInfo>,
    sector_size: SectorSize
) -> Result<(BitField, PowerPair, TokenAmount), Box<dyn StdError>>

Adds a collection of sectors to their on-time target expiration entries (quantized). The sectors are assumed to be active (non-faulty). Returns the sector numbers, power, and pledge added.

pub fn reschedule_expirations(
    &mut self,
    new_expiration: ChainEpoch,
    sectors: &[SectorOnChainInfo],
    sector_size: SectorSize
) -> Result<(), Box<dyn StdError>>

Reschedules some sectors to a new (quantized) expiration epoch. The sectors being rescheduled are assumed to be not faulty, and hence are removed from and re-scheduled for on-time rather than early expiration. The sectors’ power and pledge are assumed not to change, despite the new expiration.

pub fn reschedule_as_faults(
    &mut self,
    new_expiration: ChainEpoch,
    sectors: &[SectorOnChainInfo],
    sector_size: SectorSize
) -> Result<PowerPair, Box<dyn StdError>>

Re-schedules sectors to expire at an early expiration epoch (quantized), if they wouldn’t expire before then anyway. The sectors must not be currently faulty, so must be registered as expiring on-time rather than early. The pledge for the now-early sectors is removed from the queue. Returns the total power represented by the sectors.

pub fn reschedule_all_as_faults(
    &mut self,
    fault_expiration: ChainEpoch
) -> Result<(), Box<dyn StdError>>

Re-schedules all sectors to expire at an early expiration epoch, if they wouldn’t expire before then anyway.

pub fn reschedule_recovered(
    &mut self,
    sectors: Vec<SectorOnChainInfo>,
    sector_size: SectorSize
) -> Result<PowerPair, Box<dyn StdError>>

Removes sectors from any queue entries in which they appear that are earlier then their scheduled expiration epoch, and schedules them at their expected termination epoch. Pledge for the sectors is re-added as on-time. Power for the sectors is changed from faulty to active (whether rescheduled or not). Returns the newly-recovered power. Fails if any sectors are not found in the queue.

pub fn replace_sectors(
    &mut self,
    old_sectors: &[SectorOnChainInfo],
    new_sectors: &[SectorOnChainInfo],
    sector_size: SectorSize
) -> Result<(BitField, BitField, PowerPair, TokenAmount), Box<dyn StdError>>

Removes some sectors and adds some others. The sectors being replaced must not be faulty, so must be scheduled for on-time rather than early expiration. The sectors added are assumed to be not faulty. Returns the old a new sector number bitfields, and delta to power and pledge, new minus old.

pub fn remove_sectors(
    &mut self,
    sectors: &[SectorOnChainInfo],
    faults: &BitField,
    recovering: &BitField,
    sector_size: SectorSize
) -> Result<(ExpirationSet, PowerPair), Box<dyn StdError>>

Remove some sectors from the queue. The sectors may be active or faulty, and scheduled either for on-time or early termination. Returns the aggregate of removed sectors and power, and recovering power. Fails if any sectors are not found in the queue.

pub fn pop_until(
    &mut self,
    until: ChainEpoch
) -> Result<ExpirationSet, Box<dyn StdError>>

Removes and aggregates entries from the queue up to and including some epoch.