Skip to content

Commit 303cafb

Browse files
Mark-SimulacrumMark-Simulacrum
committed
Fix/further refactor task execution
1 parent 5ec60fe commit 303cafb

File tree

2 files changed

+91
-76
lines changed

2 files changed

+91
-76
lines changed

‎src/runner/tasks.rs

Lines changed: 1 addition & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,6 @@ impl<'ctx, DB: WriteResults + 'ctx> TaskCtx<'ctx, DB> {
4848

4949
pub(super) enum TaskStep {
5050
Prepare,
51-
Skip { tc: Toolchain },
5251
BuildAndTest { tc: Toolchain, quiet: bool },
5352
BuildOnly { tc: Toolchain, quiet: bool },
5453
CheckOnly { tc: Toolchain, quiet: bool },
@@ -61,7 +60,6 @@ impl fmt::Debug for TaskStep {
6160
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6261
let (name, quiet, tc) = match *self {
6362
TaskStep::Prepare => ("prepare", false, None),
64-
TaskStep::Skip { ref tc } => ("skip", false, Some(tc)),
6563
TaskStep::BuildAndTest { ref tc, quiet } => ("build and test", quiet, Some(tc)),
6664
TaskStep::BuildOnly { ref tc, quiet } => ("build", quiet, Some(tc)),
6765
TaskStep::CheckOnly { ref tc, quiet } => ("check", quiet, Some(tc)),
@@ -103,8 +101,7 @@ impl Task {
103101
) -> Fallible<()> {
104102
match self.step {
105103
TaskStep::Prepare => {}
106-
TaskStep::Skip { ref tc }
107-
| TaskStep::BuildAndTest { ref tc, .. }
104+
TaskStep::BuildAndTest { ref tc, .. }
108105
| TaskStep::BuildOnly { ref tc, .. }
109106
| TaskStep::CheckOnly { ref tc, .. }
110107
| TaskStep::Clippy { ref tc, .. }
@@ -223,16 +220,6 @@ impl Task {
223220
})?;
224221
return Ok(());
225222
}
226-
TaskStep::Skip { ref tc } => {
227-
// If a skipped crate is somehow sent to the agent (for example, when a crate was
228-
// added to the experiment and *then* blacklisted) report the crate as skipped
229-
// instead of silently ignoring it.
230-
db.record_result(ex, tc, &self.krate, logs, EncodingType::Plain, || {
231-
warn!("crate skipped");
232-
Ok(TestResult::Skipped)
233-
})?;
234-
return Ok(());
235-
}
236223
};
237224

238225
let ctx = TaskCtx::new(build_dir, config, db, ex, toolchain, &self.krate, quiet);

‎src/runner/worker.rs

Lines changed: 90 additions & 62 deletions
Original file line numberDiff line numberDiff line change
@@ -92,8 +92,7 @@ impl<'a, DB: WriteResults + Sync> Worker<'a, DB> {
9292
if res.is_err() && self.ex.toolchains.len() == 2 {
9393
let toolchain = match &task.step {
9494
TaskStep::Prepare => None,
95-
TaskStep::Skip { tc }
96-
| TaskStep::BuildAndTest { tc, .. }
95+
TaskStep::BuildAndTest { tc, .. }
9796
| TaskStep::BuildOnly { tc, .. }
9897
| TaskStep::CheckOnly { tc, .. }
9998
| TaskStep::Clippy { tc, .. }
@@ -148,73 +147,102 @@ impl<'a, DB: WriteResults + Sync> Worker<'a, DB> {
148147

149148
info!("{} processing crate {}", self.name, krate);
150149

151-
let mut did_prepare = false;
152-
for tc in &self.ex.toolchains {
153-
let mut tasks = Vec::new();
150+
if !self.ex.ignore_blacklist && self.config.should_skip(&krate) {
151+
for tc in &self.ex.toolchains {
152+
// If a skipped crate is somehow sent to the agent (for example, when a crate was
153+
// added to the experiment and *then* blacklisted) report the crate as skipped
154+
// instead of silently ignoring it.
155+
if let Err(e) = self.db.record_result(
156+
self.ex,
157+
tc,
158+
&krate,
159+
&LogStorage::from(self.config),
160+
crate::results::EncodingType::Plain,
161+
|| {
162+
warn!("crate skipped");
163+
Ok(TestResult::Skipped)
164+
},
165+
) {
166+
crate::utils::report_failure(&e);
167+
}
168+
}
169+
continue;
170+
}
154171

155-
if !self.ex.ignore_blacklist && self.config.should_skip(&krate) {
156-
tasks.push(Task {
157-
krate: krate.clone(),
158-
step: TaskStep::Skip { tc: tc.clone() },
159-
});
160-
} else {
161-
if !did_prepare {
162-
did_prepare = true;
163-
tasks.push(Task {
164-
krate: krate.clone(),
165-
step: TaskStep::Prepare,
166-
});
172+
let logs = LogStorage::from(self.config);
173+
let prepare_task = Task {
174+
krate: krate.clone(),
175+
step: TaskStep::Prepare,
176+
};
177+
if let Err((err, test_result)) = &self.run_task(&prepare_task, &logs) {
178+
if let Err(e) =
179+
prepare_task.mark_as_failed(self.ex, self.db, err, test_result, &logs)
180+
{
181+
crate::utils::report_failure(&e);
182+
}
183+
for tc in &self.ex.toolchains {
184+
if let Err(e) = self.db.record_result(
185+
self.ex,
186+
tc,
187+
&krate,
188+
&LogStorage::from(self.config),
189+
crate::results::EncodingType::Plain,
190+
|| {
191+
error!("this task or one of its parent failed!");
192+
utils::report_failure(err);
193+
Ok(test_result.clone())
194+
},
195+
) {
196+
crate::utils::report_failure(&e);
167197
}
168-
let quiet = self.config.is_quiet(&krate);
169-
tasks.push(Task {
170-
krate: krate.clone(),
171-
step: match self.ex.mode {
172-
Mode::BuildOnly => TaskStep::BuildOnly {
198+
}
199+
continue;
200+
}
201+
202+
for tc in &self.ex.toolchains {
203+
let quiet = self.config.is_quiet(&krate);
204+
let task = Task {
205+
krate: krate.clone(),
206+
step: match self.ex.mode {
207+
Mode::BuildOnly => TaskStep::BuildOnly {
208+
tc: tc.clone(),
209+
quiet,
210+
},
211+
Mode::BuildAndTest
212+
if !self.ex.ignore_blacklist
213+
&& self.config.should_skip_tests(&krate) =>
214+
{
215+
TaskStep::BuildOnly {
173216
tc: tc.clone(),
174217
quiet,
175-
},
176-
Mode::BuildAndTest
177-
if !self.ex.ignore_blacklist
178-
&& self.config.should_skip_tests(&krate) =>
179-
{
180-
TaskStep::BuildOnly {
181-
tc: tc.clone(),
182-
quiet,
183-
}
184218
}
185-
Mode::BuildAndTest => TaskStep::BuildAndTest {
186-
tc: tc.clone(),
187-
quiet,
188-
},
189-
Mode::CheckOnly => TaskStep::CheckOnly {
190-
tc: tc.clone(),
191-
quiet,
192-
},
193-
Mode::Clippy => TaskStep::Clippy {
194-
tc: tc.clone(),
195-
quiet,
196-
},
197-
Mode::Rustdoc => TaskStep::Rustdoc {
198-
tc: tc.clone(),
199-
quiet,
200-
},
201-
Mode::UnstableFeatures => TaskStep::UnstableFeatures { tc: tc.clone() },
219+
}
220+
Mode::BuildAndTest => TaskStep::BuildAndTest {
221+
tc: tc.clone(),
222+
quiet,
202223
},
203-
});
204-
}
224+
Mode::CheckOnly => TaskStep::CheckOnly {
225+
tc: tc.clone(),
226+
quiet,
227+
},
228+
Mode::Clippy => TaskStep::Clippy {
229+
tc: tc.clone(),
230+
quiet,
231+
},
232+
Mode::Rustdoc => TaskStep::Rustdoc {
233+
tc: tc.clone(),
234+
quiet,
235+
},
236+
Mode::UnstableFeatures => TaskStep::UnstableFeatures { tc: tc.clone() },
237+
},
238+
};
205239

206-
let mut result = Ok(());
207-
let storage = LogStorage::from(self.config);
208-
for task in tasks {
209-
if result.is_ok() {
210-
result = self.run_task(&task, &storage);
211-
}
212-
if let Err((err, test_result)) = &result {
213-
if let Err(e) =
214-
task.mark_as_failed(self.ex, self.db, err, test_result, &storage)
215-
{
216-
crate::utils::report_failure(&e);
217-
}
240+
let storage = logs.clone();
241+
if let Err((err, test_result)) = &self.run_task(&task, &storage) {
242+
if let Err(e) =
243+
task.mark_as_failed(self.ex, self.db, err, test_result, &storage)
244+
{
245+
crate::utils::report_failure(&e);
218246
}
219247
}
220248
}

0 commit comments

Comments
 (0)