more clippy

Author: passcod

src/controllers/replica.rs

@@ -231,16 +231,17 @@ pub async fn reconcile(replica: Arc<PostgresPhysicalReplica>, ctx: Arc<Context>)
 
 		// Recompute next scheduled restore in case schedule changed while restore was in flight
 		if let Some(schedule) = &replica.spec.schedule
-			&& let Some(next) = compute_next_scheduled_restore(schedule) {
-				update_replica_status_field(
-					client,
-					&namespace,
-					&name,
-					"nextScheduledRestore",
-					&next.to_rfc3339(),
-				)
-				.await?;
-			}
+			&& let Some(next) = compute_next_scheduled_restore(schedule)
+		{
+			update_replica_status_field(
+				client,
+				&namespace,
+				&name,
+				"nextScheduledRestore",
+				&next.to_rfc3339(),
+			)
+			.await?;
+		}
 
 		return Ok(Action::requeue(Duration::from_secs(10)));
 	}
@@ -413,16 +414,17 @@ pub async fn reconcile(replica: Arc<PostgresPhysicalReplica>, ctx: Arc<Context>)
 		// Whether a restore was created or skipped, advance nextScheduledRestore
 		// so we don't re-trigger on the next reconciliation.
 		if let Some(schedule) = &replica.spec.schedule
-			&& let Some(next) = compute_next_scheduled_restore(schedule) {
-				update_replica_status_field(
-					client,
-					&namespace,
-					&name,
-					"nextScheduledRestore",
-					&next.to_rfc3339(),
-				)
-				.await?;
-			}
+			&& let Some(next) = compute_next_scheduled_restore(schedule)
+		{
+			update_replica_status_field(
+				client,
+				&namespace,
+				&name,
+				"nextScheduledRestore",
+				&next.to_rfc3339(),
+			)
+			.await?;
+		}
 	}
 
 	// Update phase based on current state
