inapt 0.1.5

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

use std::{borrow::Cow, 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_storage;
mod adapter_worker;
mod domain;

pub mod tracing;

fn maybe_env(name: &str) -> Option<String> {
    std::env::var(name).ok()
}

fn with_env_or<T>(name: &str, default_value: T) -> Cow<'static, str>
where
    T: Into<Cow<'static, str>>,
{
    std::env::var(name)
        .ok()
        .map(Cow::Owned)
        .unwrap_or_else(|| default_value.into())
}

fn with_env_as_or<T>(name: &str, default_value: T) -> anyhow::Result<T>
where
    T: std::str::FromStr,
    <T as std::str::FromStr>::Err: std::error::Error + Send + Sync + 'static,
{
    let Ok(value) = std::env::var(name) else {
        return Ok(default_value);
    };
    value
        .parse::<T>()
        .with_context(|| format!("unable to parse value from {name:?}"))
}

fn with_env_as_many(name: &str, delim: &str) -> Vec<String> {
    let Ok(value) = std::env::var(name) else {
        ::tracing::warn!("no repository configured");
        return Vec::default();
    };
    value
        .split(delim)
        .map(|item| item.trim().to_string())
        .collect()
}

pub struct Config {
    config: domain::Config,
    github: adapter_github::Config,
    http_server: adapter_http_server::Config,
    storage: adapter_storage::Config,
    worker: adapter_worker::Config,
}

impl Config {
    pub fn from_env() -> anyhow::Result<Config> {
        Ok(Self {
            config: domain::Config::from_env()?,
            github: adapter_github::Config::from_env()?,
            http_server: adapter_http_server::Config::from_env()?,
            storage: adapter_storage::Config::from_env()?,
            worker: adapter_worker::Config::from_env()?,
        })
    }

    pub fn build(self) -> anyhow::Result<Application> {
        let release_storage = self.storage.build()?;
        let github = self.github.build()?;
        let apt_repository_service = AptRepositoryService {
            package_source: github.clone(),
            release_storage,
            config: Arc::from(self.config),
            clock: PhantomData::<chrono::Utc>,
            deb_extractor: DebReader,
        };
        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
    }
}