Transaction.cs

using System;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Runtime.Threading;

namespace Waher.Runtime.Transactions
{
	/// <summary>
	/// Abstract base class for transactions.
	/// </summary>
	public abstract class Transaction : ITransaction
	{
		private readonly Guid id = Guid.NewGuid();
		private TransactionState state = TransactionState.Created;
		private MultiReadSingleWriteObject synchObject;
		private object tag;

		/// <summary>
		/// Abstract base class for transactions.
		/// </summary>
		public Transaction()
		{
			this.synchObject = new MultiReadSingleWriteObject(this);
		}

		/// <summary>
		/// Abstract base class for transactions.
		/// </summary>
		/// <param name="Id">ID of transaction.</param>
		public Transaction(Guid Id)
			: this()
		{
			this.id = Id;
		}

		/// <summary>
		/// ID of transaction
		/// </summary>
		public Guid Id => this.id;

		/// <summary>
		/// Transaction state.
		/// </summary>
		public TransactionState State => this.state;

		/// <summary>
		/// Caller can use this property to tag the transaction with information.
		/// </summary>
		public object Tag
		{
			get => this.tag;
			set => this.tag = value;
		}

		/// <summary>
		/// Disposes of the transaction.
		/// </summary>
		public void Dispose()
		{
			this.synchObject?.Dispose();
			this.synchObject = null;
		}

		/// <summary>
		/// Sets a new state for the transaction object.
		/// </summary>
		/// <param name="NewState"></param>
		private Task SetStateLocked(TransactionState NewState)
		{
			if (this.state != NewState)
			{
				this.state = NewState;
				return this.Raise(this.StateChanged);
			}
			else
				return Task.CompletedTask;
		}

		/// <summary>
		/// Raises an event.
		/// </summary>
		/// <param name="EventHandler">Event handler for event.</param>
		protected async Task Raise(EventHandlerAsync<TransactionEventArgs> EventHandler)
		{
			if (!(EventHandler is null))
				await EventHandler.Raise(this, new TransactionEventArgs(this));
		}

		/// <summary>
		/// Event raised when the transaction state has changed.
		/// </summary>
		public event EventHandlerAsync<TransactionEventArgs> StateChanged;

		/// <summary>
		/// Prepares the transaction for execution. This step can be used for validation and authorization of the transaction.
		/// It must not change the underlying state.
		/// </summary>
		/// <returns>If the preparation phase is OK or not.</returns>
		/// <exception cref="TransactionException">If the transaction not in the <see cref="TransactionState.Created"/> state.</exception>
		public async Task<bool> Prepare()
		{
			await this.synchObject.BeginWrite();
			try
			{
				this.AssertState(TransactionState.Created);

				await this.SetStateLocked(TransactionState.Preparing);
				try
				{
					if (await this.DoPrepare())
					{
						await this.SetStateLocked(TransactionState.Prepared);

						try
						{
							await this.AfterPrepare();
						}
						catch (Exception ex)
						{
							Log.Exception(ex);
						}
						return true;
					}
					else
					{
						await this.SetStateLocked(TransactionState.Error);
						return false;
					}
				}
				catch (Exception ex)
				{
					Log.Exception(ex);
					await this.SetStateLocked(TransactionState.Error);
					return false;
				}
			}
			finally
			{
				await this.synchObject.EndWrite();
			}
		}

		/// <summary>
		/// Performs actual preparation.
		/// </summary>
		/// <returns>If the preparation phase is OK or not.</returns>
		protected abstract Task<bool> DoPrepare();

		/// <summary>
		/// Is called after preparation has completed.
		/// </summary>
		protected virtual Task AfterPrepare()
		{
			return Task.CompletedTask;
		}

		private void AssertState(params TransactionState[] States)
		{
			foreach (TransactionState State in States)
			{
				if (this.state == State)
					return;

			}

			throw new TransactionException(this, "Unexpected state: " + this.state.ToString());
		}

		/// <summary>
		/// Executes the transaction.
		/// </summary>
		/// <returns>If the transaction was executed correctly or not.</returns>
		/// <exception cref="TransactionException">If the transaction not in the <see cref="TransactionState.Prepared"/> state.</exception>
		public async Task<bool> Execute()
		{
			await this.synchObject.BeginWrite();
			try
			{
				this.AssertState(TransactionState.Prepared);

				await this.SetStateLocked(TransactionState.Executing);
				try
				{
					if (await this.DoExecute())
					{
						await this.SetStateLocked(TransactionState.Executed);

						try
						{
							await this.AfterExecute();
						}
						catch (Exception ex)
						{
							Log.Exception(ex);
						}
						return true;
					}
					else
					{
						await this.SetStateLocked(TransactionState.Error);
						return false;
					}
				}
				catch (Exception ex)
				{
					Log.Exception(ex);
					await this.SetStateLocked(TransactionState.Error);
					return false;
				}
			}
			finally
			{
				await this.synchObject.EndWrite();
			}
		}

