shrupl/src/main.rs

mod appstate;
mod cli;
mod sharry;

use std::sync::{
    Arc,
    atomic::{AtomicBool, Ordering},
};

use clap::Parser;
use log::{error, info};
use ureq::Agent;

use appstate::AppState;
use cli::Cli;

fn main() {
    let running = Arc::new(AtomicBool::new(true));
    let r = running.clone();

    ctrlc::set_handler(move || r.store(false, Ordering::SeqCst))
        .expect("Error setting Ctrl-C handler");

    env_logger::init();

    let args = Cli::parse();
    info!("args: {args:?}");
    info!("timeout: {:?}", args.get_timeout());

    let agent: Agent = Agent::config_builder()
        .timeout_global(args.get_timeout())
        .build()
        .into();

    let mut state = AppState::try_resume(&args)
        .map(|state| {
            info!("loaded state: {state:?}");

            state
        })
        .or_else(|| AppState::from_args(&args, &agent))
        .unwrap_or_else(|| {
            error!("could not create new state from cli arguments: {args:?}");

            std::process::exit(1);
        });

    info!("continuing with state: {state:?}");
    state.save().unwrap();

    loop {
        match state.upload_chunk(&agent, args.chunk_size * 1024 * 1024) {
            Ok(None) => break,
            Err(e) => error!("error: {e:?}"),
            _ => (),
        }

        state.save().unwrap();

        if !running.load(Ordering::SeqCst) {
            info!("terminating ...");
            std::process::exit(0);
        }
    }

    info!("uploads done");
    state.clear().unwrap();
}