clippy fixes

Signed-off-by: Robin Appelman <robin@icewind.nl>

Author: icewind1991

src/config.rs

@@ -150,7 +150,7 @@ impl Debug for Bind {
             Bind::Unix(path, permissions) => f
                 .debug_tuple("Unix")
                 .field(path)
-                .field(&format!("0{:0}", permissions))
+                .field(&format!("0{permissions:0}"))
                 .finish(),
         }
     }

src/connection.rs

@@ -57,7 +57,7 @@ impl ActiveConnections {
     pub fn remove(&self, user: &UserId) {
         if let Entry::Occupied(e) = self.0.entry(user.clone()) {
             if e.get().receiver_count() == 1 {
-                log::debug!("Removing {} from active connections", user);
+                log::debug!("Removing {user} from active connections");
                 METRICS.remove_user();
                 e.remove();
             }
@@ -96,8 +96,8 @@ pub async fn handle_user_socket(
     {
         Ok(Ok(user_id)) => user_id,
         Ok(Err(e)) => {
-            log::warn!("{}", e);
-            ws.send(Message::text(format!("err: {}", e))).await.ok();
+            log::warn!("{e:#}");
+            ws.send(Message::text(format!("err: {e:#}"))).await.ok();
             return;
         }
         Err(_) => {
@@ -108,7 +108,7 @@ pub async fn handle_user_socket(
         }
     };
 
-    log::info!("new websocket authenticated as {}", user_id);
+    log::info!("new websocket authenticated as {user_id}");
     ws.send(Message::text("authenticated")).await.ok();
 
     let mut rx = match app.connections.add(user_id.clone()) {
@@ -149,7 +149,7 @@ pub async fn handle_user_socket(
                     match msg {
                         Ok(Ok(msg)) => {
                             if let Some(msg) = send_queue.push(msg, now) {
-                                log::debug!(target: "notify_push::send", "Sending {} to {}", msg, user_id);
+                                log::debug!(target: "notify_push::send", "Sending {msg} to {user_id}");
                                 METRICS.add_message(msg.message_type());
                                 last_send = now;
                                 user_ws_tx.send(msg.into_message(&opts)).await.ok();
@@ -165,18 +165,18 @@ pub async fn handle_user_socket(
                             for msg in send_queue.drain(now, METRICS.active_connection_count() + 50000, opts.max_debounce_time) {
                                 last_send = now;
                                 METRICS.add_message(msg.message_type());
-                                log::debug!(target: "notify_push::send", "Sending debounced {} to {}", msg, user_id);
+                                log::debug!(target: "notify_push::send", "Sending debounced {msg} to {user_id}");
                                 user_ws_tx.feed(msg.into_message(&opts)).await.ok();
                             }
 
                             if now.duration_since(last_send) > PING_INTERVAL {
                                 let data = rng.gen::<NonZeroUsize>().into();
                                 let last_ping = expect_pong.swap(data, Ordering::SeqCst);
                                 if last_ping > 0 {
-                                    log::info!("{} didn't reply to ping, closing", user_id);
+                                    log::info!("{user_id} didn't reply to ping, closing");
                                     break;
                                 }
-                                log::debug!(target: "notify_push::send", "Sending ping to {}", user_id);
+                                log::debug!(target: "notify_push::send", "Sending ping to {user_id}");
                                 last_send = now;
                                 user_ws_tx
                                     .feed(Message::ping(data.to_le_bytes()))
@@ -223,9 +223,9 @@ pub async fn handle_user_socket(
                     match formatted.as_str() {
                         "WebSocket protocol error: Connection reset without closing handshake"
                         | "IO error: Connection reset by peer (os error 104)" => {
-                            log::debug!("websocket error: {}", e)
+                            log::debug!("websocket error: {e:#}")
                         }
-                        _ => log::warn!("websocket error: {}", e),
+                        _ => log::warn!("websocket error: {e:#}"),
                     };
                     break;
                 }
@@ -269,10 +269,7 @@ async fn socket_auth(
     app.pre_auth.retain(|_, (time, _)| *time > cutoff);
 
     if let Some((_, (_, user))) = app.pre_auth.remove(password) {
-        log::debug!(
-            "Authenticated socket for {} using pre authenticated token",
-            user
-        );
+        log::debug!("Authenticated socket for {user} using pre authenticated token");
         return Ok(user);
     }
 

src/lib.rs

@@ -162,7 +162,7 @@ impl App {
                                 .send_to_user(&user, PushMessage::File(file_id.into()));
                         }
                     }
-                    Err(e) => log::error!("{:#}", e),
+                    Err(e) => log::error!("{e:#}"),
                 }
             }
             Event::GroupUpdate(GroupUpdate { user, .. }) => {
@@ -196,8 +196,8 @@ impl App {
             }
             Event::Config(event::Config::LogSpec(spec)) => {
                 match self.log_handle.lock().await.parse_and_push_temp_spec(&spec) {
-                    Ok(()) => log::info!("Set log level to {}", spec),
-                    Err(e) => log::error!("Failed to set log level: {:?}", e),
+                    Ok(()) => log::info!("Set log level to {spec}"),
+                    Err(e) => log::error!("Failed to set log level: {e:#}"),
                 }
             }
             Event::Config(event::Config::LogRestore) => {
@@ -213,15 +213,15 @@ impl App {
                         )
                         .await
                     {
-                        log::warn!("Failed to set metrics: {}", e);
+                        log::warn!("Failed to set metrics: {e:#}");
                     }
                 }
-                Err(e) => log::warn!("Failed to set metrics: {}", e),
+                Err(e) => log::warn!("Failed to set metrics: {e:#}"),
             },
             Event::Signal(event::Signal::Reset) => {
                 log::info!("Stopping all open connections");
                 if let Err(e) = self.reset_tx.send(()) {
-                    log::warn!("Failed to send reset command to all connections: {}", e);
+                    log::warn!("Failed to send reset command to all connections: {e:#}");
                 }
             }
         }
@@ -270,7 +270,7 @@ pub fn serve(
         .and(app.clone())
         .map(|app: Arc<App>| {
             let cookie = app.test_cookie.load(Ordering::SeqCst);
-            log::debug!("current test cookie is {}", cookie);
+            log::debug!("current test cookie is {cookie}");
             cookie.to_string()
         });
 
@@ -279,12 +279,12 @@ pub fn serve(
         .and_then(|app: Arc<App>| async move {
             let response = match app.nc_client.get_test_cookie().await {
                 Ok(cookie) => {
-                    log::debug!("got remote test cookie {}", cookie);
+                    log::debug!("got remote test cookie {cookie}");
                     cookie.to_string()
                 }
                 Err(e) => {
-                    log::warn!("Error while trying to get cookie from Nextcloud {:#}", e);
-                    format!("{:#}", e)
+                    log::warn!("Error while trying to get cookie from Nextcloud {e:#}");
+                    format!("{e:#}")
                 }
             };
 
@@ -300,16 +300,11 @@ pub fn serve(
                 .await
                 .map(|access| {
                     let count = access.count();
-                    log::debug!("storage mapping count for {} = {}", storage_id, count);
+                    log::debug!("storage mapping count for {storage_id} = {count}");
                     count
                 })
-                .map_err(|err| {
-                    log::error!(
-                        "error while getting mapping count for {}: {:#}",
-                        storage_id,
-                        err
-                    );
-                    err
+                .inspect_err(|err| {
+                    log::error!("error while getting mapping count for {storage_id}: {err:#}");
                 })
                 .unwrap_or(0);
             Result::<_, Infallible>::Ok(access.to_string())
@@ -324,7 +319,7 @@ pub fn serve(
                 .await
                 .map(|remote| remote.to_string())
                 .unwrap_or_else(|e| e.to_string());
-            log::debug!("got remote {} when trying to set remote {}", result, remote);
+            log::debug!("got remote {result} when trying to set remote {remote}");
             Result::<_, Infallible>::Ok(result)
         });
 
@@ -341,7 +336,7 @@ pub fn serve(
                     "set"
                 }
                 Err(e) => {
-                    log::warn!("Failed to get redis connection for version set: {:#}", e);
+                    log::warn!("Failed to get redis connection for version set: {e:#}");
                     "error"
                 }
             })
@@ -412,7 +407,7 @@ pub async fn listen_loop(app: Arc<App>, cancel: oneshot::Receiver<()>) {
     let loop_ = async move {
         loop {
             if let Err(e) = listen(app.clone()).await {
-                log::error!("Failed to setup redis subscription: {:#}", e);
+                log::error!("Failed to setup redis subscription: {e:#}");
             }
             log::warn!("Redis server disconnected, reconnecting in 1s");
             sleep(Duration::from_secs(1)).await;
@@ -438,12 +433,11 @@ pub async fn listen(app: Arc<App>) -> Result<()> {
             Ok(event) => {
                 log::debug!(
                     target: "notify_push::receive",
-                    "Received {}",
-                    event
+                    "Received {event}"
                 );
                 tokio::spawn(handle(event));
             }
-            Err(e) => log::warn!("{:#}", e),
+            Err(e) => log::warn!("{e:#}"),
         }
     }
     Ok(())

src/main.rs

@@ -32,7 +32,7 @@ fn main() -> Result<()> {
     let config = Config::from_opt(opt)?;
 
     if dump_config {
-        println!("{:#?}", config);
+        println!("{config:#?}");
         return Ok(());
     }
 
@@ -64,7 +64,7 @@ async fn run(config: Config, log_handle: LoggerHandle) -> Result<()> {
     let (metrics_cancel, metrics_cancel_handle) = oneshot::channel();
     let (listen_cancel, listen_cancel_handle) = oneshot::channel();
 
-    log::trace!("Running with config: {:?}", config);
+    log::trace!("Running with config: {config:?}");
 
     if config.allow_self_signed {
         log::info!("Running with certificate validation disabled");
@@ -81,10 +81,10 @@ async fn run(config: Config, log_handle: LoggerHandle) -> Result<()> {
     let max_connection_time = config.max_connection_time;
     let app = Arc::new(App::new(config, log_handle).await?);
     if let Err(e) = app.self_test().await {
-        log::error!("Self test failed: {:#}", e);
+        log::error!("Self test failed: {e:#}");
     }
 
-    log::trace!("Listening on {}", bind);
+    log::trace!("Listening on {bind}");
     let server = spawn(serve(
         app.clone(),
         bind,
@@ -95,7 +95,7 @@ async fn run(config: Config, log_handle: LoggerHandle) -> Result<()> {
     )?);
 
     if let Some(metrics_bind) = metrics_bind {
-        log::trace!("Metrics listening {}", metrics_bind);
+        log::trace!("Metrics listening {metrics_bind}");
         spawn(serve_metrics(
             metrics_bind,
             metrics_cancel_handle,

src/message.rs

@@ -89,7 +89,7 @@ impl PushMessage {
                     ty
                 } else {
                     let mut str = ty;
-                    write!(&mut str, " {}", body).ok();
+                    write!(&mut str, " {body}").ok();
                     str
                 }
             }),

src/nc.rs

@@ -32,7 +32,7 @@ impl Client {
         password: &str,
         forwarded_for: Vec<IpAddr>,
     ) -> Result<UserId, AuthenticationError> {
-        log::debug!("Verifying credentials for {}", username);
+        log::debug!("Verifying credentials for {username}");
         let response = self.auth_request(username, password, forwarded_for).await?;
 
         match response.status() {
@@ -65,7 +65,7 @@ impl Client {
                         if !joined.is_empty() {
                             write!(&mut joined, ", ").ok();
                         }
-                        write!(&mut joined, "{}", ip).ok();
+                        write!(&mut joined, "{ip}").ok();
                         joined
                     },
                 ),

src/storage_mapping.rs

@@ -105,7 +105,7 @@ impl StorageMapping {
         &self,
         storage: u32,
     ) -> Result<Vec<UserStorageAccess>, DatabaseError> {
-        debug!("querying storage mapping for {}", storage);
+        debug!("querying storage mapping for {storage}");
         let users = query_as::<Any, UserStorageAccess>(&format!(
             "\
                 SELECT user_id, path \
@@ -120,7 +120,7 @@ impl StorageMapping {
         .map_err(DatabaseError::Query)?;
         METRICS.add_mapping_query();
 
-        debug!("got storage mappings for {}: {:?}", storage, users);
+        debug!("got storage mappings for {storage}: {users:?}");
 
         Ok(users)
     }

test_client/src/main.rs

@@ -26,7 +26,7 @@ fn main() -> Result<()> {
     let (nc_url, username, password) = match (args.next(), args.next(), args.next()) {
         (Some(host), Some(username), Some(password)) => (host, username, password),
         _ => {
-            eprintln!("usage {} <nextcloud url> <username> <password>", bin);
+            eprintln!("usage {bin} <nextcloud url> <username> <password>");
             return Ok(());
         }
     };
@@ -36,7 +36,7 @@ fn main() -> Result<()> {
     } else {
         get_endpoint(&nc_url, &username, &password)?
     };
-    info!("Found push server at {}", ws_url);
+    info!("Found push server at {ws_url}");
 
     let ws_url = Url::parse(&ws_url)
         .into_diagnostic()
@@ -61,30 +61,30 @@ fn main() -> Result<()> {
     loop {
         if let Message::Text(text) = socket.read().into_diagnostic()? {
             if let Some(err) = text.strip_prefix("err: ") {
-                warn!("Received error: {}", err);
+                warn!("Received error: {err}");
                 return Ok(());
             } else if text.starts_with("notify_file") {
-                info!("Received file update notification {}", text);
+                info!("Received file update notification {text}");
             } else if text == "notify_activity" {
                 info!("Received activity notification");
             } else if text == "notify_notification" {
                 info!("Received notification notification");
             } else if text == "authenticated" {
                 info!("Authenticated");
             } else {
-                info!("Received: {}", text);
+                info!("Received: {text}");
             }
         }
     }
 }
 
 fn get_endpoint(nc_url: &str, user: &str, password: &str) -> Result<String> {
-    let raw = ureq::get(&format!("{}/ocs/v2.php/cloud/capabilities", nc_url))
+    let raw = ureq::get(&format!("{nc_url}/ocs/v2.php/cloud/capabilities"))
         .set(
             "Authorization",
             &format!(
                 "Basic {}",
-                base64::engine::general_purpose::STANDARD.encode(format!("{}:{}", user, password))
+                base64::engine::general_purpose::STANDARD.encode(format!("{user}:{password}"))
             ),
         )
         .set("Accept", "application/json")
@@ -93,10 +93,10 @@ fn get_endpoint(nc_url: &str, user: &str, password: &str) -> Result<String> {
         .into_diagnostic()?
         .into_string()
         .into_diagnostic()?;
-    trace!("Capabilities response: {}", raw);
+    trace!("Capabilities response: {raw}");
     let json: Value = serde_json::from_str(&raw)
         .into_diagnostic()
-        .wrap_err_with(|| format!("Failed to decode json capabilities response: {}", raw))?;
+        .wrap_err_with(|| format!("Failed to decode json capabilities response: {raw}"))?;
     if let Some(capabilities) = json["ocs"]["data"]["capabilities"].as_object() {
         debug!(
             "Supported capabilities: {:?}",
@@ -116,8 +116,7 @@ fn get_endpoint(nc_url: &str, user: &str, password: &str) -> Result<String> {
         }
     } else {
         Err(Report::msg(format!(
-            "invalid capabilities response: {}",
-            json
+            "invalid capabilities response: {json}"
         )))
     }
 }