Enum Partition 

#[non_exhaustive]
pub enum Partition {
    Namespace(NamespaceKey),
    Coordinator(NamespaceKey),
    Ref {
        ns: NamespaceKey,
        repo: RepoName,
        shard_ref: String,
    },
    RepoIndex {
        ns: NamespaceKey,
        repo: RepoName,
        prefix: u16,
    },
    RefIndex {
        ns: NamespaceKey,
        repo: RepoName,
        bucket: u16,
    },
    ContentShard(u16),
}

A storage partition: one D34 shard. Everything that must commit atomically lives in one partition. The core computes the partition of every operation; a backend maps partitions to whatever it likes (a Durable Object each, rows keyed by partition in SQLite, a qmdb instance each).

Catch-all rule for backends. The enum is #[non_exhaustive]: later work adds kinds. A backend outside this crate never matches on it. It stores and names partitions by Partition::encode, which is stable and injective, so a new kind needs no backend change. Existing encodings never change; a new kind gets a new tag.

Enumeration. A store is never asked to list its partitions (a Durable Object namespace cannot list its instances). Backup and export enumerate them hierarchically, from bounded or constructible structures only; nothing lists every ref shard in one place (one ref per file can mean millions of them):

1. Namespaces (Namespace in single-partition mode, Coordinator under D34) come from deployment configuration and the namespace allowlist. Under namespace_policy = any the deployment keeps a namespace list (reserved key class nl, store::keys); a backend MAY keep it in its own metadata instead.
2. Repos: each coordinator keeps a repo registry, one row per repo of the namespace (reserved key class rr; WP-1.22 lays it out).
3. Repo index shards (RepoIndex, RefIndex) are enumerable by construction: their object-id-prefix and ref-name-hash fan-outs are fixed deployment constants.
4. Ref shards are tracked by the coordinator’s active-shard table; WP-5.3a completes GC enumeration, including deleted-ref and ticket-only shards.
5. Content shards are enumerable by construction (INDEX_FANOUT).

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Namespace(NamespaceKey)

The whole namespace: single-partition mode. Used by M0 (today’s single root Durable Object) and by the ssh / fs-layout path for good; not by D34-sharded deployments.

Coordinator(NamespaceKey)

D34 (M1): the namespace coordinator: config, the grant epoch, the table of currently epoch-leased shards (bounded by active shards) and the repo registry. Rarely written.

Ref

D34 (M1): one per (repo, ref). A branch’s head and packmap share it (shard_ref is the refs/heads/<x> name). Strongly consistent.

Fields

ns: NamespaceKey

Namespace.

repo: RepoName

Repository.

shard_ref: String

The ref whose shard this is.

RepoIndex

D34 (M1): repo membership by object-id prefix over the fixed INDEX_FANOUT (default 4096). Never resharded; eventually consistent.

Fields

ns: NamespaceKey

Namespace.

repo: RepoName

Repository.

prefix: u16

Object-id prefix bucket.

RefIndex

D34 (M1): the ref-name index ListRefs reads, hash-sharded over the fixed REF_INDEX_FANOUT (default 16). Eventually consistent.

Fields

ns: NamespaceKey

Namespace.

repo: RepoName

Repository.

bucket: u16

Ref-name hash bucket.

ContentShard(u16)

A global ContentIndex shard, by object-id prefix over INDEX_FANOUT.

Implementations

impl Partition

pub const fn kind(&self) -> &'static str

Stable, low-cardinality partition kind for metrics and alerts.

pub fn encode(&self) -> Result<Bytes, StoreError>

The portable encoding: one kind tag byte (n namespace, c coordinator, r ref, i repo index, x ref index, s content shard), then each component followed by 0x00. Strings are their UTF-8 bytes; integers are canonical decimal ASCII. Injective, so a backend may use it as an opaque name.

Errors

StoreError::Invalid if a component contains 0x00.

pub fn decode(bytes: &[u8]) -> Result<Self, StoreError>

Decode Partition::encode output.

Errors

StoreError::Corrupt for an unknown tag, a wrong component count, a missing terminator, invalid UTF-8, an invalid repo name or a non-canonical integer.

Trait Implementations

impl Clone for Partition

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Partition

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

Formats the value using the given formatter.

impl Eq for Partition

impl Hash for Partition

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Partition

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Partition

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Partition

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Partition