use std::hash::{BuildHasher, Hash};
use crate::{ConsistentRing, PhysicalRingNode, RingConfig, RingError, TokenRangeMigration};
#[derive(Clone)]
pub struct ClusterManager<'a, T, BH: BuildHasher> {
ring: ConsistentRing<'a, T, BH>,
}
impl<'a, T, BH: BuildHasher> ClusterManager<'a, T, BH> {
pub fn try_new(config: RingConfig<BH>) -> Result<Self, RingError> {
Ok(Self {
ring: ConsistentRing::try_new(config)?,
})
}
pub fn nodes(&self) -> &[PhysicalRingNode<'a, T>] {
self.ring.physical_nodes()
}
pub fn ring(&self) -> &ConsistentRing<'a, T, BH> {
&self.ring
}
pub fn add_node(
&mut self,
node: &'a T,
identifier: &str,
replica_multiplier: usize,
) -> Result<(), RingError> {
self.ring.add_node(node, identifier, replica_multiplier)?;
Ok(())
}
pub fn remove_node(&mut self, identifier: &str) -> Result<(), RingError> {
if !self.ring.contains_identifier(identifier) {
return Err(RingError::NodeNotFound(identifier.to_owned()));
}
self.ring.remove_node(identifier);
Ok(())
}
pub fn calculate_migration_on_add(
&self,
new_node: &'a T,
identifier: &str,
replica_multiplier: usize,
) -> Result<Vec<TokenRangeMigration<T>>, RingError>
where
T: Clone,
BH: Clone,
{
if self.ring.contains_identifier(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>
where
T: Clone,
BH: Clone,
{
if !self.ring.contains_identifier(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<&'a T> {
self.ring.get_node(key)
}
pub fn get_nodes<K: Hash>(&self, key: &K, count: usize) -> Vec<&'a T> {
self.ring.get_nodes(key, count)
}
pub fn len(&self) -> usize {
self.ring.physical_nodes().len()
}
pub fn is_empty(&self) -> bool {
self.ring.physical_nodes().is_empty()
}
}