Enum Placement 

pub enum Placement {
    DedicatedCluster {
        cluster: ClusterId,
    },
    DedicatedIndex {
        cluster: ClusterId,
        index: IndexName,
    },
    SharedIndex {
        cluster: ClusterId,
        index: IndexName,
        inject: Vec<InjectedField>,
    },
}

The resolved home of a partition.

The three modes trade isolation against density (docs/03 §3):

• DedicatedCluster: the partition owns a whole cluster (its index name is carried unchanged from the request’s logical index).
• DedicatedIndex: the partition owns a physical index on a shared cluster.
• SharedIndex: many partitions share one physical index; isolation is enforced by injected partition fields (whose names the SPI chose) plus a partition filter on read.

Deliberately not #[non_exhaustive]: the proxy core must interpret every placement mode to route correctly, so adding a mode should force every match in the workspace to be updated rather than silently fall through (docs/03).

Examples

use osproxy_spi::Placement;
use osproxy_spi::core::{ClusterId, IndexName};

let p = Placement::SharedIndex {
    cluster: ClusterId::from("eu-1"),
    index: IndexName::from("shared"),
    inject: vec![],
};
assert_eq!(p.cluster().as_str(), "eu-1");

Variants

DedicatedCluster

The partition has a dedicated cluster.

Fields

cluster: ClusterId

The cluster that exclusively serves this partition.

DedicatedIndex

The partition has a dedicated index on a shared cluster.

Fields

cluster: ClusterId

The hosting cluster.

index: IndexName

The physical index for this partition.

SharedIndex

The partition shares a physical index with others, isolated by the injected fields named here.

Fields

cluster: ClusterId

The hosting cluster.

index: IndexName

The shared physical index.

inject: Vec<InjectedField>

Fields injected on ingest and stripped on read to isolate tenants.

Implementations

impl Placement

pub fn cluster(&self) -> &ClusterId

The cluster this placement resolves to, regardless of mode.

Trait Implementations

impl Clone for Placement

fn clone(&self) -> Placement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Placement

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

Formats the value using the given formatter.

impl Eq for Placement

impl PartialEq for Placement

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Placement