Kestra: Restarting Killed Executions Made Easy

Hey guys! Let's dive into a common hiccup many of us have encountered when working with Kestra: dealing with killed executions. You know the drill – you're running a bunch of tasks, and suddenly, one or more get unceremoniously KILLED. What do you do next? Well, in Kestra, the ability to restart these killed executions is something we're actively refining to make your life way easier. We've been looking at the Kestra codebase, and there's a bit of a disconnect in how restarts are handled, especially for those KILLED states. This article is all about shedding light on that, explaining the current situation, and what the future holds for a smoother, more intuitive restarting experience. We want to ensure that when an execution is KILLED, you have a clear and coherent path to get it back on track without any confusion. Let's explore this together!

Understanding the Current State of KILLED Executions in Kestra

So, let's get real for a sec, guys. When an execution in Kestra gets into that KILLED state, it can be a bit of a head-scratcher, especially when you're looking to restart it. Currently, the way Kestra handles restarts for KILLED executions isn't as straightforward as we'd like. If you're dealing with bulk actions, the system's logic is primarily geared towards restarting only those executions that have failed. This means that if an execution was explicitly KILLED, it might not be picked up by the bulk restart mechanism. You can actually see this logic laid out in the Kestra codebase, specifically in the ExecutionController.java file, where it's focused on the only failed condition. This is a crucial point because it highlights a gap: the system isn't inherently designed to treat a KILLED execution as a candidate for a simple restart via bulk actions. This can lead to situations where you might expect a bulk restart to encompass all non-successful executions, only to find that KILLED ones are left behind. It’s not ideal, and we get it. Furthermore, when you navigate to an individual execution page, you might also notice that the trusty restart button seems to vanish for KILLED executions. This absence reinforces the idea that the system, as it stands, has some reservations or limitations when it comes to directly restarting a KILLED task. This isn't a bug, per se, but rather a design choice that's being re-evaluated. The underlying reason for this distinction often comes down to the inherent difference between a task that failed on its own and one that was intentionally terminated. A failed execution might have encountered an error that could be resolved by simply re-running the same logic. A killed execution, however, could have been terminated for a variety of reasons, some of which might require a different approach than a direct restart. But honestly, who wants that extra complexity when you just want to get back to work? We believe that in most scenarios, a KILLED execution should be restartable, and we're working on making that a reality. This current state, while understandable from a strict technical standpoint, can be frustrating for users who just want a consistent and predictable workflow. We're all about making Kestra intuitive, and this is an area where we see definite room for improvement. So, for now, be aware that the system differentiates, and direct restarts for KILLED states might require a little extra attention or a different path.

The Technical Details: Where the Logic Stands

Alright, let's roll up our sleeves and get a bit nerdy, shall we? Understanding why KILLED executions aren't easily restartable involves digging into the Kestra codebase. As mentioned, the logic for bulk actions, specifically in ExecutionController.java, has a condition that only allows restarts for failed executions. This is a key differentiator. However, if you trace the real execution flow and the underlying services, you'll find the more granular logic in ExecutionService.java. This service is where the heart of execution management lies, and it's here that we see how Kestra determines what actions are permissible. The issue isn't that Kestra can't technically restart a KILLED execution, but rather that the current implementation prioritizes certain states over others for automated or bulk operations. The goal is to have a single, unified logic for determining restartability across the entire Kestra ecosystem – from the backend services all the way to the frontend user interface. Right now, there are effectively two (or more) places where this logic is being interpreted, leading to the inconsistencies we're observing. For instance, the frontend component, Restart.vue, also has its own conditional checks for when a restart button should be displayed or be active. This frontend logic might be in sync with some of the backend conditions, but not necessarily all of them, especially when it comes to the nuances of a KILLED state versus a failed state. The ideal scenario, which is what the Kestra team is striving for, is to have a definitive canBeRestarted property or method associated with an execution object. This property would act as the single source of truth. Whether you're looking at bulk actions, individual execution details, or interacting with the UI, Kestra would query this canBeRestarted flag. If it returns true, then the restart functionality – whether it's a button on the UI or an option in a bulk action menu – would be enabled. This approach eliminates the need for disparate logic scattered across different parts of the application. It centralizes the decision-making process, making the system more robust, easier to maintain, and, most importantly, more predictable for you, the user. So, while the current implementation has separate checks, the future direction is clear: one authoritative source for restartability. We want to ensure that the decision to restart is based on a clear, consistent rule, not on where you happen to be interacting with Kestra.

The Path Forward: Towards a Coherent Restart Experience

We hear you, guys, and we're committed to making the Kestra experience as seamless as possible. The inconsistencies we've observed regarding the restartability of KILLED executions are not going unnoticed, and there's a clear plan to address them. The core of this improvement lies in establishing a single, authoritative logic for determining whether an execution can be restarted. This means moving away from having separate checks in the backend controllers, services, and frontend components. Instead, we aim to introduce a concept like a canBeRestarted flag directly associated with each execution. This flag would be determined by a set of well-defined rules, ensuring that Kestra knows precisely whether a given execution, regardless of its current state (be it KILLED, failed, or even something else), is a candidate for a restart. This unified logic will be the linchpin that connects all parts of Kestra. When you trigger a bulk action, Kestra will consult this canBeRestarted flag for each relevant execution. Similarly, when you view an individual execution's page, the presence and activeness of the restart button will be dictated by this same flag. The frontend component (Restart.vue) will rely on this central logic, ensuring consistency across the board. This is a significant step towards making Kestra more intuitive and user-friendly. We want to eliminate the guesswork and the