ic-query-cli 0.61.0

Command-line wrapper for read-only Internet Computer metadata queries
Documentation 
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

//! Module: progress
//!
//! Responsibility: render library progress events for the `icq` process.
//! Does not own: refresh orchestration, cache policy, or report construction.
//! Boundary: owns terminal detection and stderr output for query progress.

use ic_host_text::progress::ProgressLine as ProgressFrames;
use ic_query::{QueryProgress, QueryProgressEvent, QueryProgressState};
use std::io::{self, IsTerminal, Write};

///
/// StderrQueryProgress
///
/// CLI progress sink that renders structured query events on stderr.
///

#[derive(Debug)]
pub struct StderrQueryProgress {
    line: ProgressLine,
}

impl StderrQueryProgress {
    /// Create a CLI progress sink using the current stderr terminal state.
    pub fn new() -> Self {
        Self {
            line: ProgressLine::stderr(),
        }
    }
}

impl QueryProgress for StderrQueryProgress {
    fn report(&mut self, event: QueryProgressEvent) {
        match event {
            QueryProgressEvent::CacheRefresh {
                component,
                path,
                source_endpoint,
            } => {
                self.line.clear();
                eprintln!(
                    "{component} cache refresh required at {}; calling {source_endpoint} to refresh/create cache",
                    path.display()
                );
            }
            QueryProgressEvent::PagedRefresh { text, state } => {
                if state == QueryProgressState::Running {
                    self.line.update(&text);
                } else {
                    self.line.finish(&text);
                }
            }
        }
    }
}

///
/// ProgressLine
///
/// Same-line stderr writer used by the CLI progress sink.
///

#[derive(Debug)]
struct ProgressLine {
    enabled: bool,
    frames: ProgressFrames,
    stderr: io::Stderr,
}

impl ProgressLine {
    fn stderr() -> Self {
        Self {
            enabled: io::stderr().is_terminal(),
            frames: ProgressFrames::new(),
            stderr: io::stderr(),
        }
    }

    fn update(&mut self, text: &str) {
        if self.enabled {
            let frame = self.frames.update(text);
            self.write_frame(&frame);
        }
    }

    fn finish(&mut self, text: &str) {
        if self.enabled {
            let frame = self.frames.finish(text);
            self.write_frame(&frame);
        }
    }

    fn clear(&mut self) {
        if self.enabled {
            let frame = self.frames.clear();
            if !frame.is_empty() {
                self.write_frame(&frame);
            }
        }
    }

    fn write_frame(&mut self, frame: &str) {
        let _ = self.stderr.write_all(frame.as_bytes());
        let _ = self.stderr.flush();
    }
}

impl Drop for ProgressLine {
    fn drop(&mut self) {
        self.clear();
    }
}