use super::addr::Addr;
use super::config::Config;
use super::link;
use super::nodes_text::{self, Record};
use crate::rcli::conn::Conn;
use crate::rcli::opts::Opts;
use crate::rcli::session::eprint_bytes;
pub(crate) struct Node {
pub(crate) rec: Record,
pub(crate) replicas: usize,
pub(crate) signature: Vec<u8>,
pub(crate) own_slots: super::slots::SlotSet,
pub(crate) link: Conn,
}
impl Node {
pub(crate) fn shown(&self) -> Vec<u8> {
Addr { host: self.rec.host.clone(), port: self.rec.port }.shown()
}
pub(crate) fn is_master(&self) -> bool {
self.rec.flags.master
}
}
pub(crate) struct Cluster {
pub(crate) nodes: Vec<Node>,
pub(crate) unreachable_masters: usize,
pub(crate) cfg: Config,
pub(crate) opts: Opts,
}
impl Cluster {
pub(crate) fn load(opts: &Opts, cfg: Config, entry: &Addr) -> Option<Cluster> {
let mut link = link::open(opts, entry)?;
let (records, signature) = nodes_of(&mut link, entry, &cfg)?;
let mut cluster =
Cluster { nodes: Vec::new(), unreachable_masters: 0, cfg, opts: opts.clone() };
let myself = records.iter().find(|r| r.flags.myself)?;
let rec = Record { host: entry.host.clone(), port: entry.port, ..myself.clone() };
let own_slots = myself.slots.clone();
cluster.nodes.push(Node { rec, replicas: 0, signature, own_slots, link });
for friend in records.iter().filter(|r| !r.flags.myself) {
cluster.add_friend(friend);
}
cluster.count_replicas();
Some(cluster)
}
fn add_friend(&mut self, rec: &Record) {
if rec.flags.noaddr || rec.flags.handshake {
return;
}
let addr = Addr { host: rec.host.clone(), port: rec.port };
let Some(mut link) = link::open(&self.opts, &addr) else {
self.unreachable_masters += usize::from(rec.flags.master);
return;
};
let Some((records, signature)) = nodes_of(&mut link, &addr, &self.cfg) else { return };
let mut rec = rec.clone();
let mut own_slots = rec.slots.clone();
if let Some(own) = records.into_iter().find(|r| r.flags.myself) {
(rec.migrating, rec.importing, own_slots) = (own.migrating, own.importing, own.slots);
}
self.nodes.push(Node { rec, replicas: 0, signature, own_slots, link });
}
fn count_replicas(&mut self) {
let masters: Vec<Vec<u8>> =
self.nodes.iter().filter_map(|n| n.rec.master.clone()).collect();
for node in &mut self.nodes {
node.replicas = masters.iter().filter(|m| **m == node.rec.id).count();
}
}
}
fn nodes_of(link: &mut Conn, addr: &Addr, cfg: &Config) -> Option<(Vec<Record>, Vec<u8>)> {
let reply = match link.request(&[b"CLUSTER", b"NODES"]) {
Ok(reply) => reply,
Err(e) => {
let at = addr.shown();
eprint_bytes(&[b"Node ", &at, b" replied with error:\n", e.text().as_bytes(), b"\n"]);
return None;
}
};
let Some(text) = link::text(&reply) else {
let at = addr.shown();
let text = [&b"[ERR] Node "[..], &at, b" is not configured as a cluster node."].concat();
super::log::line(cfg.color, super::log::Level::Err, &text);
return None;
};
let records = nodes_text::parse(text);
let signature = signature(&records);
Some((records, signature))
}
pub(crate) fn signature(records: &[Record]) -> Vec<u8> {
let mut owners: Vec<Vec<u8>> = records
.iter()
.filter(|r| !r.slots.is_empty())
.map(|r| [r.id.as_slice(), b":", &super::slots::bracketed(&r.slots.ranges())].concat())
.collect();
owners.sort();
owners.join(&b'|')
}