Merge pull request #352 from beyondessential/runs-transfer-column

feat(ui): show restore downloads in the recent-runs Transfer column

Author: passcod

crates/database/src/backups.rs

@@ -1259,6 +1259,52 @@ impl BackupRun {
 		Ok((totals.sent, totals.received))
 	}
 
+	/// The size of each named snapshot, resolved from the *backup* runs that
+	/// produced them: the device-reported size (`bytes_uploaded`) or, failing
+	/// that, the inspection-observed size (`snapshot_logical_bytes`) — the same
+	/// preference the recent-runs UI applies to the producing run itself. Keyed
+	/// by snapshot id; ids with no sized producing run are absent.
+	///
+	/// This is what lets a restore run show the size of the snapshot it used
+	/// immediately: the snapshot was sized when the backup that created it ran
+	/// (or was inspected), so there is no need to wait for inspection to
+	/// backfill the restore run's own row.
+	pub async fn snapshot_sizes_by_id(
+		db: &mut AsyncPgConnection,
+		group_id: Uuid,
+		snapshot_ids: &[String],
+	) -> Result<HashMap<String, i64>> {
+		use crate::schema::backup_runs::dsl;
+
+		if snapshot_ids.is_empty() {
+			return Ok(HashMap::new());
+		}
+
+		let rows: Vec<Self> = dsl::backup_runs
+			.filter(dsl::group_id.eq(group_id))
+			.filter(dsl::purpose.eq(BackupPurpose::Backup))
+			.filter(dsl::snapshot_id.eq_any(snapshot_ids))
+			.filter(
+				dsl::bytes_uploaded
+					.is_not_null()
+					.or(dsl::snapshot_logical_bytes.is_not_null()),
+			)
+			.distinct_on(dsl::snapshot_id)
+			.order_by((dsl::snapshot_id, dsl::reported_at.desc()))
+			.load(db)
+			.await
+			.map_err(AppError::from)?;
+
+		Ok(rows
+			.into_iter()
+			.filter_map(|r| {
+				let id = r.snapshot_id?;
+				let size = r.bytes_uploaded.or(r.snapshot_logical_bytes)?;
+				Some((id, size))
+			})
+			.collect())
+	}
+
 	/// Fill `snapshot_logical_bytes` from repo inspection for runs matched by
 	/// snapshot id, only where it is still unset — write-once, since a snapshot
 	/// is immutable. `sizes` maps a snapshot id to its observed logical size.

crates/database/tests/backups.rs