		/// <summary>
		/// Performs actual execution.
		/// </summary>
		/// <returns>If the transaction was executed correctly or not.</returns>
		protected abstract Task<bool> DoExecute();

		/// <summary>
		/// Is called after execution has completed.
		/// </summary>
		protected virtual Task AfterExecute()
		{
			return Task.CompletedTask;
		}

		/// <summary>
		/// Commits any changes made during the execution phase.
		/// </summary>
		/// <returns>If the transaction was successfully committed.</returns>
		/// <exception cref="TransactionException">If the transaction not in the <see cref="TransactionState.Executed"/> state.</exception>
		public async Task<bool> Commit()
		{
			await this.synchObject.BeginWrite();
			try
			{
				this.AssertState(TransactionState.Executed);

				await this.SetStateLocked(TransactionState.Committing);
				try
				{
					if (await this.DoCommit())
					{
						await this.SetStateLocked(TransactionState.Committed);

						try
						{
							await this.AfterCommit();
						}
						catch (Exception ex)
						{
							Log.Exception(ex);
						}
						return true;
					}
					else
					{
						await this.SetStateLocked(TransactionState.Error);
						return false;
					}
				}
				catch (Exception ex)
				{
					Log.Exception(ex);
					await this.SetStateLocked(TransactionState.Error);
					return false;
				}
			}
			finally
			{
				await this.synchObject.EndWrite();
			}
		}

		/// <summary>
		/// Performs actual commit.
		/// </summary>
		/// <returns>If the transaction was successfully committed.</returns>
		protected abstract Task<bool> DoCommit();

		/// <summary>
		/// Is called after preparation has completed.
		/// </summary>
		protected virtual Task AfterCommit()
		{
			return Task.CompletedTask;
		}

		/// <summary>
		/// Rolls back any changes made during the execution phase.
		/// </summary>
		/// <returns>If the transaction was successfully rolled back.</returns>
		/// <exception cref="TransactionException">If the transaction not in the <see cref="TransactionState.Executed"/> 
		/// or <see cref="TransactionState.Error"/> states.</exception>
		public async Task<bool> Rollback()
		{
			await this.synchObject.BeginWrite();
			try
			{
				this.AssertState(TransactionState.Executed, TransactionState.Error);

				await this.SetStateLocked(TransactionState.RollingBack);
				try
				{
					if (await this.DoRollback())
					{
						await this.SetStateLocked(TransactionState.RolledBack);

						try
						{
							await this.AfterRollback();
						}
						catch (Exception ex)
						{
							Log.Exception(ex);
						}
						return true;
					}
					else
					{
						await this.SetStateLocked(TransactionState.Error);
						return false;
					}
				}
				catch (Exception ex)
				{
					Log.Exception(ex);
					await this.SetStateLocked(TransactionState.Error);
					return false;
				}
			}
			finally
			{
				await this.synchObject.EndWrite();
			}
		}

		/// <summary>
		/// Performs actual rollback.
		/// </summary>
		/// <returns>If the transaction was successfully rolled back.</returns>
		protected abstract Task<bool> DoRollback();

		/// <summary>
		/// Is called after preparation has completed.
		/// </summary>
		protected virtual Task AfterRollback()
		{
			return Task.CompletedTask;
		}

		/// <summary>
		/// Calls <paramref name="Action"/> when the transaction is idle.
		/// </summary>
		/// <param name="Action">Callback method.</param>
		public async Task WhenIdle(Func<Task> Action)
		{
			await this.synchObject.BeginWrite();
			try
			{
				await Action();
			}
			finally
			{
				await this.synchObject.EndWrite();
			}
		}

		/// <summary>
		/// Aborts the transaction.
		/// </summary>
		public async Task Abort()
		{
			await this.synchObject.BeginWrite();
			try
			{
				switch (this.state)
				{
					case TransactionState.Created:
					case TransactionState.Preparing:
					case TransactionState.Prepared:
						break;

					case TransactionState.Executing:
					case TransactionState.Executed:
					case TransactionState.Error:
						await this.SetStateLocked(TransactionState.RollingBack);
						try
						{
							await this.DoRollback();
							await this.SetStateLocked(TransactionState.RolledBack);

							try
							{
								await this.AfterRollback();
							}
							catch (Exception ex)
							{
								Log.Exception(ex);
							}
						}
						catch (Exception ex)
						{
							Log.Exception(ex);
							await this.SetStateLocked(TransactionState.Error);
						}
						break;

					case TransactionState.Committing:
					case TransactionState.Committed:
						break;

					case TransactionState.RollingBack:
					case TransactionState.RolledBack:
						break;
				}
			}
			finally
			{
				await this.synchObject.EndWrite();
			}
		}
	}
}