creeper 1.0.0-alpha.10

Minecraft Package Manager
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

use std::{
    path::PathBuf,
    time::{Duration, SystemTime, UNIX_EPOCH},
};

use anyhow::bail;
use tokio::fs::{create_dir_all, read_to_string, try_exists, write};
use tracing::debug;

use crate::{
    Id,
    index::{Index, IndexLine},
    path::creeper_cache_dir,
};

pub trait SyncBuiltinIndex {
    fn package(&self) -> Id;

    async fn sync_index(&self) -> anyhow::Result<Index>;

    fn cache_expiry(&self) -> Duration {
        Duration::from_secs(0)
    }
}

pub trait GetIndex {
    async fn get_index(&self) -> anyhow::Result<Index>;
}

pub trait BlockingGetIndex {
    fn blocking_get_index(&self) -> anyhow::Result<Index>;
}

pub trait UpdateIndex {
    async fn update_index(&self) -> anyhow::Result<()>;
}

impl<T: SyncBuiltinIndex> UpdateIndex for T {
    async fn update_index(&self) -> anyhow::Result<()> {
        let package = self.package();

        let cache = builtin_index_cache(&package)?;

        let last_updated = creeper_cache_dir()?
            .join("builtin")
            .join(&*package)
            .join("index-last-updated");

        if try_exists(&cache).await?
            && self.get_index().await.is_ok()
            && try_exists(&last_updated).await?
        {
            let last_updated = read_to_string(&last_updated).await?.parse::<u64>()?;
            let last_updated = SystemTime::UNIX_EPOCH + Duration::from_secs(last_updated);

            let now = SystemTime::now();

            if let Ok(time) = now.duration_since(last_updated)
                && time < self.cache_expiry()
            {
                debug!("skipping builtin index update for {package} because cache is still valid");
                return Ok(());
            }
        }

        let index = self.sync_index().await?;

        IndexLine::write(cache, &package, index).await?;

        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_secs();

        create_dir_all(last_updated.parent().unwrap()).await?;

        write(&last_updated, now.to_string()).await?;

        Ok(())
    }
}

fn builtin_index_cache(package: &Id) -> anyhow::Result<PathBuf> {
    let path = creeper_cache_dir()?
        .join("index")
        .join(package.indexed_path())
        .with_added_extension("jsonl");

    Ok(path)
}

impl<T: SyncBuiltinIndex> GetIndex for T {
    async fn get_index(&self) -> anyhow::Result<Index> {
        let package = self.package();

        let cache = builtin_index_cache(&package)?;

        if !cache.exists() {
            bail!("missing package index for {} in local cache", package);
        }

        let index = IndexLine::read(cache).await?;

        Ok(index)
    }
}

impl<T: SyncBuiltinIndex> BlockingGetIndex for T {
    fn blocking_get_index(&self) -> anyhow::Result<Index> {
        let package = self.package();

        let cache = builtin_index_cache(&package)?;

        if !cache.exists() {
            bail!("missing package index for {} in local cache", package);
        }

        let index = IndexLine::blocking_read(cache)?;

        Ok(index)
    }
}