Use IntGauge for media counts

Cargo.toml

@@ -20,12 +20,12 @@ jsonwebtoken = "7.2.0"
 serde = "1"
 serde_json = "1"
 diesel = { version = "1.4.5", features = ["sqlite"] }
-hmac = "0.11"
+hmac = "0.10"
 sha2 = "0.9"
 chrono = "0.4"
 dotenv = "0.15"
 bcrypt = "0.9"
-image = { version = "0.23", default-features = false, features = ["jpeg", "png", "jpeg_rayon"] }
+image = { version = "0.23.7", default-features = false, features = ["jpeg", "png", "jpeg_rayon"] }
 walkdir = "2"
 rayon = "1.3"
 notify = "4.0"
@@ -35,4 +35,3 @@ env_logger="0.8"
 actix-web-prom = "0.5.1"
 prometheus = "0.11"
 lazy_static = "1.1"
-anyhow = "1.0"

Dockerfile.ci

@@ -1,7 +0,0 @@
-FROM rust:1.55
-RUN mkdir /usr/src/image-api && chown -R 1000:999 /usr/src/image-api
-USER 1000:999
-WORKDIR /usr/src/image-api
-COPY Cargo.toml .
-RUN mkdir ./src && echo "fn main() {}" > ./src/main.rs && cargo fetch
-COPY src/ ./src/

Jenkinsfile

