credence 0.0.6

An unfussy web server designed for straightforward authoring and scalable performance
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

use credence_lib::configuration::ConfigurationError;

use super::{cli::*, errors::*};

use {
    credence_lib::server::*,
    kutil::{cli::depict::*, http::axum::*},
    std::{io, time::*},
};

impl CLI {
    /// Start.
    pub async fn start(&self) -> Result<(), MainError> {
        let shutdown = self.shutdown()?;
        let sites = self.sites(&shutdown)?;

        // Servers
        let mut servers = Servers::new(shutdown.handle);
        for site in &sites {
            servers.add_site(site)?;
        }

        // Serve!
        let join_set = servers.start()?;
        if join_set.is_empty() {
            return Err(ConfigurationError::from("no servers").into());
        }

        // Coordinators
        let mut coordinators = Vec::default();
        for site in &sites {
            if let Some(coordinator) = site.new_coordinator()? {
                coordinators.push(coordinator);
            }
        }

        // Wait for servers to shutdown
        for result in join_set.join_all().await {
            if let Err(error) = result {
                tracing::error!("{}", error);
            }
        }

        // Shutdown coordinators
        for coordinator in coordinators {
            if let Err(error) = coordinator.shutdown().await {
                tracing::error!("{}", error);
            }
        }

        tracing::info!("goodbye");

        Ok(())
    }

    /// Sites.
    pub fn sites(&self, shutdown: &Shutdown) -> Result<Vec<Site>, MainError> {
        let mut sites = Vec::default();

        for assets_path in &self.assets_paths {
            let site = Site::new(assets_path, &shutdown)?;

            tracing::info!("added site: {}", assets_path.display());
            if !self.quiet && (self.verbose > 0) {
                site.configuration.eprint_default_depiction();
            }

            sites.push(site);
        }

        Ok(sites)
    }

    /// [Shutdown].
    pub fn shutdown(&self) -> io::Result<Shutdown> {
        let shutdown = Shutdown::new(Some(Duration::from_secs(self.grace_period)));
        shutdown.on_signals()?;
        Ok(shutdown)
    }
}