inapt 0.3.3

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

use std::future::Future;

use anyhow::Context;

mod handler;
mod middleware;

/// Trait for components that can report their health status.
/// Used by the HTTP server to implement the `/health` endpoint.
pub trait HealthCheck: Send + Sync + 'static {
    /// Check if the component is healthy.
    /// Returns Ok(()) if healthy, Err with details if not.
    fn health_check(&self) -> impl Future<Output = anyhow::Result<()>> + Send;
}

const DEFAULT_ADDRESS: std::net::IpAddr = std::net::IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED);
const DEFAULT_PORT: u16 = 3000;

#[derive(serde::Deserialize)]
pub struct Config {
    #[serde(default = "Config::default_address")]
    address: std::net::IpAddr,
    #[serde(default = "Config::default_port")]
    port: u16,
}

impl Config {
    pub const fn default_address() -> std::net::IpAddr {
        DEFAULT_ADDRESS
    }
    pub const fn default_port() -> u16 {
        DEFAULT_PORT
    }

    pub fn builder<AR, APK, HC>(self) -> anyhow::Result<ServerBuilder<AR, APK, HC>> {
        Ok(ServerBuilder {
            address: std::net::SocketAddr::from((self.address, self.port)),
            apt_repository: None,
            apk_repository: None,
            health_checker: None,
        })
    }
}

#[derive(Debug)]
pub struct ServerBuilder<AR, APK, HC> {
    address: std::net::SocketAddr,
    apt_repository: Option<AR>,
    apk_repository: Option<APK>,
    health_checker: Option<HC>,
}

impl<AR, APK, HC> ServerBuilder<AR, APK, HC>
where
    AR: Clone + crate::domain::prelude::AptRepositoryReader,
    APK: Clone + crate::domain::prelude::ApkRepositoryReader,
    HC: Clone + HealthCheck,
{
    pub fn with_apt_repository(self, value: AR) -> Self {
        Self {
            apt_repository: Some(value),
            ..self
        }
    }

    pub fn with_apk_repository(self, value: APK) -> Self {
        Self {
            apk_repository: Some(value),
            ..self
        }
    }

    pub fn with_health_checker(self, value: HC) -> Self {
        Self {
            health_checker: Some(value),
            ..self
        }
    }

    pub fn build(self) -> anyhow::Result<Server> {
        let router = handler::build()
            .layer(middleware::tracing::layer())
            .with_state(ServerState {
                apt_repository: self
                    .apt_repository
                    .ok_or_else(|| anyhow::anyhow!("apt_repository service not defined"))?,
                apk_repository: self
                    .apk_repository
                    .ok_or_else(|| anyhow::anyhow!("apk_repository service not defined"))?,
                health_checker: self
                    .health_checker
                    .ok_or_else(|| anyhow::anyhow!("health_checker not defined"))?,
            });
        Ok(Server {
            address: self.address,
            router,
        })
    }
}

#[derive(Debug)]
pub struct Server {
    address: std::net::SocketAddr,
    router: axum::Router,
}

impl Server {
    pub async fn run(self) -> anyhow::Result<()> {
        let listener = tokio::net::TcpListener::bind(self.address).await?;
        tracing::info!(address = ?self.address, "starting server");
        axum::serve(listener, self.router)
            .await
            .context("server crashed")
    }
}

#[derive(Clone)]
pub(crate) struct ServerState<AR, APK, HC>
where
    AR: Clone + crate::domain::prelude::AptRepositoryReader,
    APK: Clone + crate::domain::prelude::ApkRepositoryReader,
    HC: Clone + HealthCheck,
{
    pub(crate) apt_repository: AR,
    pub(crate) apk_repository: APK,
    pub(crate) health_checker: HC,
}