Transactions.cs

using System;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Runtime.Cache;
using Waher.Runtime.Inventory;
 
namespace Waher.Runtime.Transactions
{
    public class Transactions<T> : ITransactions
        where T : ITransaction
    {
        private readonly Cache<Guid, T> transactions;
 
        public Transactions(TimeSpan TransactionTimeout)
        {
            this.transactions = new Cache<Guid, T>(int.MaxValue, TransactionTimeout, TransactionTimeout, true);
            this.transactions.Removed += this.Transactions_Removed;
 
            TransactionModule.Register(this);
        }
 
        private async Task Transactions_Removed(object Sender, CacheItemEventArgs<Guid, T> e)
        {
            if (e.Reason != RemovedReason.Manual)
            {
                try
                {
                    T Transaction = e.Value;
 
                    if (Transaction.State != TransactionState.Committed &&
                        Transaction.State != TransactionState.RolledBack)
                    {
                        await Transaction.Abort();
                    }
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            }
        }
 
        public void Dispose()
        {
            TransactionModule.Unregister(this);
        
            this.transactions.Removed -= this.Transactions_Removed;
            this.transactions.Clear();
            this.transactions.Dispose();
        }
 
        public T2 CreateNew<T2>(params object[] Arguments)
            where T2 : T
        {
            T2 Transaction = Types.Instantiate<T2>(false, Arguments);
            this.transactions.Add(Transaction.Id, Transaction);
            return Transaction;
        }
 
        public void Register(T Transaction)
        {
            this.transactions.Add(Transaction.Id, Transaction);
        }
 
        public bool Unregister(Guid Id)
        {
            return this.transactions.Remove(Id);
        }
 
        public bool Unregister(T Transaction)
        {
            if (this.transactions.TryGetValue(Transaction.Id, out T Transaction2) &&
                Transaction2.Equals(Transaction))
            {
                return this.transactions.Remove(Transaction.Id);
            }
            else
                return false;
        }
 
        public bool TryGetTransaction(Guid Id, out T Transaction)
        {
            return this.transactions.TryGetValue(Id, out Transaction);
        }
 
        public async Task<bool> Prepare(Guid TransactionId)
        {
            try
            {
                if (!this.transactions.TryGetValue(TransactionId, out T Transaction))
                    return false;
 
                return await Transaction.Prepare();
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                return false;
            }
        }
 
        public async Task<bool> Execute(Guid TransactionId)
        {
            try
            {
                if (!this.transactions.TryGetValue(TransactionId, out T Transaction))
                    return false;
 
                return await Transaction.Execute();
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                return false;
            }
        }
 
        public async Task<bool> Commit(Guid TransactionId)
        {
            try
            {
                if (!this.transactions.TryGetValue(TransactionId, out T Transaction))
                    return false;
 
                if (!await Transaction.Commit())
                    return false;
 
                this.transactions.Remove(TransactionId);
 
                return true;
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                return false;
            }
        }
 
        public async Task<bool> Rollback(Guid TransactionId)
        {
            try
            {
                if (!this.transactions.TryGetValue(TransactionId, out T Transaction))
                    return false;
 
                if (!await Transaction.Rollback())
                    return false;
 
                this.transactions.Remove(TransactionId);
 
                return true;
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                return false;
            }
        }
 
        public Task<ITransaction[]> GetTransactions()
        {
            T[] Transactions = this.transactions.GetValues();
            int i, c = Transactions.Length;
            ITransaction[] Result = new ITransaction[c];
 
            for (i = 0; i < c; i++)
                Result[i] = (ITransaction)Transactions[i];
 
            return Task.FromResult<ITransaction[]>(Result);
        }
    }
}