mega-cli 0.1.3

A command-line tool for interacting with MEGA
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

use std::pin::pin;
use std::process::ExitCode;
use std::time::Duration;

use clap::Parser;
use color_eyre::eyre::Context;
use indicatif::ProgressBar;

use crate::config::Config;
use crate::utils;
use crate::utils::terminal::USER_ATTENDED;
use crate::Result;

#[derive(Debug, Clone, PartialEq, Parser)]
#[command(author, rename_all = "kebab-case")]
pub struct Opts {}

impl Opts {
    pub fn may_need_user_session(&self) -> bool {
        true
    }
}

pub async fn handle(_: Config, mega: &mega::Client, _: Opts) -> Result<ExitCode> {
    let mut nodes = {
        let maybe_bar = USER_ATTENDED.then(|| {
            let bar = ProgressBar::new_spinner();
            bar.set_style(utils::terminal::spinner_style());
            bar.set_message("fetching MEGA nodes...");
            bar.enable_steady_tick(Duration::from_millis(75));
            bar
        });

        let nodes = mega
            .fetch_own_nodes()
            .await
            .context("could net fetch own MEGA nodes")?;

        if let Some(bar) = maybe_bar {
            bar.finish_and_clear();
        }

        nodes
    };

    let ctrl_c = tokio::signal::ctrl_c();
    let mut ctrl_c = pin!(ctrl_c);

    loop {
        let maybe_bar = USER_ATTENDED.then(|| {
            let bar = ProgressBar::new_spinner();
            bar.set_style(utils::terminal::spinner_style());
            bar.set_message(format!("waiting for new events (CTRL-C to terminate)..."));
            bar.enable_steady_tick(Duration::from_millis(75));
            bar
        });

        let events = tokio::select! {
            biased;
            _ = &mut ctrl_c => {
                if let Some(bar) = maybe_bar {
                    bar.finish_and_clear();
                }

                return Ok(ExitCode::SUCCESS);
            },
            events = mega.wait_events(&nodes) => events?,
        };

        if let Some(bar) = maybe_bar {
            bar.finish_and_clear();
        }

        for event in events.events() {
            match event {
                mega::Event::NodeCreated { nodes } => {
                    for node in nodes {
                        crate::info!(to: std::io::stdout(), from: "mega:follow", "created node: (H:{0}) `{1}`", node.handle(), node.name())?;
                    }
                }
                mega::Event::NodeUpdated { attrs } => {
                    if let Some(node) = nodes.get_node_by_handle(attrs.handle()) {
                        crate::info!(to: std::io::stdout(), from: "mega:follow", "updated node: (H:{0}) `{1}`", node.handle(), node.name())?;
                    }
                }
                mega::Event::NodeDeleted { handle } => {
                    if let Some(node) = nodes.get_node_by_handle(handle) {
                        crate::info!(to: std::io::stdout(), from: "mega:follow", "deleted node: (H:{0}) `{1}`", node.handle(), node.name())?;
                    }
                }
            }
        }

        nodes.apply_events(events)?;
    }

    // Ok(ExitCode::SUCCESS)
}