Provider / object-store database
ExperimentalSlateDB
SlateDB runs on object storage. The Rust crate exposes a flat KeyValueStore for KeyValueFs and a single-writer metadata provider for ChunkedFs.
The split provider stores a namespace snapshot, revision, and monotonic lease fence in one SlateDB key. SlateDB fences its database writer on reopen.
Pair SlateDB metadata with independent immutable blocks, such as the RustFS block provider. The key-value role stores file values inside SlateDB itself.
Storage anatomy
Follow one file through both planes.
A mount-rs namespace stores names, attributes, directory entries, layouts, and block references. The bytes stay in the independent block plane. The example below is illustrative; the provider-specific schema, keys, and prefixes are the inspectable contract.
inode 42 · size 8,192NodeMetadata → NodeData::File(FileLayout)BlockId → raw bytesNamespace {
nodes[42] = NodeMetadata {
stats: { ino: 42, size: 8192, mode: regular },
data: File(FileLayout {
chunker: { algorithm: "fixed-size", version: 1, chunk_size: 4096 },
extents: [
{ file_offset: 0, block: "b012...", block_offset: 0, length: 4096 },
{ file_offset: 4096, block: "bfed...", block_offset: 0, length: 4096 }
]
})
}
}
BlockId "b012..." -> [4 KiB raw bytes]
BlockId "bfed..." -> [4 KiB raw bytes]Object storage
SlateDB on RustFS prefix map
SlateDB persists its WAL, SSTs and manifest in the object store; mount-rs stores a namespace record inside SlateDB and file bytes in separate RustFS blocks.
caller-selected RustFS bucket/separate SlateDB and block prefixes/b0123456789abcdef0123456789abcdefbfedcba9876543210fedcba987654321Stores the namespace and the references that make each object part of a file.
Stores only raw bytes at exact keys. LIST shows a prefix; it does not reveal a directory tree.
<slatedb-path>/...database storageSlateDB WAL, SST and manifest objects
mount-rs/metadata/v1logical SlateDB keynamespace, revision and fence
<block-prefix>/...ChunkedFs block storageimmutable file blocks
The SlateDB path and block prefix must be distinct and owned by the same volume. The file name, inode, offsets, and chunk layout are not encoded in the object key; inspect the metadata plane to map them.
Local adapter and reopen tests plus a single-node RustFS release benchmark pass; deployment qualification remains open. The crate tests cover durable key-value reopen and split metadata reopen. The release benchmark runner records raw write, read, and delete samples against pinned RustFS.
Layout and chunking
Use separate object prefixes for the SlateDB database and RustFS blocks. The key-value role maps filesystem keys into SlateDB byte keys.
Durability and consistency
Each adapter write waits for SlateDB's object-store durability handle. The metadata provider supports the exclusive writer path; concurrent MRC2 and delegation remain unsupported.
Across every split-store composition, new blocks are flushed before metadata references are published. A provider acknowledgement is not automatically a power-loss or distributed-locking guarantee.
Inspect a SlateDB-backed volume
// Rust SDK: SlateDB metadata plus RustFS immutable blocks.
options.metadata = StoreConfig::SlateDb { /* endpoint, bucket, path, credentials, durable */ };
options.blocks = StoreConfig::RustFs { /* separate prefix and credentials */ };Credentials, cleanup, and safe operations
Shut down the filesystem and close the SlateDB provider. Remove only the run-owned database and block prefixes when deleting a disposable volume.
Current limits
The key-value filesystem keeps some POSIX attributes in process. The metadata role has one writer, no MRC2 or delegated mode, and no production durability claim from a single-node RustFS benchmark.
Sources: SlateDB provider · RustFS benchmark