havn 0.1.0

A fast configurable port scanner with reasonable defaults
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use std::{
    fmt,
    io::Write,
    sync::{atomic::AtomicBool, Arc},
};

use crate::terminal::color::Color;

/// State for the loading animation
#[derive(Debug, Default, Clone, Copy)]
pub enum Animation {
    #[default]
    One,
    Two,
    Three,
    Four,
    Five,
    Six,
    Seven,
    Eight,
    Nine,
    Ten,
}

impl Animation {
    fn next(&mut self) {
        *self = match self {
            Self::One => Self::Two,
            Self::Two => Self::Three,
            Self::Three => Self::Four,
            Self::Four => Self::Five,
            Self::Five => Self::Six,
            Self::Six => Self::Seven,
            Self::Seven => Self::Eight,
            Self::Eight => Self::Nine,
            Self::Nine => Self::Ten,
            Self::Ten => Self::One,
        }
    }
}

impl fmt::Display for Animation {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let disp = match self {
            Self::One => '⠋',
            Self::Two => '⠙',
            Self::Three => '⠹',
            Self::Four => '⠸',
            Self::Five => '⠼',
            Self::Six => '⠴',
            Self::Seven => '⠦',
            Self::Eight => '⠧',
            Self::Nine => '⠇',
            Self::Ten => '⠏',
        };
        write!(f, "{}{disp}{}", Color::Red, Color::Reset)
    }
}

#[derive(Debug, Default)]
pub struct Spinner(Arc<AtomicBool>);

impl Spinner {
    /// Show the cursor on the terminal again
    pub fn show_cursor() {
        let mut std = std::io::stdout().lock();
        std.write_all(b"\x1B[?25h").ok();
        std.flush().ok();
    }

    /// Hide the cursor, so spinner line looks nicer
    fn hide_cursor() {
        let mut std = std::io::stdout().lock();
        std.write_all(b"\x1B[?25l").ok();
        std.flush().ok();
    }

    /// Animate the loading icon until run is false
    async fn spin(run: Arc<AtomicBool>) {
        let mut frame = Animation::default();
        while run.load(std::sync::atomic::Ordering::SeqCst) {
            print!("{frame} scanning ");
            std::io::stdout().flush().ok();
            print!("\r");
            frame.next();
            tokio::time::sleep(std::time::Duration::from_millis(75)).await;
        }
    }

    /// Print to stdout a spinner, with the text "scanning"
    /// Spawns into own thread
    pub fn start() -> Self {
        let spinner = Self(Arc::new(AtomicBool::new(true)));
        Self::hide_cursor();
        tokio::spawn(Self::spin(Arc::clone(&spinner.0)));
        spinner
    }

    pub fn stop(&self) {
        self.0.store(false, std::sync::atomic::Ordering::SeqCst);
        Self::show_cursor();
    }
}