libxinux 1.0.2

Collection of API & ABI for Xinux
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
97
98
99
100
101
102
103
104
105
106
107

use std::path::PathBuf;

use anyhow::{anyhow, Context, Result};
use serde::{Deserialize, Serialize};
use tokio::fs;

use super::revision::get_revision;

#[derive(Debug, Clone, Deserialize, Serialize)]
struct DatabaseCache {
    current_rev: String,
    new_rev: String,
}

pub enum DatabaseCacheEntry {
    Current,
    New,
}

pub async fn fetch_database(rev: &str, entry: DatabaseCacheEntry) -> Result<String> {
    let cache_file_path = format!("{}/.cache/libxinux/cache.json", std::env::var("HOME")?);
    if !PathBuf::from(&cache_file_path).exists() {
        fs::create_dir_all(
            PathBuf::from(&cache_file_path)
                .parent()
                .context("Invalid path")?,
        )
        .await?;
        fs::write(&cache_file_path, r#"{"current_rev": "", "new_rev": ""}"#).await?;
    }
    let cache_content = fs::read_to_string(&cache_file_path).await?;
    let mut cachejson: DatabaseCache = serde_json::from_str(&cache_content)?;
    match entry {
        DatabaseCacheEntry::Current if rev != cachejson.current_rev => {
            cachejson.current_rev = rev.to_string();
        }
        DatabaseCacheEntry::New if rev != cachejson.new_rev => {
            cachejson.new_rev = rev.to_string();
        }
        _ => {}
    }
    fs::write(&cache_file_path, serde_json::to_string(&cachejson)?).await?;

    let outpath = format!("{}/.cache/libxinux/{}.db", std::env::var("HOME")?, rev);

    if PathBuf::from(&outpath).exists() {
        cleanup(&outpath, &cachejson).await?;
        return Ok(outpath);
    }

    let client = reqwest::Client::builder().brotli(true).build()?;
    let output = client
        .get(format!("https://api.snowflakeos.org/libsnow/{}", rev))
        .send()
        .await?;

    let status = output.status();
    if !status.is_success() {
        return Err(anyhow!("Failed to fetch database: {}", status));
    }

    fs::create_dir_all(PathBuf::from(&outpath).parent().context("Invalid path")?).await?;
    fs::write(&outpath, output.bytes().await?).await?;

    cleanup(&outpath, &cachejson).await?;

    Ok(outpath)
}

async fn cleanup(outpath: &str, cachejson: &DatabaseCache) -> Result<()> {
    // Clean up old databases
    let mut old_dbs = fs::read_dir(format!("{}/.cache/libxinux/", std::env::var("HOME")?)).await?;
    while let Ok(Some(entry)) = old_dbs.next_entry().await {
        let path = entry.path();
        if path.extension().unwrap_or_default() == "db" {
            let path_stem = path
                .file_stem()
                .unwrap_or_default()
                .to_string_lossy()
                .to_string();
            if path != PathBuf::from(&outpath)
                && path_stem != cachejson.current_rev
                && path_stem != cachejson.new_rev
            {
                fs::remove_file(path).await?;
            }
        }
    }
    Ok(())
}

pub async fn database_connection() -> Result<rusqlite::Connection> {
    let rev = get_revision().await?;
    let path = fetch_database(&rev, DatabaseCacheEntry::Current).await?;
    Ok(rusqlite::Connection::open(path)?)
}

pub async fn database_connection_offline() -> Result<rusqlite::Connection> {
    let mut dbs = fs::read_dir(format!("{}/.cache/libxinux/", std::env::var("HOME")?)).await?;
    while let Ok(Some(entry)) = dbs.next_entry().await {
        let path = entry.path();
        if path.extension().unwrap_or_default() == "db" {
            return Ok(rusqlite::Connection::open(path)?);
        }
    }
    Err(anyhow!("No database found"))
}