Hacktoberfest 2026: los issues que los mantenedores marcaron para octubre, abiertos y aptos para principiantes. Explorar issues de Hacktoberfest

`vp run`: an option to keep going after a task fails (today one failure kills unrelated running tasks and their results are lost)

Abierto
  • ¿Algo no está bien?
#822 0 comentarios 0 reacciones 0 asignados Ver en GitHub

Los mantenedores suelen responder en 1 día

Nadie ha tomado este issue todavía.

Evaluación

Dificultad
4/5
Tiempo estimado
3-5 días
Aptitud para principiantes
35/100
Tipo de issue
Nueva funcionalidad
Claridad
Bastante claro
Estado de actividad
Activo
Stack tecnológico
cli, rust
Área
cli, devtools

Línea de trabajo

Start in crates/vt/src/session/execute/scheduler.rs, where a failure cancels the shared token (around lines 229-231), and in cache_update.rs, where cancelled runs are skipped for caching (around lines 48-49). A --continue flag would need to stop that cancellation, skip only tasks that depend on a failure, and set a non-zero exit code at the end. Done means a fixture with independent failing and passing packages finishes the passing ones, caches them, and exits non-zero. The issue is a feature with a design choice (which continue modes to support), so confirm the scope with maintainers before starting.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

Summary

When a task fails, vp run cancels the whole run. Tasks that are running and do not depend on the failed task are killed, tasks not yet started never run, and none of them gets a cache entry. There is no option to change this.

This asks for one: keep running every task whose dependencies succeeded, skip only the tasks that depend on a failure, and exit non-zero at the end.

What happens today

A workspace of four packages with no dependencies between them. a fails after 2 s; b, c and d take 8 s.

// packages/a/package.json
{ "name": "a", "scripts": { "check": "node -e \"setTimeout(() => process.exit(1), 2000)\"" } }
// packages/b/package.json (c and d are the same)
{ "name": "b", "scripts": { "check": "node -e \"setTimeout(() => console.log(1), 8000)\"" } }

$ vp run --cache -r check
vp run: 0/4 cache hit (0%), 4 failed.

$ vp run --last-details
  [1] a#check ... ✗ (exit code: 1)
  [2] c#check ... ✗ (exit code: 137)
  [3] d#check ... ✗ (exit code: 137)
  [4] b#check ... ✗ (exit code: 137)

The run ends after about 2 s. b, c and d were healthy and independent of a. They are reported as failed, and the next run starts them from nothing. (vp v1.0.0, macOS.)

In the source this is unconditional. The scheduler cancels the shared token on any failure (scheduler.rs#L229-L231), and a run cancelled that way is not cached (cache_update.rs#L48-L49).

Why it matters
  • One failure per run. In a recursive test or lint over many packages, the first failure hides every other one. A change that breaks three packages takes three runs to fix, and in CI each run is a round trip.
  • A flake costs the whole run. One test that times out kills every suite still running. Their results are lost, so the retry re-executes work that was about to pass.
  • The killed tasks read as failures. They show exit code: 137 beside the real failure and the summary counts them as failed, so the reader has to work out which one was the cause.
  • The workaround is expensive. To get a result per package, a CI job has to start one vp run <package>#<task> process per package. Those processes then replay the same dependency tasks at the same time, and a cache hit restores a task's outputs over the existing files while another process is reading them. So the job also has to run the shared dependencies once up front and pass --ignore-depends-on to every process.
Prior art
Tool Option Its documentation
GNU Make -k, --keep-going "Keep going when some targets can't be made."
Turborepo turbo run --continue[=never|dependencies-successful|always] Default never. With dependencies-successful: "turbo will cancel dependent tasks. Tasks whose dependencies have succeeded will continue to run."
pnpm pnpm run --no-bail "Continue running the remaining matched scripts even if one of them fails. The command still exits with a non-zero exit code if any script failed."
Nx --nxBail "Stop command execution after the first failed task."
Cargo cargo test --no-fail-fast, cargo build --keep-going "Run all tests regardless of failure"; "Do not abort the build as soon as there is an error"
Proposal
vp run --continue [TASK_SPECIFIER]
  • A task that fails does not cancel the run.
  • A task whose dependencies all succeeded still runs, and its result is cached as in any other run.
  • A task that depends on a failed task, directly or through others, does not run. It is reported as skipped, naming the failure it waited on. This is Turborepo's dependencies-successful.
  • The run exits non-zero if any task failed, after every runnable task has finished.
  • Ctrl-C still cancels everything.

With the example above it would print:

$ vp run --cache --continue -r check
vp run: 0/4 cache hit (0%), 1 failed.

$ vp run --cache --continue -r check
vp run: 3/4 cache hit (75%), 1 failed.

A config key for the default would let a workspace choose it for CI. The flag alone is enough to start.

Non-goals
  • Changing the default.
  • Running the dependents of a failed task (Turborepo's always).
  • Retrying a failed task.
How we hit it

A monorepo of about 80 packages that runs vp run -r test in CI. One test timed out by 10 ms, and three healthy suites that were still running were killed with exit 137. None of the three stored a result, so the retry ran all four again, one of them with 1,282 tests. We now run one process per package to keep each verdict, at the cost described above.

Lenguaje dominante
Rust
Estrellas
473
Forks
44
Merge medio
1 d 19 min
PR fusionados (30 d)
55

Preparar el entorno

Abrir en Codespaces

Inicia el contenedor de desarrollo del proyecto en tu navegador, con tu propia cuenta de GitHub.

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de voidzero-dev/vite-task

Todos los issues de voidzero-dev/vite-task

Issues similares

Más issues de Rust

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.