We use cookies

Durable Sleep

Durable sleep is a feature of durable tasks which allow tasks to pause execution for a specified amount of time. Instead of a regular sleep call in your task, durable sleep is guaranteed to only sleep for the specified amount of time after the first time it was called.

For example, say you’d like to send a notification to a user after 24 hours. With a regular sleep, if the task is interrupted after 23 hours, it will restart and call sleep for 24 hours again. This means that the task will sleep for 47 hours in total, which is not what you want. With durable sleep, the task will respect the original sleep duration on restart — that is, if the task calls ctx.aio_sleep_for for 24 hours and is interrupted after 23 hours, it will only sleep for 1 more hour on restart.

Using durable sleep

Durable sleep can be used by calling the SleepFor method on the DurableContext object. This method takes a duration as an argument and will sleep for that duration.

@hatchet.durable_task(name="DurableSleepTask")
async def durable_sleep_task(input: EmptyModel, ctx: DurableContext) -> None:
    res = await ctx.aio_sleep_for(timedelta(seconds=5))

    print("got result", res)

durableSleep.durableTask({
  name: 'durable-sleep',
  executionTimeout: '10m',
  fn: async (_, ctx) => {
    console.log('sleeping for 5s');
    const sleepRes = await ctx.sleepFor('5s');
    console.log('done sleeping for 5s', sleepRes);

    return {
      Value: 'done',
    };
  },
});

simple := factory.NewDurableTask(
	create.StandaloneTask{
		Name: "durable-sleep",
	},
	func(ctx worker.DurableHatchetContext, input DurableSleepInput) (*DurableSleepOutput, error) {
		_, err := ctx.SleepFor(10 * time.Second)

		if err != nil {
			return nil, err
		}

		return &DurableSleepOutput{
			TransformedMessage: strings.ToLower(input.Message),
		}, nil
	},
	hatchet,
)