@@ -1,8 +1,8 @@
 pipeline {
   agent {
-    dockerfile {
+    docker {
-      filename 'Dockerfile.ci'
+      image 'rust:1.51'
-      args '-v "$PWD:/usr/src/image-api'
+      args '-v "$PWD":/usr/src/image-api'
     }
   }
 

src/auth.rs

@@ -32,11 +32,10 @@ pub async fn login(
     user_dao: web::Data<Box<dyn UserDao>>,
 ) -> HttpResponse {
     debug!("Logging in: {}", creds.username);
-
     if let Some(user) = user_dao.get_user(&creds.username, &creds.password) {
         let claims = Claims {
             sub: user.id.to_string(),
-            exp: (Utc::now() + Duration::minutes(1)).timestamp(),
+            exp: (Utc::now() + Duration::days(5)).timestamp(),
         };
         let token = encode(
             &Header::default(),
@@ -44,7 +43,6 @@ pub async fn login(
             &EncodingKey::from_secret(secret_key().as_bytes()),
         )
         .unwrap();
-
         HttpResponse::Ok().json(Token { token: &token })
     } else {
         error!(
@@ -58,7 +56,7 @@ pub async fn login(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::testhelpers::{BodyReader, TestUserDao};
+    use crate::database::testhelpers::{BodyReader, TestUserDao};
 
     #[actix_rt::test]
     async fn test_login_reports_200_when_user_exists() {

src/data/mod.rs

@@ -1,8 +1,5 @@
-use std::{fs, str::FromStr};
+use std::str::FromStr;
 
-use anyhow::{anyhow, Context};
-
-use chrono::{DateTime, Utc};
 use log::error;
 
 use actix_web::error::ErrorUnauthorized;
@@ -37,7 +34,7 @@ impl FromStr for Claims {
         let token = *(s.split("Bearer ").collect::<Vec<_>>().last().unwrap_or(&""));
 
         match decode::<Claims>(
-            token,
+            &token,
             &DecodingKey::from_secret(secret_key().as_bytes()),
             &Validation::new(Algorithm::HS256),
         ) {
@@ -56,34 +53,19 @@ impl FromRequest for Claims {
     type Config = ();
 
     fn from_request(req: &HttpRequest, _payload: &mut dev::Payload) -> Self::Future {
-        req.headers()
+        let claims = match req.headers().get(header::AUTHORIZATION) {
-            .get(header::AUTHORIZATION)
+            Some(header) => Claims::from_str(header.to_str().unwrap_or("")),
-            .map_or_else(
+            None => Err(jsonwebtoken::errors::Error::from(
-                || Err(anyhow!("No authorization header")),
+                jsonwebtoken::errors::ErrorKind::InvalidToken,
-                |header| {
+            )),
-                    header
+        };
-                        .to_str()
-                        .context("Unable to read Authorization header to string")
-                },
-            )
-            .and_then(|header| {
-                Claims::from_str(header)
-                    .with_context(|| format!("Unable to decode token from: {}", header))
-            })
-            .map_or_else(
-                |e| {
-                    error!("{}", e);
-                    err(ErrorUnauthorized("Bad token"))
-                },
-                ok,
-            )
-    }
-}
 
-#[derive(Serialize, Deserialize, Debug)]
+        if let Ok(claims) = claims {
-pub struct PhotosResponse {
+            ok(claims)
-    pub photos: Vec<String>,
+        } else {
-    pub dirs: Vec<String>,
+            err(ErrorUnauthorized("Bad token"))
+        }
+    }
 }
 
 #[derive(Deserialize)]
@@ -110,29 +92,6 @@ pub struct AddFavoriteRequest {
     pub path: String,
 }
 
-#[derive(Debug, Serialize)]
-pub struct MetadataResponse {
-    pub created: Option<i64>,
-    pub modified: Option<i64>,
-    pub size: u64,
-}
-
-impl From<fs::Metadata> for MetadataResponse {
-    fn from(metadata: fs::Metadata) -> Self {
-        MetadataResponse {
-            created: metadata.created().ok().map(|created| {
-                let utc: DateTime<Utc> = created.into();
-                utc.timestamp()
-            }),
-            modified: metadata.modified().ok().map(|modified| {
-                let utc: DateTime<Utc> = modified.into();
-                utc.timestamp()
-            }),
-            size: metadata.len(),
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::Claims;
@@ -167,17 +126,4 @@ mod tests {
             }
         }
     }
-
-    #[test]
-    fn test_junk_token_is_invalid() {
-        let err = Claims::from_str("uni-֍ՓՓՓՓՓՓՓՓՓՓՓՓՓՓՓ");
-
-        match err.unwrap_err().into_kind() {
-            ErrorKind::InvalidToken => assert!(true),
-            kind => {
-                println!("Unexpected error: {:?}", kind);
-                assert!(false)
-            }
-        }
-    }
 }

src/database/mod.rs

@@ -8,7 +8,7 @@ use std::{
 
 use crate::database::models::{Favorite, InsertFavorite, InsertUser, User};
 
-pub mod models;
+mod models;
 mod schema;
 
 pub trait UserDao {
@@ -44,12 +44,15 @@ impl UserDao for SqliteUserDao {
                 .execute(&self.connection)
                 .unwrap();
 
-            users
+            match users
                 .filter(username.eq(username))
                 .load::<User>(&self.connection)
                 .unwrap()
                 .first()
-                .cloned()
+            {
+                Some(u) => Some(u.clone()),
+                None => None,
+            }
         } else {
             None
         }
@@ -141,7 +144,7 @@ impl FavoriteDao for SqliteFavoriteDao {
             diesel::insert_into(favorites)
                 .values(InsertFavorite {
                     userid: &user_id,
-                    path: favorite_path,
+                    path: &favorite_path,
                 })
                 .execute(connection)
                 .map_err(|_| DbError::new(DbErrorKind::InsertError))
@@ -168,3 +171,74 @@ impl FavoriteDao for SqliteFavoriteDao {
             .map_err(|_| DbError::new(DbErrorKind::QueryError))
     }
 }
+
+#[cfg(test)]
+pub mod testhelpers {
+    use actix_web::dev::{Body, ResponseBody};
+
+    use super::{models::User, UserDao};
+    use std::cell::RefCell;
+    use std::option::Option;
+
+    pub struct TestUserDao {
+        pub user_map: RefCell<Vec<User>>,
+    }
+
+    impl TestUserDao {
+        pub fn new() -> Self {
+            Self {
+                user_map: RefCell::new(Vec::new()),
+            }
+        }
+    }
+
+    impl UserDao for TestUserDao {
+        fn create_user(&self, username: &str, password: &str) -> Option<User> {
+            let u = User {
+                id: (self.user_map.borrow().len() + 1) as i32,
+                username: username.to_string(),
+                password: password.to_string(),
+            };
+
+            self.user_map.borrow_mut().push(u.clone());
+
+            Some(u)
+        }
+
+        fn get_user(&self, user: &str, pass: &str) -> Option<User> {
+            match self
+                .user_map
+                .borrow()
+                .iter()
+                .find(|&u| u.username == user && u.password == pass)
+            {
+                Some(u) => {
+                    let copy = (*u).clone();
+                    Some(copy)
+                }
+                None => None,
+            }
+        }
+
+        fn user_exists(&self, user: &str) -> bool {
+            self.user_map
+                .borrow()
+                .iter()
+                .find(|&u| u.username == user)
+                .is_some()
+        }
+    }
+
+    pub trait BodyReader {
+        fn read_to_str(&self) -> &str;
+    }
+
+    impl BodyReader for ResponseBody<Body> {
+        fn read_to_str(&self) -> &str {
+            match self {
+                ResponseBody::Body(Body::Bytes(ref b)) => std::str::from_utf8(b).unwrap(),
+                _ => panic!("Unknown response body"),
+            }
+        }
+    }
+}

src/files.rs

@@ -1,68 +1,21 @@
 use std::fs::read_dir;
 use std::io;
+use std::io::Error;
 use std::path::{Path, PathBuf};
 
-use ::anyhow;
-use anyhow::{anyhow, Context};
-
-use actix_web::web::{HttpResponse, Query};
-
-use log::{debug, error};
-
-use crate::data::{Claims, PhotosResponse, ThumbnailRequest};
-
 use path_absolutize::*;
 
-pub async fn list_photos(_: Claims, req: Query<ThumbnailRequest>) -> HttpResponse {
+pub fn list_files(dir: PathBuf) -> io::Result<Vec<PathBuf>> {
-    let path = &req.path;
-    if let Some(path) = is_valid_path(path) {
-        debug!("Valid path: {:?}", path);
-        let files = list_files(&path).unwrap_or_default();
-
-        let photos = files
-            .iter()
-            .filter(|&f| {
-                f.metadata().map_or_else(
-                    |e| {
-                        error!("Failed getting file metadata: {:?}", e);
-                        false
-                    },
-                    |md| md.is_file(),
-                )
-            })
-            .map(|path: &PathBuf| {
-                let relative = path
-                    .strip_prefix(dotenv::var("BASE_PATH").unwrap())
-                    .unwrap();
-                relative.to_path_buf()
-            })
-            .map(|f| f.to_str().unwrap().to_string())
-            .collect::<Vec<String>>();
-
-        let dirs = files
-            .iter()
-            .filter(|&f| f.metadata().map_or(false, |md| md.is_dir()))
-            .map(|path: &PathBuf| {
-                let relative = path
-                    .strip_prefix(dotenv::var("BASE_PATH").unwrap())
-                    .unwrap();
-                relative.to_path_buf()
-            })
-            .map(|f| f.to_str().unwrap().to_string())
-            .collect::<Vec<String>>();
-
-        HttpResponse::Ok().json(PhotosResponse { photos, dirs })
-    } else {
-        error!("Bad photos request: {}", req.path);
-        HttpResponse::BadRequest().finish()
-    }
-}
-
-pub fn list_files(dir: &Path) -> io::Result<Vec<PathBuf>> {
     let files = read_dir(dir)?
-        .filter_map(|res| res.ok())
+        .map(|res| res.unwrap())
         .filter(|entry| is_image_or_video(&entry.path()) || entry.file_type().unwrap().is_dir())
         .map(|entry| entry.path())
+        .map(|path: PathBuf| {
+            let relative = path
+                .strip_prefix(dotenv::var("BASE_PATH").unwrap())
+                .unwrap();
+            relative.to_path_buf()
+        })
         .collect::<Vec<PathBuf>>();
 
     Ok(files)
@@ -89,42 +42,29 @@ pub fn is_valid_path(path: &str) -> Option<PathBuf> {
 }
 
 fn is_valid_full_path(base: &Path, path: &str) -> Option<PathBuf> {
-    debug!("Base: {:?}. Path: {}", base, path);
+    let mut path = PathBuf::from(path);
-
+    if path.is_relative() {
-    let path = PathBuf::from(path);
-    let mut path = if path.is_relative() {
         let mut full_path = PathBuf::from(base);
         full_path.push(&path);
-        full_path
+        is_path_above_base_dir(base, &mut full_path).ok()
+    } else if let Ok(path) = is_path_above_base_dir(base, &mut path) {
+        Some(path)
     } else {
-        path
-    };
-
-    match is_path_above_base_dir(base, &mut path) {
-        Ok(path) => Some(path),
-        Err(e) => {
-            error!("{}", e);
         None
     }
 }
-}
 
-fn is_path_above_base_dir(base: &Path, full_path: &mut PathBuf) -> anyhow::Result<PathBuf> {
+fn is_path_above_base_dir(base: &Path, full_path: &mut PathBuf) -> Result<PathBuf, Error> {
-    full_path
+    full_path.absolutize().and_then(|p| {
-        .absolutize()
+        if p.starts_with(base) {
-        .with_context(|| format!("Unable to resolve absolute path: {:?}", full_path))
-        .map_or_else(
-            |e| Err(anyhow!(e)),
-            |p| {
-                if p.starts_with(base) && p.exists() {
             Ok(p.into_owned())
-                } else if !p.exists() {
-                    Err(anyhow!("Path does not exist: {:?}", p))
         } else {
-                    Err(anyhow!("Path above base directory"))
+            Err(io::Error::new(
+                io::ErrorKind::Other,
+                "Path below base directory",
+            ))
         }
-            },
+    })
-        )
 }
 
 #[cfg(test)]
@@ -134,77 +74,6 @@ mod tests {
 
     use super::*;
 
-    mod api {
-        use actix_web::{web::Query, HttpResponse};
-
-        use super::list_photos;
-        use crate::{
-            data::{Claims, PhotosResponse, ThumbnailRequest},
-            testhelpers::TypedBodyReader,
-        };
-
-        use std::fs;
-
-        fn setup() {
-            let _ = env_logger::builder().is_test(true).try_init();
-        }
-
-        #[actix_rt::test]
-        async fn test_list_photos() {
-            setup();
-
-            let claims = Claims {
-                sub: String::from("1"),
-                exp: 12345,
-            };
-
-            let request: Query<ThumbnailRequest> = Query::from_query("path=").unwrap();
-
-            std::env::set_var("BASE_PATH", "/tmp");
-            let mut temp_photo = std::env::temp_dir();
-            let mut tmp = temp_photo.clone();
-
-            tmp.push("test-dir");
-            fs::create_dir_all(tmp).unwrap();
-
-            temp_photo.push("photo.jpg");
-
-            fs::File::create(temp_photo).unwrap();
-
-            let response: HttpResponse = list_photos(claims, request).await;
-
-            let body: PhotosResponse = response.body().read_body();
-
-            assert_eq!(response.status(), 200);
-            assert!(body.photos.contains(&String::from("photo.jpg")));
-            assert!(body.dirs.contains(&String::from("test-dir")));
-            assert!(body
-                .photos
-                .iter()
-                .filter(|filename| !filename.ends_with(".png")
-                    && !filename.ends_with(".jpg")
-                    && !filename.ends_with(".jpeg"))
-                .collect::<Vec<&String>>()
-                .is_empty());
-        }
-
-        #[actix_rt::test]
-        async fn test_list_below_base_fails_400() {
-            setup();
-
-            let claims = Claims {
-                sub: String::from("1"),
-                exp: 12345,
-            };
-
-            let request: Query<ThumbnailRequest> = Query::from_query("path=..").unwrap();
-
-            let response = list_photos(claims, request).await;
-
-            assert_eq!(response.status(), 400);
-        }
-    }
-
     #[test]
     fn directory_traversal_test() {
         assert_eq!(None, is_valid_path("../"));
@@ -216,24 +85,22 @@ mod tests {
     }
 
     #[test]
-    fn build_from_path_relative_to_base_test() {
+    fn build_from_relative_path_test() {
         let base = env::temp_dir();
         let mut test_file = PathBuf::from(&base);
         test_file.push("test.png");
         File::create(test_file).unwrap();
 
         assert!(is_valid_full_path(&base, "test.png").is_some());
-    }
-
-    #[test]
-    fn build_from_relative_returns_none_if_directory_does_not_exist_test() {
-        let base = env::temp_dir();
 
         let path = "relative/path/test.png";
         let mut test_file = PathBuf::from(&base);
         test_file.push(path);
 
-        assert_eq!(None, is_valid_full_path(&base, path));
+        assert_eq!(
+            Some(PathBuf::from("/tmp/relative/path/test.png")),
+            is_valid_full_path(&base, path)
+        );
     }
 
     #[test]
@@ -245,41 +112,44 @@ mod tests {
 
         assert!(is_valid_full_path(&base, test_file.to_str().unwrap()).is_some());
 
+        let path = "relative/path/test.png";
+        let mut test_file = PathBuf::from(&base);
+        test_file.push(path);
+
         assert_eq!(
-            Some(PathBuf::from("/tmp/test.png")),
+            Some(PathBuf::from("/tmp/relative/path/test.png")),
-            is_valid_full_path(&base, "/tmp/test.png")
+            is_valid_full_path(&base, path)
         );
     }
 
-    macro_rules! extension_test {
-        ($name:ident, $filename:literal) => {
     #[test]
-            fn $name() {
+    fn png_valid_extension_test() {
-                assert!(is_image_or_video(Path::new($filename)));
+        assert!(is_image_or_video(Path::new("image.png")));
-            }
+        assert!(is_image_or_video(Path::new("image.PNG")));
-        };
+        assert!(is_image_or_video(Path::new("image.pNg")));
     }
 
-    extension_test!(valid_png, "image.png");
+    #[test]
-    extension_test!(valid_png_mixed_case, "image.pNg");
+    fn jpg_valid_extension_test() {
-    extension_test!(valid_png_upper_case, "image.PNG");
+        assert!(is_image_or_video(Path::new("image.jpeg")));
+        assert!(is_image_or_video(Path::new("image.JPEG")));
+        assert!(is_image_or_video(Path::new("image.jpg")));
+        assert!(is_image_or_video(Path::new("image.JPG")));
+    }
 
-    extension_test!(valid_jpeg, "image.jpeg");
+    #[test]
-    extension_test!(valid_jpeg_upper_case, "image.JPEG");
+    fn mp4_valid_extension_test() {
-    extension_test!(valid_jpg, "image.jpg");
+        assert!(is_image_or_video(Path::new("image.mp4")));
-    extension_test!(valid_jpg_upper_case, "image.JPG");
+        assert!(is_image_or_video(Path::new("image.mP4")));
+        assert!(is_image_or_video(Path::new("image.MP4")));
+    }
 
-    extension_test!(valid_mp4, "image.mp4");
+    #[test]
-    extension_test!(valid_mp4_mixed_case, "image.mP4");
+    fn mov_valid_extension_test() {
-    extension_test!(valid_mp4_upper_case, "image.MP4");
+        assert!(is_image_or_video(Path::new("image.mov")));
-
+        assert!(is_image_or_video(Path::new("image.MOV")));
-    extension_test!(valid_mov, "image.mov");
+        assert!(is_image_or_video(Path::new("image.MoV")));
-    extension_test!(valid_mov_mixed_case, "image.mOV");
+    }
-    extension_test!(valid_mov_upper_case, "image.MOV");
-
-    extension_test!(valid_nef, "image.nef");
-    extension_test!(valid_nef_mixed_case, "image.nEF");
-    extension_test!(valid_nef_upper_case, "image.NEF");
 
     #[test]
     fn hidden_file_not_valid_test() {

src/main.rs

@@ -2,17 +2,17 @@
 extern crate diesel;
 extern crate rayon;
 
+use crate::auth::login;
 use actix_web_prom::PrometheusMetrics;
+use database::{DbError, DbErrorKind, FavoriteDao, SqliteFavoriteDao, SqliteUserDao, UserDao};
 use futures::stream::StreamExt;
 use lazy_static::lazy_static;
 use prometheus::{self, IntGauge};
-use std::sync::{mpsc::channel, Arc};
+use std::path::{Path, PathBuf};
+use std::sync::mpsc::channel;
+use std::sync::Arc;
 use std::{collections::HashMap, io::prelude::*};
 use std::{env, fs::File};
-use std::{
-    io::ErrorKind,
-    path::{Path, PathBuf},
-};
 use walkdir::{DirEntry, WalkDir};
 
 use actix::prelude::*;
@@ -22,18 +22,18 @@ use actix_web::{
     delete,
     error::BlockingError,
     get, middleware, post, put,
-    web::{self, BufMut, BytesMut, HttpRequest, HttpResponse},
+    web::{self, BufMut, BytesMut, HttpRequest, HttpResponse, Query},
     App, HttpServer, Responder,
 };
 use notify::{watcher, DebouncedEvent, RecursiveMode, Watcher};
 use rayon::prelude::*;
+use serde::Serialize;
 
+use data::{AddFavoriteRequest, ThumbnailRequest};
 use log::{debug, error, info};
 
-use crate::auth::login;
+use crate::data::Claims;
-use crate::data::*;
+use crate::files::{is_image_or_video, is_valid_path, list_files};
-use crate::database::*;
-use crate::files::{is_image_or_video, is_valid_path};
 use crate::video::*;
 
 mod auth;
@@ -42,9 +42,6 @@ mod database;
 mod files;
 mod video;
 
-#[cfg(test)]
-mod testhelpers;
-
 lazy_static! {
     static ref IMAGE_GAUGE: IntGauge = IntGauge::new(
         "imageserver_image_total",
@@ -58,6 +55,39 @@ lazy_static! {
     .unwrap();
 }
 
+#[get("/photos")]
+async fn list_photos(_claims: Claims, req: Query<ThumbnailRequest>) -> impl Responder {
+    info!("{}", req.path);
+
+    let path = &req.path;
+    if let Some(path) = is_valid_path(path) {
+        let files = list_files(path).unwrap_or_default();
+
+        let photos = &files
+            .iter()
+            .filter(|f| !f.extension().unwrap_or_default().is_empty())
+            .map(|f| f.to_str().unwrap().to_string())
+            .collect::<Vec<String>>();
+
+        let dirs = &files
+            .iter()
+            .filter(|f| f.extension().unwrap_or_default().is_empty())
+            .map(|f| f.to_str().unwrap().to_string())
+            .collect::<Vec<String>>();
+
+        HttpResponse::Ok().json(PhotosResponse { photos, dirs })
+    } else {
+        error!("Bad photos request: {}", req.path);
+        HttpResponse::BadRequest().finish()
+    }
+}
+
+#[derive(Serialize)]
+struct PhotosResponse<'a> {
+    photos: &'a [String],
+    dirs: &'a [String],
+}
+
 #[get("/image")]
 async fn get_image(
     _claims: Claims,
@@ -89,24 +119,6 @@ async fn get_image(
     }
 }
 
-#[get("/image/metadata")]
-async fn get_file_metadata(_: Claims, path: web::Query<ThumbnailRequest>) -> impl Responder {
-    match is_valid_path(&path.path)
-        .ok_or_else(|| ErrorKind::InvalidData.into())
-        .and_then(File::open)
-        .and_then(|file| file.metadata())
-    {
-        Ok(metadata) => {
-            let response: MetadataResponse = metadata.into();
-            HttpResponse::Ok().json(response)
-        }
-        Err(e) => {
-            error!("Error getting metadata for file '{}': {:?}", path.path, e);
-            HttpResponse::InternalServerError().finish()
-        }
-    }
-}
-
 #[post("/image")]
 async fn upload_image(_: Claims, mut payload: mp::Multipart) -> impl Responder {
     let mut file_content: BytesMut = BytesMut::new();
@@ -166,7 +178,7 @@ async fn generate_video(
         let filename = name.to_str().expect("Filename should convert to string");
         let playlist = format!("tmp/{}.m3u8", filename);
         if let Some(path) = is_valid_path(&body.path) {
-            if let Ok(child) = create_playlist(path.to_str().unwrap(), &playlist).await {
+            if let Ok(child) = create_playlist(&path.to_str().unwrap(), &playlist).await {
                 data.stream_manager
                     .do_send(ProcessMessage(playlist.clone(), child));
             }
@@ -231,8 +243,8 @@ async fn favorites(
             .collect::<Vec<String>>();
 
     HttpResponse::Ok().json(PhotosResponse {
-        photos: favorites,
+        photos: &favorites,
-        dirs: Vec::new(),
+        dirs: &Vec::new(),
     })
 }
 
@@ -358,7 +370,7 @@ fn create_thumbnails() {
     update_media_counts(&images);
 }
 
-fn update_media_counts(media_dir: &Path) {
+fn update_media_counts(media_dir: &PathBuf) {
     let mut image_count = 0;
     let mut video_count = 0;
     for ref entry in WalkDir::new(media_dir).into_iter().filter_map(|e| e.ok()) {
@@ -369,8 +381,8 @@ fn update_media_counts(media_dir: &Path) {
         }
     }
 
-    IMAGE_GAUGE.set(image_count);
+    IMAGE_GAUGE.set(image_count as f64);
-    VIDEO_GAUGE.set(video_count);
+    VIDEO_GAUGE.set(video_count as f64);
 }
 
 fn is_image(entry: &DirEntry) -> bool {
@@ -464,7 +476,7 @@ fn main() -> std::io::Result<()> {
         App::new()
             .wrap(middleware::Logger::default())
             .service(web::resource("/login").route(web::post().to(login)))
-            .service(web::resource("/photos").route(web::get().to(files::list_photos)))
+            .service(list_photos)
             .service(get_image)
             .service(upload_image)
             .service(generate_video)
@@ -473,7 +485,6 @@ fn main() -> std::io::Result<()> {
             .service(favorites)
             .service(put_add_favorite)
             .service(delete_favorite)
-            .service(get_file_metadata)
             .app_data(app_data.clone())
             .data::<Box<dyn UserDao>>(Box::new(user_dao))
             .data::<Box<dyn FavoriteDao>>(Box::new(favorites_dao))

src/testhelpers.rs

@@ -1,86 +0,0 @@
-use actix_web::dev::{Body, ResponseBody};
-use serde::Deserialize;
-
-use crate::database::{models::User, UserDao};
-use std::cell::RefCell;
-use std::option::Option;
-
-pub struct TestUserDao {
-    pub user_map: RefCell<Vec<User>>,
-}
-
-impl TestUserDao {
-    pub fn new() -> Self {
-        Self {
-            user_map: RefCell::new(Vec::new()),
-        }
-    }
-}
-
-impl UserDao for TestUserDao {
-    fn create_user(&self, username: &str, password: &str) -> Option<User> {
-        let u = User {
-            id: (self.user_map.borrow().len() + 1) as i32,
-            username: username.to_string(),
-            password: password.to_string(),
-        };
-
-        self.user_map.borrow_mut().push(u.clone());
-
-        Some(u)
-    }
-
-    fn get_user(&self, user: &str, pass: &str) -> Option<User> {
-        match self
-            .user_map
-            .borrow()
-            .iter()
-            .find(|&u| u.username == user && u.password == pass)
-        {
-            Some(u) => {
-                let copy = (*u).clone();
-                Some(copy)
-            }
-            None => None,
-        }
-    }
-
-    fn user_exists(&self, user: &str) -> bool {
-        self.user_map
-            .borrow()
-            .iter()
-            .find(|&u| u.username == user)
-            .is_some()
-    }
-}
-
-pub trait BodyReader {
-    fn read_to_str(&self) -> &str;
-}
-
-impl BodyReader for ResponseBody<Body> {
-    fn read_to_str(&self) -> &str {
-        match self {
-            ResponseBody::Body(Body::Bytes(ref b)) => std::str::from_utf8(b).unwrap(),
-            _ => panic!("Unknown response body"),
-        }
-    }
-}
-
-pub trait TypedBodyReader<'a, T>
-where
-    T: Deserialize<'a>,
-{
-    fn read_body(&'a self) -> T;
-}
-
-impl<'a, T: Deserialize<'a>> TypedBodyReader<'a, T> for ResponseBody<Body> {
-    fn read_body(&'a self) -> T {
-        match self {
-            ResponseBody::Body(Body::Bytes(ref b)) => {
-                serde_json::from_str(std::str::from_utf8(b).unwrap()).unwrap()
-            }
-            _ => panic!("Unknown response body"),
-        }
-    }
-}