use super::log::{self, Level};
use super::slots::{SLOTS, SlotSet, bracketed};
use super::topology::Cluster;
struct Groups {
none: Vec<u16>,
one: Vec<(u16, usize)>,
many: Vec<(u16, Vec<usize>)>,
}
pub(crate) fn fix(c: &mut Cluster) -> bool {
log::line(c.cfg.color, Level::Info, b">>> Fixing slots coverage...");
let groups = group(c);
if !groups.none.is_empty() {
if !ask(&groups.none, b"have no keys across the cluster", b"covering with a random node") {
return false;
}
for &slot in &groups.none {
let Some(node) = fewest_slots(c) else { break };
cover(c, node, slot, b"with");
}
}
let one: Vec<u16> = groups.one.iter().map(|(s, _)| *s).collect();
if !one.is_empty() {
if !ask(&one, b"have keys in just one node", b"covering with those nodes") {
return false;
}
for &(slot, node) in &groups.one {
cover(c, node, slot, b"with");
}
}
let many: Vec<u16> = groups.many.iter().map(|(s, _)| *s).collect();
if !many.is_empty() {
if !ask(&many, b"have keys in multiple nodes", b"moving keys into a single node") {
return false;
}
for (slot, holders) in &groups.many {
gather(c, *slot, holders);
}
}
true
}
fn group(c: &mut Cluster) -> Groups {
let covered = super::check::covered(c);
let masters: Vec<usize> = (0..c.nodes.len()).filter(|&i| c.nodes[i].is_master()).collect();
let mut groups = Groups { none: Vec::new(), one: Vec::new(), many: Vec::new() };
for slot in (0..SLOTS as u16).filter(|&s| !covered.contains(s)) {
let holders: Vec<usize> =
masters.iter().copied().filter(|&m| super::owner::keys_in(c, m, slot) > 0).collect();
match holders.as_slice() {
[] => groups.none.push(slot),
[only] => groups.one.push((slot, *only)),
_ => groups.many.push((slot, holders)),
}
}
groups
}
fn ask(slots: &[u16], what: &[u8], how: &[u8]) -> bool {
let mut set = SlotSet::default();
slots.iter().for_each(|&s| set.insert(s));
log::plain(&[&b"The following uncovered slots "[..], what, b":"].concat());
log::plain(&bracketed(&set.ranges()));
super::ask::confirm(&[&b"Fix these slots by "[..], how, b"?"].concat())
}
fn fewest_slots(c: &Cluster) -> Option<usize> {
(0..c.nodes.len()).filter(|&i| c.nodes[i].is_master()).min_by(|&a, &b| {
let key = |i: usize| (c.nodes[i].rec.slots.count(), c.nodes[i].rec.id.clone());
key(a).cmp(&key(b))
})
}
fn cover(c: &mut Cluster, node: usize, slot: u16, how: &[u8]) -> bool {
let text = [format!(">>> Covering slot {slot} ").as_bytes(), how, b" ", &c.nodes[node].shown()]
.concat();
log::line(c.cfg.color, Level::Info, &text);
match super::owner::set(c, node, slot) {
Ok(()) => true,
Err(why) => {
super::migrate::node_error(c, node, &why);
false
}
}
}
fn gather(c: &mut Cluster, slot: u16, holders: &[usize]) {
let Some(target) = super::owner::most_keys(c, holders, slot) else { return };
if !cover(c, target, slot, b"moving keys to") {
return;
}
let number = slot.to_string();
let target_id = c.nodes[target].rec.id.clone();
for &from in holders.iter().filter(|&&h| h != target) {
let own_id = c.nodes[from].rec.id.clone();
let _ = c.nodes[from].link.request(&[
b"CLUSTER",
b"SETSLOT",
number.as_bytes(),
b"NODE",
&own_id,
]); let moved = super::migrate_slot::move_keys_only(c, (from, target), slot);
let _ = c.nodes[from].link.request(&[
b"CLUSTER",
b"SETSLOT",
number.as_bytes(),
b"NODE",
&target_id,
]); if !moved {
return;
}
}
}