maintenance.rs 62.3%

66 of 106 lines run, 14 of 31 functions · run #519 on main · run missed

//! Housekeeping that runs on its own (hub spec §17.2): the nightly
//! garbage collection of every repository, one at a time under its
//! write lock, so a push never races a repack. `oxygenhub gc` runs the
//! same pass by hand.

use crate::db;
use crate::repos::RepoName;
use crate::Shared;

/// What one repository's gc did, for the log and `oxygenhub gc`.
#[derive(Clone, Debug)]
pub struct Done {
    pub repo: String,
    pub failed: bool,
    pub summary: String,
}

impl std::fmt::Display for Done {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}: {}", self.repo, self.summary)
    }
}

/// Garbage-collect every repository, in turn. A repository that fails is
/// reported and the rest still run.
pub async fn gc_all(app: &Shared) -> Vec<Done> {
    // Report files past retention first (#127), so this run prunes them.
    match crate::reports::expire(&app.db).await {
        Ok(0) => {}
        Ok(n) => tracing::info!("gc: {n} reports' files expired under retention"),
        Err(e) => tracing::warn!("gc: expiring report files: {e}"),
    }
    // Drops are repositories to keep tidy too (#279).
    let rows = match db::repos::list_with_drops(&app.db).await {
        Ok(rows) => rows,
        Err(e) => {
            tracing::warn!("gc: listing repositories: {e}");
            return Vec::new();
        }
    };
    let mut done = Vec::with_capacity(rows.len());
    for row in rows {
        let slug = format!("{}/{}", row.owner, row.name);
        let Some(name) = RepoName::new(&row.owner, &row.name) else { continue };
        if !app.repos.exists(&name) {
            continue;
        }
        let label = slug.clone();
        // Flow's artifacts and reports' files are named only in the
        // database: kept as roots, or gc would prune them after the grace
        // period (#126, #127). A listing that fails skips this repository
        // rather than risk them.
        let listed = match db::flow::artifact_blobs(&app.db, row.id).await {
            Ok(mut blobs) => crate::reports::file_blobs(&app.db, row.id).await.map(|files| {
                blobs.extend(files);
                blobs
            }),
            Err(e) => Err(e),
        };
        let keep: Vec<oxy_core::hash::ObjectRef> = match listed {
            Ok(blobs) => blobs.iter().filter_map(|b| oxy_core::hash::ObjectRef::from_hex(b)).collect(),
            Err(e) => {
                tracing::warn!("gc: {slug}: listing its artifacts: {e}; skipped");
                continue;
            }
        };
        let started = std::time::Instant::now();
        let result = app
            .repos
            .write(&name, move |repo, _| Ok(repo.gc_keeping(false, &keep, &mut |phase| tracing::debug!("gc {label}: {phase}"))?))
            .await;
        let d = match result {
            Ok(r) => Done {
                summary: format!(
                    "{} reachable; pruned {} ({} bytes){}; packed {} into one pack in {:.1} s",
                    r.reachable,
                    r.pruned.objects,
                    r.pruned.bytes,
                    if r.pruned.deferred > 0 { format!(", {} deferred by the grace period", r.pruned.deferred) } else { String::new() },
                    r.packed.objects,
                    started.elapsed().as_secs_f64()
                ),
                repo: slug,
                failed: false,
            },
            Err(e) => Done { summary: format!("failed: {e}"), repo: slug, failed: true },
        };
        if d.failed {
            tracing::warn!("gc {}", d);
        } else {
            tracing::info!("gc {}", d);
        }
        done.push(d);
    }
    done
}

/// The day the nightly run last ran, kept in the data directory: a restart
/// within `gc_hour` (a deploy) does not run it again. On 2026-10-17 one did,
/// and metalgear2's requests waited 74 s behind its repack in GCS.
fn last_run_path(app: &Shared) -> std::path::PathBuf {
    app.config.data.join("gc-last-day")
}

fn last_run(app: &Shared) -> Option<String> {
    Some(std::fs::read_to_string(last_run_path(app)).ok()?.trim().to_string())
}

fn record_run(app: &Shared, day: &str) {
    if let Err(e) = std::fs::write(last_run_path(app), day) {
        tracing::warn!("gc: recording the nightly run: {e}");
    }
}

/// A day as the record keeps it: `2026-10-17`.
fn day_text(day: time::Date) -> String {
    format!("{:04}-{:02}-{:02}", day.year(), u8::from(day.month()), day.day())
}