@@ -692,14 +694,15 @@ fn should_trigger_scheduled_restore(replica: &PostgresPhysicalReplica) -> bool {
 
 	// Check minimumTTL
 	if let Some(last_completed) = status.and_then(|s| s.last_restore_completed_at.as_ref())
-		&& let Ok(last_completed) = last_completed.parse::<chrono::DateTime<Utc>>() {
-			let minimum_ttl =
-				parse_duration(&replica.spec.minimum_ttl).unwrap_or(Duration::from_secs(6 * 3600));
-			let elapsed = Utc::now().signed_duration_since(last_completed);
-			if elapsed.to_std().unwrap_or_default() < minimum_ttl {
-				return false;
-			}
+		&& let Ok(last_completed) = last_completed.parse::<chrono::DateTime<Utc>>()
+	{
+		let minimum_ttl =
+			parse_duration(&replica.spec.minimum_ttl).unwrap_or(Duration::from_secs(6 * 3600));
+		let elapsed = Utc::now().signed_duration_since(last_completed);
+		if elapsed.to_std().unwrap_or_default() < minimum_ttl {
+			return false;
 		}
+	}
 
 	// Check cron schedule
 	let Ok(cron_schedule) = schedule.parse::<cron::Schedule>() else {
@@ -715,20 +718,22 @@ fn should_trigger_scheduled_restore(replica: &PostgresPhysicalReplica) -> bool {
 	let now = Utc::now();
 
 	if let Some(next_scheduled) = status.and_then(|s| s.next_scheduled_restore.as_ref())
-		&& let Ok(next) = next_scheduled.parse::<chrono::DateTime<Utc>>() {
-			// Add jitter to the scheduled time
-			let trigger_at = next + chrono::Duration::from_std(jitter).unwrap_or_default();
-			return now >= trigger_at;
-		}
+		&& let Ok(next) = next_scheduled.parse::<chrono::DateTime<Utc>>()
+	{
+		// Add jitter to the scheduled time
+		let trigger_at = next + chrono::Duration::from_std(jitter).unwrap_or_default();
+		return now >= trigger_at;
+	}
 
 	// Initial seed: nextScheduledRestore not yet set (first reconciliation or field was cleared).
 	// Fall back to checking whether a cron occurrence falls within a 24h lookback window.
 	let jittered_now = now - chrono::Duration::from_std(jitter).unwrap_or_default();
-	for prev in cron_schedule.after(&(jittered_now - chrono::Duration::hours(24))) {
-		if prev <= now {
-			return true;
-		}
-		break;
+	if let Some(prev) = cron_schedule
+		.after(&(jittered_now - chrono::Duration::hours(24)))
+		.next()
+		&& prev <= now
+	{
+		return true;
 	}
 
 	false
@@ -1032,6 +1037,10 @@ async fn update_restore_activated_at(
 	Ok(())
 }
 
+#[expect(
+	clippy::too_many_arguments,
+	reason = "notification dispatch needs all these context params"
+)]
 async fn send_restore_notifications(
 	client: &Client,
 	http_client: &reqwest::Client,

src/controllers/restore.rs

@@ -350,39 +350,40 @@ async fn reconcile_ready(
 
 		// Check for timeout (10 minutes)
 		if let Some(created_at) = restore.status.as_ref().and_then(|s| s.restored_at.as_ref())
-			&& let Ok(created) = created_at.parse::<chrono::DateTime<Utc>>() {
-				let elapsed = Utc::now().signed_duration_since(created);
-				if elapsed > chrono::Duration::minutes(10) {
-					warn!(
-						restore = name,
-						"deployment not ready after 10 minutes, marking as Failed"
-					);
-					update_restore_status(
-						client,
-						namespace,
-						name,
-						serde_json::json!({
-							"phase": "Failed",
-						}),
-					)
-					.await?;
-
-					let mut queue = ctx.restore_queue.write().await;
-					queue.remove(replica_name);
-					let promoted = queue.try_promote(ctx.max_concurrent_restores());
-					ctx.metrics.active_restores.set(queue.active.len() as i64);
-					ctx.metrics.queue_depth.set(queue.pending.len() as i64);
-					drop(queue);
-
-					if let Some(promoted_name) = promoted {
-						info!(promoted = %promoted_name, "promoted queued restore after timeout failure");
-					}
+			&& let Ok(created) = created_at.parse::<chrono::DateTime<Utc>>()
+		{
+			let elapsed = Utc::now().signed_duration_since(created);
+			if elapsed > chrono::Duration::minutes(10) {
+				warn!(
+					restore = name,
+					"deployment not ready after 10 minutes, marking as Failed"
+				);
+				update_restore_status(
+					client,
+					namespace,
+					name,
+					serde_json::json!({
+						"phase": "Failed",
+					}),
+				)
+				.await?;
+
+				let mut queue = ctx.restore_queue.write().await;
+				queue.remove(replica_name);
+				let promoted = queue.try_promote(ctx.max_concurrent_restores());
+				ctx.metrics.active_restores.set(queue.active.len() as i64);
+				ctx.metrics.queue_depth.set(queue.pending.len() as i64);
+				drop(queue);
+
+				if let Some(promoted_name) = promoted {
+					info!(promoted = %promoted_name, "promoted queued restore after timeout failure");
+				}
 
-					ctx.metrics.restores_failed_total.inc();
+				ctx.metrics.restores_failed_total.inc();
 
-					return Ok(Action::requeue(Duration::from_secs(300)));
-				}
+				return Ok(Action::requeue(Duration::from_secs(300)));
 			}
+		}
 
 		return Ok(Action::requeue(Duration::from_secs(10)));
 	}

src/kopia.rs

@@ -111,9 +111,10 @@ pub fn filter_snapshots(snapshots: &[Snapshot], filter: Option<&SnapshotFilter>)
 
 			// Host pattern filtering
 			if let Some(pattern) = &filter.host_pattern
-				&& !glob_matches(pattern, &snap.hostname) {
-					return false;
-				}
+				&& !glob_matches(pattern, &snap.hostname)
+			{
+				return false;
+			}
 
 			true
 		})