steid

refactor: one place decides that git ran out of time

`refs`, `commit` and `blame` each carried the same `is_timeout()` match, written
three times inside one wave because the five branches could not see each other.
The predicate moves to `web::context::timed_out` and each page keeps its own
wording, which is the part that should differ — a branches list, a diff and a
blame all offer something different instead.

`search_repo` stays as it is and the doc comment says why: it answers
`Searched::TimedOut` in the application layer, where a timeout is one of several
results the same form re-renders rather than an error to catch.

Blame's panel is renamed `took_too_long` to match the commit page's, freeing the
name the predicate now holds.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J18ViwAfdswUCMb2DXJZFG

JamesPatrickGill authored 14 hours agoparent8804ad9Browse files00d9c061fd2a562b42ac9d529a51fd7471292cfe

5 files changed+33 −27

plans/current.md+5 −4View file

		@@ -154,8 +154,8 @@ instance, and Steid's own source is pushed to it and browsable there.
154	154	- A repository with tags but no branches says "No branches"; real but exotic, not
155	155	fixture-tested.
156	156	- `web::browse::{encode, timestamp}` are now `pub(super)`, and `repo_stats` takes
157		− `handle` and `name` so the sidebar counts can link. Watch for the next page that wants
158		− `timed_out` and move it to `web::context` then.
	157	+ `handle` and `name` so the sidebar counts can link. `timed_out` has since moved to
	158	+ `web::context`, as this said it should.
159	159
160	160	- `git grep` output is collected whole before it is capped. A one-letter query on a
161	161	big repository allocates all of git's output to keep 200 hits. Bounded by the 20 s
		@@ -170,8 +170,9 @@ instance, and Steid's own source is pushed to it and browsable there.
170	170	line), and ignores `GrepHit::column` when marking.
171	171
172	172	- The commit page's timeout state has never been rendered, like search's and the
173		− refs pages'. Three pages now each map `is_timeout()` to a panel of their own; the next
174		− one should move the helper to `web::context`.
	173	+ refs pages'. The predicate itself is now `web::context::timed_out`, shared by `refs`,
	174	+ `commit` and `blame`; each page still writes its own panel, and `search_repo` still
	175	+ answers in the application layer.
175	176	- `Diff::files` is emptied wholesale when the patch is truncated, falling back to the
176	177	numstat list, so a 10 MiB commit shows no lines rather than the first few files.
177	178	numstat itself could in principle be truncated at ~300,000 changed files.