/// Run [`gc_all`] once a day at `retention.gc_hour` UTC.
pub async fn nightly(app: Shared) {
    let hour = app.config.retention.gc_hour;
    if hour >= 24 {
        tracing::info!("gc: the nightly run is off (retention.gc_hour = {hour})");
        return;
    }
    let mut last_day = last_run(&app);
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
        let now = time::OffsetDateTime::now_utc();
        if u32::from(now.hour()) != hour {
            continue;
        }
        let day = day_text(now.date());
        if last_day.as_deref() == Some(day.as_str()) {
            continue;
        }
        record_run(&app, &day);
        last_day = Some(day);
        match crate::db::sessions::sweep(&app.db).await {
            Ok(n) if n > 0 => tracing::info!("sessions: forgot {n} that had ended"),
            Ok(_) => {}
            Err(e) => tracing::warn!("sessions: sweep failed: {e}"),
        }
        let done = gc_all(&app).await;
        tracing::info!("gc: nightly run over {} repositories, {} failed", done.len(), done.iter().filter(|d| d.failed).count());
    }
}

/// Each hour, archive the cards of columns that archive after some days
/// once they have been there longer (#293).
pub async fn archiver(app: Shared) {
    loop {
        match crate::db::projects::archive_due(&app.db, crate::db::now_ms()).await {
            Ok(n) if n > 0 => tracing::info!("projects: archived {n} card(s) their columns keep no longer"),
            Ok(_) => {}
            Err(e) => tracing::warn!("projects: archiving failed: {e}"),
        }
        tokio::time::sleep(std::time::Duration::from_secs(3600)).await;
    }
}

#[cfg(test)]
mod tests {
    #[test]
    fn a_day_is_written_as_the_record_keeps_it() {
        let day = time::Date::from_calendar_date(2026, time::Month::October, 7).unwrap();
        assert_eq!(super::day_text(day), "2026-10-07");
    }
}

