Gaev.DurableTask is tiny library to build durable task, saga, process manager using the async/await capabilities. Main idea is to fit saga, process manager in one async method. Inspired by Azure Durable Task Framework.

Just imagine you can write regular code using the async/await capabilities which can last for long time, say 1 week or year. Moreover, if an application crashes the durable task will resume execution exactly from where it left.

A durable task must have some storage for storing current state in order to resume execution after restart/crash. There is MS SQL and file system based storage provider. However, you can implement your own provider, just implement IProcessStorage.

To estimate amount of used memory, a simple durable task was hosted in console application. As a result one instance of the durable task will use 4.3Kb in 32bit or 9KB in 64bit, so 250 000 instances will occupy 1Gb of 32bit console app.

Caveat: An exception type is limited due to serialization/deserialization. Any exception will be wrapped in ProcessException. So ProcessException is only one type allowed to catch in a durable task (see Rollback logic example below).

Let's look closer to the durable task. It is easier to show an example:

Saga, process manager complete example

async Task DurableTask(string id, string email = null)
{
	using (var proc = _host.Spawn(id))
	{
		// Save email not to lose it if durable task resumes
		email = await proc.Get(email, "SaveEmail");
		// Register the user
		var userId = await proc.Do(() => _service.RegisterUser(email), "RegisterUser");
		// Generate a secret for email verification
		var secret = await proc.Get(Guid.NewGuid(), "secret");
		// Send email to the user with the secret to verify
		await proc.Do(() => _service.VerifyEmail(email, secret), "VerifyEmail");
		// Wait when user receive verification email and send the secret here, it can take couple of days
		await proc.Do(() => _service.WaitForEmailVerification(secret), "WaitForEmailVerification");
		// Activate the user in the system
		await proc.Do(() => _service.ActivateUser(userId), "ActivateUser");
	}
}

Schedule complete example

async Task DurableTask(string id, string email = null)
{
	using (var proc = _host.Spawn(id))
	{
		// Save email not to lose it if durable task resumes
		email = await proc.Get(email, "SaveEmail");
		await proc.Do(() => _smtp.Send(email, "Welcome!"), "Welcome");
		// Wait 1 month
		await proc.Delay(TimeSpan.FromDays(30), "Wait1m");
		await proc.Do(() => _smtp.Send(email, "Your 1st month with us. Congrats!"), "CongratsMonth");
		// Wait 11 months
		await proc.Delay(TimeSpan.FromDays(365 - 30), "Wait1y");
		await proc.Do(() => _smtp.Send(email, "Your 1st year with us. Congrats!"), "CongratsYear");
	}
}

Rollback logic complete example

async Task DurableTask(string id, string srcAccount = null, string destAccount = null, decimal amount = 0)
{
	using (var proc = _host.Spawn(id))
	{
		// Save values not to lose it if durable task resumes
		srcAccount = await proc.Get(srcAccount, "SaveSrcAccount");
		destAccount = await proc.Get(destAccount, "SaveDestAccount");
		amount = await proc.Get(amount, "SaveAmount");
		var srcTranId = Guid.Empty;
		var destTranId = Guid.Empty;
		try
		{
			// Start transferring the money
			srcTranId = await proc.Do(() => _service.StartTransfer(srcAccount, -amount), "StartTransfer1");
			destTranId = await proc.Do(() => _service.StartTransfer(destAccount, +amount), "StartTransfer2");
			// Complete transferring the money
			await proc.Do(() => _service.CompleteTransfer(srcAccount, srcTranId), "CompleteTransfer1");
			await proc.Do(() => _service.CompleteTransfer(destAccount, destTranId), "CompleteTransfer2");
		}
		catch (ProcessException ex) when (ex.Type == nameof(TransferFailedException))
		{
			// Rollback logic
			if (srcTranId != Guid.Empty)
				await proc.Do(() => _service.RollbackTransfer(srcAccount, srcTranId), "RollbackTransfer1");
			if (destTranId != Guid.Empty)
				await proc.Do(() => _service.RollbackTransfer(destAccount, destTranId), "RollbackTransfer2");
			throw;
		}
	}
}

Sending a message to the durable task complete example

async Task DurableTask(string processId, string companyId = null, string creditCard = null)
{
	using (var proc = _host.Spawn(processId).As<CreditCardProcess>())
	{
		companyId = await proc.Get(companyId, "1");
		creditCard = await proc.Get(creditCard, "2");
		Console.WriteLine($"CreditCardFlow is up for companyId={companyId} creditCard={creditCard}");
		var email = await proc.Do(() => GetEmail(companyId), "3");
		await proc.Do(() => SendEmail(email, $"{creditCard} was assigned to you"), "4");
		var onCheckTime = proc.Delay(TimeSpan.FromMinutes(5), "5");
		var onFirstTransaction = proc.Do(() => proc.OnTransactionAppeared(), "6");
		var onDeleted = proc.Do(() => proc.OnCreditCardDeleted(), "7");
		Task.Run(async () =>
		{
			await onCheckTime;
			if (onDeleted.IsCompleted) return;
			if (!onFirstTransaction.IsCompleted)
				await proc.Do(() => SendEmail(email, $"{creditCard} is inactive long time"), "8");
		});
		Task.Run(async () =>
		{
			await onFirstTransaction;
			if (onDeleted.IsCompleted) return;
			await proc.Do(() => SendEmail(email, $"{creditCard} received 1st transaction"), "9");
		});

		await onDeleted;
		await proc.Do(() => SendEmail(email, $"{creditCard} was deleted"), "10");
	}
}
static void Main(string[] args)
{
	...
	var procId = creditCardFlow.Start("1111-1111-1111-1111", "user1@gmail.com");
	host.Get(procId).As<CreditCardProcess>()?.RaiseOnTransactionAppeared();
	host.Get(procId).As<CreditCardProcess>()?.RaiseOnCreditCardDeleted();
	...
}