cargo fmt

src/db/lib.rs

@@ -4,7 +4,6 @@ extern crate tracing;
 
 #[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.");
-
 #[cfg(feature = "lmdb")]
 pub mod lmdb_adapter;
 #[cfg(feature = "sled")]

src/garage/cli/layout.rs

@@ -190,7 +190,10 @@ pub async fn cmd_show_layout(
 		println!();
 
 		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!();
 
 		// this will print the stats of what partitions
@@ -206,11 +209,15 @@ pub async fn cmd_show_layout(
 				println!();
 				println!(
                     "You can also revert all proposed changes with: garage layout revert --version {}",
-                    layout.version + 1)},
+                    layout.version + 1)
+			}
 			Err(Error::Message(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 => (),
 		Some(r) => {
 			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.");
-            }
+			} 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);
 			}
 		}

src/garage/cli/structs.rs

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

src/rpc/graph_algo.rs

@@ -1,11 +1,10 @@
-
 //! This module deals with graph algorithms.
 //! It is used in layout.rs to build the partition to node assignation.
 
 use rand::prelude::SliceRandom;
 use std::cmp::{max, min};
-use std::collections::VecDeque;
 use std::collections::HashMap;
+use std::collections::VecDeque;
 
 //Vertex data structures used in all the graphs used in layout.rs.
 //usize parameters correspond to node/zone/partitions ids.
@@ -18,10 +17,9 @@ pub enum Vertex{
 	Pdown(usize),     //The vertex p- of partition p
 	PZ(usize, usize), //The vertex corresponding to x_(partition p, zone z)
 	N(usize),         //The vertex corresponding to node n
-    Sink
+	Sink,
 }
 
-
 //Edge data structure for the flow algorithm.
 //The graph is stored as an adjacency list
 #[derive(Clone, Copy, Debug)]
@@ -51,7 +49,7 @@ pub struct Graph<E : Edge>{
 	vertextoid: HashMap<Vertex, usize>,
 	idtovertex: Vec<Vertex>,
 
-    graph : Vec< Vec<E> >
+	graph: Vec<Vec<E>>,
 }
 
 pub type CostFunction = HashMap<(Vertex, Vertex), i32>;
@@ -65,7 +63,7 @@ impl<E : Edge> Graph<E>{
 		Graph::<E> {
 			vertextoid: map,
 			idtovertex: vertices.to_vec(),
-                graph : vec![Vec::< E >::new(); vertices.len() ]
+			graph: vec![Vec::<E>::new(); vertices.len()],
 		}
 	}
 }
@@ -81,8 +79,18 @@ impl Graph<FlowEdge>{
 		let idv = self.vertextoid[&v];
 		let rev_u = self.graph[idu].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(())
 	}
 
@@ -102,7 +110,6 @@ impl Graph<FlowEdge>{
 		Ok(result)
 	}
 
