aven 0.1.13

Local-first task manager CLI and sync server
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

use std::sync::{Arc, atomic::AtomicBool};

use anyhow::Result;

use crate::cli::SelfUpdateArgs;
use crate::update::{self, CheckOutcome, Release};

pub(crate) async fn run(args: SelfUpdateArgs) -> Result<()> {
    let client = update::client()?;
    println!("Checking for aven updates...");
    let (release, cached) = match update::check_for_update(&client, true).await {
        Ok(CheckOutcome::Current { version, cached }) => {
            println!(
                "aven v{} is current (latest release v{version}){}",
                update::CURRENT_VERSION,
                cached_suffix(cached)
            );
            return Ok(());
        }
        Ok(CheckOutcome::Available { release, cached }) => (release, cached),
        Err(error) => match update::cached_update() {
            Some(release) => (release, true),
            None => return Err(error),
        },
    };

    install_release(client, release, cached, args.yes).await
}

async fn install_release(
    client: reqwest::Client,
    release: Release,
    cached: bool,
    yes: bool,
) -> Result<()> {
    let plan = update::install_plan(release.clone());
    if let Some(lines) = plan.guidance() {
        for line in lines {
            println!("{line}");
        }
        if cached {
            println!("Release information came from the local cache.");
        }
        return Ok(());
    }

    let target = plan
        .direct_target()
        .expect("direct update plan must have a target");
    if !yes {
        println!(
            "aven v{} can update to v{} at {}{}",
            update::CURRENT_VERSION,
            release.version,
            target.display(),
            cached_suffix(cached)
        );
        println!("Run `aven update --yes` to install it.");
        return Ok(());
    }

    let (progress_tx, mut progress_rx) = update::progress_channel();
    let cancelled = Arc::new(AtomicBool::new(false));
    let install = update::install_direct(client, plan, progress_tx, cancelled);
    tokio::pin!(install);
    let mut phase = progress_rx.borrow().phase;
    println!("{}...", phase.label());

    let success = loop {
        tokio::select! {
            result = &mut install => break result?,
            changed = progress_rx.changed() => {
                if changed.is_err() {
                    continue;
                }
                let next = progress_rx.borrow().phase;
                if next != phase {
                    phase = next;
                    println!("{}...", phase.label());
                }
            }
        }
    };

    println!("Installed aven v{}.", success.version);
    println!("Restart any running aven processes to use the update.");
    Ok(())
}

fn cached_suffix(cached: bool) -> &'static str {
    if cached {
        " using cached release information"
    } else {
        ""
    }
}