urma-cli 0.2.2

Command-line program for URMA identities, wallets, Wire, archives and Git
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
104
105
106
107
108
109
110
111
112
113
114
115

use crate::git_terminal;
use std::{
    fs::File,
    io::Write,
    sync::Mutex,
    time::{Duration, Instant},
};
use tracing::{
    Event, Subscriber,
    field::{Field, Visit},
};
use tracing_subscriber::{
    Layer,
    fmt::{
        format::Writer,
        time::{FormatTime, SystemTime},
    },
    layer::Context,
};

#[derive(Default)]
struct Update {
    phase: String,
    done: u64,
    total: u64,
    counted: bool,
}

impl Visit for Update {
    fn record_str(&mut self, field: &Field, value: &str) {
        if field.name() == "phase" {
            self.phase = value.to_owned();
        }
    }

    fn record_u64(&mut self, field: &Field, value: u64) {
        match field.name() {
            "done" => self.done = value,
            "total" => {
                self.total = value;
                self.counted = true;
            }
            _ => {}
        }
    }

    fn record_debug(&mut self, _field: &Field, _value: &dyn std::fmt::Debug) {}
}

struct LoggedProgress {
    file: File,
    phase: String,
    at: Instant,
}

pub(crate) struct ProgressLayer {
    logged: Mutex<LoggedProgress>,
    enabled: bool,
}

impl ProgressLayer {
    pub(crate) fn new(file: File, enabled: bool) -> Self {
        Self {
            logged: Mutex::new(LoggedProgress {
                file,
                phase: String::new(),
                at: Instant::now(),
            }),
            enabled,
        }
    }
}

impl LoggedProgress {
    fn record(&mut self, update: &Update) {
        let mut timestamp = String::new();
        match SystemTime.format_time(&mut Writer::new(&mut timestamp)) {
            Ok(()) => (),
            Err(cause) => panic!("cannot format progress timestamp: {cause}"),
        }
        let line = format!(
            "{timestamp} INFO urma_activity: Progress phase={:?} done={} total={} counted={}\n",
            update.phase, update.done, update.total, update.counted
        );
        match self.file.write_all(line.as_bytes()) {
            Ok(()) => (),
            Err(cause) => panic!("cannot write progress log: {cause}"),
        }
    }
}

impl<S: Subscriber> Layer<S> for ProgressLayer {
    fn on_event(&self, event: &Event<'_>, _context: Context<'_, S>) {
        let mut update = Update::default();
        event.record(&mut update);
        if !update.phase.is_empty() {
            git_terminal::stage_progress(&update.phase, update.done, update.total, update.counted);
            if !self.enabled {
                return;
            }
            let mut logged = match self.logged.lock() {
                Ok(logged) => logged,
                Err(cause) => panic!("progress log lock poisoned: {cause}"),
            };
            if logged.phase != update.phase
                || (update.counted && update.done == update.total)
                || logged.at.elapsed() >= Duration::from_secs(5)
            {
                logged.record(&update);
                logged.phase = update.phase;
                logged.at = Instant::now();
            }
        }
    }
}