-    
 	//This function returns the value of the flow incoming to v.
 	pub fn get_inflow(&self, v: Vertex) -> Result<i32, String> {
 		if !self.vertextoid.contains_key(&v) {
@@ -192,7 +199,8 @@ impl Graph<FlowEdge>{
 			fifo.push_back((idsource, 0));
 			while !fifo.is_empty() {
 				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);
 						for edge in self.graph[id].iter() {
 							if edge.cap as i32 - edge.flow > 0 {
@@ -240,13 +248,15 @@ impl Graph<FlowEdge>{
 					continue;
 				}
 				//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 {
 					next_nbd[id] += 1;
 					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 {
 						//We cannot send flow to nbd.
 						next_nbd[id] += 1;
@@ -265,8 +275,11 @@ impl Graph<FlowEdge>{
 	// 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
 	// 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
 		let mut gf = self.build_cost_graph(cost)?;
 		let mut cycles = gf.list_negative_cycles(path_length);
@@ -298,7 +311,6 @@ impl Graph<FlowEdge>{
 
 	//Construct the weighted graph G_f from the flow and the cost function
 	fn build_cost_graph(&self, cost: &CostFunction) -> Result<Graph<WeightedEdge>, String> {
-        
 		let mut g = Graph::<WeightedEdge>::new(&self.idtovertex);
 		let nb_vertices = self.idtovertex.len();
 		for i in 0..nb_vertices {
@@ -309,21 +321,16 @@ impl Graph<FlowEdge>{
 					let v = self.idtovertex[edge.dest];
 					if cost.contains_key(&(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)])?;
-                    }
+					} else {
-                    else{
 						g.add_edge(u, v, 0)?;
 					}
 				}
 			}
 		}
 		Ok(g)
-
 	}
-
-
 }
 
 impl Graph<WeightedEdge> {
@@ -345,7 +352,6 @@ impl Graph<WeightedEdge>{
 	//when path_length is the length of the longest possible simple path.
 	//See the formal description of the algorithm for more details.
 	fn list_negative_cycles(&self, path_length: usize) -> Vec<Vec<Vertex>> {
-        
 		let nb_vertices = self.graph.len();
 
 		//We start with every vertex at distance 0 of some imaginary extra -1 vertex.
@@ -364,7 +370,6 @@ impl Graph<WeightedEdge>{
 			}
 		}
 
-
 		//If self.graph contains a negative cycle, then at this point the graph described
 		//by prev (which is a directed 1-forest/functional graph)
 		//must contain a cycle. We list the cycles of prev.
@@ -372,18 +377,17 @@ impl Graph<WeightedEdge>{
 
 		//Remark that the cycle in prev is in the reverse order compared to the cycle
 		//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
 //check for the consistency of the input.
 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()];
 
 	for t in 0..forest.len() {
@@ -393,8 +397,7 @@ fn cycles_of_1_forest(forest: &[Option<usize>])  -> Vec<Vec<usize>> {
 			time_of_discovery[id] = Some(t);
 			if let Some(i) = forest[id] {
 				id = i;
-            }
+			} else {
-            else{
 				break;
 			}
 		}
@@ -407,8 +410,7 @@ fn cycles_of_1_forest(forest: &[Option<usize>])  -> Vec<Vec<usize>> {
 				id2 = id_next;
 				if id2 != id {
 					cy.push(id2);
-                }
+				} else {
-                else {
 					break;
 				}
 			}
@@ -417,5 +419,3 @@ fn cycles_of_1_forest(forest: &[Option<usize>])  -> Vec<Vec<usize>> {
 	}
 	cycles
 }
-
-

src/rpc/layout.rs

@@ -7,7 +7,7 @@ use itertools::Itertools;
 
 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::error::*;
 
@@ -99,7 +99,7 @@ impl NodeRole {
 	pub fn tags_string(&self) -> String {
 		let mut tags = String::new();
 		if self.tags.is_empty() {
-            return tags
+			return tags;
 		}
 		tags.push_str(&self.tags[0].clone());
 		for t in 1..self.tags.len() {
@@ -112,10 +112,11 @@ impl NodeRole {
 
 impl ClusterLayout {
 	pub fn new(replication_factor: usize) -> Self {
-        
 		//We set the default zone redundancy to be equal to the replication factor,
 		//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 empty_lwwmap = LwwMap::new();
@@ -146,7 +147,6 @@ impl ClusterLayout {
 				self.staged_parameters.merge(&other.staged_parameters);
 				self.staging.merge(&other.staging);
 
-
 				let new_staging_hash = blake2sum(&rmp_to_vec_all_named(&self.staging).unwrap()[..]);
 				let stage_changed = new_staging_hash != self.staging_hash;
 
@@ -235,7 +235,7 @@ To know the correct value of the new layout version, invoke `garage layout show`
 		for uuid in self.node_id_vec.iter() {
 			match self.node_role(uuid) {
 				Some(role) if role.capacity != None => result.push(*uuid),
-                _ => ()
+				_ => (),
 			}
 		}
 		result
@@ -245,16 +245,25 @@ To know the correct value of the new layout version, invoke `garage layout show`
 	pub fn get_node_zone(&self, uuid: &Uuid) -> Result<String, Error> {
 		match self.node_role(uuid) {
 			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
 	pub fn get_node_capacity(&self, uuid: &Uuid) -> Result<u32, Error> {
 		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(),
+			)),
 		}
 	}
 
@@ -267,7 +276,6 @@ To know the correct value of the new layout version, invoke `garage layout show`
 		Ok(total_capacity)
 	}
 
-
 	/// Check a cluster layout for internal consistency
 	/// returns true if consistent, false if error
 	pub fn check(&self) -> bool {
@@ -319,9 +327,10 @@ To know the correct value of the new layout version, invoke `garage layout show`
 				return false;
 			}
 			//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;
 			if zones_of_p.unique().count() < redundancy {
 				return false;
@@ -336,8 +345,9 @@ To know the correct value of the new layout version, invoke `garage layout show`
 		for (n, usage) in node_usage.iter().enumerate() {
 			if *usage > 0 {
 				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;
 				}
 			}
@@ -347,15 +357,15 @@ To know the correct value of the new layout version, invoke `garage layout show`
 		//algorithm.
 		let cl2 = self.clone();
 		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 {
 			return false;
 		}
 
-
 		true
 	}
-
 }
 
 impl ClusterLayout {
@@ -378,27 +388,37 @@ impl ClusterLayout {
 
 		let redundancy = self.staged_parameters.get().zone_redundancy;
 
-
 		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,
 		//to use them as indices in the flow graphs.
 		let (id_to_zone, zone_to_id) = self.generate_useful_zone_ids()?;
 
 		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.",
+			nb_useful_nodes,
+			id_to_zone.len()
+		));
 		if nb_useful_nodes < self.replication_factor {
-            return Err(Error::Message(format!("The number of nodes with positive \
+			return Err(Error::Message(format!(
+				"The number of nodes with positive \
             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 {
-            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 ({})",
-            id_to_zone.len() , redundancy)));
+				id_to_zone.len(),
+				redundancy
+			)));
 		}
 
 		//We compute the optimal partition size
@@ -408,21 +428,28 @@ impl ClusterLayout {
 		let partition_size = self.compute_optimal_partition_size(&zone_to_id)?;
 
 		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 \
-                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.parameters = self.staged_parameters.get().clone();
 
 		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
@@ -433,7 +460,12 @@ impl ClusterLayout {
 			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());
 
 		//We update the layout structure
@@ -450,18 +482,29 @@ impl ClusterLayout {
 		// (1) We compute the new node list
 		//Non gateway nodes should be coded on 8bits, hence they must be first in the list
 		//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))
-            .map(|(k, _, _)| *k).collect();
+			.map(|(k, _, _)| *k)
+			.collect();
 
 		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))
-            .map(|(k, _, _)| *k).collect();
+			.map(|(k, _, _)| *k)
+			.collect();
 
 		let mut new_node_id_vec = Vec::<Uuid>::new();
 		new_node_id_vec.append(&mut new_non_gateway_nodes);
@@ -481,8 +524,11 @@ impl ClusterLayout {
 			return Ok(None);
 		}
 		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
@@ -508,13 +554,14 @@ impl ClusterLayout {
 		self.ring_assignation_data = Vec::<CompactNodeType>::new();
 
 		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))
 	}
 
-
 	///This function generates ids for the zone of the nodes appearing in
 	///self.node_id_vec.
 	fn generate_useful_zone_ids(&self) -> Result<(Vec<String>, HashMap<String, usize>), Error> {
@@ -523,8 +570,11 @@ impl ClusterLayout {
 
 		for uuid in self.useful_nodes().iter() {
 			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 !zone_to_id.contains_key(&r.zone) && r.capacity != None {
@@ -538,14 +588,24 @@ impl ClusterLayout {
 
 	///This function computes by dichotomy the largest realizable partition size, given
 	///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 empty_set = HashSet::<(usize, usize)>::new();
 		let mut g = self.generate_flow_graph(1, zone_to_id, &empty_set)?;
 		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;
@@ -553,10 +613,13 @@ impl ClusterLayout {
 		while s_down + 1 < s_up {
 			g = self.generate_flow_graph((s_down + s_up) / 2, zone_to_id, &empty_set)?;
 			g.compute_maximal_flow()?;
-            if g.get_flow_value()? < (nb_partitions*self.replication_factor).try_into().unwrap() {
+			if g.get_flow_value()?
+				< (nb_partitions * self.replication_factor)
+					.try_into()
+					.unwrap()
+			{
 				s_up = (s_down + s_up) / 2;
-            }
+			} else {
-            else {
 				s_down = (s_down + s_up) / 2;
 			}
 		}
@@ -579,19 +642,31 @@ impl ClusterLayout {
 		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,
+		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 redundancy = self.staged_parameters.get().zone_redundancy;
 		for p in 0..NB_PARTITIONS {
 			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 {
 				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() {
@@ -607,10 +682,11 @@ impl ClusterLayout {
 		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
 		let mut exclude_edge = HashSet::<(usize, usize)>::new();
 		if let Some(old_assoc) = old_assoc_opt {
@@ -636,7 +712,12 @@ impl ClusterLayout {
 		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();
 		for (p, assoc_p) in old_assoc.iter().enumerate() {
 			for n in assoc_p.iter() {
@@ -651,7 +732,11 @@ impl ClusterLayout {
 		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();
 		for p in 0..NB_PARTITIONS {
 			for z in 0..nb_zones {
@@ -665,38 +750,50 @@ impl ClusterLayout {
 		}
 
 		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(())
 	}
 
-
 	//This function returns a message summing up the partition repartition of the new
 	//layout.
-    fn output_stat(&self , gflow : &Graph<FlowEdge>, 
+	fn output_stat(
+		&self,
+		gflow: &Graph<FlowEdge>,
 		old_assoc_opt: &Option<Vec<Vec<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 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 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("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 \
         storage capacities. \
         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 {} / {} = {}.",
-                        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
 		let storing_nodes = self.useful_nodes();
@@ -714,8 +811,8 @@ impl ClusterLayout {
 					if let Some(old_assoc) = old_assoc_opt {
 						let mut old_zones_of_p = Vec::<usize>::new();
 						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) {
 							new_partitions_zone[z] += 1;
@@ -745,8 +842,11 @@ impl ClusterLayout {
 		msg.push("".into());
 		if *old_assoc_opt != None {
 			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("==== DETAILED STATISTICS BY ZONES AND NODES ====".into());
@@ -758,13 +858,18 @@ impl ClusterLayout {
 					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(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 mut total_cap_z = 0;
@@ -772,37 +877,45 @@ impl ClusterLayout {
 				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);
-            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() {
 				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 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:{}",
-                        &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],
-                        new_partitions[*n], available_cap_n, total_cap_n,
+					new_partitions[*n],
+					available_cap_n,
+					total_cap_n,
 					(available_cap_n as f32) / (total_cap_n as f32) * 100.0,
-                        tags_n));
+					tags_n
+				));
 			}
 		}
 
 		Ok(msg)
 	}
-    
 }
 
 //====================================================================================
 
 #[cfg(test)]
 mod tests {
-	use super::{*,Error};
+	use super::{Error, *};
 	use std::cmp::min;
 
-
 	//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
 	//assuming a partion size of S+1. If we succed, it means that the optimal assignation
@@ -834,7 +947,10 @@ mod tests {
 		for uuid in cl.useful_nodes().iter() {
 			let z = cl.get_node_zone(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
@@ -854,9 +970,10 @@ mod tests {
 
 		for replic in 0..cl.replication_factor {
 			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;
 					if curr_zone >= zones.len() {
 						return Ok(true);
@@ -884,7 +1001,7 @@ mod tests {
 		node_id_vec: &Vec<u8>,
 		node_capacity_vec: &Vec<u32>,
 		node_zone_vec: &Vec<String>,
-        zone_redundancy: usize
+		zone_redundancy: usize,
 	) {
 		for i in 0..node_id_vec.len() {
 			if let Some(x) = FixedBytes32::try_from(&[i as u8; 32]) {
@@ -936,11 +1053,12 @@ mod tests {
 		assert!(cl.check());
 		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);
 		show_msg(&cl.calculate_partition_assignation().unwrap());
 		assert!(cl.check());
 		assert!(matches!(check_against_naive(&cl), Ok(true)));
-
 	}
 }

src/rpc/lib.rs

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

src/rpc/system.rs

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