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

use std::time::Duration;

use anyhow::Context;

#[derive(serde::Deserialize)]
pub struct Config {
    #[serde(default = "Config::default_interval")]
    interval: u64,
}

impl Config {
    pub const fn default_interval() -> u64 {
        60 * 60 * 12 // 12h
    }

    pub fn builder<AR, APK>(self) -> WorkerBuilder<AR, APK> {
        WorkerBuilder {
            apt_repository: None,
            apk_repository: None,
            interval: Duration::from_secs(self.interval),
        }
    }
}

pub struct WorkerBuilder<AR, APK> {
    apt_repository: Option<AR>,
    apk_repository: Option<APK>,
    interval: Duration,
}

impl<AR, APK> WorkerBuilder<AR, APK>
where
    AR: crate::domain::prelude::AptRepositoryWriter,
    APK: crate::domain::prelude::ApkRepositoryWriter,
{
    pub fn with_apt_repository(self, service: AR) -> Self {
        Self {
            apt_repository: Some(service),
            ..self
        }
    }

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

    pub fn build(self) -> anyhow::Result<Worker> {
        let runner = Runner {
            apt_repository: self
                .apt_repository
                .ok_or_else(|| anyhow::anyhow!("apt repository not specified"))?,
            apk_repository: self
                .apk_repository
                .ok_or_else(|| anyhow::anyhow!("apk repository not specified"))?,
            interval: self.interval,
        };
        let runner = tokio::spawn(runner.run());

        Ok(Worker { runner })
    }
}

#[derive(Debug)]
pub struct Worker {
    runner: tokio::task::JoinHandle<()>,
}

impl Worker {
    pub async fn shutdown(self) -> anyhow::Result<()> {
        self.runner.abort();
        self.runner.await.context("worker didn't stop gracefully")
    }
}

struct Runner<AR, APK> {
    apt_repository: AR,
    apk_repository: APK,
    interval: Duration,
}

impl<AR, APK> Runner<AR, APK>
where
    AR: crate::domain::prelude::AptRepositoryWriter,
    APK: crate::domain::prelude::ApkRepositoryWriter,
{
    async fn run(self) {
        tracing::info!("starting worker");
        let mut interval = tokio::time::interval(self.interval);
        let mut failures = 0u64;
        loop {
            let _ = interval.tick().await;
            tracing::info!("starting synchro");

            let mut has_error = false;

            match self.apt_repository.synchronize().await {
                Ok(_) => tracing::info!("apt synchro completed"),
                Err(err) => {
                    has_error = true;
                    tracing::error!(error = ?err, "apt synchro failed");
                }
            }

            match self.apk_repository.synchronize().await {
                Ok(_) => tracing::info!("apk synchro completed"),
                Err(err) => {
                    has_error = true;
                    tracing::error!(error = ?err, "apk synchro failed");
                }
            }

            if has_error {
                failures += 1;
                let wait = failures * 30;
                tracing::error!(wait, "synchro failed, retrying later");
                interval.reset_after(Duration::from_secs(wait));
            } else {
                failures = 0;
                tracing::info!("synchro completed");
            }
        }
    }
}