drogue-bazaar 0.3.0

A place to find tools for building your Rust application
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

use super::{HealthChecker, HealthServerConfig};
use anyhow::anyhow;
use futures_util::{future::err, TryFutureExt};
use prometheus::Registry;
use serde_json::json;
use std::{future::Future, pin::Pin};

/// A server, running health check endpoints.
pub struct HealthServer {
    config: HealthServerConfig,
    checker: HealthChecker,
    registry: Option<Registry>,
}

macro_rules! health_endpoint {
    ($sys:ident) => {
        async fn index() -> $sys::HttpResponse {
            $sys::HttpResponse::Ok().json(&json!({}))
        }

        async fn readiness(checker: Data<HealthChecker>) -> $sys::HttpResponse {
            let (code, body) = super::run_checks(checker.into_inner(), |checker| async move {
                checker.is_ready().await
            })
            .await;
            $sys::HttpResponse::build(code.into()).json(&body)
        }

        async fn liveness(checker: Data<HealthChecker>) -> $sys::HttpResponse {
            let (code, body) = super::run_checks(checker.into_inner(), |checker| async move {
                checker.is_alive().await
            })
            .await;
            $sys::HttpResponse::build(code.into()).json(&body)
        }
    };
}

macro_rules! health_app {
    ($checker:expr, $app_data:ident) => {
        App::new()
            .$app_data($checker.clone())
            .route("/", web::get().to(index))
            .route("/readiness", web::get().to(readiness))
            .route("/liveness", web::get().to(liveness))
    };
}

impl HealthServer {
    pub fn new(
        config: HealthServerConfig,
        checker: HealthChecker,
        registry: Option<Registry>,
    ) -> Self {
        Self {
            config,
            checker,
            registry,
        }
    }

    pub fn run(self) -> Pin<Box<dyn Future<Output = anyhow::Result<()>> + Send>> {
        use actix_web::web;
        use actix_web::web::Data;
        health_endpoint!(actix_web);

        let checker = Data::new(self.checker);

        let prometheus = match self.registry {
            Some(metrics) => actix_web_prom::PrometheusMetricsBuilder::new("health")
                .registry(metrics)
                .endpoint("/metrics")
                .build()
                .unwrap(),
            _ => actix_web_prom::PrometheusMetricsBuilder::new("noop")
                .build()
                .unwrap(),
        };

        let http = actix_web::HttpServer::new(move || {
            use actix_web::App;

            health_app!(checker, app_data).wrap(prometheus.clone())
        });

        let http = match http.bind(self.config.bind_addr) {
            Ok(http) => http,
            Err(e) => return Box::pin(err(anyhow!(e))),
        };

        let task = http
            .workers(self.config.workers)
            .run()
            .map_err(|err| anyhow!(err));

        Box::pin(task)
    }
}