Buggy behaviour inside async context

[synalice]

1. Why isn't ^C printed to the terminal?
2. Why is the spinner still drawn after calling finish_and_clear?
3. (optional) What could cause the terminal to break the way it did inside the Nix devShell? I don't expect you to have any experience with Nix, so that's optional; just in case you have ay ideas. I've created an issue on NixOS forum about it — link.

I feel like there is a race condition somewhere inside this code, but I don't understand what exactly causes it.

Minimal Reproducible Example

Archive

indicatif-async-nix.zip

main.rs

#[tokio::main]
async fn main() {
    let pb = indicatif::ProgressBar::new_spinner().with_message("Beep-boop...");
    pb.enable_steady_tick(std::time::Duration::from_millis(80));

    tokio::signal::ctrl_c()
        .await
        .expect("should be able to set Ctrl-C handler");

    pb.finish_and_clear();

    tokio::time::sleep(std::time::Duration::from_secs(2)).await;
    println!("AHAHHAHA WHAT??????");
}

Screencast of the issue

indicatif-async-nix.mp4

[synalice]

Actually, this might not have anything to do with async and instead might be specifically because of Ctrl+C.

use std::process;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::thread;
use std::time::Duration;

use ctrlc::set_handler;

fn main() {
    let pb = indicatif::ProgressBar::new_spinner().with_message("Beep-boop...");
    pb.enable_steady_tick(std::time::Duration::from_millis(80));

    let pb_clone = pb.clone();

    let running = Arc::new(AtomicUsize::new(0));
    let r = running.clone();
    
    set_handler(move || {
        pb_clone.finish_and_clear();

        let prev = r.fetch_add(1, Ordering::SeqCst);
        if prev == 0 {
            println!("Exiting...");
        } else {
            process::exit(0);
        }
    })
    .expect("error setting Ctrl-C handler");

    println!("Running...");
    for _ in 1..6 {
        thread::sleep(Duration::from_secs(5));
        if running.load(Ordering::SeqCst) > 0 {
            break;
        }
    }
}

[chris-laplante]

IIRC finish_and_clear doesn't stop the spinner. Perhaps it should.

In the meantime, can you try calling disable_steady_tick instead?

[synalice]

IIRC finish_and_clear doesn't stop the spinner. Perhaps it should.

No, it does remove it. This code correctly waits 2 seconds and removes the spinner.

fn main() {
    let pb = indicatif::ProgressBar::new_spinner().with_message("Beep-boop...");
    pb.enable_steady_tick(std::time::Duration::from_millis(80));
    std::thread::sleep(std::time::Duration::from_secs(2));
    pb.finish_and_clear();
}

In the meantime, can you try calling disable_steady_tick instead?

Nope, same thing. Although a least I do see the Ctrl+C when not calling ProgressBar::finish_and_clear.

use std::{process::exit, thread::sleep, time::Duration};

fn main() {
    let pb = indicatif::ProgressBar::new_spinner().with_message("Beep-boop...");
    pb.enable_steady_tick(std::time::Duration::from_millis(80));

    ctrlc::set_handler(move || {
        pb.disable_steady_tick();
        println!("qwerty");
        exit(0);
    })
    .unwrap();

    sleep(Duration::from_secs(60 * 60));
}

$ cargo run
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.01s
     Running `target/debug/devaur`
⠉ Beep-boop...
^Cqwerty

[synalice]

I feel like pressing Ctrl+C writes ^C into stdin which causes indicatif to redraw (the same redraw that would happen if you type anything while the ProgressBar is running). After that the Ctrl+C handler is run and the ProgressBar is cleared. What's left on the screen is a "zombie" bar that was caused by a redraw-because-of-input.

I feel it is not possible to do a Ctrl+C handler from outside of the indicatif (as its user). It should be indicatif's job to look for SIGINT and avoid drawing over it. Although I'm not sure how exactly that would look like.

Honestly, I can can't imaging needing a progress bar and not adding any SIGINT handling logic (like removing a partially downloaded file). I don't understand, how come I am the first person to complain about it?

use std::{
    process::exit,
    thread::{self, sleep},
    time::Duration,
};

fn main() {
    let pb = indicatif::ProgressBar::new(100).with_message("Beep-boop...");

    let pb_t1 = pb.clone();
    let t1 = thread::spawn(move || {
        loop {
            pb_t1.inc(1);
            sleep(Duration::from_secs(1));
        }
    });

    thread::spawn(|| {
        ctrlc::set_handler(move || {
            pb.finish_and_clear();
            sleep(Duration::from_secs(2));
            println!("qwerty");
            exit(0);
        })
        .unwrap();
        sleep(Duration::from_secs(60 * 60));
    })
    .join()
    .unwrap();

    t1.join().unwrap();
}