Noratrieb/cargo-bisect-rustc-service
1
0
Fork 0
mirror of https://github.com/Noratrieb/cargo-bisect-rustc-service.git synced 2026-01-15 16:45:02 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Compare commits

base: Noratrieb:v0.1-alpha.1
Branches Tags
Noratrieb:main
Noratrieb:v0.2
Noratrieb:v0.1
Noratrieb:v0.1-alpha.1
Noratrieb:v0.1-alpha.0
...
compare: Noratrieb:main
Branches Tags
Noratrieb:main
Noratrieb:v0.2
Noratrieb:v0.1
Noratrieb:v0.1-alpha.1
Noratrieb:v0.1-alpha.0

14 commits
v0.1-alpha ... main

Author SHA1 Message Date
nora
95480163c9
Update README.md 2025-08-03 17:27:10 +02:00
nora
557edb1abd
Update README.md 2025-08-03 16:44:28 +02:00
Nilstrieb
316a40442e Add metrics endpoint 2024-03-31 15:44:39 +02:00
Nilstrieb
13f89b68ef
Update Dockerfile 2023-08-27 14:24:07 +02:00
Nilstrieb
8bd8676314 update 2023-08-27 13:54:40 +02:00
Nilstrieb
89f533e357
Update Dockerfile 2023-08-27 13:49:41 +02:00
nils
e4d1c77422
Merge pull request #2 from danielhenrymantilla/patch-1 
Try <!-- [skip ci] --> it
 2023-01-17 17:47:20 +01:00
Daniel Henry-Mantilla
ae0ea732e9
Try <!-- [skip ci] --> it 2023-01-17 17:46:10 +01:00
Nilstrieb
9a2f8ecdbc add github link 2022-11-26 12:17:37 +01:00
Nilstrieb
4bb561df9b remove toolchains sometimes 2022-11-26 12:09:45 +01:00
Nilstrieb
43e63d28d2
use the query parameter to store the bisection id to allow refreshes 2022-11-25 22:54:09 +01:00
Nilstrieb
edcda4d5b5
tracing 2022-11-08 20:36:15 +01:00
Nilstrieb
5d3b9c99d0
Fix stupid url path thing 
@danielhenrymantilla for you
 2022-11-08 19:47:18 +01:00
Nilstrieb
80c6b2a8a2
make into form 2022-09-29 22:12:09 +02:00
11 changed files with 974 additions and 347 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.envrc Normal file
View file

@ -0,0 +1 @@
use nix

965
Cargo.lock generated
View file

File diff suppressed because it is too large Load diff

4
Cargo.toml
View file

@ -9,10 +9,14 @@ edition = "2021"
axum = "0.5.16" axum = "0.5.16"
chrono = { version = "0.4.22", features = ["serde", "clock"] } chrono = { version = "0.4.22", features = ["serde", "clock"] }
color-eyre = "0.6.2" color-eyre = "0.6.2"
metrics = "0.22.3"
metrics-exporter-prometheus = { version = "0.14.0", default-features = false, features = ["http-listener"] }
once_cell = "1.19.0"
rusqlite = { version = "0.28.0", features = ["bundled", "uuid", "chrono"] } rusqlite = { version = "0.28.0", features = ["bundled", "uuid", "chrono"] }
serde = { version = "1.0.145", features = ["derive"] } serde = { version = "1.0.145", features = ["derive"] }
tempdir = "0.3.7" tempdir = "0.3.7"
tokio = { version = "1.21.2", features = ["full"] } tokio = { version = "1.21.2", features = ["full"] }
tower-http = { version = "0.3.4", features = ["trace"] }
tracing = "0.1.36" tracing = "0.1.36"
tracing-subscriber = { version = "0.3.15", features = ["env-filter"] } tracing-subscriber = { version = "0.3.15", features = ["env-filter"] }
uuid = { version = "1.1.2", features = ["serde", "v4"] } uuid = { version = "1.1.2", features = ["serde", "v4"] }

16
Dockerfile
View file

