inapt 0.2.0

A minimal Debian/Ubuntu APT repository proxy written in Rust. Exposes a valid APT repo structure over HTTP, sourcing .deb packages from GitHub Releases.
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use std::{io::Write, sync::Arc};

use anyhow::Context;
use tokio::sync::RwLock;

use crate::domain::entity::{DebAsset, Package, ReleaseMetadata};

const fn default_true() -> bool {
    true
}

#[derive(Debug, serde::Deserialize)]
pub struct Config {
    path: std::path::PathBuf,
    #[serde(default = "default_true")]
    ignore_errors: bool,
}

impl Config {
    pub fn build(self) -> anyhow::Result<MemoryStorage> {
        if !self.path.exists() {
            return Ok(MemoryStorage::new(self.path));
        }
        match Inner::read(&self.path) {
            Ok(inner) => Ok(MemoryStorage::from(inner)),
            Err(err) if self.ignore_errors => {
                tracing::warn!(error = ?err, "unable to load last value, ignoring");
                Ok(MemoryStorage::new(self.path))
            }
            Err(err) => Err(err),
        }
    }
}

#[derive(Debug)]
struct Inner {
    path: std::path::PathBuf,
    value: Option<ReleaseMetadata>,
}

impl Inner {
    fn read(path: &std::path::Path) -> anyhow::Result<Self> {
        let file = std::fs::File::open(path).context("unable to open storage file")?;
        let value: ReleaseMetadata =
            serde_json::from_reader(file).context("unable to deserialize storage file")?;
        Ok(Inner {
            path: std::path::PathBuf::from(path),
            value: Some(value),
        })
    }

    fn persist(&self) -> anyhow::Result<()> {
        if let Some(ref value) = self.value {
            let mut file = std::fs::OpenOptions::new()
                .create(true)
                .truncate(true)
                .write(true)
                .open(&self.path)
                .context("unable to open storage file")?;
            serde_json::to_writer(&mut file, value).context("unable to write to storage file")?;
            file.flush()?;
        }
        Ok(())
    }
}

#[derive(Clone, Debug)]
pub struct MemoryStorage(Arc<RwLock<Inner>>);

impl From<Inner> for MemoryStorage {
    fn from(value: Inner) -> Self {
        MemoryStorage(Arc::new(RwLock::new(value)))
    }
}

impl MemoryStorage {
    fn new(path: impl Into<std::path::PathBuf>) -> Self {
        MemoryStorage(Arc::new(RwLock::new(Inner {
            path: path.into(),
            value: None,
        })))
    }
}

impl crate::domain::prelude::ReleaseStore for MemoryStorage {
    async fn insert_release(&self, entry: ReleaseMetadata) {
        let mut writer = self.0.write().await;
        writer.value.replace(entry);
        if let Err(err) = writer.persist() {
            tracing::error!(error = ?err, "unable to persist on disk");
            eprintln!("unable to persist on disk: {err:?}");
        }
    }

    async fn find_package_by_asset(&self, asset: &DebAsset) -> Option<Package> {
        self.0
            .read()
            .await
            .value
            .iter()
            .flat_map(|meta| meta.architectures.iter())
            .flat_map(|arch| arch.packages.iter())
            .find(|pkg| pkg.asset.asset_id == asset.asset_id)
            .cloned()
    }

    async fn find_latest_release(&self) -> Option<ReleaseMetadata> {
        self.0.read().await.value.clone()
    }
}

#[cfg(test)]
mod tests {
    use crate::domain::prelude::ReleaseStore;

    #[tokio::test]
    async fn should_insert_and_fetch_data() {
        let storage_file = temp_file::empty();
        let storage = super::MemoryStorage::new(storage_file.path());
        storage
            .insert_release(crate::domain::entity::ReleaseMetadata {
                origin: "origin".into(),
                label: "label".into(),
                suite: "suite".into(),
                version: "version".into(),
                codename: "codename".into(),
                date: chrono::DateTime::from_timestamp_nanos(0),
                architectures: vec![],
                components: vec![],
                description: "whatever".into(),
            })
            .await;
        let res = storage.find_latest_release().await.unwrap();
        assert_eq!(res.origin, "origin");
        drop(storage);
        // should have written on disk
        let storage = super::Config {
            path: storage_file.path().into(),
            ignore_errors: false,
        }
        .build()
        .unwrap();
        let res = storage.find_latest_release().await.unwrap();
        assert_eq!(res.origin, "origin");
    }
}