cargo fmt
Some checks failed
continuous-integration/drone/push Build is failing
continuous-integration/drone/pr Build is failing

This commit is contained in:
Mendes 2022-10-10 17:21:13 +02:00
parent fcf9ac674a
commit 4abab246f1
8 changed files with 1109 additions and 985 deletions

View file

@ -4,7 +4,6 @@ extern crate tracing;
#[cfg(not(any(feature = "lmdb", feature = "sled", feature = "sqlite")))] #[cfg(not(any(feature = "lmdb", feature = "sled", feature = "sqlite")))]
//compile_error!("Must activate the Cargo feature for at least one DB engine: lmdb, sled or sqlite."); //compile_error!("Must activate the Cargo feature for at least one DB engine: lmdb, sled or sqlite.");
#[cfg(feature = "lmdb")] #[cfg(feature = "lmdb")]
pub mod lmdb_adapter; pub mod lmdb_adapter;
#[cfg(feature = "sled")] #[cfg(feature = "sled")]

View file

@ -190,7 +190,10 @@ pub async fn cmd_show_layout(
println!(); println!();
println!("==== PARAMETERS OF THE LAYOUT COMPUTATION ===="); println!("==== PARAMETERS OF THE LAYOUT COMPUTATION ====");
println!("Zone redundancy: {}", layout.staged_parameters.get().zone_redundancy); println!(
"Zone redundancy: {}",
layout.staged_parameters.get().zone_redundancy
);
println!(); println!();
// this will print the stats of what partitions // this will print the stats of what partitions
@ -206,11 +209,15 @@ pub async fn cmd_show_layout(
println!(); println!();
println!( println!(
"You can also revert all proposed changes with: garage layout revert --version {}", "You can also revert all proposed changes with: garage layout revert --version {}",
layout.version + 1)}, layout.version + 1)
}
Err(Error::Message(s)) => { Err(Error::Message(s)) => {
println!("Error while trying to compute the assignation: {}", s); println!("Error while trying to compute the assignation: {}", s);
println!("This new layout cannot yet be applied.");}, println!("This new layout cannot yet be applied.");
_ => { println!("Unknown Error"); }, }
_ => {
println!("Unknown Error");
}
} }
} }
@ -263,14 +270,17 @@ pub async fn cmd_config_layout(
None => (), None => (),
Some(r) => { Some(r) => {
if r > layout.replication_factor { if r > layout.replication_factor {
println!("The zone redundancy must be smaller or equal to the \ println!(
replication factor ({}).", layout.replication_factor); "The zone redundancy must be smaller or equal to the \
} replication factor ({}).",
else if r < 1 { layout.replication_factor
);
} else if r < 1 {
println!("The zone redundancy must be at least 1."); println!("The zone redundancy must be at least 1.");
} } else {
else { layout
layout.staged_parameters.update(LayoutParameters{ zone_redundancy: r }); .staged_parameters
.update(LayoutParameters { zone_redundancy: r });
println!("The new zone redundancy has been saved ({}).", r); println!("The new zone redundancy has been saved ({}).", r);
} }
} }

View file

@ -104,7 +104,6 @@ pub enum LayoutOperation {
Revert(RevertLayoutOpt), Revert(RevertLayoutOpt),
} }
#[derive(StructOpt, Debug)] #[derive(StructOpt, Debug)]
pub struct AssignRoleOpt { pub struct AssignRoleOpt {
/// Node(s) to which to assign role (prefix of hexadecimal node id) /// Node(s) to which to assign role (prefix of hexadecimal node id)

View file

@ -1,27 +1,25 @@
//! This module deals with graph algorithms. //! This module deals with graph algorithms.
//! It is used in layout.rs to build the partition to node assignation. //! It is used in layout.rs to build the partition to node assignation.
use rand::prelude::SliceRandom; use rand::prelude::SliceRandom;
use std::cmp::{max, min}; use std::cmp::{max, min};
use std::collections::VecDeque;
use std::collections::HashMap; use std::collections::HashMap;
use std::collections::VecDeque;
//Vertex data structures used in all the graphs used in layout.rs. //Vertex data structures used in all the graphs used in layout.rs.
//usize parameters correspond to node/zone/partitions ids. //usize parameters correspond to node/zone/partitions ids.
//To understand the vertex roles below, please refer to the formal description //To understand the vertex roles below, please refer to the formal description
//of the layout computation algorithm. //of the layout computation algorithm.
#[derive(Clone,Copy,Debug, PartialEq, Eq, Hash)] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Vertex{ pub enum Vertex {
Source, Source,
Pup(usize), //The vertex p+ of partition p Pup(usize), //The vertex p+ of partition p
Pdown(usize), //The vertex p- of partition p Pdown(usize), //The vertex p- of partition p
PZ(usize,usize), //The vertex corresponding to x_(partition p, zone z) PZ(usize, usize), //The vertex corresponding to x_(partition p, zone z)
N(usize), //The vertex corresponding to node n N(usize), //The vertex corresponding to node n
Sink Sink,
} }
//Edge data structure for the flow algorithm. //Edge data structure for the flow algorithm.
//The graph is stored as an adjacency list //The graph is stored as an adjacency list
#[derive(Clone, Copy, Debug)] #[derive(Clone, Copy, Debug)]
@ -47,33 +45,33 @@ impl Edge for WeightedEdge {}
//Struct for the graph structure. We do encapsulation here to be able to both //Struct for the graph structure. We do encapsulation here to be able to both
//provide user friendly Vertex enum to address vertices, and to use usize indices //provide user friendly Vertex enum to address vertices, and to use usize indices
//and Vec instead of HashMap in the graph algorithm to optimize execution speed. //and Vec instead of HashMap in the graph algorithm to optimize execution speed.
pub struct Graph<E : Edge>{ pub struct Graph<E: Edge> {
vertextoid : HashMap<Vertex , usize>, vertextoid: HashMap<Vertex, usize>,
idtovertex : Vec<Vertex>, idtovertex: Vec<Vertex>,
graph : Vec< Vec<E> > graph: Vec<Vec<E>>,
} }
pub type CostFunction = HashMap<(Vertex,Vertex), i32>; pub type CostFunction = HashMap<(Vertex, Vertex), i32>;
impl<E : Edge> Graph<E>{ impl<E: Edge> Graph<E> {
pub fn new(vertices : &[Vertex]) -> Self { pub fn new(vertices: &[Vertex]) -> Self {
let mut map = HashMap::<Vertex, usize>::new(); let mut map = HashMap::<Vertex, usize>::new();
for (i, vert) in vertices.iter().enumerate(){ for (i, vert) in vertices.iter().enumerate() {
map.insert(*vert , i); map.insert(*vert, i);
} }
Graph::<E> { Graph::<E> {
vertextoid : map, vertextoid: map,
idtovertex: vertices.to_vec(), idtovertex: vertices.to_vec(),
graph : vec![Vec::< E >::new(); vertices.len() ] graph: vec![Vec::<E>::new(); vertices.len()],
} }
} }
} }
impl Graph<FlowEdge>{ impl Graph<FlowEdge> {
//This function adds a directed edge to the graph with capacity c, and the //This function adds a directed edge to the graph with capacity c, and the
//corresponding reversed edge with capacity 0. //corresponding reversed edge with capacity 0.
pub fn add_edge(&mut self, u: Vertex, v:Vertex, c: u32) -> Result<(), String>{ pub fn add_edge(&mut self, u: Vertex, v: Vertex, c: u32) -> Result<(), String> {
if !self.vertextoid.contains_key(&u) || !self.vertextoid.contains_key(&v) { if !self.vertextoid.contains_key(&u) || !self.vertextoid.contains_key(&v) {
return Err("The graph does not contain the provided vertex.".to_string()); return Err("The graph does not contain the provided vertex.".to_string());
} }
@ -81,14 +79,24 @@ impl Graph<FlowEdge>{
let idv = self.vertextoid[&v]; let idv = self.vertextoid[&v];
let rev_u = self.graph[idu].len(); let rev_u = self.graph[idu].len();
let rev_v = self.graph[idv].len(); let rev_v = self.graph[idv].len();
self.graph[idu].push( FlowEdge{cap: c , dest: idv , flow: 0, rev : rev_v} ); self.graph[idu].push(FlowEdge {
self.graph[idv].push( FlowEdge{cap: 0 , dest: idu , flow: 0, rev : rev_u} ); cap: c,
dest: idv,
flow: 0,
rev: rev_v,
});
self.graph[idv].push(FlowEdge {
cap: 0,
dest: idu,
flow: 0,
rev: rev_u,
});
Ok(()) Ok(())
} }
//This function returns the list of vertices that receive a positive flow from //This function returns the list of vertices that receive a positive flow from
//vertex v. //vertex v.
pub fn get_positive_flow_from(&self , v:Vertex) -> Result< Vec<Vertex> , String>{ pub fn get_positive_flow_from(&self, v: Vertex) -> Result<Vec<Vertex>, String> {
if !self.vertextoid.contains_key(&v) { if !self.vertextoid.contains_key(&v) {
return Err("The graph does not contain the provided vertex.".to_string()); return Err("The graph does not contain the provided vertex.".to_string());
} }
@ -102,29 +110,28 @@ impl Graph<FlowEdge>{
Ok(result) Ok(result)
} }
//This function returns the value of the flow incoming to v. //This function returns the value of the flow incoming to v.
pub fn get_inflow(&self , v:Vertex) -> Result< i32 , String>{ pub fn get_inflow(&self, v: Vertex) -> Result<i32, String> {
if !self.vertextoid.contains_key(&v) { if !self.vertextoid.contains_key(&v) {
return Err("The graph does not contain the provided vertex.".to_string()); return Err("The graph does not contain the provided vertex.".to_string());
} }
let idv = self.vertextoid[&v]; let idv = self.vertextoid[&v];
let mut result = 0; let mut result = 0;
for edge in self.graph[idv].iter() { for edge in self.graph[idv].iter() {
result += max(0,self.graph[edge.dest][edge.rev].flow); result += max(0, self.graph[edge.dest][edge.rev].flow);
} }
Ok(result) Ok(result)
} }
//This function returns the value of the flow outgoing from v. //This function returns the value of the flow outgoing from v.
pub fn get_outflow(&self , v:Vertex) -> Result< i32 , String>{ pub fn get_outflow(&self, v: Vertex) -> Result<i32, String> {
if !self.vertextoid.contains_key(&v) { if !self.vertextoid.contains_key(&v) {
return Err("The graph does not contain the provided vertex.".to_string()); return Err("The graph does not contain the provided vertex.".to_string());
} }
let idv = self.vertextoid[&v]; let idv = self.vertextoid[&v];
let mut result = 0; let mut result = 0;
for edge in self.graph[idv].iter() { for edge in self.graph[idv].iter() {
result += max(0,edge.flow); result += max(0, edge.flow);
} }
Ok(result) Ok(result)
} }
@ -151,10 +158,10 @@ impl Graph<FlowEdge>{
} }
//Computes an upper bound of the flow n the graph //Computes an upper bound of the flow n the graph
pub fn flow_upper_bound(&self) -> u32{ pub fn flow_upper_bound(&self) -> u32 {
let idsource = self.vertextoid[&Vertex::Source]; let idsource = self.vertextoid[&Vertex::Source];
let mut flow_upper_bound = 0; let mut flow_upper_bound = 0;
for edge in self.graph[idsource].iter(){ for edge in self.graph[idsource].iter() {
flow_upper_bound += edge.cap; flow_upper_bound += edge.cap;
} }
flow_upper_bound flow_upper_bound
@ -192,7 +199,8 @@ impl Graph<FlowEdge>{
fifo.push_back((idsource, 0)); fifo.push_back((idsource, 0));
while !fifo.is_empty() { while !fifo.is_empty() {
if let Some((id, lvl)) = fifo.pop_front() { if let Some((id, lvl)) = fifo.pop_front() {
if level[id] == None { //it means id has not yet been reached if level[id] == None {
//it means id has not yet been reached
level[id] = Some(lvl); level[id] = Some(lvl);
for edge in self.graph[id].iter() { for edge in self.graph[id].iter() {
if edge.cap as i32 - edge.flow > 0 { if edge.cap as i32 - edge.flow > 0 {
@ -240,13 +248,15 @@ impl Graph<FlowEdge>{
continue; continue;
} }
//else we can try to send flow from id to its nbd //else we can try to send flow from id to its nbd
let new_flow = min(f as i32, self.graph[id][nbd].cap as i32 - self.graph[id][nbd].flow) as u32; let new_flow = min(
f as i32,
self.graph[id][nbd].cap as i32 - self.graph[id][nbd].flow,
) as u32;
if new_flow == 0 { if new_flow == 0 {
next_nbd[id] += 1; next_nbd[id] += 1;
continue; continue;
} }
if let (Some(lvldest), Some(lvlid)) = if let (Some(lvldest), Some(lvlid)) = (level[self.graph[id][nbd].dest], level[id]) {
(level[self.graph[id][nbd].dest], level[id]){
if lvldest <= lvlid { if lvldest <= lvlid {
//We cannot send flow to nbd. //We cannot send flow to nbd.
next_nbd[id] += 1; next_nbd[id] += 1;
@ -265,25 +275,28 @@ impl Graph<FlowEdge>{
// as subroutine the Bellman Ford algorithm run up to path_length. // as subroutine the Bellman Ford algorithm run up to path_length.
// We assume that the cost of edge (u,v) is the opposite of the cost of (v,u), and only // We assume that the cost of edge (u,v) is the opposite of the cost of (v,u), and only
// one needs to be present in the cost function. // one needs to be present in the cost function.
pub fn optimize_flow_with_cost(&mut self , cost: &CostFunction, path_length: usize ) pub fn optimize_flow_with_cost(
-> Result<(),String>{ &mut self,
cost: &CostFunction,
path_length: usize,
) -> Result<(), String> {
//We build the weighted graph g where we will look for negative cycle //We build the weighted graph g where we will look for negative cycle
let mut gf = self.build_cost_graph(cost)?; let mut gf = self.build_cost_graph(cost)?;
let mut cycles = gf.list_negative_cycles(path_length); let mut cycles = gf.list_negative_cycles(path_length);
while !cycles.is_empty() { while !cycles.is_empty() {
//we enumerate negative cycles //we enumerate negative cycles
for c in cycles.iter(){ for c in cycles.iter() {
for i in 0..c.len(){ for i in 0..c.len() {
//We add one flow unit to the edge (u,v) of cycle c //We add one flow unit to the edge (u,v) of cycle c
let idu = self.vertextoid[&c[i]]; let idu = self.vertextoid[&c[i]];
let idv = self.vertextoid[&c[(i+1)%c.len()]]; let idv = self.vertextoid[&c[(i + 1) % c.len()]];
for j in 0..self.graph[idu].len(){ for j in 0..self.graph[idu].len() {
//since idu appears at most once in the cycles, we enumerate every //since idu appears at most once in the cycles, we enumerate every
//edge at most once. //edge at most once.
let edge = self.graph[idu][j]; let edge = self.graph[idu][j];
if edge.dest == idv { if edge.dest == idv {
self.graph[idu][j].flow += 1; self.graph[idu][j].flow += 1;
self.graph[idv][edge.rev].flow -=1; self.graph[idv][edge.rev].flow -= 1;
break; break;
} }
} }
@ -297,44 +310,38 @@ impl Graph<FlowEdge>{
} }
//Construct the weighted graph G_f from the flow and the cost function //Construct the weighted graph G_f from the flow and the cost function
fn build_cost_graph(&self , cost: &CostFunction) -> Result<Graph<WeightedEdge>,String>{ fn build_cost_graph(&self, cost: &CostFunction) -> Result<Graph<WeightedEdge>, String> {
let mut g = Graph::<WeightedEdge>::new(&self.idtovertex); let mut g = Graph::<WeightedEdge>::new(&self.idtovertex);
let nb_vertices = self.idtovertex.len(); let nb_vertices = self.idtovertex.len();
for i in 0..nb_vertices { for i in 0..nb_vertices {
for edge in self.graph[i].iter() { for edge in self.graph[i].iter() {
if edge.cap as i32 -edge.flow > 0 { if edge.cap as i32 - edge.flow > 0 {
//It is possible to send overflow through this edge //It is possible to send overflow through this edge
let u = self.idtovertex[i]; let u = self.idtovertex[i];
let v = self.idtovertex[edge.dest]; let v = self.idtovertex[edge.dest];
if cost.contains_key(&(u,v)) { if cost.contains_key(&(u, v)) {
g.add_edge(u,v, cost[&(u,v)])?; g.add_edge(u, v, cost[&(u, v)])?;
} } else if cost.contains_key(&(v, u)) {
else if cost.contains_key(&(v,u)) { g.add_edge(u, v, -cost[&(v, u)])?;
g.add_edge(u,v, -cost[&(v,u)])?; } else {
} g.add_edge(u, v, 0)?;
else{
g.add_edge(u,v, 0)?;
} }
} }
} }
} }
Ok(g) Ok(g)
} }
} }
impl Graph<WeightedEdge>{ impl Graph<WeightedEdge> {
//This function adds a single directed weighted edge to the graph. //This function adds a single directed weighted edge to the graph.
pub fn add_edge(&mut self, u: Vertex, v:Vertex, w: i32) -> Result<(), String>{ pub fn add_edge(&mut self, u: Vertex, v: Vertex, w: i32) -> Result<(), String> {
if !self.vertextoid.contains_key(&u) || !self.vertextoid.contains_key(&v) { if !self.vertextoid.contains_key(&u) || !self.vertextoid.contains_key(&v) {
return Err("The graph does not contain the provided vertex.".to_string()); return Err("The graph does not contain the provided vertex.".to_string());
} }
let idu = self.vertextoid[&u]; let idu = self.vertextoid[&u];
let idv = self.vertextoid[&v]; let idv = self.vertextoid[&v];
self.graph[idu].push( WeightedEdge{ w , dest: idv} ); self.graph[idu].push(WeightedEdge { w, dest: idv });
Ok(()) Ok(())
} }
@ -344,18 +351,17 @@ impl Graph<WeightedEdge>{
//for particular graph structures like our case, the algorithm is still correct //for particular graph structures like our case, the algorithm is still correct
//when path_length is the length of the longest possible simple path. //when path_length is the length of the longest possible simple path.
//See the formal description of the algorithm for more details. //See the formal description of the algorithm for more details.
fn list_negative_cycles(&self, path_length: usize) -> Vec< Vec<Vertex> > { fn list_negative_cycles(&self, path_length: usize) -> Vec<Vec<Vertex>> {
let nb_vertices = self.graph.len(); let nb_vertices = self.graph.len();
//We start with every vertex at distance 0 of some imaginary extra -1 vertex. //We start with every vertex at distance 0 of some imaginary extra -1 vertex.
let mut distance = vec![0 ; nb_vertices]; let mut distance = vec![0; nb_vertices];
//The prev vector collects for every vertex from where does the shortest path come //The prev vector collects for every vertex from where does the shortest path come
let mut prev = vec![None; nb_vertices]; let mut prev = vec![None; nb_vertices];
for _ in 0..path_length +1 { for _ in 0..path_length + 1 {
for id in 0..nb_vertices{ for id in 0..nb_vertices {
for e in self.graph[id].iter(){ for e in self.graph[id].iter() {
if distance[id] + e.w < distance[e.dest] { if distance[id] + e.w < distance[e.dest] {
distance[e.dest] = distance[id] + e.w; distance[e.dest] = distance[id] + e.w;
prev[e.dest] = Some(id); prev[e.dest] = Some(id);
@ -364,7 +370,6 @@ impl Graph<WeightedEdge>{
} }
} }
//If self.graph contains a negative cycle, then at this point the graph described //If self.graph contains a negative cycle, then at this point the graph described
//by prev (which is a directed 1-forest/functional graph) //by prev (which is a directed 1-forest/functional graph)
//must contain a cycle. We list the cycles of prev. //must contain a cycle. We list the cycles of prev.
@ -372,29 +377,27 @@ impl Graph<WeightedEdge>{
//Remark that the cycle in prev is in the reverse order compared to the cycle //Remark that the cycle in prev is in the reverse order compared to the cycle
//in the graph. Thus the .rev(). //in the graph. Thus the .rev().
return cycles_prev.iter().map(|cycle| cycle.iter().rev().map( return cycles_prev
|id| self.idtovertex[*id] .iter()
).collect() ).collect(); .map(|cycle| cycle.iter().rev().map(|id| self.idtovertex[*id]).collect())
.collect();
} }
} }
//This function returns the list of cycles of a directed 1 forest. It does not //This function returns the list of cycles of a directed 1 forest. It does not
//check for the consistency of the input. //check for the consistency of the input.
fn cycles_of_1_forest(forest: &[Option<usize>]) -> Vec<Vec<usize>> { fn cycles_of_1_forest(forest: &[Option<usize>]) -> Vec<Vec<usize>> {
let mut cycles = Vec::<Vec::<usize>>::new(); let mut cycles = Vec::<Vec<usize>>::new();
let mut time_of_discovery = vec![None; forest.len()]; let mut time_of_discovery = vec![None; forest.len()];
for t in 0..forest.len(){ for t in 0..forest.len() {
let mut id = t; let mut id = t;
//while we are on a valid undiscovered node //while we are on a valid undiscovered node
while time_of_discovery[id] == None { while time_of_discovery[id] == None {
time_of_discovery[id] = Some(t); time_of_discovery[id] = Some(t);
if let Some(i) = forest[id] { if let Some(i) = forest[id] {
id = i; id = i;
} } else {
else{
break; break;
} }
} }
@ -407,8 +410,7 @@ fn cycles_of_1_forest(forest: &[Option<usize>]) -> Vec<Vec<usize>> {
id2 = id_next; id2 = id_next;
if id2 != id { if id2 != id {
cy.push(id2); cy.push(id2);
} } else {
else {
break; break;
} }
} }
@ -417,5 +419,3 @@ fn cycles_of_1_forest(forest: &[Option<usize>]) -> Vec<Vec<usize>> {
} }
cycles cycles
} }

View file

@ -7,7 +7,7 @@ use itertools::Itertools;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use garage_util::crdt::{AutoCrdt, Crdt, LwwMap, Lww}; use garage_util::crdt::{AutoCrdt, Crdt, Lww, LwwMap};
use garage_util::data::*; use garage_util::data::*;
use garage_util::error::*; use garage_util::error::*;
@ -58,14 +58,14 @@ pub struct ClusterLayout {
///algorithm. It is stored as a Crdt. ///algorithm. It is stored as a Crdt.
#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Debug, Serialize, Deserialize)] #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Debug, Serialize, Deserialize)]
pub struct LayoutParameters { pub struct LayoutParameters {
pub zone_redundancy:usize, pub zone_redundancy: usize,
} }
impl AutoCrdt for LayoutParameters { impl AutoCrdt for LayoutParameters {
const WARN_IF_DIFFERENT: bool = true; const WARN_IF_DIFFERENT: bool = true;
} }
const NB_PARTITIONS : usize = 1usize << PARTITION_BITS; const NB_PARTITIONS: usize = 1usize << PARTITION_BITS;
#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Debug, Serialize, Deserialize)] #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Debug, Serialize, Deserialize)]
pub struct NodeRoleV(pub Option<NodeRole>); pub struct NodeRoleV(pub Option<NodeRole>);
@ -99,10 +99,10 @@ impl NodeRole {
pub fn tags_string(&self) -> String { pub fn tags_string(&self) -> String {
let mut tags = String::new(); let mut tags = String::new();
if self.tags.is_empty() { if self.tags.is_empty() {
return tags return tags;
} }
tags.push_str(&self.tags[0].clone()); tags.push_str(&self.tags[0].clone());
for t in 1..self.tags.len(){ for t in 1..self.tags.len() {
tags.push(','); tags.push(',');
tags.push_str(&self.tags[t].clone()); tags.push_str(&self.tags[t].clone());
} }
@ -112,10 +112,11 @@ impl NodeRole {
impl ClusterLayout { impl ClusterLayout {
pub fn new(replication_factor: usize) -> Self { pub fn new(replication_factor: usize) -> Self {
//We set the default zone redundancy to be equal to the replication factor, //We set the default zone redundancy to be equal to the replication factor,
//i.e. as strict as possible. //i.e. as strict as possible.
let parameters = LayoutParameters{ zone_redundancy: replication_factor}; let parameters = LayoutParameters {
zone_redundancy: replication_factor,
};
let staged_parameters = Lww::<LayoutParameters>::new(parameters.clone()); let staged_parameters = Lww::<LayoutParameters>::new(parameters.clone());
let empty_lwwmap = LwwMap::new(); let empty_lwwmap = LwwMap::new();
@ -146,7 +147,6 @@ impl ClusterLayout {
self.staged_parameters.merge(&other.staged_parameters); self.staged_parameters.merge(&other.staged_parameters);
self.staging.merge(&other.staging); self.staging.merge(&other.staging);
let new_staging_hash = blake2sum(&rmp_to_vec_all_named(&self.staging).unwrap()[..]); let new_staging_hash = blake2sum(&rmp_to_vec_all_named(&self.staging).unwrap()[..]);
let stage_changed = new_staging_hash != self.staging_hash; let stage_changed = new_staging_hash != self.staging_hash;
@ -158,7 +158,7 @@ impl ClusterLayout {
} }
} }
pub fn apply_staged_changes(mut self, version: Option<u64>) -> Result<(Self,Message), Error> { pub fn apply_staged_changes(mut self, version: Option<u64>) -> Result<(Self, Message), Error> {
match version { match version {
None => { None => {
let error = r#" let error = r#"
@ -184,7 +184,7 @@ To know the correct value of the new layout version, invoke `garage layout show`
self.version += 1; self.version += 1;
Ok((self,msg)) Ok((self, msg))
} }
pub fn revert_staged_changes(mut self, version: Option<u64>) -> Result<Self, Error> { pub fn revert_staged_changes(mut self, version: Option<u64>) -> Result<Self, Error> {
@ -235,31 +235,40 @@ To know the correct value of the new layout version, invoke `garage layout show`
for uuid in self.node_id_vec.iter() { for uuid in self.node_id_vec.iter() {
match self.node_role(uuid) { match self.node_role(uuid) {
Some(role) if role.capacity != None => result.push(*uuid), Some(role) if role.capacity != None => result.push(*uuid),
_ => () _ => (),
} }
} }
result result
} }
///Given a node uuids, this function returns the label of its zone ///Given a node uuids, this function returns the label of its zone
pub fn get_node_zone(&self, uuid : &Uuid) -> Result<String,Error> { pub fn get_node_zone(&self, uuid: &Uuid) -> Result<String, Error> {
match self.node_role(uuid) { match self.node_role(uuid) {
Some(role) => Ok(role.zone.clone()), Some(role) => Ok(role.zone.clone()),
_ => Err(Error::Message("The Uuid does not correspond to a node present in the cluster.".into())) _ => Err(Error::Message(
"The Uuid does not correspond to a node present in the cluster.".into(),
)),
} }
} }
///Given a node uuids, this function returns its capacity or fails if it does not have any ///Given a node uuids, this function returns its capacity or fails if it does not have any
pub fn get_node_capacity(&self, uuid : &Uuid) -> Result<u32,Error> { pub fn get_node_capacity(&self, uuid: &Uuid) -> Result<u32, Error> {
match self.node_role(uuid) { match self.node_role(uuid) {
Some(NodeRole{capacity : Some(cap), zone: _, tags: _}) => Ok(*cap), Some(NodeRole {
_ => Err(Error::Message("The Uuid does not correspond to a node present in the \ capacity: Some(cap),
cluster or this node does not have a positive capacity.".into())) zone: _,
tags: _,
}) => Ok(*cap),
_ => Err(Error::Message(
"The Uuid does not correspond to a node present in the \
cluster or this node does not have a positive capacity."
.into(),
)),
} }
} }
///Returns the sum of capacities of non gateway nodes in the cluster ///Returns the sum of capacities of non gateway nodes in the cluster
pub fn get_total_capacity(&self) -> Result<u32,Error> { pub fn get_total_capacity(&self) -> Result<u32, Error> {
let mut total_capacity = 0; let mut total_capacity = 0;
for uuid in self.useful_nodes().iter() { for uuid in self.useful_nodes().iter() {
total_capacity += self.get_node_capacity(uuid)?; total_capacity += self.get_node_capacity(uuid)?;
@ -267,7 +276,6 @@ To know the correct value of the new layout version, invoke `garage layout show`
Ok(total_capacity) Ok(total_capacity)
} }
/// Check a cluster layout for internal consistency /// Check a cluster layout for internal consistency
/// returns true if consistent, false if error /// returns true if consistent, false if error
pub fn check(&self) -> bool { pub fn check(&self) -> bool {
@ -314,14 +322,15 @@ To know the correct value of the new layout version, invoke `garage layout show`
//Check that every partition is associated to distinct nodes //Check that every partition is associated to distinct nodes
let rf = self.replication_factor; let rf = self.replication_factor;
for p in 0..(1 << PARTITION_BITS) { for p in 0..(1 << PARTITION_BITS) {
let nodes_of_p = self.ring_assignation_data[rf*p..rf*(p+1)].to_vec(); let nodes_of_p = self.ring_assignation_data[rf * p..rf * (p + 1)].to_vec();
if nodes_of_p.iter().unique().count() != rf { if nodes_of_p.iter().unique().count() != rf {
return false; return false;
} }
//Check that every partition is spread over at least zone_redundancy zones. //Check that every partition is spread over at least zone_redundancy zones.
let zones_of_p = nodes_of_p.iter() let zones_of_p = nodes_of_p.iter().map(|n| {
.map(|n| self.get_node_zone(&self.node_id_vec[*n as usize]) self.get_node_zone(&self.node_id_vec[*n as usize])
.expect("Zone not found.")); .expect("Zone not found.")
});
let redundancy = self.parameters.zone_redundancy; let redundancy = self.parameters.zone_redundancy;
if zones_of_p.unique().count() < redundancy { if zones_of_p.unique().count() < redundancy {
return false; return false;
@ -333,11 +342,12 @@ To know the correct value of the new layout version, invoke `garage layout show`
for n in self.ring_assignation_data.iter() { for n in self.ring_assignation_data.iter() {
node_usage[*n as usize] += 1; node_usage[*n as usize] += 1;
} }
for (n, usage) in node_usage.iter().enumerate(){ for (n, usage) in node_usage.iter().enumerate() {
if *usage > 0 { if *usage > 0 {
let uuid = self.node_id_vec[n]; let uuid = self.node_id_vec[n];
if usage*self.partition_size > self.get_node_capacity(&uuid) if usage * self.partition_size
.expect("Critical Error"){ > self.get_node_capacity(&uuid).expect("Critical Error")
{
return false; return false;
} }
} }
@ -346,16 +356,16 @@ To know the correct value of the new layout version, invoke `garage layout show`
//Check that the partition size stored is the one computed by the asignation //Check that the partition size stored is the one computed by the asignation
//algorithm. //algorithm.
let cl2 = self.clone(); let cl2 = self.clone();
let (_ , zone_to_id) = cl2.generate_useful_zone_ids().expect("Critical Error"); let (_, zone_to_id) = cl2.generate_useful_zone_ids().expect("Critical Error");
let partition_size = cl2.compute_optimal_partition_size(&zone_to_id).expect("Critical Error"); let partition_size = cl2
.compute_optimal_partition_size(&zone_to_id)
.expect("Critical Error");
if partition_size != self.partition_size { if partition_size != self.partition_size {
return false; return false;
} }
true true
} }
} }
impl ClusterLayout { impl ClusterLayout {
@ -367,7 +377,7 @@ impl ClusterLayout {
/// the former assignation (if any) to minimize the amount of /// the former assignation (if any) to minimize the amount of
/// data to be moved. /// data to be moved.
/// Staged changes must be merged with nodes roles before calling this function. /// Staged changes must be merged with nodes roles before calling this function.
pub fn calculate_partition_assignation(&mut self) -> Result<Message,Error> { pub fn calculate_partition_assignation(&mut self) -> Result<Message, Error> {
//The nodes might have been updated, some might have been deleted. //The nodes might have been updated, some might have been deleted.
//So we need to first update the list of nodes and retrieve the //So we need to first update the list of nodes and retrieve the
//assignation. //assignation.
@ -378,27 +388,37 @@ impl ClusterLayout {
let redundancy = self.staged_parameters.get().zone_redundancy; let redundancy = self.staged_parameters.get().zone_redundancy;
let mut msg = Message::new(); let mut msg = Message::new();
msg.push(format!("Computation of a new cluster layout where partitions are \ msg.push(format!(
replicated {} times on at least {} distinct zones.", self.replication_factor, redundancy)); "Computation of a new cluster layout where partitions are \
replicated {} times on at least {} distinct zones.",
self.replication_factor, redundancy
));
//We generate for once numerical ids for the zones of non gateway nodes, //We generate for once numerical ids for the zones of non gateway nodes,
//to use them as indices in the flow graphs. //to use them as indices in the flow graphs.
let (id_to_zone , zone_to_id) = self.generate_useful_zone_ids()?; let (id_to_zone, zone_to_id) = self.generate_useful_zone_ids()?;
let nb_useful_nodes = self.useful_nodes().len(); let nb_useful_nodes = self.useful_nodes().len();
msg.push(format!("The cluster contains {} nodes spread over {} zones.", msg.push(format!(
nb_useful_nodes, id_to_zone.len())); "The cluster contains {} nodes spread over {} zones.",
if nb_useful_nodes < self.replication_factor{ nb_useful_nodes,
return Err(Error::Message(format!("The number of nodes with positive \ id_to_zone.len()
));
if nb_useful_nodes < self.replication_factor {
return Err(Error::Message(format!(
"The number of nodes with positive \
capacity ({}) is smaller than the replication factor ({}).", capacity ({}) is smaller than the replication factor ({}).",
nb_useful_nodes, self.replication_factor))); nb_useful_nodes, self.replication_factor
)));
} }
if id_to_zone.len() < redundancy { if id_to_zone.len() < redundancy {
return Err(Error::Message(format!("The number of zones with non-gateway \ return Err(Error::Message(format!(
"The number of zones with non-gateway \
nodes ({}) is smaller than the redundancy parameter ({})", nodes ({}) is smaller than the redundancy parameter ({})",
id_to_zone.len() , redundancy))); id_to_zone.len(),
redundancy
)));
} }
//We compute the optimal partition size //We compute the optimal partition size
@ -408,36 +428,48 @@ impl ClusterLayout {
let partition_size = self.compute_optimal_partition_size(&zone_to_id)?; let partition_size = self.compute_optimal_partition_size(&zone_to_id)?;
if old_assignation_opt != None { if old_assignation_opt != None {
msg.push(format!("Given the replication and redundancy constraint, the \ msg.push(format!(
"Given the replication and redundancy constraint, the \
optimal size of a partition is {}. In the previous layout, it used to \ optimal size of a partition is {}. In the previous layout, it used to \
be {} (the zone redundancy was {}).", partition_size, self.partition_size, be {} (the zone redundancy was {}).",
self.parameters.zone_redundancy)); partition_size, self.partition_size, self.parameters.zone_redundancy
} ));
else { } else {
msg.push(format!("Given the replication and redundancy constraints, the \ msg.push(format!(
optimal size of a partition is {}.", partition_size)); "Given the replication and redundancy constraints, the \
optimal size of a partition is {}.",
partition_size
));
} }
self.partition_size = partition_size; self.partition_size = partition_size;
self.parameters = self.staged_parameters.get().clone(); self.parameters = self.staged_parameters.get().clone();
if partition_size < 100 { if partition_size < 100 {
msg.push("WARNING: The partition size is low (< 100), you might consider to \ msg.push(
provide the nodes capacities in a smaller unit (e.g. Mb instead of Gb).".into()); "WARNING: The partition size is low (< 100), you might consider to \
provide the nodes capacities in a smaller unit (e.g. Mb instead of Gb)."
.into(),
);
} }
//We compute a first flow/assignment that is heuristically close to the previous //We compute a first flow/assignment that is heuristically close to the previous
//assignment //assignment
let mut gflow = self.compute_candidate_assignment( &zone_to_id, &old_assignation_opt)?; let mut gflow = self.compute_candidate_assignment(&zone_to_id, &old_assignation_opt)?;
if let Some(assoc) = &old_assignation_opt { if let Some(assoc) = &old_assignation_opt {
//We minimize the distance to the previous assignment. //We minimize the distance to the previous assignment.
self.minimize_rebalance_load(&mut gflow, &zone_to_id, assoc)?; self.minimize_rebalance_load(&mut gflow, &zone_to_id, assoc)?;
} }
msg.append(&mut self.output_stat(&gflow, &old_assignation_opt, &zone_to_id,&id_to_zone)?); msg.append(&mut self.output_stat(
&gflow,
&old_assignation_opt,
&zone_to_id,
&id_to_zone,
)?);
msg.push("".to_string()); msg.push("".to_string());
//We update the layout structure //We update the layout structure
self.update_ring_from_flow(id_to_zone.len() , &gflow)?; self.update_ring_from_flow(id_to_zone.len(), &gflow)?;
Ok(msg) Ok(msg)
} }
@ -446,22 +478,33 @@ impl ClusterLayout {
/// None if the node is not present anymore. /// None if the node is not present anymore.
/// We work with the assumption that only this function and calculate_new_assignation /// We work with the assumption that only this function and calculate_new_assignation
/// do modify assignation_ring and node_id_vec. /// do modify assignation_ring and node_id_vec.
fn update_node_id_vec(&mut self) -> Result< Option< Vec<Vec<usize> > > ,Error> { fn update_node_id_vec(&mut self) -> Result<Option<Vec<Vec<usize>>>, Error> {
// (1) We compute the new node list // (1) We compute the new node list
//Non gateway nodes should be coded on 8bits, hence they must be first in the list //Non gateway nodes should be coded on 8bits, hence they must be first in the list
//We build the new node ids //We build the new node ids
let mut new_non_gateway_nodes: Vec<Uuid> = self.roles.items().iter() let mut new_non_gateway_nodes: Vec<Uuid> = self
.roles
.items()
.iter()
.filter(|(_, _, v)| matches!(&v.0, Some(r) if r.capacity != None)) .filter(|(_, _, v)| matches!(&v.0, Some(r) if r.capacity != None))
.map(|(k, _, _)| *k).collect(); .map(|(k, _, _)| *k)
.collect();
if new_non_gateway_nodes.len() > MAX_NODE_NUMBER { if new_non_gateway_nodes.len() > MAX_NODE_NUMBER {
return Err(Error::Message(format!("There are more than {} non-gateway nodes in the new \ return Err(Error::Message(format!(
layout. This is not allowed.", MAX_NODE_NUMBER) )); "There are more than {} non-gateway nodes in the new \
layout. This is not allowed.",
MAX_NODE_NUMBER
)));
} }
let mut new_gateway_nodes: Vec<Uuid> = self.roles.items().iter() let mut new_gateway_nodes: Vec<Uuid> = self
.roles
.items()
.iter()
.filter(|(_, _, v)| matches!(v, NodeRoleV(Some(r)) if r.capacity == None)) .filter(|(_, _, v)| matches!(v, NodeRoleV(Some(r)) if r.capacity == None))
.map(|(k, _, _)| *k).collect(); .map(|(k, _, _)| *k)
.collect();
let mut new_node_id_vec = Vec::<Uuid>::new(); let mut new_node_id_vec = Vec::<Uuid>::new();
new_node_id_vec.append(&mut new_non_gateway_nodes); new_node_id_vec.append(&mut new_non_gateway_nodes);
@ -474,15 +517,18 @@ impl ClusterLayout {
//We rewrite the old association with the new indices. We only consider partition //We rewrite the old association with the new indices. We only consider partition
//to node assignations where the node is still in use. //to node assignations where the node is still in use.
let nb_partitions = 1usize << PARTITION_BITS; let nb_partitions = 1usize << PARTITION_BITS;
let mut old_assignation = vec![ Vec::<usize>::new() ; nb_partitions]; let mut old_assignation = vec![Vec::<usize>::new(); nb_partitions];
if self.ring_assignation_data.is_empty() { if self.ring_assignation_data.is_empty() {
//This is a new association //This is a new association
return Ok(None); return Ok(None);
} }
if self.ring_assignation_data.len() != nb_partitions * self.replication_factor { if self.ring_assignation_data.len() != nb_partitions * self.replication_factor {
return Err(Error::Message("The old assignation does not have a size corresponding to \ return Err(Error::Message(
the old replication factor or the number of partitions.".into())); "The old assignation does not have a size corresponding to \
the old replication factor or the number of partitions."
.into(),
));
} }
//We build a translation table between the uuid and new ids //We build a translation table between the uuid and new ids
@ -491,12 +537,12 @@ impl ClusterLayout {
//We add the indices of only the new non-gateway nodes that can be used in the //We add the indices of only the new non-gateway nodes that can be used in the
//association ring //association ring
for (i, uuid) in new_node_id_vec.iter().enumerate() { for (i, uuid) in new_node_id_vec.iter().enumerate() {
uuid_to_new_id.insert(*uuid, i ); uuid_to_new_id.insert(*uuid, i);
} }
let rf= self.replication_factor; let rf = self.replication_factor;
for (p, old_assign_p) in old_assignation.iter_mut().enumerate() { for (p, old_assign_p) in old_assignation.iter_mut().enumerate() {
for old_id in &self.ring_assignation_data[p*rf..(p+1)*rf] { for old_id in &self.ring_assignation_data[p * rf..(p + 1) * rf] {
let uuid = old_node_id_vec[*old_id as usize]; let uuid = old_node_id_vec[*old_id as usize];
if uuid_to_new_id.contains_key(&uuid) { if uuid_to_new_id.contains_key(&uuid) {
old_assign_p.push(uuid_to_new_id[&uuid]); old_assign_p.push(uuid_to_new_id[&uuid]);
@ -508,27 +554,31 @@ impl ClusterLayout {
self.ring_assignation_data = Vec::<CompactNodeType>::new(); self.ring_assignation_data = Vec::<CompactNodeType>::new();
if !self.check() { if !self.check() {
return Err(Error::Message("Critical error: The computed layout happens to be incorrect".into())); return Err(Error::Message(
"Critical error: The computed layout happens to be incorrect".into(),
));
} }
Ok(Some(old_assignation)) Ok(Some(old_assignation))
} }
///This function generates ids for the zone of the nodes appearing in ///This function generates ids for the zone of the nodes appearing in
///self.node_id_vec. ///self.node_id_vec.
fn generate_useful_zone_ids(&self) -> Result<(Vec<String>, HashMap<String, usize>),Error>{ fn generate_useful_zone_ids(&self) -> Result<(Vec<String>, HashMap<String, usize>), Error> {
let mut id_to_zone = Vec::<String>::new(); let mut id_to_zone = Vec::<String>::new();
let mut zone_to_id = HashMap::<String,usize>::new(); let mut zone_to_id = HashMap::<String, usize>::new();
for uuid in self.useful_nodes().iter() { for uuid in self.useful_nodes().iter() {
if self.roles.get(uuid) == None { if self.roles.get(uuid) == None {
return Err(Error::Message("The uuid was not found in the node roles (this should \ return Err(Error::Message(
not happen, it might be a critical error).".into())); "The uuid was not found in the node roles (this should \
not happen, it might be a critical error)."
.into(),
));
} }
if let Some(r) = self.node_role(uuid) { if let Some(r) = self.node_role(uuid) {
if !zone_to_id.contains_key(&r.zone) && r.capacity != None { if !zone_to_id.contains_key(&r.zone) && r.capacity != None {
zone_to_id.insert(r.zone.clone() , id_to_zone.len()); zone_to_id.insert(r.zone.clone(), id_to_zone.len());
id_to_zone.push(r.zone.clone()); id_to_zone.push(r.zone.clone());
} }
} }
@ -538,33 +588,46 @@ impl ClusterLayout {
///This function computes by dichotomy the largest realizable partition size, given ///This function computes by dichotomy the largest realizable partition size, given
///the layout. ///the layout.
fn compute_optimal_partition_size(&self, zone_to_id: &HashMap<String, usize>) -> Result<u32,Error>{ fn compute_optimal_partition_size(
&self,
zone_to_id: &HashMap<String, usize>,
) -> Result<u32, Error> {
let nb_partitions = 1usize << PARTITION_BITS; let nb_partitions = 1usize << PARTITION_BITS;
let empty_set = HashSet::<(usize,usize)>::new(); let empty_set = HashSet::<(usize, usize)>::new();
let mut g = self.generate_flow_graph(1, zone_to_id, &empty_set)?; let mut g = self.generate_flow_graph(1, zone_to_id, &empty_set)?;
g.compute_maximal_flow()?; g.compute_maximal_flow()?;
if g.get_flow_value()? < (nb_partitions*self.replication_factor).try_into().unwrap() { if g.get_flow_value()?
return Err(Error::Message("The storage capacity of he cluster is to small. It is \ < (nb_partitions * self.replication_factor)
impossible to store partitions of size 1.".into())); .try_into()
.unwrap()
{
return Err(Error::Message(
"The storage capacity of he cluster is to small. It is \
impossible to store partitions of size 1."
.into(),
));
} }
let mut s_down = 1; let mut s_down = 1;
let mut s_up = self.get_total_capacity()?; let mut s_up = self.get_total_capacity()?;
while s_down +1 < s_up { while s_down + 1 < s_up {
g = self.generate_flow_graph((s_down+s_up)/2, zone_to_id, &empty_set)?; g = self.generate_flow_graph((s_down + s_up) / 2, zone_to_id, &empty_set)?;
g.compute_maximal_flow()?; g.compute_maximal_flow()?;
if g.get_flow_value()? < (nb_partitions*self.replication_factor).try_into().unwrap() { if g.get_flow_value()?
s_up = (s_down+s_up)/2; < (nb_partitions * self.replication_factor)
} .try_into()
else { .unwrap()
s_down = (s_down+s_up)/2; {
s_up = (s_down + s_up) / 2;
} else {
s_down = (s_down + s_up) / 2;
} }
} }
Ok(s_down) Ok(s_down)
} }
fn generate_graph_vertices(nb_zones : usize, nb_nodes : usize) -> Vec<Vertex> { fn generate_graph_vertices(nb_zones: usize, nb_nodes: usize) -> Vec<Vertex> {
let mut vertices = vec![Vertex::Source, Vertex::Sink]; let mut vertices = vec![Vertex::Source, Vertex::Sink];
for p in 0..NB_PARTITIONS { for p in 0..NB_PARTITIONS {
vertices.push(Vertex::Pup(p)); vertices.push(Vertex::Pup(p));
@ -579,27 +642,39 @@ impl ClusterLayout {
vertices vertices
} }
fn generate_flow_graph(&self, size: u32, zone_to_id: &HashMap<String, usize>, exclude_assoc : &HashSet<(usize,usize)>) -> Result<Graph<FlowEdge>, Error> { fn generate_flow_graph(
let vertices = ClusterLayout::generate_graph_vertices(zone_to_id.len(), &self,
self.useful_nodes().len()); size: u32,
let mut g= Graph::<FlowEdge>::new(&vertices); zone_to_id: &HashMap<String, usize>,
exclude_assoc: &HashSet<(usize, usize)>,
) -> Result<Graph<FlowEdge>, Error> {
let vertices =
ClusterLayout::generate_graph_vertices(zone_to_id.len(), self.useful_nodes().len());
let mut g = Graph::<FlowEdge>::new(&vertices);
let nb_zones = zone_to_id.len(); let nb_zones = zone_to_id.len();
let redundancy = self.staged_parameters.get().zone_redundancy; let redundancy = self.staged_parameters.get().zone_redundancy;
for p in 0..NB_PARTITIONS { for p in 0..NB_PARTITIONS {
g.add_edge(Vertex::Source, Vertex::Pup(p), redundancy as u32)?; g.add_edge(Vertex::Source, Vertex::Pup(p), redundancy as u32)?;
g.add_edge(Vertex::Source, Vertex::Pdown(p), (self.replication_factor - redundancy) as u32)?; g.add_edge(
Vertex::Source,
Vertex::Pdown(p),
(self.replication_factor - redundancy) as u32,
)?;
for z in 0..nb_zones { for z in 0..nb_zones {
g.add_edge(Vertex::Pup(p) , Vertex::PZ(p,z) , 1)?; g.add_edge(Vertex::Pup(p), Vertex::PZ(p, z), 1)?;
g.add_edge(Vertex::Pdown(p) , Vertex::PZ(p,z) , g.add_edge(
self.replication_factor as u32)?; Vertex::Pdown(p),
Vertex::PZ(p, z),
self.replication_factor as u32,
)?;
} }
} }
for n in 0..self.useful_nodes().len() { for n in 0..self.useful_nodes().len() {
let node_capacity = self.get_node_capacity(&self.node_id_vec[n])?; let node_capacity = self.get_node_capacity(&self.node_id_vec[n])?;
let node_zone = zone_to_id[&self.get_node_zone(&self.node_id_vec[n])?]; let node_zone = zone_to_id[&self.get_node_zone(&self.node_id_vec[n])?];
g.add_edge(Vertex::N(n), Vertex::Sink, node_capacity/size)?; g.add_edge(Vertex::N(n), Vertex::Sink, node_capacity / size)?;
for p in 0..NB_PARTITIONS { for p in 0..NB_PARTITIONS {
if !exclude_assoc.contains(&(p,n)) { if !exclude_assoc.contains(&(p, n)) {
g.add_edge(Vertex::PZ(p, node_zone), Vertex::N(n), 1)?; g.add_edge(Vertex::PZ(p, node_zone), Vertex::N(n), 1)?;
} }
} }
@ -607,55 +682,65 @@ impl ClusterLayout {
Ok(g) Ok(g)
} }
fn compute_candidate_assignment(
fn compute_candidate_assignment(&self, zone_to_id: &HashMap<String, usize>, &self,
old_assoc_opt : &Option<Vec< Vec<usize> >>) -> Result<Graph<FlowEdge>, Error > { zone_to_id: &HashMap<String, usize>,
old_assoc_opt: &Option<Vec<Vec<usize>>>,
) -> Result<Graph<FlowEdge>, Error> {
//We list the edges that are not used in the old association //We list the edges that are not used in the old association
let mut exclude_edge = HashSet::<(usize,usize)>::new(); let mut exclude_edge = HashSet::<(usize, usize)>::new();
if let Some(old_assoc) = old_assoc_opt { if let Some(old_assoc) = old_assoc_opt {
let nb_nodes = self.useful_nodes().len(); let nb_nodes = self.useful_nodes().len();
for (p, old_assoc_p) in old_assoc.iter().enumerate() { for (p, old_assoc_p) in old_assoc.iter().enumerate() {
for n in 0..nb_nodes { for n in 0..nb_nodes {
exclude_edge.insert((p,n)); exclude_edge.insert((p, n));
} }
for n in old_assoc_p.iter() { for n in old_assoc_p.iter() {
exclude_edge.remove(&(p,*n)); exclude_edge.remove(&(p, *n));
} }
} }
} }
//We compute the best flow using only the edges used in the old assoc //We compute the best flow using only the edges used in the old assoc
let mut g = self.generate_flow_graph(self.partition_size, zone_to_id, &exclude_edge )?; let mut g = self.generate_flow_graph(self.partition_size, zone_to_id, &exclude_edge)?;
g.compute_maximal_flow()?; g.compute_maximal_flow()?;
for (p,n) in exclude_edge.iter() { for (p, n) in exclude_edge.iter() {
let node_zone = zone_to_id[&self.get_node_zone(&self.node_id_vec[*n])?]; let node_zone = zone_to_id[&self.get_node_zone(&self.node_id_vec[*n])?];
g.add_edge(Vertex::PZ(*p,node_zone), Vertex::N(*n), 1)?; g.add_edge(Vertex::PZ(*p, node_zone), Vertex::N(*n), 1)?;
} }
g.compute_maximal_flow()?; g.compute_maximal_flow()?;
Ok(g) Ok(g)
} }
fn minimize_rebalance_load(&self, gflow: &mut Graph<FlowEdge>, zone_to_id: &HashMap<String, usize>, old_assoc : &[Vec<usize> ]) -> Result<(), Error > { fn minimize_rebalance_load(
&self,
gflow: &mut Graph<FlowEdge>,
zone_to_id: &HashMap<String, usize>,
old_assoc: &[Vec<usize>],
) -> Result<(), Error> {
let mut cost = CostFunction::new(); let mut cost = CostFunction::new();
for (p, assoc_p) in old_assoc.iter().enumerate(){ for (p, assoc_p) in old_assoc.iter().enumerate() {
for n in assoc_p.iter() { for n in assoc_p.iter() {
let node_zone = zone_to_id[&self.get_node_zone(&self.node_id_vec[*n])?]; let node_zone = zone_to_id[&self.get_node_zone(&self.node_id_vec[*n])?];
cost.insert((Vertex::PZ(p,node_zone), Vertex::N(*n)), -1); cost.insert((Vertex::PZ(p, node_zone), Vertex::N(*n)), -1);
} }
} }
let nb_nodes = self.useful_nodes().len(); let nb_nodes = self.useful_nodes().len();
let path_length = 4*nb_nodes; let path_length = 4 * nb_nodes;
gflow.optimize_flow_with_cost(&cost, path_length)?; gflow.optimize_flow_with_cost(&cost, path_length)?;
Ok(()) Ok(())
} }
fn update_ring_from_flow(&mut self, nb_zones : usize, gflow: &Graph<FlowEdge> ) -> Result<(), Error>{ fn update_ring_from_flow(
&mut self,
nb_zones: usize,
gflow: &Graph<FlowEdge>,
) -> Result<(), Error> {
self.ring_assignation_data = Vec::<CompactNodeType>::new(); self.ring_assignation_data = Vec::<CompactNodeType>::new();
for p in 0..NB_PARTITIONS { for p in 0..NB_PARTITIONS {
for z in 0..nb_zones { for z in 0..nb_zones {
let assoc_vertex = gflow.get_positive_flow_from(Vertex::PZ(p,z))?; let assoc_vertex = gflow.get_positive_flow_from(Vertex::PZ(p, z))?;
for vertex in assoc_vertex.iter() { for vertex in assoc_vertex.iter() {
if let Vertex::N(n) = vertex { if let Vertex::N(n) = vertex {
self.ring_assignation_data.push((*n).try_into().unwrap()); self.ring_assignation_data.push((*n).try_into().unwrap());
@ -664,39 +749,51 @@ impl ClusterLayout {
} }
} }
if self.ring_assignation_data.len() != NB_PARTITIONS*self.replication_factor { if self.ring_assignation_data.len() != NB_PARTITIONS * self.replication_factor {
return Err(Error::Message("Critical Error : the association ring we produced does not \ return Err(Error::Message(
have the right size.".into())); "Critical Error : the association ring we produced does not \
have the right size."
.into(),
));
} }
Ok(()) Ok(())
} }
//This function returns a message summing up the partition repartition of the new //This function returns a message summing up the partition repartition of the new
//layout. //layout.
fn output_stat(&self , gflow : &Graph<FlowEdge>, fn output_stat(
old_assoc_opt : &Option< Vec<Vec<usize>> >, &self,
gflow: &Graph<FlowEdge>,
old_assoc_opt: &Option<Vec<Vec<usize>>>,
zone_to_id: &HashMap<String, usize>, zone_to_id: &HashMap<String, usize>,
id_to_zone : &[String]) -> Result<Message, Error>{ id_to_zone: &[String],
) -> Result<Message, Error> {
let mut msg = Message::new(); let mut msg = Message::new();
let nb_partitions = 1usize << PARTITION_BITS; let nb_partitions = 1usize << PARTITION_BITS;
let used_cap = self.partition_size * nb_partitions as u32 * let used_cap = self.partition_size * nb_partitions as u32 * self.replication_factor as u32;
self.replication_factor as u32;
let total_cap = self.get_total_capacity()?; let total_cap = self.get_total_capacity()?;
let percent_cap = 100.0*(used_cap as f32)/(total_cap as f32); let percent_cap = 100.0 * (used_cap as f32) / (total_cap as f32);
msg.push(format!("Available capacity / Total cluster capacity: {} / {} ({:.1} %)", msg.push(format!(
used_cap , total_cap , percent_cap )); "Available capacity / Total cluster capacity: {} / {} ({:.1} %)",
used_cap, total_cap, percent_cap
));
msg.push("".into()); msg.push("".into());
msg.push("If the percentage is to low, it might be that the \ msg.push(
"If the percentage is to low, it might be that the \
replication/redundancy constraints force the use of nodes/zones with small \ replication/redundancy constraints force the use of nodes/zones with small \
storage capacities. \ storage capacities. \
You might want to rebalance the storage capacities or relax the constraints. \ You might want to rebalance the storage capacities or relax the constraints. \
See the detailed statistics below and look for saturated nodes/zones.".into()); See the detailed statistics below and look for saturated nodes/zones."
msg.push(format!("Recall that because of the replication factor, the actual available \ .into(),
);
msg.push(format!(
"Recall that because of the replication factor, the actual available \
storage capacity is {} / {} = {}.", storage capacity is {} / {} = {}.",
used_cap , self.replication_factor , used_cap,
used_cap/self.replication_factor as u32)); self.replication_factor,
used_cap / self.replication_factor as u32
));
//We define and fill in the following tables //We define and fill in the following tables
let storing_nodes = self.useful_nodes(); let storing_nodes = self.useful_nodes();
@ -708,14 +805,14 @@ impl ClusterLayout {
for p in 0..nb_partitions { for p in 0..nb_partitions {
for z in 0..id_to_zone.len() { for z in 0..id_to_zone.len() {
let pz_nodes = gflow.get_positive_flow_from(Vertex::PZ(p,z))?; let pz_nodes = gflow.get_positive_flow_from(Vertex::PZ(p, z))?;
if !pz_nodes.is_empty() { if !pz_nodes.is_empty() {
stored_partitions_zone[z] += 1; stored_partitions_zone[z] += 1;
if let Some(old_assoc) = old_assoc_opt { if let Some(old_assoc) = old_assoc_opt {
let mut old_zones_of_p = Vec::<usize>::new(); let mut old_zones_of_p = Vec::<usize>::new();
for n in old_assoc[p].iter() { for n in old_assoc[p].iter() {
old_zones_of_p.push( old_zones_of_p
zone_to_id[&self.get_node_zone(&self.node_id_vec[*n])?]); .push(zone_to_id[&self.get_node_zone(&self.node_id_vec[*n])?]);
} }
if !old_zones_of_p.contains(&z) { if !old_zones_of_p.contains(&z) {
new_partitions_zone[z] += 1; new_partitions_zone[z] += 1;
@ -744,65 +841,81 @@ impl ClusterLayout {
msg.push("".into()); msg.push("".into());
if *old_assoc_opt != None { if *old_assoc_opt != None {
let total_new_partitions : usize = new_partitions.iter().sum(); let total_new_partitions: usize = new_partitions.iter().sum();
msg.push(format!("A total of {} new copies of partitions need to be \ msg.push(format!(
transferred.", total_new_partitions)); "A total of {} new copies of partitions need to be \
transferred.",
total_new_partitions
));
} }
msg.push("".into()); msg.push("".into());
msg.push("==== DETAILED STATISTICS BY ZONES AND NODES ====".into()); msg.push("==== DETAILED STATISTICS BY ZONES AND NODES ====".into());
for z in 0..id_to_zone.len(){ for z in 0..id_to_zone.len() {
let mut nodes_of_z = Vec::<usize>::new(); let mut nodes_of_z = Vec::<usize>::new();
for n in 0..storing_nodes.len(){ for n in 0..storing_nodes.len() {
if self.get_node_zone(&self.node_id_vec[n])? == id_to_zone[z] { if self.get_node_zone(&self.node_id_vec[n])? == id_to_zone[z] {
nodes_of_z.push(n); nodes_of_z.push(n);
} }
} }
let replicated_partitions : usize = nodes_of_z.iter() let replicated_partitions: usize =
.map(|n| stored_partitions[*n]).sum(); nodes_of_z.iter().map(|n| stored_partitions[*n]).sum();
msg.push("".into()); msg.push("".into());
msg.push(format!("Zone {}: {} distinct partitions stored ({} new, \ msg.push(format!(
{} partition copies) ", id_to_zone[z], stored_partitions_zone[z], "Zone {}: {} distinct partitions stored ({} new, \
new_partitions_zone[z], replicated_partitions)); {} partition copies) ",
id_to_zone[z],
stored_partitions_zone[z],
new_partitions_zone[z],
replicated_partitions
));
let available_cap_z : u32 = self.partition_size*replicated_partitions as u32; let available_cap_z: u32 = self.partition_size * replicated_partitions as u32;
let mut total_cap_z = 0; let mut total_cap_z = 0;
for n in nodes_of_z.iter() { for n in nodes_of_z.iter() {
total_cap_z += self.get_node_capacity(&self.node_id_vec[*n])?; total_cap_z += self.get_node_capacity(&self.node_id_vec[*n])?;
} }
let percent_cap_z = 100.0*(available_cap_z as f32)/(total_cap_z as f32); let percent_cap_z = 100.0 * (available_cap_z as f32) / (total_cap_z as f32);
msg.push(format!(" Available capacity / Total capacity: {}/{} ({:.1}%).", msg.push(format!(
available_cap_z, total_cap_z, percent_cap_z)); " Available capacity / Total capacity: {}/{} ({:.1}%).",
available_cap_z, total_cap_z, percent_cap_z
));
for n in nodes_of_z.iter() { for n in nodes_of_z.iter() {
let available_cap_n = stored_partitions[*n] as u32 *self.partition_size; let available_cap_n = stored_partitions[*n] as u32 * self.partition_size;
let total_cap_n =self.get_node_capacity(&self.node_id_vec[*n])?; let total_cap_n = self.get_node_capacity(&self.node_id_vec[*n])?;
let tags_n = (self.node_role(&self.node_id_vec[*n]) let tags_n = (self
.ok_or("Node not found."))?.tags_string(); .node_role(&self.node_id_vec[*n])
msg.push(format!(" Node {}: {} partitions ({} new) ; \ .ok_or("Node not found."))?
.tags_string();
msg.push(format!(
" Node {}: {} partitions ({} new) ; \
available/total capacity: {} / {} ({:.1}%) ; tags:{}", available/total capacity: {} / {} ({:.1}%) ; tags:{}",
&self.node_id_vec[*n].to_vec()[0..2].to_vec().encode_hex::<String>(), &self.node_id_vec[*n].to_vec()[0..2]
.to_vec()
.encode_hex::<String>(),
stored_partitions[*n], stored_partitions[*n],
new_partitions[*n], available_cap_n, total_cap_n, new_partitions[*n],
(available_cap_n as f32)/(total_cap_n as f32)*100.0 , available_cap_n,
tags_n)); total_cap_n,
(available_cap_n as f32) / (total_cap_n as f32) * 100.0,
tags_n
));
} }
} }
Ok(msg) Ok(msg)
} }
} }
//==================================================================================== //====================================================================================
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::{*,Error}; use super::{Error, *};
use std::cmp::min; use std::cmp::min;
//This function checks that the partition size S computed is at least better than the //This function checks that the partition size S computed is at least better than the
//one given by a very naive algorithm. To do so, we try to run the naive algorithm //one given by a very naive algorithm. To do so, we try to run the naive algorithm
//assuming a partion size of S+1. If we succed, it means that the optimal assignation //assuming a partion size of S+1. If we succed, it means that the optimal assignation
@ -817,8 +930,8 @@ mod tests {
//number of tokens by zone : (A, 4), (B,1), (C,4), (D, 4), (E, 2) //number of tokens by zone : (A, 4), (B,1), (C,4), (D, 4), (E, 2)
//With these parameters, the naive algo fails, whereas there is a solution: //With these parameters, the naive algo fails, whereas there is a solution:
//(A,A,C,D,E) , (A,B,C,D,D) (A,C,C,D,E) //(A,A,C,D,E) , (A,B,C,D,D) (A,C,C,D,E)
fn check_against_naive(cl: &ClusterLayout) -> Result<bool,Error> { fn check_against_naive(cl: &ClusterLayout) -> Result<bool, Error> {
let over_size = cl.partition_size +1; let over_size = cl.partition_size + 1;
let mut zone_token = HashMap::<String, usize>::new(); let mut zone_token = HashMap::<String, usize>::new();
let nb_partitions = 1usize << PARTITION_BITS; let nb_partitions = 1usize << PARTITION_BITS;
@ -834,14 +947,17 @@ mod tests {
for uuid in cl.useful_nodes().iter() { for uuid in cl.useful_nodes().iter() {
let z = cl.get_node_zone(uuid)?; let z = cl.get_node_zone(uuid)?;
let c = cl.get_node_capacity(uuid)?; let c = cl.get_node_capacity(uuid)?;
zone_token.insert(z.clone(), zone_token[&z] + min(nb_partitions , (c/over_size) as usize)); zone_token.insert(
z.clone(),
zone_token[&z] + min(nb_partitions, (c / over_size) as usize),
);
} }
//For every partition, we count the number of zone already associated and //For every partition, we count the number of zone already associated and
//the name of the last zone associated //the name of the last zone associated
let mut id_zone_token = vec![0; zones.len()]; let mut id_zone_token = vec![0; zones.len()];
for (z,t) in zone_token.iter() { for (z, t) in zone_token.iter() {
id_zone_token[zone_to_id[z]] = *t; id_zone_token[zone_to_id[z]] = *t;
} }
@ -854,9 +970,10 @@ mod tests {
for replic in 0..cl.replication_factor { for replic in 0..cl.replication_factor {
for p in 0..nb_partitions { for p in 0..nb_partitions {
while id_zone_token[curr_zone] == 0 || while id_zone_token[curr_zone] == 0
(last_zone[p] == curr_zone || (last_zone[p] == curr_zone
&& redundancy - nb_token[p] <= cl.replication_factor - replic) { && redundancy - nb_token[p] <= cl.replication_factor - replic)
{
curr_zone += 1; curr_zone += 1;
if curr_zone >= zones.len() { if curr_zone >= zones.len() {
return Ok(true); return Ok(true);
@ -873,9 +990,9 @@ mod tests {
return Ok(false); return Ok(false);
} }
fn show_msg(msg : &Message) { fn show_msg(msg: &Message) {
for s in msg.iter(){ for s in msg.iter() {
println!("{}",s); println!("{}", s);
} }
} }
@ -884,7 +1001,7 @@ mod tests {
node_id_vec: &Vec<u8>, node_id_vec: &Vec<u8>,
node_capacity_vec: &Vec<u32>, node_capacity_vec: &Vec<u32>,
node_zone_vec: &Vec<String>, node_zone_vec: &Vec<String>,
zone_redundancy: usize zone_redundancy: usize,
) { ) {
for i in 0..node_id_vec.len() { for i in 0..node_id_vec.len() {
if let Some(x) = FixedBytes32::try_from(&[i as u8; 32]) { if let Some(x) = FixedBytes32::try_from(&[i as u8; 32]) {
@ -901,7 +1018,7 @@ mod tests {
); );
cl.roles.merge(&update); cl.roles.merge(&update);
} }
cl.staged_parameters = Lww::<LayoutParameters>::new(LayoutParameters{zone_redundancy}); cl.staged_parameters = Lww::<LayoutParameters>::new(LayoutParameters { zone_redundancy });
} }
#[test] #[test]
@ -936,11 +1053,12 @@ mod tests {
assert!(cl.check()); assert!(cl.check());
assert!(matches!(check_against_naive(&cl), Ok(true))); assert!(matches!(check_against_naive(&cl), Ok(true)));
node_capacity_vec = vec![4000000, 4000000, 2000000, 7000000, 1000000, 9000000, 2000000, 10000, 2000000]; node_capacity_vec = vec![
4000000, 4000000, 2000000, 7000000, 1000000, 9000000, 2000000, 10000, 2000000,
];
update_layout(&mut cl, &node_id_vec, &node_capacity_vec, &node_zone_vec, 1); update_layout(&mut cl, &node_id_vec, &node_capacity_vec, &node_zone_vec, 1);
show_msg(&cl.calculate_partition_assignation().unwrap()); show_msg(&cl.calculate_partition_assignation().unwrap());
assert!(cl.check()); assert!(cl.check());
assert!(matches!(check_against_naive(&cl), Ok(true))); assert!(matches!(check_against_naive(&cl), Ok(true)));
} }
} }

View file

@ -7,12 +7,11 @@ mod consul;
#[cfg(feature = "kubernetes-discovery")] #[cfg(feature = "kubernetes-discovery")]
mod kubernetes; mod kubernetes;
pub mod layout;
pub mod graph_algo; pub mod graph_algo;
pub mod layout;
pub mod ring; pub mod ring;
pub mod system; pub mod system;
mod metrics; mod metrics;
pub mod rpc_helper; pub mod rpc_helper;

View file

@ -565,7 +565,6 @@ impl System {
return Err(Error::Message(msg)); return Err(Error::Message(msg));
} }
let update_ring = self.update_ring.lock().await; let update_ring = self.update_ring.lock().await;
let mut layout: ClusterLayout = self.ring.borrow().layout.clone(); let mut layout: ClusterLayout = self.ring.borrow().layout.clone();