@ -1,4 +1,4 @@
FROM rust as build FROM rust:1.77 as build
RUN rustup toolchain install nightly RUN rustup toolchain install nightly
RUN rustup default nightly RUN rustup default nightly
@ -12,22 +12,30 @@ COPY Cargo.toml Cargo.lock ./
RUN mkdir src RUN mkdir src
RUN echo "fn main() {}" > src/main.rs RUN echo "fn main() {}" > src/main.rs
RUN cargo build --release -Zsparse-registry RUN cargo build --release
COPY src ./src COPY src ./src
COPY index.html index.html COPY index.html index.html
# now rebuild with the proper main # now rebuild with the proper main
RUN touch src/main.rs RUN touch src/main.rs
RUN cargo build --release -Zsparse-registry RUN cargo build --release
### RUN ### RUN
FROM rust FROM rust:1.77
RUN cargo install cargo-bisect-rustc RUN cargo install cargo-bisect-rustc
WORKDIR /app WORKDIR /app
# random user
RUN useradd --create-home bisector
USER bisector
# this server listens on port 4000 and 4001 (metrics)
EXPOSE 4000
EXPOSE 4001
COPY --from=build /app/target/release/cargo-bisect-rustc-service cargo-bisect-rustc-service COPY --from=build /app/target/release/cargo-bisect-rustc-service cargo-bisect-rustc-service
CMD ["/app/cargo-bisect-rustc-service"] CMD ["/app/cargo-bisect-rustc-service"]

7
README.md
View file

@ -1,4 +1,9 @@
# cargo-bisect-rustc-service # cargo-bisect-rustc-service
**⚠️ this service has been turned off due to lack of usage ⚠️**
if you think it's useful you should tell me so i can turn it on again
a small web service that bisects rustc for you a small web service that bisects rustc for you
https://nilstrieb.dev/bisect-rustc https://bisect-rustc.noratrieb.dev

207
index.html
View file

