busybar 0.0.8

BUSY Bar CLI
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use busylib::types::log_name::LogName;
use clap::Subcommand;

use crate::cli::Context;
use crate::error::Result;
use crate::reporter::{
    SystemLogDumpEvent, SystemStatusDeviceEvent, SystemStatusEvent, SystemStatusFirmwareEvent,
    SystemStatusPowerEvent, SystemStatusSystemEvent, SystemTransportEvent, SystemVersionEvent,
};

#[derive(Debug, Subcommand)]
pub enum SystemCommand {
    /// Show the HTTP API version
    Version,

    /// Show how the device is connected
    Transport,

    /// Show device, firmware, system and power information
    Status,

    /// Show device information
    StatusDevice,

    /// Show firmware information
    StatusFirmware,

    /// Show system information
    StatusSystem,

    /// Show power and battery information
    StatusPower,

    /// Write the in-memory log to a file
    LogDump {
        /// Destination file name without extension
        #[arg(long, short = 'f', value_name = "NAME")]
        filename: Option<LogName>,
    },
}

impl SystemCommand {
    pub async fn run(self, context: &Context) -> Result<()> {
        match self {
            SystemCommand::Version => version(context).await,
            SystemCommand::Transport => transport(context).await,
            SystemCommand::Status => status(context).await,
            SystemCommand::StatusDevice => status_device(context).await,
            SystemCommand::StatusFirmware => status_firmware(context).await,
            SystemCommand::StatusSystem => status_system(context).await,
            SystemCommand::StatusPower => status_power(context).await,
            SystemCommand::LogDump { filename } => log_dump(context, filename).await,
        }
    }
}

async fn version(context: &Context) -> Result<()> {
    let version = context.client.system().version().await?;

    context.reporter.report(SystemVersionEvent::new(version))?;

    Ok(())
}

async fn transport(context: &Context) -> Result<()> {
    let transport = context.client.system().transport().await?;

    context
        .reporter
        .report(SystemTransportEvent::new(transport))?;

    Ok(())
}

async fn status(context: &Context) -> Result<()> {
    let status = context.client.system().status().await?;

    context.reporter.report(SystemStatusEvent::new(status))?;

    Ok(())
}

async fn status_device(context: &Context) -> Result<()> {
    let device = context.client.system().status_device().await?;

    context
        .reporter
        .report(SystemStatusDeviceEvent::new(device))?;

    Ok(())
}

async fn status_firmware(context: &Context) -> Result<()> {
    let firmware = context.client.system().status_firmware().await?;

    context
        .reporter
        .report(SystemStatusFirmwareEvent::new(firmware))?;

    Ok(())
}

async fn status_system(context: &Context) -> Result<()> {
    let system = context.client.system().status_system().await?;

    context
        .reporter
        .report(SystemStatusSystemEvent::new(system))?;

    Ok(())
}

async fn log_dump(context: &Context, filename: Option<LogName>) -> Result<()> {
    let path = context.client.system().log_dump(filename).await?;

    context.reporter.report(SystemLogDumpEvent::new(path))?;

    Ok(())
}

async fn status_power(context: &Context) -> Result<()> {
    let power = context.client.system().status_power().await?;

    context
        .reporter
        .report(SystemStatusPowerEvent::new(power))?;

    Ok(())
}