Provider / object-store database

Experimental

SlateDB

SlateDB runs on object storage. The Rust crate exposes a flat KeyValueStore for KeyValueFs and a single-writer metadata provider for ChunkedFs.

Metadata

The split provider stores a namespace snapshot, revision, and monotonic lease fence in one SlateDB key. SlateDB fences its database writer on reopen.

Immutable blocks

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.

Logical file/docs/readme.mdinode 42 · size 8,192NodeMetadata → NodeData::File(FileLayout)
blocksIndependent RustFS prefixBlockId → raw bytes
Illustrative Namespace / FileLayout record (shape, not serialized bytes)
Namespace {
  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

block-only bucket

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.

Bucketcaller-selected RustFS bucket
caller-selected RustFS bucket/
└─separate SlateDB and block prefixes/
├─b0123456789abcdef0123456789abcdef
└─bfedcba9876543210fedcba987654321
SlateDB database path

Stores the namespace and the references that make each object part of a file.

blocksIndependent RustFS prefix

Stores only raw bytes at exact keys. LIST shows a prefix; it does not reveal a directory tree.

<slatedb-path>/...database storage

SlateDB WAL, SST and manifest objects

mount-rs/metadata/v1logical SlateDB key

namespace, revision and fence

<block-prefix>/...ChunkedFs block storage

immutable file blocks

What the key does not tell you

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.

Experimental — scoped evidence

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

Read-only inspection example
// 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.

← Back to providers