@ -32,12 +32,16 @@
<body> <body>
<h1>Bisect rustc</h1> <h1>Bisect rustc</h1>
<textarea <form name="bisect" id="bisect-form">
id="code" <label for="code">Code</label>
rows="30" <br />
cols="80" <textarea
placeholder="// Rust code goes here..." id="code"
> rows="30"
cols="80"
placeholder="// Rust code goes here..."
name="code"
>
struct Struct&lt;T&gt;(T); struct Struct&lt;T&gt;(T);
impl&lt;T&gt; Struct&lt;T&gt; { impl&lt;T&gt; Struct&lt;T&gt; {
@ -46,25 +50,27 @@ impl&lt;T&gt; Struct&lt;T&gt; {
}; };
} }
</textarea </textarea
> >
<br /> <br />
<label for="start">Start</label> <label for="start">Start</label>
<input id="start" value="2022-01-01" /> <input id="start" value="2022-01-01" name="start" />
<label for="end">End (optional)</label>
<input id="end" value="2022-06-01" />
<label for="kind">Regression Kind</label>
<select id="kind">
<option>error</option>
<option>success</option>
<option selected="selected">ice</option>
<option>non-ice</option>
<option>non-error</option>
</select>
<br /> <label for="end">End (optional)</label>
<br /> <input id="end" value="2022-06-01" name="end" />
<button class="bisect-btn" onclick="bisect()">Bisect!</button> <label for="kind">Regression Kind</label>
<select id="kind" name="select">
<option>error</option>
<option>success</option>
<option selected="selected">ice</option>
<option>non-ice</option>
<option>non-error</option>
</select>
<br />
<br />
<input type="submit" class="bisect-btn" value="Bisect!" />
</form>
<br /> <br />
<br /> <br />
@ -78,17 +84,53 @@ impl&lt;T&gt; Struct&lt;T&gt; {
readonly readonly
></textarea> ></textarea>
<div>
Made by Nilstrieb
<a href="https://github.com/Nilstrieb/cargo-bisect-rustc-service"
>Github</a
>
</div>
<script> <script>
const BASE_URL = `${document.location}`; let BASE_URL = `${document.location}`.split("?")[0];
const htmlCode = document.getElementById("code"); if (!BASE_URL.endsWith("/")) {
// ugh, i hate url paths and their subtle interactions with things
BASE_URL = `${BASE_URL}/`;
}
// The important HTML elements.
const htmlStatus = document.getElementById("status"); const htmlStatus = document.getElementById("status");
const htmlResult = document.getElementById("result"); const htmlResult = document.getElementById("result");
const htmlStart = document.getElementById("start"); const htmlCode = document.getElementById("code");
const htmlEnd = document.getElementById("end");
const htmlKind = document.getElementById("kind"); // A list of all ongoing fetches in fetchAndUpdate.
const fetches = [];
let bisecting = false; let bisecting = false;
initialLoad();
document.getElementById("bisect-form").addEventListener("submit", (e) => {
e.preventDefault();
submitForm();
});
async function initialLoad() {
const params = document.location.search;
const urlParams = new URLSearchParams(params);
const bisection = urlParams.get("bisection");
if (bisection) {
const response = await fetchAndUpdate(bisection);
if (!response) {
fatal(`Bisection with ID \`${bisection}\` not found.`);
return;
}
code.value = response.code;
}
}
// Report a fatal error to the console and screen.
function fatal(err, ...extra) { function fatal(err, ...extra) {
console.error(err, ...(extra || [])); console.error(err, ...(extra || []));
htmlStatus.innerHTML = `ERROR: ${err}`; htmlStatus.innerHTML = `ERROR: ${err}`;
@ -97,15 +139,30 @@ impl&lt;T&gt; Struct&lt;T&gt; {
bisecting = false; bisecting = false;
} }
async function bisect() { function submitForm() {
const form = document.forms.bisect;
const options = {
code: form.code.value,
start: form.start.value?.trim(),
end: form.end.value?.trim(),
kind: form.kind.value,
};
console.log("Options", options);
if (!options.start) {
fatal("Must provide a start");
return;
}
bisect(options);
}
async function bisect(options) {
if (bisecting) { if (bisecting) {
return; return;
} }
if (!htmlStart.value.trim()) { fetches.forEach((fetchId) => clearTimeout(fetchId));
fatal("Must provide a start");
return;
}
bisecting = true; bisecting = true;
@ -116,16 +173,14 @@ impl&lt;T&gt; Struct&lt;T&gt; {
const params = new URLSearchParams(); const params = new URLSearchParams();
params.append("start", htmlStart.value.trim()); params.append("start", options.start);
params.append("kind", htmlKind.value); params.append("kind", options.kind);
if (htmlEnd.value.trim()) { if (options.end) {
params.append("end", htmlEnd.value.trim()); params.append("end", options.end);
} }
const body = htmlCode.value; const body = options.code;
console.log("Bisecting", body);
let jobId; let jobId;
try { try {
@ -143,6 +198,11 @@ impl&lt;T&gt; Struct&lt;T&gt; {
} }
const data = await fetched.json(); const data = await fetched.json();
jobId = data?.job_id; jobId = data?.job_id;
const urlParams = new URLSearchParams(window.location.search);
urlParams.set("bisection", jobId);
window.location.search = urlParams;
if (!jobId) { if (!jobId) {
fatal("Received invalid response", data); fatal("Received invalid response", data);
return; return;
@ -152,38 +212,51 @@ impl&lt;T&gt; Struct&lt;T&gt; {
return; return;
} }
async function tryFetch() { fetchAndUpdate(jobId);
let response; }
try {
const fetched = await fetch(`${BASE_URL}bisect/${jobId}`); async function fetchAndUpdate(jobId) {
if (!fetched.ok) { htmlStatus.innerHTML = `Waiting for result, job id=${jobId}`;
fatal("Failed to fetch", fetched); htmlStatus.classList.remove("hidden");
return;
} let response;
response = await fetched.json(); try {
} catch (e) { const fetched = await fetch(`${BASE_URL}bisect/${jobId}`);
fatal(e); if (!fetched.ok) {
fatal("Failed to fetch bisection.", fetched);
return; return;
} }
response = await fetched.json();
if (response.status.status !== "InProgress") { } catch (e) {
bisecting = false; fatal(e);
console.log(response.status.output); return;
htmlStatus.classList.add("hidden");
htmlResult.classList.remove("hidden");
htmlResult.value = response.status.output;
htmlStatus.innerHTML = `Bisected job ${jobId}`;
} else {
console.log("Waiting for bisection", response.status.status);
setTimeout(tryFetch, 3000);
}
} }
tryFetch(); if (!response) {
console.log("Waiting for bisection", response.status.status);
const timeout = setTimeout(() => fetchAndUpdate(jobId), 3000);
fetches.push(timeout);
return response;
}
htmlStatus.innerHTML = `Waiting for result, job id=${jobId}`; const status = response.status;
if (response.status.status !== "InProgress") {
bisecting = false;
console.log(response.status.output);
htmlStatus.classList.add("hidden");
htmlResult.classList.remove("hidden");
htmlResult.value = response.status.output;
htmlStatus.innerHTML = `Bisected job ${jobId}`;
} else {
console.log("Waiting for bisection", response.status.status);
const timeout = setTimeout(() => fetchAndUpdate(jobId), 3000);
fetches.push(timeout);
}
return response;
} }
</script> </script>
</body> </body>

3
shell.nix Normal file
View file

@ -0,0 +1,3 @@
{ pkgs ? import <nixpkgs> { } }: pkgs.mkShell {
packages = with pkgs; [ rustup ];
}

2
src/bisect.rs
View file

@ -107,6 +107,8 @@ pub fn process_job(job: Job, conn: &Connection) -> Result<()> {
trace!(?bisect, "Finished bisection job"); trace!(?bisect, "Finished bisection job");
crate::toolchain::clean_toolchains()?;
Ok(()) Ok(())
} }

41
src/main.rs
View file

@ -2,9 +2,14 @@
mod bisect; mod bisect;
mod db; mod db;
mod toolchain;
use std::sync::{mpsc, Arc, Mutex}; use std::{
future,
sync::{mpsc, Arc, Mutex},
};
use crate::bisect::Job;
use axum::{ use axum::{
extract::{Path, Query}, extract::{Path, Query},
http::StatusCode, http::StatusCode,
@ -12,16 +17,17 @@ use axum::{
routing::{get, post, Router}, routing::{get, post, Router},
Extension, Json, Extension, Json,
}; };
use bisect::Job;
use color_eyre::eyre::Context; use color_eyre::eyre::Context;
use metrics_exporter_prometheus::{PrometheusBuilder, PrometheusHandle};
use rusqlite::Connection; use rusqlite::Connection;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use std::env; use std::env;
use tower_http::trace::TraceLayer;
use tracing::{error, info, metadata::LevelFilter}; use tracing::{error, info, metadata::LevelFilter};
use tracing_subscriber::EnvFilter; use tracing_subscriber::EnvFilter;
use uuid::Uuid; use uuid::Uuid;
type SendChannel = Arc<Mutex<mpsc::Sender<Job>>>; type SendChannel = Arc<Mutex<mpsc::SyncSender<Job>>>;
type Conn = Arc<Mutex<Connection>>; type Conn = Arc<Mutex<Connection>>;
#[tokio::main] #[tokio::main]
@ -36,7 +42,23 @@ async fn main() -> color_eyre::Result<()> {
) )
.init(); .init();
let (job_queue_send, job_queue_recv) = mpsc::channel(); // FIXME: make this a sync_channel because bounds are cool let metrics_app = async {
let prom_handle = setup_metrics();
let router: Router =
Router::new().route("/metrics", get(move || future::ready(prom_handle.render())));
info!("Starting up metrics server on port 4001");
axum::Server::bind(&"0.0.0.0:4001".parse().unwrap())
.serve(router.into_make_service())
.await
.wrap_err("failed to start server")
};
tokio::try_join!(metrics_app, main_server())?;
Ok(())
}
async fn main_server() -> color_eyre::Result<()> {
let (job_queue_send, job_queue_recv) = mpsc::sync_channel(10);
let sqlite_db = env::var("SQLITE_DB").unwrap_or_else(|_| "bisect.sqlite".to_string()); let sqlite_db = env::var("SQLITE_DB").unwrap_or_else(|_| "bisect.sqlite".to_string());
@ -49,6 +71,8 @@ async fn main() -> color_eyre::Result<()> {
db::setup(&worker_conn).wrap_err("db setup")?; db::setup(&worker_conn).wrap_err("db setup")?;
toolchain::clean_toolchains()?;
let app = Router::new() let app = Router::new()
.route("/", get(|| async { index_html() })) .route("/", get(|| async { index_html() }))
.route("/bisect/:id", get(get_bisection)) .route("/bisect/:id", get(get_bisection))
@ -56,11 +80,12 @@ async fn main() -> color_eyre::Result<()> {
.route("/bisect", post(do_bisection)) .route("/bisect", post(do_bisection))
// this is really stupid and hacky // this is really stupid and hacky
.layer(Extension(Arc::new(Mutex::new(job_queue_send)))) .layer(Extension(Arc::new(Mutex::new(job_queue_send))))
.layer(Extension(main_conn)); .layer(Extension(main_conn))
.layer(TraceLayer::new_for_http());
std::thread::spawn(|| bisect::bisect_worker(job_queue_recv, worker_conn)); std::thread::spawn(|| bisect::bisect_worker(job_queue_recv, worker_conn));
info!("Starting up server"); info!("Starting up server on port 4000");
axum::Server::bind(&"0.0.0.0:4000".parse().unwrap()) axum::Server::bind(&"0.0.0.0:4000".parse().unwrap())
.serve(app.into_make_service()) .serve(app.into_make_service())
@ -110,6 +135,7 @@ async fn do_bisection(
body: String, body: String,
send_channel: Extension<SendChannel>, send_channel: Extension<SendChannel>,
) -> impl IntoResponse { ) -> impl IntoResponse {
metrics::counter!("bisections").increment(1);
let job_id = Uuid::new_v4(); let job_id = Uuid::new_v4();
let job = Job::new(job_id, body, options.0); let job = Job::new(job_id, body, options.0);
@ -125,3 +151,6 @@ async fn do_bisection(
)), )),
} }
} }
pub fn setup_metrics() -> PrometheusHandle {
PrometheusBuilder::new().install_recorder().unwrap()
}

