use std::{
collections::HashMap,
fmt::Debug,
hash::{BuildHasher, Hash},
};
use crate::{ConsistentRing, RingConfig, RingError, TokenRangeMigration};
#[derive(Clone)]
pub struct ClusterManager<T, BH: BuildHasher> {
nodes: HashMap<String, (T, usize)>,
ring: ConsistentRing<T, BH>,
}
impl<T: Clone + PartialEq + Debug, BH: BuildHasher + Clone> ClusterManager<T, BH> {
pub fn try_new(config: RingConfig<BH>) -> Result<Self, RingError> {
Ok(Self {
nodes: HashMap::new(),
ring: ConsistentRing::try_new(config)?,
})
}
pub fn nodes(&self) -> &HashMap<String, (T, usize)> {
&self.nodes
}
pub fn ring(&self) -> &ConsistentRing<T, BH> {
&self.ring
}
pub fn add_node(
&mut self,
node: T,
identifier: &str,
replica_multiplier: usize,
) -> Result<(), RingError> {
if self.nodes.contains_key(identifier) {
return Err(RingError::NodeAlreadyExists(identifier.to_owned()));
}
self.ring
.add_node(node.clone(), identifier, replica_multiplier)?;
self.nodes
.insert(identifier.to_owned(), (node, replica_multiplier));
Ok(())
}
pub fn remove_node(&mut self, identifier: &str) -> Result<(), RingError> {
if !self.nodes.contains_key(identifier) {
return Err(RingError::NodeNotFound(identifier.to_owned()));
}
self.ring.remove_node(identifier);
self.nodes.remove(identifier);
Ok(())
}
pub fn calculate_migration_on_add(
&self,
new_node: T,
identifier: &str,
replica_multiplier: usize,
) -> Result<Vec<TokenRangeMigration<T>>, RingError> {
if self.nodes.contains_key(identifier) {
return Err(RingError::NodeAlreadyExists(identifier.to_owned()));
}
self.ring
.calculate_migration_on_add(new_node, identifier, replica_multiplier)
}
pub fn calculate_migration_on_remove(
&self,
identifier: &str,
) -> Result<Vec<TokenRangeMigration<T>>, RingError> {
if !self.nodes.contains_key(identifier) {
return Err(RingError::NodeNotFound(identifier.to_owned()));
}
Ok(self.ring.calculate_migration_on_remove(identifier))
}
pub fn get_node<K: Hash>(&self, key: &K) -> Option<&T> {
self.ring.get_node(key)
}
pub fn get_nodes<K: Hash>(&self, key: &K, count: usize) -> Vec<&T> {
self.ring.get_nodes(key, count)
}
pub fn len(&self) -> usize {
self.nodes.len()
}
pub fn is_empty(&self) -> bool {
self.nodes.is_empty()
}
}