upend/src/filesystem.rs

use std::fs;
use std::path::{Path, PathBuf};

use actix::prelude::*;
use anyhow::Result;
use chrono::prelude::*;
use log::{info, warn};
use walkdir::WalkDir;

use crate::hash::{encode, ComputeHash, Hash, HasherWorker};
use crate::models::NewFile;

pub async fn update_directory<T: AsRef<Path>>(
    directory: T,
    db_executor: &Addr<crate::database::DbExecutor>,
    hasher_worker: &Addr<HasherWorker>,
) -> Result<()> {
    for entry in WalkDir::new(&directory)
        .into_iter()
        .filter_map(|e| e.ok())
        .filter(|e| e.path().is_file())
    {
        info!("Processing: {}", entry.path().display());

        let metadata = fs::metadata(entry.path())?;
        let size = metadata.len() as i64;
        if size < 0 {
            panic!("File {} too large?!", entry.path().display());
        }

        let msg = ComputeHash {
            path: entry.path().to_path_buf(),
        };

        let digest: Result<Result<Hash>, MailboxError> = hasher_worker.send(msg).await;

        let new_file = NewFile {
            path: entry
                .path()
                .to_str()
                .expect("path not valid unicode?!")
                .to_string(),
            hash: encode(digest??.0),
            size,
            created: NaiveDateTime::from_timestamp(Utc::now().timestamp(), 0),
        };

        let _insert_result = db_executor
            .send(crate::database::InsertFile { file: new_file })
            .await?;
    }
    info!("Finished updating {}.", directory.as_ref().display());

    Ok(())
}

pub async fn update_directory_bg(
    directory: PathBuf,
    db_executor: Addr<crate::database::DbExecutor>,
    hasher_worker: Addr<HasherWorker>,
) {
    let result = update_directory(directory, &db_executor, &hasher_worker).await;
    if result.is_err() {
        warn!("Update did not succeed!");
    }
}