Garmelon/tablejohn
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use extension trait for resolving paths

Browse source
This commit is contained in:
Joscha 2024-05-12 14:52:23 +02:00
parent 5409e176b1
commit cf96b72dfb
10 changed files with 88 additions and 86 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/server/web.rs
View file

@ -4,6 +4,7 @@ mod base;
mod link;
mod pages;
pub mod paths;
mod server_config_ext;
mod r#static;
use axum::{extract::DefaultBodyLimit, routing::get, Router};

17
src/server/web/admin/queue.rs
View file

@ -11,11 +11,11 @@ use time::OffsetDateTime;
use crate::{
config::ServerConfig,
server::web::{
base::Base,
paths::{
PathAdminQueueAdd, PathAdminQueueAddBatch, PathAdminQueueDecrease,
PathAdminQueueDelete, PathAdminQueueIncrease, PathQueue,
},
server_config_ext::ServerConfigExt,
},
somehow,
};
@ -52,8 +52,7 @@ pub async fn post_admin_queue_add(
form.hash, form.priority,
);
let link = Base::link_with_config(config, PathQueue {});
Ok(Redirect::to(&format!("{link}")))
Ok(Redirect::to(config.path(PathQueue {}).as_ref()))
}
#[derive(Deserialize)]
@ -95,8 +94,7 @@ pub async fn post_admin_queue_add_batch(
);
}
let link = Base::link_with_config(config, PathQueue {});
Ok(Redirect::to(&format!("{link}")))
Ok(Redirect::to(config.path(PathQueue {}).as_ref()))
}
#[derive(Deserialize)]
@ -116,8 +114,7 @@ pub async fn post_admin_queue_delete(
info!("Admin deleted {} from queue", form.hash);
let link = Base::link_with_config(config, PathQueue {});
Ok(Redirect::to(&format!("{link}")))
Ok(Redirect::to(config.path(PathQueue {}).as_ref()))
}
#[derive(Deserialize)]
@ -140,8 +137,7 @@ pub async fn post_admin_queue_increase(
info!("Admin increased queue priority of {} by one", form.hash);
let link = Base::link_with_config(config, PathQueue {});
Ok(Redirect::to(&format!("{link}")))
Ok(Redirect::to(config.path(PathQueue {}).as_ref()))
}
#[derive(Deserialize)]
@ -164,6 +160,5 @@ pub async fn post_admin_queue_decrease(
info!("Admin decreased queue priority of {} by one", form.hash);
let link = Base::link_with_config(config, PathQueue {});
Ok(Redirect::to(&format!("{link}")))
Ok(Redirect::to(config.path(PathQueue {}).as_ref()))
}

11
src/server/web/admin/refs.rs
View file

