inapt 0.3.2

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

use std::{marker::PhantomData, sync::Arc};

use anyhow::Context;

use crate::{adapter_deb::DebReader, domain::AptRepositoryService};

mod adapter_deb;
mod adapter_github;
mod adapter_http_server;
mod adapter_pgp;
mod adapter_sqlite;
mod adapter_worker;
mod domain;

pub mod tracing;

#[derive(serde::Deserialize)]
pub struct Config {
    #[serde(rename = "core")]
    config: domain::Config,
    github: adapter_github::Config,
    http_server: adapter_http_server::Config,
    pgp_cipher: adapter_pgp::Config,
    sqlite: adapter_sqlite::Config,
    worker: adapter_worker::Config,
}

impl Config {
    pub fn from_path(path: impl Into<std::path::PathBuf>) -> anyhow::Result<Self> {
        let content = std::fs::read(path.into()).context("unable to read file")?;
        Ok(toml::from_slice(&content)?)
    }

    pub async fn build(self) -> anyhow::Result<Application> {
        let storage = self.sqlite.build().await?;
        let github = self.github.build()?;
        let apt_repository_service = AptRepositoryService {
            package_source: github.clone(),
            release_storage: storage.clone(),
            config: Arc::from(self.config),
            clock: PhantomData::<chrono::Utc>,
            deb_extractor: DebReader,
            pgp_cipher: self.pgp_cipher.build()?,
            release_tracker: storage.clone(),
            package_store: storage,
        };
        Ok(Application {
            github,
            http_server: self
                .http_server
                .builder()?
                .with_apt_repository(apt_repository_service.clone())
                .build()?,
            worker: self
                .worker
                .builder()
                .with_apt_repository(apt_repository_service)
                .build()?,
        })
    }
}

pub struct Application {
    #[allow(unused, reason = "preparation")]
    github: adapter_github::Client,
    http_server: adapter_http_server::Server,
    worker: adapter_worker::Worker,
}

impl Application {
    pub async fn run(self) -> anyhow::Result<()> {
        self.http_server.run().await?;
        self.worker.shutdown().await
    }
}