reddit-image-wall-rs/src/fetch_preload/mod.rs

use super::subprograms::*;
use std::collections::HashMap;
use threadpool::ThreadPool;

pub static SUBPROGRAM: Subprogram = Subprogram {
    name: SUBPROGRAM_NAME,
    wrapper,
};

pub static SUBPROGRAM_NAME: &str = "fetch-preload";

fn wrapper<'a>(arg: &HashMap<String, String>) -> WrapperFnRet<'a> {
    let redownload_empties =
        parse_from::<bool>(arg, &"redownload_empties".to_string(), &"false".to_string())?;
    let redownload_all =
        parse_from::<bool>(arg, &"redownload_all".to_string(), &"false".to_string())?;
    let retry_generic_errors = parse_from::<bool>(
        arg,
        &"retry_generic_errors".to_string(),
        &"false".to_string(),
    )?;
    let retry_unknown_errors = parse_from::<bool>(
        arg,
        &"retry_unknown_errors".to_string(),
        &"false".to_string(),
    )?;
    let retry_network_errors = parse_from::<bool>(
        arg,
        &"retry_network_errors".to_string(),
        &"false".to_string(),
    )?;
    let retry_not_found_errors = parse_from::<bool>(
        arg,
        &"retry_not_found_errors".to_string(),
        &"false".to_string(),
    )?;
    let retry_auth_errors =
        parse_from::<bool>(arg, &"retry_auth_errors".to_string(), &"false".to_string())?;
    let retry_format_errors = parse_from::<bool>(
        arg,
        &"retry_format_errors".to_string(),
        &"false".to_string(),
    )?;
    let retry_extractor_errors = parse_from::<bool>(
        arg,
        &"retry_extractor_errors".to_string(),
        &"false".to_string(),
    )?;
    let retry_os_errors =
        parse_from::<bool>(arg, &"retry_os_errors".to_string(), &"false".to_string())?;
    let retry_not_in_disk_errors = parse_from::<bool>(
        arg,
        &"retry_not_in_disk_errors".to_string(),
        &"false".to_string(),
    )?;
    let retry_python_exception = parse_from::<bool>(
        arg,
        &"retry_python_exception".to_string(),
        &"false".to_string(),
    )?;
    let skip_indexed_files =
        parse_from::<bool>(arg, &"skip_indexed_files".to_string(), &"false".to_string())?;
    let mut retry_gdl_mask =
        parse_from::<u16>(arg, &"retry_gdl_mask".to_string(), &"0".to_string())?;
    let split_workers =
        parse_from::<usize>(arg, &"split_workers".to_string(), &"10000".to_string())?;
    let custom_worker_splits = serde_json::from_str::<HashMap<String, usize>>(
        arg.get(&"custom_worker_splits".to_string())
            .unwrap_or(&"".to_string()),
    )
    .unwrap_or(HashMap::new());
    let ignore_workers = serde_json::from_str::<Vec<String>>(
        arg.get(&"ignore_workers".to_string())
            .unwrap_or(&"".to_string()),
    )
    .unwrap_or(vec![]);
    if retry_generic_errors {
        retry_gdl_mask |= 1 << 0;
    }
    if retry_unknown_errors {
        retry_gdl_mask |= 1 << 1;
    }
    if retry_network_errors {
        retry_gdl_mask |= 1 << 2;
    }
    if retry_not_found_errors {
        retry_gdl_mask |= 1 << 3;
    }
    if retry_auth_errors {
        retry_gdl_mask |= 1 << 4;
    }
    if retry_format_errors {
        retry_gdl_mask |= 1 << 5;
    }
    if retry_extractor_errors {
        retry_gdl_mask |= 1 << 6;
    }
    if retry_os_errors {
        retry_gdl_mask |= 1 << 7;
    }
    if retry_not_in_disk_errors {
        retry_gdl_mask |= 1 << 8;
    }
    if retry_python_exception {
        retry_gdl_mask |= 1 << 9;
    }
    Ok(Box::new(FetchCallable {
        redownload_empties,
        redownload_all,
        skip_indexed_files,
        retry_gdl_mask,
        split_workers,
        custom_worker_splits,
        ignore_workers,
    }))
}

struct FetchCallable {
    redownload_empties: bool,
    redownload_all: bool,
    skip_indexed_files: bool,
    retry_gdl_mask: u16,
    split_workers: usize,
    custom_worker_splits: HashMap<String, usize>,
    ignore_workers: Vec<String>,
}

impl SubprogramWithArguments for FetchCallable {
    fn call(&self) -> Result<(), String> {
        main(
            self.redownload_empties,
            self.redownload_all,
            self.skip_indexed_files,
            self.retry_gdl_mask,
            self.split_workers,
            &self.custom_worker_splits,
            &self.ignore_workers,
        )
    }
}

fn main(
    redownload_empties: bool,
    redownload_all: bool,
    skip_indexed_files: bool,
    retry_gdl_mask: u16,
    split_workers: usize,
    custom_worker_splits: &HashMap<String, usize>,
    ignore_workers: &Vec<String>,
) -> Result<(), String> {
    Ok(())
}