@ -13,8 +13,8 @@ use tokio::sync::mpsc;
use crate::{
config::ServerConfig,
server::web::{
base::Base,
paths::{PathAdminRefsTrack, PathAdminRefsUntrack, PathAdminRefsUpdate, PathIndex},
server_config_ext::ServerConfigExt,
},
somehow,
};
@ -38,8 +38,7 @@ pub async fn post_admin_refs_track(
info!("Admin tracked {}", form.r#ref);
}
let link = Base::link_with_config(config, PathIndex {});
Ok(Redirect::to(&link.to_string()))
Ok(Redirect::to(config.path(PathIndex {}).as_ref()))
}
pub async fn post_admin_refs_untrack(
@ -56,8 +55,7 @@ pub async fn post_admin_refs_untrack(
info!("Admin untracked {}", form.r#ref);
}
let link = Base::link_with_config(config, PathIndex {});
Ok(Redirect::to(&link.to_string()))
Ok(Redirect::to(config.path(PathIndex {}).as_ref()))
}
pub async fn post_admin_repo_update(
@ -68,6 +66,5 @@ pub async fn post_admin_repo_update(
let _ = recurring_tx.send(());
info!("Admin updated repo");
let link = Base::link_with_config(config, PathIndex {});
Ok(Redirect::to(&link.to_string()))
Ok(Redirect::to(config.path(PathIndex {}).as_ref()))
}

59
src/server/web/base.rs
View file

@ -1,5 +1,3 @@
use std::fmt;
use maud::{html, Markup, DOCTYPE};
use crate::config::ServerConfig;
@ -7,6 +5,7 @@ use crate::config::ServerConfig;
use super::{
paths::{PathGraph, PathIndex, PathQueue},
r#static::{BASE_CSS, LOGO_SVG},
server_config_ext::{AbsPath, ServerConfigExt},
};
pub enum Tab {
@ -18,18 +17,17 @@ pub enum Tab {
#[derive(Clone)]
pub struct Base {
pub link_logo_svg: Link,
pub link_base_css: Link,
pub link_index: Link,
pub link_graph: Link,
pub link_queue: Link,
pub web_base: String,
pub repo_name: String,
pub link_logo_svg: AbsPath,
pub link_base_css: AbsPath,
pub link_index: AbsPath,
pub link_graph: AbsPath,
pub link_queue: AbsPath,
pub config: &'static ServerConfig,
pub tab: &'static str,
}
impl Base {
pub fn new(config: &ServerConfig, tab: Tab) -> Self {
pub fn new(config: &'static ServerConfig, tab: Tab) -> Self {
let tab = match tab {
Tab::None => "",
Tab::Index => "index",
@ -37,32 +35,16 @@ impl Base {
Tab::Queue => "queue",
};
Self {
link_logo_svg: Self::link_with_config(config, LOGO_SVG),
link_base_css: Self::link_with_config(config, BASE_CSS),
link_index: Self::link_with_config(config, PathIndex {}),
link_graph: Self::link_with_config(config, PathGraph {}),
link_queue: Self::link_with_config(config, PathQueue {}),
web_base: config.web_base.clone(),
repo_name: config.repo_name.clone(),
link_logo_svg: config.path(LOGO_SVG),
link_base_css: config.path(BASE_CSS),
link_index: config.path(PathIndex {}),
link_graph: config.path(PathGraph {}),
link_queue: config.path(PathQueue {}),
config,
tab,
}
}
fn link_with_base<P: fmt::Display>(base: &str, to: P) -> Link {
let to = format!("{to}");
assert!(!base.ends_with('/'));
assert!(to.starts_with('/'));
Link(format!("{base}{to}"))
}
pub fn link_with_config<P: fmt::Display>(config: &ServerConfig, to: P) -> Link {
Self::link_with_base(&config.web_base, to)
}
pub fn link<P: fmt::Display>(&self, to: P) -> Link {
Self::link_with_base(&self.web_base, to)
}
pub fn html(&self, title: &str, head: Markup, body: Markup) -> Markup {
html!(
(DOCTYPE)
@ -70,7 +52,7 @@ impl Base {
head {
meta charset="utf-8";
meta name="viewport" content="width=device-width";
title { (title) " - " (self.repo_name) }
title { (title) " - " (self.config.repo_name) }
link rel="icon" href=(self.link_logo_svg);
link rel="stylesheet" href=(self.link_base_css);
(head)
@ -79,7 +61,7 @@ impl Base {
nav {
a .current[self.tab == "index"] href=(self.link_index) {
img src=(self.link_logo_svg) alt="";
(self.repo_name)
(self.config.repo_name)
}
a .current[self.tab == "graph"] href=(self.link_graph) { "graph" }
a .current[self.tab == "queue"] href=(self.link_queue) { "queue" }
@ -90,12 +72,3 @@ impl Base {
)
}
}
#[derive(Clone)]
pub struct Link(String);
impl fmt::Display for Link {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f)
}
}

19
src/server/web/link.rs
View file

@ -4,12 +4,13 @@ use time::OffsetDateTime;
use crate::server::util;
use super::{
base::{Base, Link},
base::Base,
paths::{PathCommitByHash, PathRunById, PathWorkerByName},
server_config_ext::{AbsPath, ServerConfigExt},
};
pub struct LinkCommit {
link: Link,
link: AbsPath,
short: String,
reachable: i64,
}
@ -18,7 +19,7 @@ impl LinkCommit {
pub fn new(base: &Base, hash: String, message: &str, reachable: i64) -> Self {
Self {
short: util::format_commit_short(&hash, message),
link: base.link(PathCommitByHash { hash }),
link: base.config.path(PathCommitByHash { hash }),
reachable,
}
}
@ -53,14 +54,14 @@ impl LinkCommit {
}
pub struct LinkRunShort {
link: Link,
link: AbsPath,
short: String,
}
impl LinkRunShort {
pub fn new(base: &Base, id: String, hash: &str, message: &str) -> Self {
Self {
link: base.link(PathRunById { id }),
link: base.config.path(PathRunById { id }),
short: util::format_commit_short(hash, message),
}
}
@ -73,14 +74,14 @@ impl LinkRunShort {
}
pub struct LinkRunDate {
link: Link,
link: AbsPath,
date: String, // TODO base.date(...)?
}
impl LinkRunDate {
pub fn new(base: &Base, id: String, start: OffsetDateTime) -> Self {
Self {
link: base.link(PathRunById { id }),
link: base.config.path(PathRunById { id }),
date: util::format_time(start),
}
}
@ -93,14 +94,14 @@ impl LinkRunDate {
}
pub struct LinkWorker {
link: Link,
link: AbsPath,
name: String,
}
impl LinkWorker {
pub fn new(base: &Base, name: String) -> Self {
Self {
link: base.link(PathWorkerByName { name: name.clone() }),
link: base.config.path(PathWorkerByName { name: name.clone() }),
name,
}
}

3
src/server/web/pages/commit.rs
View file

@ -15,6 +15,7 @@ use crate::{
base::{Base, Tab},
link::{LinkCommit, LinkRunDate},
paths::{PathAdminQueueAdd, PathCommitByHash},
server_config_ext::ServerConfigExt,
},
},
somehow,
@ -145,7 +146,7 @@ pub async fn get_commit_by_hash(
}
}
}
form method="post" action=(base.link(PathAdminQueueAdd {})) {
form method="post" action=(config.path(PathAdminQueueAdd {})) {
input type="hidden" name="hash" value=(commit.hash);
button { "Add to queue" } " with a "
label for="priority" { "priority" } " of "

5
src/server/web/pages/graph.rs
View file

@ -15,6 +15,7 @@ use crate::{
base::{Base, Tab},
paths::{PathGraph, PathGraphCommits, PathGraphMeasurements, PathGraphMetrics},
r#static::{GRAPH_JS, UPLOT_CSS},
server_config_ext::ServerConfigExt,
},
},
somehow,
@ -29,8 +30,8 @@ pub async fn get_graph(
Ok(base.html(
"graph",
html! {
link rel="stylesheet" href=(base.link(UPLOT_CSS));
script type="module" src=(base.link(GRAPH_JS)) {}
link rel="stylesheet" href=(config.path(UPLOT_CSS));
script type="module" src=(config.path(GRAPH_JS)) {}
},
html! {
h2 { "Graph" }

7
src/server/web/pages/index.rs
View file

@ -9,6 +9,7 @@ use crate::{
base::{Base, Tab},
link::LinkCommit,
paths::{PathAdminRefsTrack, PathAdminRefsUntrack, PathAdminRefsUpdate, PathIndex},
server_config_ext::ServerConfigExt,
},
somehow,
};
@ -60,7 +61,7 @@ pub async fn get_index(
h2 { "Refs" }
details .refs-list open {
summary { "Tracked (" (tracked_refs.len()) ")" }
form method="post" action=(base.link(PathAdminRefsUntrack {})) {
form method="post" action=(config.path(PathAdminRefsUntrack {})) {
dl {
@for r#ref in tracked_refs {
dt {
@ -75,7 +76,7 @@ pub async fn get_index(
}
details .refs-list {
summary { "Untracked (" (untracked_refs.len()) ")" }
form method="post" action=(base.link(PathAdminRefsTrack {})) {
form method="post" action=(config.path(PathAdminRefsTrack {})) {
dl {
@for r#ref in untracked_refs {
dt {
@ -88,7 +89,7 @@ pub async fn get_index(
}
}
}
form method="post" action=(base.link(PathAdminRefsUpdate {})) {
form method="post" action=(config.path(PathAdminRefsUpdate {})) {
button { "Update" }
}
},

21
src/server/web/pages/queue.rs
View file

@ -17,13 +17,14 @@ use crate::{
server::{
util,
web::{
base::{Base, Link, Tab},
base::{Base, Tab},
link::{LinkCommit, LinkRunShort, LinkWorker},
paths::{
PathAdminQueueAddBatch, PathAdminQueueDecrease, PathAdminQueueDelete,
PathAdminQueueIncrease, PathQueue, PathQueueDelete, PathQueueInner,
},
r#static::QUEUE_JS,
server_config_ext::{AbsPath, ServerConfigExt},
},
workers::{WorkerInfo, Workers},
},
@ -43,9 +44,9 @@ struct Worker {
}
struct Task {
link_delete: Link,
link_increase: Link,
link_decrease: Link,
link_delete: AbsPath,
link_increase: AbsPath,
link_decrease: AbsPath,
hash: String,
commit: LinkCommit,
since: String,
@ -125,11 +126,11 @@ async fn get_queue_data(
.fetch(db)
.map_ok(|r| Task {
workers: workers_by_commit.remove(&r.hash).unwrap_or_default(),
link_delete: base.link(PathQueueDelete {
link_delete: base.config.path(PathQueueDelete {
hash: r.hash.clone(),
}),
link_increase: base.link(PathAdminQueueIncrease {}),
link_decrease: base.link(PathAdminQueueDecrease {}),
link_increase: base.config.path(PathAdminQueueIncrease {}),
link_decrease: base.config.path(PathAdminQueueDecrease {}),
hash: r.hash.clone(),
commit: LinkCommit::new(base, r.hash, &r.message, r.reachable),
since: util::format_delta_from_now(r.date),
@ -246,11 +247,11 @@ pub async fn get_queue(
Ok(base.html(
&format!("queue ({})", tasks.len()),
html! {
script type="module" src=(base.link(QUEUE_JS)) {}
script type="module" src=(config.path(QUEUE_JS)) {}
},
html! {
div #inner { (page_inner(workers, tasks)) }
form method="post" action=(base.link(PathAdminQueueAddBatch {})) {
form method="post" action=(config.path(PathAdminQueueAddBatch {})) {
label {
"Batch size: "
input name="amount" type="number" value="10" min="1";
@ -299,7 +300,7 @@ pub async fn get_queue_delete(
p { "You are about to delete this commit from the queue:" }
p { (commit.html()) }
p { "All runs of this commit currently in progress will be aborted!" }
form method="post" action=(base.link(PathAdminQueueDelete {})) {
form method="post" action=(config.path(PathAdminQueueDelete {})) {
input name="hash" type="hidden" value=(r.hash);
button { "Delete commit and abort runs" }
}

31
src/server/web/server_config_ext.rs Normal file
View file

@ -0,0 +1,31 @@
use std::fmt;
use crate::config::ServerConfig;
pub trait ServerConfigExt {
fn path<T: fmt::Display>(&self, to: T) -> AbsPath;
}
impl ServerConfigExt for ServerConfig {
fn path<T: fmt::Display>(&self, to: T) -> AbsPath {
let to = to.to_string();
assert!(to.starts_with('/'));
AbsPath(format!("{}{to}", self.web_base))
}
}
/// An absolute path to a resource on the web server.
#[derive(Clone)]
pub struct AbsPath(String);
impl fmt::Display for AbsPath {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f)
}
}
impl AsRef<str> for AbsPath {
fn as_ref(&self) -> &str {
&self.0
}
}