1 use crate::builder::{Builder, RunConfig, ShouldRun, Step};
3 use serde::{Deserialize, Serialize};
4 use std::collections::HashMap;
8 use std::io::{Seek, SeekFrom};
9 use std::path::{Path, PathBuf};
10 use std::process::Command;
13 // Each cycle is 42 days long (6 weeks); the last week is 35..=42 then.
14 const BETA_WEEK_START: u64 = 35;
16 #[cfg(target_os = "linux")]
17 const OS: Option<&str> = Some("linux");
20 const OS: Option<&str> = Some("windows");
22 #[cfg(all(not(target_os = "linux"), not(windows)))]
23 const OS: Option<&str> = None;
25 type ToolstateData = HashMap<Box<str>, ToolState>;
27 #[derive(Copy, Clone, Debug, Deserialize, Serialize, PartialEq, Eq, PartialOrd)]
28 #[serde(rename_all = "kebab-case")]
29 /// Whether a tool can be compiled, tested or neither
31 /// The tool compiles successfully, but the test suite fails
33 /// The tool compiles successfully and its test suite passes
35 /// The tool can't even be compiled
39 impl fmt::Display for ToolState {
40 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
45 ToolState::TestFail => "test-fail",
46 ToolState::TestPass => "test-pass",
47 ToolState::BuildFail => "build-fail",
53 impl Default for ToolState {
54 fn default() -> Self {
55 // err on the safe side
60 /// Number of days after the last promotion of beta.
61 /// Its value is 41 on the Tuesday where "Promote master to beta (T-2)" happens.
62 /// The Wednesday after this has value 0.
63 /// We track this value to prevent regressing tools in the last week of the 6-week cycle.
64 fn days_since_beta_promotion() -> u64 {
65 let since_epoch = t!(time::SystemTime::UNIX_EPOCH.elapsed());
66 (since_epoch.as_secs() / 86400 - 20) % 42
69 // These tools must test-pass on the beta/stable channels.
71 // On the nightly channel, their build step must be attempted, but they may not
72 // be able to build successfully.
73 static STABLE_TOOLS: &[(&str, &str)] = &[
74 ("book", "src/doc/book"),
75 ("nomicon", "src/doc/nomicon"),
76 ("reference", "src/doc/reference"),
77 ("rust-by-example", "src/doc/rust-by-example"),
78 ("edition-guide", "src/doc/edition-guide"),
79 ("rls", "src/tools/rls"),
82 // These tools are permitted to not build on the beta/stable channels.
84 // We do require that we checked whether they build or not on the tools builder,
85 // though, as otherwise we will be unable to file an issue if they start
87 static NIGHTLY_TOOLS: &[(&str, &str)] = &[
88 ("miri", "src/tools/miri"),
89 ("embedded-book", "src/doc/embedded-book"),
90 // ("rustc-dev-guide", "src/doc/rustc-dev-guide"),
93 fn print_error(tool: &str, submodule: &str) {
95 eprintln!("We detected that this PR updated '{}', but its tests failed.", tool);
97 eprintln!("If you do intend to update '{}', please check the error messages above and", tool);
98 eprintln!("commit another update.");
100 eprintln!("If you do NOT intend to update '{}', please ensure you did not accidentally", tool);
101 eprintln!("change the submodule at '{}'. You may ask your reviewer for the", submodule);
102 eprintln!("proper steps.");
103 std::process::exit(3);
106 fn check_changed_files(toolstates: &HashMap<Box<str>, ToolState>) {
108 let output = std::process::Command::new("git")
110 .arg("--name-status")
114 let output = match output {
117 eprintln!("Failed to get changed files: {:?}", e);
118 std::process::exit(1);
122 let output = t!(String::from_utf8(output.stdout));
124 for (tool, submodule) in STABLE_TOOLS.iter().chain(NIGHTLY_TOOLS.iter()) {
125 let changed = output.lines().any(|l| l.starts_with('M') && l.ends_with(submodule));
126 eprintln!("Verifying status of {}...", tool);
131 eprintln!("This PR updated '{}', verifying if status is 'test-pass'...", submodule);
132 if toolstates[*tool] != ToolState::TestPass {
133 print_error(tool, submodule);
138 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
139 pub struct ToolStateCheck;
141 impl Step for ToolStateCheck {
144 /// Checks tool state status.
146 /// This is intended to be used in the `checktools.sh` script. To use
147 /// this, set `save-toolstates` in `config.toml` so that tool status will
148 /// be saved to a JSON file. Then, run `x.py test --no-fail-fast` for all
149 /// of the tools to populate the JSON file. After that is done, this
150 /// command can be run to check for any status failures, and exits with an
151 /// error if there are any.
153 /// This also handles publishing the results to the `history` directory of
154 /// the toolstate repo <https://github.com/rust-lang-nursery/rust-toolstate>
155 /// if the env var `TOOLSTATE_PUBLISH` is set. Note that there is a
156 /// *separate* step of updating the `latest.json` file and creating GitHub
157 /// issues and comments in `src/ci/publish_toolstate.sh`, which is only
158 /// performed on master. (The shell/python code is intended to be migrated
159 /// here eventually.)
161 /// The rules for failure are:
162 /// * If the PR modifies a tool, the status must be test-pass.
163 /// NOTE: There is intent to change this, see
164 /// <https://github.com/rust-lang/rust/issues/65000>.
165 /// * All "stable" tools must be test-pass on the stable or beta branches.
166 /// * During beta promotion week, a PR is not allowed to "regress" a
167 /// stable tool. That is, the status is not allowed to get worse
168 /// (test-pass to test-fail or build-fail).
169 fn run(self, builder: &Builder<'_>) {
170 if builder.config.dry_run {
174 let days_since_beta_promotion = days_since_beta_promotion();
175 let in_beta_week = days_since_beta_promotion >= BETA_WEEK_START;
176 let is_nightly = !(builder.config.channel == "beta" || builder.config.channel == "stable");
177 let toolstates = builder.toolstates();
179 let mut did_error = false;
181 for (tool, _) in STABLE_TOOLS.iter().chain(NIGHTLY_TOOLS.iter()) {
182 if !toolstates.contains_key(*tool) {
184 eprintln!("error: Tool `{}` was not recorded in tool state.", tool);
189 std::process::exit(1);
192 check_changed_files(&toolstates);
193 checkout_toolstate_repo();
194 let old_toolstate = read_old_toolstate();
196 for (tool, _) in STABLE_TOOLS.iter() {
197 let state = toolstates[*tool];
199 if state != ToolState::TestPass {
202 eprintln!("error: Tool `{}` should be test-pass but is {}", tool, state);
203 } else if in_beta_week {
204 let old_state = old_toolstate
206 .find(|ts| ts.tool == *tool)
207 .expect("latest.json missing tool")
209 if state < old_state {
212 "error: Tool `{}` has regressed from {} to {} during beta week.",
213 tool, old_state, state
216 // This warning only appears in the logs, which most
217 // people won't read. It's mostly here for testing and
220 "warning: Tool `{}` is not test-pass (is `{}`), \
221 this should be fixed before beta is branched.",
226 // `publish_toolstate.py` is responsible for updating
227 // `latest.json` and creating comments/issues warning people
228 // if there is a regression. That all happens in a separate CI
229 // job on the master branch once the PR has passed all tests
230 // on the `auto` branch.
235 std::process::exit(1);
238 if builder.config.channel == "nightly" && env::var_os("TOOLSTATE_PUBLISH").is_some() {
239 commit_toolstate_change(&toolstates);
243 fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
244 run.path("check-tools")
247 fn make_run(run: RunConfig<'_>) {
248 run.builder.ensure(ToolStateCheck);
253 fn toolstates(&self) -> HashMap<Box<str>, ToolState> {
254 if let Some(ref path) = self.config.save_toolstates {
255 if let Some(parent) = path.parent() {
256 // Ensure the parent directory always exists
257 t!(std::fs::create_dir_all(parent));
260 t!(fs::OpenOptions::new().create(true).write(true).read(true).open(path));
262 serde_json::from_reader(&mut file).unwrap_or_default()
268 /// Updates the actual toolstate of a tool.
270 /// The toolstates are saved to the file specified by the key
271 /// `rust.save-toolstates` in `config.toml`. If unspecified, nothing will be
272 /// done. The file is updated immediately after this function completes.
273 pub fn save_toolstate(&self, tool: &str, state: ToolState) {
274 // If we're in a dry run setting we don't want to save toolstates as
275 // that means if we e.g. panic down the line it'll look like we tested
276 // everything (but we actually haven't).
277 if self.config.dry_run {
280 // Toolstate isn't tracked for clippy or rustfmt, but since most tools do, we avoid checking
281 // in all the places we could save toolstate and just do so here.
282 if tool == "clippy-driver" || tool == "rustfmt" {
285 if let Some(ref path) = self.config.save_toolstates {
286 if let Some(parent) = path.parent() {
287 // Ensure the parent directory always exists
288 t!(std::fs::create_dir_all(parent));
291 t!(fs::OpenOptions::new().create(true).read(true).write(true).open(path));
293 let mut current_toolstates: HashMap<Box<str>, ToolState> =
294 serde_json::from_reader(&mut file).unwrap_or_default();
295 current_toolstates.insert(tool.into(), state);
296 t!(file.seek(SeekFrom::Start(0)));
298 t!(serde_json::to_writer(file, ¤t_toolstates));
303 fn toolstate_repo() -> String {
304 env::var("TOOLSTATE_REPO")
305 .unwrap_or_else(|_| "https://github.com/rust-lang-nursery/rust-toolstate.git".to_string())
308 /// Directory where the toolstate repo is checked out.
309 const TOOLSTATE_DIR: &str = "rust-toolstate";
311 /// Checks out the toolstate repo into `TOOLSTATE_DIR`.
312 fn checkout_toolstate_repo() {
313 if let Ok(token) = env::var("TOOLSTATE_REPO_ACCESS_TOKEN") {
314 prepare_toolstate_config(&token);
316 if Path::new(TOOLSTATE_DIR).exists() {
317 eprintln!("Cleaning old toolstate directory...");
318 t!(fs::remove_dir_all(TOOLSTATE_DIR));
321 let status = Command::new("git")
324 .arg(toolstate_repo())
327 let success = match status {
328 Ok(s) => s.success(),
332 panic!("git clone unsuccessful (status: {:?})", status);
336 /// Sets up config and authentication for modifying the toolstate repo.
337 fn prepare_toolstate_config(token: &str) {
338 fn git_config(key: &str, value: &str) {
339 let status = Command::new("git").arg("config").arg("--global").arg(key).arg(value).status();
340 let success = match status {
341 Ok(s) => s.success(),
345 panic!("git config key={} value={} failed (status: {:?})", key, value, status);
349 // If changing anything here, then please check that `src/ci/publish_toolstate.sh` is up to date
351 git_config("user.email", "7378925+rust-toolstate-update@users.noreply.github.com");
352 git_config("user.name", "Rust Toolstate Update");
353 git_config("credential.helper", "store");
355 let credential = format!("https://{}:x-oauth-basic@github.com\n", token,);
356 let git_credential_path = PathBuf::from(t!(env::var("HOME"))).join(".git-credentials");
357 t!(fs::write(&git_credential_path, credential));
360 /// Reads the latest toolstate from the toolstate repo.
361 fn read_old_toolstate() -> Vec<RepoState> {
362 let latest_path = Path::new(TOOLSTATE_DIR).join("_data").join("latest.json");
363 let old_toolstate = t!(fs::read(latest_path));
364 t!(serde_json::from_slice(&old_toolstate))
367 /// This function `commit_toolstate_change` provides functionality for pushing a change
368 /// to the `rust-toolstate` repository.
370 /// The function relies on a GitHub bot user, which should have a Personal access
371 /// token defined in the environment variable $TOOLSTATE_REPO_ACCESS_TOKEN. If for
372 /// some reason you need to change the token, please update the Azure Pipelines
375 /// 1. Generate a new Personal access token:
377 /// * Login to the bot account, and go to Settings -> Developer settings ->
378 /// Personal access tokens
379 /// * Click "Generate new token"
380 /// * Enable the "public_repo" permission, then click "Generate token"
381 /// * Copy the generated token (should be a 40-digit hexadecimal number).
382 /// Save it somewhere secure, as the token would be gone once you leave
385 /// 2. Update the variable group in Azure Pipelines
387 /// * Ping a member of the infrastructure team to do this.
389 /// 4. Replace the email address below if the bot account identity is changed
391 /// * See <https://help.github.com/articles/about-commit-email-addresses/>
392 /// if a private email by GitHub is wanted.
393 fn commit_toolstate_change(current_toolstate: &ToolstateData) {
394 let message = format!("({} CI update)", OS.expect("linux/windows only"));
395 let mut success = false;
397 // Upload the test results (the new commit-to-toolstate mapping) to the toolstate repo.
398 // This does *not* change the "current toolstate"; that only happens post-landing
399 // via `src/ci/docker/publish_toolstate.sh`.
400 publish_test_results(¤t_toolstate);
402 // `git commit` failing means nothing to commit.
403 let status = t!(Command::new("git")
404 .current_dir(TOOLSTATE_DIR)
410 if !status.success() {
415 let status = t!(Command::new("git")
416 .current_dir(TOOLSTATE_DIR)
421 // If we successfully push, exit.
422 if status.success() {
426 eprintln!("Sleeping for 3 seconds before retrying push");
427 std::thread::sleep(std::time::Duration::from_secs(3));
428 let status = t!(Command::new("git")
429 .current_dir(TOOLSTATE_DIR)
434 assert!(status.success());
435 let status = t!(Command::new("git")
436 .current_dir(TOOLSTATE_DIR)
439 .arg("origin/master")
441 assert!(status.success());
445 panic!("Failed to update toolstate repository with new data");
449 /// Updates the "history" files with the latest results.
451 /// These results will later be promoted to `latest.json` by the
452 /// `publish_toolstate.py` script if the PR passes all tests and is merged to
454 fn publish_test_results(current_toolstate: &ToolstateData) {
455 let commit = t!(std::process::Command::new("git").arg("rev-parse").arg("HEAD").output());
456 let commit = t!(String::from_utf8(commit.stdout));
458 let toolstate_serialized = t!(serde_json::to_string(¤t_toolstate));
460 let history_path = Path::new(TOOLSTATE_DIR)
462 .join(format!("{}.tsv", OS.expect("linux/windows only")));
463 let mut file = t!(fs::read_to_string(&history_path));
464 let end_of_first_line = file.find('\n').unwrap();
465 file.insert_str(end_of_first_line, &format!("\n{}\t{}", commit.trim(), toolstate_serialized));
466 t!(fs::write(&history_path, file));
469 #[derive(Debug, Serialize, Deserialize)]
479 fn state(&self) -> ToolState {
480 if cfg!(target_os = "linux") {
482 } else if cfg!(windows) {