Struct ConfBucketType 

pub struct ConfBucketType {
    pub name: String,
    pub read_consistency: String,
    pub write_consistency: String,
    pub n_val: u8,
}

Routing-property bundle attached to a key bucket.

Bucket types let operators give different key classes different SLAs without running multiple pools. Cache-style keys can pin to DC_ONE while transactional keys sit on DC_EACH_SAFE_QUORUM; the same dynomited binary serves both.

n_val caps the replica fan-out for the lifetime of one request: when the topology offers more replicas than n_val, the dispatcher takes the first n_val (the existing rack / DC ordering puts preferred replicas first). A value of 0 means “no cap” and is treated identically to omitting the field.

Examples

use dynomite::conf::{ConfBucketType, ConsistencyLevel};
let bt = ConfBucketType {
    name: "sessions".into(),
    read_consistency: "DC_QUORUM".into(),
    write_consistency: "DC_EACH_SAFE_QUORUM".into(),
    n_val: 3,
};
assert_eq!(bt.name, "sessions");
assert_eq!(
    ConsistencyLevel::parse("read_consistency", &bt.read_consistency).unwrap(),
    ConsistencyLevel::DcQuorum,
);
assert_eq!(bt.n_val, 3);

Fields

name: String

Bucket name. Compared verbatim against the bytes returned by crate::proto::redis::bucket_name; no normalisation is performed. Names must be unique within a pool and must not be empty.

read_consistency: String

Read-side consistency level for keys in this bucket. Stored as a string so the YAML round-trip is human-readable; parsed via ConsistencyLevel::parse during validation.

write_consistency: String

Write-side consistency level for keys in this bucket. See ConfBucketType::read_consistency.

n_val: u8

Replication-factor cap. The dispatcher trims its replica fan-out to at most this many targets. 0 means “no cap”; any positive value caps the fan-out to the leading n_val peers (rack-local first).

Implementations

impl ConfBucketType

pub fn read_level(&self) -> Result<ConsistencyLevel, ConfError>

Parse Self::read_consistency into the typed enum.

Examples

use dynomite::conf::{ConfBucketType, ConsistencyLevel};
let bt = ConfBucketType {
    name: "s".into(),
    read_consistency: "DC_QUORUM".into(),
    write_consistency: "DC_ONE".into(),
    n_val: 0,
};
assert_eq!(bt.read_level().unwrap(), ConsistencyLevel::DcQuorum);

pub fn write_level(&self) -> Result<ConsistencyLevel, ConfError>

Parse Self::write_consistency into the typed enum.

Examples

use dynomite::conf::{ConfBucketType, ConsistencyLevel};
let bt = ConfBucketType {
    name: "s".into(),
    read_consistency: "DC_ONE".into(),
    write_consistency: "DC_SAFE_QUORUM".into(),
    n_val: 0,
};
assert_eq!(bt.write_level().unwrap(), ConsistencyLevel::DcSafeQuorum);

Trait Implementations

impl Clone for ConfBucketType

fn clone(&self) -> ConfBucketType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConfBucketType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ConfBucketType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ConfBucketType

fn eq(&self, other: &ConfBucketType) -> 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 Serialize for ConfBucketType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ConfBucketType

impl StructuralPartialEq for ConfBucketType