@@ -335,6 +335,82 @@ async fn backfill_snapshot_logical_bytes_writes_once() {
 	.await;
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn snapshot_sizes_by_id_resolves_from_producing_backups_only() {
+	TestDb::run(|mut conn, _url| async move {
+		let group_id = insert_group(&mut conn, "g").await;
+		let other_group = insert_group(&mut conn, "other").await;
+		let server_id = insert_server(&mut conn, group_id).await;
+		let other_server = insert_server(&mut conn, other_group).await;
+		let device_id = insert_device(&mut conn).await;
+
+		// The backup that produced kopia-snap-1, sized by the device (42 from
+		// new_run's bytes_uploaded).
+		BackupRun::record(
+			&mut conn,
+			new_run(
+				Uuid::new_v4(),
+				device_id,
+				group_id,
+				Some(server_id),
+				BackupPurpose::Backup,
+				RunOutcome::Success,
+			),
+		)
+		.await
+		.expect("record backup");
+		// A restore of the same snapshot must not satisfy the lookup itself.
+		BackupRun::record(
+			&mut conn,
+			NewBackupRun {
+				bytes_uploaded: None,
+				..new_run(
+					Uuid::new_v4(),
+					device_id,
+					group_id,
+					Some(server_id),
+					BackupPurpose::Restore,
+					RunOutcome::Success,
+				)
+			},
+		)
+		.await
+		.expect("record restore");
+		// Same snapshot id in another group: out of scope.
+		BackupRun::record(
+			&mut conn,
+			new_run(
+				Uuid::new_v4(),
+				device_id,
+				other_group,
+				Some(other_server),
+				BackupPurpose::Backup,
+				RunOutcome::Success,
+			),
+		)
+		.await
+		.expect("record other-group backup");
+
+		let sizes =
+			BackupRun::snapshot_sizes_by_id(&mut conn, group_id, &["kopia-snap-1".to_string()])
+				.await
+				.expect("lookup");
+		assert_eq!(sizes.get("kopia-snap-1"), Some(&42));
+		assert_eq!(sizes.len(), 1);
+
+		// Unknown ids resolve to nothing; the empty query short-circuits.
+		let miss = BackupRun::snapshot_sizes_by_id(&mut conn, group_id, &["nope".to_string()])
+			.await
+			.expect("lookup miss");
+		assert!(miss.is_empty());
+		let none = BackupRun::snapshot_sizes_by_id(&mut conn, group_id, &[])
+			.await
+			.expect("empty lookup");
+		assert!(none.is_empty());
+	})
+	.await;
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn latest_sized_lists_only_runs_with_both_sizes() {
 	TestDb::run(|mut conn, _url| async move {

crates/private-server/src/fns/backups.rs

@@ -375,9 +375,13 @@ pub struct RecentRun {
 	pub error: Option<String>,
 	/// Bytes the device reported uploading, if any (reported runs only).
 	pub bytes_uploaded: Option<i64>,
-	/// Snapshot the run produced, if any (reported runs only).
+	/// Snapshot the run produced (backup) or used (restore), if any (reported
+	/// runs only).
 	pub snapshot_id: Option<String>,
-	/// Logical snapshot size from repo inspection, if known (reported runs only).
+	/// Logical size of the run's snapshot, if known (reported runs only). For
+	/// a backup this comes from repo inspection. For a restore it is resolved
+	/// from the backup run that produced the snapshot (matched by snapshot id),
+	/// falling back to inspection's backfill onto the restore run itself.
 	pub snapshot_logical_bytes: Option<i64>,
 	/// Raw bytes sent to S3 during the run, if tallied (reported runs only).
 	pub s3_sent_raw_bytes: Option<i64>,
@@ -409,6 +413,12 @@ pub struct RecentRun {
 /// surface as inferred rows — in-flight while their creds are still valid,
 /// otherwise unreported past attempts (e.g. manual restores, which don't report).
 ///
+/// `source_snapshot_sizes` maps snapshot ids to sizes already known from the
+/// backup runs that produced them (see [`BackupRun::snapshot_sizes_by_id`]);
+/// a restore run's snapshot size resolves from it first, so the figure shows
+/// immediately rather than waiting for inspection to backfill the restore
+/// run's own row (which stays as the fallback).
+///
 /// Pairing is exact when the client stamped its run-uuid on the credential
 /// request (`run_id`): those issuances group by that id, so concurrent runs of
 /// the same type on one server never conflate. Issuances without a `run_id`
@@ -419,6 +429,7 @@ fn build_recent_runs(
 	runs: Vec<BackupRun>,
 	issuances: Vec<BackupCredentialIssuance>,
 	device_to_server: &std::collections::HashMap<Uuid, Uuid>,
+	source_snapshot_sizes: &std::collections::HashMap<String, i64>,
 	now: Timestamp,
 	limit: usize,
 ) -> Vec<RecentRun> {
@@ -439,6 +450,15 @@ fn build_recent_runs(
 		.zip(starts)
 		.map(|(run, started_at)| {
 			let duration_seconds = started_at.map(|s| run.reported_at.as_second() - s.as_second());
+			let snapshot_logical_bytes = if run.purpose == BackupPurpose::Restore {
+				run.snapshot_id
+					.as_ref()
+					.and_then(|id| source_snapshot_sizes.get(id))
+					.copied()
+					.or(run.snapshot_logical_bytes)
+			} else {
+				run.snapshot_logical_bytes
+			};
 			RecentRun {
 				key: format!("run-{}", run.id),
 				server_id: run.server_id,
@@ -449,7 +469,7 @@ fn build_recent_runs(
 				error: run.error,
 				bytes_uploaded: run.bytes_uploaded,
 				snapshot_id: run.snapshot_id,
-				snapshot_logical_bytes: run.snapshot_logical_bytes,
+				snapshot_logical_bytes,
 				s3_sent_raw_bytes: run.s3_sent_raw_bytes,
 				s3_sent_payload_bytes: run.s3_sent_payload_bytes,
 				s3_received_raw_bytes: run.s3_received_raw_bytes,
@@ -1819,10 +1839,22 @@ pub async fn stats(
 		RECENT_LIMIT * 4,
 	)
 	.await?;
+	// A restore's snapshot was already sized when the backup that produced it
+	// ran (or was inspected), so resolve restore snapshot sizes from that data
+	// rather than waiting for inspection to backfill the restore run's row.
+	let restore_snapshot_ids: Vec<String> = reported_runs
+		.iter()
+		.filter(|r| r.purpose == BackupPurpose::Restore)
+		.filter_map(|r| r.snapshot_id.clone())
+		.collect();
+	let source_snapshot_sizes =
+		BackupRun::snapshot_sizes_by_id(&mut conn, args.server_group_id, &restore_snapshot_ids)
+			.await?;
 	let recent_runs = build_recent_runs(
 		reported_runs,
 		issuances,
 		&device_to_server,
+		&source_snapshot_sizes,
 		now,
 		RECENT_LIMIT as usize,
 	);
@@ -2334,13 +2366,18 @@ mod tests {
 		std::collections::HashMap::from([(device, Uuid::from_u128(server))])
 	}
 
+	fn no_sizes() -> std::collections::HashMap<String, i64> {
+		std::collections::HashMap::new()
+	}
+
 	#[test]
 	fn reported_run_gets_duration_from_its_issuance() {
 		let d = Uuid::from_u128(1);
 		let rows = build_recent_runs(
 			vec![run(10, d, BackupPurpose::Backup, 4000)],
 			vec![issuance(1, d, BackupPurpose::Backup, 1000, 4600)],
 			&device_map(d, 9),
+			&no_sizes(),
 			ts(5000),
 			20,
 		);
@@ -2358,6 +2395,7 @@ mod tests {
 			vec![],
 			vec![issuance(1, d, BackupPurpose::Restore, 4900, 8500)],
 			&device_map(d, 9),
+			&no_sizes(),
 			ts(5000),
 			20,
 		);
@@ -2375,6 +2413,7 @@ mod tests {
 			vec![],
 			vec![issuance(1, d, BackupPurpose::Restore, 1000, 4600)],
 			&device_map(d, 9),
+			&no_sizes(),
 			ts(5000),
 			20,
 		);
@@ -2389,6 +2428,7 @@ mod tests {
 			vec![run(10, d, BackupPurpose::Restore, 4000)],
 			vec![issuance(1, d, BackupPurpose::Restore, 1000, 4600)],
 			&device_map(d, 9),
+			&no_sizes(),
 			ts(5000),
 			20,
 		);
@@ -2407,6 +2447,7 @@ mod tests {
 				issuance(2, d, BackupPurpose::Backup, 4500, 8100),
 			],
 			&device_map(d, 9),
+			&no_sizes(),
 			ts(9000),
 			20,
 		);
@@ -2423,6 +2464,7 @@ mod tests {
 			vec![run(10, d, BackupPurpose::Backup, 8000)],
 			vec![issuance(1, d, BackupPurpose::Backup, 1000, 4600)],
 			&device_map(d, 9),
+			&no_sizes(),
 			ts(9000),
 			20,
 		);
@@ -2461,6 +2503,7 @@ mod tests {
 				),
 			],
 			&device_map(d, 9),
+			&no_sizes(),
 			ts(5000),
 			20,
 		);
@@ -2483,6 +2526,7 @@ mod tests {
 			vec![run(200, d, BackupPurpose::Backup, 100_000)],
 			vec![issuance_for(1, d, BackupPurpose::Backup, 1000, 4600, rid)],
 			&device_map(d, 9),
+			&no_sizes(),
 			ts(101_000),
 			20,
 		);
@@ -2491,6 +2535,67 @@ mod tests {
 		assert_eq!(rows[0].duration_seconds, Some(99_000));
 	}
 
+	#[test]
+	fn restore_snapshot_size_resolves_from_the_producing_backup() {
+		let d = Uuid::from_u128(9);
+		let mut restore = run(10, d, BackupPurpose::Restore, 4000);
+		restore.snapshot_id = Some("snap-a".into());
+		// The size the snapshot was recorded at when its backup ran/was inspected.
+		let sizes = std::collections::HashMap::from([("snap-a".to_string(), 8_192_i64)]);
+		let rows = build_recent_runs(
+			vec![restore],
+			vec![],
+			&device_map(d, 9),
+			&sizes,
+			ts(5000),
+			20,
+		);
+		assert_eq!(rows.len(), 1);
+		assert_eq!(
+			rows[0].snapshot_logical_bytes,
+			Some(8192),
+			"restore shows its source snapshot's size without inspection of its own row"
+		);
+	}
+
+	#[test]
+	fn restore_snapshot_size_falls_back_to_its_own_backfill() {
+		let d = Uuid::from_u128(9);
+		let mut restore = run(10, d, BackupPurpose::Restore, 4000);
+		restore.snapshot_id = Some("snap-a".into());
+		restore.snapshot_logical_bytes = Some(4096);
+		// No producing backup carries the size — the restore row's own
+		// (inspection-backfilled) figure still surfaces.
+		let rows = build_recent_runs(
+			vec![restore],
+			vec![],
+			&device_map(d, 9),
+			&no_sizes(),
+			ts(5000),
+			20,
+		);
+		assert_eq!(rows[0].snapshot_logical_bytes, Some(4096));
+	}
+
+	#[test]
+	fn backup_snapshot_size_ignores_the_lookup() {
+		let d = Uuid::from_u128(9);
+		let mut backup = run(10, d, BackupPurpose::Backup, 4000);
+		backup.snapshot_id = Some("snap-a".into());
+		// A backup's size is its own (device-reported or backfilled) figure; the
+		// source-snapshot lookup is restore-only.
+		let sizes = std::collections::HashMap::from([("snap-a".to_string(), 8_192_i64)]);
+		let rows = build_recent_runs(
+			vec![backup],
+			vec![],
+			&device_map(d, 9),
+			&sizes,
+			ts(5000),
+			20,
+		);
+		assert_eq!(rows[0].snapshot_logical_bytes, None);
+	}
+
 	#[test]
 	fn inferred_rows_only_for_member_devices() {
 		let member = Uuid::from_u128(1);
@@ -2503,6 +2608,7 @@ mod tests {
 			],
 			// Only the member device maps to a server; the consumer device doesn't.
 			&device_map(member, 9),
+			&no_sizes(),
 			ts(5000),
 			20,
 		);