73
src/toolchain.rs Normal file
View file

@ -0,0 +1,73 @@
use std::process::Command;
use color_eyre::{
eyre::{eyre, Context},
Result,
};
use tracing::debug;
const MAX_BISECTOR_TOOLCHAINS: usize = 15;
#[tracing::instrument]
pub fn clean_toolchains() -> Result<()> {
let toolchains = get_toolchains()?;
let for_removal = filter_toolchain_for_removal(toolchains);
if !for_removal.is_empty() {
remove_toolchains(&for_removal)?;
}
Ok(())
}
fn filter_toolchain_for_removal(mut toolchains: Vec<String>) -> Vec<String> {
toolchains.retain(|toolchain| toolchain.starts_with("bisector-"));
let amount = toolchains.len();
if amount <= MAX_BISECTOR_TOOLCHAINS {
debug!(%amount, "No toolchains removed");
return Vec::new();
}
let to_remove = amount - MAX_BISECTOR_TOOLCHAINS;
toolchains.into_iter().take(to_remove).collect()
}
fn get_toolchains() -> Result<Vec<String>> {
let mut command = Command::new("rustup");
command.args(["toolchain", "list"]);
let output = command
.output()
.wrap_err("running `rustup toolchain list`")?;
if output.status.success() {
let stdout =
String::from_utf8(output.stdout).wrap_err("rustup returned non-utf-8 bytes")?;
let toolchains = stdout.lines().map(ToOwned::to_owned).collect();
Ok(toolchains)
} else {
let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
Err(eyre!("`rustup toolchain list` failed").wrap_err(stderr))
}
}
fn remove_toolchains(toolchains: &[String]) -> Result<()> {
debug!(?toolchains, "Removing toolchains");
let mut command = Command::new("rustup");
command.args(["toolchain", "remove"]);
command.args(toolchains);
let output = command
.output()
.wrap_err("running `rustup toolchain remove`")?;
if output.status.success() {
return Ok(());
}
let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
Err(eyre!("`rustup toolchain remove` failed").wrap_err(stderr))
}