Clippy

src/cache/fs.rs

@@ -121,13 +121,16 @@ pub(super) async fn read_file(
     // parsed_metadata is either set or unset here. If it's set then we
     // successfully decoded the data; otherwise the file is garbage.
 
-    if let Some(reader) = reader {
+    reader.map_or_else(
-        let stream = CacheStream::Completed(ReaderStream::new(reader));
+        || {
-        parsed_metadata.map(|metadata| Ok((stream, maybe_header, metadata)))
+            debug!("Reader was invalid, file is corrupt");
-    } else {
+            None
-        debug!("Reader was invalid, file is corrupt");
+        },
-        None
+        |reader| {
-    }
+            let stream = CacheStream::Completed(ReaderStream::new(reader));
+            parsed_metadata.map(|metadata| Ok((stream, maybe_header, metadata)))
+        },
+    )
 }
 
 struct EncryptedReader<R> {

src/ping.rs

@@ -73,7 +73,7 @@ impl<'a> From<(&'a ClientSecret, &Config)> for Request<'a> {
 #[derive(Deserialize, Debug)]
 #[serde(untagged)]
 pub enum Response {
-    Ok(OkResponse),
+    Ok(Box<OkResponse>),
     Error(ErrorResponse),
 }
 

src/routes.rs

@@ -3,10 +3,10 @@ use std::sync::atomic::Ordering;
 
 use actix_web::body::BoxBody;
 use actix_web::error::ErrorNotFound;
-use actix_web::http::header::{CONTENT_LENGTH, CONTENT_TYPE, LAST_MODIFIED, HeaderValue};
+use actix_web::http::header::{HeaderValue, CONTENT_LENGTH, CONTENT_TYPE, LAST_MODIFIED};
-use actix_web::web::Path;
+use actix_web::web::{Data, Path};
 use actix_web::HttpResponseBuilder;
-use actix_web::{get, web::Data, HttpRequest, HttpResponse, Responder};
+use actix_web::{get, HttpRequest, HttpResponse, Responder};
 use base64::DecodeError;
 use bytes::Bytes;
 use chrono::{DateTime, Utc};

src/state.rs

@@ -64,15 +64,16 @@ impl ServerState {
                         .token_key
                         .ok_or(ServerInitError::MissingTokenKey)
                         .and_then(|key| {
-                            if let Some(key) = base64::decode(&key)
+                            base64::decode(&key)
                                 .ok()
                                 .and_then(|k| PrecomputedKey::from_slice(&k))
-                            {
+                                .map_or_else(
-                                Ok(key)
+                                    || {
-                            } else {
+                                        error!("Failed to parse token key: got {}", key);
-                                error!("Failed to parse token key: got {}", key);
+                                        Err(ServerInitError::KeyParseError(key))
-                                Err(ServerInitError::KeyParseError(key))
+                                    },
-                            }
+                                    Ok,
+                                )
                         })?;
 
                     PREVIOUSLY_COMPROMISED.store(resp.compromised, Ordering::Release);