clippy

Signed-off-by: oppiliappan <[e-mail]>

readme.md

···
-# excuse
-
-mount jetstream as a userspace character device on linux.
-
-## usage
-
-```
-λ cargo b
-λ sudo RUST_LOG=info ./target/debug/excuse
-
-# -- in another shell --
-λ cat /dev/jetstream | jq
-```
-
-## motivation
-
-> People who think that userspace filesystems are realistic
-> for anything but toys are just misguided
->
-> Linus Torvalds

readme.txt

···
+excuse - mount jetstream as a character device on linux
+
+CUSE is FUSE's little brother, and it allows mounting a
+single character device file in /dev, with the device driver
+being implemented in userspace.
+
+unlike typical files, character devices like /dev/urandom
+are not seekable. they only support a streaming interface:
+
+    λ cat /dev/urandom   # random numbers
+
+excuse simply mounts a websocket connection to an atproto
+jetstream as a userspace character device:
+
+    λ sudo RUST_LOG=info excuse
+    [2025-09-21 INFO  excuse] Initializing CUSE at /dev/jetstream
+    [2025-09-21 INFO  excuse] /dev/jetstream is now 0644
+
+in another terminal:
+
+    λ cat /dev/jetstream | jq
+    {
+      "did": "did:plc:s6zjj6aw652mmvsrs573j6ti",
+      "time_us": 1758442606746247,
+      "kind": "commit",
+      "commit": { ... }
+    }
+    .
+    .
+    .
+
+you will notice a couple of optimizations:
+
+  - the websocket is only opened when the file has readers,
+    and is closed when all readers are closed
+  - the same connection is shared by all readers
+  - the data is buffered and not sent byte by byte
+
+it is a bit of a gimmick however, you can do this easily
+with websocat:
+
+  λ websocat wss://jetstream1.us-east.fire.hose.cam/subscribe

src/main.rs

···
                                         break;
                                     }
                                     Some(Err(e)) => {
-                                        error!("websocket error: {}", e);
+                                        error!("websocket error: {e}");
                                         break;
                                     }
                                     None => {
···
                     }
                 }
                 Err(e) => {
-                    error!("failed to connect to websocket: {}", e);
+                    error!("failed to connect to websocket: {e}");
                 }
             }
 
···
         reply: fuser::ReplyEmpty,
     ) {
         info!(
-            "release(ino: {:#x?}, fh: {}, flags: {:#x?}, lock_owner: {:?}, flush: {})",
-            ino, fh, flags, lock_owner, flush
+            "release(ino: {ino:#x?}, fh: {fh}, flags: {flags:#x?}, lock_owner: {lock_owner:?}, flush: {flush})"
         );
         self.end_stream();
         reply.ok();
···
     let handle = thread::spawn(|| {
         fuser::cuse(device).unwrap_or_else(|e| {
             error!(
-                "failed to start cuse device: {}. try run this example as privileged user",
-                e
+                "failed to start cuse device: {e}. try run this example as privileged user"
             );
             std::process::exit(1);
         })
···
 
     // make the device readable without sudo
     let output = Command::new("chmod")
-        .args(&["644", &format!("/dev/{DEV}")])
+        .args(["644", &format!("/dev/{DEV}")])
         .output();
 
     match output {