clockworklabs/SpacetimeDB · error · io::Error

NotFound

NotFound

Error message

segment {offset} does not exist

What it means

open_segment_writer on the in-memory repo found no segment registered under this offset (NotFound). The Memory repo only knows segments that were explicitly created in (or carried over by) its map - there is no filesystem to discover files from.

Source

Thrown at crates/commitlog/src/repo/mem.rs:85

                        io::ErrorKind::AlreadyExists,
                        format!("segment {offset} already exists"),
                    ));
                }
            }
            btree_map::Entry::Vacant(entry) => {
                let storage = entry.insert(Arc::new(RwLock::new(Storage::new())));
                Segment::from_shared(self.space.clone(), storage.clone())
            }
        };
        header.write(&mut segment)?;

        Ok(segment)
    }

    fn open_segment_writer(&self, offset: u64) -> io::Result<Self::SegmentWriter> {
        let inner = self.segments.read().unwrap();
        let Some(buf) = inner.get(&offset) else {
            return Err(io::Error::new(
                io::ErrorKind::NotFound,
                format!("segment {offset} does not exist"),
            ));
        };
        Ok(Segment::from_shared(self.space.clone(), buf.clone()))
    }

    fn open_segment_reader(&self, offset: u64) -> io::Result<Self::SegmentReader> {
        self.open_segment_writer(offset).map(Into::into)
    }

    fn remove_segment(&self, offset: u64) -> io::Result<()> {
        let mut inner = self.segments.write().unwrap();
        if inner.remove(&offset).is_none() {
            return Err(io::Error::new(
                io::ErrorKind::NotFound,
                format!("segment {offset} does not exist"),
            ));

View on GitHub (pinned to 524b4487d9)

Solutions

1. Let the Commitlog create/roll segments itself, or create the segment first via create_segment_writer
2. Use resume_segment_writer when reopening an offset that should exist
3. Derive offsets from existing_segment_offsets() instead of guessing

Example fix

// before
let writer = repo.open_segment_writer(offset)?; // NotFound

// after
let writer = match repo.open_segment_writer(offset) {
    Ok(w) => w,
    Err(e) if e.kind() == io::ErrorKind::NotFound => {
        repo::create_segment_writer(&repo, offset, header)?
    }
    Err(e) => return Err(e),
};

// ask the repo which segments exist before opening one
let known = log.existing_segment_offsets()?;
if !known.contains(&offset) {
    return Err(io::Error::new(io::ErrorKind::NotFound, format!("segment {offset} not present")));
}

fn is_mem_segment_missing(e: &io::Error) -> bool {
    e.kind() == io::ErrorKind::NotFound
        && e.to_string().contains("segment")
        && e.to_string().contains("does not exist")
}

let writer = match repo.open_segment_writer(offset) {
    Ok(w) => w,
    Err(e) if is_mem_segment_missing(&e) => repo::create_segment_writer(&repo, offset, header)?,
    Err(e) => return Err(e),
};

When it happens

Trigger: Opening a writer for an offset that was never created or that remove_segment already removed; deriving offsets by hand (e.g. guessing base offsets) instead of asking the repo which segments exist.

Common situations: Test helpers that assume a segment exists; code ported from the FS repo where the file happened to exist on disk; cleanup code racing writers.

Related errors

• AlreadyExists
• InvalidInput
• AlreadyExists
• InvalidInput
• StorageFull

AI-assisted analysis of clockworklabs/SpacetimeDB@524b4487d9 (2026-08-16). Data as JSON: /api/errors/36945fb1ebfbacd7. Report an issue: GitHub.