Struct MultiCloudMultiRegionConfiguration 

pub struct MultiCloudMultiRegionConfiguration<R: Clone + Debug, T: Clone + Debug> {
    pub preferred: RegionName,
    pub regions: Vec<ProviderRegion<R>>,
    pub topologies: Vec<Topology<T>>,
}

Configuration for multi-cloud, multi-region deployments.

This type validates its invariants both during construction via new and during deserialization. Invalid configurations will fail with a ValidationError.

The type has two generic parameters:

• R: The type of per-region configuration data stored in ProviderRegion.
• T: The type of per-topology configuration data stored in Topology.

Example

use chroma_types::{
    MultiCloudMultiRegionConfiguration, ProviderRegion, Topology,
    RegionName, TopologyName,
};

let config = MultiCloudMultiRegionConfiguration::<(), ()>::new(
    RegionName::new("aws-us-east-1").unwrap(),
    vec![ProviderRegion::new(
        RegionName::new("aws-us-east-1").unwrap(),
        "aws",
        "us-east-1",
        (),
    )],
    vec![],
).expect("valid configuration");

assert_eq!(config.preferred().as_str(), "aws-us-east-1");

Fields

preferred: RegionName

The name of the preferred region for operations with region affinity.

regions: Vec<ProviderRegion<R>>

The set of provider regions available in this configuration.

topologies: Vec<Topology<T>>

The set of topologies defined over the provider regions.

Implementations

impl<R: Clone + Debug, T: Clone + Debug> MultiCloudMultiRegionConfiguration<R, T>

pub fn preferred_region(&self) -> Option<&ProviderRegion<R>>

Returns the preferred region, if found.

pub fn lookup_region(&self, name: &RegionName) -> Option<ProviderRegion<R>>

Returns the named region or None if nothing.

pub fn lookup_topology( &self, name: &TopologyName, ) -> Option<(Vec<ProviderRegion<R>>, Topology<T>)>

Returns the regions for a configured topology or None if it doesn’t exist or references a non-existent region.

impl<R: Clone + Debug, T: Clone + Debug> MultiCloudMultiRegionConfiguration<R, T>

pub fn new( preferred: RegionName, regions: Vec<ProviderRegion<R>>, topologies: Vec<Topology<T>>, ) -> Result<Self, ValidationError>

Creates and validates a new multi-cloud, multi-region configuration.

Returns an error if validation fails.

Example

use chroma_types::{
    MultiCloudMultiRegionConfiguration, ProviderRegion, Topology,
    RegionName, TopologyName,
};

// Valid configuration
let config = MultiCloudMultiRegionConfiguration::new(
    RegionName::new("aws-us-east-1").unwrap(),
    vec![ProviderRegion::new(
        RegionName::new("aws-us-east-1").unwrap(),
        "aws",
        "us-east-1",
        (),
    )],
    vec![Topology::new(
        TopologyName::new("default").unwrap(),
        vec![RegionName::new("aws-us-east-1").unwrap()],
        (),
    )],
);
assert!(config.is_ok());

// Invalid configuration - preferred region doesn't exist
let config = MultiCloudMultiRegionConfiguration::<(), ()>::new(
    RegionName::new("nonexistent").unwrap(),
    vec![ProviderRegion::new(
        RegionName::new("aws-us-east-1").unwrap(),
        "aws",
        "us-east-1",
        (),
    )],
    vec![],
);
assert!(config.is_err());

pub fn preferred(&self) -> &RegionName

Returns the preferred region for operations with region affinity.

pub fn regions(&self) -> &[ProviderRegion<R>]

Returns the set of provider regions available in this configuration.

pub fn topologies(&self) -> &[Topology<T>]

Returns the set of topologies defined over the provider regions.

pub fn validate(&self) -> Result<(), ValidationError>

Validates the configuration against the invariants.

Returns Ok(()) if validation passes, or a ValidationError describing any violations. Each unique error is reported only once, even if it occurs multiple times.

pub fn preferred_region_config(&self) -> Option<&R>

Returns the configuration for the preferred region, if found.

Since the configuration validates that the preferred region exists during construction, this method returns Some for valid configurations. It returns None only if the internal state is inconsistent, which should not occur with properly constructed instances.

Example

use chroma_types::{
    MultiCloudMultiRegionConfiguration, ProviderRegion, RegionName,
};

let config = MultiCloudMultiRegionConfiguration::<String, ()>::new(
    RegionName::new("aws-us-east-1").unwrap(),
    vec![ProviderRegion::new(
        RegionName::new("aws-us-east-1").unwrap(),
        "aws",
        "us-east-1",
        "custom-config".to_string(),
    )],
    vec![],
).expect("valid configuration");

assert_eq!(config.preferred_region_config(), Some(&"custom-config".to_string()));

