trunk 0.21.14

Build, bundle & ship your Rust WASM application to the web.
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 semver::Version;
use serde::{Deserialize, Serialize};
use std::io::ErrorKind;
use std::path::PathBuf;
use time::{Duration, OffsetDateTime};

const CHECK_PERIOD: Duration = Duration::days(1);

/// Get the path to the state file.
fn state_file() -> Option<PathBuf> {
    let dirs = directories::BaseDirs::new()?;
    let path = dirs.state_dir().unwrap_or_else(|| dirs.data_local_dir());

    Some(path.join(env!("CARGO_PKG_NAME")).join("update.json"))
}

#[derive(Clone, Debug, Serialize, Deserialize)]
struct StateInformation {
    #[serde(with = "time::serde::rfc3339")]
    pub last_check: OffsetDateTime,

    pub versions: Versions,
}

#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct Versions {
    /// The most recent released version
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub release: Option<Version>,

    /// The most recent version, including pre-releases
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prerelease: Option<Version>,
}

#[derive(Clone, Debug)]
pub enum State {
    NotNeeded(Versions),
    Needed,
}

/// Evaluate if we are due for a check
///
/// Returns `false` if anything goes wrong.
pub async fn need_check() -> State {
    let Some(file) = state_file() else {
        tracing::debug!("Unable to find a user home. Skipping update checks.");
        return State::NotNeeded(Default::default());
    };

    let state = match tokio::fs::read(&file).await {
        Err(err) if err.kind() == ErrorKind::NotFound => return State::Needed,
        Err(err) => {
            tracing::debug!(
                "Failed to check update state file ({}), skipping: {err}",
                file.display()
            );
            return State::NotNeeded(Default::default());
        }
        Ok(state) => state,
    };

    let Ok(state) = serde_json::from_slice::<StateInformation>(&state) else {
        // if we can't read the file, check and re-write
        return State::Needed;
    };

    let diff = OffsetDateTime::now_utc() - state.last_check;

    tracing::debug!("Time since last check: {diff}");

    if diff > CHECK_PERIOD {
        State::Needed
    } else {
        State::NotNeeded(state.versions)
    }
}

/// Record that we did perform a check.
///
/// Silently ignores errors.
pub async fn record_checked(versions: Versions) {
    let Some(file) = state_file() else {
        tracing::debug!("Unable to find a user home. Skipping update checks.");
        return;
    };

    let state = match serde_json::to_vec(&StateInformation {
        last_check: OffsetDateTime::now_utc(),
        versions,
    }) {
        Ok(state) => state,
        Err(err) => {
            tracing::debug!("Unable to serialize state file: {err}");
            return;
        }
    };

    if let Some(parent) = file.parent() {
        if let Err(err) = tokio::fs::create_dir_all(parent).await {
            tracing::debug!(
                "Failed to create parent directory for update state ({}): {err}",
                parent.display()
            );
            return;
        }
    }

    if let Err(err) = tokio::fs::write(&file, state).await {
        tracing::debug!(
            "Failed to write update state file ({}): {err}",
            file.display()
        );
    }
}