clippy and format

src/main.rs

@@ -4,13 +4,13 @@ mod store;
 mod upload;
 mod zip;
 
-use std::{fmt::Debug, path::PathBuf, str::FromStr, ops::Deref};
+use std::{fmt::Debug, ops::Deref, path::PathBuf, str::FromStr};
 
 use actix_http::StatusCode;
-use actix_session::{SessionMiddleware, storage::CookieSessionStore, Session};
+use actix_session::{storage::CookieSessionStore, Session, SessionMiddleware};
 use actix_web::{
-    error::InternalError, get, middleware::Logger, post, web, App, HttpRequest, HttpResponse,
+    cookie, error::InternalError, get, middleware::Logger, post, web, App, HttpRequest,
-    HttpServer, Responder, cookie,
+    HttpResponse, HttpServer, Responder,
 };
 use actix_web_actors::ws;
 use argon2::{Argon2, PasswordVerifier};
@@ -19,7 +19,7 @@ use bytesize::ByteSize;
 use log::{error, warn};
 use password_hash::PasswordHashString;
 use serde::{Deserialize, Serialize};
-use state::{StateDb, prelude::SizedFile};
+use state::{prelude::SizedFile, StateDb};
 use store::{StoredFile, StoredFiles};
 use tokio::fs::File;
 
@@ -93,19 +93,24 @@ struct AdminPage<'a> {
 }
 
 #[get("/admin")]
-async fn admin_panel(data: web::Data<AppData>, session: Session) -> actix_web::Result<HttpResponse> {
+async fn admin_panel(
+    data: web::Data<AppData>,
+    session: Session,
+) -> actix_web::Result<HttpResponse> {
     if let Some(true) = session.get::<bool>("admin")? {
         Ok(AdminPage {
             cachebuster: data.config.cachebuster.clone(),
             base_url: data.config.base_url.clone(),
             stored_files: data.state.read().await.deref(),
-        }.to_response())
+        }
+        .to_response())
     } else {
         Ok(SignedOutAdminPage {
             cachebuster: data.config.cachebuster.clone(),
             base_url: data.config.base_url.clone(),
             incorrect_password: false,
-        }.to_response())
+        }
+        .to_response())
     }
 }
 
@@ -115,14 +120,26 @@ struct AdminPanelSignin {
 }
 
 #[post("/admin")]
-async fn admin_signin(req: HttpRequest, data: web::Data<AppData>, form: web::Form<AdminPanelSignin>, session: Session) -> actix_web::Result<HttpResponse> {
+async fn admin_signin(
-    if Argon2::default().verify_password(form.password.as_bytes(), &data.config.admin_password_hash.password_hash()).is_ok() {
+    req: HttpRequest,
+    data: web::Data<AppData>,
+    form: web::Form<AdminPanelSignin>,
+    session: Session,
+) -> actix_web::Result<HttpResponse> {
+    if Argon2::default()
+        .verify_password(
+            form.password.as_bytes(),
+            &data.config.admin_password_hash.password_hash(),
+        )
+        .is_ok()
+    {
         session.insert("admin", true)?;
         Ok(AdminPage {
             cachebuster: data.config.cachebuster.clone(),
             base_url: data.config.base_url.clone(),
             stored_files: data.state.read().await.deref(),
-        }.to_response())
+        }
+        .to_response())
     } else {
         let ip_addr = get_ip_addr(&req, data.config.reverse_proxy);
         log_auth_failure(&ip_addr);
@@ -130,7 +147,8 @@ async fn admin_signin(req: HttpRequest, data: web::Data<AppData>, form: web::For
             cachebuster: data.config.cachebuster.clone(),
             base_url: data.config.base_url.clone(),
             incorrect_password: true,
-        }.to_response();
+        }
+        .to_response();
         *resp.status_mut() = StatusCode::FORBIDDEN;
 
         Err(InternalError::from_response("Incorrect password", resp).into())
@@ -375,12 +393,13 @@ async fn main() -> std::io::Result<()> {
     let admin_password_hash: PasswordHashString = env_or_panic("TRANSBEAM_ADMIN_PASSWORD_HASH");
 
     let cookie_secret_base64: String = env_or_panic("TRANSBEAM_COOKIE_SECRET");
-    let cookie_key = cookie::Key::from(
+    let cookie_key =
-        &base64::decode(&cookie_secret_base64)
+        cookie::Key::from(&base64::decode(&cookie_secret_base64).unwrap_or_else(|_| {
-            .unwrap_or_else(
+            panic!(
-                |_| panic!("Value {} for TRANSBEAM_COOKIE_SECRET is not valid base64", cookie_secret_base64)
+                "Value {} for TRANSBEAM_COOKIE_SECRET is not valid base64",
+                cookie_secret_base64
             )
-    );
+        }));
 
     let state_file: PathBuf = match std::env::var("TRANSBEAM_STATE_FILE") {
         Ok(v) => v
@@ -424,7 +443,10 @@ async fn main() -> std::io::Result<()> {
             } else {
                 Logger::default()
             })
-            .wrap(SessionMiddleware::new(CookieSessionStore::default(), cookie_key.clone()))
+            .wrap(SessionMiddleware::new(
+                CookieSessionStore::default(),
+                cookie_key.clone(),
+            ))
             .service(index)
             .service(handle_download)
             .service(download_info)

src/state.rs

@@ -13,12 +13,11 @@ pub mod prelude {
         fn size(&self) -> u64;
 
         fn formatted_size(&self) -> String {
-            bytesize::to_string(self.size(), false).replace(" ", "")
+            bytesize::to_string(self.size(), false).replace(' ', "")
         }
     }
 }
 
-
 mod v0;
 
 pub mod v1 {
@@ -52,7 +51,9 @@ pub mod v1 {
         }
     }
     impl SizedFile for UploadedFile {
-        fn size(&self) -> u64 { self.size }
+        fn size(&self) -> u64 {
+            self.size
+        }
     }
 
     #[derive(Debug, Clone, Deserialize, Serialize)]
@@ -83,7 +84,9 @@ pub mod v1 {
         pub contents: Option<FileSet>,
     }
     impl SizedFile for StoredFile {
-        fn size(&self) -> u64 { self.size }
+        fn size(&self) -> u64 {
+            self.size
+        }
     }
 
     #[derive(Debug, Clone, Deserialize, Serialize)]

src/store.rs

@@ -36,7 +36,7 @@ async fn is_valid_entry(key: &str, info: &StoredFile, storage_dir: &Path) -> boo
         return false;
     }
 
-    let file = if let Ok(f) = File::open(storage_dir.join(&key)).await {
+    let file = if let Ok(f) = File::open(storage_dir.join(key)).await {
         f
     } else {
         error!(
@@ -108,7 +108,11 @@ impl crate::AppData {
     /// Attempts to add a file to the store. Returns an I/O error if
     /// something's broken, or a u64 of the maximum allowed file size
     /// if the file was too big, or a unit if everything worked.
-    pub async fn add_file(&self, key: String, entry: StoredFileWithPassword) -> Result<(), FileAddError> {
+    pub async fn add_file(
+        &self,
+        key: String,
+        entry: StoredFileWithPassword,
+    ) -> Result<(), FileAddError> {
         let mut store = self.state.write().await;
         if store.full(self.config.max_storage_size) {
             return Err(FileAddError::Full);