sword-web 0.3.0

Web controllers and runtime for the Sword framework
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

mod config;
mod extensions;
mod router;

use axum::Router;
use router::WebApplicationRouter;
use std::net::SocketAddr;
use sword_core::*;
use tokio::net::TcpListener;

pub use config::WebApplicationConfig;
pub use extensions::{WebExtension, WebExtensionContext, WebExtensionRegistrar};

pub struct WebApplication {
    pub state: State,
    pub router: Router<State>,
    pub config: WebApplicationConfig,
    pub graceful_shutdown: bool,
}

impl WebApplication {
    pub async fn start(&self) {
        let bind = format!("{}:{}", self.config.host, self.config.port);
        let router_prefix = self
            .config
            .router_prefix
            .as_deref()
            .unwrap_or("none")
            .to_string();

        tracing::info!(
            target: "sword.startup.web",
            bind,
            router_prefix,
            "Starting application listener"
        );

        #[cfg(feature = "swagger-ui")]
        {
            if let Some(cfg) = &self.config.openapi {
                let display_host = if self.config.host == "0.0.0.0" {
                    "localhost"
                } else {
                    &self.config.host
                };

                let docs_url = format!(
                    "http://{}:{}{}/docs",
                    display_host,
                    self.config.port,
                    self.config.router_prefix.as_deref().unwrap_or("")
                );

                tracing::info!(
                    target: "sword.startup.app",
                    docs_url = docs_url.as_str(),
                    "Loaded {} OpenAPI spec file(s) for Swagger UI",
                    cfg.spec_file_paths.len()
                );
            }
        }

        let app = self.router.clone().with_state(self.state.clone());

        let bind_addr: SocketAddr = bind.parse::<SocketAddr>().unwrap_or_else(|err| {
            sword_error! {
                title: "Invalid web bind address",
                reason: err,
                context: {
                    "bind" => bind,
                    "source" => "WebApplication::start",
                },
                hints: ["Ensure host and port values are valid"],
            }
        });

        let listener = TcpListener::bind(bind_addr).await.unwrap_or_else(|err| {
            sword_error! {
                title: "Failed to bind HTTP listener",
                reason: err,
                context: {
                    "host" => self.config.host.clone(),
                    "port" => self.config.port.to_string(),
                },
                hints: ["Ensure the host/port is available and not already in use"],
            }
        });

        if self.graceful_shutdown {
            axum::serve(listener, app)
                .with_graceful_shutdown(shutdown_signal())
                .await
                .unwrap_or_else(|err| {
                    sword_error! {
                        title: "HTTP server stopped with an internal error",
                        reason: err,
                        context: {
                            "mode" => "graceful_shutdown",
                            "host" => self.config.host.clone(),
                            "port" => self.config.port.to_string(),
                        },
                    }
                });

            return;
        }

        axum::serve(listener, app).await.unwrap_or_else(|err| {
            sword_error! {
                title: "HTTP server stopped with an internal error",
                reason: err,
                context: {
                    "mode" => "normal",
                    "host" => self.config.host.clone(),
                    "port" => self.config.port.to_string(),
                },
            }
        });
    }

    pub fn router(&self) -> axum::Router {
        self.router.clone().with_state(self.state.clone())
    }
}

impl From<EngineBuildContext> for WebApplication {
    fn from(ctx: EngineBuildContext) -> Self {
        let EngineBuildContext {
            state,
            config,
            controllers,
            layer_stack,
        } = ctx;

        let web_config = config.get_or_default::<WebApplicationConfig>();
        let graceful_shutdown = config
            .get_or_default::<ApplicationConfig>()
            .graceful_shutdown;

        let mut router = WebApplicationRouter {
            state: state.clone(),
            config,
            layer_stack,
            controller_registry: controllers,
            web_config: web_config.clone(),
        };

        Self {
            state,
            config: web_config,
            graceful_shutdown,
            router: router.build(),
        }
    }
}