Struct SegmentsManifest 

pub struct SegmentsManifest { /* private fields */ }

Contents of segments_manifest.json: a flat map of segment UUID to its state, e.g. { "1b4e28ba-...": "active", "6ba7b810-...": "active" }.

Consistency assumptions (important for readers)

The manifest is not an exact, instantaneous snapshot of the on-disk segment set. To guarantee that no data is ever lost across the non-atomic create/delete transitions, it deliberately errs on the side of listing more segments than strictly necessary:

• May list a segment that is not yet fully created. A new segment is registered here as soon as it exists on disk — potentially before its version file is written (i.e. before it is finalized). This guarantees a real, writable segment is never missing from the manifest. A reader must therefore tolerate a listed segment that is incomplete / not yet loadable and skip it (a segment without a saved version is not ready to read).
• May list a segment that has already been (or is about to be) deleted. Removal from the manifest is intentionally not strict: a superseded segment may linger in the manifest after its data has been dropped, or be dropped from disk slightly after it leaves the manifest. A reader must tolerate a listed segment that no longer exists on disk and skip it.

In other words: the manifest is a superset-biased view. Over-listing (duplicate/extra segments) is always safe and is resolved by point versioning during reads; under-listing a live segment is the only thing that would lose data, and the writer ordering prevents it. Readers must handle both of the above cases gracefully rather than assuming every listed segment is present and ready.

Implementations

impl SegmentsManifest

pub fn from_segment_holder(holder: &SegmentHolder) -> Self

Build a manifest from the current live segments in the holder, marking every segment Active.

Includes segments temporarily wrapped as proxies during optimization — they are still live.

pub fn set( &mut self, uuid: Uuid, state: SegmentManifestState, ) -> Option<SegmentManifestState>

Set uuid’s state, returning the previous one.

pub fn remove(&mut self, uuid: &Uuid) -> Option<SegmentManifestState>

Remove uuid’s entry, returning its state.

pub fn preserving(self, previous: &SegmentsManifest) -> Self

Merge rule for persisting a rebuild: a rebuild from the segment holder marks every live segment Active, which would erase an out-of-process optimizer’s marks. Re-apply previous’s optimizer marks (Optimizing/Retiring) to segments this manifest still lists; marks for segments gone from the holder drop with them. Staleness is governed by the lease, not by rebuilds.

pub fn sync( manifest: Option<&Arc<SaveOnDisk<SegmentsManifest>>>, holder: &SegmentHolder, extra_segment: Option<Uuid>, ) -> OperationResult<()>

Rebuild the manifest from holder and persist it if it changed.

No-op when manifest is None (the write_segment_manifest flag is off). Errors propagate so callers that gate destructive work (e.g. deleting superseded segments) on a fresh manifest can abort instead of risking a stale manifest.

Idempotent and cheap: it only writes when the live segment set differs from what is persisted, so it is safe to call on every relevant segment-set transition. Usually invoked via [SegmentHolder::sync_segment_manifest], which owns the manifest.

pub fn get(&self, uuid: &Uuid) -> Option<SegmentManifestState>

pub fn iter(&self) -> impl Iterator<Item = (&Uuid, &SegmentManifestState)>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

Trait Implementations

impl Clone for SegmentsManifest

fn clone(&self) -> SegmentsManifest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SegmentsManifest

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

Formats the value using the given formatter.

impl Default for SegmentsManifest

fn default() -> SegmentsManifest

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SegmentsManifest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SegmentsManifest

impl FromIterator<(Uuid, SegmentManifestState)> for SegmentsManifest

fn from_iter<I: IntoIterator<Item = (Uuid, SegmentManifestState)>>( iter: I, ) -> Self

Creates a value from an iterator.

impl PartialEq for SegmentsManifest

fn eq(&self, other: &SegmentsManifest) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for SegmentsManifest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SegmentsManifest