Pause and resume¶

using Amazon.Lambda.Core;
using Amazon.Lambda.DurableExecution;
using Microsoft.Extensions.Logging;

public class WaitVsSleepExample
{
    public Task<DurableExecutionInvocationOutput> Handler(
        DurableExecutionInvocationInput input, ILambdaContext context)
        => DurableFunction.WrapAsync<CoolOffEvent, string>(Workflow, input, context);

    private async Task<string> Workflow(CoolOffEvent input, IDurableContext ctx)
    {
        // Do NOT use Thread.Sleep or Task.Delay to pause a durable function.
        // They keep the invocation running (billing compute) and reset to zero
        // on replay:
        //     await Task.Delay(TimeSpan.FromHours(24)); // wrong

        // Use WaitAsync instead: the SDK suspends the execution, checkpoints the
        // wait, and re-invokes the handler when it elapses. No compute charge
        // while suspended. Name every wait so it reads clearly in logs and tests.
        await ctx.WaitAsync(TimeSpan.FromHours(24), name: "cool-off");

        ctx.Logger.LogInformation("Cool-off complete for {OrderId}", input.OrderId);
        return "done";
    }
}

public record CoolOffEvent(string OrderId);

using Amazon.Lambda.Core;
using Amazon.Lambda.DurableExecution;

public class CallbackTimeoutExample
{
    public Task<DurableExecutionInvocationOutput> Handler(
        DurableExecutionInvocationInput input, ILambdaContext context)
        => DurableFunction.WrapAsync<OrderEvent, Approval>(Workflow, input, context);

    private async Task<Approval> Workflow(OrderEvent input, IDurableContext ctx)
    {
        // Always set a timeout on a callback. Without one the execution waits up
        // to the execution timeout, holding the resource slot until an operator
        // intervenes.
        var config = new WaitForCallbackConfig
        {
            Timeout = TimeSpan.FromHours(24),
        };

        // The submitter hands the service-allocated callbackId to the external
        // system. The external system later calls the SDK's callback success or
        // failure endpoint with that id.
        Approval outcome = await ctx.WaitForCallbackAsync<Approval>(
            async (callbackId, _, ct) =>
                await ApprovalsService.RequestAsync(input.OrderId, callbackId, ct),
            name: "wait-for-approval",
            config: config);

        return outcome;
    }
}

public record OrderEvent(string OrderId);
public record Approval(bool Approved);

public static class ApprovalsService
{
    public static Task RequestAsync(string orderId, string callbackId, CancellationToken ct)
        => Task.CompletedTask;
}

using Amazon.Lambda.Core;
using Amazon.Lambda.DurableExecution;

public class HeartbeatTimeoutExample
{
    public Task<DurableExecutionInvocationOutput> Handler(
        DurableExecutionInvocationInput input, ILambdaContext context)
        => DurableFunction.WrapAsync<JobEvent, JobResult>(Workflow, input, context);

    private async Task<JobResult> Workflow(JobEvent input, IDurableContext ctx)
    {
        // HeartbeatTimeout fails the callback if the external worker stops
        // checking in, even before the overall Timeout elapses. Set it
        // comfortably longer than the expected interval between heartbeats but
        // shorter than the overall operation timeout.
        var config = new WaitForCallbackConfig
        {
            Timeout = TimeSpan.FromHours(24),
            HeartbeatTimeout = TimeSpan.FromMinutes(10),
        };

        // The external system must call the SDK's heartbeat endpoint periodically
        // while the work is in progress, and the success/failure endpoint when done.
        JobResult outcome = await ctx.WaitForCallbackAsync<JobResult>(
            async (callbackId, _, ct) =>
                await JobService.StartAsync(input.JobId, callbackId, ct),
            name: "long-running-job",
            config: config);

        return outcome;
    }
}

public record JobEvent(string JobId);
public record JobResult(string Status);

public static class JobService
{
    public static Task StartAsync(string jobId, string callbackId, CancellationToken ct)
        => Task.CompletedTask;
}

using Amazon.Lambda.Core;
using Amazon.Lambda.DurableExecution;

public class WaitForConditionExample
{
    public Task<DurableExecutionInvocationOutput> Handler(
        DurableExecutionInvocationInput input, ILambdaContext context)
        => DurableFunction.WrapAsync<JobEvent, JobState>(Workflow, input, context);

    private async Task<JobState> Workflow(JobEvent input, IDurableContext ctx)
    {
        // Use an exponential-backoff wait strategy so an unresponsive downstream
        // system does not create a retry storm. The isDone predicate stops
        // polling once the state satisfies the condition.
        var strategy = WaitStrategy.Exponential<JobState>(
            maxAttempts: 60,
            initialDelay: TimeSpan.FromSeconds(5),
            maxDelay: TimeSpan.FromMinutes(1),
            backoffRate: 2.0,
            jitter: JitterStrategy.Full,
            isDone: state => state.Status == "completed");

        var config = new WaitForConditionConfig<JobState>
        {
            InitialState = new JobState(input.JobId, "pending"),
            WaitStrategy = strategy,
        };

        // The SDK runs the check on each poll, applies the wait strategy between
        // polls (suspending the execution — no compute charge), and resumes when
        // the strategy stops. Each poll is a step.
        JobState finalState = await ctx.WaitForConditionAsync<JobState>(
            async (state, _, ct) =>
            {
                string status = await JobService.GetStatusAsync(state.JobId, ct);
                return state with { Status = status };
            },
            config,
            name: "wait-for-job");

        return finalState;
    }
}

public record JobEvent(string JobId);
public record JobState(string JobId, string Status);

public static class JobService
{
    public static Task<string> GetStatusAsync(string jobId, CancellationToken ct)
        => Task.FromResult("completed");
}