Restart invocation

[slinkydeveloper]

This is gonna be the command:

/// Restart an invocation.
///
/// This will restart the invocation, given its input is available.
#[derive(Debug, Clone, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct RestartInvocationRequest {
    pub invocation_id: InvocationId,

    // What to do if the invocation is still running.
    pub if_running: IfRunning,

    /// If set, it will override the configured completion_retention/journal_retention when the invocation was executed the first time.
    /// If none of the completion_retention/journal_retention are configured, and neither this previous_attempt_retention, then the previous attempt won't be retained at all.
    ///
    /// To retain the previous attempt, the new attempt will take the invocation id of the previous attempt (the one used to trigger this reset),
    /// and the old invocation id will take a new randomly generated invocation id.
    pub previous_attempt_retention: Option<Duration>,

    /// What to do in case the invocation was a Workflow run (workflow service and workflow handler type)
    pub apply_to_workflow_run: ApplyToWorkflowRun,
}

#[derive(Default, Debug, Clone, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum IfRunning {
    /// Kill the invocation, then restart it.
    #[default]
    Kill,
    /// Fail the Restart command if the invocation is still running
    Fail,
}

#[derive(Default, Debug, Clone, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum ApplyToWorkflowRun {
    Nothing,
    ClearOnlyPromises,
    ClearOnlyState,
    #[default]
    ClearAllPromisesAndState
}

[slinkydeveloper]

To retain previous invocation statuses and journals, we'll introduce a new key kind for both status and journal for the "archived invocations". When we bump the epoch on restart, we copy invocation status and journal into the archived key kind. Nothing changes for the "ongoing invocation", that is the latest invocation.

Example change to the invocation status table:

    fn get_invocation_status(
        &mut self,
        invocation_id: &InvocationId,
        /// If no epoch is provided, get the latest/current
        invocation_epoch: Option<InvocationEpoch>,
    ) -> impl Future<Output = Result<InvocationStatus>> + Send;

    /// Copy over the latest/current invocation into the archived invocation statuses
    fn archive_invocation_status(
        &mut self,
        invocation_id: &InvocationId,
        invocation_epoch: InvocationEpoch,
        status: &InvocationStatus,
    ) -> impl Future<Output = Result<()>> + Send;

    // This also deletes the archived statuses with the same invocation id
    fn delete_invocation_status(
        &mut self,
        invocation_id: &InvocationId,
    ) -> impl Future<Output = Result<()>> + Send;

    /// Deletes a specific invocation status by epoch
    fn delete_archived_invocation_status(
        &mut self,
        invocation_id: &InvocationId,
        invocation_epoch: InvocationEpoch,
    ) -> impl Future<Output = Result<()>> + Send;

   /// Returns also the archived invocation statuses, so user can browse them
    fn all_invocation_statuses(
        &self,
        range: RangeInclusive<PartitionKey>,
    ) -> Result<impl Stream<Item = Result<(InvocationId, InvocationStatus)>> + Send>;

The user will be able to correlate which "attempt" it is using invocation epochs, exposed in the logs and in SQL. The UI will be able to show the past attempts for a given invocation.

When attaching/getting output, you always operate on the "latest" attempt, past epochs are retained and exposed to the user only in the observability stack.