pub fn cast<R2, T2, FR, FT>( self, region_fn: FR, topology_fn: FT, ) -> MultiCloudMultiRegionConfiguration<R2, T2>

where R2: Clone + Debug, T2: Clone + Debug, FR: Fn(R) -> R2, FT: Fn(T) -> T2,

Transforms this configuration into a new type by applying functions to the region and topology configs.

This method consumes the configuration and produces a new one with different generic type parameters. The transformation functions are applied to each region config and topology config respectively.

Example

use chroma_types::{
    MultiCloudMultiRegionConfiguration, ProviderRegion, Topology,
    RegionName, TopologyName,
};

let config = MultiCloudMultiRegionConfiguration::<i32, &str>::new(
    RegionName::new("aws-us-east-1").unwrap(),
    vec![ProviderRegion::new(
        RegionName::new("aws-us-east-1").unwrap(),
        "aws",
        "us-east-1",
        42,
    )],
    vec![Topology::new(
        TopologyName::new("default").unwrap(),
        vec![RegionName::new("aws-us-east-1").unwrap()],
        "topology-config",
    )],
).expect("valid configuration");

let transformed = config.cast(
    |r| r.to_string(),
    |t| t.len(),
);

assert_eq!(transformed.preferred_region_config(), Some(&"42".to_string()));
assert_eq!(transformed.topologies()[0].config(), &15);

pub fn try_cast<R2, T2, E, FR, FT>( self, region_fn: FR, topology_fn: FT, ) -> Result<MultiCloudMultiRegionConfiguration<R2, T2>, E>

where R2: Clone + Debug, T2: Clone + Debug, FR: Fn(R) -> Result<R2, E>, FT: Fn(T) -> Result<T2, E>,

Transforms this configuration into a new type by applying fallible functions to the region and topology configs.

This method consumes the configuration and produces a new one with different generic type parameters. The transformation functions are applied to each region config and topology config respectively. If any transformation fails, the error is returned immediately.

Errors

Returns an error if any region or topology transformation function returns an error.

Example

use chroma_types::{
    MultiCloudMultiRegionConfiguration, ProviderRegion, Topology,
    RegionName, TopologyName,
};

let config = MultiCloudMultiRegionConfiguration::<&str, i32>::new(
    RegionName::new("aws-us-east-1").unwrap(),
    vec![ProviderRegion::new(
        RegionName::new("aws-us-east-1").unwrap(),
        "aws",
        "us-east-1",
        "42",
    )],
    vec![Topology::new(
        TopologyName::new("default").unwrap(),
        vec![RegionName::new("aws-us-east-1").unwrap()],
        100,
    )],
).expect("valid configuration");

let result: Result<_, std::num::ParseIntError> = config.try_cast(
    |r| r.parse::<i32>(),
    |t| Ok(t.to_string()),
);

let transformed = result.expect("transformation should succeed");
assert_eq!(transformed.preferred_region_config(), Some(&42));
assert_eq!(transformed.topologies()[0].config(), "100");

pub async fn try_cast_async<R2, T2, E, FR, FT, FUT1, FUT2>( self, region_fn: FR, topology_fn: FT, ) -> Result<MultiCloudMultiRegionConfiguration<R2, T2>, E>

where R2: Clone + Debug, T2: Clone + Debug, FR: Fn(R) -> FUT1, FT: Fn(T) -> FUT2, FUT1: Future<Output = Result<R2, E>> + Send, FUT2: Future<Output = Result<T2, E>> + Send,

Transforms this configuration into a new type by applying async fallible functions to the region and topology configs.

Errors

Returns an error if any region or topology transformation function returns an error.

Trait Implementations

impl<R: Clone + Clone + Debug, T: Clone + Clone + Debug> Clone for MultiCloudMultiRegionConfiguration<R, T>

fn clone(&self) -> MultiCloudMultiRegionConfiguration<R, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug + Clone + Debug, T: Debug + Clone + Debug> Debug for MultiCloudMultiRegionConfiguration<R, T>

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

Formats the value using the given formatter.

impl<'de, R: Clone + Debug + Serialize + DeserializeOwned, T: Clone + Debug + Serialize + DeserializeOwned> Deserialize<'de> for MultiCloudMultiRegionConfiguration<R, T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R: PartialEq + Clone + Debug, T: PartialEq + Clone + Debug> PartialEq for MultiCloudMultiRegionConfiguration<R, T>

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

where R: Clone + Debug + Serialize, T: Clone + Debug + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<R: Eq + Clone + Debug, T: Eq + Clone + Debug> Eq for MultiCloudMultiRegionConfiguration<R, T>

impl<R: Clone + Debug, T: Clone + Debug> StructuralPartialEq for MultiCloudMultiRegionConfiguration<R, T>