1		//! Housekeeping that runs on its own (hub spec §17.2): the nightly
2		//! garbage collection of every repository, one at a time under its
3		//! write lock, so a push never races a repack. `oxygenhub gc` runs the
4		//! same pass by hand.
5
6		use crate::db;
7		use crate::repos::RepoName;
8		use crate::Shared;
9
10		/// What one repository's gc did, for the log and `oxygenhub gc`.
11		#[derive(Clone, Debug)]
12		pub struct Done {
13		pub repo: String,
14		pub failed: bool,
15		pub summary: String,
16		}
17
18		impl std::fmt::Display for Done {
19	0×	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20	0×	write!(f, "{}: {}", self.repo, self.summary)
21	0×	}
22		}
23
24		/// Garbage-collect every repository, in turn. A repository that fails is
25		/// reported and the rest still run.
26	3×	pub async fn gc_all(app: &Shared) -> Vec<Done> {
27		// Report files past retention first (#127), so this run prunes them.
28	3×	match crate::reports::expire(&app.db).await {
29	3×	Ok(0) => {}
30	0×	Ok(n) => tracing::info!("gc: {n} reports' files expired under retention"),
31	0×	Err(e) => tracing::warn!("gc: expiring report files: {e}"),
32		}
33		// Drops are repositories to keep tidy too (#279).
34	3×	let rows = match db::repos::list_with_drops(&app.db).await {
35	3×	Ok(rows) => rows,
36	0×	Err(e) => {
37	0×	tracing::warn!("gc: listing repositories: {e}");
38	0×	return Vec::new();
39		}
40		};
41	3×	let mut done = Vec::with_capacity(rows.len());
42	4×	for row in rows {
43	4×	let slug = format!("{}/{}", row.owner, row.name);
44	4×	let Some(name) = RepoName::new(&row.owner, &row.name) else { continue };
45	4×	if !app.repos.exists(&name) {
46	0×	continue;
47	4×	}
48	4×	let label = slug.clone();
49		// Flow's artifacts and reports' files are named only in the
50		// database: kept as roots, or gc would prune them after the grace
51		// period (#126, #127). A listing that fails skips this repository
52		// rather than risk them.
53	4×	let listed = match db::flow::artifact_blobs(&app.db, row.id).await {
54	4×	Ok(mut blobs) => crate::reports::file_blobs(&app.db, row.id).await.map(\|files\| {
55	4×	blobs.extend(files);
56	4×	blobs
57	4×	}),
58	0×	Err(e) => Err(e),
59		};
60	4×	let keep: Vec<oxy_core::hash::ObjectRef> = match listed {
61	5×	Ok(blobs) => blobs.iter().filter_map(\|b\| oxy_core::hash::ObjectRef::from_hex(b)).collect(),
62	0×	Err(e) => {
63	0×	tracing::warn!("gc: {slug}: listing its artifacts: {e}; skipped");
64	0×	continue;
65		}
66		};
67	4×	let started = std::time::Instant::now();
68	4×	let result = app
69	4×	.repos
70	20×	.write(&name, move \|repo, _\| Ok(repo.gc_keeping(false, &keep, &mut \|phase\| tracing::debug!("gc {label}: {phase}"))?))
71	4×	.await;
72	4×	let d = match result {
73	4×	Ok(r) => Done {
74	4×	summary: format!(
75		"{} reachable; pruned {} ({} bytes){}; packed {} into one pack in {:.1} s",
76		r.reachable,
77		r.pruned.objects,
78		r.pruned.bytes,
79	4×	if r.pruned.deferred > 0 { format!(", {} deferred by the grace period", r.pruned.deferred) } else { String::new() },
80		r.packed.objects,
81	4×	started.elapsed().as_secs_f64()
82		),
83	4×	repo: slug,
84		failed: false,
85		},
86	0×	Err(e) => Done { summary: format!("failed: {e}"), repo: slug, failed: true },
87		};
88	4×	if d.failed {
89	0×	tracing::warn!("gc {}", d);
90		} else {
91	4×	tracing::info!("gc {}", d);
92		}
93	4×	done.push(d);
94		}
95	3×	done
96	3×	}
97
98		/// The day the nightly run last ran, kept in the data directory: a restart
99		/// within `gc_hour` (a deploy) does not run it again. On 2026-10-17 one did,
100		/// and metalgear2's requests waited 74 s behind its repack in GCS.
101	198×	fn last_run_path(app: &Shared) -> std::path::PathBuf {
102	198×	app.config.data.join("gc-last-day")
103	198×	}
104
105	198×	fn last_run(app: &Shared) -> Option<String> {
106	198×	Some(std::fs::read_to_string(last_run_path(app)).ok()?.trim().to_string())
107	198×	}
108
109	0×	fn record_run(app: &Shared, day: &str) {
110	0×	if let Err(e) = std::fs::write(last_run_path(app), day) {
111	0×	tracing::warn!("gc: recording the nightly run: {e}");
112	0×	}
113	0×	}
114
115		/// A day as the record keeps it: `2026-10-17`.
116	1×	fn day_text(day: time::Date) -> String {
117	1×	format!("{:04}-{:02}-{:02}", day.year(), u8::from(day.month()), day.day())
118	1×	}
119
120		/// Run [`gc_all`] once a day at `retention.gc_hour` UTC.
121	198×	pub async fn nightly(app: Shared) {
122	198×	let hour = app.config.retention.gc_hour;
123	198×	if hour >= 24 {
124	0×	tracing::info!("gc: the nightly run is off (retention.gc_hour = {hour})");
125	0×	return;
126	198×	}
127	198×	let mut last_day = last_run(&app);
128		loop {
129	198×	tokio::time::sleep(std::time::Duration::from_secs(60)).await;
130	0×	let now = time::OffsetDateTime::now_utc();
131	0×	if u32::from(now.hour()) != hour {
132	0×	continue;
133	0×	}
134	0×	let day = day_text(now.date());
135	0×	if last_day.as_deref() == Some(day.as_str()) {
136	0×	continue;
137	0×	}
138	0×	record_run(&app, &day);
139	0×	last_day = Some(day);
140	0×	match crate::db::sessions::sweep(&app.db).await {
141	0×	Ok(n) if n > 0 => tracing::info!("sessions: forgot {n} that had ended"),
142	0×	Ok(_) => {}
143	0×	Err(e) => tracing::warn!("sessions: sweep failed: {e}"),
144		}
145	0×	let done = gc_all(&app).await;
146	0×	tracing::info!("gc: nightly run over {} repositories, {} failed", done.len(), done.iter().filter(\|d\| d.failed).count());
147		}
148	0×	}
149
150		/// Each hour, archive the cards of columns that archive after some days
151		/// once they have been there longer (#293).
152	198×	pub async fn archiver(app: Shared) {
153		loop {
154	198×	match crate::db::projects::archive_due(&app.db, crate::db::now_ms()).await {
155	197×	Ok(n) if n > 0 => tracing::info!("projects: archived {n} card(s) their columns keep no longer"),
156	197×	Ok(_) => {}
157	0×	Err(e) => tracing::warn!("projects: archiving failed: {e}"),
158		}
159	197×	tokio::time::sleep(std::time::Duration::from_secs(3600)).await;
160		}
161		}
162
163		#[cfg(test)]
164		mod tests {
165		#[test]
166	1×	fn a_day_is_written_as_the_record_keeps_it() {
167	1×	let day = time::Date::from_calendar_date(2026, time::Month::October, 7).unwrap();
168	1×	assert_eq!(super::day_text(day), "2026-10-07");
169	1×	}
170		}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/hub/src/maintenance.rs 62.3%

Keyboard