Method new

arc-disk-cache/src/lib.rs:279–481

(capacity: usize, content_dir: P, durable_fs: bool)

    D: Serialize + DeserializeOwned + Clone + Debug + Sync + Send + 'static,
{
    pub fn new<P>(capacity: usize, content_dir: P, durable_fs: bool) -> io::Result<Self>
    where
        P: AsRef<Path>,
    {
        let content_dir: &Path = content_dir.as_ref();

        info!("capacity: {}  content_dir: {:?}", capacity, content_dir);

        let cache = Arc::new(
            ARCacheBuilder::new()
                .set_size(capacity, 0)
                .set_watermark(0)
                .set_reader_quiesce(false)
                .build()
                .ok_or_else(|| {
                    io::Error::new(
                        io::ErrorKind::Other,
                        "Failed to build Arc Disk Cache - Invalid Parameters",
                    )
                })?,
        );

        let running = Arc::new(AtomicBool::new(true));
        // Clean up the legacy content structure.
        let entries = std::fs::read_dir(content_dir)?
            .filter_map(|dir_ent| dir_ent.ok().map(|d| d.path()))
            .filter(|dir_ent| !dir_ent.is_dir())
            .collect::<Vec<_>>();

        let garbage_path = content_dir.join("garbage");

        if !garbage_path.exists() {
            let _ = fs::create_dir(&garbage_path);
        }

        let temp_path = content_dir.join("tmp");

        if !temp_path.exists() {
            let _ = fs::create_dir(&temp_path);
        }

        debug!("Start cleanup");

        for dir_ent in entries {
            if let Some(fname) = dir_ent.file_name() {
                let dir_ent_gbg = garbage_path.join(fname);
                info!("{:?}", dir_ent_gbg);
                if !dir_ent_gbg.exists() {
                    fs::rename(dir_ent, dir_ent_gbg).inspect_err(|err| error!(?err))?
                } else {
                    warn!("Unable to cleanup {:?}", dir_ent_gbg);
                }
            }
        }

        debug!("start new content dirs");

        // Make a map for the u8 -> hex str.