Merge commit 'ec12d6c' into next

1 files changed, 133 insertions, 43 deletions

diff --git a/src/garage/cli/layout.rs b/src/garage/cli/layout.rs
index 3884bb92..27bb7eb8 100644
--- a/src/garage/cli/layout.rs
+++ b/src/garage/cli/layout.rs
@@ -1,3 +1,5 @@
+use bytesize::ByteSize;
+
 use garage_util::crdt::Crdt;
 use garage_util::error::*;
 use garage_util::formater::format_table;
@@ -14,8 +16,8 @@ pub async fn cli_layout_command_dispatch(
 	rpc_host: NodeID,
 ) -> Result<(), Error> {
 	match cmd {
-		LayoutOperation::Assign(configure_opt) => {
-			cmd_assign_role(system_rpc_endpoint, rpc_host, configure_opt).await
+		LayoutOperation::Assign(assign_opt) => {
+			cmd_assign_role(system_rpc_endpoint, rpc_host, assign_opt).await
 		}
 		LayoutOperation::Remove(remove_opt) => {
 			cmd_remove_role(system_rpc_endpoint, rpc_host, remove_opt).await
@@ -27,6 +29,9 @@ pub async fn cli_layout_command_dispatch(
 		LayoutOperation::Revert(revert_opt) => {
 			cmd_revert_layout(system_rpc_endpoint, rpc_host, revert_opt).await
 		}
+		LayoutOperation::Config(config_opt) => {
+			cmd_config_layout(system_rpc_endpoint, rpc_host, config_opt).await
+		}
 	}
 }
 
@@ -60,14 +65,14 @@ pub async fn cmd_assign_role(
 		.collect::<Result<Vec<_>, _>>()?;
 
 	let mut roles = layout.roles.clone();
-	roles.merge(&layout.staging);
+	roles.merge(&layout.staging_roles);
 
 	for replaced in args.replace.iter() {
 		let replaced_node = find_matching_node(layout.node_ids().iter().cloned(), replaced)?;
 		match roles.get(&replaced_node) {
 			Some(NodeRoleV(Some(_))) => {
 				layout
-					.staging
+					.staging_roles
 					.merge(&roles.update_mutator(replaced_node, NodeRoleV(None)));
 			}
 			_ => {
@@ -83,7 +88,7 @@ pub async fn cmd_assign_role(
 		return Err(Error::Message(
 				"-c and -g are mutually exclusive, please configure node either with c>0 to act as a storage node or with -g to act as a gateway node".into()));
 	}
-	if args.capacity == Some(0) {
+	if args.capacity == Some(ByteSize::b(0)) {
 		return Err(Error::Message("Invalid capacity value: 0".into()));
 	}
 
@@ -91,7 +96,7 @@ pub async fn cmd_assign_role(
 		let new_entry = match roles.get(&added_node) {
 			Some(NodeRoleV(Some(old))) => {
 				let capacity = match args.capacity {
-					Some(c) => Some(c),
+					Some(c) => Some(c.as_u64()),
 					None if args.gateway => None,
 					None => old.capacity,
 				};
@@ -108,7 +113,7 @@ pub async fn cmd_assign_role(
 			}
 			_ => {
 				let capacity = match args.capacity {
-					Some(c) => Some(c),
+					Some(c) => Some(c.as_u64()),
 					None if args.gateway => None,
 					None => return Err(Error::Message(
 							"Please specify a capacity with the -c flag, or set node explicitly as gateway with -g".into())),
@@ -125,7 +130,7 @@ pub async fn cmd_assign_role(
 		};
 
 		layout
-			.staging
+			.staging_roles
 			.merge(&roles.update_mutator(added_node, NodeRoleV(Some(new_entry))));
 	}
 
@@ -145,13 +150,13 @@ pub async fn cmd_remove_role(
 	let mut layout = fetch_layout(rpc_cli, rpc_host).await?;
 
 	let mut roles = layout.roles.clone();
-	roles.merge(&layout.staging);
+	roles.merge(&layout.staging_roles);
 
 	let deleted_node =
 		find_matching_node(roles.items().iter().map(|(id, _, _)| *id), &args.node_id)?;
 
 	layout
-		.staging
+		.staging_roles
 		.merge(&roles.update_mutator(deleted_node, NodeRoleV(None)));
 
 	send_layout(rpc_cli, rpc_host, layout).await?;
@@ -166,7 +171,7 @@ pub async fn cmd_show_layout(
 	rpc_cli: &Endpoint<SystemRpc, ()>,
 	rpc_host: NodeID,
 ) -> Result<(), Error> {
-	let mut layout = fetch_layout(rpc_cli, rpc_host).await?;
+	let layout = fetch_layout(rpc_cli, rpc_host).await?;
 
 	println!("==== CURRENT CLUSTER LAYOUT ====");
 	if !print_cluster_layout(&layout) {
@@ -176,30 +181,41 @@ pub async fn cmd_show_layout(
 	println!();
 	println!("Current cluster layout version: {}", layout.version);
 
-	if print_staging_role_changes(&layout) {
-		layout.roles.merge(&layout.staging);
-
-		println!();
-		println!("==== NEW CLUSTER LAYOUT AFTER APPLYING CHANGES ====");
-		if !print_cluster_layout(&layout) {
-			println!("No nodes have a role in the new layout.");
-		}
-		println!();
+	let has_role_changes = print_staging_role_changes(&layout);
+	let has_param_changes = print_staging_parameters_changes(&layout);
+	if has_role_changes || has_param_changes {
+		let v = layout.version;
+		let res_apply = layout.apply_staged_changes(Some(v + 1));
 
 		// this will print the stats of what partitions
 		// will move around when we apply
-		if layout.calculate_partition_assignation() {
-			println!("To enact the staged role changes, type:");
-			println!();
-			println!("    garage layout apply --version {}", layout.version + 1);
-			println!();
-			println!(
-				"You can also revert all proposed changes with: garage layout revert --version {}",
-				layout.version + 1
-			);
-		} else {
-			println!("Not enough nodes have an assigned role to maintain enough copies of data.");
-			println!("This new layout cannot yet be applied.");
+		match res_apply {
+			Ok((layout, msg)) => {
+				println!();
+				println!("==== NEW CLUSTER LAYOUT AFTER APPLYING CHANGES ====");
+				if !print_cluster_layout(&layout) {
+					println!("No nodes have a role in the new layout.");
+				}
+				println!();
+
+				for line in msg.iter() {
+					println!("{}", line);
+				}
+				println!("To enact the staged role changes, type:");
+				println!();
+				println!("    garage layout apply --version {}", v + 1);
+				println!();
+				println!(
+                    "You can also revert all proposed changes with: garage layout revert --version {}",
+                    v + 1)
+			}
+			Err(e) => {
+				println!("Error while trying to compute the assignation: {}", e);
+				println!("This new layout cannot yet be applied.");
+				println!(
+                    "You can also revert all proposed changes with: garage layout revert --version {}",
+                    v + 1)
+			}
 		}
 	}
 
@@ -213,7 +229,10 @@ pub async fn cmd_apply_layout(
 ) -> Result<(), Error> {
 	let layout = fetch_layout(rpc_cli, rpc_host).await?;
 
-	let layout = layout.apply_staged_changes(apply_opt.version)?;
+	let (layout, msg) = layout.apply_staged_changes(apply_opt.version)?;
+	for line in msg.iter() {
+		println!("{}", line);
+	}
 
 	send_layout(rpc_cli, rpc_host, layout).await?;
 
@@ -238,6 +257,45 @@ pub async fn cmd_revert_layout(
 	Ok(())
 }
 
+pub async fn cmd_config_layout(
+	rpc_cli: &Endpoint<SystemRpc, ()>,
+	rpc_host: NodeID,
+	config_opt: ConfigLayoutOpt,
+) -> Result<(), Error> {
+	let mut layout = fetch_layout(rpc_cli, rpc_host).await?;
+
+	let mut did_something = false;
+	match config_opt.redundancy {
+		None => (),
+		Some(r) => {
+			if r > layout.replication_factor {
+				println!(
+					"The zone redundancy must be smaller or equal to the \
+                replication factor ({}).",
+					layout.replication_factor
+				);
+			} else if r < 1 {
+				println!("The zone redundancy must be at least 1.");
+			} else {
+				layout
+					.staging_parameters
+					.update(LayoutParameters { zone_redundancy: r });
+				println!("The new zone redundancy has been saved ({}).", r);
+			}
+			did_something = true;
+		}
+	}
+
+	if !did_something {
+		return Err(Error::Message(
+			"Please specify an action for `garage layout config` to do".into(),
+		));
+	}
+
+	send_layout(rpc_cli, rpc_host, layout).await?;
+	Ok(())
+}
+
 // --- utility ---
 
 pub async fn fetch_layout(
@@ -269,21 +327,39 @@ pub async fn send_layout(
 }
 
 pub fn print_cluster_layout(layout: &ClusterLayout) -> bool {
-	let mut table = vec!["ID\tTags\tZone\tCapacity".to_string()];
+	let mut table = vec!["ID\tTags\tZone\tCapacity\tUsable capacity".to_string()];
 	for (id, _, role) in layout.roles.items().iter() {
 		let role = match &role.0 {
 			Some(r) => r,
 			_ => continue,
 		};
 		let tags = role.tags.join(",");
-		table.push(format!(
-			"{:?}\t{}\t{}\t{}",
-			id,
-			tags,
-			role.zone,
-			role.capacity_string()
-		));
+		let usage = layout.get_node_usage(id).unwrap_or(0);
+		let capacity = layout.get_node_capacity(id).unwrap_or(0);
+		if capacity > 0 {
+			table.push(format!(
+				"{:?}\t{}\t{}\t{}\t{} ({:.1}%)",
+				id,
+				tags,
+				role.zone,
+				role.capacity_string(),
+				ByteSize::b(usage as u64 * layout.partition_size).to_string_as(false),
+				(100.0 * usage as f32 * layout.partition_size as f32) / (capacity as f32)
+			));
+		} else {
+			table.push(format!(
+				"{:?}\t{}\t{}\t{}",
+				id,
+				tags,
+				role.zone,
+				role.capacity_string()
+			));
+		};
 	}
+	println!();
+	println!("Parameters of the layout computation:");
+	println!("Zone redundancy: {}", layout.parameters.zone_redundancy);
+	println!();
 	if table.len() == 1 {
 		false
 	} else {
@@ -292,9 +368,23 @@ pub fn print_cluster_layout(layout: &ClusterLayout) -> bool {
 	}
 }
 
+pub fn print_staging_parameters_changes(layout: &ClusterLayout) -> bool {
+	let has_changes = *layout.staging_parameters.get() != layout.parameters;
+	if has_changes {
+		println!();
+		println!("==== NEW LAYOUT PARAMETERS ====");
+		println!(
+			"Zone redundancy: {}",
+			layout.staging_parameters.get().zone_redundancy
+		);
+		println!();
+	}
+	has_changes
+}
+
 pub fn print_staging_role_changes(layout: &ClusterLayout) -> bool {
 	let has_changes = layout
-		.staging
+		.staging_roles
 		.items()
 		.iter()
 		.any(|(k, _, v)| layout.roles.get(k) != Some(v));
@@ -303,7 +393,7 @@ pub fn print_staging_role_changes(layout: &ClusterLayout) -> bool {
 		println!();
 		println!("==== STAGED ROLE CHANGES ====");
 		let mut table = vec!["ID\tTags\tZone\tCapacity".to_string()];
-		for (id, _, role) in layout.staging.items().iter() {
+		for (id, _, role) in layout.staging_roles.items().iter() {
 			if layout.roles.get(id) == Some(role) {
 				continue;
 			}