aboutsummaryrefslogtreecommitdiffstats
path: root/pkgs/by-name/ba/back/src/web
diff options
context:
space:
mode:
Diffstat (limited to 'pkgs/by-name/ba/back/src/web')
-rw-r--r--pkgs/by-name/ba/back/src/web/generate/mod.rs227
-rw-r--r--pkgs/by-name/ba/back/src/web/issue_html.rs166
-rw-r--r--pkgs/by-name/ba/back/src/web/mod.rs271
-rw-r--r--pkgs/by-name/ba/back/src/web/prefix.rs35
-rw-r--r--pkgs/by-name/ba/back/src/web/responses.rs50
5 files changed, 383 insertions, 366 deletions
diff --git a/pkgs/by-name/ba/back/src/web/generate/mod.rs b/pkgs/by-name/ba/back/src/web/generate/mod.rs
new file mode 100644
index 0000000..10146bb
--- /dev/null
+++ b/pkgs/by-name/ba/back/src/web/generate/mod.rs
@@ -0,0 +1,227 @@
+use std::{fs, path::Path};
+
+use gix::hash::Prefix;
+use log::info;
+use rinja::Template;
+use url::Url;
+
+use crate::{
+ config::BackConfig,
+ error,
+ git_bug::{
+ dag::issues_from_repository,
+ issue::{CollapsedIssue, Status},
+ },
+};
+
+#[derive(Template)]
+#[template(path = "./issues.html")]
+struct IssuesTemplate {
+ wanted_status: Status,
+ counter_status: Status,
+ issues: Vec<CollapsedIssue>,
+
+ /// The path to the repository
+ repo_path: String,
+
+ /// The URL to `back`'s source code
+ source_code_repository_url: Url,
+}
+pub fn issues(
+ config: &BackConfig,
+ wanted_status: Status,
+ counter_status: Status,
+ repo_path: &Path,
+) -> error::Result<String> {
+ let repository = config
+ .repositories
+ .get(repo_path)?
+ .open(config.repositories.scan_path())?;
+
+ let mut issue_list = issues_from_repository(&repository.to_thread_local())?
+ .into_iter()
+ .map(|issue| issue.collapse())
+ .filter(|issue| issue.status == wanted_status)
+ .collect::<Vec<CollapsedIssue>>();
+
+ // Sort by date descending.
+ // SAFETY:
+ // The time stamp is only used for sorting, so a malicious attacker could only affect the issue
+ // sorting.
+ issue_list.sort_by_key(|issue| unsafe { issue.timestamp.to_unsafe() });
+ issue_list.reverse();
+
+ Ok(IssuesTemplate {
+ wanted_status,
+ counter_status,
+ source_code_repository_url: config.source_code_repository_url.clone(),
+ issues: issue_list,
+ repo_path: repo_path.display().to_string(),
+ }
+ .render()
+ .expect("This should always work"))
+}
+
+use crate::git_bug::format::HtmlString;
+#[derive(Template)]
+#[template(path = "./issue.html")]
+struct IssueTemplate {
+ issue: CollapsedIssue,
+
+ /// The path to the repository
+ repo_path: String,
+
+ /// The URL to `back`'s source code
+ source_code_repository_url: Url,
+}
+pub fn issue(config: &BackConfig, repo_path: &Path, prefix: Prefix) -> error::Result<String> {
+ let repository = config
+ .repositories
+ .get(repo_path)?
+ .open(config.repositories.scan_path())?
+ .to_thread_local();
+
+ let maybe_issue = issues_from_repository(&repository)?
+ .into_iter()
+ .map(|val| val.collapse())
+ .find(|issue| issue.id.to_string().starts_with(&prefix.to_string()));
+
+ match maybe_issue {
+ Some(issue) => Ok(IssueTemplate {
+ issue,
+ repo_path: repo_path.display().to_string(),
+ source_code_repository_url: config.source_code_repository_url.clone(),
+ }
+ .render()
+ .expect("This should always work")),
+ None => Err(error::Error::IssuesPrefixMissing { prefix }),
+ }
+}
+
+#[derive(Template)]
+#[template(path = "./repos.html")]
+struct ReposTemplate {
+ repos: Vec<RepoValue>,
+
+ /// The URL to `back`'s source code
+ source_code_repository_url: Url,
+}
+struct RepoValue {
+ description: String,
+ owner: String,
+ path: String,
+}
+pub fn repos(config: &BackConfig) -> error::Result<String> {
+ let repos: Vec<RepoValue> = config
+ .repositories
+ .iter()
+ .filter_map(
+ |raw_repo| match raw_repo.open(config.repositories.scan_path()) {
+ Ok(repo) => {
+ let repo = repo.to_thread_local();
+ let git_config = repo.config_snapshot();
+
+ let path = raw_repo.path().to_string_lossy().to_string();
+
+ let owner = git_config
+ .string("cgit.owner")
+ .map(|v| v.to_string())
+ .unwrap_or("<No owner>".to_owned());
+
+ let description = fs::read_to_string(repo.git_dir().join("description"))
+ .unwrap_or("<No description>".to_owned());
+
+ Some(RepoValue {
+ description,
+ owner,
+ path,
+ })
+ }
+ Err(err) => {
+ info!(
+ "Repo '{}' could not be opened: '{err}'",
+ raw_repo.path().display()
+ );
+ None
+ }
+ },
+ )
+ .collect();
+
+ Ok(ReposTemplate {
+ repos,
+ source_code_repository_url: config.source_code_repository_url.clone(),
+ }
+ .render()
+ .expect("this should work"))
+}
+
+pub fn feed(config: &BackConfig, repo_path: &Path) -> error::Result<String> {
+ use rss::{ChannelBuilder, Item, ItemBuilder};
+
+ let repository = config
+ .repositories
+ .get(repo_path)?
+ .open(config.repositories.scan_path())?
+ .to_thread_local();
+
+ let issues: Vec<CollapsedIssue> = issues_from_repository(&repository)?
+ .into_iter()
+ .map(|issue| issue.collapse())
+ .collect();
+
+ // Collect all Items as rss items
+ let mut items: Vec<Item> = issues
+ .iter()
+ .map(|issue| {
+ ItemBuilder::default()
+ .title(issue.title.to_string())
+ .author(issue.author.to_string())
+ .description(issue.message.to_string())
+ .pub_date(issue.timestamp.to_string())
+ .link(format!(
+ "/{}/{}/issue/{}",
+ repo_path.display(),
+ &config.root,
+ issue.id
+ ))
+ .build()
+ })
+ .collect();
+
+ // Append all comments after converting them to rss items
+ items.extend(
+ issues
+ .iter()
+ .filter(|issue| !issue.comments.is_empty())
+ .flat_map(|issue| {
+ issue
+ .comments
+ .iter()
+ .map(|comment| {
+ ItemBuilder::default()
+ .title(issue.title.to_string())
+ .author(comment.author.to_string())
+ .description(comment.message.to_string())
+ .pub_date(comment.timestamp.to_string())
+ .link(format!(
+ "/{}/{}/issue/{}",
+ repo_path.display(),
+ &config.root,
+ issue.id
+ ))
+ .build()
+ })
+ .collect::<Vec<Item>>()
+ })
+ .collect::<Vec<Item>>(),
+ );
+
+ let channel = ChannelBuilder::default()
+ .title("Issues")
+ .link(config.root.to_string())
+ .description(format!("The rss feed for issues on {}.", &config.root))
+ .items(items)
+ .build();
+ Ok(channel.to_string())
+}
diff --git a/pkgs/by-name/ba/back/src/web/issue_html.rs b/pkgs/by-name/ba/back/src/web/issue_html.rs
deleted file mode 100644
index 45c0281..0000000
--- a/pkgs/by-name/ba/back/src/web/issue_html.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-// Back - An extremely simple git issue tracking system. Inspired by tvix's
-// panettone
-//
-// Copyright (C) 2024 Benedikt Peetz <benedikt.peetz@b-peetz.de>
-// SPDX-License-Identifier: AGPL-3.0-or-later
-//
-// This file is part of Back.
-//
-// You should have received a copy of the License along with this program.
-// If not, see <https://www.gnu.org/licenses/agpl.txt>.
-
-use rocket::response::content::RawHtml;
-
-use crate::{
- config::BackConfig,
- git_bug::{
- format::HtmlString,
- issue::{identity::Author, CollapsedIssue, Comment},
- },
-};
-
-impl CollapsedIssue {
- pub fn to_list_entry(&self) -> RawHtml<String> {
- let comment_list = if self.comments.is_empty() {
- String::new()
- } else {
- let comments_string = if self.comments.len() > 1 {
- "comments"
- } else {
- "comment"
- };
-
- format!(
- r#"
- <span class="comment-count"> - {} {}</span>
- "#,
- self.comments.len(),
- comments_string
- )
- };
-
- let CollapsedIssue {
- id,
- title,
- message: _,
- author,
- timestamp,
- comments: _,
- status: _,
- last_status_change: _,
- labels: _,
- } = self;
-
- let Author { name, email, id: _ } = author;
-
- RawHtml(format!(
- r#"
- <li>
- <a href="/issue/{id}">
- <p>
- <span class="issue-subject">{title}</span>
- </p>
- <span class="issue-number">{id}</span> - <span class="created-by-at">Opened by <span class="user-name">{name}</span> <span class="user-email">&lt;{email}&gt;</span> at <span class="timestamp">{timestamp}</span></span>{comment_list} </a>
- </li>
-"#,
- ))
- }
-
- pub fn to_html(&self, config: &BackConfig) -> RawHtml<String> {
- let comments = if self.comments.is_empty() {
- String::new()
- } else {
- let fmt_comments: String = self
- .comments
- .iter()
- .map(|val| {
- let Comment {
- id,
- author,
- message,
- timestamp,
- } = val;
- let Author {
- name,
- email: _,
- id: _,
- } = author;
-
- format!(
- r#"
- <li class="comment" id="{id}">
- {message}
- <p class="comment-info"><span class="user-name">{name} at {timestamp}</span></p>
- </li>
- "#,
- )
- })
- .collect::<Vec<String>>()
- .join("\n");
-
- format!(
- r#"
- <ol class="issue-history">
- {fmt_comments}
- </ol>
- "#
- )
- };
-
- {
- let CollapsedIssue {
- id,
- title,
- message,
- author,
- timestamp,
- comments: _,
- status: _,
- last_status_change: _,
- labels: _,
- } = self;
- let Author { name, email, id: _ } = author;
- let html_title = HtmlString::from(title.clone());
-
- RawHtml(format!(
- r#"
-<!DOCTYPE html>
-<html lang="en">
- <head>
- <title>{html_title} | Back</title>
- <link href="/style.css" rel="stylesheet" type="text/css">
- <meta content="width=device-width,initial-scale=1" name="viewport">
- </head>
- <body>
- <div class="content">
- <nav>
- <a href="/issues/open">Open Issues</a>
- <a href="/issues/closed">Closed Issues</a>
- </nav>
- <header>
- <h1>{title}</h1>
- <div class="issue-number">{id}</div>
- </header>
- <main>
- <div class="issue-info">
- <span class="created-by-at">Opened by <span class="user-name">{name}</span> <span class="user-email">&lt;{email}&gt;</span> at <span class="timestamp">{timestamp}</span></span>
- </div>
- {message}
- {comments}
- </main>
- <footer>
- <nav>
- <a href="/issues/open">Open Issues</a>
- <a href="{}">Source code</a>
- <a href="/issues/closed">Closed Issues</a>
- </nav>
- </footer>
- </div>
- </body>
-</html>
-"#,
- config.source_code_repository_url
- ))
- }
- }
-}
diff --git a/pkgs/by-name/ba/back/src/web/mod.rs b/pkgs/by-name/ba/back/src/web/mod.rs
index f7a4077..cc087ab 100644
--- a/pkgs/by-name/ba/back/src/web/mod.rs
+++ b/pkgs/by-name/ba/back/src/web/mod.rs
@@ -1,186 +1,127 @@
-// Back - An extremely simple git issue tracking system. Inspired by tvix's
-// panettone
-//
-// Copyright (C) 2024 Benedikt Peetz <benedikt.peetz@b-peetz.de>
-// SPDX-License-Identifier: AGPL-3.0-or-later
-//
-// This file is part of Back.
-//
-// You should have received a copy of the License along with this program.
-// If not, see <https://www.gnu.org/licenses/agpl.txt>.
+use bytes::Bytes;
+use http_body_util::combinators::BoxBody;
+use hyper::{server::conn::http1, service::service_fn, Method, Request, Response, StatusCode};
+use hyper_util::rt::TokioIo;
+use log::{error, info};
+use responses::{html_response, html_response_status, html_response_status_content_type};
+use tokio::net::TcpListener;
-use crate::{
- config::BackConfig,
- error::{self, Error},
- git_bug::{
- dag::issues_from_repository,
- issue::{CollapsedIssue, Status},
- },
-};
-use prefix::BackPrefix;
-use rocket::{
- get,
- response::content::{RawCss, RawHtml},
- State,
-};
+use std::{convert::Infallible, net::SocketAddr, path::PathBuf, sync::Arc};
-mod issue_html;
-pub mod prefix;
+use crate::{config::BackConfig, error, git_bug::issue::Status};
-#[get("/style.css")]
-pub fn styles() -> RawCss<String> {
- RawCss(include_str!("../../assets/style.css").to_owned())
-}
+mod generate;
+mod responses;
+
+async fn match_uri(
+ config: Arc<BackConfig>,
+ req: Request<hyper::body::Incoming>,
+) -> Result<Response<BoxBody<Bytes, Infallible>>, hyper::Error> {
+ if req.method() != Method::GET {
+ return Ok(html_response_status(
+ "Only get requests are supported",
+ StatusCode::NOT_ACCEPTABLE,
+ ));
+ }
-pub fn issue_list_boilerplate(
- config: &State<BackConfig>,
- wanted_status: Status,
- counter_status: Status,
-) -> error::Result<RawHtml<String>> {
- let repository = &config.repository;
+ let output = || -> Result<Response<BoxBody<Bytes, Infallible>>, error::Error> {
+ match req.uri().path().trim_end_matches("/") {
+ "" => Ok(html_response(generate::repos(&config)?)),
- let mut issue_list = issues_from_repository(&repository.to_thread_local())?
- .into_iter()
- .map(|issue| issue.collapse())
- .collect::<Vec<CollapsedIssue>>();
+ "/style.css" => Ok(responses::html_response_status_content_type(
+ include_str!("../../assets/style.css"),
+ StatusCode::OK,
+ "text/css",
+ )),
- // Sort by date descending.
- issue_list.sort_by_key(|issue| unsafe { issue.timestamp.to_unsafe() });
- issue_list.reverse();
+ path if path.ends_with("/issues/open") => {
+ let repo_path = PathBuf::from(
+ path.strip_suffix("/issues/open")
+ .expect("This suffix exists")
+ .strip_prefix("/")
+ .expect("This also exists"),
+ );
- let issue_list_str = issue_list.into_iter().fold(String::new(), |acc, issue| {
- format!("{}{}", acc, {
- if issue.status == wanted_status {
- let issue_entry = issue.to_list_entry();
- issue_entry.0
- } else {
- String::new()
+ let issues = generate::issues(&config, Status::Open, Status::Closed, &repo_path)?;
+ Ok(html_response(issues))
}
- })
- });
+ path if path.ends_with("/issues/closed") => {
+ let repo_path = PathBuf::from(
+ path.strip_suffix("/issues/closed")
+ .expect("This suffix exists")
+ .strip_prefix("/")
+ .expect("This also exists"),
+ );
- let counter_status_lower = counter_status.to_string().to_lowercase();
- Ok(RawHtml(format!(
- r#"
- <!DOCTYPE html>
- <html lang="en">
- <head>
- <title>Back</title>
- <link href="/style.css" rel="stylesheet" type="text/css">
- <meta content="width=device-width,initial-scale=1" name="viewport">
- </head>
- <body>
- <div class="content">
- <header>
- <h1>{wanted_status} Issues</h1>
- </header>
- <main>
- <div class="issue-links">
- <a href="/issues/{counter_status_lower}/">View {counter_status} issues</a>
- <a href="{}">Source code</a>
- <!--
- <form class="issue-search" method="get">
- <input name="search" title="Issue search query" type="search">
- <input class="sr-only" type="submit" value="Search Issues">
- </form>
- -->
- </div>
- <ol class="issue-list">
- {issue_list_str}
- </ol>
- </main>
- </div>
- </body>
- </html>
- "#,
- config.source_code_repository_url
- )))
-}
+ let issues = generate::issues(&config, Status::Closed, Status::Open, &repo_path)?;
+ Ok(html_response(issues))
+ }
+ path if path.ends_with("/issues/feed") => {
+ let repo_path = PathBuf::from(
+ path.strip_suffix("/issues/feed")
+ .expect("This suffix exists")
+ .strip_prefix("/")
+ .expect("This also exists"),
+ );
-#[get("/issues/open")]
-pub fn open(config: &State<BackConfig>) -> error::Result<RawHtml<String>> {
- issue_list_boilerplate(config, Status::Open, Status::Closed)
-}
-#[get("/issues/closed")]
-pub fn closed(config: &State<BackConfig>) -> error::Result<RawHtml<String>> {
- issue_list_boilerplate(config, Status::Closed, Status::Open)
-}
+ let feed = generate::feed(&config, &repo_path)?;
+ Ok(html_response_status_content_type(
+ feed,
+ StatusCode::OK,
+ "text/xml",
+ ))
+ }
+
+ path if path.contains("/issue/") => {
+ let (repo_path, prefix) = {
+ let split: Vec<&str> = path.split("/issue/").collect();
+
+ let prefix =
+ gix::hash::Prefix::from_hex(split[1]).map_err(error::Error::from)?;
-#[get("/issues/feed")]
-pub fn feed(config: &State<BackConfig>) -> error::Result<RawHtml<String>> {
- use rss::{ChannelBuilder, Item, ItemBuilder};
+ let repo_path =
+ PathBuf::from(split[0].strip_prefix("/").expect("This prefix exists"));
- //Collect all Items as rss items
- let mut items: Vec<Item> = issues_from_repository(&config.repository.to_thread_local())?
- .into_iter()
- .map(|issue| issue.collapse())
- .map(|issue| {
- ItemBuilder::default()
- .title(issue.title.to_string())
- .author(issue.author.to_string())
- .description(issue.message.to_string())
- .pub_date(issue.timestamp.to_string())
- .link(format!("{}/issue/{}", &config.root.to_string(), issue.id))
- .build()
- })
- .collect();
- //Append all comments after converting them to rss items
- items.extend(
- issues_from_repository(&config.repository.to_thread_local())?
- .into_iter()
- .map(|issue| issue.collapse())
- .filter(|issue| issue.comments.len() > 0)
- .map(|issue| {
- issue
- .comments
- .into_iter()
- .map(|comment| {
- ItemBuilder::default()
- .title(issue.title.to_string())
- .author(comment.author.to_string())
- .description(comment.message.to_string())
- .pub_date(comment.timestamp.to_string())
- .link(format!("{}/issue/{}", &config.root.to_string(), issue.id))
- .build()
- })
- .collect::<Vec<Item>>()
- })
- .flatten()
- .collect::<Vec<Item>>(),
- );
+ (repo_path, prefix)
+ };
+ Ok(html_response(generate::issue(&config, &repo_path, prefix)?))
+ }
- let channel = ChannelBuilder::default()
- .title("Issues")
- .link(config.root.to_string())
- .description(format!("The rss feed for issues on {}.", config.root))
- .items(items)
- .build();
- Ok(RawHtml(channel.to_string()))
+ other => Ok(responses::html_response_status_content_type(
+ format!("'{}' not found", other),
+ StatusCode::NOT_FOUND,
+ "text/plain",
+ )),
+ }
+ };
+ match output() {
+ Ok(response) => Ok(response),
+ Err(err) => Ok(err.into_response()),
+ }
}
-#[get("/issue/<prefix>")]
-pub fn show_issue(
- config: &State<BackConfig>,
- prefix: Result<BackPrefix, gix::hash::prefix::from_hex::Error>,
-) -> error::Result<RawHtml<String>> {
- // NOTE(@bpeetz): Explicitly unwrap the `prefix` here (instead of taking the unwrapped value as
- // argument), to avoid triggering rockets "errors forward to the next route" feature.
- // This ensures, that our error message actually reaches the user. <2024-12-26>
- let prefix = prefix?;
+pub async fn main(config: Arc<BackConfig>) -> Result<(), error::Error> {
+ let addr: SocketAddr = ([127, 0, 0, 1], 8000).into();
- let repository = config.repository.to_thread_local();
+ let listener = TcpListener::bind(addr)
+ .await
+ .map_err(|err| error::Error::TcpBind { addr, err })?;
+ info!("Listening on http://{}", addr);
+ loop {
+ let (stream, _) = listener
+ .accept()
+ .await
+ .map_err(|err| error::Error::TcpAccept { err })?;
+ let io = TokioIo::new(stream);
- let all_issues: Vec<CollapsedIssue> = issues_from_repository(&repository)?
- .into_iter()
- .map(|val| val.collapse())
- .collect();
+ let local_config = Arc::clone(&config);
- let maybe_issue = all_issues
- .iter()
- .find(|issue| issue.id.to_string().starts_with(&prefix.to_string()));
+ let service = service_fn(move |req| match_uri(Arc::clone(&local_config), req));
- match maybe_issue {
- Some(issue) => Ok(issue.to_html(config)),
- None => Err(Error::IssuesPrefixMissing { prefix }),
+ tokio::task::spawn(async move {
+ if let Err(err) = http1::Builder::new().serve_connection(io, service).await {
+ error!("Error serving connection: {:?}", err);
+ }
+ });
}
}
diff --git a/pkgs/by-name/ba/back/src/web/prefix.rs b/pkgs/by-name/ba/back/src/web/prefix.rs
deleted file mode 100644
index 5143799..0000000
--- a/pkgs/by-name/ba/back/src/web/prefix.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Back - An extremely simple git issue tracking system. Inspired by tvix's
-// panettone
-//
-// Copyright (C) 2024 Benedikt Peetz <benedikt.peetz@b-peetz.de>
-// SPDX-License-Identifier: AGPL-3.0-or-later
-//
-// This file is part of Back.
-//
-// You should have received a copy of the License along with this program.
-// If not, see <https://www.gnu.org/licenses/agpl.txt>.
-
-use std::fmt::Display;
-
-use gix::hash::Prefix;
-use rocket::request::FromParam;
-
-#[derive(Debug)]
-pub struct BackPrefix {
- prefix: Prefix,
-}
-impl Display for BackPrefix {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- self.prefix.fmt(f)
- }
-}
-
-impl<'a> FromParam<'a> for BackPrefix {
- type Error = gix::hash::prefix::from_hex::Error;
-
- fn from_param(param: &'a str) -> Result<Self, Self::Error> {
- let prefix = Prefix::from_hex(param)?;
-
- Ok(Self { prefix })
- }
-}
diff --git a/pkgs/by-name/ba/back/src/web/responses.rs b/pkgs/by-name/ba/back/src/web/responses.rs
new file mode 100644
index 0000000..e50f8c2
--- /dev/null
+++ b/pkgs/by-name/ba/back/src/web/responses.rs
@@ -0,0 +1,50 @@
+use std::convert::Infallible;
+
+use bytes::Bytes;
+use http::{Response, StatusCode, Version};
+use http_body_util::{combinators::BoxBody, BodyExt, Full};
+
+use crate::{error, git_bug::format::HtmlString};
+
+pub(super) fn html_response<T: Into<Bytes>>(html_text: T) -> Response<BoxBody<Bytes, Infallible>> {
+ html_response_status(html_text, StatusCode::OK)
+}
+
+pub(super) fn html_response_status<T: Into<Bytes>>(
+ html_text: T,
+ status: StatusCode,
+) -> Response<BoxBody<Bytes, Infallible>> {
+ html_response_status_content_type(html_text, status, "text/html")
+}
+
+pub(super) fn html_response_status_content_type<T: Into<Bytes>>(
+ html_text: T,
+ status: StatusCode,
+ content_type: &str,
+) -> Response<BoxBody<Bytes, Infallible>> {
+ Response::builder()
+ .status(status)
+ .version(Version::HTTP_2)
+ .header("Content-Type", format!("{}; charset=utf-8", content_type))
+ .header("x-content-type-options", "nosniff")
+ .header("x-frame-options", "SAMEORIGIN")
+ .body(full(html_text))
+ .expect("This will always build")
+}
+
+fn full<T: Into<Bytes>>(chunk: T) -> BoxBody<Bytes, Infallible> {
+ Full::new(chunk.into()).boxed()
+}
+
+// FIXME: Not all errors should return `INTERNAL_SERVER_ERROR`. <2025-03-08>
+impl error::Error {
+ pub fn into_response(self) -> Response<BoxBody<Bytes, Infallible>> {
+ html_response_status(
+ format!(
+ "<h1> Internal server error. </h1> <pre>Error: {}</pre>",
+ HtmlString::from(self.to_string())
+ ),
+ StatusCode::INTERNAL_SERVER_ERROR,
+ )
+ }
+}
generated by cgit v1.3.1 (git 2.54.0) at 2026-05-31 16:02:20 +0000