Merge pull request #781 from Mark-Simulacrum/bump-deps

Mark-Simulacrum · web-flow · commit 5b5f77f1cf90 · 2025-06-22T21:05:46.000Z
Run cargo update
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/src/agent/api.rs b/src/agent/api.rs
@@ -111,10 +111,7 @@ impl AgentApi {
                         let sleep_for = Duration::from_millis(
                             rand::thread_rng().gen_range(500..(retry_interval * 1000)),
                         );
-                        warn!(
-                            "connection to the server failed. retrying in {:?}...",
-                            sleep_for
-                        );
+                        warn!("connection to the server failed. retrying in {sleep_for:?}...");
                         ::std::thread::sleep(sleep_for);
                         retry_interval *= 2;
                         if retry_interval >= 8 * 60 {
diff --git a/src/agent/mod.rs b/src/agent/mod.rs
@@ -73,7 +73,7 @@ pub struct Agent {
 
 impl Agent {
     fn new(url: &str, token: &str, caps: &Capabilities) -> Fallible<Self> {
-        info!("connecting to crater server {}...", url);
+        info!("connecting to crater server {url}...");
 
         let api = AgentApi::new(url, token);
         let config = api.config(caps)?;
@@ -166,7 +166,7 @@ fn run_experiment(
             }
         }
         Err(err) => {
-            warn!("failed to check the disk usage: {}", err);
+            warn!("failed to check the disk usage: {err}");
         }
     }
 
diff --git a/src/cli.rs b/src/cli.rs
@@ -33,8 +33,6 @@ use std::time::Duration;
 #[derive(Debug, Clone)]
 pub struct Ex(String);
 
-#[derive(Debug, Clone)]
-pub struct DockerEnv(#[allow(unused)] String);
 impl FromStr for Ex {
     type Err = Error;
 
@@ -43,14 +41,6 @@ impl FromStr for Ex {
     }
 }
 
-impl FromStr for DockerEnv {
-    type Err = Error;
-
-    fn from_str(env: &str) -> Result<DockerEnv> {
-        Ok(DockerEnv(env.to_string()))
-    }
-}
-
 #[derive(Debug, Clone)]
 pub struct Dest(PathBuf);
 
diff --git a/src/config.rs b/src/config.rs
@@ -158,7 +158,7 @@ impl Config {
 
     fn check_for_dup_keys(buffer: &str) -> Fallible<()> {
         if let Err(e) = ::toml::from_str::<::toml::Value>(buffer) {
-            error!("got error parsing the config-file: {}", e);
+            error!("got error parsing the config-file: {e}");
             Err(e.into())
         } else {
             Ok(())
@@ -183,10 +183,7 @@ impl Config {
         let mut any_missing = false;
         for crate_name in self.crates.keys() {
             if !list_of_crates.contains(crate_name) {
-                error!(
-                    "check-config failed: crate `{}` is not available.",
-                    crate_name
-                );
+                error!("check-config failed: crate `{crate_name}` is not available.");
                 any_missing = true;
             }
         }
@@ -215,10 +212,7 @@ impl Config {
         let mut any_missing = false;
         for repo_name in self.github_repos.keys() {
             if !list_of_crates.contains(repo_name) {
-                error!(
-                    "check-config failed: GitHub repo `{}` is missing",
-                    repo_name
-                );
+                error!("check-config failed: GitHub repo `{repo_name}` is missing");
                 any_missing = true;
             }
         }
diff --git a/src/db/migrations.rs b/src/db/migrations.rs
@@ -396,7 +396,7 @@ pub fn execute(db: &mut Connection) -> Fallible<()> {
             t.execute("INSERT INTO migrations (name) VALUES (?1)", [&name])?;
             t.commit()?;
 
-            info!("executed migration: {}", name);
+            info!("executed migration: {name}");
         }
     }
 
diff --git a/src/db/mod.rs b/src/db/mod.rs
@@ -58,7 +58,7 @@ impl<E: std::error::Error> r2d2::HandleError<E> for ErrorHandler {
     fn handle_error(&self, error: E) {
         // ensure that a message gets logged regardless of whether it's enabled.
         if log::log_enabled!(log::Level::Error) {
-            log::error!("r2d2 error: {:?}", error);
+            log::error!("r2d2 error: {error:?}");
         } else {
             eprintln!("r2d2 error: {error:?}");
         }
@@ -297,9 +297,9 @@ pub trait QueryUtils {
         let elapsed = start.elapsed();
         // Log all queries that take at least 1/2 a second to execute.
         if elapsed.as_millis() > 500 {
-            debug!("sql query \"{}\" executed in {:?}", sql, elapsed);
+            debug!("sql query \"{sql}\" executed in {elapsed:?}");
         } else {
-            trace!("sql query \"{}\" executed in {:?}", sql, elapsed);
+            trace!("sql query \"{sql}\" executed in {elapsed:?}");
         }
         res
     }
diff --git a/src/report/html.rs b/src/report/html.rs
@@ -255,7 +255,7 @@ fn write_report<W: ReportWriter>(
         result_names,
     };
 
-    info!("generating {}", to);
+    info!("generating {to}");
 
     if output_templates {
         dest.write_string(
diff --git a/src/report/markdown.rs b/src/report/markdown.rs
@@ -185,7 +185,7 @@ fn write_report<W: ReportWriter>(
     };
 
     let markdown = render_markdown(&context)?;
-    info!("generating {}", to);
+    info!("generating {to}");
     dest.write_string(to, markdown.into(), &mime::TEXT_PLAIN)?;
 
     if output_templates {
diff --git a/src/report/mod.rs b/src/report/mod.rs
@@ -301,7 +301,7 @@ fn write_logs<DB: ReadResults, W: ReportWriter>(
 
         for (i, krate) in crates.iter().enumerate() {
             if i % progress_every == 0 {
-                info!("wrote logs for {}/{} crates", i, num_crates)
+                info!("wrote logs for {i}/{num_crates} crates")
             }
 
             if config.should_skip(krate) {
@@ -360,7 +360,7 @@ pub fn gen<DB: ReadResults, W: ReportWriter + Display>(
 ) -> Fallible<TestResults> {
     let raw = generate_report(db, config, ex, crates)?;
 
-    info!("writing results to {}", dest);
+    info!("writing results to {dest}");
     info!("writing metadata");
     dest.write_string(
         "results.json",
diff --git a/src/runner/mod.rs b/src/runner/mod.rs
@@ -47,10 +47,7 @@ pub fn run_ex(
     // jobs won't be completed.
     let mut i = 0;
     while !rustwide::cmd::docker_running(workspace) {
-        log::error!(
-            "docker is not currently up, waiting for it to start (tried {} times)",
-            i
-        );
+        log::error!("docker is not currently up, waiting for it to start (tried {i} times)");
         i += 1;
     }
 
@@ -80,7 +77,7 @@ pub fn run_ex(
         }
     }
 
-    info!("running tasks in {} threads...", threads_count);
+    info!("running tasks in {threads_count} threads...");
 
     let workers = (0..threads_count)
         .map(|i| {
diff --git a/src/runner/test.rs b/src/runner/test.rs
@@ -234,10 +234,7 @@ pub(super) fn run_test(
     rustwide::logging::capture(logs, || {
         info!(
             "{} {} against {} for {}",
-            action,
-            ctx.krate,
-            ctx.toolchain.to_string(),
-            ctx.experiment.name
+            action, ctx.krate, ctx.toolchain, ctx.experiment.name
         );
         let sandbox = SandboxBuilder::new()
             .memory_limit(Some(ctx.config.sandbox.memory_limit.to_bytes()))
diff --git a/src/runner/unstable_features.rs b/src/runner/unstable_features.rs
@@ -41,7 +41,7 @@ pub(super) fn find_unstable_features(
     let mut features: Vec<_> = features.into_iter().collect();
     features.sort();
     for feature in features {
-        info!("unstable-feature: {}", feature);
+        info!("unstable-feature: {feature}");
     }
 
     Ok(TestResult::TestPass)
diff --git a/src/runner/worker.rs b/src/runner/worker.rs
@@ -94,7 +94,7 @@ impl<'a> Worker<'a> {
         task: &Task,
         storage: &LogStorage,
     ) -> Result<TestResult, (anyhow::Error, TestResult)> {
-        info!("running task: {:?}", task);
+        info!("running task: {task:?}");
 
         let mut res = None;
         let max_attempts = 5;
@@ -136,11 +136,11 @@ impl<'a> Worker<'a> {
                 break;
             }
 
-            log::info!("Retrying task {:?} [{run}/{max_attempts}]", task);
+            log::info!("Retrying task {task:?} [{run}/{max_attempts}]");
         }
         // Unreachable unless we failed to succeed above.
         let e = res.unwrap();
-        error!("task {:?} failed", task);
+        error!("task {task:?} failed");
         utils::report_failure(&e);
 
         let mut result = if self.config.is_broken(&task.krate) {
@@ -215,8 +215,7 @@ impl<'a> Worker<'a> {
                                     return Err(e);
                                 } else {
                                     log::warn!(
-                                        "Retrying crate fetch in 3 seconds (attempt {})",
-                                        attempt
+                                        "Retrying crate fetch in 3 seconds (attempt {attempt})"
                                     );
                                     std::thread::sleep(std::time::Duration::from_secs(3));
                                 }
@@ -394,7 +393,7 @@ impl<'a> DiskSpaceWatcher<'a> {
             Ok(usage) => usage,
             Err(err) => {
                 // TODO: `current_mount` fails sometimes on Windows with ERROR_DEVICE_NOT_READY.
-                warn!("Failed to check space remaining: {}", err);
+                warn!("Failed to check space remaining: {err}");
                 return;
             }
         };
diff --git a/src/server/auth.rs b/src/server/auth.rs
@@ -130,11 +130,8 @@ impl ACL {
         let mut orgs = HashMap::new();
         for (org, team) in &self.teams {
             if let Err(err) = self.load_team(github, &mut new_cache, &mut orgs, org, team) {
-                warn!(
-                    "failed to authorize members of {}/{} to use the bot",
-                    org, team
-                );
-                warn!("caused by: {}", err);
+                warn!("failed to authorize members of {org}/{team} to use the bot");
+                warn!("caused by: {err}");
             }
         }
 
diff --git a/src/server/mod.rs b/src/server/mod.rs
@@ -72,7 +72,7 @@ pub fn run(config: Config, bind: SocketAddr) -> Fallible<()> {
         .map(|tokens| {
             let github = GitHubApi::new(&tokens);
             let bot_username = github.username()?;
-            info!("bot username: {}", bot_username);
+            info!("bot username: {bot_username}");
             Ok::<_, anyhow::Error>(GithubData {
                 api: github,
                 bot_username,
@@ -107,7 +107,7 @@ pub fn run(config: Config, bind: SocketAddr) -> Fallible<()> {
     info!("spawned reports worker...");
     cronjobs::spawn(data.clone());
 
-    info!("running server on {}...", bind);
+    info!("running server on {bind}...");
 
     let data = Arc::new(data);
     let github_data = github_data.map(Arc::new);
diff --git a/src/server/reports.rs b/src/server/reports.rs
@@ -62,13 +62,13 @@ fn reports_thread(data: &Data, github_data: Option<&GithubData>) -> Fallible<()>
         };
         let name = ex.name.clone();
 
-        info!("generating report for experiment {}...", name);
+        info!("generating report for experiment {name}...");
         ex.set_status(&data.db, Status::GeneratingReport)?;
 
         match generate_report(data, &ex, &results) {
             Err(err) => {
                 ex.set_status(&data.db, Status::ReportFailed)?;
-                error!("failed to generate the report of {}", name);
+                error!("failed to generate the report of {name}");
                 utils::report_failure(&err);
 
                 if let Some(github_data) = github_data {
@@ -102,7 +102,7 @@ fn reports_thread(data: &Data, github_data: Option<&GithubData>) -> Fallible<()>
 
                 ex.set_status(&data.db, Status::Completed)?;
                 ex.set_report_url(&data.db, &report_url)?;
-                info!("report for the experiment {} generated successfully!", name);
+                info!("report for the experiment {name} generated successfully!");
 
                 let (regressed, fixed) = (
                     res.info.get(&Comparison::Regressed).unwrap_or(&0),
diff --git a/src/server/routes/agent.rs b/src/server/routes/agent.rs
@@ -225,7 +225,7 @@ impl RecordProgressThread {
                         if let Err(e) = db.store(&ex, &result.data, EncodingType::Plain) {
                             // Failing to record a result is basically fine -- this
                             // just means that we'll have to re-try this job.
-                            log::error!("Failed to store result into database: {:?}", e);
+                            log::error!("Failed to store result into database: {e:?}");
                             crate::utils::report_failure(&e);
                         }
 
@@ -234,7 +234,7 @@ impl RecordProgressThread {
                         if let Err(e) = db.clear_stale_records() {
                             // Not a hard failure. We can continue even if we failed
                             // to clear records from already completed runs...
-                            log::error!("Failed to clear stale records: {:?}", e);
+                            log::error!("Failed to clear stale records: {e:?}");
                             crate::utils::report_failure(&e);
                         }
 
diff --git a/src/server/routes/webhooks/mod.rs b/src/server/routes/webhooks/mod.rs
@@ -108,7 +108,7 @@ fn process_command(
             return Ok(());
         }
 
-        info!("user @{} sent command: {}", sender, command);
+        info!("user @{sender} sent command: {command}");
 
         let args: Command =
             Command::from_str(command).with_context(|| "failed to parse the command")?;
diff --git a/src/utils/mod.rs b/src/utils/mod.rs
@@ -29,20 +29,20 @@ pub(crate) const FILENAME_ENCODE_SET: AsciiSet = CONTROLS
 
 pub fn report_panic(e: &dyn Any) {
     if let Some(e) = e.downcast_ref::<String>() {
-        error!("panicked: {}", e)
+        error!("panicked: {e}")
     } else if let Some(e) = e.downcast_ref::<&'static str>() {
-        error!("panicked: {}", e)
+        error!("panicked: {e}")
     } else {
         error!("panicked")
     }
 }
 
 pub fn report_failure(err: &anyhow::Error) {
     let backtrace = err.backtrace();
-    error!("{}", err);
+    error!("{err}");
 
     for cause in err.chain() {
-        error!("caused by: {}", cause);
+        error!("caused by: {cause}");
     }
 
     // Avoid printing a blank line if the backtrace exists but is empty.
@@ -51,7 +51,7 @@ pub fn report_failure(err: &anyhow::Error) {
     // environment variables are not set.
     let backtrace = backtrace.to_string();
     if !backtrace.is_empty() {
-        error!("{}", backtrace);
+        error!("{backtrace}");
         return;
     }
 

Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ pub struct Agent {`
`73`	`73`
`74`	`74`	`impl Agent {`
`75`	`75`	`fn new(url: &str, token: &str, caps: &Capabilities) -> Fallible<Self> {`
`76`		`- info!("connecting to crater server {}...", url);`
	`76`	`+ info!("connecting to crater server {url}...");`
`77`	`77`
`78`	`78`	`let api = AgentApi::new(url, token);`
`79`	`79`	`let config = api.config(caps)?;`
`@@ -166,7 +166,7 @@ fn run_experiment(`
`166`	`166`	`}`
`167`	`167`	`}`
`168`	`168`	`Err(err) => {`
`169`		`- warn!("failed to check the disk usage: {}", err);`
	`169`	`+ warn!("failed to check the disk usage: {err}");`
`170`	`170`	`}`
`171`	`171`	`}`
`172`	`172`
Original file line number	Diff line number	Diff line change
`@@ -396,7 +396,7 @@ pub fn execute(db: &mut Connection) -> Fallible<()> {`
`396`	`396`	`t.execute("INSERT INTO migrations (name) VALUES (?1)", [&name])?;`
`397`	`397`	`t.commit()?;`
`398`	`398`
`399`		`- info!("executed migration: {}", name);`
	`399`	`+ info!("executed migration: {name}");`
`400`	`400`	`}`
`401`	`401`	`}`
`402`	`402`