1use std::future::Future;
8use std::io;
9use std::net::SocketAddr;
10use std::path::{Path, PathBuf};
11use std::sync::Arc;
12use std::time::{SystemTime, UNIX_EPOCH};
13
14use axum::Router;
15use axum::extract::rejection::QueryRejection;
16use axum::extract::{Path as UrlPath, Query, Request, State};
17use axum::http::{HeaderValue, StatusCode, header};
18use axum::middleware::{self, Next};
19use axum::response::{Html, IntoResponse, Response};
20use axum::routing::{delete, get, post};
21use maud::Markup;
22use runnerd_core::client::{Client, ClientError};
23use runnerd_core::config::Origin;
24use tokio::net::TcpListener;
25use tokio::sync::watch;
26use tokio::task::JoinHandle;
27use tracing::{info, warn};
28
29mod actions;
30mod assets;
31mod auth;
32mod chart;
33mod format;
34mod live;
35mod views;
36
37pub use auth::{PAIRING_LIFETIME, PAIRING_MAX, PairError, Sessions, login_file, session_file};
38use views::caches::CachesView;
39use views::config::{ConfigQuery, ConfigView};
40use views::history::{Filter, History};
41use views::insights::InsightsView;
42use views::job::JobView;
43use views::overview::Overview;
44use views::records::RecordsView;
45use views::sizing::SizingView;
46
47pub const DEFAULT_ADDR: &str = "127.0.0.1:7477";
49
50#[derive(Clone)]
52pub(crate) struct App {
53 daemon: Client,
54 proxies: Arc<[String]>,
56 stopping: watch::Receiver<bool>,
58}
59
60pub(crate) fn now() -> u64 {
61 SystemTime::now()
62 .duration_since(UNIX_EPOCH)
63 .map_or(0, |since| since.as_secs())
64}
65
66pub async fn listen(flag: &str) -> io::Result<Option<TcpListener>> {
69 if flag == "off" {
70 return Ok(None);
71 }
72 let addr: SocketAddr = flag
73 .parse()
74 .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
75 if !addr.ip().is_loopback() {
76 return Err(io::Error::new(
77 io::ErrorKind::InvalidInput,
78 format!("the dashboard listens on loopback only, not {addr}"),
79 ));
80 }
81 TcpListener::bind(addr).await.map(Some)
82}
83
84pub fn spawn(
86 listener: TcpListener,
87 socket: PathBuf,
88 proxies: Vec<Origin>,
89 sessions: Arc<Sessions>,
90 stop: impl Future + Send + 'static,
91) -> JoinHandle<()> {
92 tokio::spawn(async move {
93 let stop = async {
94 stop.await;
95 };
96 if let Err(error) = serve(listener, &socket, &proxies, sessions, stop).await {
97 warn!("the dashboard stopped: {error}");
98 }
99 })
100}
101
102pub async fn serve(
106 listener: TcpListener,
107 socket: &Path,
108 proxies: &[Origin],
109 sessions: Arc<Sessions>,
110 stop: impl Future<Output = ()> + Send + 'static,
111) -> io::Result<()> {
112 let addr = listener.local_addr()?;
113 let file = login_file(socket);
114 let auth = auth::Auth::new(addr, proxies, sessions, file.clone())?;
115 info!(
116 "serving the dashboard on http://{addr}; `runnerctl web` opens it (login links in {})",
117 file.display()
118 );
119 let (stopping, stopping_receiver) = watch::channel(false);
120 let app = router(
121 Client::new(socket.to_owned()),
122 auth.clone(),
123 stopping_receiver,
124 );
125 let served = axum::serve(listener, app)
126 .with_graceful_shutdown(async move {
127 stop.await;
128 let _ = stopping.send(true);
129 })
130 .await;
131 auth.remove_login_file();
132 served
133}
134
135fn router(daemon: Client, auth: Arc<auth::Auth>, stopping: watch::Receiver<bool>) -> Router {
136 let proxies = auth.proxies().into();
137 let pages = Router::new()
138 .route("/", get(overview))
139 .route("/history", get(history))
140 .route("/records", get(records))
141 .route("/caches", get(caches))
142 .route("/sizing", get(sizing))
143 .route("/insights", get(insights))
144 .route("/jobs/{id}", get(job))
145 .route("/jobs/{id}/log", get(job_log))
146 .route("/jobs/{id}/cancel", post(actions::cancel_job))
147 .route("/jobs/{id}/rerun", post(actions::rerun_job))
148 .route("/live/overview", get(live::overview))
149 .route("/live/jobs/{id}", get(live::job))
150 .route("/config", get(config).put(actions::save_config))
151 .route("/config/check", post(actions::check_config))
152 .route("/config/diff", post(actions::review_config))
153 .route("/config/doctor", get(config_doctor))
154 .route(
155 "/v1/repositories/{owner}/{name}/pause",
156 post(actions::pause),
157 )
158 .route(
159 "/v1/repositories/{owner}/{name}/resume",
160 post(actions::resume),
161 )
162 .route("/v1/repositories/pause", post(actions::pause_all))
163 .route("/v1/repositories/resume", post(actions::resume_all))
164 .route("/v1/profiles/{name}/reseed", post(actions::reseed))
165 .route("/v1/caches/{name}/clean", post(actions::clean))
166 .route("/v1/records", delete(actions::remove_all_records))
167 .route("/v1/records/{job}", delete(actions::remove_record))
168 .route("/assets/{name}", get(assets::serve))
169 .fallback(|| async { not_found() })
170 .with_state(App {
171 daemon,
172 proxies,
173 stopping,
174 });
175 let login = Router::new()
176 .route("/login", get(auth::login))
177 .route("/pair", post(auth::pair))
178 .with_state(auth.clone());
179 pages
180 .merge(login)
181 .layer(middleware::from_fn_with_state(auth, auth::require_session))
182 .layer(middleware::from_fn(security_headers))
183}
184
185async fn security_headers(request: Request, next: Next) -> Response {
189 let mut response = next.run(request).await;
190 let headers = response.headers_mut();
191 headers.insert(
192 header::CONTENT_SECURITY_POLICY,
193 HeaderValue::from_static(
194 "default-src 'none'; script-src 'self' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; \
195 img-src 'self' data:; font-src 'self'; connect-src 'self'; manifest-src 'self'; form-action 'self'; \
196 base-uri 'none'; frame-ancestors 'none'",
197 ),
198 );
199 headers.insert(
200 header::X_CONTENT_TYPE_OPTIONS,
201 HeaderValue::from_static("nosniff"),
202 );
203 headers.insert(
204 header::REFERRER_POLICY,
205 HeaderValue::from_static("no-referrer"),
206 );
207 response
208}
209
210fn not_found() -> Response {
212 (
213 StatusCode::NOT_FOUND,
214 views::error_page("Not found", "There is no page at this address."),
215 )
216 .into_response()
217}
218
219fn lenient<T: Default>(query: Result<Query<T>, QueryRejection>) -> T {
222 query.map(|Query(query)| query).unwrap_or_default()
223}
224
225fn page(rendered: Result<Markup, ClientError>) -> Response {
227 match rendered {
228 Ok(markup) => Html(markup.into_string()).into_response(),
229 Err(ClientError::Api {
230 status: StatusCode::NOT_FOUND,
231 message,
232 ..
233 }) => (
234 StatusCode::NOT_FOUND,
235 views::error_page("Not found", &message),
236 )
237 .into_response(),
238 Err(error) => (
239 StatusCode::BAD_GATEWAY,
240 views::error_page("runnerd did not answer", &error.to_string()),
241 )
242 .into_response(),
243 }
244}
245
246async fn overview(State(app): State<App>) -> Response {
247 page(
248 Overview::load(&app.daemon, now())
249 .await
250 .map(|overview| views::overview::render(&overview)),
251 )
252}
253
254async fn history(
255 State(app): State<App>,
256 filter: Result<Query<Filter>, QueryRejection>,
257) -> Response {
258 let filter = lenient(filter);
259 page(
260 History::load(&app.daemon, filter, now())
261 .await
262 .map(|history| views::history::render(&history)),
263 )
264}
265
266async fn records(State(app): State<App>) -> Response {
267 page(
268 RecordsView::load(&app.daemon, now())
269 .await
270 .map(|records| views::records::render(&records)),
271 )
272}
273
274async fn caches(State(app): State<App>) -> Response {
275 page(
276 CachesView::load(&app.daemon, now())
277 .await
278 .map(|caches| views::caches::render(&caches)),
279 )
280}
281
282async fn sizing(State(app): State<App>) -> Response {
283 page(
284 SizingView::load(&app.daemon, now())
285 .await
286 .map(|sizing| views::sizing::render(&sizing)),
287 )
288}
289
290async fn insights(State(app): State<App>) -> Response {
291 page(
292 InsightsView::load(&app.daemon, now())
293 .await
294 .map(|insights| views::insights::render(&insights)),
295 )
296}
297
298async fn config(
299 State(app): State<App>,
300 query: Result<Query<ConfigQuery>, QueryRejection>,
301) -> Response {
302 let query = lenient(query);
303 page(
304 ConfigView::load(&app.daemon, query)
305 .await
306 .map(|config| views::config::render(&config, &app.proxies)),
307 )
308}
309
310async fn config_doctor(State(app): State<App>) -> Response {
313 let doctor = app.daemon.get("/v1/doctor").await;
314 Html(views::config::doctor(&doctor, now()).into_string()).into_response()
315}
316
317async fn job(
318 State(app): State<App>,
319 UrlPath(id): UrlPath<String>,
320 query: Result<Query<views::job::JobPageQuery>, QueryRejection>,
321) -> Response {
322 let Ok(id) = id.parse::<u64>() else {
324 return not_found();
325 };
326 let query = lenient(query);
327 page(
328 JobView::load(&app.daemon, id, now(), &query)
329 .await
330 .map(|job| views::job::render(&job)),
331 )
332}
333
334async fn job_log(State(app): State<App>, UrlPath(id): UrlPath<u64>) -> Response {
336 match app.daemon.text(&format!("/v1/jobs/{id}/logs")).await {
337 Ok(text) => ([(header::CONTENT_TYPE, "text/plain; charset=utf-8")], text).into_response(),
338 Err(ClientError::Api {
339 status, message, ..
340 }) => (status, message).into_response(),
341 Err(error) => (StatusCode::BAD_GATEWAY, error.to_string()).into_response(),
342 }
343}
344
345#[cfg(test)]
346mod tests;