Struct fluvio::config::Config

pub struct Config {
    pub profile: HashMap<String, Profile>,
    pub cluster: HashMap<String, FluvioConfig>,
    /* private fields */
}

Fields

profile: HashMap<String, Profile>

cluster: HashMap<String, FluvioConfig>

Implementations

impl Config

pub fn new() -> Self

pub fn new_with_local_cluster(domain: String) -> Self

create new config with a single local cluster

pub fn add_cluster(&mut self, cluster: FluvioConfig, name: String)

add new cluster

pub fn add_profile(&mut self, profile: Profile, name: String)

pub fn version(&self) -> &str

pub fn current_profile_name(&self) -> Option<&str>

current profile

pub fn set_current_profile(&mut self, profile_name: &str) -> bool

set current profile, if profile doesn’t exists return false

pub fn rename_profile(&mut self, from: &str, to: String) -> bool

pub fn delete_profile(&mut self, profile_name: &str) -> bool

delete profile

pub fn delete_cluster(&mut self, cluster_name: &str) -> Option<FluvioConfig>

Deletes the named cluster, whether it is being used or not.

You may want to check if the named cluster is active or not using delete_cluster_check. Otherwise, you may remove a cluster that is being used by the active profile.

Example

let mut config = Config::new();
let cluster = FluvioConfig::new("https://cloud.fluvio.io".to_string());
config.add_cluster(cluster, "fluvio-cloud".to_string());
let profile = Profile::new("fluvio-cloud".to_string());
config.add_profile(profile, "fluvio-cloud".to_string());

config.delete_cluster("fluvio-cloud").unwrap();
assert!(config.cluster("fluvio-cloud").is_none());

pub fn delete_cluster_check( &mut self, cluster_name: &str ) -> Result<(), Vec<&str>>

Checks whether it’s safe to delete the named cluster

If there are any profiles that reference the named cluster, they are considered conflicts and the cluster is unsafe to delete. When conflicts exist, the conflicting profile names are returned in the Err() return value.

If there are no profile conflicts, this returns with Ok(()).

Example

let mut config = Config::new();
let cluster = FluvioConfig::new("https://cloud.fluvio.io".to_string());
config.add_cluster(cluster, "fluvio-cloud".to_string());
let profile = Profile::new("fluvio-cloud".to_string());
config.add_profile(profile, "fluvio-cloud".to_string());

let conflicts = config.delete_cluster_check("fluvio-cloud").unwrap_err();
assert_eq!(conflicts, vec!["fluvio-cloud"]);

pub fn current_profile(&self) -> Result<&Profile, FluvioError>

Returns a reference to the current Profile if there is one.

pub fn profile(&self, profile_name: &str) -> Option<&Profile>

Returns a reference to the current Profile if there is one.

pub fn profile_mut(&mut self, profile_name: &str) -> Option<&mut Profile>

Returns a mutable reference to the current Profile if there is one.

pub fn current_cluster(&self) -> Result<&FluvioConfig, FluvioError>

Returns the FluvioConfig belonging to the current profile.

pub fn current_cluster_mut(&mut self) -> Result<&mut FluvioConfig, FluvioError>

Returns the mutable reference to FluvioConfig belonging to the current profile.

pub fn cluster_with_profile(&self, profile_name: &str) -> Option<&FluvioConfig>

Returns the FluvioConfig belonging to the named profile.

pub fn cluster(&self, cluster_name: &str) -> Option<&FluvioConfig>

Returns a reference to the named FluvioConfig.

pub fn cluster_mut(&mut self, cluster_name: &str) -> Option<&mut FluvioConfig>

Returns a mutable reference to the named FluvioConfig.

pub fn resolve_replica_config( &self, _topic_name: &str, _partition: i32 ) -> Replica

look up replica config this will iterate and find all configuration that can resolve config

1. match all config that matches criteria including asterisk
2. apply in terms of precedent

Trait Implementations

impl Debug for Config

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

Formats the value using the given formatter.

impl Default for Config

fn default() -> Config

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Config

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Config

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

where __S: Serializer,

Serialize this value into the given Serde serializer.