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, 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 /// Number of days after the last promotion of beta.
54 /// Its value is 41 on the Tuesday where "Promote master to beta (T-2)" happens.
55 /// The Wednesday after this has value 0.
56 /// We track this value to prevent regressing tools in the last week of the 6-week cycle.
57 fn days_since_beta_promotion() -> u64 {
58 let since_epoch
= t
!(time
::SystemTime
::UNIX_EPOCH
.elapsed());
59 (since_epoch
.as_secs() / 86400 - 20) % 42
62 // These tools must test-pass on the beta/stable channels.
64 // On the nightly channel, their build step must be attempted, but they may not
65 // be able to build successfully.
66 static STABLE_TOOLS
: &[(&str, &str)] = &[
67 ("book", "src/doc/book"),
68 ("nomicon", "src/doc/nomicon"),
69 ("reference", "src/doc/reference"),
70 ("rust-by-example", "src/doc/rust-by-example"),
71 ("edition-guide", "src/doc/edition-guide"),
72 ("rls", "src/tools/rls"),
75 // These tools are permitted to not build on the beta/stable channels.
77 // We do require that we checked whether they build or not on the tools builder,
78 // though, as otherwise we will be unable to file an issue if they start
80 static NIGHTLY_TOOLS
: &[(&str, &str)] = &[
81 ("miri", "src/tools/miri"),
82 ("embedded-book", "src/doc/embedded-book"),
83 // ("rustc-dev-guide", "src/doc/rustc-dev-guide"),
86 fn print_error(tool
: &str, submodule
: &str) {
88 eprintln
!("We detected that this PR updated '{}', but its tests failed.", tool
);
90 eprintln
!("If you do intend to update '{}', please check the error messages above and", tool
);
91 eprintln
!("commit another update.");
93 eprintln
!("If you do NOT intend to update '{}', please ensure you did not accidentally", tool
);
94 eprintln
!("change the submodule at '{}'. You may ask your reviewer for the", submodule
);
95 eprintln
!("proper steps.");
96 std
::process
::exit(3);
99 fn check_changed_files(toolstates
: &HashMap
<Box
<str>, ToolState
>) {
101 let output
= std
::process
::Command
::new("git")
103 .arg("--name-status")
107 let output
= match output
{
110 eprintln
!("Failed to get changed files: {:?}", e
);
111 std
::process
::exit(1);
115 let output
= t
!(String
::from_utf8(output
.stdout
));
117 for (tool
, submodule
) in STABLE_TOOLS
.iter().chain(NIGHTLY_TOOLS
.iter()) {
118 let changed
= output
.lines().any(|l
| l
.starts_with('M'
) && l
.ends_with(submodule
));
119 eprintln
!("Verifying status of {}...", tool
);
124 eprintln
!("This PR updated '{}', verifying if status is 'test-pass'...", submodule
);
125 if toolstates
[*tool
] != ToolState
::TestPass
{
126 print_error(tool
, submodule
);
131 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
132 pub struct ToolStateCheck
;
134 impl Step
for ToolStateCheck
{
137 /// Checks tool state status.
139 /// This is intended to be used in the `checktools.sh` script. To use
140 /// this, set `save-toolstates` in `config.toml` so that tool status will
141 /// be saved to a JSON file. Then, run `x.py test --no-fail-fast` for all
142 /// of the tools to populate the JSON file. After that is done, this
143 /// command can be run to check for any status failures, and exits with an
144 /// error if there are any.
146 /// This also handles publishing the results to the `history` directory of
147 /// the toolstate repo <https://github.com/rust-lang-nursery/rust-toolstate>
148 /// if the env var `TOOLSTATE_PUBLISH` is set. Note that there is a
149 /// *separate* step of updating the `latest.json` file and creating GitHub
150 /// issues and comments in `src/ci/publish_toolstate.sh`, which is only
151 /// performed on master. (The shell/python code is intended to be migrated
152 /// here eventually.)
154 /// The rules for failure are:
155 /// * If the PR modifies a tool, the status must be test-pass.
156 /// NOTE: There is intent to change this, see
157 /// <https://github.com/rust-lang/rust/issues/65000>.
158 /// * All "stable" tools must be test-pass on the stable or beta branches.
159 /// * During beta promotion week, a PR is not allowed to "regress" a
160 /// stable tool. That is, the status is not allowed to get worse
161 /// (test-pass to test-fail or build-fail).
162 fn run(self, builder
: &Builder
<'_
>) {
163 if builder
.config
.dry_run
{
167 let days_since_beta_promotion
= days_since_beta_promotion();
168 let in_beta_week
= days_since_beta_promotion
>= BETA_WEEK_START
;
169 let is_nightly
= !(builder
.config
.channel
== "beta" || builder
.config
.channel
== "stable");
170 let toolstates
= builder
.toolstates();
172 let mut did_error
= false;
174 for (tool
, _
) in STABLE_TOOLS
.iter().chain(NIGHTLY_TOOLS
.iter()) {
175 if !toolstates
.contains_key(*tool
) {
177 eprintln
!("error: Tool `{}` was not recorded in tool state.", tool
);
182 std
::process
::exit(1);
185 check_changed_files(&toolstates
);
186 checkout_toolstate_repo();
187 let old_toolstate
= read_old_toolstate();
189 for (tool
, _
) in STABLE_TOOLS
.iter() {
190 let state
= toolstates
[*tool
];
192 if state
!= ToolState
::TestPass
{
195 eprintln
!("error: Tool `{}` should be test-pass but is {}", tool
, state
);
196 } else if in_beta_week
{
197 let old_state
= old_toolstate
199 .find(|ts
| ts
.tool
== *tool
)
200 .expect("latest.json missing tool")
202 if state
< old_state
{
205 "error: Tool `{}` has regressed from {} to {} during beta week.",
206 tool
, old_state
, state
209 // This warning only appears in the logs, which most
210 // people won't read. It's mostly here for testing and
213 "warning: Tool `{}` is not test-pass (is `{}`), \
214 this should be fixed before beta is branched.",
219 // `publish_toolstate.py` is responsible for updating
220 // `latest.json` and creating comments/issues warning people
221 // if there is a regression. That all happens in a separate CI
222 // job on the master branch once the PR has passed all tests
223 // on the `auto` branch.
228 std
::process
::exit(1);
231 if builder
.config
.channel
== "nightly" && env
::var_os("TOOLSTATE_PUBLISH").is_some() {
232 commit_toolstate_change(&toolstates
);
236 fn should_run(run
: ShouldRun
<'_
>) -> ShouldRun
<'_
> {
237 run
.alias("check-tools")
240 fn make_run(run
: RunConfig
<'_
>) {
241 run
.builder
.ensure(ToolStateCheck
);
246 fn toolstates(&self) -> HashMap
<Box
<str>, ToolState
> {
247 if let Some(ref path
) = self.config
.save_toolstates
{
248 if let Some(parent
) = path
.parent() {
249 // Ensure the parent directory always exists
250 t
!(std
::fs
::create_dir_all(parent
));
253 t
!(fs
::OpenOptions
::new().create(true).write(true).read(true).open(path
));
255 serde_json
::from_reader(&mut file
).unwrap_or_default()
261 /// Updates the actual toolstate of a tool.
263 /// The toolstates are saved to the file specified by the key
264 /// `rust.save-toolstates` in `config.toml`. If unspecified, nothing will be
265 /// done. The file is updated immediately after this function completes.
266 pub fn save_toolstate(&self, tool
: &str, state
: ToolState
) {
267 // If we're in a dry run setting we don't want to save toolstates as
268 // that means if we e.g. panic down the line it'll look like we tested
269 // everything (but we actually haven't).
270 if self.config
.dry_run
{
273 // Toolstate isn't tracked for clippy or rustfmt, but since most tools do, we avoid checking
274 // in all the places we could save toolstate and just do so here.
275 if tool
== "clippy-driver" || tool
== "rustfmt" {
278 if let Some(ref path
) = self.config
.save_toolstates
{
279 if let Some(parent
) = path
.parent() {
280 // Ensure the parent directory always exists
281 t
!(std
::fs
::create_dir_all(parent
));
284 t
!(fs
::OpenOptions
::new().create(true).read(true).write(true).open(path
));
286 let mut current_toolstates
: HashMap
<Box
<str>, ToolState
> =
287 serde_json
::from_reader(&mut file
).unwrap_or_default();
288 current_toolstates
.insert(tool
.into(), state
);
289 t
!(file
.seek(SeekFrom
::Start(0)));
291 t
!(serde_json
::to_writer(file
, ¤t_toolstates
));
296 fn toolstate_repo() -> String
{
297 env
::var("TOOLSTATE_REPO")
298 .unwrap_or_else(|_
| "https://github.com/rust-lang-nursery/rust-toolstate.git".to_string())
301 /// Directory where the toolstate repo is checked out.
302 const TOOLSTATE_DIR
: &str = "rust-toolstate";
304 /// Checks out the toolstate repo into `TOOLSTATE_DIR`.
305 fn checkout_toolstate_repo() {
306 if let Ok(token
) = env
::var("TOOLSTATE_REPO_ACCESS_TOKEN") {
307 prepare_toolstate_config(&token
);
309 if Path
::new(TOOLSTATE_DIR
).exists() {
310 eprintln
!("Cleaning old toolstate directory...");
311 t
!(fs
::remove_dir_all(TOOLSTATE_DIR
));
314 let status
= Command
::new("git")
317 .arg(toolstate_repo())
320 let success
= match status
{
321 Ok(s
) => s
.success(),
325 panic
!("git clone unsuccessful (status: {:?})", status
);
329 /// Sets up config and authentication for modifying the toolstate repo.
330 fn prepare_toolstate_config(token
: &str) {
331 fn git_config(key
: &str, value
: &str) {
332 let status
= Command
::new("git").arg("config").arg("--global").arg(key
).arg(value
).status();
333 let success
= match status
{
334 Ok(s
) => s
.success(),
338 panic
!("git config key={} value={} failed (status: {:?})", key
, value
, status
);
342 // If changing anything here, then please check that `src/ci/publish_toolstate.sh` is up to date
344 git_config("user.email", "7378925+rust-toolstate-update@users.noreply.github.com");
345 git_config("user.name", "Rust Toolstate Update");
346 git_config("credential.helper", "store");
348 let credential
= format
!("https://{}:x-oauth-basic@github.com\n", token
,);
349 let git_credential_path
= PathBuf
::from(t
!(env
::var("HOME"))).join(".git-credentials");
350 t
!(fs
::write(&git_credential_path
, credential
));
353 /// Reads the latest toolstate from the toolstate repo.
354 fn read_old_toolstate() -> Vec
<RepoState
> {
355 let latest_path
= Path
::new(TOOLSTATE_DIR
).join("_data").join("latest.json");
356 let old_toolstate
= t
!(fs
::read(latest_path
));
357 t
!(serde_json
::from_slice(&old_toolstate
))
360 /// This function `commit_toolstate_change` provides functionality for pushing a change
361 /// to the `rust-toolstate` repository.
363 /// The function relies on a GitHub bot user, which should have a Personal access
364 /// token defined in the environment variable $TOOLSTATE_REPO_ACCESS_TOKEN. If for
365 /// some reason you need to change the token, please update the Azure Pipelines
368 /// 1. Generate a new Personal access token:
370 /// * Login to the bot account, and go to Settings -> Developer settings ->
371 /// Personal access tokens
372 /// * Click "Generate new token"
373 /// * Enable the "public_repo" permission, then click "Generate token"
374 /// * Copy the generated token (should be a 40-digit hexadecimal number).
375 /// Save it somewhere secure, as the token would be gone once you leave
378 /// 2. Update the variable group in Azure Pipelines
380 /// * Ping a member of the infrastructure team to do this.
382 /// 4. Replace the email address below if the bot account identity is changed
384 /// * See <https://help.github.com/articles/about-commit-email-addresses/>
385 /// if a private email by GitHub is wanted.
386 fn commit_toolstate_change(current_toolstate
: &ToolstateData
) {
387 let message
= format
!("({} CI update)", OS
.expect("linux/windows only"));
388 let mut success
= false;
390 // Upload the test results (the new commit-to-toolstate mapping) to the toolstate repo.
391 // This does *not* change the "current toolstate"; that only happens post-landing
392 // via `src/ci/docker/publish_toolstate.sh`.
393 publish_test_results(¤t_toolstate
);
395 // `git commit` failing means nothing to commit.
396 let status
= t
!(Command
::new("git")
397 .current_dir(TOOLSTATE_DIR
)
403 if !status
.success() {
408 let status
= t
!(Command
::new("git")
409 .current_dir(TOOLSTATE_DIR
)
414 // If we successfully push, exit.
415 if status
.success() {
419 eprintln
!("Sleeping for 3 seconds before retrying push");
420 std
::thread
::sleep(std
::time
::Duration
::from_secs(3));
421 let status
= t
!(Command
::new("git")
422 .current_dir(TOOLSTATE_DIR
)
427 assert
!(status
.success());
428 let status
= t
!(Command
::new("git")
429 .current_dir(TOOLSTATE_DIR
)
432 .arg("origin/master")
434 assert
!(status
.success());
438 panic
!("Failed to update toolstate repository with new data");
442 /// Updates the "history" files with the latest results.
444 /// These results will later be promoted to `latest.json` by the
445 /// `publish_toolstate.py` script if the PR passes all tests and is merged to
447 fn publish_test_results(current_toolstate
: &ToolstateData
) {
448 let commit
= t
!(std
::process
::Command
::new("git").arg("rev-parse").arg("HEAD").output());
449 let commit
= t
!(String
::from_utf8(commit
.stdout
));
451 let toolstate_serialized
= t
!(serde_json
::to_string(¤t_toolstate
));
453 let history_path
= Path
::new(TOOLSTATE_DIR
)
455 .join(format
!("{}.tsv", OS
.expect("linux/windows only")));
456 let mut file
= t
!(fs
::read_to_string(&history_path
));
457 let end_of_first_line
= file
.find('
\n'
).unwrap();
458 file
.insert_str(end_of_first_line
, &format
!("\n{}\t{}", commit
.trim(), toolstate_serialized
));
459 t
!(fs
::write(&history_path
, file
));
462 #[derive(Debug, Deserialize)]
470 fn state(&self) -> ToolState
{
471 if cfg
!(target_os
= "linux") {
473 } else if cfg
!(windows
) {