src/infrastructure/web/blame.rs+5 −7View file

		@@ -20,9 +20,7 @@ use topcoat::{
20	20	};
21	21
22	22	use crate::{
23		− application::{
24		− Blame, BlameContent, BlameFile, BlameGroup, Error, blame::AGE_STEPS, blame_file,
25		− },
	23	+ application::{Blame, BlameContent, BlameFile, BlameGroup, blame::AGE_STEPS, blame_file},
26	24	domain::{ObjectId, RefName, RepoPath},
27	25	};
28	26
		@@ -30,7 +28,7 @@ use super::{
30	28	browse::{
31	29	Switch, ago, crumbs, encode, raw_url, ref_links, refs_for, rev_switcher, size_of, tree_url,
32	30	},
33		− context::{current_actor, memberships, orgs, queries, repos, server_error},
	31	+ context::{current_actor, memberships, orgs, queries, repos, server_error, timed_out},
34	32	layout::wide,
35	33	repo::{Tab, repo_for, repo_header},
36	34	};
		@@ -93,7 +91,7 @@ async fn blaming(cx: &Cx, rev: RefName, path: RepoPath) -> Result {
93	91	let file: Option<BlameFile> = match outcome {
94	92	Ok(Some(file)) => Some(file),
95	93	Ok(None) => return Err(not_found().into()),
96		− Err(Error::GitQuery(error)) if error.is_timeout() => None,
	94	+ Err(error) if timed_out(&error) => None,
97	95	Err(other) => return Err(server_error(std::io::Error::other(other.to_string()))),
98	96	};
99	97
		@@ -172,7 +170,7 @@ async fn blaming(cx: &Cx, rev: RefName, path: RepoPath) -> Result {
172	170	Body::Empty => note(message: "This file is empty."),
173	171	Body::Binary => note(message: "This file cannot be blamed as text."),
174	172	Body::TooLarge(_) => note(message: oversized.as_str()),
175		− Body::TimedOut => timed_out(blob: blob.as_str()),
	173	+ Body::TimedOut => took_too_long(blob: blob.as_str()),
176	174	}
177	175	</div>
178	176	)
		@@ -192,7 +190,7 @@ async fn note(message: &str) -> Result {
192	190	/// It offers the file itself rather than a retry: the read will take just as long the
193	191	/// second time, and the reader came here to see the file.
194	192	#[component]
195		−async fn timed_out(blob: &str) -> Result {
	193	+async fn took_too_long(blob: &str) -> Result {
196	194	view! {
197	195	<div class="px-4 py-6 text-center">
198	196	<p class="text-sm text-muted-foreground">

src/infrastructure/web/commit.rs+4 −4View file

		@@ -33,8 +33,8 @@ use topcoat::{
33	33
34	34	use crate::{
35	35	application::{
36		− COMPARE_LOG_LIMIT, Compared, Comparison, Diff, DiffLine, Error, FileChange, FileDiff,
37		− FileStat, LineKind, MAX_FILE_DIFF_LINES, RefList, RepoView, compare_revisions, list_refs,
	36	+ COMPARE_LOG_LIMIT, Compared, Comparison, Diff, DiffLine, FileChange, FileDiff, FileStat,
	37	+ LineKind, MAX_FILE_DIFF_LINES, RefList, RepoView, compare_revisions, list_refs,
38	38	view_commit,
39	39	},
40	40	components::{
		@@ -47,7 +47,7 @@ use crate::{
47	47
48	48	use super::{
49	49	browse::{ago, commit_log, encode, timestamp, tree_url},
50		− context::{current_actor, memberships, orgs, queries, repos, server_error},
	50	+ context::{current_actor, memberships, orgs, queries, repos, server_error, timed_out},
51	51	layout::wide,
52	52	repo::{Tab, repo_for, repo_header},
53	53	};
		@@ -711,7 +711,7 @@ fn unwrap_page<T>(loaded: crate::application::Result<Option<T>>) -> Result<Optio
711	711	match loaded {
712	712	Ok(Some(page)) => Ok(Some(page)),
713	713	Ok(None) => Err(not_found().into()),
714		− Err(Error::GitQuery(error)) if error.is_timeout() => {
	714	+ Err(error) if timed_out(&error) => {
715	715	eprintln!("steid: {error}");
716	716	Ok(None)
717	717	}

src/infrastructure/web/context.rs+17 −1View file

		@@ -20,7 +20,7 @@ use topcoat::{
20	20	};
21	21
22	22	use crate::{
23		− application::{AppConfig, Identity, describe_identity, is_claimed, resolve_actor},
	23	+ application::{AppConfig, Error, Identity, describe_identity, is_claimed, resolve_actor},
24	24	domain::{Actor, SessionTokenHash},
25	25	infrastructure::{
26	26	git::{DiskGitArchive, DiskGitStorage, GitHttpBackend},
		@@ -51,6 +51,22 @@ where
51	51	internal_server_error(error).into()
52	52	}
53	53
	54	+/// Whether a use case failed because git was too slow rather than because git broke.
	55	+///
	56	+/// A timeout is the one read failure that is not a fault: the repository is fine and the
	57	+/// request asked more of it than one page's budget allows. A page that can say so
	58	+/// renders a state of its own — in its own words, offering whatever costs less — rather
	59	+/// than a 500 that claims the instance is broken.
	60	+///
	61	+/// Four pages wanted this within one wave (`refs`, `commit`, `blame`, and `search`
	62	+/// before it moved), which is what it took to earn a home here. `search_repo` is the
	63	+/// exception and stays as it is: it answers `Searched::TimedOut` in the application
	64	+/// layer, because there the timeout is one of several results the same form re-renders
	65	+/// rather than an error to be caught.
	66	+pub fn timed_out(error: &Error) -> bool {
	67	+ matches!(error, Error::GitQuery(query) if query.is_timeout())
	68	+}
	69	+
54	70	pub fn orgs(cx: &Cx) -> SqliteOrgRepo {
55	71	SqliteOrgRepo::new(pool(cx).clone())
56	72	}

src/infrastructure/web/refs.rs+2 −11View file

		@@ -22,14 +22,14 @@ use topcoat::{
22	22	};
23	23
24	24	use crate::{
25		− application::{Error, RefPage, RepoView, list_branches, list_tags},
	25	+ application::{RefPage, RepoView, list_branches, list_tags},
26	26	components::badge::{BadgeVariant, badge},
27	27	domain::{BranchRow, RefName, TagRow},
28	28	};
29	29
30	30	use super::{
31	31	browse::{ago, empty_repo, encode, log_url, timestamp, tree_url},
32		− context::{current_actor, memberships, orgs, queries, repos, server_error},
	32	+ context::{current_actor, memberships, orgs, queries, repos, server_error, timed_out},
33	33	layout::wide,
34	34	repo::{Tab, clone_url_for, repo_for, repo_header},
35	35	};
		@@ -61,15 +61,6 @@ fn compare_url(handle: &str, name: &str, base: &RefName, head: &RefName) -> Stri
61	61	)
62	62	}
63	63
64		−/// Whether a failure was git being too slow rather than git being broken.
65		−///
66		−/// A timeout is the one read failure that is not a fault: the repository is fine and the
67		−/// request asked more of it than one page's budget allows. It gets a page state so the
68		−/// visitor is told what happened, rather than a 500 that says the instance is broken.
69		−fn timed_out(error: &Error) -> bool {
70		− matches!(error, Error::GitQuery(query) if query.is_timeout())
71		−}
72		−
73	64	#[page("/{handle}/repos/{name}/branches")]
74	65	async fn branches_page(cx: &Cx) -> Result {
75	66	let repo = repo_for(cx).await?;