Merge pull request #626 from nextcloud/flake-update

icewind1991 · web-flow · commit c2a0e96f174f · 2025-07-08T17:42:00.000+02:00
update nixpkgs to 25.05
diff --git a/flake.lock b/flake.lock
diff --git a/flake.nix b/flake.nix
@@ -1,6 +1,6 @@
 {
   inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.11";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.05";
     utils.url = "github:numtide/flake-utils";
     naersk.url = "github:nix-community/naersk";
     naersk.inputs.nixpkgs.follows = "nixpkgs";
diff --git a/src/config.rs b/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(),
         }
     }
diff --git a/src/connection.rs b/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);
     }
 
diff --git a/src/lib.rs b/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(())
diff --git a/src/main.rs b/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,
diff --git a/src/message.rs b/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
                 }
             }),
diff --git a/src/nc.rs b/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
                     },
                 ),
diff --git a/src/storage_mapping.rs b/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)
     }
diff --git a/test_client/src/main.rs b/test_client/src/main.rs

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`inputs = {`
`3`		`- nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.11";`
	`3`	`+ nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.05";`
`4`	`4`	`utils.url = "github:numtide/flake-utils";`
`5`	`5`	`naersk.url = "github:nix-community/naersk";`
`6`	`6`	`naersk.inputs.nixpkgs.follows = "nixpkgs";`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ impl Debug for Bind {`
`150`	`150`	`Bind::Unix(path, permissions) => f`
`151`	`151`	`.debug_tuple("Unix")`
`152`	`152`	`.field(path)`
`153`		`- .field(&format!("0{:0}", permissions))`
	`153`	`+ .field(&format!("0{permissions:0}"))`
`154`	`154`	`.finish(),`
`155`	`155`	`}`
`156`	`156`	`}`
Original file line number	Diff line number	Diff line change
`@@ -162,7 +162,7 @@ impl App {`
`162`	`162`	`.send_to_user(&user, PushMessage::File(file_id.into()));`
`163`	`163`	`}`
`164`	`164`	`}`
`165`		`- Err(e) => log::error!("{:#}", e),`
	`165`	`+ Err(e) => log::error!("{e:#}"),`
`166`	`166`	`}`
`167`	`167`	`}`
`168`	`168`	`Event::GroupUpdate(GroupUpdate { user, .. }) => {`
`@@ -196,8 +196,8 @@ impl App {`
`196`	`196`	`}`
`197`	`197`	`Event::Config(event::Config::LogSpec(spec)) => {`
`198`	`198`	`match self.log_handle.lock().await.parse_and_push_temp_spec(&spec) {`
`199`		`- Ok(()) => log::info!("Set log level to {}", spec),`
`200`		`- Err(e) => log::error!("Failed to set log level: {:?}", e),`
	`199`	`+ Ok(()) => log::info!("Set log level to {spec}"),`
	`200`	`+ Err(e) => log::error!("Failed to set log level: {e:#}"),`
`201`	`201`	`}`
`202`	`202`	`}`
`203`	`203`	`Event::Config(event::Config::LogRestore) => {`
`@@ -213,15 +213,15 @@ impl App {`
`213`	`213`	`)`
`214`	`214`	`.await`
`215`	`215`	`{`
`216`		`- log::warn!("Failed to set metrics: {}", e);`
	`216`	`+ log::warn!("Failed to set metrics: {e:#}");`
`217`	`217`	`}`
`218`	`218`	`}`
`219`		`- Err(e) => log::warn!("Failed to set metrics: {}", e),`
	`219`	`+ Err(e) => log::warn!("Failed to set metrics: {e:#}"),`
`220`	`220`	`},`
`221`	`221`	`Event::Signal(event::Signal::Reset) => {`
`222`	`222`	`log::info!("Stopping all open connections");`
`223`	`223`	`if let Err(e) = self.reset_tx.send(()) {`
`224`		`- log::warn!("Failed to send reset command to all connections: {}", e);`
	`224`	`+ log::warn!("Failed to send reset command to all connections: {e:#}");`
`225`	`225`	`}`
`226`	`226`	`}`
`227`	`227`	`}`
`@@ -270,7 +270,7 @@ pub fn serve(`
`270`	`270`	`.and(app.clone())`
`271`	`271`	`.map(\|app: Arc<App>\| {`
`272`	`272`	`let cookie = app.test_cookie.load(Ordering::SeqCst);`
`273`		`- log::debug!("current test cookie is {}", cookie);`
	`273`	`+ log::debug!("current test cookie is {cookie}");`
`274`	`274`	`cookie.to_string()`
`275`	`275`	`});`
`276`	`276`
`@@ -279,12 +279,12 @@ pub fn serve(`
`279`	`279`	`.and_then(\|app: Arc<App>\| async move {`
`280`	`280`	`let response = match app.nc_client.get_test_cookie().await {`
`281`	`281`	`Ok(cookie) => {`
`282`		`- log::debug!("got remote test cookie {}", cookie);`
	`282`	`+ log::debug!("got remote test cookie {cookie}");`
`283`	`283`	`cookie.to_string()`
`284`	`284`	`}`
`285`	`285`	`Err(e) => {`
`286`		`- log::warn!("Error while trying to get cookie from Nextcloud {:#}", e);`
`287`		`- format!("{:#}", e)`
	`286`	`+ log::warn!("Error while trying to get cookie from Nextcloud {e:#}");`
	`287`	`+ format!("{e:#}")`
`288`	`288`	`}`
`289`	`289`	`};`
`290`	`290`
`@@ -300,16 +300,11 @@ pub fn serve(`
`300`	`300`	`.await`
`301`	`301`	`.map(\|access\| {`
`302`	`302`	`let count = access.count();`
`303`		`- log::debug!("storage mapping count for {} = {}", storage_id, count);`
	`303`	`+ log::debug!("storage mapping count for {storage_id} = {count}");`
`304`	`304`	`count`
`305`	`305`	`})`
`306`		`- .map_err(\|err\| {`
`307`		`- log::error!(`
`308`		`- "error while getting mapping count for {}: {:#}",`
`309`		`- storage_id,`
`310`		`- err`
`311`		`- );`
`312`		`- err`
	`306`	`+ .inspect_err(\|err\| {`
	`307`	`+ log::error!("error while getting mapping count for {storage_id}: {err:#}");`
`313`	`308`	`})`
`314`	`309`	`.unwrap_or(0);`
`315`	`310`	`Result::<_, Infallible>::Ok(access.to_string())`
`@@ -324,7 +319,7 @@ pub fn serve(`
`324`	`319`	`.await`
`325`	`320`	`.map(\|remote\| remote.to_string())`
`326`	`321`	`.unwrap_or_else(\|e\| e.to_string());`
`327`		`- log::debug!("got remote {} when trying to set remote {}", result, remote);`
	`322`	`+ log::debug!("got remote {result} when trying to set remote {remote}");`
`328`	`323`	`Result::<_, Infallible>::Ok(result)`
`329`	`324`	`});`
`330`	`325`
`@@ -341,7 +336,7 @@ pub fn serve(`
`341`	`336`	`"set"`
`342`	`337`	`}`
`343`	`338`	`Err(e) => {`
`344`		`- log::warn!("Failed to get redis connection for version set: {:#}", e);`
	`339`	`+ log::warn!("Failed to get redis connection for version set: {e:#}");`
`345`	`340`	`"error"`
`346`	`341`	`}`
`347`	`342`	`})`
`@@ -412,7 +407,7 @@ pub async fn listen_loop(app: Arc<App>, cancel: oneshot::Receiver<()>) {`
`412`	`407`	`let loop_ = async move {`
`413`	`408`	`loop {`
`414`	`409`	`if let Err(e) = listen(app.clone()).await {`
`415`		`- log::error!("Failed to setup redis subscription: {:#}", e);`
	`410`	`+ log::error!("Failed to setup redis subscription: {e:#}");`
`416`	`411`	`}`
`417`	`412`	`log::warn!("Redis server disconnected, reconnecting in 1s");`
`418`	`413`	`sleep(Duration::from_secs(1)).await;`
`@@ -438,12 +433,11 @@ pub async fn listen(app: Arc<App>) -> Result<()> {`
`438`	`433`	`Ok(event) => {`
`439`	`434`	`log::debug!(`
`440`	`435`	`target: "notify_push::receive",`
`441`		`- "Received {}",`
`442`		`- event`
	`436`	`+ "Received {event}"`
`443`	`437`	`);`
`444`	`438`	`tokio::spawn(handle(event));`
`445`	`439`	`}`
`446`		`- Err(e) => log::warn!("{:#}", e),`
	`440`	`+ Err(e) => log::warn!("{e:#}"),`
`447`	`441`	`}`
`448`	`442`	`}`
`449`	`443`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ impl PushMessage {`
`89`	`89`	`ty`
`90`	`90`	`} else {`
`91`	`91`	`let mut str = ty;`
`92`		`- write!(&mut str, " {}", body).ok();`
	`92`	`+ write!(&mut str, " {body}").ok();`
`93`	`93`	`str`
`94`	`94`	`}`
`95`	`95`	`}),`